diff -Nru btrfs-tools-0.19+20111121/bcp btrfs-tools-0.19+20120328/bcp
--- btrfs-tools-0.19+20111121/bcp	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/bcp	1970-01-01 00:00:00.000000000 +0000
@@ -1,159 +0,0 @@
-#!/usr/bin/env python
-# Copyright (C) 2007 Oracle.  All rights reserved.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public
-# License v2 as published by the Free Software Foundation.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public
-# License along with this program; if not, write to the
-# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-# Boston, MA 021110-1307, USA.
-#
-import sys, os, stat, fcntl
-from optparse import OptionParser
-
-def copylink(srcname, dst, filename, statinfo, force_name):
-    dstname = os.path.join(dst, force_name or filename)
-    if not os.path.exists(dstname):
-        link_target = os.readlink(srcname)
-        os.symlink(link_target, dstname)
-
-def copydev(srcname, dst, filename, statinfo, force_name):
-    devbits = statinfo.st_mode & (stat.S_IFBLK | stat.S_IFCHR)
-    mode = stat.S_IMODE(statinfo.st_mode) | devbits
-    dstname = os.path.join(dst, force_name or filename)
-    if not os.path.exists(dstname):
-        os.mknod(dstname, mode, statinfo.st_rdev)
-
-def copyfile(srcname, dst, filename, statinfo, force_name):
-    written = 0
-    dstname = os.path.join(dst, force_name or filename)
-
-    st_mode = statinfo.st_mode
-    if stat.S_ISLNK(st_mode):
-        copylink(srcname, dst, part, statinfo, None)
-        return
-    elif stat.S_ISBLK(st_mode) or stat.S_ISCHR(st_mode):
-        copydev(srcname, dst, part, statinfo, None)
-        return
-    elif not stat.S_ISREG(st_mode):
-        return
-
-    try:
-        os.unlink(dstname)
-    except:
-        pass
-
-    if options.link:
-        os.link(srcname, dstname)
-        return
-
-    dstf = file(dstname, 'w')
-    srcf = file(srcname, 'r')
-
-    ret = 1
-
-    try:
-        if not options.copy:
-            ret = fcntl.ioctl(dstf.fileno(), 1074041865, srcf.fileno())
-    except:
-        pass
-
-    if ret != 0:
-        while True:
-            buf = srcf.read(256 * 1024)
-            if not buf:
-                break
-            written += len(buf)
-            dstf.write(buf)
-
-    os.chmod(dstname, stat.S_IMODE(statinfo.st_mode))
-    os.chown(dstname, statinfo.st_uid, statinfo.st_gid)
-
-
-usage = "usage: %prog [options]"
-parser = OptionParser(usage=usage)
-parser.add_option("-l", "--link", help="Create hard links", default=False,
-                  action="store_true")
-parser.add_option("-c", "--copy", help="Copy file bytes (don't cow)",
-                  default=False, action="store_true")
-
-(options,args) = parser.parse_args()
-
-if len(args) < 2:
-    sys.stderr.write("source or destination not specified\n")
-    sys.exit(1)
-
-if options.link and options.copy:
-    sys.stderr.write("Both -l and -c specified, using copy mode\n")
-    options.link = False
-
-
-total_args = len(args)
-src_args = total_args - 1
-orig_dst = args[-1]
-
-if src_args > 1:
-    if not os.path.exists(orig_dst):
-        os.makedirs(orig_dst)
-    if not os.path.isdir(orig_dst):
-        sys.stderr.write("Destination %s is not a directory\n" % orig_dst)
-        exit(1)
-
-for srci in xrange(0, src_args):
-    src = args[srci]
-    if os.path.isfile(src):
-        statinfo = os.lstat(src)
-        force_name = None
-        if src_args == 1:
-            if not os.path.isdir(orig_dst):
-                force_name = os.path.basename(orig_dst)
-                orig_dst = os.path.dirname(orig_dst) or '.'
-        copyfile(src, orig_dst, os.path.basename(src), statinfo, force_name)
-        continue
-
-    if src_args > 1 or os.path.exists(orig_dst):
-        dst = os.path.join(orig_dst, os.path.basename(src))
-    else:
-        dst = orig_dst
-
-    if not os.path.exists(dst):
-        os.makedirs(dst)
-        statinfo = os.stat(src)
-        os.chmod(dst, stat.S_IMODE(statinfo.st_mode))
-        os.chown(dst, statinfo.st_uid, statinfo.st_gid)
-        
-    iter = os.walk(src, topdown=True)
-
-    for (dirpath, dirnames, filenames) in iter:
-        for x in dirnames:
-            srcname = os.path.join(dirpath, x)
-            statinfo = os.lstat(srcname)
-
-            part = os.path.relpath(srcname, src)
-
-            if stat.S_ISLNK(statinfo.st_mode):
-                copylink(srcname, dst, part, statinfo, None)
-                continue
-
-            dst_dir = os.path.join(dst, part)
-            if not os.path.exists(dst_dir):
-                os.makedirs(dst_dir)
-
-            os.chmod(dst_dir, stat.S_IMODE(statinfo.st_mode))
-            os.chown(dst_dir, statinfo.st_uid, statinfo.st_gid)
-
-        for f in filenames:
-            srcname = os.path.join(dirpath, f)
-            part = os.path.relpath(srcname, src)
-
-            statinfo = os.lstat(srcname)
-            copyfile(srcname, dst, part, statinfo, None)
-
-
diff -Nru btrfs-tools-0.19+20111121/btrfs.c btrfs-tools-0.19+20120328/btrfs.c
--- btrfs-tools-0.19+20111121/btrfs.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/btrfs.c	2012-05-05 18:22:58.000000000 +0000
@@ -19,444 +19,258 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "kerncompat.h"
-#include "btrfs_cmds.h"
+#include "commands.h"
 #include "version.h"
 
-#define BASIC_HELP 0
-#define ADVANCED_HELP 1
-
-typedef int (*CommandFunction)(int argc, char **argv);
-
-struct Command {
-	CommandFunction	func;	/* function which implements the command */
-	int	nargs;		/* if == 999, any number of arguments
-				   if >= 0, number of arguments,
-				   if < 0, _minimum_ number of arguments */
-	char	*verb;		/* verb */
-	char	*help;		/* help lines; from the 2nd line onward they 
-                                   are automatically indented */
-        char    *adv_help;      /* advanced help message; from the 2nd line 
-                                   onward they are automatically indented */
-
-	/* the following fields are run-time filled by the program */
-	char	**cmds;		/* array of subcommands */
-	int	ncmds;		/* number of subcommand */
+static const char * const btrfs_cmd_group_usage[] = {
+	"btrfs [--help] [--version] <group> [<group>...] <command> [<args>]",
+	NULL
 };
 
-static struct Command commands[] = {
+static const char btrfs_cmd_group_info[] =
+	"Use --help as an argument for information on a specific group or command.";
 
-	/*
-		avoid short commands different for the case only
-	*/
-	{ do_clone, -2,
-	  "subvolume snapshot", "[-r] <source> [<dest>/]<name>\n"
-		"Create a writable/readonly snapshot of the subvolume <source> with\n"
-		"the name <name> in the <dest> directory.",
-	  NULL
-	},
-	{ do_delete_subvolume, 1,
-	  "subvolume delete", "<subvolume>\n"
-		"Delete the subvolume <subvolume>.",
-	  NULL
-	},
-	{ do_create_subvol, 1,
-	  "subvolume create", "[<dest>/]<name>\n"
-		"Create a subvolume in <dest> (or the current directory if\n"
-		"not passed).",
-	  NULL
-	},
-	{ do_subvol_list, -1, "subvolume list", "[-p] <path>\n"
-		"List the snapshot/subvolume of a filesystem.",
-		"[-p] <path>\n"
-		"List the snapshot/subvolume of a filesystem.\n"
-		"-p	   print parent ID"
-	},
-	{ do_set_default_subvol, 2,
-	  "subvolume set-default", "<id> <path>\n"
-		"Set the subvolume of the filesystem <path> which will be mounted\n"
-		"as default.",
-	  NULL
-	},
-	{ do_find_newer, 2, "subvolume find-new", "<path> <last_gen>\n"
-		"List the recently modified files in a filesystem.",
-	  NULL
-	},
-	{ do_defrag, -1,
-	  "filesystem defragment", "[-vf] [-c[zlib,lzo]] [-s start] [-l len] [-t size] <file>|<dir> [<file>|<dir>...]\n"
-		"Defragment a file or a directory.",
-	  	"[-vcf] [-s start] [-l len] [-t size] <file>|<dir> [<file>|<dir>...]\n"
-		"Defragment file data or directory metadata.\n"
-		"-v         be verbose\n"
-		"-c         compress the file while defragmenting\n"
-		"-f         flush data to disk immediately after defragmenting\n"
-		"-s start   defragment only from byte onward\n"
-		"-l len     defragment only up to len bytes\n"
-		"-t size    minimal size of file to be considered for defragmenting\n"
-	},
-	{ do_get_default_subvol, 1, "subvolume get-default", "<path>\n"
-		"Get the default subvolume of a filesystem."
-	},
-	{ do_fssync, 1,
-	  "filesystem sync", "<path>\n"
-		"Force a sync on the filesystem <path>.",
-	  NULL
-	},
-	{ do_resize, 2,
-	  "filesystem resize", "[+/-]<newsize>[gkm]|max <filesystem>\n"
-		"Resize the file system. If 'max' is passed, the filesystem\n"
-		"will occupe all available space on the device.",
-	  NULL
-	},
-	{ do_show_filesystem, 999,
-	  "filesystem show", "[--all-devices][<uuid>|<label>]\n"
-		"Show the info of a btrfs filesystem. If no argument\n"
-		"is passed, info of all the btrfs filesystem are shown.",
-	  NULL
-	},
-	{ do_df_filesystem, 1,
-	  "filesystem df", "<path>\n"
-		"Show space usage information for a mount point.",
-	  NULL
-	},
-	{ do_balance, 1,
-	  "filesystem balance", "<path>\n"
-		"Balance the chunks across the device.",
-	  NULL
-	},
-	{ do_change_label, -1,
-	  "filesystem label", "<device> [<newlabel>]\n"
-	  "With one argument, get the label of filesystem on <device>.\n"
-	  "If <newlabel> is passed, set the filesystem label to <newlabel>.\n"
-	  "The filesystem must be unmounted.\n"
-	},
-	{ do_scrub_start, -1,
-	  "scrub start", "[-Bdqr] <path>|<device>\n"
-		"Start a new scrub.",
-		"\n-B  do not background\n"
-		"-d  stats per device (-B only)\n"
-		"-q  quiet\n"
-		"-r  read only mode\n"
-	},
-	{ do_scrub_cancel, 1,
-	  "scrub cancel", "<path>|<device>\n"
-		"Cancel a running scrub.",
-	  NULL
-	},
-	{ do_scrub_resume, -1,
-	  "scrub resume", "[-Bdqr] <path>|<device>\n"
-		"Resume previously canceled or interrupted scrub.",
-	  NULL
-	},
-	{ do_scrub_status, -1,
-	  "scrub status", "[-d] <path>|<device>\n"
-		"Show status of running or finished scrub.",
-	  NULL
-	},
-	{ do_scan, 999, 
-	  "device scan", "[<device>...]\n"
-		"Scan all device for or the passed device for a btrfs\n"
-		"filesystem.",
-	  NULL
-	},
-	{ do_add_volume, -2,
-	  "device add", "<device> [<device>...] <path>\n"
-		"Add a device to a filesystem.",
-	  NULL
-	},
-	{ do_remove_volume, -2,
-	  "device delete", "<device> [<device>...] <path>\n"
-		"Remove a device from a filesystem.",
-	  NULL
-	},
-	{ do_ino_to_path, -2,
-	  "inspect-internal inode-resolve", "[-v] <inode> <path>\n"
-		"get file system paths for the given inode.",
-	  NULL
-	},
-	{ do_logical_to_ino, -2,
-	  "inspect-internal logical-resolve", "[-v] [-P] <logical> <path>\n"
-		"get file system paths for the given logical address.",
-	  NULL
-	},
-	{ 0, 0, 0, 0 }
-};
+char argv0_buf[ARGV0_BUF_SIZE] = "btrfs";
 
-static char *get_prgname(char *programname)
+static inline const char *skip_prefix(const char *str, const char *prefix)
 {
-	char	*np;
-	np = strrchr(programname,'/');
-	if(!np)
-		np = programname;
-	else
-		np++;
+	size_t len = strlen(prefix);
+	return strncmp(str, prefix, len) ? NULL : str + len;
+}
 
-	return np;
+int prefixcmp(const char *str, const char *prefix)
+{
+	for (; ; str++, prefix++)
+		if (!*prefix)
+			return 0;
+		else if (*str != *prefix)
+			return (unsigned char)*prefix - (unsigned char)*str;
 }
 
-static void print_help(char *programname, struct Command *cmd, int helptype)
+static int parse_one_token(const char *arg, const struct cmd_group *grp,
+			   const struct cmd_struct **cmd_ret)
 {
-	char	*pc;
+	const struct cmd_struct *cmd = grp->commands;
+	const struct cmd_struct *abbrev_cmd = NULL, *ambiguous_cmd = NULL;
 
-	printf("\t%s %s ", programname, cmd->verb );
+	for (; cmd->token; cmd++) {
+		const char *rest;
 
-	if (helptype == ADVANCED_HELP && cmd->adv_help)
-		for(pc = cmd->adv_help; *pc; pc++){
-			putchar(*pc);
-			if(*pc == '\n')
-				printf("\t\t");
-		}
-	else
-		for(pc = cmd->help; *pc; pc++){
-			putchar(*pc);
-			if(*pc == '\n')
-				printf("\t\t");
+		rest = skip_prefix(arg, cmd->token);
+		if (!rest) {
+			if (!prefixcmp(cmd->token, arg)) {
+				if (abbrev_cmd) {
+					/*
+					 * If this is abbreviated, it is
+					 * ambiguous. So when there is no
+					 * exact match later, we need to
+					 * error out.
+					 */
+					ambiguous_cmd = abbrev_cmd;
+				}
+				abbrev_cmd = cmd;
+			}
+			continue;
 		}
+		if (*rest)
+			continue;
 
-	putchar('\n');
-}
+		*cmd_ret = cmd;
+		return 0;
+	}
 
-static void help(char *np)
-{
-	struct Command *cp;
+	if (ambiguous_cmd)
+		return -2;
 
-	printf("Usage:\n");
-	for( cp = commands; cp->verb; cp++ )
-		print_help(np, cp, BASIC_HELP);
+	if (abbrev_cmd) {
+		*cmd_ret = abbrev_cmd;
+		return 0;
+	}
 
-	printf("\n\t%s help|--help|-h\n\t\tShow the help.\n",np);
-	printf("\n\t%s <cmd> --help\n\t\tShow detailed help for a command or\n\t\t"
-	       "subset of commands.\n",np);
-	printf("\n%s\n", BTRFS_BUILD_VERSION);
+	return -1;
 }
 
-static int split_command(char *cmd, char ***commands)
+static const struct cmd_struct *
+parse_command_token(const char *arg, const struct cmd_group *grp)
 {
-	int	c, l;
-	char	*p, *s;
-
-	for( *commands = 0, l = c = 0, p = s = cmd ; ; p++, l++ ){
-		if ( *p && *p != ' ' )
-			continue;
+	const struct cmd_struct *cmd;
 
-		/* c + 2 so that we have room for the null */
-		(*commands) = realloc( (*commands), sizeof(char *)*(c + 2));
-		(*commands)[c] = strndup(s, l);
-		c++;
-		l = 0;
-		s = p+1;
-		if( !*p ) break;
+	switch(parse_one_token(arg, grp, &cmd)) {
+	case -1:
+		help_unknown_token(arg, grp);
+	case -2:
+		help_ambiguous_token(arg, grp);
 	}
 
-	(*commands)[c] = 0;
-	return c;
+	return cmd;
 }
 
-/*
-	This function checks if the passed command is ambiguous
-*/
-static int check_ambiguity(struct Command *cmd, char **argv){
-	int		i;
-	struct Command	*cp;
-	/* check for ambiguity */
-	for( i = 0 ; i < cmd->ncmds ; i++ ){
-		int match;
-		for( match = 0, cp = commands; cp->verb; cp++ ){
-			int	j, skip;
-			char	*s1, *s2;
-
-			if( cp->ncmds < i )
-				continue;
-
-			for( skip = 0, j = 0 ; j < i ; j++ )
-				if( strcmp(cmd->cmds[j], cp->cmds[j])){
-					skip=1;
-					break;
-				}
-			if(skip)
-				continue;
+void handle_help_options_next_level(const struct cmd_struct *cmd,
+				    int argc, char **argv)
+{
+	if (argc < 2)
+		return;
 
-			if( !strcmp(cmd->cmds[i], cp->cmds[i]))
-				continue;
-			for(s2 = cp->cmds[i], s1 = argv[i+1];
-				*s1 == *s2 && *s1; s1++, s2++ ) ;
-			if( !*s1 )
-				match++;
-		}
-		if(match){
-			int j;
-			fprintf(stderr, "ERROR: in command '");
-			for( j = 0 ; j <= i ; j++ )
-				fprintf(stderr, "%s%s",j?" ":"", argv[j+1]);
-			fprintf(stderr, "', '%s' is ambiguous\n",argv[j]);
-			return -2;
+	if (!strcmp(argv[1], "--help")) {
+		if (cmd->next) {
+			argc--;
+			argv++;
+			help_command_group(cmd->next, argc, argv);
+		} else {
+			usage_command(cmd, 1, 0);
 		}
+
+		exit(0);
 	}
-	return 0;
 }
 
-/*
- * This function, compacts the program name and the command in the first
- * element of the '*av' array
- */
-static int prepare_args(int *ac, char ***av, char *prgname, struct Command *cmd ){
-
-	char	**ret;
-	int	i;
-	char	*newname;
-
-	ret = (char **)malloc(sizeof(char*)*(*ac+1));
-	newname = (char*)malloc(strlen(prgname)+strlen(cmd->verb)+2);
-	if( !ret || !newname ){
-		free(ret);
-		free(newname);
-		return -1;
-	}
+static void fixup_argv0(char **argv, const char *token)
+{
+	int len = strlen(argv0_buf);
 
-	ret[0] = newname;
-	for(i=0; i < *ac ; i++ )
-		ret[i+1] = (*av)[i];
-
-	strcpy(newname, prgname);
-	strcat(newname, " ");
-	strcat(newname, cmd->verb);
+	snprintf(argv0_buf + len, sizeof(argv0_buf) - len, " %s", token);
+	argv[0] = argv0_buf;
+}
 
-	(*ac)++;
-	*av = ret;
+int handle_command_group(const struct cmd_group *grp, int argc,
+			 char **argv)
 
-	return 0;
+{
+	const struct cmd_struct *cmd;
+
+	argc--;
+	argv++;
+	if (argc < 1) {
+		usage_command_group(grp, 0, 0);
+		exit(1);
+	}
 
+	cmd = parse_command_token(argv[0], grp);
+
+	handle_help_options_next_level(cmd, argc, argv);
+
+	fixup_argv0(argv, cmd->token);
+	return cmd->fn(argc, argv);
 }
 
+int check_argc_exact(int nargs, int expected)
+{
+	if (nargs < expected)
+		fprintf(stderr, "%s: too few arguments\n", argv0_buf);
+	if (nargs > expected)
+		fprintf(stderr, "%s: too many arguments\n", argv0_buf);
 
+	return nargs != expected;
+}
 
-/*
-	This function performs the following jobs:
-	- show the help if '--help' or 'help' or '-h' are passed
-	- verify that a command is not ambiguous, otherwise show which
-	  part of the command is ambiguous
-	- if after a (even partial) command there is '--help' show detailed help
-	  for all the matching commands
-	- if the command doesn't match show an error
-	- finally, if a command matches, they return which command matched and
-	  the arguments
-
-	The function return 0 in case of help is requested; <0 in case
-	of uncorrect command; >0 in case of matching commands
-	argc, argv are the arg-counter and arg-vector (input)
-	*nargs_ is the number of the arguments after the command (output)
-	**cmd_  is the invoked command (output)
-	***args_ are the arguments after the command
-
-*/
-static int parse_args(int argc, char **argv,
-		      CommandFunction *func_,
-		      int *nargs_, char **cmd_, char ***args_ )
-{
-	struct Command	*cp;
-	struct Command	*matchcmd=0;
-	char		*prgname = get_prgname(argv[0]);
-	int		i=0, helprequested=0;
-
-	if( argc < 2 || !strcmp(argv[1], "help") ||
-		!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")){
-		help(prgname);
-		return 0;
+int check_argc_min(int nargs, int expected)
+{
+	if (nargs < expected) {
+		fprintf(stderr, "%s: too few arguments\n", argv0_buf);
+		return 1;
 	}
 
-	for( cp = commands; cp->verb; cp++ )
-		if( !cp->ncmds)
-			cp->ncmds = split_command(cp->verb, &(cp->cmds));
+	return 0;
+}
 
-	for( cp = commands; cp->verb; cp++ ){
-		int     match;
+int check_argc_max(int nargs, int expected)
+{
+	if (nargs > expected) {
+		fprintf(stderr, "%s: too many arguments\n", argv0_buf);
+		return 1;
+	}
 
-		if( argc-1 < cp->ncmds )
-			continue;
-		for( match = 1, i = 0 ; i < cp->ncmds ; i++ ){
-			char	*s1, *s2;
-			s1 = cp->cmds[i];
-			s2 = argv[i+1];
-
-			for(s2 = cp->cmds[i], s1 = argv[i+1];
-				*s1 == *s2 && *s1;
-				s1++, s2++ ) ;
-			if( *s1 ){
-				match=0;
-				break;
-			}
-		}
+	return 0;
+}
 
-		/* If you understand why this code works ...
-			you are a genious !! */
-		if(argc>i+1 && !strcmp(argv[i+1],"--help")){
-			if(!helprequested)
-				printf("Usage:\n");
-			print_help(prgname, cp, ADVANCED_HELP);
-			helprequested=1;
-			continue;
-		}
+const struct cmd_group btrfs_cmd_group;
 
-		if(!match)
-			continue;
+static const char * const cmd_help_usage[] = {
+	"btrfs help [--full]",
+	"Dislay help information",
+	"",
+	"--full     display detailed help on every command",
+	NULL
+};
 
-		matchcmd = cp;
-		*nargs_  = argc-matchcmd->ncmds-1;
-		*cmd_ = matchcmd->verb;
-		*args_ = argv+matchcmd->ncmds+1;
-		*func_ = cp->func;
+static int cmd_help(int argc, char **argv)
+{
+	help_command_group(&btrfs_cmd_group, argc, argv);
+	return 0;
+}
 
-		break;
-	}
+static const char * const cmd_version_usage[] = {
+	"btrfs version",
+	"Display btrfs-progs version",
+	NULL
+};
 
-	if(helprequested){
-		printf("\n%s\n", BTRFS_BUILD_VERSION);
-		return 0;
-	}
+static int cmd_version(int argc, char **argv)
+{
+	printf("%s\n", BTRFS_BUILD_VERSION);
+	return 0;
+}
 
-	if(!matchcmd){
-		fprintf( stderr, "ERROR: unknown command '%s'\n",argv[1]);
-		help(prgname);
-		return -1;
-	}
+static int handle_options(int *argc, char ***argv)
+{
+	char **orig_argv = *argv;
 
-	if(check_ambiguity(matchcmd, argv))
-		return -2;
+	while (*argc > 0) {
+		const char *arg = (*argv)[0];
+		if (arg[0] != '-')
+			break;
+
+		if (!strcmp(arg, "--help")) {
+			break;
+		} else if (!strcmp(arg, "--version")) {
+			break;
+		} else {
+			fprintf(stderr, "Unknown option: %s\n", arg);
+			fprintf(stderr, "usage: %s\n",
+				btrfs_cmd_group.usagestr[0]);
+			exit(129);
+		}
 
-	/* check the number of argument */
-	if (matchcmd->nargs < 0 && matchcmd->nargs < -*nargs_ ){
-		fprintf(stderr, "ERROR: '%s' requires minimum %d arg(s)\n",
-			matchcmd->verb, -matchcmd->nargs);
-			return -2;
+		(*argv)++;
+		(*argc)--;
 	}
-	if(matchcmd->nargs >= 0 && matchcmd->nargs != *nargs_ && matchcmd->nargs != 999){
-		fprintf(stderr, "ERROR: '%s' requires %d arg(s)\n",
-			matchcmd->verb, matchcmd->nargs);
-			return -2;
-	}
-	
-        if (prepare_args( nargs_, args_, prgname, matchcmd )){
-                fprintf(stderr, "ERROR: not enough memory\\n");
-		return -20;
-        }
-
 
-	return 1;
+	return (*argv) - orig_argv;
 }
-int main(int ac, char **av )
-{
 
-	char		*cmd=0, **args=0;
-	int		nargs=0, r;
-	CommandFunction func=0;
+const struct cmd_group btrfs_cmd_group = {
+	btrfs_cmd_group_usage, btrfs_cmd_group_info, {
+		{ "subvolume", cmd_subvolume, NULL, &subvolume_cmd_group, 0 },
+		{ "filesystem", cmd_filesystem, NULL, &filesystem_cmd_group, 0 },
+		{ "balance", cmd_balance, NULL, &balance_cmd_group, 0 },
+		{ "device", cmd_device, NULL, &device_cmd_group, 0 },
+		{ "scrub", cmd_scrub, NULL, &scrub_cmd_group, 0 },
+		{ "inspect-internal", cmd_inspect, NULL, &inspect_cmd_group, 0 },
+		{ "help", cmd_help, cmd_help_usage, NULL, 0 },
+		{ "version", cmd_version, cmd_version_usage, NULL, 0 },
+		{ 0, 0, 0, 0, 0 }
+	},
+};
+
+int main(int argc, char **argv)
+{
+	const struct cmd_struct *cmd;
 
-	r = parse_args(ac, av, &func, &nargs, &cmd, &args);
-	if( r <= 0 ){
-		/* error or no command to parse*/
-		exit(-r);
+	argc--;
+	argv++;
+	handle_options(&argc, &argv);
+	if (argc > 0) {
+		if (!prefixcmp(argv[0], "--"))
+			argv[0] += 2;
+	} else {
+		usage_command_group(&btrfs_cmd_group, 0, 0);
+		exit(1);
 	}
 
-	exit(func(nargs, args));
+	cmd = parse_command_token(argv[0], &btrfs_cmd_group);
 
-}
+	handle_help_options_next_level(cmd, argc, argv);
 
+	fixup_argv0(argv, cmd->token);
+	exit(cmd->fn(argc, argv));
+}
diff -Nru btrfs-tools-0.19+20111121/btrfsck.c btrfs-tools-0.19+20120328/btrfsck.c
--- btrfs-tools-0.19+20111121/btrfsck.c	2011-11-23 00:03:58.000000000 +0000
+++ btrfs-tools-0.19+20120328/btrfsck.c	2012-05-05 18:53:48.000000000 +0000
@@ -23,8 +23,11 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/stat.h>
+#include <getopt.h>
 #include "kerncompat.h"
 #include "ctree.h"
+#include "volumes.h"
+#include "repair.h"
 #include "disk-io.h"
 #include "print-tree.h"
 #include "transaction.h"
@@ -74,9 +77,13 @@
 	struct cache_extent cache;
 	struct btrfs_disk_key parent_key;
 	u64 start;
+	u64 max_size;
 	u64 nr;
 	u64 refs;
 	u64 extent_item_refs;
+	u64 generation;
+	u64 info_objectid;
+	u8 info_level;
 	unsigned int content_checked:1;
 	unsigned int owner_ref_checked:1;
 	unsigned int is_root:1;
@@ -1082,7 +1089,9 @@
 	ret = btrfs_lookup_extent_info(NULL, root,
 				       path->nodes[*level]->start,
 				       path->nodes[*level]->len, &refs, NULL);
-	BUG_ON(ret);
+	if (ret < 0)
+		goto out;
+
 	if (refs > 1) {
 		ret = enter_shared_node(root, path->nodes[*level]->start,
 					refs, wc, *level);
@@ -1109,7 +1118,8 @@
 		blocksize = btrfs_level_size(root, *level - 1);
 		ret = btrfs_lookup_extent_info(NULL, root, bytenr, blocksize,
 					       &refs, NULL);
-		BUG_ON(ret);
+		if (ret < 0)
+			refs = 0;
 
 		if (refs > 1) {
 			ret = enter_shared_node(root, bytenr, refs,
@@ -1710,86 +1720,6 @@
 	return err;
 }
 
-static int check_node(struct btrfs_root *root,
-		      struct btrfs_disk_key *parent_key,
-		      struct extent_buffer *buf)
-{
-	int i;
-	struct btrfs_key cpukey;
-	struct btrfs_disk_key key;
-	u32 nritems = btrfs_header_nritems(buf);
-
-	if (nritems == 0 || nritems > BTRFS_NODEPTRS_PER_BLOCK(root))
-		return 1;
-	if (parent_key->type) {
-		btrfs_node_key(buf, &key, 0);
-		if (memcmp(parent_key, &key, sizeof(key)))
-			return 1;
-	}
-	for (i = 0; nritems > 1 && i < nritems - 2; i++) {
-		btrfs_node_key(buf, &key, i);
-		btrfs_node_key_to_cpu(buf, &cpukey, i + 1);
-		if (btrfs_comp_keys(&key, &cpukey) >= 0)
-			return 1;
-	}
-	return 0;
-}
-
-static int check_leaf(struct btrfs_root *root,
-		      struct btrfs_disk_key *parent_key,
-		      struct extent_buffer *buf)
-{
-	int i;
-	struct btrfs_key cpukey;
-	struct btrfs_disk_key key;
-	u32 nritems = btrfs_header_nritems(buf);
-
-	if (btrfs_header_level(buf) != 0) {
-		fprintf(stderr, "leaf is not a leaf %llu\n",
-		       (unsigned long long)btrfs_header_bytenr(buf));
-		return 1;
-	}
-	if (btrfs_leaf_free_space(root, buf) < 0) {
-		fprintf(stderr, "leaf free space incorrect %llu %d\n",
-			(unsigned long long)btrfs_header_bytenr(buf),
-			btrfs_leaf_free_space(root, buf));
-		return 1;
-	}
-
-	if (nritems == 0)
-		return 0;
-
-	btrfs_item_key(buf, &key, 0);
-	if (parent_key->type && memcmp(parent_key, &key, sizeof(key))) {
-		fprintf(stderr, "leaf parent key incorrect %llu\n",
-		       (unsigned long long)btrfs_header_bytenr(buf));
-		return 1;
-	}
-	for (i = 0; nritems > 1 && i < nritems - 2; i++) {
-		btrfs_item_key(buf, &key, i);
-		btrfs_item_key_to_cpu(buf, &cpukey, i + 1);
-		if (btrfs_comp_keys(&key, &cpukey) >= 0) {
-			fprintf(stderr, "bad key ordering %d %d\n", i, i+1);
-			return 1;
-		}
-		if (btrfs_item_offset_nr(buf, i) !=
-			btrfs_item_end_nr(buf, i + 1)) {
-			fprintf(stderr, "incorrect offsets %u %u\n",
-				btrfs_item_offset_nr(buf, i),
-				btrfs_item_end_nr(buf, i + 1));
-			return 1;
-		}
-		if (i == 0 && btrfs_item_end_nr(buf, i) !=
-		    BTRFS_LEAF_DATA_SIZE(root)) {
-			fprintf(stderr, "bad item end %u wanted %u\n",
-				btrfs_item_end_nr(buf, i),
-				(unsigned)BTRFS_LEAF_DATA_SIZE(root));
-			return 1;
-		}
-	}
-	return 0;
-}
-
 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
 {
 	struct list_head *cur = rec->backrefs.next;
@@ -1834,12 +1764,12 @@
 			if (!print_errs)
 				goto out;
 			tback = (struct tree_backref *)back;
-			fprintf(stderr, "Backref %llu %s %llu not referenced\n",
+			fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
 				(unsigned long long)rec->start,
 				back->full_backref ? "parent" : "root",
 				back->full_backref ?
 				(unsigned long long)tback->parent :
-				(unsigned long long)tback->root);
+				(unsigned long long)tback->root, back);
 		}
 		if (back->is_data) {
 			dback = (struct data_backref *)back;
@@ -1849,7 +1779,7 @@
 					goto out;
 				fprintf(stderr, "Incorrect local backref count"
 					" on %llu %s %llu owner %llu"
-					" offset %llu found %u wanted %u\n",
+					" offset %llu found %u wanted %u back %p\n",
 					(unsigned long long)rec->start,
 					back->full_backref ?
 					"parent" : "root",
@@ -1858,7 +1788,7 @@
 					(unsigned long long)dback->root,
 					(unsigned long long)dback->owner,
 					(unsigned long long)dback->offset,
-					dback->found_ref, dback->num_refs);
+					dback->found_ref, dback->num_refs, back);
 			}
 		}
 		if (!back->is_data) {
@@ -1946,7 +1876,7 @@
 		btrfs_item_key_to_cpu(buf, &key, 0);
 	else
 		btrfs_node_key_to_cpu(buf, &key, 0);
-	
+
 	btrfs_init_path(&path);
 	path.lowest_level = level + 1;
 	btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
@@ -1959,23 +1889,81 @@
 	return found ? 0 : 1;
 }
 
+static int is_extent_tree_record(struct extent_record *rec)
+{
+	struct list_head *cur = rec->backrefs.next;
+	struct extent_backref *node;
+	struct tree_backref *back;
+	int is_extent = 0;
+
+	while(cur != &rec->backrefs) {
+		node = list_entry(cur, struct extent_backref, list);
+		cur = cur->next;
+		if (node->is_data)
+			return 0;
+		back = (struct tree_backref *)node;
+		if (node->full_backref)
+			return 0;
+		if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
+			is_extent = 1;
+	}
+	return is_extent;
+}
+
+
+static int record_bad_block_io(struct btrfs_fs_info *info,
+			       struct cache_tree *extent_cache,
+			       u64 start, u64 len)
+{
+	struct extent_record *rec;
+	struct cache_extent *cache;
+	struct btrfs_key key;
+
+	cache = find_cache_extent(extent_cache, start, len);
+	if (!cache)
+		return 0;
+
+	rec = container_of(cache, struct extent_record, cache);
+	if (!is_extent_tree_record(rec))
+		return 0;
+
+	btrfs_disk_key_to_cpu(&key, &rec->parent_key);
+	return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
+}
+
 static int check_block(struct btrfs_root *root,
 		       struct cache_tree *extent_cache,
 		       struct extent_buffer *buf, u64 flags)
 {
 	struct extent_record *rec;
 	struct cache_extent *cache;
+	struct btrfs_key key;
 	int ret = 1;
+	int level;
 
 	cache = find_cache_extent(extent_cache, buf->start, buf->len);
 	if (!cache)
 		return 1;
 	rec = container_of(cache, struct extent_record, cache);
-	if (btrfs_is_leaf(buf)) {
-		ret = check_leaf(root, &rec->parent_key, buf);
-	} else {
-		ret = check_node(root, &rec->parent_key, buf);
+	rec->generation = btrfs_header_generation(buf);
+
+	level = btrfs_header_level(buf);
+	if (btrfs_header_nritems(buf) > 0) {
+
+		if (level == 0)
+			btrfs_item_key_to_cpu(buf, &key, 0);
+		else
+			btrfs_node_key_to_cpu(buf, &key, 0);
+
+		rec->info_objectid = key.objectid;
 	}
+	rec->info_level = level;
+
+	if (btrfs_is_leaf(buf))
+		ret = btrfs_check_leaf(root, &rec->parent_key, buf);
+	else
+		ret = btrfs_check_node(root, &rec->parent_key, buf);
+
 	if (ret) {
 		fprintf(stderr, "bad block %llu\n",
 			(unsigned long long)buf->start);
@@ -2035,6 +2023,7 @@
 		ref->node.full_backref = 0;
 	}
 	list_add_tail(&ref->node.list, &rec->backrefs);
+
 	return ref;
 }
 
@@ -2052,7 +2041,7 @@
 		if (!node->is_data)
 			continue;
 		back = (struct data_backref *)node;
-		if (parent > 0) { 
+		if (parent > 0) {
 			if (!node->full_backref)
 				continue;
 			if (parent == back->parent)
@@ -2070,11 +2059,13 @@
 
 static struct data_backref *alloc_data_backref(struct extent_record *rec,
 						u64 parent, u64 root,
-						u64 owner, u64 offset)
+						u64 owner, u64 offset,
+						u64 max_size)
 {
 	struct data_backref *ref = malloc(sizeof(*ref));
 	memset(&ref->node, 0, sizeof(ref->node));
 	ref->node.is_data = 1;
+
 	if (parent > 0) {
 		ref->parent = parent;
 		ref->owner = 0;
@@ -2089,13 +2080,16 @@
 	ref->found_ref = 0;
 	ref->num_refs = 0;
 	list_add_tail(&ref->node.list, &rec->backrefs);
+	if (max_size > rec->max_size)
+		rec->max_size = max_size;
 	return ref;
 }
 
 static int add_extent_rec(struct cache_tree *extent_cache,
 			  struct btrfs_key *parent_key,
 			  u64 start, u64 nr, u64 extent_item_refs,
-			  int is_root, int inc_ref, int set_checked)
+			  int is_root, int inc_ref, int set_checked,
+			  u64 max_size)
 {
 	struct extent_record *rec;
 	struct cache_extent *cache;
@@ -2107,7 +2101,7 @@
 		if (inc_ref)
 			rec->refs++;
 		if (rec->nr == 1)
-			rec->nr = nr;
+			rec->nr = max(nr, max_size);
 
 		if (start != rec->start) {
 			fprintf(stderr, "warning, start mismatch %llu %llu\n",
@@ -2136,12 +2130,16 @@
 		if (parent_key)
 			btrfs_cpu_key_to_disk(&rec->parent_key, parent_key);
 
+		if (rec->max_size < max_size)
+			rec->max_size = max_size;
+
 		maybe_free_extent_rec(extent_cache, rec);
 		return ret;
 	}
 	rec = malloc(sizeof(*rec));
 	rec->start = start;
-	rec->nr = nr;
+	rec->max_size = max_size;
+	rec->nr = max(nr, max_size);
 	rec->content_checked = 0;
 	rec->owner_ref_checked = 0;
 	INIT_LIST_HEAD(&rec->backrefs);
@@ -2187,7 +2185,7 @@
 
 	cache = find_cache_extent(extent_cache, bytenr, 1);
 	if (!cache) {
-		add_extent_rec(extent_cache, NULL, bytenr, 1, 0, 0, 0, 0);
+		add_extent_rec(extent_cache, NULL, bytenr, 1, 0, 0, 0, 0, 0);
 		cache = find_cache_extent(extent_cache, bytenr, 1);
 		if (!cache)
 			abort();
@@ -2226,7 +2224,7 @@
 
 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
 			    u64 parent, u64 root, u64 owner, u64 offset,
-			    u32 num_refs, int found_ref)
+			    u32 num_refs, int found_ref, u64 max_size)
 {
 	struct extent_record *rec;
 	struct data_backref *back;
@@ -2234,7 +2232,8 @@
 
 	cache = find_cache_extent(extent_cache, bytenr, 1);
 	if (!cache) {
-		add_extent_rec(extent_cache, NULL, bytenr, 1, 0, 0, 0, 0);
+		add_extent_rec(extent_cache, NULL, bytenr, 1, 0, 0, 0, 0,
+			       max_size);
 		cache = find_cache_extent(extent_cache, bytenr, 1);
 		if (!cache)
 			abort();
@@ -2244,9 +2243,13 @@
 	if (rec->start != bytenr) {
 		abort();
 	}
+	if (rec->max_size < max_size)
+		rec->max_size = max_size;
+
 	back = find_data_backref(rec, parent, root, owner, offset);
 	if (!back)
-		back = alloc_data_backref(rec, parent, root, owner, offset);
+		back = alloc_data_backref(rec, parent, root, owner, offset,
+					  max_size);
 
 	if (found_ref) {
 		BUG_ON(num_refs != 1);
@@ -2359,11 +2362,10 @@
 	btrfs_item_key_to_cpu(leaf, &key, slot);
 	ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
 	if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
-		add_tree_backref(extent_cache, key.objectid, key.offset,
-				 0, 0);
+		add_tree_backref(extent_cache, key.objectid, key.offset, 0, 0);
 	} else {
 		add_data_backref(extent_cache, key.objectid, key.offset, 0,
-				 0, 0, btrfs_ref_count_v0(leaf, ref0), 0);
+				 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
 	}
 	return 0;
 }
@@ -2396,14 +2398,14 @@
 		BUG();
 #endif
 		return add_extent_rec(extent_cache, NULL, key.objectid,
-				      key.offset, refs, 0, 0, 0);
+				      key.offset, refs, 0, 0, 0, key.offset);
 	}
 
 	ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
 	refs = btrfs_extent_refs(eb, ei);
 
 	add_extent_rec(extent_cache, NULL, key.objectid, key.offset,
-		       refs, 0, 0, 0);
+		       refs, 0, 0, 0, key.offset);
 
 	ptr = (unsigned long)(ei + 1);
 	if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
@@ -2431,21 +2433,24 @@
 								       dref),
 					btrfs_extent_data_ref_offset(eb, dref),
 					btrfs_extent_data_ref_count(eb, dref),
-					0);
+					0, key.offset);
 			break;
 		case BTRFS_SHARED_DATA_REF_KEY:
 			sref = (struct btrfs_shared_data_ref *)(iref + 1);
 			add_data_backref(extent_cache, key.objectid, offset,
 					0, 0, 0,
 					btrfs_shared_data_ref_count(eb, sref),
-					0);
+					0, key.offset);
 			break;
 		default:
-			BUG();
+			fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
+				key.objectid, key.type, key.offset);
+			goto out;
 		}
 		ptr += btrfs_extent_inline_ref_size(type);
 	}
 	WARN_ON(ptr > end);
+out:
 	return 0;
 }
 
@@ -2509,9 +2514,18 @@
 
 	/* fixme, get the real parent transid */
 	buf = read_tree_block(root, bytenr, size, 0);
+	if (!extent_buffer_uptodate(buf)) {
+		record_bad_block_io(root->fs_info,
+				    extent_cache, bytenr, size);
+		free_extent_buffer(buf);
+		goto out;
+	}
+
 	nritems = btrfs_header_nritems(buf);
 
 	ret = btrfs_lookup_extent_info(NULL, root, bytenr, size, NULL, &flags);
+	if (ret < 0)
+		flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
 
 	if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
 		parent = bytenr;
@@ -2522,6 +2536,8 @@
 	}
 
 	ret = check_block(root, extent_cache, buf, flags);
+	if (ret)
+		goto out;
 
 	if (btrfs_is_leaf(buf)) {
 		btree_space_waste += btrfs_leaf_free_space(root, buf);
@@ -2570,7 +2586,7 @@
 								       ref),
 					btrfs_extent_data_ref_offset(buf, ref),
 					btrfs_extent_data_ref_count(buf, ref),
-					0);
+					0, root->sectorsize);
 				continue;
 			}
 			if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
@@ -2580,7 +2596,7 @@
 				add_data_backref(extent_cache,
 					key.objectid, key.offset, 0, 0, 0, 
 					btrfs_shared_data_ref_count(buf, ref),
-					0);
+					0, root->sectorsize);
 				continue;
 			}
 			if (key.type != BTRFS_EXTENT_DATA_KEY)
@@ -2603,26 +2619,33 @@
 			ret = add_extent_rec(extent_cache, NULL,
 				   btrfs_file_extent_disk_bytenr(buf, fi),
 				   btrfs_file_extent_disk_num_bytes(buf, fi),
-				   0, 0, 1, 1);
+				   0, 0, 1, 1,
+				   btrfs_file_extent_disk_num_bytes(buf, fi));
 			add_data_backref(extent_cache,
 				btrfs_file_extent_disk_bytenr(buf, fi),
 				parent, owner, key.objectid, key.offset -
-				btrfs_file_extent_offset(buf, fi), 1, 1);
+				btrfs_file_extent_offset(buf, fi), 1, 1,
+				btrfs_file_extent_disk_num_bytes(buf, fi));
 			BUG_ON(ret);
 		}
 	} else {
 		int level;
+		struct btrfs_key first_key;
+
+		first_key.objectid = 0;
+
+		if (nritems > 0)
+			btrfs_item_key_to_cpu(buf, &first_key, 0);
 		level = btrfs_header_level(buf);
 		for (i = 0; i < nritems; i++) {
 			u64 ptr = btrfs_node_blockptr(buf, i);
 			u32 size = btrfs_level_size(root, level - 1);
 			btrfs_node_key_to_cpu(buf, &key, i);
 			ret = add_extent_rec(extent_cache, &key,
-					     ptr, size, 0, 0, 1, 0);
+					     ptr, size, 0, 0, 1, 0, size);
 			BUG_ON(ret);
 
-			add_tree_backref(extent_cache, ptr, parent, 
-					 owner, 1);
+			add_tree_backref(extent_cache, ptr, parent, owner, 1);
 
 			if (level > 1) {
 				add_pending(nodes, seen, ptr, size);
@@ -2641,6 +2664,7 @@
 	    btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
 	    !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
 		found_old_backref = 1;
+out:
 	free_extent_buffer(buf);
 	return 0;
 }
@@ -2660,25 +2684,553 @@
 	else
 		add_pending(pending, seen, buf->start, buf->len);
 	add_extent_rec(extent_cache, NULL, buf->start, buf->len,
-		       0, 1, 1, 0);
+		       0, 1, 1, 0, buf->len);
 
 	if (root_key->objectid == BTRFS_TREE_RELOC_OBJECTID ||
 	    btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
-		add_tree_backref(extent_cache, buf->start, buf->start, 0, 1);
+		add_tree_backref(extent_cache, buf->start, buf->start,
+				 0, 1);
 	else
 		add_tree_backref(extent_cache, buf->start, 0,
 				 root_key->objectid, 1);
 	return 0;
 }
 
-static int check_extent_refs(struct btrfs_root *root,
-		      struct cache_tree *extent_cache)
+/* as we fix the tree, we might be deleting blocks that
+ * we're tracking for repair.  This hook makes sure we
+ * remove any backrefs for blocks as we are fixing them.
+ */
+static int free_extent_hook(struct btrfs_trans_handle *trans,
+			    struct btrfs_root *root,
+			    u64 bytenr, u64 num_bytes, u64 parent,
+			    u64 root_objectid, u64 owner, u64 offset,
+			    int refs_to_drop)
+{
+	struct extent_record *rec;
+	struct cache_extent *cache;
+	int is_data;
+	struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
+
+	is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
+	cache = find_cache_extent(extent_cache, bytenr, num_bytes);
+	if (!cache)
+		return 0;
+
+	rec = container_of(cache, struct extent_record, cache);
+	if (is_data) {
+		struct data_backref *back;
+		back = find_data_backref(rec, parent, root_objectid, owner,
+					 offset);
+		if (!back)
+			goto out;
+		if (back->node.found_ref) {
+			back->found_ref -= refs_to_drop;
+			if (rec->refs)
+				rec->refs -= refs_to_drop;
+		}
+		if (back->node.found_extent_tree) {
+			back->num_refs -= refs_to_drop;
+			if (rec->extent_item_refs)
+				rec->extent_item_refs -= refs_to_drop;
+		}
+		if (back->found_ref == 0)
+			back->node.found_ref = 0;
+		if (back->num_refs == 0)
+			back->node.found_extent_tree = 0;
+
+		if (!back->node.found_extent_tree && back->node.found_ref) {
+			list_del(&back->node.list);
+			free(back);
+		}
+	} else {
+		struct tree_backref *back;
+		back = find_tree_backref(rec, parent, root_objectid);
+		if (!back)
+			goto out;
+		if (back->node.found_ref) {
+			if (rec->refs)
+				rec->refs--;
+			back->node.found_ref = 0;
+		}
+		if (back->node.found_extent_tree) {
+			if (rec->extent_item_refs)
+				rec->extent_item_refs--;
+			back->node.found_extent_tree = 0;
+		}
+		if (!back->node.found_extent_tree && back->node.found_ref) {
+			list_del(&back->node.list);
+			free(back);
+		}
+	}
+	maybe_free_extent_rec(extent_cache, rec);
+out:
+	return 0;
+}
+
+static int delete_extent_records(struct btrfs_trans_handle *trans,
+				 struct btrfs_root *root,
+				 struct btrfs_path *path,
+				 u64 bytenr, u64 new_len)
+{
+	struct btrfs_key key;
+	struct btrfs_key found_key;
+	struct extent_buffer *leaf;
+	int ret;
+	int slot;
+
+
+	key.objectid = bytenr;
+	key.type = (u8)-1;
+	key.offset = (u64)-1;
+
+	while(1) {
+		ret = btrfs_search_slot(trans, root->fs_info->extent_root,
+					&key, path, 0, 1);
+		if (ret < 0)
+			break;
+
+		if (ret > 0) {
+			ret = 0;
+			if (path->slots[0] == 0)
+				break;
+			path->slots[0]--;
+		}
+		ret = 0;
+
+		leaf = path->nodes[0];
+		slot = path->slots[0];
+
+		btrfs_item_key_to_cpu(leaf, &found_key, slot);
+		if (found_key.objectid != bytenr)
+			break;
+
+		if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
+		    found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
+		    found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
+		    found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
+		    found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
+		    found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
+			btrfs_release_path(NULL, path);
+			if (found_key.type == 0) {
+				if (found_key.offset == 0)
+					break;
+				key.offset = found_key.offset - 1;
+				key.type = found_key.type;
+			}
+			key.type = found_key.type - 1;
+			key.offset = (u64)-1;
+			continue;
+		}
+
+		fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
+			found_key.objectid, found_key.type, found_key.offset);
+
+		ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
+		if (ret)
+			break;
+		btrfs_release_path(NULL, path);
+
+		if (found_key.type == BTRFS_EXTENT_ITEM_KEY) {
+			ret = btrfs_update_block_group(trans, root, bytenr,
+						       found_key.offset, 0, 0);
+			if (ret)
+				break;
+		}
+	}
+
+	btrfs_release_path(NULL, path);
+	return ret;
+}
+
+/*
+ * for a single backref, this will allocate a new extent
+ * and add the backref to it.
+ */
+static int record_extent(struct btrfs_trans_handle *trans,
+			 struct btrfs_fs_info *info,
+			 struct btrfs_path *path,
+			 struct extent_record *rec,
+			 struct extent_backref *back,
+			 int allocated, u64 flags)
+{
+	int ret;
+	struct btrfs_root *extent_root = info->extent_root;
+	struct extent_buffer *leaf;
+	struct btrfs_key ins_key;
+	struct btrfs_extent_item *ei;
+	struct tree_backref *tback;
+	struct data_backref *dback;
+	struct btrfs_tree_block_info *bi;
+
+	if (!back->is_data)
+		rec->max_size = max_t(u64, rec->max_size,
+				    info->extent_root->leafsize);
+
+	if (!allocated) {
+		u32 item_size = sizeof(*ei);
+
+		if (!back->is_data)
+			item_size += sizeof(*bi);
+
+		ins_key.objectid = rec->start;
+		ins_key.offset = rec->max_size;
+		ins_key.type = BTRFS_EXTENT_ITEM_KEY;
+
+		ret = btrfs_insert_empty_item(trans, extent_root, path,
+					&ins_key, item_size);
+		if (ret)
+			goto fail;
+
+		leaf = path->nodes[0];
+		ei = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_extent_item);
+
+		btrfs_set_extent_refs(leaf, ei, 0);
+		btrfs_set_extent_generation(leaf, ei, rec->generation);
+
+		if (back->is_data) {
+			btrfs_set_extent_flags(leaf, ei,
+					       BTRFS_EXTENT_FLAG_DATA);
+		} else {
+			struct btrfs_disk_key copy_key;;
+
+			tback = (struct tree_backref *)back;
+			bi = (struct btrfs_tree_block_info *)(ei + 1);
+			memset_extent_buffer(leaf, 0, (unsigned long)bi,
+					     sizeof(*bi));
+			memset(&copy_key, 0, sizeof(copy_key));
+
+			copy_key.objectid = le64_to_cpu(rec->info_objectid);
+			btrfs_set_tree_block_level(leaf, bi, rec->info_level);
+			btrfs_set_tree_block_key(leaf, bi, &copy_key);
+
+			btrfs_set_extent_flags(leaf, ei,
+					       BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
+		}
+
+		btrfs_mark_buffer_dirty(leaf);
+		ret = btrfs_update_block_group(trans, extent_root, rec->start,
+					       rec->max_size, 1, 0);
+		if (ret)
+			goto fail;
+		btrfs_release_path(NULL, path);
+	}
+
+	if (back->is_data) {
+		u64 parent;
+		int i;
+
+		dback = (struct data_backref *)back;
+		if (back->full_backref)
+			parent = dback->parent;
+		else
+			parent = 0;
+
+		for (i = 0; i < dback->found_ref; i++) {
+			/* if parent != 0, we're doing a full backref
+			 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
+			 * just makes the backref allocator create a data
+			 * backref
+			 */
+			ret = btrfs_inc_extent_ref(trans, info->extent_root,
+						   rec->start, rec->max_size,
+						   parent,
+						   dback->root,
+						   parent ?
+						   BTRFS_FIRST_FREE_OBJECTID :
+						   dback->owner,
+						   dback->offset);
+			if (ret)
+				break;
+		}
+		fprintf(stderr, "adding new data backref"
+				" on %llu %s %llu owner %llu"
+				" offset %llu found %d\n",
+				(unsigned long long)rec->start,
+				back->full_backref ?
+				"parent" : "root",
+				back->full_backref ?
+				(unsigned long long)parent :
+				(unsigned long long)dback->root,
+				(unsigned long long)dback->owner,
+				(unsigned long long)dback->offset,
+				dback->found_ref);
+	} else {
+		u64 parent;
+
+		tback = (struct tree_backref *)back;
+		if (back->full_backref)
+			parent = tback->parent;
+		else
+			parent = 0;
+
+		ret = btrfs_inc_extent_ref(trans, info->extent_root,
+					   rec->start, rec->max_size,
+					   parent, tback->root, 0, 0);
+		fprintf(stderr, "adding new tree backref on "
+			"start %llu len %llu parent %llu root %llu\n",
+			rec->start, rec->max_size, tback->parent, tback->root);
+	}
+	if (ret)
+		goto fail;
+fail:
+	btrfs_release_path(NULL, path);
+	return ret;
+}
+
+/*
+ * when an incorrect extent item is found, this will delete
+ * all of the existing entries for it and recreate them
+ * based on what the tree scan found.
+ */
+static int fixup_extent_refs(struct btrfs_trans_handle *trans,
+			     struct btrfs_fs_info *info,
+			     struct extent_record *rec)
+{
+	int ret;
+	struct btrfs_path *path;
+	struct list_head *cur = rec->backrefs.next;
+	struct cache_extent *cache;
+	struct extent_backref *back;
+	int allocated = 0;
+	u64 flags = 0;
+
+	/* remember our flags for recreating the extent */
+	ret = btrfs_lookup_extent_info(NULL, info->extent_root, rec->start,
+				       rec->max_size, NULL, &flags);
+	if (ret < 0)
+		flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
+
+	path = btrfs_alloc_path();
+
+	/* step one, delete all the existing records */
+	ret = delete_extent_records(trans, info->extent_root, path,
+				    rec->start, rec->max_size);
+
+	if (ret < 0)
+		goto out;
+
+	/* was this block corrupt?  If so, don't add references to it */
+	cache = find_cache_extent(info->corrupt_blocks, rec->start, rec->max_size);
+	if (cache) {
+		ret = 0;
+		goto out;
+	}
+
+	/* step two, recreate all the refs we did find */
+	while(cur != &rec->backrefs) {
+		back = list_entry(cur, struct extent_backref, list);
+		cur = cur->next;
+
+		/*
+		 * if we didn't find any references, don't create a
+		 * new extent record
+		 */
+		if (!back->found_ref)
+			continue;
+
+		ret = record_extent(trans, info, path, rec, back, allocated, flags);
+		allocated = 1;
+
+		if (ret)
+			goto out;
+	}
+out:
+	btrfs_free_path(path);
+	return ret;
+}
+
+/* right now we only prune from the extent allocation tree */
+static int prune_one_block(struct btrfs_trans_handle *trans,
+			   struct btrfs_fs_info *info,
+			   struct btrfs_corrupt_block *corrupt)
+{
+	int ret;
+	struct btrfs_path path;
+	struct extent_buffer *eb;
+	u64 found;
+	int slot;
+	int nritems;
+	int level = corrupt->level + 1;
+
+	btrfs_init_path(&path);
+again:
+	/* we want to stop at the parent to our busted block */
+	path.lowest_level = level;
+
+	ret = btrfs_search_slot(trans, info->extent_root,
+				&corrupt->key, &path, -1, 1);
+
+	if (ret < 0)
+		goto out;
+
+	eb = path.nodes[level];
+	if (!eb) {
+		ret = -ENOENT;
+		goto out;
+	}
+
+	/*
+	 * hopefully the search gave us the block we want to prune,
+	 * lets try that first
+	 */
+	slot = path.slots[level];
+	found =  btrfs_node_blockptr(eb, slot);
+	if (found == corrupt->cache.start)
+		goto del_ptr;
+
+	nritems = btrfs_header_nritems(eb);
+
+	/* the search failed, lets scan this node and hope we find it */
+	for (slot = 0; slot < nritems; slot++) {
+		found =  btrfs_node_blockptr(eb, slot);
+		if (found == corrupt->cache.start)
+			goto del_ptr;
+	}
+	/*
+	 * we couldn't find the bad block.  TODO, search all the nodes for pointers
+	 * to this block
+	 */
+	if (eb == info->extent_root->node) {
+		ret = -ENOENT;
+		goto out;
+	} else {
+		level++;
+		btrfs_release_path(NULL, &path);
+		goto again;
+	}
+
+del_ptr:
+	printk("deleting pointer to block %Lu\n", corrupt->cache.start);
+	ret = btrfs_del_ptr(trans, info->extent_root, &path, level, slot);
+
+out:
+	btrfs_release_path(NULL, &path);
+	return ret;
+}
+
+static int prune_corrupt_blocks(struct btrfs_trans_handle *trans,
+				struct btrfs_fs_info *info)
+{
+	struct cache_extent *cache;
+	struct btrfs_corrupt_block *corrupt;
+
+	cache = find_first_cache_extent(info->corrupt_blocks, 0);
+	while (1) {
+		if (!cache)
+			break;
+		corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
+		prune_one_block(trans, info, corrupt);
+		cache = next_cache_extent(cache);
+	}
+	return 0;
+}
+
+static void free_corrupt_blocks(struct btrfs_fs_info *info)
+{
+	struct cache_extent *cache;
+	struct btrfs_corrupt_block *corrupt;
+
+	while (1) {
+		cache = find_first_cache_extent(info->corrupt_blocks, 0);
+		if (!cache)
+			break;
+		corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
+		remove_cache_extent(info->corrupt_blocks, cache);
+		free(corrupt);
+	}
+}
+
+static int check_block_group(struct btrfs_trans_handle *trans,
+			      struct btrfs_fs_info *info,
+			      struct map_lookup *map,
+			      int *reinit)
+{
+	struct btrfs_key key;
+	struct btrfs_path path;
+	int ret;
+
+	key.objectid = map->ce.start;
+	key.offset = map->ce.size;
+	key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
+
+	btrfs_init_path(&path);
+	ret = btrfs_search_slot(NULL, info->extent_root,
+				&key, &path, 0, 0);
+	btrfs_release_path(NULL, &path);
+	if (ret <= 0)
+		goto out;
+
+	ret = btrfs_make_block_group(trans, info->extent_root, 0, map->type,
+			       BTRFS_FIRST_CHUNK_TREE_OBJECTID,
+			       key.objectid, key.offset);
+	*reinit = 1;
+out:
+	return ret;
+}
+
+static int check_block_groups(struct btrfs_trans_handle *trans,
+			      struct btrfs_fs_info *info, int *reinit)
+{
+	struct cache_extent *ce;
+	struct map_lookup *map;
+	struct btrfs_mapping_tree *map_tree = &info->mapping_tree;
+
+	/* this isn't quite working */
+	return 0;
+
+	ce = find_first_cache_extent(&map_tree->cache_tree, 0);
+	while (1) {
+		if (!ce)
+			break;
+		map = container_of(ce, struct map_lookup, ce);
+		check_block_group(trans, info, map, reinit);
+		ce = next_cache_extent(ce);
+	}
+	return 0;
+}
+
+static int check_extent_refs(struct btrfs_trans_handle *trans,
+			     struct btrfs_root *root,
+			     struct cache_tree *extent_cache, int repair)
 {
 	struct extent_record *rec;
 	struct cache_extent *cache;
 	int err = 0;
+	int ret = 0;
+	int fixed = 0;
+	int reinit = 0;
 
+	if (repair) {
+		/*
+		 * if we're doing a repair, we have to make sure
+		 * we don't allocate from the problem extents.
+		 * In the worst case, this will be all the
+		 * extents in the FS
+		 */
+		cache = find_first_cache_extent(extent_cache, 0);
+		while(cache) {
+			rec = container_of(cache, struct extent_record, cache);
+			btrfs_pin_extent(root->fs_info,
+					 rec->start, rec->max_size);
+			cache = next_cache_extent(cache);
+		}
+
+		/* pin down all the corrupted blocks too */
+		cache = find_first_cache_extent(root->fs_info->corrupt_blocks, 0);
+		while(cache) {
+			rec = container_of(cache, struct extent_record, cache);
+			btrfs_pin_extent(root->fs_info,
+					 rec->start, rec->max_size);
+			cache = next_cache_extent(cache);
+		}
+		prune_corrupt_blocks(trans, root->fs_info);
+		check_block_groups(trans, root->fs_info, &reinit);
+		if (reinit)
+			btrfs_read_block_groups(root->fs_info->extent_root);
+	}
 	while(1) {
+		fixed = 0;
 		cache = find_first_cache_extent(extent_cache, 0);
 		if (!cache)
 			break;
@@ -2690,19 +3242,39 @@
 			fprintf(stderr, "extent item %llu, found %llu\n",
 				(unsigned long long)rec->extent_item_refs,
 				(unsigned long long)rec->refs);
+			if (!fixed && repair) {
+				ret = fixup_extent_refs(trans, root->fs_info, rec);
+				if (ret)
+					goto repair_abort;
+				fixed = 1;
+			}
 			err = 1;
+
 		}
 		if (all_backpointers_checked(rec, 1)) {
 			fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
 				(unsigned long long)rec->start,
 				(unsigned long long)rec->nr);
 
+			if (!fixed && repair) {
+				ret = fixup_extent_refs(trans, root->fs_info, rec);
+				if (ret)
+					goto repair_abort;
+				fixed = 1;
+			}
+
 			err = 1;
 		}
 		if (!rec->owner_ref_checked) {
 			fprintf(stderr, "owner ref check failed [%llu %llu]\n",
 				(unsigned long long)rec->start,
 				(unsigned long long)rec->nr);
+			if (!fixed && repair) {
+				ret = fixup_extent_refs(trans, root->fs_info, rec);
+				if (ret)
+					goto repair_abort;
+				fixed = 1;
+			}
 			err = 1;
 		}
 
@@ -2710,16 +3282,30 @@
 		free_all_extent_backrefs(rec);
 		free(rec);
 	}
+repair_abort:
+	if (repair) {
+		if (ret) {
+			fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
+			exit(1);
+		} else {
+			btrfs_fix_block_accounting(trans, root);
+		}
+		if (err)
+			fprintf(stderr, "repaired damaged extent references\n");
+		return ret;
+	}
 	return err;
 }
 
-static int check_extents(struct btrfs_root *root)
+static int check_extents(struct btrfs_trans_handle *trans,
+			 struct btrfs_root *root, int repair)
 {
 	struct cache_tree extent_cache;
 	struct cache_tree seen;
 	struct cache_tree pending;
 	struct cache_tree reada;
 	struct cache_tree nodes;
+	struct cache_tree corrupt_blocks;
 	struct btrfs_path path;
 	struct btrfs_key key;
 	struct btrfs_key found_key;
@@ -2736,6 +3322,13 @@
 	cache_tree_init(&pending);
 	cache_tree_init(&nodes);
 	cache_tree_init(&reada);
+	cache_tree_init(&corrupt_blocks);
+
+	if (repair) {
+		root->fs_info->fsck_extent_cache = &extent_cache;
+		root->fs_info->free_extent_hook = free_extent_hook;
+		root->fs_info->corrupt_blocks = &corrupt_blocks;
+	}
 
 	bits_nr = 1024;
 	bits = malloc(bits_nr * sizeof(struct block_info));
@@ -2794,7 +3387,15 @@
 		if (ret != 0)
 			break;
 	}
-	ret = check_extent_refs(root, &extent_cache);
+	ret = check_extent_refs(trans, root, &extent_cache, repair);
+
+	if (repair) {
+		free_corrupt_blocks(root->fs_info);
+		root->fs_info->fsck_extent_cache = NULL;
+		root->fs_info->free_extent_hook = NULL;
+		root->fs_info->corrupt_blocks = NULL;
+	}
+
 	return ret;
 }
 
@@ -2805,17 +3406,32 @@
 	exit(1);
 }
 
+static struct option long_options[] = {
+	{ "super", 1, NULL, 's' },
+	{ "repair", 0, NULL, 0 },
+	{ "init-csum-tree", 0, NULL, 0 },
+	{ "init-extent-tree", 0, NULL, 0 },
+	{ 0, 0, 0, 0}
+};
+
 int main(int ac, char **av)
 {
 	struct cache_tree root_cache;
 	struct btrfs_root *root;
+	struct btrfs_fs_info *info;
+	struct btrfs_trans_handle *trans = NULL;
 	u64 bytenr = 0;
 	int ret;
 	int num;
+	int repair = 0;
+	int option_index = 0;
+	int init_csum_tree = 0;
+	int rw = 0;
 
 	while(1) {
 		int c;
-		c = getopt(ac, av, "s:");
+		c = getopt_long(ac, av, "a", long_options,
+				&option_index);
 		if (c < 0)
 			break;
 		switch(c) {
@@ -2825,9 +3441,21 @@
 				printf("using SB copy %d, bytenr %llu\n", num,
 				       (unsigned long long)bytenr);
 				break;
-			default:
+			case 'a':
+			    break;
+			case '?':
 				print_usage();
 		}
+		if (option_index == 1) {
+			printf("enabling repair mode\n");
+			repair = 1;
+			rw = 1;
+		} else if (option_index == 2) {
+			printf("Creating a new CRC tree\n");
+			init_csum_tree = 1;
+			rw = 1;
+		}
+
 	}
 	ac = ac - optind;
 
@@ -2845,25 +3473,55 @@
 		return -EBUSY;
 	}
 
-	root = open_ctree(av[optind], bytenr, 0);
+	info = open_ctree_fs_info(av[optind], bytenr, rw, 1);
 
-	if (root == NULL)
+	if (info == NULL)
 		return 1;
 
-	ret = check_extents(root);
-	if (ret)
+	if (!extent_buffer_uptodate(info->tree_root->node) ||
+	    !extent_buffer_uptodate(info->dev_root->node) ||
+	    !extent_buffer_uptodate(info->extent_root->node) ||
+	    !extent_buffer_uptodate(info->chunk_root->node)) {
+		fprintf(stderr, "Critical roots corrupted, unable to fsck the FS\n");
+		return -EIO;
+	}
+
+	root = info->fs_root;
+
+	fprintf(stderr, "checking extents\n");
+	if (rw)
+		trans = btrfs_start_transaction(root, 1);
+
+	if (init_csum_tree) {
+		fprintf(stderr, "Reinit crc root\n");
+		ret = btrfs_fsck_reinit_root(trans, info->csum_root);
+		if (ret) {
+			fprintf(stderr, "crc root initialization failed\n");
+			return -EIO;
+		}
 		goto out;
+	}
+	ret = check_extents(trans, root, repair);
+	if (ret)
+		fprintf(stderr, "Errors found in extent allocation tree\n");
+
+	fprintf(stderr, "checking fs roots\n");
 	ret = check_fs_roots(root, &root_cache);
 	if (ret)
 		goto out;
 
+	fprintf(stderr, "checking root refs\n");
 	ret = check_root_refs(root, &root_cache);
 out:
 	free_root_recs(&root_cache);
+	if (rw) {
+		ret = btrfs_commit_transaction(trans, root);
+		if (ret)
+			exit(1);
+	}
 	close_ctree(root);
 
-	if (found_old_backref) {
-		/*
+	if (found_old_backref) { /*
 		 * there was a disk format change when mixed
 		 * backref was in testing tree. The old format
 		 * existed about one week.
diff -Nru btrfs-tools-0.19+20111121/btrfs_cmds.c btrfs-tools-0.19+20120328/btrfs_cmds.c
--- btrfs-tools-0.19+20111121/btrfs_cmds.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/btrfs_cmds.c	1970-01-01 00:00:00.000000000 +0000
@@ -1,1307 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <libgen.h>
-#include <limits.h>
-#include <uuid/uuid.h>
-#include <ctype.h>
-
-#undef ULONG_MAX
-
-#include "kerncompat.h"
-#include "ctree.h"
-#include "transaction.h"
-#include "utils.h"
-#include "version.h"
-#include "ioctl.h"
-#include "volumes.h"
-
-#include "btrfs_cmds.h"
-#include "btrfslabel.h"
-
-#ifdef __CHECKER__
-#define BLKGETSIZE64 0
-#define BTRFS_IOC_SNAP_CREATE_V2 0
-#define BTRFS_VOL_NAME_MAX 255
-struct btrfs_ioctl_vol_args { char name[BTRFS_VOL_NAME_MAX]; };
-static inline int ioctl(int fd, int define, void *arg) { return 0; }
-#endif
-
-/*
- * test if path is a subvolume:
- * this function return
- * 0-> path exists but it is not a subvolume
- * 1-> path exists and it is  a subvolume
- * -1 -> path is unaccessible
- */
-static int test_issubvolume(char *path)
-{
-
-	struct stat	st;
-	int		res;
-
-	res = stat(path, &st);
-	if(res < 0 )
-		return -1;
-
-	return (st.st_ino == 256) && S_ISDIR(st.st_mode);
-
-}
-
-/*
- * test if path is a directory
- * this function return
- * 0-> path exists but it is not a directory
- * 1-> path exists and it is  a directory
- * -1 -> path is unaccessible
- */
-static int test_isdir(char *path)
-{
-	struct stat	st;
-	int		res;
-
-	res = stat(path, &st);
-	if(res < 0 )
-		return -1;
-
-	return S_ISDIR(st.st_mode);
-
-}
-
-int open_file_or_dir(const char *fname)
-{
-	int ret;
-	struct stat st;
-	DIR *dirstream;
-	int fd;
-
-	ret = stat(fname, &st);
-	if (ret < 0) {
-		return -1;
-	}
-	if (S_ISDIR(st.st_mode)) {
-		dirstream = opendir(fname);
-		if (!dirstream) {
-			return -2;
-		}
-		fd = dirfd(dirstream);
-	} else {
-		fd = open(fname, O_RDWR);
-	}
-	if (fd < 0) {
-		return -3;
-	}
-	return fd;
-}
-
-static u64 parse_size(char *s)
-{
-	int len = strlen(s);
-	char c;
-	u64 mult = 1;
-
-	if (!isdigit(s[len - 1])) {
-		c = tolower(s[len - 1]);
-		switch (c) {
-		case 'g':
-			mult *= 1024;
-		case 'm':
-			mult *= 1024;
-		case 'k':
-			mult *= 1024;
-		case 'b':
-			break;
-		default:
-			fprintf(stderr, "Unknown size descriptor %c\n", c);
-			exit(1);
-		}
-		s[len - 1] = '\0';
-	}
-	return atoll(s) * mult;
-}
-
-static int parse_compress_type(char *s)
-{
-	if (strcmp(optarg, "zlib") == 0)
-		return BTRFS_COMPRESS_ZLIB;
-	else if (strcmp(optarg, "lzo") == 0)
-		return BTRFS_COMPRESS_LZO;
-	else {
-		fprintf(stderr, "Unknown compress type %s\n", s);
-		exit(1);
-	};
-}
-
-int do_defrag(int ac, char **av)
-{
-	int fd;
-	int flush = 0;
-	u64 start = 0;
-	u64 len = (u64)-1;
-	u32 thresh = 0;
-	int i;
-	int errors = 0;
-	int ret = 0;
-	int verbose = 0;
-	int fancy_ioctl = 0;
-	struct btrfs_ioctl_defrag_range_args range;
-	int e=0;
-	int compress_type = BTRFS_COMPRESS_NONE;
-
-	optind = 1;
-	while(1) {
-		int c = getopt(ac, av, "vc::fs:l:t:");
-		if (c < 0)
-			break;
-		switch(c) {
-		case 'c':
-			compress_type = BTRFS_COMPRESS_ZLIB;
-			if (optarg)
-				compress_type = parse_compress_type(optarg);
-			fancy_ioctl = 1;
-			break;
-		case 'f':
-			flush = 1;
-			fancy_ioctl = 1;
-			break;
-		case 'v':
-			verbose = 1;
-			break;
-		case 's':
-			start = parse_size(optarg);
-			fancy_ioctl = 1;
-			break;
-		case 'l':
-			len = parse_size(optarg);
-			fancy_ioctl = 1;
-			break;
-		case 't':
-			thresh = parse_size(optarg);
-			fancy_ioctl = 1;
-			break;
-		default:
-			fprintf(stderr, "Invalid arguments for defragment\n");
-			free(av);
-			return 1;
-		}
-	}
-	if (ac - optind == 0) {
-		fprintf(stderr, "Invalid arguments for defragment\n");
-		free(av);
-		return 1;
-	}
-
-	memset(&range, 0, sizeof(range));
-	range.start = start;
-	range.len = len;
-	range.extent_thresh = thresh;
-	if (compress_type) {
-		range.flags |= BTRFS_DEFRAG_RANGE_COMPRESS;
-		range.compress_type = compress_type;
-	}
-	if (flush)
-		range.flags |= BTRFS_DEFRAG_RANGE_START_IO;
-
-	for (i = optind; i < ac; i++) {
-		if (verbose)
-			printf("%s\n", av[i]);
-		fd = open_file_or_dir(av[i]);
-		if (fd < 0) {
-			fprintf(stderr, "failed to open %s\n", av[i]);
-			perror("open:");
-			errors++;
-			continue;
-		}
-		if (!fancy_ioctl) {
-			ret = ioctl(fd, BTRFS_IOC_DEFRAG, NULL);
-			e=errno;
-		} else {
-			ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, &range);
-			if (ret && errno == ENOTTY) {
-				fprintf(stderr, "ERROR: defrag range ioctl not "
-					"supported in this kernel, please try "
-					"without any options.\n");
-				errors++;
-				close(fd);
-				break;
-			}
-		}
-		if (ret) {
-			fprintf(stderr, "ERROR: defrag failed on %s - %s\n",
-				av[i], strerror(e));
-			errors++;
-		}
-		close(fd);
-	}
-	if (verbose)
-		printf("%s\n", BTRFS_BUILD_VERSION);
-	if (errors) {
-		fprintf(stderr, "total %d failures\n", errors);
-		exit(1);
-	}
-
-	free(av);
-	return errors + 20;
-}
-
-int do_find_newer(int argc, char **argv)
-{
-	int fd;
-	int ret;
-	char *subvol;
-	u64 last_gen;
-
-	subvol = argv[1];
-	last_gen = atoll(argv[2]);
-
-	ret = test_issubvolume(subvol);
-	if (ret < 0) {
-		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
-		return 12;
-	}
-	if (!ret) {
-		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
-		return 13;
-	}
-
-	fd = open_file_or_dir(subvol);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
-		return 12;
-	}
-	ret = find_updated_files(fd, 0, last_gen);
-	if (ret)
-		return 19;
-	return 0;
-}
-
-int do_subvol_list(int argc, char **argv)
-{
-	int fd;
-	int ret;
-	int print_parent = 0;
-	char *subvol;
-        int optind = 1;
-
-	while(1) {
-		int c = getopt(argc, argv, "p");
-		if (c < 0) break;
-		switch(c) {
-		case 'p':
-			print_parent = 1;
-			optind++;
-			break;
-		}
-	}
-	
-	if (argc - optind != 1) {
-		fprintf(stderr, "ERROR: invalid arguments for subvolume list\n");
-		return 1;
-	}
-
-	subvol = argv[optind];
-
-	ret = test_issubvolume(subvol);
-	if (ret < 0) {
-		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
-		return 12;
-	}
-	if (!ret) {
-		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
-		return 13;
-	}
-
-	fd = open_file_or_dir(subvol);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
-		return 12;
-	}
-	ret = list_subvols(fd, print_parent, 0);
-	if (ret)
-		return 19;
-	return 0;
-}
-
-int do_clone(int argc, char **argv)
-{
-	char	*subvol, *dst;
-	int	res, fd, fddst, len, e, optind = 0, readonly = 0;
-	char	*newname;
-	char	*dstdir;
-	struct btrfs_ioctl_vol_args_v2	args;
-
-	memset(&args, 0, sizeof(args));
-
-	while (1) {
-		int c = getopt(argc, argv, "r");
-
-		if (c < 0)
-			break;
-		switch (c) {
-		case 'r':
-			optind++;
-			readonly = 1;
-			break;
-		default:
-			fprintf(stderr,
-				"Invalid arguments for subvolume snapshot\n");
-			free(argv);
-			return 1;
-		}
-	}
-	if (argc - optind != 3) {
-		fprintf(stderr, "Invalid arguments for subvolume snapshot\n");
-		free(argv);
-		return 1;
-	}
-
-	subvol = argv[optind+1];
-	dst = argv[optind+2];
-
-	res = test_issubvolume(subvol);
-	if(res<0){
-		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
-		return 12;
-	}
-	if(!res){
-		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
-		return 13;
-	}
-
-	res = test_isdir(dst);
-	if(res == 0 ){
-		fprintf(stderr, "ERROR: '%s' exists and it is not a directory\n", dst);
-		return 12;
-	}
-
-	if(res>0){
-		newname = strdup(subvol);
-		newname = basename(newname);
-		dstdir = dst;
-	}else{
-		newname = strdup(dst);
-		newname = basename(newname);
-		dstdir = strdup(dst);
-		dstdir = dirname(dstdir);
-	}
-
-	if( !strcmp(newname,".") || !strcmp(newname,"..") ||
-	     strchr(newname, '/') ){
-		fprintf(stderr, "ERROR: incorrect snapshot name ('%s')\n",
-			newname);
-		return 14;
-	}
-
-	len = strlen(newname);
-	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
-		fprintf(stderr, "ERROR: snapshot name too long ('%s)\n",
-			newname);
-		return 14;
-	}
-
-	fddst = open_file_or_dir(dstdir);
-	if (fddst < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
-		return 12;
-	}
-
-	fd = open_file_or_dir(subvol);
-	if (fd < 0) {
-		close(fddst);
-		fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
-		return 12;
-	}
-
-	if (readonly) {
-		args.flags |= BTRFS_SUBVOL_RDONLY;
-		printf("Create a readonly snapshot of '%s' in '%s/%s'\n",
-		       subvol, dstdir, newname);
-	} else {
-		printf("Create a snapshot of '%s' in '%s/%s'\n",
-		       subvol, dstdir, newname);
-	}
-
-	args.fd = fd;
-	strncpy(args.name, newname, BTRFS_SUBVOL_NAME_MAX);
-	res = ioctl(fddst, BTRFS_IOC_SNAP_CREATE_V2, &args);
-	e = errno;
-
-	close(fd);
-	close(fddst);
-
-	if(res < 0 ){
-		fprintf( stderr, "ERROR: cannot snapshot '%s' - %s\n",
-			subvol, strerror(e));
-		return 11;
-	}
-
-	return 0;
-
-}
-
-int do_delete_subvolume(int argc, char **argv)
-{
-	int	res, fd, len, e;
-	struct btrfs_ioctl_vol_args	args;
-	char	*dname, *vname, *cpath;
-	char	*path = argv[1];
-
-	res = test_issubvolume(path);
-	if(res<0){
-		fprintf(stderr, "ERROR: error accessing '%s'\n", path);
-		return 12;
-	}
-	if(!res){
-		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", path);
-		return 13;
-	}
-
-	cpath = realpath(path, 0);
-	dname = strdup(cpath);
-	dname = dirname(dname);
-	vname = strdup(cpath);
-	vname = basename(vname);
-	free(cpath);
-
-	if( !strcmp(vname,".") || !strcmp(vname,"..") ||
-	     strchr(vname, '/') ){
-		fprintf(stderr, "ERROR: incorrect subvolume name ('%s')\n",
-			vname);
-		return 14;
-	}
-
-	len = strlen(vname);
-	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
-		fprintf(stderr, "ERROR: snapshot name too long ('%s)\n",
-			vname);
-		return 14;
-	}
-
-	fd = open_file_or_dir(dname);
-	if (fd < 0) {
-		close(fd);
-		fprintf(stderr, "ERROR: can't access to '%s'\n", dname);
-		return 12;
-	}
-
-	printf("Delete subvolume '%s/%s'\n", dname, vname);
-	strncpy(args.name, vname, BTRFS_PATH_NAME_MAX);
-	res = ioctl(fd, BTRFS_IOC_SNAP_DESTROY, &args);
-	e = errno;
-
-	close(fd);
-
-	if(res < 0 ){
-		fprintf( stderr, "ERROR: cannot delete '%s/%s' - %s\n",
-			dname, vname, strerror(e));
-		return 11;
-	}
-
-	return 0;
-
-}
-
-int do_create_subvol(int argc, char **argv)
-{
-	int	res, fddst, len, e;
-	char	*newname;
-	char	*dstdir;
-	struct btrfs_ioctl_vol_args	args;
-	char	*dst = argv[1];
-
-	res = test_isdir(dst);
-	if(res >= 0 ){
-		fprintf(stderr, "ERROR: '%s' exists\n", dst);
-		return 12;
-	}
-
-	newname = strdup(dst);
-	newname = basename(newname);
-	dstdir = strdup(dst);
-	dstdir = dirname(dstdir);
-
-	if( !strcmp(newname,".") || !strcmp(newname,"..") ||
-	     strchr(newname, '/') ){
-		fprintf(stderr, "ERROR: uncorrect subvolume name ('%s')\n",
-			newname);
-		return 14;
-	}
-
-	len = strlen(newname);
-	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
-		fprintf(stderr, "ERROR: subvolume name too long ('%s)\n",
-			newname);
-		return 14;
-	}
-
-	fddst = open_file_or_dir(dstdir);
-	if (fddst < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
-		return 12;
-	}
-
-	printf("Create subvolume '%s/%s'\n", dstdir, newname);
-	strncpy(args.name, newname, BTRFS_PATH_NAME_MAX);
-	res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE, &args);
-	e = errno;
-
-	close(fddst);
-
-	if(res < 0 ){
-		fprintf( stderr, "ERROR: cannot create subvolume - %s\n",
-			strerror(e));
-		return 11;
-	}
-
-	return 0;
-
-}
-
-int do_fssync(int argc, char **argv)
-{
-	int 	fd, res, e;
-	char	*path = argv[1];
-
-	fd = open_file_or_dir(path);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
-		return 12;
-	}
-
-	printf("FSSync '%s'\n", path);
-	res = ioctl(fd, BTRFS_IOC_SYNC);
-	e = errno;
-	close(fd);
-	if( res < 0 ){
-		fprintf(stderr, "ERROR: unable to fs-syncing '%s' - %s\n", 
-			path, strerror(e));
-		return 16;
-	}
-
-	return 0;
-}
-
-int do_scan(int argc, char **argv)
-{
-	int	i, fd, e;
-	int	checklist = 1;
-	int	devstart = 1;
-
-	if( argc >= 2 && !strcmp(argv[1],"--all-devices")){
-
-		if( argc >2 ){
-			fprintf(stderr, "ERROR: too may arguments\n");
-                        return 22;
-                }
-
-		checklist = 0;
-		devstart += 1;
-	}
-
-	if(argc<=devstart){
-
-		int ret;
-
-		printf("Scanning for Btrfs filesystems\n");
-		if(checklist)
-			ret = btrfs_scan_block_devices(1);
-		else
-			ret = btrfs_scan_one_dir("/dev", 1);
-		if (ret){
-			fprintf(stderr, "ERROR: error %d while scanning\n", ret);
-			return 18;
-		}
-		return 0;
-	}
-
-	fd = open("/dev/btrfs-control", O_RDWR);
-	if (fd < 0) {
-		perror("failed to open /dev/btrfs-control");
-		return 10;
-	}
-
-	for( i = devstart ; i < argc ; i++ ){
-		struct btrfs_ioctl_vol_args args;
-		int ret;
-
-		printf("Scanning for Btrfs filesystems in '%s'\n", argv[i]);
-
-		strncpy(args.name, argv[i], BTRFS_PATH_NAME_MAX);
-		/*
-		 * FIXME: which are the error code returned by this ioctl ?
-		 * it seems that is impossible to understand if there no is
-		 * a btrfs filesystem from an I/O error !!!
-		 */
-		ret = ioctl(fd, BTRFS_IOC_SCAN_DEV, &args);
-		e = errno;
-
-		if( ret < 0 ){
-			close(fd);
-			fprintf(stderr, "ERROR: unable to scan the device '%s' - %s\n", 
-				argv[i], strerror(e));
-			return 11;
-		}
-	}
-
-	close(fd);
-	return 0;
-
-}
-
-int do_resize(int argc, char **argv)
-{
-
-	struct btrfs_ioctl_vol_args	args;
-	int	fd, res, len, e;
-	char	*amount=argv[1], *path=argv[2];
-
-	fd = open_file_or_dir(path);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
-		return 12;
-	}
-	len = strlen(amount);
-	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
-		fprintf(stderr, "ERROR: size value too long ('%s)\n",
-			amount);
-		return 14;
-	}
-
-	printf("Resize '%s' of '%s'\n", path, amount);
-	strncpy(args.name, amount, BTRFS_PATH_NAME_MAX);
-	res = ioctl(fd, BTRFS_IOC_RESIZE, &args);
-	e = errno;
-	close(fd);
-	if( res < 0 ){
-		fprintf(stderr, "ERROR: unable to resize '%s' - %s\n", 
-			path, strerror(e));
-		return 30;
-	}
-	return 0;
-}
-
-static int uuid_search(struct btrfs_fs_devices *fs_devices, char *search)
-{
-	struct list_head *cur;
-	struct btrfs_device *device;
-
-	list_for_each(cur, &fs_devices->devices) {
-		device = list_entry(cur, struct btrfs_device, dev_list);
-		if ((device->label && strcmp(device->label, search) == 0) ||
-		    strcmp(device->name, search) == 0)
-			return 1;
-	}
-	return 0;
-}
-
-static void print_one_uuid(struct btrfs_fs_devices *fs_devices)
-{
-	char uuidbuf[37];
-	struct list_head *cur;
-	struct btrfs_device *device;
-	char *super_bytes_used;
-	u64 devs_found = 0;
-	u64 total;
-
-	uuid_unparse(fs_devices->fsid, uuidbuf);
-	device = list_entry(fs_devices->devices.next, struct btrfs_device,
-			    dev_list);
-	if (device->label && device->label[0])
-		printf("Label: '%s' ", device->label);
-	else
-		printf("Label: none ");
-
-	super_bytes_used = pretty_sizes(device->super_bytes_used);
-
-	total = device->total_devs;
-	printf(" uuid: %s\n\tTotal devices %llu FS bytes used %s\n", uuidbuf,
-	       (unsigned long long)total, super_bytes_used);
-
-	free(super_bytes_used);
-
-	list_for_each(cur, &fs_devices->devices) {
-		char *total_bytes;
-		char *bytes_used;
-		device = list_entry(cur, struct btrfs_device, dev_list);
-		total_bytes = pretty_sizes(device->total_bytes);
-		bytes_used = pretty_sizes(device->bytes_used);
-		printf("\tdevid %4llu size %s used %s path %s\n",
-		       (unsigned long long)device->devid,
-		       total_bytes, bytes_used, device->name);
-		free(total_bytes);
-		free(bytes_used);
-		devs_found++;
-	}
-	if (devs_found < total) {
-		printf("\t*** Some devices missing\n");
-	}
-	printf("\n");
-}
-
-int do_show_filesystem(int argc, char **argv)
-{
-	struct list_head *all_uuids;
-	struct btrfs_fs_devices *fs_devices;
-	struct list_head *cur_uuid;
-	char *search = 0;
-	int ret;
-	int checklist = 1;
-	int searchstart = 1;
-
-	if( argc >= 2 && !strcmp(argv[1],"--all-devices")){
-		checklist = 0;
-		searchstart += 1;
-	}
-
-	if( argc > searchstart+1 ){
-		fprintf(stderr, "ERROR: too many arguments\n");
-		return 22;
-	}	
-
-	if(checklist)
-		ret = btrfs_scan_block_devices(0);
-	else
-		ret = btrfs_scan_one_dir("/dev", 0);
-
-	if (ret){
-		fprintf(stderr, "ERROR: error %d while scanning\n", ret);
-		return 18;
-	}
-	
-	if(searchstart < argc)
-		search = argv[searchstart];
-
-	all_uuids = btrfs_scanned_uuids();
-	list_for_each(cur_uuid, all_uuids) {
-		fs_devices = list_entry(cur_uuid, struct btrfs_fs_devices,
-					list);
-		if (search && uuid_search(fs_devices, search) == 0)
-			continue;
-		print_one_uuid(fs_devices);
-	}
-	printf("%s\n", BTRFS_BUILD_VERSION);
-	return 0;
-}
-
-int do_add_volume(int nargs, char **args)
-{
-
-	char	*mntpnt = args[nargs-1];
-	int	i, fdmnt, ret=0, e;
-
-
-	fdmnt = open_file_or_dir(mntpnt);
-	if (fdmnt < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", mntpnt);
-		return 12;
-	}
-
-	for (i = 1; i < (nargs-1); i++ ){
-		struct btrfs_ioctl_vol_args ioctl_args;
-		int	devfd, res;
-		u64 dev_block_count = 0;
-		struct stat st;
-		int mixed = 0;
-
-		res = check_mounted(args[i]);
-		if (res < 0) {
-			fprintf(stderr, "error checking %s mount status\n",
-				args[i]);
-			ret++;
-			continue;
-		}
-		if (res == 1) {
-			fprintf(stderr, "%s is mounted\n", args[i]);
-			ret++;
-			continue;
-		}
-
-		devfd = open(args[i], O_RDWR);
-		if (!devfd) {
-			fprintf(stderr, "ERROR: Unable to open device '%s'\n", args[i]);
-			close(devfd);
-			ret++;
-			continue;
-		}
-		res = fstat(devfd, &st);
-		if (res) {
-			fprintf(stderr, "ERROR: Unable to stat '%s'\n", args[i]);
-			close(devfd);
-			ret++;
-			continue;
-		}
-		if (!S_ISBLK(st.st_mode)) {
-			fprintf(stderr, "ERROR: '%s' is not a block device\n", args[i]);
-			close(devfd);
-			ret++;
-			continue;
-		}
-
-		res = btrfs_prepare_device(devfd, args[i], 1, &dev_block_count, &mixed);
-		if (res) {
-			fprintf(stderr, "ERROR: Unable to init '%s'\n", args[i]);
-			close(devfd);
-			ret++;
-			continue;
-		}
-		close(devfd);
-
-		strncpy(ioctl_args.name, args[i], BTRFS_PATH_NAME_MAX);
-		res = ioctl(fdmnt, BTRFS_IOC_ADD_DEV, &ioctl_args);
-		e = errno;
-		if(res<0){
-			fprintf(stderr, "ERROR: error adding the device '%s' - %s\n", 
-				args[i], strerror(e));
-			ret++;
-		}
-
-	}
-
-	close(fdmnt);
-	if (ret)
-		return ret+20;
-	else
-		return 0;
-
-}
-
-int do_balance(int argc, char **argv)
-{
-
-	int	fdmnt, ret=0, e;
-	struct btrfs_ioctl_vol_args args;
-	char	*path = argv[1];
-
-	fdmnt = open_file_or_dir(path);
-	if (fdmnt < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
-		return 12;
-	}
-
-	memset(&args, 0, sizeof(args));
-	ret = ioctl(fdmnt, BTRFS_IOC_BALANCE, &args);
-	e = errno;
-	close(fdmnt);
-	if(ret<0){
-		fprintf(stderr, "ERROR: error during balancing '%s' - %s\n", 
-			path, strerror(e));
-
-		return 19;
-	}
-	return 0;
-}
-int do_remove_volume(int nargs, char **args)
-{
-
-	char	*mntpnt = args[nargs-1];
-	int	i, fdmnt, ret=0, e;
-
-	fdmnt = open_file_or_dir(mntpnt);
-	if (fdmnt < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", mntpnt);
-		return 12;
-	}
-
-	for(i=1 ; i < (nargs-1) ; i++ ){
-		struct	btrfs_ioctl_vol_args arg;
-		int	res;
-
-		strncpy(arg.name, args[i], BTRFS_PATH_NAME_MAX);
-		res = ioctl(fdmnt, BTRFS_IOC_RM_DEV, &arg);
-		e = errno;
-		if(res<0){
-			fprintf(stderr, "ERROR: error removing the device '%s' - %s\n", 
-				args[i], strerror(e));
-			ret++;
-		}
-	}
-
-	close(fdmnt);
-	if( ret)
-		return ret+20;
-	else
-		return 0;
-}
-
-int do_set_default_subvol(int nargs, char **argv)
-{
-	int	ret=0, fd, e;
-	u64	objectid;
-	char	*path = argv[2];
-	char	*subvolid = argv[1];
-
-	fd = open_file_or_dir(path);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
-		return 12;
-	}
-
-	objectid = (unsigned long long)strtoll(subvolid, NULL, 0);
-	if (errno == ERANGE) {
-		fprintf(stderr, "ERROR: invalid tree id (%s)\n",subvolid);
-		return 30;
-	}
-	ret = ioctl(fd, BTRFS_IOC_DEFAULT_SUBVOL, &objectid);
-	e = errno;
-	close(fd);
-	if( ret < 0 ){
-		fprintf(stderr, "ERROR: unable to set a new default subvolume - %s\n",
-			strerror(e));
-		return 30;
-	}
-	return 0;
-}
-
-int do_change_label(int nargs, char **argv)
-{
-	/* check the number of argument */
-	if ( nargs > 3 ){
-		fprintf(stderr, "ERROR: '%s' requires maximum 2 args\n",
-			argv[0]);
-		return -2;
-	}else if (nargs == 2){
-		return get_label(argv[1]);
-	} else {	/* nargs == 0 */
-		return set_label(argv[1], argv[2]);
-	}
-}
-
-
-int do_get_default_subvol(int nargs, char **argv)
-{
-	int fd;
-	int ret;
-	char *subvol;
-
-	subvol = argv[1];
-
-	ret = test_issubvolume(subvol);
-	if (ret < 0) {
-		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
-		return 12;
-	}
-	if (!ret) {
-		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
-		return 13;
-	}
-
-	fd = open_file_or_dir(subvol);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
-		return 12;
-	}
-	ret = list_subvols(fd, 0, 1);
-	if (ret)
-		return 19;
-	return 0;
-}
-
-int do_df_filesystem(int nargs, char **argv)
-{
-	struct btrfs_ioctl_space_args *sargs;
-	u64 count = 0, i;
-	int ret;
-	int fd;
-	int e;
-	char *path = argv[1];
-
-	fd = open_file_or_dir(path);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
-		return 12;
-	}
-
-	sargs = malloc(sizeof(struct btrfs_ioctl_space_args));
-	if (!sargs)
-		return -ENOMEM;
-
-	sargs->space_slots = 0;
-	sargs->total_spaces = 0;
-
-	ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs);
-	e = errno;
-	if (ret) {
-		fprintf(stderr, "ERROR: couldn't get space info on '%s' - %s\n",
-			path, strerror(e));
-		free(sargs);
-		return ret;
-	}
-	if (!sargs->total_spaces)
-		return 0;
-
-	count = sargs->total_spaces;
-
-	sargs = realloc(sargs, sizeof(struct btrfs_ioctl_space_args) +
-			(count * sizeof(struct btrfs_ioctl_space_info)));
-	if (!sargs)
-		return -ENOMEM;
-
-	sargs->space_slots = count;
-	sargs->total_spaces = 0;
-
-	ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs);
-	e = errno;
-	if (ret) {
-		fprintf(stderr, "ERROR: couldn't get space info on '%s' - %s\n",
-			path, strerror(e));
-		close(fd);
-		free(sargs);
-		return ret;
-	}
-
-	for (i = 0; i < sargs->total_spaces; i++) {
-		char description[80];
-		char *total_bytes;
-		char *used_bytes;
-		int written = 0;
-		u64 flags = sargs->spaces[i].flags;
-
-		memset(description, 0, 80);
-
-		if (flags & BTRFS_BLOCK_GROUP_DATA) {
-			if (flags & BTRFS_BLOCK_GROUP_METADATA) {
-				snprintf(description, 14, "%s",
-					 "Data+Metadata");
-				written += 13;
-			} else {
-				snprintf(description, 5, "%s", "Data");
-				written += 4;
-			}
-		} else if (flags & BTRFS_BLOCK_GROUP_SYSTEM) {
-			snprintf(description, 7, "%s", "System");
-			written += 6;
-		} else if (flags & BTRFS_BLOCK_GROUP_METADATA) {
-			snprintf(description, 9, "%s", "Metadata");
-			written += 8;
-		}
-
-		if (flags & BTRFS_BLOCK_GROUP_RAID0) {
-			snprintf(description+written, 8, "%s", ", RAID0");
-			written += 7;
-		} else if (flags & BTRFS_BLOCK_GROUP_RAID1) {
-			snprintf(description+written, 8, "%s", ", RAID1");
-			written += 7;
-		} else if (flags & BTRFS_BLOCK_GROUP_DUP) {
-			snprintf(description+written, 6, "%s", ", DUP");
-			written += 5;
-		} else if (flags & BTRFS_BLOCK_GROUP_RAID10) {
-			snprintf(description+written, 9, "%s", ", RAID10");
-			written += 8;
-		}
-
-		total_bytes = pretty_sizes(sargs->spaces[i].total_bytes);
-		used_bytes = pretty_sizes(sargs->spaces[i].used_bytes);
-		printf("%s: total=%s, used=%s\n", description, total_bytes,
-		       used_bytes);
-	}
-	free(sargs);
-
-	return 0;
-}
-
-static int __ino_to_path_fd(u64 inum, int fd, int verbose, const char *prepend)
-{
-	int ret;
-	int i;
-	struct btrfs_ioctl_ino_path_args ipa;
-	struct btrfs_data_container *fspath;
-
-	fspath = malloc(4096);
-	if (!fspath)
-		return 1;
-
-	ipa.inum = inum;
-	ipa.size = 4096;
-	ipa.fspath = (u64)fspath;
-
-	ret = ioctl(fd, BTRFS_IOC_INO_PATHS, &ipa);
-	if (ret) {
-		printf("ioctl ret=%d, error: %s\n", ret, strerror(errno));
-		goto out;
-	}
-
-	if (verbose)
-		printf("ioctl ret=%d, bytes_left=%lu, bytes_missing=%lu, "
-			"cnt=%d, missed=%d\n", ret,
-			(unsigned long)fspath->bytes_left,
-			(unsigned long)fspath->bytes_missing,
-			fspath->elem_cnt, fspath->elem_missed);
-
-	for (i = 0; i < fspath->elem_cnt; ++i) {
-		char **str = (char **)fspath->val;
-		str[i] += (unsigned long)fspath->val;
-		if (prepend)
-			printf("%s/%s\n", prepend, str[i]);
-		else
-			printf("%s\n", str[i]);
-	}
-
-out:
-	free(fspath);
-	return ret;
-}
-
-int do_ino_to_path(int nargs, char **argv)
-{
-	int fd;
-	int verbose = 0;
-
-	optind = 1;
-	while (1) {
-		int c = getopt(nargs, argv, "v");
-		if (c < 0)
-			break;
-		switch (c) {
-		case 'v':
-			verbose = 1;
-			break;
-		default:
-			fprintf(stderr, "invalid arguments for ipath\n");
-			return 1;
-		}
-	}
-	if (nargs - optind != 2) {
-		fprintf(stderr, "invalid arguments for ipath\n");
-		return 1;
-	}
-
-	fd = open_file_or_dir(argv[optind+1]);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access '%s'\n", argv[optind+1]);
-		return 12;
-	}
-
-	return __ino_to_path_fd(atoll(argv[optind]), fd, verbose,
-				argv[optind+1]);
-}
-
-int do_logical_to_ino(int nargs, char **argv)
-{
-	int ret;
-	int fd;
-	int i;
-	int verbose = 0;
-	int getpath = 1;
-	int bytes_left;
-	struct btrfs_ioctl_logical_ino_args loi;
-	struct btrfs_data_container *inodes;
-	char full_path[4096];
-	char *path_ptr;
-
-	optind = 1;
-	while (1) {
-		int c = getopt(nargs, argv, "Pv");
-		if (c < 0)
-			break;
-		switch (c) {
-		case 'P':
-			getpath = 0;
-			break;
-		case 'v':
-			verbose = 1;
-			break;
-		default:
-			fprintf(stderr, "invalid arguments for ipath\n");
-			return 1;
-		}
-	}
-	if (nargs - optind != 2) {
-		fprintf(stderr, "invalid arguments for ipath\n");
-		return 1;
-	}
-
-	inodes = malloc(4096);
-	if (!inodes)
-		return 1;
-
-	loi.logical = atoll(argv[optind]);
-	loi.size = 4096;
-	loi.inodes = (u64)inodes;
-
-	fd = open_file_or_dir(argv[optind+1]);
-	if (fd < 0) {
-		fprintf(stderr, "ERROR: can't access '%s'\n", argv[optind+1]);
-		ret = 12;
-		goto out;
-	}
-
-	ret = ioctl(fd, BTRFS_IOC_LOGICAL_INO, &loi);
-	if (ret) {
-		printf("ioctl ret=%d, error: %s\n", ret, strerror(errno));
-		goto out;
-	}
-
-	if (verbose)
-		printf("ioctl ret=%d, bytes_left=%lu, bytes_missing=%lu, "
-			"cnt=%d, missed=%d\n", ret,
-			(unsigned long)inodes->bytes_left,
-			(unsigned long)inodes->bytes_missing,
-			inodes->elem_cnt, inodes->elem_missed);
-
-	bytes_left = sizeof(full_path);
-	ret = snprintf(full_path, bytes_left, "%s/", argv[optind+1]);
-	path_ptr = full_path + ret;
-	bytes_left -= ret + 1;
-	BUG_ON(bytes_left < 0);
-
-	for (i = 0; i < inodes->elem_cnt; i += 3) {
-		u64 inum = inodes->val[i];
-		u64 offset = inodes->val[i+1];
-		u64 root = inodes->val[i+2];
-		int path_fd;
-		char *name;
-
-		if (getpath) {
-			name = path_for_root(fd, root);
-			if (IS_ERR(name))
-				return PTR_ERR(name);
-			if (!name) {
-				path_ptr[-1] = '\0';
-				path_fd = fd;
-			} else {
-				path_ptr[-1] = '/';
-				ret = snprintf(path_ptr, bytes_left, "%s",
-						name);
-				BUG_ON(ret >= bytes_left);
-				free(name);
-				path_fd = open_file_or_dir(full_path);
-				if (path_fd < 0) {
-					fprintf(stderr, "ERROR: can't access "
-						"'%s'\n", full_path);
-					goto out;
-				}
-			}
-			__ino_to_path_fd(inum, path_fd, verbose, full_path);
-		} else {
-			printf("inode %llu offset %llu root %llu\n", inum,
-				offset, root);
-		}
-	}
-
-out:
-	free(inodes);
-	return ret;
-}
diff -Nru btrfs-tools-0.19+20111121/btrfs_cmds.h btrfs-tools-0.19+20120328/btrfs_cmds.h
--- btrfs-tools-0.19+20111121/btrfs_cmds.h	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/btrfs_cmds.h	1970-01-01 00:00:00.000000000 +0000
@@ -1,44 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
-
-/* btrfs_cmds.c*/
-int do_clone(int nargs, char **argv);
-int do_delete_subvolume(int nargs, char **argv);
-int do_create_subvol(int nargs, char **argv);
-int do_fssync(int nargs, char **argv);
-int do_defrag(int argc, char **argv);
-int do_show_filesystem(int nargs, char **argv);
-int do_add_volume(int nargs, char **args);
-int do_balance(int nargs, char **argv);
-int do_scrub_start(int nargs, char **argv);
-int do_scrub_status(int argc, char **argv);
-int do_scrub_resume(int argc, char **argv);
-int do_scrub_cancel(int nargs, char **argv);
-int do_remove_volume(int nargs, char **args);
-int do_scan(int nargs, char **argv);
-int do_resize(int nargs, char **argv);
-int do_subvol_list(int nargs, char **argv);
-int do_set_default_subvol(int nargs, char **argv);
-int do_get_default_subvol(int nargs, char **argv);
-int list_subvols(int fd, int print_parent, int get_default);
-int do_df_filesystem(int nargs, char **argv);
-int find_updated_files(int fd, u64 root_id, u64 oldest_gen);
-int do_find_newer(int argc, char **argv);
-int do_change_label(int argc, char **argv);
-int open_file_or_dir(const char *fname);
-int do_ino_to_path(int nargs, char **argv);
-int do_logical_to_ino(int nargs, char **argv);
-char *path_for_root(int fd, u64 root);
diff -Nru btrfs-tools-0.19+20111121/btrfs-corrupt-block.c btrfs-tools-0.19+20120328/btrfs-corrupt-block.c
--- btrfs-tools-0.19+20111121/btrfs-corrupt-block.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/btrfs-corrupt-block.c	2012-05-05 18:22:58.000000000 +0000
@@ -32,11 +32,6 @@
 #include "list.h"
 #include "version.h"
 
-/* we write the mirror info to stdout unless they are dumping the data
- * to stdout
- * */
-static FILE *info_file;
-
 struct extent_buffer *debug_corrupt_block(struct btrfs_root *root, u64 bytenr,
 				     u32 blocksize, int copy)
 {
@@ -62,7 +57,7 @@
 		device->total_ios++;
 		eb->dev_bytenr = multi->stripes[0].physical;
 
-		fprintf(info_file, "mirror %d logical %Lu physical %Lu "
+		fprintf(stdout, "mirror %d logical %Lu physical %Lu "
 			"device %s\n", mirror_num, (unsigned long long)bytenr,
 			(unsigned long long)eb->dev_bytenr, device->name);
 		kfree(multi);
@@ -98,32 +93,210 @@
 	exit(1);
 }
 
+static void corrupt_keys(struct btrfs_trans_handle *trans,
+			 struct btrfs_root *root,
+			 struct extent_buffer *eb)
+{
+	int slot;
+	int bad_slot;
+	int nr;
+	struct btrfs_disk_key bad_key;;
+
+	nr = btrfs_header_nritems(eb);
+	if (nr == 0)
+		return;
+
+	slot = rand() % nr;
+	bad_slot = rand() % nr;
+
+	if (bad_slot == slot)
+		return;
+
+	fprintf(stderr, "corrupting keys in block %llu slot %d swapping with %d\n",
+		(unsigned long long)eb->start, slot, bad_slot);
+
+	if (btrfs_header_level(eb) == 0) {
+		btrfs_item_key(eb, &bad_key, bad_slot);
+		btrfs_set_item_key(eb, &bad_key, slot);
+	} else {
+		btrfs_node_key(eb, &bad_key, bad_slot);
+		btrfs_set_node_key(eb, &bad_key, slot);
+	}
+	btrfs_mark_buffer_dirty(eb);
+	if (!trans) {
+		csum_tree_block(root, eb, 0);
+		write_extent_to_disk(eb);
+	}
+}
+
+
+static int corrupt_keys_in_block(struct btrfs_root *root, u64 bytenr)
+{
+	struct extent_buffer *eb;
+
+	eb = read_tree_block(root, bytenr, root->leafsize, 0);
+	if (!eb)
+		return -EIO;;
+
+	corrupt_keys(NULL, root, eb);
+	free_extent_buffer(eb);
+	return 0;
+}
+
+static int corrupt_extent(struct btrfs_trans_handle *trans,
+			  struct btrfs_root *root, u64 bytenr, int copy)
+{
+	struct btrfs_key key;
+	struct extent_buffer *leaf;
+	u32 item_size;
+	unsigned long ptr;
+	struct btrfs_path *path;
+	int ret;
+	int slot;
+	int should_del = rand() % 3;
+
+	path = btrfs_alloc_path();
+
+	key.objectid = bytenr;
+	key.type = (u8)-1;
+	key.offset = (u64)-1;
+
+	while(1) {
+		ret = btrfs_search_slot(trans, root->fs_info->extent_root,
+					&key, path, -1, 1);
+		if (ret < 0)
+			break;
+
+		if (ret > 0) {
+			if (path->slots[0] == 0)
+				break;
+			path->slots[0]--;
+			ret = 0;
+		}
+		leaf = path->nodes[0];
+		slot = path->slots[0];
+		btrfs_item_key_to_cpu(leaf, &key, slot);
+		if (key.objectid != bytenr)
+			break;
+
+		if (key.type != BTRFS_EXTENT_ITEM_KEY &&
+		    key.type != BTRFS_TREE_BLOCK_REF_KEY &&
+		    key.type != BTRFS_EXTENT_DATA_REF_KEY &&
+		    key.type != BTRFS_EXTENT_REF_V0_KEY &&
+		    key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
+		    key.type != BTRFS_SHARED_DATA_REF_KEY)
+			goto next;
+
+		if (should_del) {
+			fprintf(stderr, "deleting extent record: key %Lu %u %Lu\n",
+				key.objectid, key.type, key.offset);
+
+			if (key.type == BTRFS_EXTENT_ITEM_KEY) {
+				/* make sure this extent doesn't get
+				 * reused for other purposes */
+				btrfs_pin_extent(root->fs_info,
+						 key.objectid, key.offset);
+			}
+
+			btrfs_del_item(trans, root, path);
+		} else {
+			fprintf(stderr, "corrupting extent record: key %Lu %u %Lu\n",
+				key.objectid, key.type, key.offset);
+			ptr = btrfs_item_ptr_offset(leaf, slot);
+			item_size = btrfs_item_size_nr(leaf, slot);
+			memset_extent_buffer(leaf, 0, ptr, item_size);
+			btrfs_mark_buffer_dirty(leaf);
+		}
+next:
+		btrfs_release_path(NULL, path);
+
+		if (key.offset > 0)
+			key.offset--;
+		if (key.offset == 0)
+			break;
+	}
+
+	btrfs_free_path(path);
+	return 0;
+}
+
+static void btrfs_corrupt_extent_leaf(struct btrfs_trans_handle *trans,
+				      struct btrfs_root *root, struct extent_buffer *eb)
+{
+	u32 nr = btrfs_header_nritems(eb);
+	u32 victim = rand() % nr;
+	u64 objectid;
+	struct btrfs_key key;
+
+	btrfs_item_key_to_cpu(eb, &key, victim);
+	objectid = key.objectid;
+	corrupt_extent(trans, root, objectid, 1);
+}
+
+static void btrfs_corrupt_extent_tree(struct btrfs_trans_handle *trans,
+				      struct btrfs_root *root, struct extent_buffer *eb)
+{
+	int i;
+	u32 nr;
+
+	if (!eb)
+		return;
+
+	nr = btrfs_header_nritems(eb);
+	if (btrfs_is_leaf(eb)) {
+		btrfs_corrupt_extent_leaf(trans, root, eb);
+		return;
+	}
+
+	if (btrfs_header_level(eb) == 1 && eb != root->node) {
+		if (rand() % 5)
+			return;
+	}
+
+	for (i = 0; i < nr; i++) {
+		struct extent_buffer *next;
+
+		next = read_tree_block(root, btrfs_node_blockptr(eb, i),
+				       root->leafsize, btrfs_node_ptr_generation(eb, i));
+		if (!next)
+			continue;
+		btrfs_corrupt_extent_tree(trans, root, next);
+		free_extent_buffer(next);
+	}
+}
+
 static struct option long_options[] = {
 	/* { "byte-count", 1, NULL, 'b' }, */
 	{ "logical", 1, NULL, 'l' },
 	{ "copy", 1, NULL, 'c' },
 	{ "bytes", 1, NULL, 'b' },
+	{ "extent-record", 0, NULL, 'e' },
+	{ "extent-tree", 0, NULL, 'E' },
+	{ "keys", 0, NULL, 'k' },
 	{ 0, 0, 0, 0}
 };
 
+
 int main(int ac, char **av)
 {
 	struct cache_tree root_cache;
 	struct btrfs_root *root;
 	struct extent_buffer *eb;
 	char *dev;
-	char *output_file = NULL;
 	u64 logical = 0;
 	int ret = 0;
 	int option_index = 0;
 	int copy = 0;
 	u64 bytes = 4096;
-	int out_fd = 0;
-	int err;
+	int extent_rec = 0;
+	int extent_tree = 0;
+	int corrupt_block_keys = 0;
+
+	srand(128);
 
 	while(1) {
 		int c;
-		c = getopt_long(ac, av, "l:c:", long_options,
+		c = getopt_long(ac, av, "l:c:eEk", long_options,
 				&option_index);
 		if (c < 0)
 			break;
@@ -152,6 +325,15 @@
 					print_usage();
 				}
 				break;
+			case 'e':
+				extent_rec = 1;
+				break;
+			case 'E':
+				extent_tree = 1;
+				break;
+			case 'k':
+				corrupt_block_keys = 1;
+				break;
 			default:
 				print_usage();
 		}
@@ -159,7 +341,7 @@
 	ac = ac - optind;
 	if (ac == 0)
 		print_usage();
-	if (logical == 0)
+	if (logical == 0 && !extent_tree)
 		print_usage();
 	if (copy < 0)
 		print_usage();
@@ -174,23 +356,20 @@
 		fprintf(stderr, "Open ctree failed\n");
 		exit(1);
 	}
-
-	info_file = stdout;
-	if (output_file) {
-		if (strcmp(output_file, "-") == 0) {
-			out_fd = 1;
-			info_file = stderr;
-		} else {
-			out_fd = open(output_file, O_RDWR | O_CREAT, 0600);
-			if (out_fd < 0)
-				goto close;
-			err = ftruncate(out_fd, 0);
-			if (err) {
-				close(out_fd);
-				goto close;
-			}
-			info_file = stdout;
-		}
+	if (extent_rec) {
+		struct btrfs_trans_handle *trans;
+		trans = btrfs_start_transaction(root, 1);
+		ret = corrupt_extent (trans, root, logical, 0);
+		btrfs_commit_transaction(trans, root);
+		goto out_close;
+	}
+	if (extent_tree) {
+		struct btrfs_trans_handle *trans;
+		trans = btrfs_start_transaction(root, 1);
+		btrfs_corrupt_extent_tree(trans, root->fs_info->extent_root,
+					  root->fs_info->extent_root->node);
+		btrfs_commit_transaction(trans, root);
+		goto out_close;
 	}
 
 	if (bytes == 0)
@@ -200,22 +379,18 @@
 	bytes *= root->sectorsize;
 
 	while (bytes > 0) {
-		eb = debug_corrupt_block(root, logical, root->sectorsize, copy);
-		if (eb && output_file) {
-			err = write(out_fd, eb->data, eb->len);
-			if (err < 0 || err != eb->len) {
-				fprintf(stderr, "output file write failed\n");
-				goto out_close_fd;
-			}
+		if (corrupt_block_keys) {
+			corrupt_keys_in_block(root, logical);
+		} else {
+			eb = debug_corrupt_block(root, logical,
+						 root->sectorsize, copy);
+			free_extent_buffer(eb);
 		}
-		free_extent_buffer(eb);
 		logical += root->sectorsize;
 		bytes -= root->sectorsize;
 	}
-
-out_close_fd:
-	if (output_file && out_fd != 1)
-		close(out_fd);
-close:
+	return ret;
+out_close:
+	close_ctree(root);
 	return ret;
 }
diff -Nru btrfs-tools-0.19+20111121/cmds-balance.c btrfs-tools-0.19+20120328/cmds-balance.c
--- btrfs-tools-0.19+20111121/cmds-balance.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/cmds-balance.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,713 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+
+#include "kerncompat.h"
+#include "ctree.h"
+#include "ioctl.h"
+#include "volumes.h"
+
+#include "commands.h"
+
+static const char * const balance_cmd_group_usage[] = {
+	"btrfs [filesystem] balance <command> [options] <path>",
+	"btrfs [filesystem] balance <path>",
+	NULL
+};
+
+static const char balance_cmd_group_info[] =
+	"'btrfs filesystem balance' command is deprecated, please use\n"
+	"'btrfs balance start' command instead.";
+
+static int parse_one_profile(const char *profile, u64 *flags)
+{
+	if (!strcmp(profile, "raid0")) {
+		*flags |= BTRFS_BLOCK_GROUP_RAID0;
+	} else if (!strcmp(profile, "raid1")) {
+		*flags |= BTRFS_BLOCK_GROUP_RAID1;
+	} else if (!strcmp(profile, "raid10")) {
+		*flags |= BTRFS_BLOCK_GROUP_RAID10;
+	} else if (!strcmp(profile, "dup")) {
+		*flags |= BTRFS_BLOCK_GROUP_DUP;
+	} else if (!strcmp(profile, "single")) {
+		*flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE;
+	} else {
+		fprintf(stderr, "Unknown profile '%s'\n", profile);
+		return 1;
+	}
+
+	return 0;
+}
+
+static int parse_profiles(char *profiles, u64 *flags)
+{
+	char *this_char;
+	char *save_ptr;
+
+	for (this_char = strtok_r(profiles, "|", &save_ptr);
+	     this_char != NULL;
+	     this_char = strtok_r(NULL, "|", &save_ptr)) {
+		if (parse_one_profile(this_char, flags))
+			return 1;
+	}
+
+	return 0;
+}
+
+static int parse_u64(const char *str, u64 *result)
+{
+	char *endptr;
+	u64 val;
+
+	val = strtoull(str, &endptr, 10);
+	if (*endptr)
+		return 1;
+
+	*result = val;
+	return 0;
+}
+
+static int parse_range(const char *range, u64 *start, u64 *end)
+{
+	char *dots;
+
+	dots = strstr(range, "..");
+	if (dots) {
+		const char *rest = dots + 2;
+		int skipped = 0;
+
+		*dots = 0;
+
+		if (!*rest) {
+			*end = (u64)-1;
+			skipped++;
+		} else {
+			if (parse_u64(rest, end))
+				return 1;
+		}
+		if (dots == range) {
+			*start = 0;
+			skipped++;
+		} else {
+			if (parse_u64(range, start))
+				return 1;
+		}
+
+		if (*start >= *end) {
+			fprintf(stderr, "Range %llu..%llu doesn't make "
+				"sense\n", (unsigned long long)*start,
+				(unsigned long long)*end);
+			return 1;
+		}
+
+		if (skipped <= 1)
+			return 0;
+	}
+
+	return 1;
+}
+
+static int parse_filters(char *filters, struct btrfs_balance_args *args)
+{
+	char *this_char;
+	char *value;
+	char *save_ptr;
+
+	if (!filters)
+		return 0;
+
+	for (this_char = strtok_r(filters, ",", &save_ptr);
+	     this_char != NULL;
+	     this_char = strtok_r(NULL, ",", &save_ptr)) {
+		if ((value = strchr(this_char, '=')) != NULL)
+			*value++ = 0;
+		if (!strcmp(this_char, "profiles")) {
+			if (!value || !*value) {
+				fprintf(stderr, "the profiles filter requires "
+				       "an argument\n");
+				return 1;
+			}
+			if (parse_profiles(value, &args->profiles)) {
+				fprintf(stderr, "Invalid profiles argument\n");
+				return 1;
+			}
+			args->flags |= BTRFS_BALANCE_ARGS_PROFILES;
+		} else if (!strcmp(this_char, "usage")) {
+			if (!value || !*value) {
+				fprintf(stderr, "the usage filter requires "
+				       "an argument\n");
+				return 1;
+			}
+			if (parse_u64(value, &args->usage) ||
+			    args->usage < 1 || args->usage > 100) {
+				fprintf(stderr, "Invalid usage argument: %s\n",
+				       value);
+				return 1;
+			}
+			args->flags |= BTRFS_BALANCE_ARGS_USAGE;
+		} else if (!strcmp(this_char, "devid")) {
+			if (!value || !*value) {
+				fprintf(stderr, "the devid filter requires "
+				       "an argument\n");
+				return 1;
+			}
+			if (parse_u64(value, &args->devid) ||
+			    args->devid == 0) {
+				fprintf(stderr, "Invalid devid argument: %s\n",
+				       value);
+				return 1;
+			}
+			args->flags |= BTRFS_BALANCE_ARGS_DEVID;
+		} else if (!strcmp(this_char, "drange")) {
+			if (!value || !*value) {
+				fprintf(stderr, "the drange filter requires "
+				       "an argument\n");
+				return 1;
+			}
+			if (parse_range(value, &args->pstart, &args->pend)) {
+				fprintf(stderr, "Invalid drange argument\n");
+				return 1;
+			}
+			args->flags |= BTRFS_BALANCE_ARGS_DRANGE;
+		} else if (!strcmp(this_char, "vrange")) {
+			if (!value || !*value) {
+				fprintf(stderr, "the vrange filter requires "
+				       "an argument\n");
+				return 1;
+			}
+			if (parse_range(value, &args->vstart, &args->vend)) {
+				fprintf(stderr, "Invalid vrange argument\n");
+				return 1;
+			}
+			args->flags |= BTRFS_BALANCE_ARGS_VRANGE;
+		} else if (!strcmp(this_char, "convert")) {
+			if (!value || !*value) {
+				fprintf(stderr, "the convert option requires "
+				       "an argument\n");
+				return 1;
+			}
+			if (parse_one_profile(value, &args->target)) {
+				fprintf(stderr, "Invalid convert argument\n");
+				return 1;
+			}
+			args->flags |= BTRFS_BALANCE_ARGS_CONVERT;
+		} else if (!strcmp(this_char, "soft")) {
+			args->flags |= BTRFS_BALANCE_ARGS_SOFT;
+		} else {
+			fprintf(stderr, "Unrecognized balance option '%s'\n",
+				this_char);
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static void dump_balance_args(struct btrfs_balance_args *args)
+{
+	if (args->flags & BTRFS_BALANCE_ARGS_CONVERT) {
+		printf("converting, target=%llu, soft is %s",
+		       (unsigned long long)args->target,
+		       (args->flags & BTRFS_BALANCE_ARGS_SOFT) ? "on" : "off");
+	} else {
+		printf("balancing");
+	}
+
+	if (args->flags & BTRFS_BALANCE_ARGS_PROFILES)
+		printf(", profiles=%llu", (unsigned long long)args->profiles);
+	if (args->flags & BTRFS_BALANCE_ARGS_USAGE)
+		printf(", usage=%llu", (unsigned long long)args->usage);
+	if (args->flags & BTRFS_BALANCE_ARGS_DEVID)
+		printf(", devid=%llu", (unsigned long long)args->devid);
+	if (args->flags & BTRFS_BALANCE_ARGS_DRANGE)
+		printf(", drange=%llu..%llu",
+		       (unsigned long long)args->pstart,
+		       (unsigned long long)args->pend);
+	if (args->flags & BTRFS_BALANCE_ARGS_VRANGE)
+		printf(", vrange=%llu..%llu",
+		       (unsigned long long)args->vstart,
+		       (unsigned long long)args->vend);
+
+	printf("\n");
+}
+
+static void dump_ioctl_balance_args(struct btrfs_ioctl_balance_args *args)
+{
+	printf("Dumping filters: flags 0x%llx, state 0x%llx, force is %s\n",
+	       (unsigned long long)args->flags, (unsigned long long)args->state,
+	       (args->flags & BTRFS_BALANCE_FORCE) ? "on" : "off");
+	if (args->flags & BTRFS_BALANCE_DATA) {
+		printf("  DATA (flags 0x%llx): ",
+		       (unsigned long long)args->data.flags);
+		dump_balance_args(&args->data);
+	}
+	if (args->flags & BTRFS_BALANCE_METADATA) {
+		printf("  METADATA (flags 0x%llx): ",
+		       (unsigned long long)args->meta.flags);
+		dump_balance_args(&args->meta);
+	}
+	if (args->flags & BTRFS_BALANCE_SYSTEM) {
+		printf("  SYSTEM (flags 0x%llx): ",
+		       (unsigned long long)args->sys.flags);
+		dump_balance_args(&args->sys);
+	}
+}
+
+static int do_balance_v1(int fd)
+{
+	struct btrfs_ioctl_vol_args args;
+	int ret;
+
+	memset(&args, 0, sizeof(args));
+	ret = ioctl(fd, BTRFS_IOC_BALANCE, &args);
+	return ret;
+}
+
+static int do_balance(const char *path, struct btrfs_ioctl_balance_args *args,
+		      int nofilters)
+{
+	int fd;
+	int ret;
+	int e;
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	ret = ioctl(fd, BTRFS_IOC_BALANCE_V2, args);
+	e = errno;
+
+	if (ret < 0) {
+		/*
+		 * older kernels don't have the new balance ioctl, try the
+		 * old one.  But, the old one doesn't know any filters, so
+		 * don't fall back if they tried to use the fancy new things
+		 */
+		if (e == ENOTTY && nofilters) {
+			ret = do_balance_v1(fd);
+			if (ret == 0)
+				goto out;
+			e = errno;
+		}
+
+		if (e == ECANCELED) {
+			if (args->state & BTRFS_BALANCE_STATE_PAUSE_REQ)
+				fprintf(stderr, "balance paused by user\n");
+			if (args->state & BTRFS_BALANCE_STATE_CANCEL_REQ)
+				fprintf(stderr, "balance canceled by user\n");
+			ret = 0;
+		} else {
+			fprintf(stderr, "ERROR: error during balancing '%s' "
+				"- %s\n", path, strerror(e));
+			if (e != EINPROGRESS)
+				fprintf(stderr, "There may be more info in "
+					"syslog - try dmesg | tail\n");
+			ret = 19;
+		}
+	} else {
+		printf("Done, had to relocate %llu out of %llu chunks\n",
+		       (unsigned long long)args->stat.completed,
+		       (unsigned long long)args->stat.considered);
+		ret = 0;
+	}
+
+out:
+	close(fd);
+	return ret;
+}
+
+static const char * const cmd_balance_start_usage[] = {
+	"btrfs [filesystem] balance start [options] <path>",
+	"Balance chunks across the devices",
+	"Balance and/or convert (change allocation profile of) chunks that",
+	"passed all filters in a comma-separated list of filters for a",
+	"particular chunk type.  If filter list is not given balance all",
+	"chunks of that type.  In case none of the -d, -m or -s options is",
+	"given balance all chunks in a filesystem.",
+	"",
+	"-d[filters]    act on data chunks",
+	"-m[filters]    act on metadata chunks",
+	"-s[filetrs]    act on system chunks (only under -f)",
+	"-v             be verbose",
+	"-f             force reducing of metadata integrity",
+	NULL
+};
+
+static int cmd_balance_start(int argc, char **argv)
+{
+	struct btrfs_ioctl_balance_args args;
+	struct btrfs_balance_args *ptrs[] = { &args.data, &args.sys,
+						&args.meta, NULL };
+	int force = 0;
+	int verbose = 0;
+	int nofilters = 1;
+	int i;
+
+	memset(&args, 0, sizeof(args));
+
+	optind = 1;
+	while (1) {
+		int longindex;
+		static struct option longopts[] = {
+			{ "data", optional_argument, NULL, 'd'},
+			{ "metadata", optional_argument, NULL, 'm' },
+			{ "system", optional_argument, NULL, 's' },
+			{ "force", no_argument, NULL, 'f' },
+			{ "verbose", no_argument, NULL, 'v' },
+			{ 0, 0, 0, 0 }
+		};
+
+		int opt = getopt_long(argc, argv, "d::s::m::fv", longopts,
+				      &longindex);
+		if (opt < 0)
+			break;
+
+		switch (opt) {
+		case 'd':
+			nofilters = 0;
+			args.flags |= BTRFS_BALANCE_DATA;
+
+			if (parse_filters(optarg, &args.data))
+				return 1;
+			break;
+		case 's':
+			nofilters = 0;
+			args.flags |= BTRFS_BALANCE_SYSTEM;
+
+			if (parse_filters(optarg, &args.sys))
+				return 1;
+			break;
+		case 'm':
+			nofilters = 0;
+			args.flags |= BTRFS_BALANCE_METADATA;
+
+			if (parse_filters(optarg, &args.meta))
+				return 1;
+			break;
+		case 'f':
+			force = 1;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		default:
+			usage(cmd_balance_start_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 1))
+		usage(cmd_balance_start_usage);
+
+	/*
+	 * allow -s only under --force, otherwise do with system chunks
+	 * the same thing we were ordered to do with meta chunks
+	 */
+	if (args.flags & BTRFS_BALANCE_SYSTEM) {
+		if (!force) {
+			fprintf(stderr,
+"Refusing to explicitly operate on system chunks.\n"
+"Pass --force if you really want to do that.\n");
+			return 1;
+		}
+	} else if (args.flags & BTRFS_BALANCE_METADATA) {
+		args.flags |= BTRFS_BALANCE_SYSTEM;
+		memcpy(&args.sys, &args.meta,
+			sizeof(struct btrfs_balance_args));
+	}
+
+	if (nofilters) {
+		/* relocate everything - no filters */
+		args.flags |= BTRFS_BALANCE_TYPE_MASK;
+	}
+
+	/* drange makes sense only when devid is set */
+	for (i = 0; ptrs[i]; i++) {
+		if ((ptrs[i]->flags & BTRFS_BALANCE_ARGS_DRANGE) &&
+		    !(ptrs[i]->flags & BTRFS_BALANCE_ARGS_DEVID)) {
+			fprintf(stderr, "drange filter can be used only if "
+				"devid filter is used\n");
+			return 1;
+		}
+	}
+
+	/* soft makes sense only when convert for corresponding type is set */
+	for (i = 0; ptrs[i]; i++) {
+		if ((ptrs[i]->flags & BTRFS_BALANCE_ARGS_SOFT) &&
+		    !(ptrs[i]->flags & BTRFS_BALANCE_ARGS_CONVERT)) {
+			fprintf(stderr, "'soft' option can be used only if "
+				"changing profiles\n");
+			return 1;
+		}
+	}
+
+	if (force)
+		args.flags |= BTRFS_BALANCE_FORCE;
+	if (verbose)
+		dump_ioctl_balance_args(&args);
+
+	return do_balance(argv[optind], &args, nofilters);
+}
+
+static const char * const cmd_balance_pause_usage[] = {
+	"btrfs [filesystem] balance pause <path>",
+	"Pause running balance",
+	NULL
+};
+
+static int cmd_balance_pause(int argc, char **argv)
+{
+	const char *path;
+	int fd;
+	int ret;
+	int e;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_balance_pause_usage);
+
+	path = argv[1];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	ret = ioctl(fd, BTRFS_IOC_BALANCE_CTL, BTRFS_BALANCE_CTL_PAUSE);
+	e = errno;
+	close(fd);
+
+	if (ret < 0) {
+		fprintf(stderr, "ERROR: balance pause on '%s' failed - %s\n",
+			path, (e == ENOTCONN) ? "Not running" : strerror(e));
+		return 19;
+	}
+
+	return 0;
+}
+
+static const char * const cmd_balance_cancel_usage[] = {
+	"btrfs [filesystem] balance cancel <path>",
+	"Cancel running or paused balance",
+	NULL
+};
+
+static int cmd_balance_cancel(int argc, char **argv)
+{
+	const char *path;
+	int fd;
+	int ret;
+	int e;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_balance_cancel_usage);
+
+	path = argv[1];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	ret = ioctl(fd, BTRFS_IOC_BALANCE_CTL, BTRFS_BALANCE_CTL_CANCEL);
+	e = errno;
+	close(fd);
+
+	if (ret < 0) {
+		fprintf(stderr, "ERROR: balance cancel on '%s' failed - %s\n",
+			path, (e == ENOTCONN) ? "Not in progress" : strerror(e));
+		return 19;
+	}
+
+	return 0;
+}
+
+static const char * const cmd_balance_resume_usage[] = {
+	"btrfs [filesystem] balance resume <path>",
+	"Resume interrupted balance",
+	NULL
+};
+
+static int cmd_balance_resume(int argc, char **argv)
+{
+	struct btrfs_ioctl_balance_args args;
+	const char *path;
+	int fd;
+	int ret;
+	int e;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_balance_resume_usage);
+
+	path = argv[1];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	memset(&args, 0, sizeof(args));
+	args.flags |= BTRFS_BALANCE_RESUME;
+
+	ret = ioctl(fd, BTRFS_IOC_BALANCE_V2, &args);
+	e = errno;
+	close(fd);
+
+	if (ret < 0) {
+		if (e == ECANCELED) {
+			if (args.state & BTRFS_BALANCE_STATE_PAUSE_REQ)
+				fprintf(stderr, "balance paused by user\n");
+			if (args.state & BTRFS_BALANCE_STATE_CANCEL_REQ)
+				fprintf(stderr, "balance canceled by user\n");
+		} else if (e == ENOTCONN || e == EINPROGRESS) {
+			fprintf(stderr, "ERROR: balance resume on '%s' "
+				"failed - %s\n", path,
+				(e == ENOTCONN) ? "Not in progress" :
+						  "Already running");
+			return 19;
+		} else {
+			fprintf(stderr,
+"ERROR: error during balancing '%s' - %s\n"
+"There may be more info in syslog - try dmesg | tail\n", path, strerror(e));
+			return 19;
+		}
+	} else {
+		printf("Done, had to relocate %llu out of %llu chunks\n",
+		       (unsigned long long)args.stat.completed,
+		       (unsigned long long)args.stat.considered);
+	}
+
+	return 0;
+}
+
+static const char * const cmd_balance_status_usage[] = {
+	"btrfs [filesystem] balance status [-v] <path>",
+	"Show status of running or paused balance",
+	"",
+	"-v     be verbose",
+	NULL
+};
+
+static int cmd_balance_status(int argc, char **argv)
+{
+	struct btrfs_ioctl_balance_args args;
+	const char *path;
+	int fd;
+	int verbose = 0;
+	int ret;
+	int e;
+
+	optind = 1;
+	while (1) {
+		int longindex;
+		static struct option longopts[] = {
+			{ "verbose", no_argument, NULL, 'v' },
+			{ 0, 0, 0, 0}
+		};
+
+		int opt = getopt_long(argc, argv, "v", longopts, &longindex);
+		if (opt < 0)
+			break;
+
+		switch (opt) {
+		case 'v':
+			verbose = 1;
+			break;
+		default:
+			usage(cmd_balance_status_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 1))
+		usage(cmd_balance_status_usage);
+
+	path = argv[optind];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	ret = ioctl(fd, BTRFS_IOC_BALANCE_PROGRESS, &args);
+	e = errno;
+	close(fd);
+
+	if (ret < 0) {
+		fprintf(stderr, "ERROR: balance status on '%s' failed - %s\n",
+			path, (e == ENOTCONN) ? "Not in progress" : strerror(e));
+		return 19;
+	}
+
+	if (args.state & BTRFS_BALANCE_STATE_RUNNING) {
+		printf("Balance on '%s' is running", path);
+		if (args.state & BTRFS_BALANCE_STATE_CANCEL_REQ)
+			printf(", cancel requested\n");
+		else if (args.state & BTRFS_BALANCE_STATE_PAUSE_REQ)
+			printf(", pause requested\n");
+		else
+			printf("\n");
+	} else {
+		printf("Balance on '%s' is paused\n", path);
+	}
+
+	printf("%llu out of about %llu chunks balanced (%llu considered), "
+	       "%3.f%% left\n", (unsigned long long)args.stat.completed,
+	       (unsigned long long)args.stat.expected,
+	       (unsigned long long)args.stat.considered,
+	       100 * (1 - (float)args.stat.completed/args.stat.expected));
+
+	if (verbose)
+		dump_ioctl_balance_args(&args);
+
+	return 0;
+}
+
+const struct cmd_group balance_cmd_group = {
+	balance_cmd_group_usage, balance_cmd_group_info, {
+		{ "start", cmd_balance_start, cmd_balance_start_usage, NULL, 0 },
+		{ "pause", cmd_balance_pause, cmd_balance_pause_usage, NULL, 0 },
+		{ "cancel", cmd_balance_cancel, cmd_balance_cancel_usage, NULL, 0 },
+		{ "resume", cmd_balance_resume, cmd_balance_resume_usage, NULL, 0 },
+		{ "status", cmd_balance_status, cmd_balance_status_usage, NULL, 0 },
+		{ 0, 0, 0, 0, 0 }
+	}
+};
+
+int cmd_balance(int argc, char **argv)
+{
+	if (argc == 2) {
+		/* old 'btrfs filesystem balance <path>' syntax */
+		struct btrfs_ioctl_balance_args args;
+
+		memset(&args, 0, sizeof(args));
+		args.flags |= BTRFS_BALANCE_TYPE_MASK;
+
+		return do_balance(argv[1], &args, 1);
+	}
+
+	return handle_command_group(&balance_cmd_group, argc, argv);
+}
diff -Nru btrfs-tools-0.19+20111121/cmds-device.c btrfs-tools-0.19+20120328/cmds-device.c
--- btrfs-tools-0.19+20111121/cmds-device.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/cmds-device.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,261 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+#include "kerncompat.h"
+#include "ctree.h"
+#include "ioctl.h"
+#include "utils.h"
+
+#include "commands.h"
+
+/* FIXME - imported cruft, fix sparse errors and warnings */
+#ifdef __CHECKER__
+#define BLKGETSIZE64 0
+#define BTRFS_IOC_SNAP_CREATE_V2 0
+#define BTRFS_VOL_NAME_MAX 255
+struct btrfs_ioctl_vol_args { char name[BTRFS_VOL_NAME_MAX]; };
+static inline int ioctl(int fd, int define, void *arg) { return 0; }
+#endif
+
+static const char * const device_cmd_group_usage[] = {
+	"btrfs device <command> [<args>]",
+	NULL
+};
+
+static const char * const cmd_add_dev_usage[] = {
+	"btrfs device add <device> [<device>...] <path>",
+	"Add a device to a filesystem",
+	NULL
+};
+
+static int cmd_add_dev(int argc, char **argv)
+{
+	char	*mntpnt;
+	int	i, fdmnt, ret=0, e;
+
+	if (check_argc_min(argc, 3))
+		usage(cmd_add_dev_usage);
+
+	mntpnt = argv[argc - 1];
+
+	fdmnt = open_file_or_dir(mntpnt);
+	if (fdmnt < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", mntpnt);
+		return 12;
+	}
+
+	for (i = 1; i < argc - 1; i++ ){
+		struct btrfs_ioctl_vol_args ioctl_args;
+		int	devfd, res;
+		u64 dev_block_count = 0;
+		struct stat st;
+		int mixed = 0;
+
+		res = check_mounted(argv[i]);
+		if (res < 0) {
+			fprintf(stderr, "error checking %s mount status\n",
+				argv[i]);
+			ret++;
+			continue;
+		}
+		if (res == 1) {
+			fprintf(stderr, "%s is mounted\n", argv[i]);
+			ret++;
+			continue;
+		}
+
+		devfd = open(argv[i], O_RDWR);
+		if (!devfd) {
+			fprintf(stderr, "ERROR: Unable to open device '%s'\n", argv[i]);
+			close(devfd);
+			ret++;
+			continue;
+		}
+		res = fstat(devfd, &st);
+		if (res) {
+			fprintf(stderr, "ERROR: Unable to stat '%s'\n", argv[i]);
+			close(devfd);
+			ret++;
+			continue;
+		}
+		if (!S_ISBLK(st.st_mode)) {
+			fprintf(stderr, "ERROR: '%s' is not a block device\n", argv[i]);
+			close(devfd);
+			ret++;
+			continue;
+		}
+
+		res = btrfs_prepare_device(devfd, argv[i], 1, &dev_block_count, &mixed);
+		if (res) {
+			fprintf(stderr, "ERROR: Unable to init '%s'\n", argv[i]);
+			close(devfd);
+			ret++;
+			continue;
+		}
+		close(devfd);
+
+		strncpy(ioctl_args.name, argv[i], BTRFS_PATH_NAME_MAX);
+		res = ioctl(fdmnt, BTRFS_IOC_ADD_DEV, &ioctl_args);
+		e = errno;
+		if(res<0){
+			fprintf(stderr, "ERROR: error adding the device '%s' - %s\n",
+				argv[i], strerror(e));
+			ret++;
+		}
+
+	}
+
+	close(fdmnt);
+	if (ret)
+		return ret+20;
+	else
+		return 0;
+}
+
+static const char * const cmd_rm_dev_usage[] = {
+	"btrfs device delete <device> [<device>...] <path>",
+	"Remove a device from a filesystem",
+	NULL
+};
+
+static int cmd_rm_dev(int argc, char **argv)
+{
+	char	*mntpnt;
+	int	i, fdmnt, ret=0, e;
+
+	if (check_argc_min(argc, 3))
+		usage(cmd_rm_dev_usage);
+
+	mntpnt = argv[argc - 1];
+
+	fdmnt = open_file_or_dir(mntpnt);
+	if (fdmnt < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", mntpnt);
+		return 12;
+	}
+
+	for(i=1 ; i < argc - 1; i++ ){
+		struct	btrfs_ioctl_vol_args arg;
+		int	res;
+
+		strncpy(arg.name, argv[i], BTRFS_PATH_NAME_MAX);
+		res = ioctl(fdmnt, BTRFS_IOC_RM_DEV, &arg);
+		e = errno;
+		if(res<0){
+			fprintf(stderr, "ERROR: error removing the device '%s' - %s\n",
+				argv[i], strerror(e));
+			ret++;
+		}
+	}
+
+	close(fdmnt);
+	if( ret)
+		return ret+20;
+	else
+		return 0;
+}
+
+static const char * const cmd_scan_dev_usage[] = {
+	"btrfs device scan [<device>...]",
+	"Scan devices for a btrfs filesystem",
+	NULL
+};
+
+static int cmd_scan_dev(int argc, char **argv)
+{
+	int	i, fd, e;
+	int	checklist = 1;
+	int	devstart = 1;
+
+	if( argc > 1 && !strcmp(argv[1],"--all-devices")){
+		if (check_argc_max(argc, 2))
+			usage(cmd_scan_dev_usage);
+
+		checklist = 0;
+		devstart += 1;
+	}
+
+	if(argc<=devstart){
+
+		int ret;
+
+		printf("Scanning for Btrfs filesystems\n");
+		if(checklist)
+			ret = btrfs_scan_block_devices(1);
+		else
+			ret = btrfs_scan_one_dir("/dev", 1);
+		if (ret){
+			fprintf(stderr, "ERROR: error %d while scanning\n", ret);
+			return 18;
+		}
+		return 0;
+	}
+
+	fd = open("/dev/btrfs-control", O_RDWR);
+	if (fd < 0) {
+		perror("failed to open /dev/btrfs-control");
+		return 10;
+	}
+
+	for( i = devstart ; i < argc ; i++ ){
+		struct btrfs_ioctl_vol_args args;
+		int ret;
+
+		printf("Scanning for Btrfs filesystems in '%s'\n", argv[i]);
+
+		strncpy(args.name, argv[i], BTRFS_PATH_NAME_MAX);
+		/*
+		 * FIXME: which are the error code returned by this ioctl ?
+		 * it seems that is impossible to understand if there no is
+		 * a btrfs filesystem from an I/O error !!!
+		 */
+		ret = ioctl(fd, BTRFS_IOC_SCAN_DEV, &args);
+		e = errno;
+
+		if( ret < 0 ){
+			close(fd);
+			fprintf(stderr, "ERROR: unable to scan the device '%s' - %s\n",
+				argv[i], strerror(e));
+			return 11;
+		}
+	}
+
+	close(fd);
+	return 0;
+}
+
+const struct cmd_group device_cmd_group = {
+	device_cmd_group_usage, NULL, {
+		{ "add", cmd_add_dev, cmd_add_dev_usage, NULL, 0 },
+		{ "delete", cmd_rm_dev, cmd_rm_dev_usage, NULL, 0 },
+		{ "scan", cmd_scan_dev, cmd_scan_dev_usage, NULL, 0 },
+		{ 0, 0, 0, 0, 0 }
+	}
+};
+
+int cmd_device(int argc, char **argv)
+{
+	return handle_command_group(&device_cmd_group, argc, argv);
+}
diff -Nru btrfs-tools-0.19+20111121/cmds-filesystem.c btrfs-tools-0.19+20120328/cmds-filesystem.c
--- btrfs-tools-0.19+20111121/cmds-filesystem.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/cmds-filesystem.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,538 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <uuid/uuid.h>
+#include <ctype.h>
+
+#include "kerncompat.h"
+#include "ctree.h"
+#include "ioctl.h"
+#include "utils.h"
+#include "volumes.h"
+
+#include "version.h"
+
+#include "commands.h"
+#include "btrfslabel.h"
+
+static const char * const filesystem_cmd_group_usage[] = {
+	"btrfs filesystem [<group>] <command> [<args>]",
+	NULL
+};
+
+static const char * const cmd_df_usage[] = {
+	"btrfs filesystem df <path>",
+	"Show space usage information for a mount point",
+	NULL
+};
+
+static int cmd_df(int argc, char **argv)
+{
+	struct btrfs_ioctl_space_args *sargs;
+	u64 count = 0, i;
+	int ret;
+	int fd;
+	int e;
+	char *path;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_df_usage);
+
+	path = argv[1];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	sargs = malloc(sizeof(struct btrfs_ioctl_space_args));
+	if (!sargs)
+		return -ENOMEM;
+
+	sargs->space_slots = 0;
+	sargs->total_spaces = 0;
+
+	ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs);
+	e = errno;
+	if (ret) {
+		fprintf(stderr, "ERROR: couldn't get space info on '%s' - %s\n",
+			path, strerror(e));
+		free(sargs);
+		return ret;
+	}
+	if (!sargs->total_spaces)
+		return 0;
+
+	count = sargs->total_spaces;
+
+	sargs = realloc(sargs, sizeof(struct btrfs_ioctl_space_args) +
+			(count * sizeof(struct btrfs_ioctl_space_info)));
+	if (!sargs)
+		return -ENOMEM;
+
+	sargs->space_slots = count;
+	sargs->total_spaces = 0;
+
+	ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs);
+	e = errno;
+	if (ret) {
+		fprintf(stderr, "ERROR: couldn't get space info on '%s' - %s\n",
+			path, strerror(e));
+		close(fd);
+		free(sargs);
+		return ret;
+	}
+
+	for (i = 0; i < sargs->total_spaces; i++) {
+		char description[80];
+		char *total_bytes;
+		char *used_bytes;
+		int written = 0;
+		u64 flags = sargs->spaces[i].flags;
+
+		memset(description, 0, 80);
+
+		if (flags & BTRFS_BLOCK_GROUP_DATA) {
+			if (flags & BTRFS_BLOCK_GROUP_METADATA) {
+				snprintf(description, 14, "%s",
+					 "Data+Metadata");
+				written += 13;
+			} else {
+				snprintf(description, 5, "%s", "Data");
+				written += 4;
+			}
+		} else if (flags & BTRFS_BLOCK_GROUP_SYSTEM) {
+			snprintf(description, 7, "%s", "System");
+			written += 6;
+		} else if (flags & BTRFS_BLOCK_GROUP_METADATA) {
+			snprintf(description, 9, "%s", "Metadata");
+			written += 8;
+		}
+
+		if (flags & BTRFS_BLOCK_GROUP_RAID0) {
+			snprintf(description+written, 8, "%s", ", RAID0");
+			written += 7;
+		} else if (flags & BTRFS_BLOCK_GROUP_RAID1) {
+			snprintf(description+written, 8, "%s", ", RAID1");
+			written += 7;
+		} else if (flags & BTRFS_BLOCK_GROUP_DUP) {
+			snprintf(description+written, 6, "%s", ", DUP");
+			written += 5;
+		} else if (flags & BTRFS_BLOCK_GROUP_RAID10) {
+			snprintf(description+written, 9, "%s", ", RAID10");
+			written += 8;
+		}
+
+		total_bytes = pretty_sizes(sargs->spaces[i].total_bytes);
+		used_bytes = pretty_sizes(sargs->spaces[i].used_bytes);
+		printf("%s: total=%s, used=%s\n", description, total_bytes,
+		       used_bytes);
+	}
+	free(sargs);
+
+	return 0;
+}
+
+static int uuid_search(struct btrfs_fs_devices *fs_devices, char *search)
+{
+	struct list_head *cur;
+	struct btrfs_device *device;
+
+	list_for_each(cur, &fs_devices->devices) {
+		device = list_entry(cur, struct btrfs_device, dev_list);
+		if ((device->label && strcmp(device->label, search) == 0) ||
+		    strcmp(device->name, search) == 0)
+			return 1;
+	}
+	return 0;
+}
+
+static void print_one_uuid(struct btrfs_fs_devices *fs_devices)
+{
+	char uuidbuf[37];
+	struct list_head *cur;
+	struct btrfs_device *device;
+	char *super_bytes_used;
+	u64 devs_found = 0;
+	u64 total;
+
+	uuid_unparse(fs_devices->fsid, uuidbuf);
+	device = list_entry(fs_devices->devices.next, struct btrfs_device,
+			    dev_list);
+	if (device->label && device->label[0])
+		printf("Label: '%s' ", device->label);
+	else
+		printf("Label: none ");
+
+	super_bytes_used = pretty_sizes(device->super_bytes_used);
+
+	total = device->total_devs;
+	printf(" uuid: %s\n\tTotal devices %llu FS bytes used %s\n", uuidbuf,
+	       (unsigned long long)total, super_bytes_used);
+
+	free(super_bytes_used);
+
+	list_for_each(cur, &fs_devices->devices) {
+		char *total_bytes;
+		char *bytes_used;
+		device = list_entry(cur, struct btrfs_device, dev_list);
+		total_bytes = pretty_sizes(device->total_bytes);
+		bytes_used = pretty_sizes(device->bytes_used);
+		printf("\tdevid %4llu size %s used %s path %s\n",
+		       (unsigned long long)device->devid,
+		       total_bytes, bytes_used, device->name);
+		free(total_bytes);
+		free(bytes_used);
+		devs_found++;
+	}
+	if (devs_found < total) {
+		printf("\t*** Some devices missing\n");
+	}
+	printf("\n");
+}
+
+static const char * const cmd_show_usage[] = {
+	"btrfs filesystem show [--all-devices] [<uuid>|<label>]",
+	"Show the structure of a filesystem",
+	"If no argument is given, structure of all present filesystems is shown.",
+	NULL
+};
+
+static int cmd_show(int argc, char **argv)
+{
+	struct list_head *all_uuids;
+	struct btrfs_fs_devices *fs_devices;
+	struct list_head *cur_uuid;
+	char *search = 0;
+	int ret;
+	int checklist = 1;
+	int searchstart = 1;
+
+	if( argc > 1 && !strcmp(argv[1],"--all-devices")){
+		checklist = 0;
+		searchstart += 1;
+	}
+
+	if (check_argc_max(argc, searchstart + 1))
+		usage(cmd_show_usage);
+
+	if(checklist)
+		ret = btrfs_scan_block_devices(0);
+	else
+		ret = btrfs_scan_one_dir("/dev", 0);
+
+	if (ret){
+		fprintf(stderr, "ERROR: error %d while scanning\n", ret);
+		return 18;
+	}
+	
+	if(searchstart < argc)
+		search = argv[searchstart];
+
+	all_uuids = btrfs_scanned_uuids();
+	list_for_each(cur_uuid, all_uuids) {
+		fs_devices = list_entry(cur_uuid, struct btrfs_fs_devices,
+					list);
+		if (search && uuid_search(fs_devices, search) == 0)
+			continue;
+		print_one_uuid(fs_devices);
+	}
+	printf("%s\n", BTRFS_BUILD_VERSION);
+	return 0;
+}
+
+static const char * const cmd_sync_usage[] = {
+	"btrfs filesystem sync <path>",
+	"Force a sync on a filesystem",
+	NULL
+};
+
+static int cmd_sync(int argc, char **argv)
+{
+	int 	fd, res, e;
+	char	*path;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_sync_usage);
+
+	path = argv[1];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	printf("FSSync '%s'\n", path);
+	res = ioctl(fd, BTRFS_IOC_SYNC);
+	e = errno;
+	close(fd);
+	if( res < 0 ){
+		fprintf(stderr, "ERROR: unable to fs-syncing '%s' - %s\n", 
+			path, strerror(e));
+		return 16;
+	}
+
+	return 0;
+}
+
+static u64 parse_size(char *s)
+{
+	int len = strlen(s);
+	char c;
+	u64 mult = 1;
+
+	if (!isdigit(s[len - 1])) {
+		c = tolower(s[len - 1]);
+		switch (c) {
+		case 'g':
+			mult *= 1024;
+		case 'm':
+			mult *= 1024;
+		case 'k':
+			mult *= 1024;
+		case 'b':
+			break;
+		default:
+			fprintf(stderr, "Unknown size descriptor %c\n", c);
+			exit(1);
+		}
+		s[len - 1] = '\0';
+	}
+	return atoll(s) * mult;
+}
+
+static int parse_compress_type(char *s)
+{
+	if (strcmp(optarg, "zlib") == 0)
+		return BTRFS_COMPRESS_ZLIB;
+	else if (strcmp(optarg, "lzo") == 0)
+		return BTRFS_COMPRESS_LZO;
+	else {
+		fprintf(stderr, "Unknown compress type %s\n", s);
+		exit(1);
+	};
+}
+
+static const char * const cmd_defrag_usage[] = {
+	"btrfs filesystem defragment [options] <file>|<dir> [<file>|<dir>...]",
+	"Defragment a file or a directory",
+	"",
+	"-v             be verbose",
+	"-c[zlib,lzo]   compress the file while defragmenting",
+	"-f             flush data to disk immediately after defragmenting",
+	"-s start       defragment only from byte onward",
+	"-l len         defragment only up to len bytes",
+	"-t size        minimal size of file to be considered for defragmenting",
+	NULL
+};
+
+static int cmd_defrag(int argc, char **argv)
+{
+	int fd;
+	int flush = 0;
+	u64 start = 0;
+	u64 len = (u64)-1;
+	u32 thresh = 0;
+	int i;
+	int errors = 0;
+	int ret = 0;
+	int verbose = 0;
+	int fancy_ioctl = 0;
+	struct btrfs_ioctl_defrag_range_args range;
+	int e=0;
+	int compress_type = BTRFS_COMPRESS_NONE;
+
+	optind = 1;
+	while(1) {
+		int c = getopt(argc, argv, "vc::fs:l:t:");
+		if (c < 0)
+			break;
+
+		switch(c) {
+		case 'c':
+			compress_type = BTRFS_COMPRESS_ZLIB;
+			if (optarg)
+				compress_type = parse_compress_type(optarg);
+			fancy_ioctl = 1;
+			break;
+		case 'f':
+			flush = 1;
+			fancy_ioctl = 1;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		case 's':
+			start = parse_size(optarg);
+			fancy_ioctl = 1;
+			break;
+		case 'l':
+			len = parse_size(optarg);
+			fancy_ioctl = 1;
+			break;
+		case 't':
+			thresh = parse_size(optarg);
+			fancy_ioctl = 1;
+			break;
+		default:
+			usage(cmd_defrag_usage);
+		}
+	}
+
+	if (check_argc_min(argc - optind, 1))
+		usage(cmd_defrag_usage);
+
+	memset(&range, 0, sizeof(range));
+	range.start = start;
+	range.len = len;
+	range.extent_thresh = thresh;
+	if (compress_type) {
+		range.flags |= BTRFS_DEFRAG_RANGE_COMPRESS;
+		range.compress_type = compress_type;
+	}
+	if (flush)
+		range.flags |= BTRFS_DEFRAG_RANGE_START_IO;
+
+	for (i = optind; i < argc; i++) {
+		if (verbose)
+			printf("%s\n", argv[i]);
+		fd = open_file_or_dir(argv[i]);
+		if (fd < 0) {
+			fprintf(stderr, "failed to open %s\n", argv[i]);
+			perror("open:");
+			errors++;
+			continue;
+		}
+		if (!fancy_ioctl) {
+			ret = ioctl(fd, BTRFS_IOC_DEFRAG, NULL);
+			e=errno;
+		} else {
+			ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, &range);
+			if (ret && errno == ENOTTY) {
+				fprintf(stderr, "ERROR: defrag range ioctl not "
+					"supported in this kernel, please try "
+					"without any options.\n");
+				errors++;
+				close(fd);
+				break;
+			}
+		}
+		if (ret) {
+			fprintf(stderr, "ERROR: defrag failed on %s - %s\n",
+				argv[i], strerror(e));
+			errors++;
+		}
+		close(fd);
+	}
+	if (verbose)
+		printf("%s\n", BTRFS_BUILD_VERSION);
+	if (errors) {
+		fprintf(stderr, "total %d failures\n", errors);
+		exit(1);
+	}
+
+	return errors + 20;
+}
+
+static const char * const cmd_resize_usage[] = {
+	"btrfs filesystem resize [+/-]<newsize>[gkm]|max <path>",
+	"Resize a filesystem",
+	"If 'max' is passed, the filesystem will occupy all available space",
+	"on the device.",
+	NULL
+};
+
+static int cmd_resize(int argc, char **argv)
+{
+	struct btrfs_ioctl_vol_args	args;
+	int	fd, res, len, e;
+	char	*amount, *path;
+
+	if (check_argc_exact(argc, 3))
+		usage(cmd_resize_usage);
+
+	amount = argv[1];
+	path = argv[2];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+	len = strlen(amount);
+	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
+		fprintf(stderr, "ERROR: size value too long ('%s)\n",
+			amount);
+		return 14;
+	}
+
+	printf("Resize '%s' of '%s'\n", path, amount);
+	strncpy(args.name, amount, BTRFS_PATH_NAME_MAX);
+	res = ioctl(fd, BTRFS_IOC_RESIZE, &args);
+	e = errno;
+	close(fd);
+	if( res < 0 ){
+		fprintf(stderr, "ERROR: unable to resize '%s' - %s\n", 
+			path, strerror(e));
+		return 30;
+	}
+	return 0;
+}
+
+static const char * const cmd_label_usage[] = {
+	"btrfs filesystem label <device> [<newlabel>]",
+	"Get or change the label of an unmounted filesystem",
+	"With one argument, get the label of filesystem on <device>.",
+	"If <newlabel> is passed, set the filesystem label to <newlabel>.",
+	NULL
+};
+
+static int cmd_label(int argc, char **argv)
+{
+	if (check_argc_min(argc, 2) || check_argc_max(argc, 3))
+		usage(cmd_label_usage);
+
+	if (argc > 2)
+		return set_label(argv[1], argv[2]);
+	else
+		return get_label(argv[1]);
+}
+
+const struct cmd_group filesystem_cmd_group = {
+	filesystem_cmd_group_usage, NULL, {
+		{ "df", cmd_df, cmd_df_usage, NULL, 0 },
+		{ "show", cmd_show, cmd_show_usage, NULL, 0 },
+		{ "sync", cmd_sync, cmd_sync_usage, NULL, 0 },
+		{ "defragment", cmd_defrag, cmd_defrag_usage, NULL, 0 },
+		{ "balance", cmd_balance, NULL, &balance_cmd_group, 1 },
+		{ "resize", cmd_resize, cmd_resize_usage, NULL, 0 },
+		{ "label", cmd_label, cmd_label_usage, NULL, 0 },
+		{ 0, 0, 0, 0, 0 },
+	}
+};
+
+int cmd_filesystem(int argc, char **argv)
+{
+	return handle_command_group(&filesystem_cmd_group, argc, argv);
+}
diff -Nru btrfs-tools-0.19+20111121/cmds-inspect.c btrfs-tools-0.19+20120328/cmds-inspect.c
--- btrfs-tools-0.19+20111121/cmds-inspect.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/cmds-inspect.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,243 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+
+#include "kerncompat.h"
+#include "ioctl.h"
+
+#include "commands.h"
+
+/* btrfs-list.c */
+char *path_for_root(int fd, u64 root);
+
+static const char * const inspect_cmd_group_usage[] = {
+	"btrfs inspect-internal <command> <args>",
+	NULL
+};
+
+static int __ino_to_path_fd(u64 inum, int fd, int verbose, const char *prepend)
+{
+	int ret;
+	int i;
+	struct btrfs_ioctl_ino_path_args ipa;
+	struct btrfs_data_container *fspath;
+
+	fspath = malloc(4096);
+	if (!fspath)
+		return 1;
+
+	ipa.inum = inum;
+	ipa.size = 4096;
+	ipa.fspath = (u64)fspath;
+
+	ret = ioctl(fd, BTRFS_IOC_INO_PATHS, &ipa);
+	if (ret) {
+		printf("ioctl ret=%d, error: %s\n", ret, strerror(errno));
+		goto out;
+	}
+
+	if (verbose)
+		printf("ioctl ret=%d, bytes_left=%lu, bytes_missing=%lu, "
+			"cnt=%d, missed=%d\n", ret,
+			(unsigned long)fspath->bytes_left,
+			(unsigned long)fspath->bytes_missing,
+			fspath->elem_cnt, fspath->elem_missed);
+
+	for (i = 0; i < fspath->elem_cnt; ++i) {
+		char **str = (char **)fspath->val;
+		str[i] += (unsigned long)fspath->val;
+		if (prepend)
+			printf("%s/%s\n", prepend, str[i]);
+		else
+			printf("%s\n", str[i]);
+	}
+
+out:
+	free(fspath);
+	return ret;
+}
+
+static const char * const cmd_inode_resolve_usage[] = {
+	"btrfs inspect-internal inode-resolve [-v] <inode> <path>",
+	"Get file system paths for the given inode",
+	NULL
+};
+
+static int cmd_inode_resolve(int argc, char **argv)
+{
+	int fd;
+	int verbose = 0;
+
+	optind = 1;
+	while (1) {
+		int c = getopt(argc, argv, "v");
+		if (c < 0)
+			break;
+
+		switch (c) {
+		case 'v':
+			verbose = 1;
+			break;
+		default:
+			usage(cmd_inode_resolve_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 2))
+		usage(cmd_inode_resolve_usage);
+
+	fd = open_file_or_dir(argv[optind+1]);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access '%s'\n", argv[optind+1]);
+		return 12;
+	}
+
+	return __ino_to_path_fd(atoll(argv[optind]), fd, verbose,
+				argv[optind+1]);
+}
+
+static const char * const cmd_logical_resolve_usage[] = {
+	"btrfs inspect-internal logical-resolve [-Pv] <logical> <path>",
+	"Get file system paths for the given logical address",
+	NULL
+};
+
+static int cmd_logical_resolve(int argc, char **argv)
+{
+	int ret;
+	int fd;
+	int i;
+	int verbose = 0;
+	int getpath = 1;
+	int bytes_left;
+	struct btrfs_ioctl_logical_ino_args loi;
+	struct btrfs_data_container *inodes;
+	char full_path[4096];
+	char *path_ptr;
+
+	optind = 1;
+	while (1) {
+		int c = getopt(argc, argv, "Pv");
+		if (c < 0)
+			break;
+
+		switch (c) {
+		case 'P':
+			getpath = 0;
+			break;
+		case 'v':
+			verbose = 1;
+			break;
+		default:
+			usage(cmd_logical_resolve_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 2))
+		usage(cmd_logical_resolve_usage);
+
+	inodes = malloc(4096);
+	if (!inodes)
+		return 1;
+
+	loi.logical = atoll(argv[optind]);
+	loi.size = 4096;
+	loi.inodes = (u64)inodes;
+
+	fd = open_file_or_dir(argv[optind+1]);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access '%s'\n", argv[optind+1]);
+		ret = 12;
+		goto out;
+	}
+
+	ret = ioctl(fd, BTRFS_IOC_LOGICAL_INO, &loi);
+	if (ret) {
+		printf("ioctl ret=%d, error: %s\n", ret, strerror(errno));
+		goto out;
+	}
+
+	if (verbose)
+		printf("ioctl ret=%d, bytes_left=%lu, bytes_missing=%lu, "
+			"cnt=%d, missed=%d\n", ret,
+			(unsigned long)inodes->bytes_left,
+			(unsigned long)inodes->bytes_missing,
+			inodes->elem_cnt, inodes->elem_missed);
+
+	bytes_left = sizeof(full_path);
+	ret = snprintf(full_path, bytes_left, "%s/", argv[optind+1]);
+	path_ptr = full_path + ret;
+	bytes_left -= ret + 1;
+	BUG_ON(bytes_left < 0);
+
+	for (i = 0; i < inodes->elem_cnt; i += 3) {
+		u64 inum = inodes->val[i];
+		u64 offset = inodes->val[i+1];
+		u64 root = inodes->val[i+2];
+		int path_fd;
+		char *name;
+
+		if (getpath) {
+			name = path_for_root(fd, root);
+			if (IS_ERR(name))
+				return PTR_ERR(name);
+			if (!name) {
+				path_ptr[-1] = '\0';
+				path_fd = fd;
+			} else {
+				path_ptr[-1] = '/';
+				ret = snprintf(path_ptr, bytes_left, "%s",
+						name);
+				BUG_ON(ret >= bytes_left);
+				free(name);
+				path_fd = open_file_or_dir(full_path);
+				if (path_fd < 0) {
+					fprintf(stderr, "ERROR: can't access "
+						"'%s'\n", full_path);
+					goto out;
+				}
+			}
+			__ino_to_path_fd(inum, path_fd, verbose, full_path);
+		} else {
+			printf("inode %llu offset %llu root %llu\n", inum,
+				offset, root);
+		}
+	}
+
+out:
+	free(inodes);
+	return ret;
+}
+
+const struct cmd_group inspect_cmd_group = {
+	inspect_cmd_group_usage, NULL, {
+		{ "inode-resolve", cmd_inode_resolve, cmd_inode_resolve_usage,
+			NULL, 0 },
+		{ "logical-resolve", cmd_logical_resolve,
+			cmd_logical_resolve_usage, NULL, 0 },
+		{ 0, 0, 0, 0, 0 }
+	}
+};
+
+int cmd_inspect(int argc, char **argv)
+{
+	return handle_command_group(&inspect_cmd_group, argc, argv);
+}
diff -Nru btrfs-tools-0.19+20111121/cmds-scrub.c btrfs-tools-0.19+20120328/cmds-scrub.c
--- btrfs-tools-0.19+20111121/cmds-scrub.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/cmds-scrub.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,1721 @@
+/*
+ * Copyright (C) 2011 STRATO.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <poll.h>
+#include <sys/file.h>
+#include <uuid/uuid.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <ctype.h>
+#include <signal.h>
+#include <stdarg.h>
+
+#include "ctree.h"
+#include "ioctl.h"
+#include "utils.h"
+#include "volumes.h"
+#include "disk-io.h"
+
+#include "commands.h"
+
+static const char * const scrub_cmd_group_usage[] = {
+	"btrfs scrub <command> [options] <path>|<device>",
+	NULL
+};
+
+#define SCRUB_DATA_FILE "/var/lib/btrfs/scrub.status"
+#define SCRUB_PROGRESS_SOCKET_PATH "/var/lib/btrfs/scrub.progress"
+#define SCRUB_FILE_VERSION_PREFIX "scrub status"
+#define SCRUB_FILE_VERSION "1"
+
+struct scrub_stats {
+	time_t t_start;
+	time_t t_resumed;
+	u64 duration;
+	u64 finished;
+	u64 canceled;
+};
+
+struct scrub_progress {
+	struct btrfs_ioctl_scrub_args scrub_args;
+	int fd;
+	int ret;
+	int skip;
+	struct scrub_stats stats;
+	struct scrub_file_record *resumed;
+	int ioctl_errno;
+	pthread_mutex_t progress_mutex;
+};
+
+struct scrub_file_record {
+	u8 fsid[BTRFS_FSID_SIZE];
+	u64 devid;
+	struct scrub_stats stats;
+	struct btrfs_scrub_progress p;
+};
+
+struct scrub_progress_cycle {
+	int fdmnt;
+	int prg_fd;
+	int do_record;
+	struct btrfs_ioctl_fs_info_args *fi;
+	struct scrub_progress *progress;
+	struct scrub_progress *shared_progress;
+	pthread_mutex_t *write_mutex;
+};
+
+struct scrub_fs_stat {
+	struct btrfs_scrub_progress p;
+	struct scrub_stats s;
+	int i;
+};
+
+static void print_scrub_full(struct btrfs_scrub_progress *sp)
+{
+	printf("\tdata_extents_scrubbed: %lld\n", sp->data_extents_scrubbed);
+	printf("\ttree_extents_scrubbed: %lld\n", sp->tree_extents_scrubbed);
+	printf("\tdata_bytes_scrubbed: %lld\n", sp->data_bytes_scrubbed);
+	printf("\ttree_bytes_scrubbed: %lld\n", sp->tree_bytes_scrubbed);
+	printf("\tread_errors: %lld\n", sp->read_errors);
+	printf("\tcsum_errors: %lld\n", sp->csum_errors);
+	printf("\tverify_errors: %lld\n", sp->verify_errors);
+	printf("\tno_csum: %lld\n", sp->no_csum);
+	printf("\tcsum_discards: %lld\n", sp->csum_discards);
+	printf("\tsuper_errors: %lld\n", sp->super_errors);
+	printf("\tmalloc_errors: %lld\n", sp->malloc_errors);
+	printf("\tuncorrectable_errors: %lld\n", sp->uncorrectable_errors);
+	printf("\tunverified_errors: %lld\n", sp->unverified_errors);
+	printf("\tcorrected_errors: %lld\n", sp->corrected_errors);
+	printf("\tlast_physical: %lld\n", sp->last_physical);
+}
+
+#define ERR(test, ...) do {			\
+	if (test)				\
+		fprintf(stderr, __VA_ARGS__);	\
+} while (0)
+
+#define PRINT_SCRUB_ERROR(test, desc) do {	\
+	if (test)				\
+		printf(" %s=%llu", desc, test);	\
+} while (0)
+
+static void print_scrub_summary(struct btrfs_scrub_progress *p)
+{
+	u64 err_cnt;
+	u64 err_cnt2;
+	char *bytes;
+
+	err_cnt = p->read_errors +
+			p->csum_errors +
+			p->verify_errors +
+			p->super_errors;
+
+	err_cnt2 = p->corrected_errors + p->uncorrectable_errors;
+
+	if (p->malloc_errors)
+		printf("*** WARNING: memory allocation failed while scrubbing. "
+		       "results may be inaccurate\n");
+	bytes = pretty_sizes(p->data_bytes_scrubbed + p->tree_bytes_scrubbed);
+	printf("\ttotal bytes scrubbed: %s with %llu errors\n", bytes,
+		max(err_cnt, err_cnt2));
+	free(bytes);
+	if (err_cnt || err_cnt2) {
+		printf("\terror details:");
+		PRINT_SCRUB_ERROR(p->read_errors, "read");
+		PRINT_SCRUB_ERROR(p->super_errors, "super");
+		PRINT_SCRUB_ERROR(p->verify_errors, "verify");
+		PRINT_SCRUB_ERROR(p->csum_errors, "csum");
+		printf("\n");
+		printf("\tcorrected errors: %llu, uncorrectable errors: %llu, "
+			"unverified errors: %llu\n", p->corrected_errors,
+			p->uncorrectable_errors, p->unverified_errors);
+	}
+}
+
+#define _SCRUB_FS_STAT(p, name, fs_stat) do {	\
+	fs_stat->p.name += p->name;		\
+} while (0)
+
+#define _SCRUB_FS_STAT_MIN(ss, name, fs_stat)	\
+do {						\
+	if (fs_stat->s.name > ss->name) {	\
+		fs_stat->s.name = ss->name;	\
+	}					\
+} while (0)
+
+#define _SCRUB_FS_STAT_ZMIN(ss, name, fs_stat)			\
+do {								\
+	if (!fs_stat->s.name || fs_stat->s.name > ss->name) {	\
+		fs_stat->s.name = ss->name;			\
+	}							\
+} while (0)
+
+#define _SCRUB_FS_STAT_ZMAX(ss, name, fs_stat)				\
+do {									\
+	if (!(fs_stat)->s.name || (fs_stat)->s.name < (ss)->name) {	\
+		(fs_stat)->s.name = (ss)->name;				\
+	}								\
+} while (0)
+
+static void add_to_fs_stat(struct btrfs_scrub_progress *p,
+				struct scrub_stats *ss,
+				struct scrub_fs_stat *fs_stat)
+{
+	_SCRUB_FS_STAT(p, data_extents_scrubbed, fs_stat);
+	_SCRUB_FS_STAT(p, tree_extents_scrubbed, fs_stat);
+	_SCRUB_FS_STAT(p, data_bytes_scrubbed, fs_stat);
+	_SCRUB_FS_STAT(p, tree_bytes_scrubbed, fs_stat);
+	_SCRUB_FS_STAT(p, read_errors, fs_stat);
+	_SCRUB_FS_STAT(p, csum_errors, fs_stat);
+	_SCRUB_FS_STAT(p, verify_errors, fs_stat);
+	_SCRUB_FS_STAT(p, no_csum, fs_stat);
+	_SCRUB_FS_STAT(p, csum_discards, fs_stat);
+	_SCRUB_FS_STAT(p, super_errors, fs_stat);
+	_SCRUB_FS_STAT(p, malloc_errors, fs_stat);
+	_SCRUB_FS_STAT(p, uncorrectable_errors, fs_stat);
+	_SCRUB_FS_STAT(p, corrected_errors, fs_stat);
+	_SCRUB_FS_STAT(p, last_physical, fs_stat);
+	_SCRUB_FS_STAT_ZMIN(ss, t_start, fs_stat);
+	_SCRUB_FS_STAT_ZMIN(ss, t_resumed, fs_stat);
+	_SCRUB_FS_STAT_ZMAX(ss, duration, fs_stat);
+	_SCRUB_FS_STAT_ZMAX(ss, canceled, fs_stat);
+	_SCRUB_FS_STAT_MIN(ss, finished, fs_stat);
+}
+
+static void init_fs_stat(struct scrub_fs_stat *fs_stat)
+{
+	memset(fs_stat, 0, sizeof(*fs_stat));
+	fs_stat->s.finished = 1;
+}
+
+static void _print_scrub_ss(struct scrub_stats *ss)
+{
+	char t[4096];
+	struct tm tm;
+
+	if (!ss || !ss->t_start) {
+		printf("\tno stats available\n");
+		return;
+	}
+	if (ss->t_resumed) {
+		localtime_r(&ss->t_resumed, &tm);
+		strftime(t, sizeof(t), "%c", &tm);
+		t[sizeof(t) - 1] = '\0';
+		printf("\tscrub resumed at %s", t);
+	} else {
+		localtime_r(&ss->t_start, &tm);
+		strftime(t, sizeof(t), "%c", &tm);
+		t[sizeof(t) - 1] = '\0';
+		printf("\tscrub started at %s", t);
+	}
+	if (ss->finished && !ss->canceled) {
+		printf(" and finished after %llu seconds\n",
+		       ss->duration);
+	} else if (ss->canceled) {
+		printf(" and was aborted after %llu seconds\n",
+		       ss->duration);
+	} else {
+		printf(", running for %llu seconds\n", ss->duration);
+	}
+}
+
+static void print_scrub_dev(struct btrfs_ioctl_dev_info_args *di,
+				struct btrfs_scrub_progress *p, int raw,
+				const char *append, struct scrub_stats *ss)
+{
+	printf("scrub device %s (id %llu) %s\n", di->path, di->devid,
+	       append ? append : "");
+
+	_print_scrub_ss(ss);
+
+	if (p) {
+		if (raw)
+			print_scrub_full(p);
+		else
+			print_scrub_summary(p);
+	}
+}
+
+static void print_fs_stat(struct scrub_fs_stat *fs_stat, int raw)
+{
+	_print_scrub_ss(&fs_stat->s);
+
+	if (raw)
+		print_scrub_full(&fs_stat->p);
+	else
+		print_scrub_summary(&fs_stat->p);
+}
+
+static void free_history(struct scrub_file_record **last_scrubs)
+{
+	struct scrub_file_record **l = last_scrubs;
+	if (!l)
+		return;
+	while (*l)
+		free(*l++);
+	free(last_scrubs);
+}
+
+/*
+ * cancels a running scrub and makes the master process record the current
+ * progress status before exiting.
+ */
+static int cancel_fd = -1;
+static void scrub_sigint_record_progress(int signal)
+{
+	ioctl(cancel_fd, BTRFS_IOC_SCRUB_CANCEL, NULL);
+}
+
+static int scrub_handle_sigint_parent(void)
+{
+	struct sigaction sa = {
+		.sa_handler = SIG_IGN,
+		.sa_flags = SA_RESTART,
+	};
+
+	return sigaction(SIGINT, &sa, NULL);
+}
+
+static int scrub_handle_sigint_child(int fd)
+{
+	struct sigaction sa = {
+		.sa_handler = fd == -1 ? SIG_DFL : scrub_sigint_record_progress,
+	};
+
+	cancel_fd = fd;
+	return sigaction(SIGINT, &sa, NULL);
+}
+
+static int scrub_datafile(const char *fn_base, const char *fn_local,
+				const char *fn_tmp, char *datafile, int size)
+{
+	int ret;
+	int end = size - 2;
+
+	datafile[end + 1] = '\0';
+	strncpy(datafile, fn_base, end);
+	ret = strlen(datafile);
+
+	if (ret + 1 > end)
+		return -EOVERFLOW;
+
+	datafile[ret] = '.';
+	strncpy(datafile + ret + 1, fn_local, end - ret - 1);
+	ret = strlen(datafile);
+
+	if (ret + 1 > end)
+		return -EOVERFLOW;
+
+	if (fn_tmp) {
+		datafile[ret] = '_';
+		strncpy(datafile + ret + 1, fn_tmp, end - ret - 1);
+		ret = strlen(datafile);
+
+		if (ret > end)
+			return -EOVERFLOW;
+	}
+
+	return 0;
+}
+
+static int scrub_open_file(const char *datafile, int m)
+{
+	int fd;
+	int ret;
+
+	fd = open(datafile, m, 0600);
+	if (fd < 0)
+		return -errno;
+
+	ret = flock(fd, LOCK_EX|LOCK_NB);
+	if (ret) {
+		ret = errno;
+		close(fd);
+		return -ret;
+	}
+
+	return fd;
+}
+
+static int scrub_open_file_r(const char *fn_base, const char *fn_local)
+{
+	int ret;
+	char datafile[BTRFS_PATH_NAME_MAX + 1];
+	ret = scrub_datafile(fn_base, fn_local, NULL,
+				datafile, sizeof(datafile));
+	if (ret < 0)
+		return ret;
+	return scrub_open_file(datafile, O_RDONLY);
+}
+
+static int scrub_open_file_w(const char *fn_base, const char *fn_local,
+				const char *tmp)
+{
+	int ret;
+	char datafile[BTRFS_PATH_NAME_MAX + 1];
+	ret = scrub_datafile(fn_base, fn_local, tmp,
+				datafile, sizeof(datafile));
+	if (ret < 0)
+		return ret;
+	return scrub_open_file(datafile, O_WRONLY|O_CREAT);
+}
+
+static int scrub_rename_file(const char *fn_base, const char *fn_local,
+				const char *tmp)
+{
+	int ret;
+	char datafile_old[BTRFS_PATH_NAME_MAX + 1];
+	char datafile_new[BTRFS_PATH_NAME_MAX + 1];
+	ret = scrub_datafile(fn_base, fn_local, tmp,
+				datafile_old, sizeof(datafile_old));
+	if (ret < 0)
+		return ret;
+	ret = scrub_datafile(fn_base, fn_local, NULL,
+				datafile_new, sizeof(datafile_new));
+	if (ret < 0)
+		return ret;
+	ret = rename(datafile_old, datafile_new);
+	return ret ? -errno : 0;
+}
+
+#define _SCRUB_KVREAD(ret, i, name, avail, l, dest) if (ret == 0) {	  \
+	ret = scrub_kvread(i, sizeof(#name), avail, l, #name, dest.name); \
+}
+
+/*
+ * returns 0 if the key did not match (nothing was read)
+ *         1 if the key did match (success)
+ *        -1 if the key did match and an error occured
+ */
+static int scrub_kvread(int *i, int len, int avail, const char *buf,
+			const char *key, u64 *dest)
+{
+	int j;
+
+	if (*i + len + 1 < avail && strncmp(&buf[*i], key, len - 1) == 0) {
+		*i += len - 1;
+		if (buf[*i] != ':')
+			return -1;
+		*i += 1;
+		for (j = 0; isdigit(buf[*i + j]) && *i + j < avail; ++j)
+			;
+		if (*i + j >= avail)
+			return -1;
+		*dest = atoll(&buf[*i]);
+		*i += j;
+		return 1;
+	}
+
+	return 0;
+}
+
+#define _SCRUB_INVALID do {						\
+	if (report_errors)						\
+		fprintf(stderr, "WARNING: invalid data in line %d pos "	\
+			"%d state %d (near \"%.*s\") at %s:%d\n",	\
+			lineno, i, state, 20 > avail ? avail : 20,	\
+			l + i,	__FILE__, __LINE__);			\
+	goto skip;							\
+} while (0)
+
+static struct scrub_file_record **scrub_read_file(int fd, int report_errors)
+{
+	int avail = 0;
+	int old_avail = 0;
+	char l[16 * 1024];
+	int state = 0;
+	int curr = -1;
+	int i = 0;
+	int j;
+	int ret;
+	int eof = 0;
+	int lineno = 0;
+	u64 version;
+	char empty_uuid[BTRFS_FSID_SIZE] = {0};
+	struct scrub_file_record **p = NULL;
+
+	if (fd < 0)
+		return ERR_PTR(-EINVAL);
+
+again:
+	old_avail = avail - i;
+	BUG_ON(old_avail < 0);
+	if (old_avail)
+		memmove(l, l + i, old_avail);
+	avail = read(fd, l + old_avail, sizeof(l) - old_avail);
+	if (avail == 0)
+		eof = 1;
+	if (avail == 0 && old_avail == 0) {
+		if (curr >= 0 &&
+		    memcmp(p[curr]->fsid, empty_uuid, BTRFS_FSID_SIZE) == 0) {
+			p[curr] = NULL;
+		} else if (curr == -1) {
+			p = ERR_PTR(-ENODATA);
+		}
+		return p;
+	}
+	if (avail == -1)
+		return ERR_PTR(-errno);
+	avail += old_avail;
+
+	i = 0;
+	while (i < avail) {
+		switch (state) {
+		case 0: /* start of file */
+			ret = scrub_kvread(&i,
+				sizeof(SCRUB_FILE_VERSION_PREFIX), avail, l,
+				SCRUB_FILE_VERSION_PREFIX, &version);
+			if (ret != 1)
+				_SCRUB_INVALID;
+			if (version != atoll(SCRUB_FILE_VERSION))
+				return ERR_PTR(-ENOTSUP);
+			state = 6;
+			continue;
+		case 1: /* start of line, alloc */
+			/*
+			 * this state makes sure we have a complete line in
+			 * further processing, so we don't need wrap-tracking
+			 * everywhere.
+			 */
+			if (!eof && !memchr(l + i, '\n', avail - i))
+				goto again;
+			++lineno;
+			if (curr > -1 && memcmp(p[curr]->fsid, empty_uuid,
+						BTRFS_FSID_SIZE) == 0) {
+				state = 2;
+				continue;
+			}
+			++curr;
+			p = realloc(p, (curr + 2) * sizeof(*p));
+			if (p)
+				p[curr] = malloc(sizeof(**p));
+			if (!p || !p[curr])
+				return ERR_PTR(-errno);
+			memset(p[curr], 0, sizeof(**p));
+			p[curr + 1] = NULL;
+			++state;
+			/* fall through */
+		case 2: /* start of line, skip space */
+			while (isspace(l[i]) && i < avail) {
+				if (l[i] == '\n')
+					++lineno;
+				++i;
+			}
+			if (i >= avail ||
+			    (!eof && !memchr(l + i, '\n', avail - i)))
+				goto again;
+			++state;
+			/* fall through */
+		case 3: /* read fsid */
+			if (i == avail)
+				continue;
+			for (j = 0; l[i + j] != ':' && i + j < avail; ++j)
+				;
+			if (i + j + 1 >= avail)
+				_SCRUB_INVALID;
+			if (j != 36)
+				_SCRUB_INVALID;
+			l[i + j] = '\0';
+			ret = uuid_parse(l + i, p[curr]->fsid);
+			if (ret)
+				_SCRUB_INVALID;
+			i += j + 1;
+			++state;
+			/* fall through */
+		case 4: /* read dev id */
+			for (j = 0; isdigit(l[i + j]) && i+j < avail; ++j)
+				;
+			if (j == 0 || i + j + 1 >= avail)
+				_SCRUB_INVALID;
+			p[curr]->devid = atoll(&l[i]);
+			i += j + 1;
+			++state;
+			/* fall through */
+		case 5: /* read key/value pair */
+			ret = 0;
+			_SCRUB_KVREAD(ret, &i, data_extents_scrubbed, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, data_extents_scrubbed, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, tree_extents_scrubbed, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, data_bytes_scrubbed, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, tree_bytes_scrubbed, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, read_errors, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, csum_errors, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, verify_errors, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, no_csum, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, csum_discards, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, super_errors, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, malloc_errors, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, uncorrectable_errors, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, corrected_errors, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, last_physical, avail, l,
+					&p[curr]->p);
+			_SCRUB_KVREAD(ret, &i, finished, avail, l,
+					&p[curr]->stats);
+			_SCRUB_KVREAD(ret, &i, t_start, avail, l,
+					(u64 *)&p[curr]->stats);
+			_SCRUB_KVREAD(ret, &i, t_resumed, avail, l,
+					(u64 *)&p[curr]->stats);
+			_SCRUB_KVREAD(ret, &i, duration, avail, l,
+					(u64 *)&p[curr]->stats);
+			_SCRUB_KVREAD(ret, &i, canceled, avail, l,
+					&p[curr]->stats);
+			if (ret != 1)
+				_SCRUB_INVALID;
+			++state;
+			/* fall through */
+		case 6: /* after number */
+			if (l[i] == '|')
+				state = 5;
+			else if (l[i] == '\n')
+				state = 1;
+			else
+				_SCRUB_INVALID;
+			++i;
+			continue;
+		case 99: /* skip rest of line */
+skip:
+			state = 99;
+			do {
+				++i;
+				if (l[i - 1] == '\n') {
+					state = 1;
+					break;
+				}
+			} while (i < avail);
+			continue;
+		}
+		BUG();
+	}
+	goto again;
+}
+
+static int scrub_write_buf(int fd, const void *data, int len)
+{
+	int ret;
+	ret = write(fd, data, len);
+	return ret - len;
+}
+
+static int scrub_writev(int fd, char *buf, int max, const char *fmt, ...)
+				__attribute__ ((format (printf, 4, 5)));
+static int scrub_writev(int fd, char *buf, int max, const char *fmt, ...)
+{
+	int ret;
+	va_list args;
+
+	va_start(args, fmt);
+	ret = vsnprintf(buf, max, fmt, args);
+	va_end(args);
+	if (ret >= max)
+		return ret - max;
+	return scrub_write_buf(fd, buf, ret);
+}
+
+#define _SCRUB_SUM(dest, data, name) dest->scrub_args.progress.name =	\
+			data->resumed->p.name + data->scrub_args.progress.name
+
+static struct scrub_progress *scrub_resumed_stats(struct scrub_progress *data,
+						  struct scrub_progress *dest)
+{
+	if (!data->resumed || data->skip)
+		return data;
+
+	_SCRUB_SUM(dest, data, data_extents_scrubbed);
+	_SCRUB_SUM(dest, data, tree_extents_scrubbed);
+	_SCRUB_SUM(dest, data, data_bytes_scrubbed);
+	_SCRUB_SUM(dest, data, tree_bytes_scrubbed);
+	_SCRUB_SUM(dest, data, read_errors);
+	_SCRUB_SUM(dest, data, csum_errors);
+	_SCRUB_SUM(dest, data, verify_errors);
+	_SCRUB_SUM(dest, data, no_csum);
+	_SCRUB_SUM(dest, data, csum_discards);
+	_SCRUB_SUM(dest, data, super_errors);
+	_SCRUB_SUM(dest, data, malloc_errors);
+	_SCRUB_SUM(dest, data, uncorrectable_errors);
+	_SCRUB_SUM(dest, data, corrected_errors);
+	_SCRUB_SUM(dest, data, last_physical);
+	dest->stats.canceled = data->stats.canceled;
+	dest->stats.finished = data->stats.finished;
+	dest->stats.t_resumed = data->stats.t_start;
+	dest->stats.t_start = data->resumed->stats.t_start;
+	dest->stats.duration = data->resumed->stats.duration +
+							data->stats.duration;
+	dest->scrub_args.devid = data->scrub_args.devid;
+	return dest;
+}
+
+#define _SCRUB_KVWRITE(fd, buf, name, use)		\
+	scrub_kvwrite(fd, buf, sizeof(buf), #name,	\
+			use->scrub_args.progress.name)
+
+#define _SCRUB_KVWRITE_STATS(fd, buf, name, use)	\
+	scrub_kvwrite(fd, buf, sizeof(buf), #name,	\
+			use->stats.name)
+
+static int scrub_kvwrite(int fd, char *buf, int max, const char *key, u64 val)
+{
+	return scrub_writev(fd, buf, max, "|%s:%lld", key, val);
+}
+
+static int scrub_write_file(int fd, const char *fsid,
+				struct scrub_progress *data, int n)
+{
+	int ret = 0;
+	int i;
+	char buf[1024];
+	struct scrub_progress local;
+	struct scrub_progress *use;
+
+	if (n < 1)
+		return -EINVAL;
+
+	/* each -1 is to subtract one \0 byte, the + 2 is for ':' and '\n' */
+	ret = scrub_write_buf(fd, SCRUB_FILE_VERSION_PREFIX ":"
+				SCRUB_FILE_VERSION "\n",
+				(sizeof(SCRUB_FILE_VERSION_PREFIX) - 1) +
+				(sizeof(SCRUB_FILE_VERSION) - 1) + 2);
+	if (ret)
+		return -EOVERFLOW;
+
+	for (i = 0; i < n; ++i) {
+		use = scrub_resumed_stats(&data[i], &local);
+		if (scrub_write_buf(fd, fsid, strlen(fsid)) ||
+		    scrub_write_buf(fd, ":", 1) ||
+		    scrub_writev(fd, buf, sizeof(buf), "%lld",
+					use->scrub_args.devid) ||
+		    scrub_write_buf(fd, buf, ret) ||
+		    _SCRUB_KVWRITE(fd, buf, data_extents_scrubbed, use) ||
+		    _SCRUB_KVWRITE(fd, buf, tree_extents_scrubbed, use) ||
+		    _SCRUB_KVWRITE(fd, buf, data_bytes_scrubbed, use) ||
+		    _SCRUB_KVWRITE(fd, buf, tree_bytes_scrubbed, use) ||
+		    _SCRUB_KVWRITE(fd, buf, read_errors, use) ||
+		    _SCRUB_KVWRITE(fd, buf, csum_errors, use) ||
+		    _SCRUB_KVWRITE(fd, buf, verify_errors, use) ||
+		    _SCRUB_KVWRITE(fd, buf, no_csum, use) ||
+		    _SCRUB_KVWRITE(fd, buf, csum_discards, use) ||
+		    _SCRUB_KVWRITE(fd, buf, super_errors, use) ||
+		    _SCRUB_KVWRITE(fd, buf, malloc_errors, use) ||
+		    _SCRUB_KVWRITE(fd, buf, uncorrectable_errors, use) ||
+		    _SCRUB_KVWRITE(fd, buf, corrected_errors, use) ||
+		    _SCRUB_KVWRITE(fd, buf, last_physical, use) ||
+		    _SCRUB_KVWRITE_STATS(fd, buf, t_start, use) ||
+		    _SCRUB_KVWRITE_STATS(fd, buf, t_resumed, use) ||
+		    _SCRUB_KVWRITE_STATS(fd, buf, duration, use) ||
+		    _SCRUB_KVWRITE_STATS(fd, buf, canceled, use) ||
+		    _SCRUB_KVWRITE_STATS(fd, buf, finished, use) ||
+		    scrub_write_buf(fd, "\n", 1)) {
+			return -EOVERFLOW;
+		}
+	}
+
+	return 0;
+}
+
+static int scrub_write_progress(pthread_mutex_t *m, const char *fsid,
+				struct scrub_progress *data, int n)
+{
+	int ret;
+	int err;
+	int fd = 0;
+	int old;
+
+	ret = pthread_mutex_lock(m);
+	if (ret) {
+		err = -errno;
+		goto out;
+	}
+
+	ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old);
+	if (ret) {
+		err = -ret;
+		goto out;
+	}
+
+	fd = scrub_open_file_w(SCRUB_DATA_FILE, fsid, "tmp");
+	if (fd < 0) {
+		err = fd;
+		goto out;
+	}
+	err = scrub_write_file(fd, fsid, data, n);
+	if (err)
+		goto out;
+	err = scrub_rename_file(SCRUB_DATA_FILE, fsid, "tmp");
+	if (err)
+		goto out;
+
+out:
+	if (fd > 0) {
+		ret = close(fd);
+		if (ret)
+			err = -errno;
+	}
+
+	ret = pthread_mutex_unlock(m);
+	if (ret && !err)
+		err = -ret;
+
+	ret = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old);
+	if (ret && !err)
+		err = -ret;
+
+	return err;
+}
+
+static void *scrub_one_dev(void *ctx)
+{
+	struct scrub_progress *sp = ctx;
+	int ret;
+	struct timeval tv;
+
+	sp->stats.canceled = 0;
+	sp->stats.duration = 0;
+	sp->stats.finished = 0;
+
+	ret = ioctl(sp->fd, BTRFS_IOC_SCRUB, &sp->scrub_args);
+	gettimeofday(&tv, NULL);
+	sp->ret = ret;
+	sp->stats.duration = tv.tv_sec - sp->stats.t_start;
+	sp->stats.canceled = !!ret;
+	sp->ioctl_errno = errno;
+	ret = pthread_mutex_lock(&sp->progress_mutex);
+	if (ret)
+		return ERR_PTR(-ret);
+	sp->stats.finished = 1;
+	ret = pthread_mutex_unlock(&sp->progress_mutex);
+	if (ret)
+		return ERR_PTR(-ret);
+
+	return NULL;
+}
+
+static void *progress_one_dev(void *ctx)
+{
+	struct scrub_progress *sp = ctx;
+
+	sp->ret = ioctl(sp->fd, BTRFS_IOC_SCRUB_PROGRESS, &sp->scrub_args);
+	sp->ioctl_errno = errno;
+
+	return NULL;
+}
+
+static void *scrub_progress_cycle(void *ctx)
+{
+	int ret;
+	int old;
+	int i;
+	char fsid[37];
+	struct scrub_progress *sp;
+	struct scrub_progress *sp_last;
+	struct scrub_progress *sp_shared;
+	struct timeval tv;
+	struct scrub_progress_cycle *spc = ctx;
+	int ndev = spc->fi->num_devices;
+	int this = 1;
+	int last = 0;
+	int peer_fd = -1;
+	struct pollfd accept_poll_fd = {
+		.fd = spc->prg_fd,
+		.events = POLLIN,
+		.revents = 0,
+	};
+	struct pollfd write_poll_fd = {
+		.events = POLLOUT,
+		.revents = 0,
+	};
+	struct sockaddr_un peer;
+	socklen_t peer_size = sizeof(peer);
+
+	ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);
+	if (ret)
+		return ERR_PTR(-ret);
+
+	uuid_unparse(spc->fi->fsid, fsid);
+
+	for (i = 0; i < ndev; ++i) {
+		sp = &spc->progress[i];
+		sp_last = &spc->progress[i + ndev];
+		sp_shared = &spc->shared_progress[i];
+		sp->scrub_args.devid = sp_last->scrub_args.devid =
+						sp_shared->scrub_args.devid;
+		sp->fd = sp_last->fd = spc->fdmnt;
+		sp->stats.t_start = sp_last->stats.t_start =
+						sp_shared->stats.t_start;
+		sp->resumed = sp_last->resumed = sp_shared->resumed;
+		sp->skip = sp_last->skip = sp_shared->skip;
+		sp->stats.finished = sp_last->stats.finished =
+						sp_shared->stats.finished;
+	}
+
+	while (1) {
+		ret = poll(&accept_poll_fd, 1, 5 * 1000);
+		if (ret == -1)
+			return ERR_PTR(-errno);
+		if (ret)
+			peer_fd = accept(spc->prg_fd, (struct sockaddr *)&peer,
+					 &peer_size);
+		gettimeofday(&tv, NULL);
+		this = (this + 1)%2;
+		last = (last + 1)%2;
+		for (i = 0; i < ndev; ++i) {
+			sp = &spc->progress[this * ndev + i];
+			sp_last = &spc->progress[last * ndev + i];
+			sp_shared = &spc->shared_progress[i];
+			if (sp->stats.finished)
+				continue;
+			progress_one_dev(sp);
+			sp->stats.duration = tv.tv_sec - sp->stats.t_start;
+			if (!sp->ret)
+				continue;
+			if (sp->ioctl_errno != ENOTCONN &&
+			    sp->ioctl_errno != ENODEV)
+				return ERR_PTR(-sp->ioctl_errno);
+			/*
+			 * scrub finished or device removed, check the
+			 * finished flag. if unset, just use the last
+			 * result we got for the current write and go
+			 * on. flag should be set on next cycle, then.
+			 */
+			ret = pthread_mutex_lock(&sp_shared->progress_mutex);
+			if (ret)
+				return ERR_PTR(-ret);
+			if (!sp_shared->stats.finished) {
+				ret = pthread_mutex_unlock(
+						&sp_shared->progress_mutex);
+				if (ret)
+					return ERR_PTR(-ret);
+				memcpy(sp, sp_last, sizeof(*sp));
+				continue;
+			}
+			ret = pthread_mutex_unlock(&sp_shared->progress_mutex);
+			if (ret)
+				return ERR_PTR(-ret);
+			memcpy(sp, sp_shared, sizeof(*sp));
+			memcpy(sp_last, sp_shared, sizeof(*sp));
+		}
+		if (peer_fd != -1) {
+			write_poll_fd.fd = peer_fd;
+			ret = poll(&write_poll_fd, 1, 0);
+			if (ret == -1)
+				return ERR_PTR(-errno);
+			if (ret) {
+				ret = scrub_write_file(
+					peer_fd, fsid,
+					&spc->progress[this * ndev], ndev);
+				if (ret)
+					return ERR_PTR(ret);
+			}
+			close(peer_fd);
+			peer_fd = -1;
+		}
+		if (!spc->do_record)
+			continue;
+		ret = scrub_write_progress(spc->write_mutex, fsid,
+					   &spc->progress[this * ndev], ndev);
+		if (ret)
+			return ERR_PTR(ret);
+	}
+}
+
+static struct scrub_file_record *last_dev_scrub(
+		struct scrub_file_record *const *const past_scrubs, u64 devid)
+{
+	int i;
+
+	if (!past_scrubs || IS_ERR(past_scrubs))
+		return NULL;
+
+	for (i = 0; past_scrubs[i]; ++i)
+		if (past_scrubs[i]->devid == devid)
+			return past_scrubs[i];
+
+	return NULL;
+}
+
+static int scrub_device_info(int fd, u64 devid,
+			     struct btrfs_ioctl_dev_info_args *di_args)
+{
+	int ret;
+
+	di_args->devid = devid;
+	memset(&di_args->uuid, '\0', sizeof(di_args->uuid));
+
+	ret = ioctl(fd, BTRFS_IOC_DEV_INFO, di_args);
+	return ret ? -errno : 0;
+}
+
+static int scrub_fs_info(int fd, char *path,
+				struct btrfs_ioctl_fs_info_args *fi_args,
+				struct btrfs_ioctl_dev_info_args **di_ret)
+{
+	int ret = 0;
+	int ndevs = 0;
+	int i = 1;
+	struct btrfs_fs_devices *fs_devices_mnt = NULL;
+	struct btrfs_ioctl_dev_info_args *di_args;
+	char mp[BTRFS_PATH_NAME_MAX + 1];
+
+	memset(fi_args, 0, sizeof(*fi_args));
+
+	ret = ioctl(fd, BTRFS_IOC_FS_INFO, fi_args);
+	if (ret && errno == EINVAL) {
+		/* path is no mounted btrfs. try if it's a device */
+		ret = check_mounted_where(fd, path, mp, sizeof(mp),
+						&fs_devices_mnt);
+		if (!ret)
+			return -EINVAL;
+		if (ret < 0)
+			return ret;
+		fi_args->num_devices = 1;
+		fi_args->max_id = fs_devices_mnt->latest_devid;
+		i = fs_devices_mnt->latest_devid;
+		memcpy(fi_args->fsid, fs_devices_mnt->fsid, BTRFS_FSID_SIZE);
+		close(fd);
+		fd = open_file_or_dir(mp);
+		if (fd < 0)
+			return -errno;
+	} else if (ret) {
+		return -errno;
+	}
+
+	if (!fi_args->num_devices)
+		return 0;
+
+	di_args = *di_ret = malloc(fi_args->num_devices * sizeof(*di_args));
+	if (!di_args)
+		return -errno;
+
+	for (; i <= fi_args->max_id; ++i) {
+		BUG_ON(ndevs >= fi_args->num_devices);
+		ret = scrub_device_info(fd, i, &di_args[ndevs]);
+		if (ret == -ENODEV)
+			continue;
+		if (ret)
+			return ret;
+		++ndevs;
+	}
+
+	BUG_ON(ndevs == 0);
+
+	return 0;
+}
+
+int mkdir_p(char *path)
+{
+	int i;
+	int ret;
+
+	for (i = 1; i < strlen(path); ++i) {
+		if (path[i] != '/')
+			continue;
+		path[i] = '\0';
+		ret = mkdir(path, 0777);
+		if (ret && errno != EEXIST)
+			return 1;
+		path[i] = '/';
+	}
+
+	return 0;
+}
+
+static const char * const cmd_scrub_start_usage[];
+static const char * const cmd_scrub_resume_usage[];
+
+static int scrub_start(int argc, char **argv, int resume)
+{
+	int fdmnt;
+	int prg_fd = -1;
+	int fdres = -1;
+	int ret;
+	pid_t pid;
+	int c;
+	int i;
+	int err = 0;
+	int e_uncorrectable = 0;
+	int e_correctable = 0;
+	int print_raw = 0;
+	char *path;
+	int do_background = 1;
+	int do_wait = 0;
+	int do_print = 0;
+	int do_quiet = 0;
+	int do_record = 1;
+	int readonly = 0;
+	int do_stats_per_dev = 0;
+	int n_start = 0;
+	int n_skip = 0;
+	int n_resume = 0;
+	struct btrfs_ioctl_fs_info_args fi_args;
+	struct btrfs_ioctl_dev_info_args *di_args = NULL;
+	struct scrub_progress *sp = NULL;
+	struct scrub_fs_stat fs_stat;
+	struct timeval tv;
+	struct sockaddr_un addr = {
+		.sun_family = AF_UNIX,
+	};
+	pthread_t *t_devs = NULL;
+	pthread_t t_prog;
+	pthread_attr_t t_attr;
+	struct scrub_file_record **past_scrubs = NULL;
+	struct scrub_file_record *last_scrub = NULL;
+	char *datafile = strdup(SCRUB_DATA_FILE);
+	char fsid[37];
+	char sock_path[BTRFS_PATH_NAME_MAX + 1] = "";
+	struct scrub_progress_cycle spc;
+	pthread_mutex_t spc_write_mutex = PTHREAD_MUTEX_INITIALIZER;
+	void *terr;
+	u64 devid;
+
+	optind = 1;
+	while ((c = getopt(argc, argv, "BdqrR")) != -1) {
+		switch (c) {
+		case 'B':
+			do_background = 0;
+			do_wait = 1;
+			do_print = 1;
+			break;
+		case 'd':
+			do_stats_per_dev = 1;
+			break;
+		case 'q':
+			do_quiet = 1;
+			break;
+		case 'r':
+			readonly = 1;
+			break;
+		case 'R':
+			print_raw = 1;
+			break;
+		case '?':
+		default:
+			usage(resume ? cmd_scrub_resume_usage :
+						cmd_scrub_start_usage);
+		}
+	}
+
+	/* try to catch most error cases before forking */
+
+	if (check_argc_exact(argc - optind, 1)) {
+		usage(resume ? cmd_scrub_resume_usage :
+					cmd_scrub_start_usage);
+	}
+
+	spc.progress = NULL;
+	if (do_quiet && do_print)
+		do_print = 0;
+
+	if (mkdir_p(datafile)) {
+		ERR(!do_quiet, "WARNING: cannot create scrub data "
+			       "file, mkdir %s failed: %s. Status recording "
+			       "disabled\n", datafile, strerror(errno));
+		do_record = 0;
+	}
+	free(datafile);
+
+	path = argv[optind];
+
+	fdmnt = open_file_or_dir(path);
+	if (fdmnt < 0) {
+		ERR(!do_quiet, "ERROR: can't access '%s'\n", path);
+		return 12;
+	}
+
+	ret = scrub_fs_info(fdmnt, path, &fi_args, &di_args);
+	if (ret) {
+		ERR(!do_quiet, "ERROR: getting dev info for scrub failed: "
+		    "%s\n", strerror(-ret));
+		err = 1;
+		goto out;
+	}
+	if (!fi_args.num_devices) {
+		ERR(!do_quiet, "ERROR: no devices found\n");
+		err = 1;
+		goto out;
+	}
+
+	uuid_unparse(fi_args.fsid, fsid);
+	fdres = scrub_open_file_r(SCRUB_DATA_FILE, fsid);
+	if (fdres < 0 && fdres != -ENOENT) {
+		ERR(!do_quiet, "WARNING: failed to open status file: "
+		    "%s\n", strerror(-fdres));
+	} else if (fdres >= 0) {
+		past_scrubs = scrub_read_file(fdres, !do_quiet);
+		if (IS_ERR(past_scrubs))
+			ERR(!do_quiet, "WARNING: failed to read status file: "
+			    "%s\n", strerror(-PTR_ERR(past_scrubs)));
+		close(fdres);
+	}
+
+	t_devs = malloc(fi_args.num_devices * sizeof(*t_devs));
+	sp = calloc(fi_args.num_devices, sizeof(*sp));
+	spc.progress = calloc(fi_args.num_devices * 2, sizeof(*spc.progress));
+
+	if (!t_devs || !sp || !spc.progress) {
+		ERR(!do_quiet, "ERROR: scrub failed: %s", strerror(errno));
+		err = 1;
+		goto out;
+	}
+
+	ret = pthread_attr_init(&t_attr);
+	if (ret) {
+		ERR(!do_quiet, "ERROR: pthread_attr_init failed: %s\n",
+		    strerror(ret));
+		err = 1;
+		goto out;
+	}
+
+	for (i = 0; i < fi_args.num_devices; ++i) {
+		devid = di_args[i].devid;
+		ret = pthread_mutex_init(&sp[i].progress_mutex, NULL);
+		if (ret) {
+			ERR(!do_quiet, "ERROR: pthread_mutex_init failed: "
+			    "%s\n", strerror(ret));
+			err = 1;
+			goto out;
+		}
+		last_scrub = last_dev_scrub(past_scrubs, devid);
+		sp[i].scrub_args.devid = devid;
+		sp[i].fd = fdmnt;
+		if (resume && last_scrub && (last_scrub->stats.canceled ||
+					     !last_scrub->stats.finished)) {
+			++n_resume;
+			sp[i].scrub_args.start = last_scrub->p.last_physical;
+			sp[i].resumed = last_scrub;
+		} else if (resume) {
+			++n_skip;
+			sp[i].skip = 1;
+			sp[i].resumed = last_scrub;
+			continue;
+		} else {
+			++n_start;
+			sp[i].scrub_args.start = 0ll;
+			sp[i].resumed = NULL;
+		}
+		sp[i].skip = 0;
+		sp[i].scrub_args.end = (u64)-1ll;
+		sp[i].scrub_args.flags = readonly ? BTRFS_SCRUB_READONLY : 0;
+	}
+
+	if (!n_start && !n_resume) {
+		if (!do_quiet)
+			printf("scrub: nothing to resume for %s, fsid %s\n",
+			       path, fsid);
+		err = 0;
+		goto out;
+	}
+
+	ret = prg_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+	while (ret != -1) {
+		ret = scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH, fsid, NULL,
+					sock_path, sizeof(sock_path));
+		/* ignore EOVERFLOW, try using a shorter path for the socket */
+		addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
+		strncpy(addr.sun_path, sock_path, sizeof(addr.sun_path) - 1);
+		ret = bind(prg_fd, (struct sockaddr *)&addr, sizeof(addr));
+		if (ret != -1 || errno != EADDRINUSE)
+			break;
+		/*
+		 * bind failed with EADDRINUSE. so let's see if anyone answers
+		 * when we make a call to the socket ...
+		 */
+		ret = connect(prg_fd, (struct sockaddr *)&addr, sizeof(addr));
+		if (!ret || errno != ECONNREFUSED) {
+			/* ... yes, so scrub must be running. error out */
+			fprintf(stderr, "ERROR: scrub already running\n");
+			close(prg_fd);
+			goto out;
+		}
+		/*
+		 * ... no, this means someone left us alone with an unused
+		 * socket in the file system. remove it and try again.
+		 */
+		ret = unlink(sock_path);
+	}
+	if (ret != -1)
+		ret = listen(prg_fd, 100);
+	if (ret == -1) {
+		ERR(!do_quiet, "WARNING: failed to open the progress status "
+		    "socket at %s: %s. Progress cannot be queried\n",
+		    sock_path[0] ? sock_path : SCRUB_PROGRESS_SOCKET_PATH,
+		    strerror(errno));
+		if (prg_fd != -1) {
+			close(prg_fd);
+			prg_fd = -1;
+			if (sock_path[0])
+				unlink(sock_path);
+		}
+	}
+
+	if (do_record) {
+		/* write all-zero progress file for a start */
+		ret = scrub_write_progress(&spc_write_mutex, fsid, sp,
+					   fi_args.num_devices);
+		if (ret) {
+			ERR(!do_quiet, "WARNING: failed to write the progress "
+			    "status file: %s. Status recording disabled\n",
+			    strerror(-ret));
+			do_record = 0;
+		}
+	}
+
+	if (do_background) {
+		pid = fork();
+		if (pid == -1) {
+			ERR(!do_quiet, "ERROR: cannot scrub, fork failed: "
+					"%s\n", strerror(errno));
+			err = 1;
+			goto out;
+		}
+
+		if (pid) {
+			int stat;
+			scrub_handle_sigint_parent();
+			if (!do_quiet)
+				printf("scrub %s on %s, fsid %s (pid=%d)\n",
+				       n_start ? "started" : "resumed",
+				       path, fsid, pid);
+			if (!do_wait) {
+				err = 0;
+				goto out;
+			}
+			ret = wait(&stat);
+			if (ret != pid) {
+				ERR(!do_quiet, "ERROR: wait failed: (ret=%d) "
+				    "%s\n", ret, strerror(errno));
+				err = 1;
+				goto out;
+			}
+			if (!WIFEXITED(stat) || WEXITSTATUS(stat)) {
+				ERR(!do_quiet, "ERROR: scrub process failed\n");
+				err = WIFEXITED(stat) ? WEXITSTATUS(stat) : -1;
+				goto out;
+			}
+			err = 0;
+			goto out;
+		}
+	}
+
+	scrub_handle_sigint_child(fdmnt);
+
+	for (i = 0; i < fi_args.num_devices; ++i) {
+		if (sp[i].skip) {
+			sp[i].scrub_args.progress = sp[i].resumed->p;
+			sp[i].stats = sp[i].resumed->stats;
+			sp[i].ret = 0;
+			sp[i].stats.finished = 1;
+			continue;
+		}
+		devid = di_args[i].devid;
+		gettimeofday(&tv, NULL);
+		sp[i].stats.t_start = tv.tv_sec;
+		ret = pthread_create(&t_devs[i], &t_attr,
+					scrub_one_dev, &sp[i]);
+		if (ret) {
+			if (do_print)
+				fprintf(stderr, "ERROR: creating "
+					"scrub_one_dev[%llu] thread failed: "
+					"%s\n", devid, strerror(ret));
+			err = 1;
+			goto out;
+		}
+	}
+
+	spc.fdmnt = fdmnt;
+	spc.prg_fd = prg_fd;
+	spc.do_record = do_record;
+	spc.write_mutex = &spc_write_mutex;
+	spc.shared_progress = sp;
+	spc.fi = &fi_args;
+	ret = pthread_create(&t_prog, &t_attr, scrub_progress_cycle, &spc);
+	if (ret) {
+		if (do_print)
+			fprintf(stderr, "ERROR: creating progress thread "
+				"failed: %s\n", strerror(ret));
+		err = 1;
+		goto out;
+	}
+
+	err = 0;
+	for (i = 0; i < fi_args.num_devices; ++i) {
+		if (sp[i].skip)
+			continue;
+		devid = di_args[i].devid;
+		ret = pthread_join(t_devs[i], NULL);
+		if (ret) {
+			if (do_print)
+				fprintf(stderr, "ERROR: pthread_join failed "
+					"for scrub_one_dev[%llu]: %s\n", devid,
+					strerror(ret));
+			++err;
+			continue;
+		}
+		if (sp[i].ret && sp[i].ioctl_errno == ENODEV) {
+			if (do_print)
+				fprintf(stderr, "WARNING: device %lld not "
+					"present\n", devid);
+			continue;
+		}
+		if (sp[i].ret && sp[i].ioctl_errno == ECANCELED) {
+			++err;
+		} else if (sp[i].ret) {
+			if (do_print)
+				fprintf(stderr, "ERROR: scrubbing %s failed "
+					"for device id %lld (%s)\n", path,
+					devid, strerror(sp[i].ioctl_errno));
+			++err;
+			continue;
+		}
+		if (sp[i].scrub_args.progress.uncorrectable_errors > 0)
+			e_uncorrectable++;
+		if (sp[i].scrub_args.progress.corrected_errors > 0
+		    || sp[i].scrub_args.progress.unverified_errors > 0)
+			e_correctable++;
+	}
+
+	if (do_print) {
+		const char *append = "done";
+		if (!do_stats_per_dev)
+			init_fs_stat(&fs_stat);
+		for (i = 0; i < fi_args.num_devices; ++i) {
+			if (do_stats_per_dev) {
+				print_scrub_dev(&di_args[i],
+						&sp[i].scrub_args.progress,
+						print_raw,
+						sp[i].ret ? "canceled" : "done",
+						&sp[i].stats);
+			} else {
+				if (sp[i].ret)
+					append = "canceled";
+				add_to_fs_stat(&sp[i].scrub_args.progress,
+						&sp[i].stats, &fs_stat);
+			}
+		}
+		if (!do_stats_per_dev) {
+			printf("scrub %s for %s\n", append, fsid);
+			print_fs_stat(&fs_stat, print_raw);
+		}
+	}
+
+	ret = pthread_cancel(t_prog);
+	if (!ret)
+		ret = pthread_join(t_prog, &terr);
+	if (do_print && ret) {
+		fprintf(stderr, "ERROR: progress thead handling failed: %s\n",
+			strerror(ret));
+	}
+
+	if (do_print && terr && terr != PTHREAD_CANCELED) {
+		fprintf(stderr, "ERROR: recording progress "
+			"failed: %s\n", strerror(-PTR_ERR(terr)));
+	}
+
+	if (do_record) {
+		ret = scrub_write_progress(&spc_write_mutex, fsid, sp,
+					   fi_args.num_devices);
+		if (ret && do_print) {
+			fprintf(stderr, "ERROR: failed to record the result: "
+				"%s\n", strerror(-ret));
+		}
+	}
+
+	scrub_handle_sigint_child(-1);
+
+out:
+	free_history(past_scrubs);
+	free(di_args);
+	free(t_devs);
+	free(sp);
+	free(spc.progress);
+	if (prg_fd > -1) {
+		close(prg_fd);
+		if (sock_path[0])
+			unlink(sock_path);
+	}
+	close(fdmnt);
+
+	if (err)
+		return 1;
+	if (e_correctable)
+		return 7;
+	if (e_uncorrectable)
+		return 8;
+	return 0;
+}
+
+static const char * const cmd_scrub_start_usage[] = {
+	"btrfs scrub start [-Bdqr] <path>|<device>",
+	"Start a new scrub",
+	"",
+	"-B     do not background",
+	"-d     stats per device (-B only)",
+	"-q     be quiet",
+	"-r     read only mode",
+	NULL
+};
+
+static int cmd_scrub_start(int argc, char **argv)
+{
+	return scrub_start(argc, argv, 0);
+}
+
+static const char * const cmd_scrub_cancel_usage[] = {
+	"btrfs scrub cancel <path>|<device>",
+	"Cancel a running scrub",
+	NULL
+};
+
+static int cmd_scrub_cancel(int argc, char **argv)
+{
+	char *path;
+	int ret;
+	int fdmnt;
+	int err;
+	char mp[BTRFS_PATH_NAME_MAX + 1];
+	struct btrfs_fs_devices *fs_devices_mnt = NULL;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_scrub_cancel_usage);
+
+	path = argv[1];
+
+	fdmnt = open_file_or_dir(path);
+	if (fdmnt < 0) {
+		fprintf(stderr, "ERROR: scrub cancel failed\n");
+		return 12;
+	}
+
+again:
+	ret = ioctl(fdmnt, BTRFS_IOC_SCRUB_CANCEL, NULL);
+	err = errno;
+	close(fdmnt);
+
+	if (ret && err == EINVAL) {
+		/* path is no mounted btrfs. try if it's a device */
+		ret = check_mounted_where(fdmnt, path, mp, sizeof(mp),
+					  &fs_devices_mnt);
+		close(fdmnt);
+		if (ret) {
+			fdmnt = open_file_or_dir(mp);
+			if (fdmnt >= 0) {
+				path = mp;
+				goto again;
+			}
+		}
+	}
+
+	if (ret) {
+		fprintf(stderr, "ERROR: scrub cancel failed on %s: %s\n", path,
+			err == ENOTCONN ? "not running" : strerror(errno));
+		return 1;
+	}
+
+	printf("scrub cancelled\n");
+
+	return 0;
+}
+
+static const char * const cmd_scrub_resume_usage[] = {
+	"btrfs scrub resume [-Bdqr] <path>|<device>",
+	"Resume previously canceled or interrupted scrub",
+	"",
+	"-B     do not background",
+	"-d     stats per device (-B only)",
+	"-q     be quiet",
+	"-r     read only mode",
+	NULL
+};
+
+static int cmd_scrub_resume(int argc, char **argv)
+{
+	return scrub_start(argc, argv, 1);
+}
+
+static const char * const cmd_scrub_status_usage[] = {
+	"btrfs scrub status [-dR] <path>|<device>",
+	"Show status of running or finished scrub",
+	"",
+	"-d     stats per device",
+	"-R     print raw stats",
+	NULL
+};
+
+static int cmd_scrub_status(int argc, char **argv)
+{
+	char *path;
+	struct btrfs_ioctl_fs_info_args fi_args;
+	struct btrfs_ioctl_dev_info_args *di_args = NULL;
+	struct scrub_file_record **past_scrubs = NULL;
+	struct scrub_file_record *last_scrub;
+	struct scrub_fs_stat fs_stat;
+	struct sockaddr_un addr = {
+		.sun_family = AF_UNIX,
+	};
+	int ret;
+	int fdmnt;
+	int i;
+	int print_raw = 0;
+	int do_stats_per_dev = 0;
+	char c;
+	char fsid[37];
+	int fdres = -1;
+	int err = 0;
+
+	optind = 1;
+	while ((c = getopt(argc, argv, "dR")) != -1) {
+		switch (c) {
+		case 'd':
+			do_stats_per_dev = 1;
+			break;
+		case 'R':
+			print_raw = 1;
+			break;
+		case '?':
+		default:
+			usage(cmd_scrub_status_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 1))
+		usage(cmd_scrub_status_usage);
+
+	path = argv[optind];
+
+	fdmnt = open_file_or_dir(path);
+	if (fdmnt < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	ret = scrub_fs_info(fdmnt, path, &fi_args, &di_args);
+	if (ret) {
+		fprintf(stderr, "ERROR: getting dev info for scrub failed: "
+				"%s\n", strerror(-ret));
+		err = 1;
+		goto out;
+	}
+	if (!fi_args.num_devices) {
+		fprintf(stderr, "ERROR: no devices found\n");
+		err = 1;
+		goto out;
+	}
+
+	uuid_unparse(fi_args.fsid, fsid);
+
+	fdres = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (fdres == -1) {
+		fprintf(stderr, "ERROR: failed to create socket to "
+			"receive progress information: %s\n",
+			strerror(errno));
+		err = 1;
+		goto out;
+	}
+	scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH, fsid,
+			NULL, addr.sun_path, sizeof(addr.sun_path));
+	/* ignore EOVERFLOW, just use shorter name and hope for the best */
+	addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
+	ret = connect(fdres, (struct sockaddr *)&addr, sizeof(addr));
+	if (ret == -1) {
+		fdres = scrub_open_file_r(SCRUB_DATA_FILE, fsid);
+		if (fdres < 0 && fdres != -ENOENT) {
+			fprintf(stderr, "WARNING: failed to open status file: "
+				"%s\n", strerror(-fdres));
+			err = 1;
+			goto out;
+		}
+	}
+
+	if (fdres >= 0) {
+		past_scrubs = scrub_read_file(fdres, 1);
+		if (IS_ERR(past_scrubs))
+			fprintf(stderr, "WARNING: failed to read status: %s\n",
+				strerror(-PTR_ERR(past_scrubs)));
+	}
+
+	printf("scrub status for %s\n", fsid);
+
+	if (do_stats_per_dev) {
+		for (i = 0; i < fi_args.num_devices; ++i) {
+			last_scrub = last_dev_scrub(past_scrubs,
+							di_args[i].devid);
+			if (!last_scrub) {
+				print_scrub_dev(&di_args[i], NULL, print_raw,
+						NULL, NULL);
+				continue;
+			}
+			print_scrub_dev(&di_args[i], &last_scrub->p, print_raw,
+					last_scrub->stats.finished ?
+							"history" : "status",
+					&last_scrub->stats);
+		}
+	} else {
+		init_fs_stat(&fs_stat);
+		for (i = 0; i < fi_args.num_devices; ++i) {
+			last_scrub = last_dev_scrub(past_scrubs,
+							di_args[i].devid);
+			if (!last_scrub)
+				continue;
+			add_to_fs_stat(&last_scrub->p, &last_scrub->stats,
+					&fs_stat);
+		}
+		print_fs_stat(&fs_stat, print_raw);
+	}
+
+out:
+	free_history(past_scrubs);
+	free(di_args);
+	close(fdmnt);
+	if (fdres > -1)
+		close(fdres);
+
+	return err;
+}
+
+const struct cmd_group scrub_cmd_group = {
+	scrub_cmd_group_usage, NULL, {
+		{ "start", cmd_scrub_start, cmd_scrub_start_usage, NULL, 0 },
+		{ "cancel", cmd_scrub_cancel, cmd_scrub_cancel_usage, NULL, 0 },
+		{ "resume", cmd_scrub_resume, cmd_scrub_resume_usage, NULL, 0 },
+		{ "status", cmd_scrub_status, cmd_scrub_status_usage, NULL, 0 },
+		{ 0, 0, 0, 0, 0 }
+	}
+};
+
+int cmd_scrub(int argc, char **argv)
+{
+	return handle_command_group(&scrub_cmd_group, argc, argv);
+}
diff -Nru btrfs-tools-0.19+20111121/cmds-subvolume.c btrfs-tools-0.19+20120328/cmds-subvolume.c
--- btrfs-tools-0.19+20111121/cmds-subvolume.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/cmds-subvolume.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,533 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <libgen.h>
+#include <limits.h>
+
+#include "kerncompat.h"
+#include "ioctl.h"
+
+#include "commands.h"
+
+/* btrfs-list.c */
+int list_subvols(int fd, int print_parent, int get_default);
+int find_updated_files(int fd, u64 root_id, u64 oldest_gen);
+
+static const char * const subvolume_cmd_group_usage[] = {
+	"btrfs subvolume <command> <args>",
+	NULL
+};
+
+/*
+ * test if path is a directory
+ * this function return
+ * 0-> path exists but it is not a directory
+ * 1-> path exists and it is  a directory
+ * -1 -> path is unaccessible
+ */
+static int test_isdir(char *path)
+{
+	struct stat	st;
+	int		res;
+
+	res = stat(path, &st);
+	if(res < 0 )
+		return -1;
+
+	return S_ISDIR(st.st_mode);
+}
+
+static const char * const cmd_subvol_create_usage[] = {
+	"btrfs subvolume create [<dest>/]<name>",
+	"Create a subvolume",
+	"Create a subvolume <name> in <dest>.  If <dest> is not given",
+	"subvolume <name> will be created in the current directory.",
+	NULL
+};
+
+static int cmd_subvol_create(int argc, char **argv)
+{
+	int	res, fddst, len, e;
+	char	*newname;
+	char	*dstdir;
+	struct btrfs_ioctl_vol_args	args;
+	char	*dst;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_subvol_create_usage);
+
+	dst = argv[1];
+
+	res = test_isdir(dst);
+	if(res >= 0 ){
+		fprintf(stderr, "ERROR: '%s' exists\n", dst);
+		return 12;
+	}
+
+	newname = strdup(dst);
+	newname = basename(newname);
+	dstdir = strdup(dst);
+	dstdir = dirname(dstdir);
+
+	if( !strcmp(newname,".") || !strcmp(newname,"..") ||
+	     strchr(newname, '/') ){
+		fprintf(stderr, "ERROR: uncorrect subvolume name ('%s')\n",
+			newname);
+		return 14;
+	}
+
+	len = strlen(newname);
+	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
+		fprintf(stderr, "ERROR: subvolume name too long ('%s)\n",
+			newname);
+		return 14;
+	}
+
+	fddst = open_file_or_dir(dstdir);
+	if (fddst < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
+		return 12;
+	}
+
+	printf("Create subvolume '%s/%s'\n", dstdir, newname);
+	strncpy(args.name, newname, BTRFS_PATH_NAME_MAX);
+	res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE, &args);
+	e = errno;
+
+	close(fddst);
+
+	if(res < 0 ){
+		fprintf( stderr, "ERROR: cannot create subvolume - %s\n",
+			strerror(e));
+		return 11;
+	}
+
+	return 0;
+}
+
+/*
+ * test if path is a subvolume:
+ * this function return
+ * 0-> path exists but it is not a subvolume
+ * 1-> path exists and it is  a subvolume
+ * -1 -> path is unaccessible
+ */
+static int test_issubvolume(char *path)
+{
+	struct stat	st;
+	int		res;
+
+	res = stat(path, &st);
+	if(res < 0 )
+		return -1;
+
+	return (st.st_ino == 256) && S_ISDIR(st.st_mode);
+}
+
+static const char * const cmd_subvol_delete_usage[] = {
+	"btrfs subvolume delete <name>",
+	"Delete a subvolume",
+	NULL
+};
+
+static int cmd_subvol_delete(int argc, char **argv)
+{
+	int	res, fd, len, e;
+	struct btrfs_ioctl_vol_args	args;
+	char	*dname, *vname, *cpath;
+	char	*path;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_subvol_delete_usage);
+
+	path = argv[1];
+
+	res = test_issubvolume(path);
+	if(res<0){
+		fprintf(stderr, "ERROR: error accessing '%s'\n", path);
+		return 12;
+	}
+	if(!res){
+		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", path);
+		return 13;
+	}
+
+	cpath = realpath(path, 0);
+	dname = strdup(cpath);
+	dname = dirname(dname);
+	vname = strdup(cpath);
+	vname = basename(vname);
+	free(cpath);
+
+	if( !strcmp(vname,".") || !strcmp(vname,"..") ||
+	     strchr(vname, '/') ){
+		fprintf(stderr, "ERROR: incorrect subvolume name ('%s')\n",
+			vname);
+		return 14;
+	}
+
+	len = strlen(vname);
+	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
+		fprintf(stderr, "ERROR: snapshot name too long ('%s)\n",
+			vname);
+		return 14;
+	}
+
+	fd = open_file_or_dir(dname);
+	if (fd < 0) {
+		close(fd);
+		fprintf(stderr, "ERROR: can't access to '%s'\n", dname);
+		return 12;
+	}
+
+	printf("Delete subvolume '%s/%s'\n", dname, vname);
+	strncpy(args.name, vname, BTRFS_PATH_NAME_MAX);
+	res = ioctl(fd, BTRFS_IOC_SNAP_DESTROY, &args);
+	e = errno;
+
+	close(fd);
+
+	if(res < 0 ){
+		fprintf( stderr, "ERROR: cannot delete '%s/%s' - %s\n",
+			dname, vname, strerror(e));
+		return 11;
+	}
+
+	return 0;
+}
+
+static const char * const cmd_subvol_list_usage[] = {
+	"btrfs subvolume list [-p] <path>",
+	"List subvolumes (and snapshots)",
+	"",
+	"-p     print parent ID",
+	NULL
+};
+
+static int cmd_subvol_list(int argc, char **argv)
+{
+	int fd;
+	int ret;
+	int print_parent = 0;
+	char *subvol;
+
+	optind = 1;
+	while(1) {
+		int c = getopt(argc, argv, "p");
+		if (c < 0)
+			break;
+
+		switch(c) {
+		case 'p':
+			print_parent = 1;
+			break;
+		default:
+			usage(cmd_subvol_list_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 1))
+		usage(cmd_subvol_list_usage);
+
+	subvol = argv[optind];
+
+	ret = test_issubvolume(subvol);
+	if (ret < 0) {
+		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
+		return 12;
+	}
+	if (!ret) {
+		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
+		return 13;
+	}
+
+	fd = open_file_or_dir(subvol);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
+		return 12;
+	}
+	ret = list_subvols(fd, print_parent, 0);
+	if (ret)
+		return 19;
+	return 0;
+}
+
+static const char * const cmd_snapshot_usage[] = {
+	"btrfs subvolume snapshot [-r] <source> [<dest>/]<name>",
+	"Create a snapshot of the subvolume",
+	"Create a writable/readonly snapshot of the subvolume <source> with",
+	"the name <name> in the <dest> directory",
+	"",
+	"-r     create a readonly snapshot",
+	NULL
+};
+
+static int cmd_snapshot(int argc, char **argv)
+{
+	char	*subvol, *dst;
+	int	res, fd, fddst, len, e, readonly = 0;
+	char	*newname;
+	char	*dstdir;
+	struct btrfs_ioctl_vol_args_v2	args;
+
+	memset(&args, 0, sizeof(args));
+
+	optind = 1;
+	while (1) {
+		int c = getopt(argc, argv, "r");
+		if (c < 0)
+			break;
+
+		switch (c) {
+		case 'r':
+			readonly = 1;
+			break;
+		default:
+			usage(cmd_snapshot_usage);
+		}
+	}
+
+	if (check_argc_exact(argc - optind, 2))
+		usage(cmd_snapshot_usage);
+
+	subvol = argv[optind];
+	dst = argv[optind + 1];
+
+	res = test_issubvolume(subvol);
+	if(res<0){
+		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
+		return 12;
+	}
+	if(!res){
+		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
+		return 13;
+	}
+
+	res = test_isdir(dst);
+	if(res == 0 ){
+		fprintf(stderr, "ERROR: '%s' exists and it is not a directory\n", dst);
+		return 12;
+	}
+
+	if(res>0){
+		newname = strdup(subvol);
+		newname = basename(newname);
+		dstdir = dst;
+	}else{
+		newname = strdup(dst);
+		newname = basename(newname);
+		dstdir = strdup(dst);
+		dstdir = dirname(dstdir);
+	}
+
+	if( !strcmp(newname,".") || !strcmp(newname,"..") ||
+	     strchr(newname, '/') ){
+		fprintf(stderr, "ERROR: incorrect snapshot name ('%s')\n",
+			newname);
+		return 14;
+	}
+
+	len = strlen(newname);
+	if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
+		fprintf(stderr, "ERROR: snapshot name too long ('%s)\n",
+			newname);
+		return 14;
+	}
+
+	fddst = open_file_or_dir(dstdir);
+	if (fddst < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
+		return 12;
+	}
+
+	fd = open_file_or_dir(subvol);
+	if (fd < 0) {
+		close(fddst);
+		fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
+		return 12;
+	}
+
+	if (readonly) {
+		args.flags |= BTRFS_SUBVOL_RDONLY;
+		printf("Create a readonly snapshot of '%s' in '%s/%s'\n",
+		       subvol, dstdir, newname);
+	} else {
+		printf("Create a snapshot of '%s' in '%s/%s'\n",
+		       subvol, dstdir, newname);
+	}
+
+	args.fd = fd;
+	strncpy(args.name, newname, BTRFS_SUBVOL_NAME_MAX);
+	res = ioctl(fddst, BTRFS_IOC_SNAP_CREATE_V2, &args);
+	e = errno;
+
+	close(fd);
+	close(fddst);
+
+	if(res < 0 ){
+		fprintf( stderr, "ERROR: cannot snapshot '%s' - %s\n",
+			subvol, strerror(e));
+		return 11;
+	}
+
+	return 0;
+}
+
+static const char * const cmd_subvol_get_default_usage[] = {
+	"btrfs subvolume get-dafault <path>",
+	"Get the default subvolume of a filesystem",
+	NULL
+};
+
+static int cmd_subvol_get_default(int argc, char **argv)
+{
+	int fd;
+	int ret;
+	char *subvol;
+
+	if (check_argc_exact(argc, 2))
+		usage(cmd_subvol_get_default_usage);
+
+	subvol = argv[1];
+
+	ret = test_issubvolume(subvol);
+	if (ret < 0) {
+		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
+		return 12;
+	}
+	if (!ret) {
+		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
+		return 13;
+	}
+
+	fd = open_file_or_dir(subvol);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
+		return 12;
+	}
+	ret = list_subvols(fd, 0, 1);
+	if (ret)
+		return 19;
+	return 0;
+}
+
+static const char * const cmd_subvol_set_default_usage[] = {
+	"btrfs subvolume set-dafault <subvolid> <path>",
+	"Set the default subvolume of a filesystem",
+	NULL
+};
+
+static int cmd_subvol_set_default(int argc, char **argv)
+{
+	int	ret=0, fd, e;
+	u64	objectid;
+	char	*path;
+	char	*subvolid;
+
+	if (check_argc_exact(argc, 3))
+		usage(cmd_subvol_set_default_usage);
+
+	subvolid = argv[1];
+	path = argv[2];
+
+	fd = open_file_or_dir(path);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+		return 12;
+	}
+
+	objectid = (unsigned long long)strtoll(subvolid, NULL, 0);
+	if (errno == ERANGE) {
+		fprintf(stderr, "ERROR: invalid tree id (%s)\n",subvolid);
+		return 30;
+	}
+	ret = ioctl(fd, BTRFS_IOC_DEFAULT_SUBVOL, &objectid);
+	e = errno;
+	close(fd);
+	if( ret < 0 ){
+		fprintf(stderr, "ERROR: unable to set a new default subvolume - %s\n",
+			strerror(e));
+		return 30;
+	}
+	return 0;
+}
+
+static const char * const cmd_find_new_usage[] = {
+	"btrfs subvolume find-new <path> <lastgen>",
+	"List the recently modified files in a filesystem",
+	NULL
+};
+
+static int cmd_find_new(int argc, char **argv)
+{
+	int fd;
+	int ret;
+	char *subvol;
+	u64 last_gen;
+
+	if (check_argc_exact(argc, 3))
+		usage(cmd_find_new_usage);
+
+	subvol = argv[1];
+	last_gen = atoll(argv[2]);
+
+	ret = test_issubvolume(subvol);
+	if (ret < 0) {
+		fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
+		return 12;
+	}
+	if (!ret) {
+		fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
+		return 13;
+	}
+
+	fd = open_file_or_dir(subvol);
+	if (fd < 0) {
+		fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
+		return 12;
+	}
+	ret = find_updated_files(fd, 0, last_gen);
+	if (ret)
+		return 19;
+	return 0;
+}
+
+const struct cmd_group subvolume_cmd_group = {
+	subvolume_cmd_group_usage, NULL, {
+		{ "create", cmd_subvol_create, cmd_subvol_create_usage, NULL, 0 },
+		{ "delete", cmd_subvol_delete, cmd_subvol_delete_usage, NULL, 0 },
+		{ "list", cmd_subvol_list, cmd_subvol_list_usage, NULL, 0 },
+		{ "snapshot", cmd_snapshot, cmd_snapshot_usage, NULL, 0 },
+		{ "get-default", cmd_subvol_get_default,
+			cmd_subvol_get_default_usage, NULL, 0 },
+		{ "set-default", cmd_subvol_set_default,
+			cmd_subvol_set_default_usage, NULL, 0 },
+		{ "find-new", cmd_find_new, cmd_find_new_usage, NULL, 0 },
+		{ 0, 0, 0, 0, 0 }
+	}
+};
+
+int cmd_subvolume(int argc, char **argv)
+{
+	return handle_command_group(&subvolume_cmd_group, argc, argv);
+}
diff -Nru btrfs-tools-0.19+20111121/commands.h btrfs-tools-0.19+20120328/commands.h
--- btrfs-tools-0.19+20111121/commands.h	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/commands.h	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,97 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#define ARGV0_BUF_SIZE	64
+
+struct cmd_struct {
+	const char *token;
+	int (*fn)(int, char **);
+
+	/*
+	 * Usage strings
+	 *
+	 * A NULL-terminated array of the following format:
+	 *
+	 *   usagestr[0] - one-line synopsis (required)
+	 *   usagestr[1] - one-line short description (required)
+	 *   usagestr[2..m] - a long (possibly multi-line) description
+	 *                    (optional)
+	 *   usagestr[m + 1] - an empty line separator (required if at least one
+	 *                     option string is given, not needed otherwise)
+	 *   usagestr[m + 2..n] - option strings, one option per line
+	 *                        (optional)
+	 *   usagestr[n + 1] - NULL terminator
+	 *
+	 * Options (if present) should always (even if there is no long
+	 * description) be prepended with an empty line.  Supplied strings are
+	 * indented but otherwise printed as-is, no automatic wrapping is done.
+	 *
+	 * Grep for cmd_*_usage[] for examples.
+	 */
+	const char * const *usagestr;
+
+	/* should be NULL if token is not a subgroup */
+	const struct cmd_group *next;
+
+	/* if true don't list this token in help listings */
+	int hidden;
+};
+
+struct cmd_group {
+	const char * const *usagestr;
+	const char *infostr;
+
+	const struct cmd_struct commands[];
+};
+
+/* btrfs.c */
+int prefixcmp(const char *str, const char *prefix);
+
+int check_argc_exact(int nargs, int expected);
+int check_argc_min(int nargs, int expected);
+int check_argc_max(int nargs, int expected);
+
+int handle_command_group(const struct cmd_group *grp, int argc,
+			 char **argv);
+
+/* help.c */
+extern const char * const generic_cmd_help_usage[];
+
+void usage(const char * const *usagestr);
+void usage_command(const struct cmd_struct *cmd, int full, int err);
+void usage_command_group(const struct cmd_group *grp, int all, int err);
+
+void help_unknown_token(const char *arg, const struct cmd_group *grp);
+void help_ambiguous_token(const char *arg, const struct cmd_group *grp);
+
+void help_command_group(const struct cmd_group *grp, int argc, char **argv);
+
+/* common.c */
+int open_file_or_dir(const char *fname);
+
+extern const struct cmd_group subvolume_cmd_group;
+extern const struct cmd_group filesystem_cmd_group;
+extern const struct cmd_group balance_cmd_group;
+extern const struct cmd_group device_cmd_group;
+extern const struct cmd_group scrub_cmd_group;
+extern const struct cmd_group inspect_cmd_group;
+
+int cmd_subvolume(int argc, char **argv);
+int cmd_filesystem(int argc, char **argv);
+int cmd_balance(int argc, char **argv);
+int cmd_device(int argc, char **argv);
+int cmd_scrub(int argc, char **argv);
+int cmd_inspect(int argc, char **argv);
diff -Nru btrfs-tools-0.19+20111121/common.c btrfs-tools-0.19+20120328/common.c
--- btrfs-tools-0.19+20111121/common.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/common.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,46 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <fcntl.h>
+
+int open_file_or_dir(const char *fname)
+{
+	int ret;
+	struct stat st;
+	DIR *dirstream;
+	int fd;
+
+	ret = stat(fname, &st);
+	if (ret < 0) {
+		return -1;
+	}
+	if (S_ISDIR(st.st_mode)) {
+		dirstream = opendir(fname);
+		if (!dirstream) {
+			return -2;
+		}
+		fd = dirfd(dirstream);
+	} else {
+		fd = open(fname, O_RDWR);
+	}
+	if (fd < 0) {
+		return -3;
+	}
+	return fd;
+}
diff -Nru btrfs-tools-0.19+20111121/convert.c btrfs-tools-0.19+20120328/convert.c
--- btrfs-tools-0.19+20111121/convert.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/convert.c	2012-05-05 18:22:58.000000000 +0000
@@ -1504,66 +1504,6 @@
 	return new_root;
 }
 
-/*
- * Fixup block accounting. The initial block accounting created by
- * make_block_groups isn't accuracy in this case.
- */
-static int fixup_block_accounting(struct btrfs_trans_handle *trans,
-				  struct btrfs_root *root)
-{
-	int ret;
-	int slot;
-	u64 start = 0;
-	u64 bytes_used = 0;
-	struct btrfs_path path;
-	struct btrfs_key key;
-	struct extent_buffer *leaf;
-	struct btrfs_block_group_cache *cache;
-	struct btrfs_fs_info *fs_info = root->fs_info;
-
-	while(1) {
-		cache = btrfs_lookup_block_group(fs_info, start);
-		if (!cache)
-			break;
-		start = cache->key.objectid + cache->key.offset;
-		btrfs_set_block_group_used(&cache->item, 0);
-		cache->space_info->bytes_used = 0;
-	}
-
-	btrfs_init_path(&path);
-	key.offset = 0;
-	key.objectid = 0;
-	btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
-	ret = btrfs_search_slot(trans, root->fs_info->extent_root,
-				&key, &path, 0, 0);
-	if (ret < 0)
-		return ret;
-	while(1) {
-		leaf = path.nodes[0];
-		slot = path.slots[0];
-		if (slot >= btrfs_header_nritems(leaf)) {
-			ret = btrfs_next_leaf(root, &path);
-			if (ret < 0)
-				return ret;
-			if (ret > 0)
-				break;
-			leaf = path.nodes[0];
-			slot = path.slots[0];
-		}
-		btrfs_item_key_to_cpu(leaf, &key, slot);
-		if (key.type == BTRFS_EXTENT_ITEM_KEY) {
-			bytes_used += key.offset;
-			ret = btrfs_update_block_group(trans, root,
-				  key.objectid, key.offset, 1, 0);
-			BUG_ON(ret);
-		}
-		path.slots[0]++;
-	}
-	btrfs_set_super_bytes_used(&root->fs_info->super_copy, bytes_used);
-	btrfs_release_path(root, &path);
-	return 0;
-}
-
 static int create_chunk_mapping(struct btrfs_trans_handle *trans,
 				struct btrfs_root *root)
 {
@@ -1735,7 +1675,7 @@
 	ret = btrfs_make_block_groups(trans, root);
 	if (ret)
 		goto err;
-	ret = fixup_block_accounting(trans, root);
+	ret = btrfs_fix_block_accounting(trans, root);
 	if (ret)
 		goto err;
 	ret = create_chunk_mapping(trans, root);
diff -Nru btrfs-tools-0.19+20111121/ctree.c btrfs-tools-0.19+20120328/ctree.c
--- btrfs-tools-0.19+20111121/ctree.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/ctree.c	2012-05-05 18:22:58.000000000 +0000
@@ -19,6 +19,7 @@
 #include "disk-io.h"
 #include "transaction.h"
 #include "print-tree.h"
+#include "repair.h"
 
 static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
 		      *root, struct btrfs_path *path, int level);
@@ -32,8 +33,6 @@
 			      struct btrfs_root *root,
 			      struct extent_buffer *dst_buf,
 			      struct extent_buffer *src_buf);
-static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-		   struct btrfs_path *path, int level, int slot);
 
 inline void btrfs_init_path(struct btrfs_path *p)
 {
@@ -138,6 +137,48 @@
 	return 0;
 }
 
+int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
+		      struct btrfs_root *root)
+{
+	struct extent_buffer *c;
+	struct extent_buffer *old = root->node;
+	int level;
+	struct btrfs_disk_key disk_key = {0,0,0};
+
+	level = 0;
+
+	c = btrfs_alloc_free_block(trans, root,
+				   btrfs_level_size(root, 0),
+				   root->root_key.objectid,
+				   &disk_key, level, 0, 0);
+	if (IS_ERR(c)) {
+		c = old;
+		extent_buffer_get(c);
+	}
+
+	memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
+	btrfs_set_header_level(c, level);
+	btrfs_set_header_bytenr(c, c->start);
+	btrfs_set_header_generation(c, trans->transid);
+	btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
+	btrfs_set_header_owner(c, root->root_key.objectid);
+
+	write_extent_buffer(c, root->fs_info->fsid,
+			    (unsigned long)btrfs_header_fsid(c),
+			    BTRFS_FSID_SIZE);
+
+	write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
+			    (unsigned long)btrfs_header_chunk_tree_uuid(c),
+			    BTRFS_UUID_SIZE);
+
+	btrfs_mark_buffer_dirty(c);
+
+	free_extent_buffer(old);
+	root->node = c;
+	add_root_to_dirty_list(root);
+	return 0;
+}
+
 /*
  * check if the tree block can be shared by multiple trees
  */
@@ -549,156 +590,125 @@
 	return btrfs_item_offset_nr(leaf, nr - 1);
 }
 
-static int check_node(struct btrfs_root *root, struct btrfs_path *path,
-		      int level)
+int btrfs_check_node(struct btrfs_root *root,
+		      struct btrfs_disk_key *parent_key,
+		      struct extent_buffer *buf)
 {
-	struct extent_buffer *parent = NULL;
-	struct extent_buffer *node = path->nodes[level];
-	struct btrfs_disk_key parent_key;
-	struct btrfs_disk_key node_key;
-	int parent_slot;
-	int slot;
+	int i;
 	struct btrfs_key cpukey;
-	u32 nritems = btrfs_header_nritems(node);
+	struct btrfs_disk_key key;
+	u32 nritems = btrfs_header_nritems(buf);
 
-	if (path->nodes[level + 1])
-		parent = path->nodes[level + 1];
+	if (nritems == 0 || nritems > BTRFS_NODEPTRS_PER_BLOCK(root))
+		goto fail;
 
-	slot = path->slots[level];
-	BUG_ON(nritems == 0);
-	if (parent) {
-		parent_slot = path->slots[level + 1];
-		btrfs_node_key(parent, &parent_key, parent_slot);
-		btrfs_node_key(node, &node_key, 0);
-		BUG_ON(memcmp(&parent_key, &node_key,
-			      sizeof(struct btrfs_disk_key)));
-		BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
-		       btrfs_header_bytenr(node));
-	}
-	BUG_ON(nritems > BTRFS_NODEPTRS_PER_BLOCK(root));
-	if (slot != 0) {
-		btrfs_node_key_to_cpu(node, &cpukey, slot - 1);
-		btrfs_node_key(node, &node_key, slot);
-		BUG_ON(btrfs_comp_keys(&node_key, &cpukey) <= 0);
-	}
-	if (slot < nritems - 1) {
-		btrfs_node_key_to_cpu(node, &cpukey, slot + 1);
-		btrfs_node_key(node, &node_key, slot);
-		BUG_ON(btrfs_comp_keys(&node_key, &cpukey) >= 0);
+	if (parent_key && parent_key->type) {
+		btrfs_node_key(buf, &key, 0);
+		if (memcmp(parent_key, &key, sizeof(key)))
+			goto fail;
+	}
+	for (i = 0; nritems > 1 && i < nritems - 2; i++) {
+		btrfs_node_key(buf, &key, i);
+		btrfs_node_key_to_cpu(buf, &cpukey, i + 1);
+		if (btrfs_comp_keys(&key, &cpukey) >= 0)
+			goto fail;
 	}
 	return 0;
+fail:
+	if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID) {
+		if (parent_key)
+			btrfs_disk_key_to_cpu(&cpukey, parent_key);
+		else
+			btrfs_node_key_to_cpu(buf, &cpukey, 0);
+		btrfs_add_corrupt_extent_record(root->fs_info, &cpukey,
+						buf->start, buf->len,
+						btrfs_header_level(buf));
+	}
+	return -EIO;
 }
 
-static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
-		      int level)
+int btrfs_check_leaf(struct btrfs_root *root,
+		      struct btrfs_disk_key *parent_key,
+		      struct extent_buffer *buf)
 {
-	struct extent_buffer *leaf = path->nodes[level];
-	struct extent_buffer *parent = NULL;
-	int parent_slot;
+	int i;
 	struct btrfs_key cpukey;
-	struct btrfs_disk_key parent_key;
-	struct btrfs_disk_key leaf_key;
-	int slot = path->slots[0];
+	struct btrfs_disk_key key;
+	u32 nritems = btrfs_header_nritems(buf);
 
-	u32 nritems = btrfs_header_nritems(leaf);
-
-	if (path->nodes[level + 1])
-		parent = path->nodes[level + 1];
+	if (btrfs_header_level(buf) != 0) {
+		fprintf(stderr, "leaf is not a leaf %llu\n",
+		       (unsigned long long)btrfs_header_bytenr(buf));
+		goto fail;
+	}
+	if (btrfs_leaf_free_space(root, buf) < 0) {
+		fprintf(stderr, "leaf free space incorrect %llu %d\n",
+			(unsigned long long)btrfs_header_bytenr(buf),
+			btrfs_leaf_free_space(root, buf));
+		goto fail;
+	}
 
 	if (nritems == 0)
 		return 0;
 
-	if (parent) {
-		parent_slot = path->slots[level + 1];
-		btrfs_node_key(parent, &parent_key, parent_slot);
-		btrfs_item_key(leaf, &leaf_key, 0);
-
-		BUG_ON(memcmp(&parent_key, &leaf_key,
-		       sizeof(struct btrfs_disk_key)));
-		BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
-		       btrfs_header_bytenr(leaf));
+	btrfs_item_key(buf, &key, 0);
+	if (parent_key && parent_key->type &&
+	    memcmp(parent_key, &key, sizeof(key))) {
+		fprintf(stderr, "leaf parent key incorrect %llu\n",
+		       (unsigned long long)btrfs_header_bytenr(buf));
+		goto fail;
 	}
-#if 0
 	for (i = 0; nritems > 1 && i < nritems - 2; i++) {
-		btrfs_item_key_to_cpu(leaf, &cpukey, i + 1);
-		btrfs_item_key(leaf, &leaf_key, i);
-		if (comp_keys(&leaf_key, &cpukey) >= 0) {
-			btrfs_print_leaf(root, leaf);
-			printk("slot %d offset bad key\n", i);
-			BUG_ON(1);
-		}
-		if (btrfs_item_offset_nr(leaf, i) !=
-			btrfs_item_end_nr(leaf, i + 1)) {
-			btrfs_print_leaf(root, leaf);
-			printk("slot %d offset bad\n", i);
-			BUG_ON(1);
-		}
-		if (i == 0) {
-			if (btrfs_item_offset_nr(leaf, i) +
-			       btrfs_item_size_nr(leaf, i) !=
-			       BTRFS_LEAF_DATA_SIZE(root)) {
-				btrfs_print_leaf(root, leaf);
-				printk("slot %d first offset bad\n", i);
-				BUG_ON(1);
-			}
-		}
-	}
-	if (nritems > 0) {
-		if (btrfs_item_size_nr(leaf, nritems - 1) > 4096) {
-				btrfs_print_leaf(root, leaf);
-				printk("slot %d bad size \n", nritems - 1);
-				BUG_ON(1);
-		}
-	}
-#endif
-	if (slot != 0 && slot < nritems - 1) {
-		btrfs_item_key(leaf, &leaf_key, slot);
-		btrfs_item_key_to_cpu(leaf, &cpukey, slot - 1);
-		if (btrfs_comp_keys(&leaf_key, &cpukey) <= 0) {
-			btrfs_print_leaf(root, leaf);
-			printk("slot %d offset bad key\n", slot);
-			BUG_ON(1);
-		}
-		if (btrfs_item_offset_nr(leaf, slot - 1) !=
-		       btrfs_item_end_nr(leaf, slot)) {
-			btrfs_print_leaf(root, leaf);
-			printk("slot %d offset bad\n", slot);
-			BUG_ON(1);
-		}
-	}
-	if (slot < nritems - 1) {
-		btrfs_item_key(leaf, &leaf_key, slot);
-		btrfs_item_key_to_cpu(leaf, &cpukey, slot + 1);
-		BUG_ON(btrfs_comp_keys(&leaf_key, &cpukey) >= 0);
-		if (btrfs_item_offset_nr(leaf, slot) !=
-			btrfs_item_end_nr(leaf, slot + 1)) {
-			btrfs_print_leaf(root, leaf);
-			printk("slot %d offset bad\n", slot);
-			BUG_ON(1);
+		btrfs_item_key(buf, &key, i);
+		btrfs_item_key_to_cpu(buf, &cpukey, i + 1);
+		if (btrfs_comp_keys(&key, &cpukey) >= 0) {
+			fprintf(stderr, "bad key ordering %d %d\n", i, i+1);
+			goto fail;
+		}
+		if (btrfs_item_offset_nr(buf, i) !=
+			btrfs_item_end_nr(buf, i + 1)) {
+			fprintf(stderr, "incorrect offsets %u %u\n",
+				btrfs_item_offset_nr(buf, i),
+				btrfs_item_end_nr(buf, i + 1));
+			goto fail;
+		}
+		if (i == 0 && btrfs_item_end_nr(buf, i) !=
+		    BTRFS_LEAF_DATA_SIZE(root)) {
+			fprintf(stderr, "bad item end %u wanted %u\n",
+				btrfs_item_end_nr(buf, i),
+				(unsigned)BTRFS_LEAF_DATA_SIZE(root));
+			goto fail;
 		}
 	}
-	BUG_ON(btrfs_item_offset_nr(leaf, 0) +
-	       btrfs_item_size_nr(leaf, 0) != BTRFS_LEAF_DATA_SIZE(root));
 	return 0;
+fail:
+	if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID) {
+		if (parent_key)
+			btrfs_disk_key_to_cpu(&cpukey, parent_key);
+		else
+			btrfs_item_key_to_cpu(buf, &cpukey, 0);
+
+		btrfs_add_corrupt_extent_record(root->fs_info, &cpukey,
+						buf->start, buf->len, 0);
+	}
+	return -EIO;
 }
 
 static int noinline check_block(struct btrfs_root *root,
 				struct btrfs_path *path, int level)
 {
-	return 0;
-#if 0
-	struct extent_buffer *buf = path->nodes[level];
+	struct btrfs_disk_key key;
+	struct btrfs_disk_key *key_ptr = NULL;
+	struct extent_buffer *parent;
 
-	if (memcmp_extent_buffer(buf, root->fs_info->fsid,
-				 (unsigned long)btrfs_header_fsid(buf),
-				 BTRFS_FSID_SIZE)) {
-		printk("warning bad block %Lu\n", buf->start);
-		return 1;
+	if (path->nodes[level + 1]) {
+		parent = path->nodes[level + 1];
+		btrfs_node_key(parent, &key, path->slots[level + 1]);
+		key_ptr = &key;
 	}
-#endif
 	if (level == 0)
-		return check_leaf(root, path, level);
-	return check_node(root, path, level);
+		return btrfs_check_leaf(root, key_ptr, path->nodes[0]);
+	return btrfs_check_node(root, key_ptr, path->nodes[level]);
 }
 
 /*
@@ -884,8 +894,8 @@
 			wait_on_tree_block_writeback(root, right);
 			free_extent_buffer(right);
 			right = NULL;
-			wret = del_ptr(trans, root, path, level + 1, pslot +
-				       1);
+			wret = btrfs_del_ptr(trans, root, path,
+					     level + 1, pslot + 1);
 			if (wret)
 				ret = wret;
 			wret = btrfs_free_extent(trans, root, bytenr,
@@ -932,7 +942,7 @@
 		wait_on_tree_block_writeback(root, mid);
 		free_extent_buffer(mid);
 		mid = NULL;
-		wret = del_ptr(trans, root, path, level + 1, pslot);
+		wret = btrfs_del_ptr(trans, root, path, level + 1, pslot);
 		if (wret)
 			ret = wret;
 		wret = btrfs_free_extent(trans, root, bytenr, blocksize,
@@ -1254,6 +1264,8 @@
 						 key->objectid);
 
 			b = read_node_slot(root, b, slot);
+			if (!extent_buffer_uptodate(b))
+				return -EIO;
 		} else {
 			p->slots[level] = slot;
 			if (ins_len > 0 &&
@@ -2659,7 +2671,7 @@
  * continuing all the way the root if required.  The root is converted into
  * a leaf if all the nodes are emptied.
  */
-static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+int btrfs_del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 		   struct btrfs_path *path, int level, int slot)
 {
 	struct extent_buffer *parent = path->nodes[level];
@@ -2711,7 +2723,7 @@
 	int ret;
 
 	WARN_ON(btrfs_header_generation(leaf) != trans->transid);
-	ret = del_ptr(trans, root, path, 1, path->slots[1]);
+	ret = btrfs_del_ptr(trans, root, path, 1, path->slots[1]);
 	if (ret)
 		return ret;
 
diff -Nru btrfs-tools-0.19+20111121/ctree.h btrfs-tools-0.19+20120328/ctree.h
--- btrfs-tools-0.19+20111121/ctree.h	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/ctree.h	2012-05-05 18:22:58.000000000 +0000
@@ -61,6 +61,9 @@
 #define BTRFS_CSUM_TREE_OBJECTID 7ULL
 
 
+/* for storing balance parameters in the root tree */
+#define BTRFS_BALANCE_OBJECTID -4ULL
+
 /* oprhan objectid for tracking unlinked/truncated files */
 #define BTRFS_ORPHAN_OBJECTID -5ULL
 
@@ -409,6 +412,20 @@
 #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL	(1ULL << 1)
 #define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS	(1ULL << 2)
 #define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO	(1ULL << 3)
+/*
+ * some patches floated around with a second compression method
+ * lets save that incompat here for when they do get in
+ * Note we don't actually support it, we're just reserving the
+ * number
+ */
+#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZOv2   (1ULL << 4)
+
+/*
+ * older kernels tried to do bigger metadata blocks, but the
+ * code was pretty buggy.  Lets not let them try anymore.
+ */
+#define BTRFS_FEATURE_INCOMPAT_BIG_METADATA     (1ULL << 5)
+
 
 #define BTRFS_FEATURE_COMPAT_SUPP		0ULL
 #define BTRFS_FEATURE_COMPAT_RO_SUPP		0ULL
@@ -416,6 +433,7 @@
 	(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |		\
 	 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |	\
 	 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |		\
+	 BTRFS_FEATURE_INCOMPAT_BIG_METADATA |		\
 	 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
 
 /*
@@ -697,13 +715,17 @@
 } __attribute__ ((__packed__));
 
 /* tag for the radix tree of block groups in ram */
-#define BTRFS_BLOCK_GROUP_DATA     (1 << 0)
-#define BTRFS_BLOCK_GROUP_SYSTEM   (1 << 1)
-#define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
-#define BTRFS_BLOCK_GROUP_RAID0    (1 << 3)
-#define BTRFS_BLOCK_GROUP_RAID1    (1 << 4)
-#define BTRFS_BLOCK_GROUP_DUP	   (1 << 5)
-#define BTRFS_BLOCK_GROUP_RAID10   (1 << 6)
+#define BTRFS_BLOCK_GROUP_DATA		(1ULL << 0)
+#define BTRFS_BLOCK_GROUP_SYSTEM	(1ULL << 1)
+#define BTRFS_BLOCK_GROUP_METADATA	(1ULL << 2)
+#define BTRFS_BLOCK_GROUP_RAID0		(1ULL << 3)
+#define BTRFS_BLOCK_GROUP_RAID1		(1ULL << 4)
+#define BTRFS_BLOCK_GROUP_DUP		(1ULL << 5)
+#define BTRFS_BLOCK_GROUP_RAID10	(1ULL << 6)
+#define BTRFS_BLOCK_GROUP_RESERVED	BTRFS_AVAIL_ALLOC_BIT_SINGLE
+
+/* used in struct btrfs_balance_args fields */
+#define BTRFS_AVAIL_ALLOC_BIT_SINGLE	(1ULL << 48)
 
 struct btrfs_block_group_item {
 	__le64 used;
@@ -790,6 +812,13 @@
 	struct list_head space_info;
 	int system_allocs;
 	int readonly;
+	int (*free_extent_hook)(struct btrfs_trans_handle *trans,
+				struct btrfs_root *root,
+				u64 bytenr, u64 num_bytes, u64 parent,
+				u64 root_objectid, u64 owner, u64 offset,
+				int refs_to_drop);
+	struct cache_tree *fsck_extent_cache;
+	struct cache_tree *corrupt_blocks;
 };
 
 /*
@@ -911,6 +940,8 @@
 #define BTRFS_DEV_ITEM_KEY	216
 #define BTRFS_CHUNK_ITEM_KEY	228
 
+#define BTRFS_BALANCE_ITEM_KEY	248
+
 /*
  * string items are for debugging.  They just store a short string of
  * data in the FS
@@ -1776,6 +1807,10 @@
 	btrfs_item_offset_nr(leaf, slot)))
 
 /* extent-tree.c */
+int btrfs_fix_block_accounting(struct btrfs_trans_handle *trans,
+				 struct btrfs_root *root);
+int btrfs_check_block_accounting(struct btrfs_root *root);
+void btrfs_pin_extent(struct btrfs_fs_info *fs_info, u64 bytenr, u64 num_bytes);
 int btrfs_extent_post_op(struct btrfs_trans_handle *trans,
 			 struct btrfs_root *root);
 int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy);
@@ -1838,6 +1873,16 @@
 			     struct btrfs_root *root, u64 bytenr, u64 num,
 			     int alloc, int mark_free);
 /* ctree.c */
+int btrfs_del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+		   struct btrfs_path *path, int level, int slot);
+int btrfs_check_node(struct btrfs_root *root,
+		      struct btrfs_disk_key *parent_key,
+		      struct extent_buffer *buf);
+int btrfs_check_leaf(struct btrfs_root *root,
+		      struct btrfs_disk_key *parent_key,
+		      struct extent_buffer *buf);
+int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
+		      struct btrfs_root *root);
 void reada_for_search(struct btrfs_root *root, struct btrfs_path *path,
 			     int level, int slot, u64 objectid);
 struct extent_buffer *read_node_slot(struct btrfs_root *root,
diff -Nru btrfs-tools-0.19+20111121/debian/btrfs-tools.links btrfs-tools-0.19+20120328/debian/btrfs-tools.links
--- btrfs-tools-0.19+20111121/debian/btrfs-tools.links	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/btrfs-tools.links	2012-05-05 18:49:50.000000000 +0000
@@ -0,0 +1,2 @@
+sbin/btrfsck sbin/fsck.btrfs
+
diff -Nru btrfs-tools-0.19+20111121/debian/btrfs-tools-udeb.install btrfs-tools-0.19+20120328/debian/btrfs-tools-udeb.install
--- btrfs-tools-0.19+20111121/debian/btrfs-tools-udeb.install	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/btrfs-tools-udeb.install	2012-05-05 18:51:08.000000000 +0000
@@ -1,2 +1,3 @@
 btrfsctl	/sbin
 mkfs.btrfs	/sbin
+btrfs		/sbin
diff -Nru btrfs-tools-0.19+20111121/debian/changelog btrfs-tools-0.19+20120328/debian/changelog
--- btrfs-tools-0.19+20111121/debian/changelog	2011-11-23 00:03:48.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/changelog	2012-05-09 16:19:11.000000000 +0000
@@ -1,3 +1,22 @@
+btrfs-tools (0.19+20120328-3ubuntu1~ppa3) lucid; urgency=low
+
+  * build for lucid
+
+ -- Jools Wills <jools@oxfordinspire.co.uk>  Wed, 09 May 2012 17:18:50 +0100
+
+btrfs-tools (0.19+20120328-3ubuntu1~ppa2) lucid; urgency=low
+
+  * folder cleanup
+  * fix package building with update
+
+ -- Jools Wills <jools@oxfordinspire.co.uk>  Sat, 05 May 2012 20:32:31 +0100
+
+btrfs-tools (0.19+20120328-3ubuntu1~ppa1) lucid; urgency=low
+
+  * upstream changes
+
+ -- Jools Wills <jools@oxfordinspire.co.uk>  Sat, 05 May 2012 19:39:44 +0100
+
 btrfs-tools (0.19+20111121-3ubuntu1~ppa1) lucid; urgency=low
 
   * New upstream release - git 6da41f2a
diff -Nru btrfs-tools-0.19+20111121/debian/local/btrfs.hook btrfs-tools-0.19+20120328/debian/local/btrfs.hook
--- btrfs-tools-0.19+20111121/debian/local/btrfs.hook	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/local/btrfs.hook	2012-05-05 18:47:28.000000000 +0000
@@ -18,7 +18,7 @@
 
 . /usr/share/initramfs-tools/hook-functions
 
-if [ -x /sbin/btrfsctl ]
+if [ -x "`which btrfs`" ]
 then
-	copy_exec /sbin/btrfsctl /sbin
+	copy_exec "`which btrfs`" /sbin
 fi
diff -Nru btrfs-tools-0.19+20111121/debian/local/btrfs.local-premount btrfs-tools-0.19+20120328/debian/local/btrfs.local-premount
--- btrfs-tools-0.19+20111121/debian/local/btrfs.local-premount	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/local/btrfs.local-premount	2012-05-05 18:46:19.000000000 +0000
@@ -16,8 +16,8 @@
 		;;
 esac
 
-if [ -x /sbin/btrfsctl ]
+if [ -x /sbin/btrfs ]
 then
 	modprobe btrfs
-	/sbin/btrfsctl -a 2>/dev/null
+	/sbin/btrfs device scan 2>/dev/null
 fi
diff -Nru btrfs-tools-0.19+20111121/debian/patches/01-labels.patch btrfs-tools-0.19+20120328/debian/patches/01-labels.patch
--- btrfs-tools-0.19+20111121/debian/patches/01-labels.patch	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/patches/01-labels.patch	1970-01-01 00:00:00.000000000 +0000
@@ -1,27 +0,0 @@
-Author: Chris Mason <chris.mason@oracle.com>
-Description: Allow /'s in labels.
-
-diff -Naurp btrfs-tools.orig/mkfs.c btrfs-tools/mkfs.c
---- btrfs-tools.orig/mkfs.c	2009-03-15 13:27:12.000000000 +0100
-+++ btrfs-tools/mkfs.c	2009-04-17 20:53:12.000000000 +0200
-@@ -294,7 +294,6 @@ static u64 parse_profile(char *s)
- 
- static char *parse_label(char *input)
- {
--	int i;
- 	int len = strlen(input);
- 
- 	if (len > BTRFS_LABEL_SIZE) {
-@@ -302,12 +301,6 @@ static char *parse_label(char *input)
- 			BTRFS_LABEL_SIZE);
- 		exit(1);
- 	}
--	for (i = 0; i < len; i++) {
--		if (input[i] == '/' || input[i] == '\\') {
--			fprintf(stderr, "invalid label %s\n", input);
--			exit(1);
--		}
--	}
- 	return strdup(input);
- }
- 
diff -Nru btrfs-tools-0.19+20111121/debian/patches/02-ftbfs.patch btrfs-tools-0.19+20120328/debian/patches/02-ftbfs.patch
--- btrfs-tools-0.19+20111121/debian/patches/02-ftbfs.patch	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/patches/02-ftbfs.patch	1970-01-01 00:00:00.000000000 +0000
@@ -1,123 +0,0 @@
-Authors:
- Luca Bruno <lucab@debian.org>
- Alexander Kurtz <kurtz.alex@googlemail.com>
- Daniel Baumann <daniel@debian.org>
-Description:
- Patch to properly cast and avoiding compiler warnings. Fixes FTBFS on alpha
- and ia64 (Closes: #539433, #583768).
-
-diff -Naurp btrfs-tools.orig/btrfsctl.c btrfs-tools/btrfsctl.c
---- btrfs-tools.orig/btrfsctl.c	2010-06-01 07:22:33.000000000 +0200
-+++ btrfs-tools/btrfsctl.c	2010-06-05 08:44:05.000000000 +0200
-@@ -234,7 +234,7 @@ int main(int ac, char **av)
- 		args.fd = fd;
- 		ret = ioctl(snap_fd, command, &args);
- 	} else if (command == BTRFS_IOC_DEFAULT_SUBVOL) {
--		printf("objectid is %llu\n", objectid);
-+		printf("objectid is %llu\n", (long long unsigned int) objectid);
- 		ret = ioctl(fd, command, &objectid);
- 	} else
- 		ret = ioctl(fd, command, &args);
-diff -Naurp btrfs-tools.orig/btrfs-list.c btrfs-tools/btrfs-list.c
---- btrfs-tools.orig/btrfs-list.c	2010-06-01 07:22:33.000000000 +0200
-+++ btrfs-tools/btrfs-list.c	2010-06-05 08:47:27.000000000 +0200
-@@ -248,8 +248,9 @@ static int resolve_root(struct root_look
- 			break;
- 		}
- 	}
--	printf("ID %llu top level %llu path %s\n", ri->root_id, top_id,
--	       full_path);
-+	printf("ID %llu top level %llu path %s\n",
-+		(long long unsigned int) ri->root_id,
-+		(long long unsigned int) top_id, full_path);
- 	free(full_path);
- 	return 0;
- }
-diff -Naurp btrfs-tools.orig/btrfs-map-logical.c btrfs-tools/btrfs-map-logical.c
---- btrfs-tools.orig/btrfs-map-logical.c	2010-06-01 07:22:33.000000000 +0200
-+++ btrfs-tools/btrfs-map-logical.c	2010-06-05 08:48:10.000000000 +0200
-@@ -65,8 +65,9 @@ struct extent_buffer *debug_read_block(s
- 		eb->dev_bytenr = multi->stripes[0].physical;
- 
- 		fprintf(info_file, "mirror %d logical %Lu physical %Lu "
--			"device %s\n", mirror_num, bytenr, eb->dev_bytenr,
--			device->name);
-+			"device %s\n", mirror_num,
-+			(long long unsigned int) bytenr,
-+			(long long unsigned int) eb->dev_bytenr, device->name);
- 		kfree(multi);
- 
- 		if (!copy || mirror_num == copy)
-diff -Naurp btrfs-tools.orig/convert.c btrfs-tools/convert.c
---- btrfs-tools.orig/convert.c	2010-06-01 07:22:33.000000000 +0200
-+++ btrfs-tools/convert.c	2010-06-05 08:43:29.000000000 +0200
-@@ -2572,7 +2572,7 @@ int do_rollback(const char *devname, int
- 	ext2_root = btrfs_read_fs_root(root->fs_info, &key);
- 	if (!ext2_root || IS_ERR(ext2_root)) {
- 		fprintf(stderr, "unable to open subvol %llu\n",
--			key.objectid);
-+			(unsigned long long) key.objectid);
- 		goto fail;
- 	}
- 
-diff -Naurp btrfs-tools.orig/debug-tree.c btrfs-tools/debug-tree.c
---- btrfs-tools.orig/debug-tree.c	2010-06-01 07:22:33.000000000 +0200
-+++ btrfs-tools/debug-tree.c	2010-06-05 08:46:17.000000000 +0200
-@@ -162,7 +162,8 @@ int main(int ac, char **av)
- 					      root->nodesize, 0);
- 		}
- 		if (!leaf) {
--			fprintf(stderr, "failed to read %llu\n", block_only);
-+			fprintf(stderr, "failed to read %llu\n",
-+			(long long unsigned int) block_only);
- 			return 0;
- 		}
- 		btrfs_print_tree(root, leaf, 0);
-diff -Naurp btrfs-tools.orig/disk-io.c btrfs-tools/disk-io.c
---- btrfs-tools.orig/disk-io.c	2010-06-01 07:18:01.000000000 +0200
-+++ btrfs-tools/disk-io.c	2010-06-05 08:43:29.000000000 +0200
-@@ -678,7 +678,8 @@ struct btrfs_root *open_ctree_fd(int fp,
- 		   ~BTRFS_FEATURE_INCOMPAT_SUPP;
- 	if (features) {
- 		printk("couldn't open because of unsupported "
--		       "option features (%Lx).\n", features);
-+		       "option features (%Lx).\n",
-+			(unsigned long long)features);
- 		BUG_ON(1);
- 	}
- 
-@@ -692,7 +693,8 @@ struct btrfs_root *open_ctree_fd(int fp,
- 		~BTRFS_FEATURE_COMPAT_RO_SUPP;
- 	if (writes && features) {
- 		printk("couldn't open RDWR because of unsupported "
--		       "option features (%Lx).\n", features);
-+		       "option features (%Lx).\n",
-+			(unsigned long long) features);
- 		BUG_ON(1);
- 	}
- 
-diff -Naurp btrfs-tools.orig/extent-tree.c btrfs-tools/extent-tree.c
---- btrfs-tools.orig/extent-tree.c	2010-06-01 07:18:01.000000000 +0200
-+++ btrfs-tools/extent-tree.c	2010-06-05 08:43:29.000000000 +0200
-@@ -1448,7 +1448,8 @@ int btrfs_lookup_extent_info(struct btrf
- 		goto out;
- 	if (ret != 0) {
- 		btrfs_print_leaf(root, path->nodes[0]);
--		printk("failed to find block number %Lu\n", bytenr);
-+		printk("failed to find block number %Lu\n",
-+		(unsigned long long) bytenr);
- 		BUG();
- 	}
- 
-diff -Naurp btrfs-tools.orig/print-tree.c btrfs-tools/print-tree.c
---- btrfs-tools.orig/print-tree.c	2010-06-01 07:22:33.000000000 +0200
-+++ btrfs-tools/print-tree.c	2010-06-05 08:43:29.000000000 +0200
-@@ -494,7 +494,7 @@ void btrfs_print_leaf(struct btrfs_root
- 		case BTRFS_DIR_LOG_ITEM_KEY:
- 			dlog = btrfs_item_ptr(l, i, struct btrfs_dir_log_item);
- 			printf("\t\tdir log end %Lu\n",
--			       btrfs_dir_log_end(l, dlog));
-+			       (unsigned long long) btrfs_dir_log_end(l, dlog));
- 		       break;
- 		case BTRFS_ORPHAN_ITEM_KEY:
- 			printf("\t\torphan item\n");
diff -Nru btrfs-tools-0.19+20111121/debian/patches/03-glibc.patch btrfs-tools-0.19+20120328/debian/patches/03-glibc.patch
--- btrfs-tools-0.19+20111121/debian/patches/03-glibc.patch	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/patches/03-glibc.patch	1970-01-01 00:00:00.000000000 +0000
@@ -1,14 +0,0 @@
-Author: Colin Watson <cjwatson@debian.org>
-Description: Fixes FTBFS with glibc 2.12 (Closes; #586111).
-
-diff -Naurp btrfs-tools.orig//btrfsck.c btrfs-tools/btrfsck.c
---- btrfs-tools.orig//btrfsck.c	2010-06-05 09:06:38.000000000 +0200
-+++ btrfs-tools/btrfsck.c	2010-06-16 16:16:10.000000000 +0200
-@@ -21,6 +21,7 @@
- #include <stdio.h>
- #include <stdlib.h>
- #include <fcntl.h>
-+#include <sys/stat.h>
- #include "kerncompat.h"
- #include "ctree.h"
- #include "disk-io.h"
diff -Nru btrfs-tools-0.19+20111121/debian/patches/08-allow-fsck-options.patch btrfs-tools-0.19+20120328/debian/patches/08-allow-fsck-options.patch
--- btrfs-tools-0.19+20111121/debian/patches/08-allow-fsck-options.patch	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/patches/08-allow-fsck-options.patch	1970-01-01 00:00:00.000000000 +0000
@@ -1,22 +0,0 @@
-Index: btrfs-tools-0.19/btrfsck.c
-===================================================================
---- btrfs-tools-0.19.orig/btrfsck.c	2011-03-08 00:16:14.574987003 +0000
-+++ btrfs-tools-0.19/btrfsck.c	2011-03-08 00:22:02.368599116 +0000
-@@ -2826,7 +2826,7 @@
- 
- 	while(1) {
- 		int c;
--		c = getopt(ac, av, "s:");
-+		c = getopt(ac, av, "as:");
- 		if (c < 0)
- 			break;
- 		switch(c) {
-@@ -2836,6 +2836,8 @@
- 				printf("using SB copy %d, bytenr %llu\n", num,
- 				       (unsigned long long)bytenr);
- 				break;
-+			case 'a':
-+			    break;
- 			default:
- 				print_usage();
- 		}
diff -Nru btrfs-tools-0.19+20111121/debian/patches/09-pthreadlink.patch btrfs-tools-0.19+20120328/debian/patches/09-pthreadlink.patch
--- btrfs-tools-0.19+20111121/debian/patches/09-pthreadlink.patch	2011-11-23 00:02:33.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/patches/09-pthreadlink.patch	1970-01-01 00:00:00.000000000 +0000
@@ -1,15 +0,0 @@
-diff --git a/Makefile b/Makefile
-index 96e2002..834be47 100644
---- a/Makefile
-+++ b/Makefile
-@@ -37,8 +37,8 @@ version:
- 	bash version.sh
- 
- btrfs: $(objects) btrfs.o btrfs_cmds.o scrub.o
--	$(CC) -lpthread $(CFLAGS) -o btrfs btrfs.o btrfs_cmds.o scrub.o \
--		$(objects) $(LDFLAGS) $(LIBS)
-+	$(CC) $(CFLAGS) -o btrfs btrfs.o btrfs_cmds.o scrub.o \
-+		$(objects) $(LDFLAGS) $(LIBS) -lpthread
- 
- calc-size: $(objects) calc-size.o
- 	gcc $(CFLAGS) -o calc-size calc-size.o $(objects) $(LDFLAGS) $(LIBS)
diff -Nru btrfs-tools-0.19+20111121/debian/patches/series btrfs-tools-0.19+20120328/debian/patches/series
--- btrfs-tools-0.19+20111121/debian/patches/series	2011-11-23 00:02:46.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/patches/series	1970-01-01 00:00:00.000000000 +0000
@@ -1,5 +0,0 @@
-01-labels.patch
-#02-ftbfs.patch
-08-allow-fsck-options.patch
-09-pthreadlink.patch
-
diff -Nru btrfs-tools-0.19+20111121/debian/rules btrfs-tools-0.19+20120328/debian/rules
--- btrfs-tools-0.19+20111121/debian/rules	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debian/rules	2012-05-05 19:32:05.000000000 +0000
@@ -5,14 +5,6 @@
 %:
 	dh --with quilt ${@}
 
-override_dh_auto_clean:
-	dh_auto_clean
-
-	rm -f btrfs-image btrfstune version.h
-
-override_dh_auto_build:
-	CFLAGS="$(CFLAGS)" $(MAKE) all btrfsck btrfstune btrfs-image convert
-
 override_dh_auto_install:
 	$(MAKE) DESTDIR=$(CURDIR)/debian/btrfs-tools prefix=/ bindir=/sbin mandir=/usr/share/man install
 
diff -Nru btrfs-tools-0.19+20111121/debug-tree.c btrfs-tools-0.19+20120328/debug-tree.c
--- btrfs-tools-0.19+20111121/debug-tree.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/debug-tree.c	2012-05-05 18:22:58.000000000 +0000
@@ -104,6 +104,7 @@
 int main(int ac, char **av)
 {
 	struct btrfs_root *root;
+	struct btrfs_fs_info *info;
 	struct btrfs_path path;
 	struct btrfs_key key;
 	struct btrfs_root_item ri;
@@ -152,12 +153,18 @@
 	if (ac != 1)
 		print_usage();
 
-	root = open_ctree(av[optind], 0, 0);
-	if (!root) {
+	info = open_ctree_fs_info(av[optind], 0, 0, 1);
+	if (!info) {
 		fprintf(stderr, "unable to open %s\n", av[optind]);
 		exit(1);
 	}
+	root = info->fs_root;
+
 	if (block_only) {
+		if (!root) {
+			fprintf(stderr, "unable to open %s\n", av[optind]);
+			exit(1);
+		}
 		leaf = read_tree_block(root,
 				      block_only,
 				      root->leafsize, 0);
@@ -184,25 +191,32 @@
 	if (!extent_only) {
 		if (roots_only) {
 			printf("root tree: %llu level %d\n",
-			     (unsigned long long)root->fs_info->tree_root->node->start,
-			     btrfs_header_level(root->fs_info->tree_root->node));
+			     (unsigned long long)info->tree_root->node->start,
+			     btrfs_header_level(info->tree_root->node));
 			printf("chunk tree: %llu level %d\n",
-			     (unsigned long long)root->fs_info->chunk_root->node->start,
-			     btrfs_header_level(root->fs_info->chunk_root->node));
+			     (unsigned long long)info->chunk_root->node->start,
+			     btrfs_header_level(info->chunk_root->node));
 		} else {
-			printf("root tree\n");
-			btrfs_print_tree(root->fs_info->tree_root,
-					 root->fs_info->tree_root->node, 1);
+			if (info->tree_root->node) {
+				printf("root tree\n");
+				btrfs_print_tree(info->tree_root,
+						 info->tree_root->node, 1);
+			}
 
-			printf("chunk tree\n");
-			btrfs_print_tree(root->fs_info->chunk_root,
-					 root->fs_info->chunk_root->node, 1);
+			if (info->chunk_root->node) {
+				printf("chunk tree\n");
+				btrfs_print_tree(info->chunk_root,
+						 info->chunk_root->node, 1);
+			}
 		}
 	}
-	tree_root_scan = root->fs_info->tree_root;
+	tree_root_scan = info->tree_root;
 
 	btrfs_init_path(&path);
 again:
+	if (!extent_buffer_uptodate(tree_root_scan->node))
+		goto no_node;
+
 	key.offset = 0;
 	key.objectid = 0;
 	btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
@@ -232,6 +246,9 @@
 					      btrfs_level_size(tree_root_scan,
 							btrfs_root_level(&ri)),
 					      0);
+			if (!extent_buffer_uptodate(buf))
+				goto next;
+
 			switch(found_key.objectid) {
 			case BTRFS_ROOT_TREE_OBJECTID:
 				if (!skip)
@@ -320,13 +337,15 @@
 				}
 			}
 		}
+next:
 		path.slots[0]++;
 	}
+no_node:
 	btrfs_release_path(root, &path);
 
-	if (tree_root_scan == root->fs_info->tree_root &&
-	    root->fs_info->log_root_tree) {
-		tree_root_scan = root->fs_info->log_root_tree;
+	if (tree_root_scan == info->tree_root &&
+	    info->log_root_tree) {
+		tree_root_scan = info->log_root_tree;
 		goto again;
 	}
 
@@ -334,14 +353,14 @@
 		return 0;
 
 	if (root_backups)
-		print_old_roots(&root->fs_info->super_copy);
+		print_old_roots(&info->super_copy);
 
 	printf("total bytes %llu\n",
-	       (unsigned long long)btrfs_super_total_bytes(&root->fs_info->super_copy));
+	       (unsigned long long)btrfs_super_total_bytes(&info->super_copy));
 	printf("bytes used %llu\n",
-	       (unsigned long long)btrfs_super_bytes_used(&root->fs_info->super_copy));
+	       (unsigned long long)btrfs_super_bytes_used(&info->super_copy));
 	uuidbuf[36] = '\0';
-	uuid_unparse(root->fs_info->super_copy.fsid, uuidbuf);
+	uuid_unparse(info->super_copy.fsid, uuidbuf);
 	printf("uuid %s\n", uuidbuf);
 	printf("%s\n", BTRFS_BUILD_VERSION);
 	return 0;
diff -Nru btrfs-tools-0.19+20111121/disk-io.c btrfs-tools-0.19+20120328/disk-io.c
--- btrfs-tools-0.19+20111121/disk-io.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/disk-io.c	2012-05-05 18:22:58.000000000 +0000
@@ -444,7 +444,9 @@
 	generation = btrfs_root_generation(&root->root_item);
 	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
 				     blocksize, generation);
-	BUG_ON(!root->node);
+	if (!extent_buffer_uptodate(root->node))
+		return -EIO;
+
 	return 0;
 }
 
@@ -471,7 +473,9 @@
 				     btrfs_super_generation(disk_super) + 1);
 
 	fs_info->log_root_tree = log_root;
-	BUG_ON(!log_root->node);
+
+	if (!extent_buffer_uptodate(log_root->node))
+		return -EIO;
 	return 0;
 }
 
@@ -580,7 +584,7 @@
 		return fs_info->dev_root;
 	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
 		return fs_info->csum_root;
-	
+
 	BUG_ON(location->objectid == BTRFS_TREE_RELOC_OBJECTID ||
 	       location->offset != (u64)-1);
 
@@ -601,8 +605,10 @@
 	return root;
 }
 
-struct btrfs_root *__open_ctree_fd(int fp, const char *path, u64 sb_bytenr,
-				   u64 root_tree_bytenr, int writes)
+static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path,
+					     u64 sb_bytenr,
+					     u64 root_tree_bytenr, int writes,
+					     int partial)
 {
 	u32 sectorsize;
 	u32 nodesize;
@@ -733,7 +739,7 @@
 	chunk_root->node = read_tree_block(chunk_root,
 					   btrfs_super_chunk_root(disk_super),
 					   blocksize, generation);
-	if (!chunk_root->node) {
+	if (!extent_buffer_uptodate(chunk_root->node)) {
 		printk("Couldn't read chunk root\n");
 		goto out_devices;
 	}
@@ -745,7 +751,7 @@
 	if (!(btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_METADUMP)) {
 		ret = btrfs_read_chunk_tree(chunk_root);
 		if (ret)
-			goto out_chunk;
+			goto out_failed;
 	}
 
 	blocksize = btrfs_level_size(tree_root,
@@ -757,15 +763,15 @@
 	tree_root->node = read_tree_block(tree_root,
 					  root_tree_bytenr,
 					  blocksize, generation);
-	if (!tree_root->node) {
+	if (!extent_buffer_uptodate(tree_root->node)) {
 		printk("Couldn't read tree root\n");
-		goto out_chunk;
+		goto out_failed;
 	}
 	ret = find_and_setup_root(tree_root, fs_info,
 				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 	if (ret) {
 		printk("Couldn't setup extent tree\n");
-		goto out_tree;
+		goto out_failed;
 	}
 	extent_root->track_dirty = 1;
 
@@ -773,7 +779,7 @@
 				  BTRFS_DEV_TREE_OBJECTID, dev_root);
 	if (ret) {
 		printk("Couldn't setup device tree\n");
-		goto out_extent;
+		goto out_failed;
 	}
 	dev_root->track_dirty = 1;
 
@@ -781,7 +787,8 @@
 				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
 	if (ret) {
 		printk("Couldn't setup csum tree\n");
-		goto out_dev;
+		if (!partial)
+			goto out_failed;
 	}
 	csum_root->track_dirty = 1;
 
@@ -797,23 +804,28 @@
 	fs_info->fs_root = btrfs_read_fs_root(fs_info, &key);
 
 	if (!fs_info->fs_root)
-		goto out_csum;
+		goto out_failed;
 
 	fs_info->data_alloc_profile = (u64)-1;
 	fs_info->metadata_alloc_profile = (u64)-1;
 	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
 
-	return fs_info->fs_root;
-out_csum:
-	free_extent_buffer(fs_info->csum_root->node);
-out_dev:
-	free_extent_buffer(fs_info->dev_root->node);
-out_extent:
-	free_extent_buffer(fs_info->extent_root->node);
-out_tree:
-	free_extent_buffer(fs_info->tree_root->node);
-out_chunk:
-	free_extent_buffer(fs_info->chunk_root->node);
+	return fs_info;
+
+out_failed:
+	if (partial)
+		return fs_info;
+
+	if (fs_info->csum_root)
+		free_extent_buffer(fs_info->csum_root->node);
+	if (fs_info->dev_root)
+		free_extent_buffer(fs_info->dev_root->node);
+	if (fs_info->extent_root)
+		free_extent_buffer(fs_info->extent_root->node);
+	if (fs_info->tree_root)
+		free_extent_buffer(fs_info->tree_root->node);
+	if (fs_info->chunk_root)
+		free_extent_buffer(fs_info->chunk_root->node);
 out_devices:
 	close_all_devices(fs_info);
 out_cleanup:
@@ -833,10 +845,12 @@
 	return NULL;
 }
 
-struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr, int writes)
+struct btrfs_fs_info *open_ctree_fs_info(const char *filename,
+					 u64 sb_bytenr, int writes,
+					 int partial)
 {
 	int fp;
-	struct btrfs_root *root;
+	struct btrfs_fs_info *info;
 	int flags = O_CREAT | O_RDWR;
 
 	if (!writes)
@@ -847,33 +861,50 @@
 		fprintf (stderr, "Could not open %s\n", filename);
 		return NULL;
 	}
-	root = __open_ctree_fd(fp, filename, sb_bytenr, 0, writes);
+	info = __open_ctree_fd(fp, filename, sb_bytenr, 0, writes, partial);
 	close(fp);
+	return info;
+}
 
-	return root;
+struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr, int writes)
+{
+	struct btrfs_fs_info *info;
+
+	info = open_ctree_fs_info(filename, sb_bytenr, writes, 0);
+	if (!info)
+		return NULL;
+	return info->fs_root;
 }
 
 struct btrfs_root *open_ctree_recovery(const char *filename, u64 sb_bytenr,
 				       u64 root_tree_bytenr)
 {
 	int fp;
-	struct btrfs_root *root;
+	struct btrfs_fs_info *info;
+
 
 	fp = open(filename, O_RDONLY);
 	if (fp < 0) {
 		fprintf (stderr, "Could not open %s\n", filename);
 		return NULL;
 	}
-	root = __open_ctree_fd(fp, filename, sb_bytenr, root_tree_bytenr, 0);
+	info = __open_ctree_fd(fp, filename, sb_bytenr,
+			       root_tree_bytenr, 0, 0);
 	close(fp);
 
-	return root;
+	if (!info)
+		return NULL;
+	return info->fs_root;
 }
 
 struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr,
 				 int writes)
 {
-	return __open_ctree_fd(fp, path, sb_bytenr, 0, writes);
+	struct btrfs_fs_info *info;
+	info = __open_ctree_fd(fp, path, sb_bytenr, 0, writes, 0);
+	if (!info)
+		return NULL;
+	return info->fs_root;
 }
 
 int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr)
diff -Nru btrfs-tools-0.19+20111121/disk-io.h btrfs-tools-0.19+20120328/disk-io.h
--- btrfs-tools-0.19+20111121/disk-io.h	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/disk-io.h	2012-05-05 18:22:58.000000000 +0000
@@ -48,6 +48,9 @@
 				 int writes);
 struct btrfs_root *open_ctree_recovery(const char *filename, u64 sb_bytenr,
 				       u64 root_tree_bytenr);
+struct btrfs_fs_info *open_ctree_fs_info(const char *filename,
+					 u64 sb_bytenr, int writes,
+					 int partial);
 int close_ctree(struct btrfs_root *root);
 int write_all_supers(struct btrfs_root *root);
 int write_ctree_super(struct btrfs_trans_handle *trans,
diff -Nru btrfs-tools-0.19+20111121/extent_io.c btrfs-tools-0.19+20120328/extent_io.c
--- btrfs-tools-0.19+20111121/extent_io.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/extent_io.c	2012-05-05 18:22:58.000000000 +0000
@@ -28,7 +28,8 @@
 #include "extent_io.h"
 #include "list.h"
 
-u64 cache_max = 1024 * 1024 * 32;
+u64 cache_soft_max = 1024 * 1024 * 256;
+u64 cache_hard_max = 1 * 1024 * 1024 * 1024;
 
 void extent_io_tree_init(struct extent_io_tree *tree)
 {
@@ -540,18 +541,19 @@
 	struct extent_buffer *eb;
 	struct list_head *node, *next;
 
-	if (tree->cache_size < cache_max)
+	if (tree->cache_size < cache_soft_max)
 		return 0;
+
 	list_for_each_safe(node, next, &tree->lru) {
 		eb = list_entry(node, struct extent_buffer, lru);
 		if (eb->refs == 1) {
 			free_extent_buffer(eb);
-			if (tree->cache_size < cache_max)
+			if (tree->cache_size < cache_hard_max)
 				break;
 		} else {
 			list_move_tail(&eb->lru, &tree->lru);
 		}
-		if (nrscan++ > 64)
+		if (nrscan++ > 64 && tree->cache_size < cache_hard_max)
 			break;
 	}
 	return 0;
@@ -706,6 +708,9 @@
 
 int extent_buffer_uptodate(struct extent_buffer *eb)
 {
+	if (!eb)
+		return 0;
+
 	if (eb->flags & EXTENT_UPTODATE)
 		return 1;
 	return 0;
diff -Nru btrfs-tools-0.19+20111121/extent-tree.c btrfs-tools-0.19+20120328/extent-tree.c
--- btrfs-tools-0.19+20111121/extent-tree.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/extent-tree.c	2012-05-05 18:22:58.000000000 +0000
@@ -1041,8 +1041,6 @@
 	}
 	if (ret) {
 		printf("Failed to find [%llu, %u, %llu]\n", key.objectid, key.type, key.offset);
-		btrfs_print_leaf(root, path->nodes[0]);
-		btrfs_free_path(path);
 		return -ENOENT;
 	}
 
@@ -1067,8 +1065,9 @@
 	}
 #endif
 	if (item_size < sizeof(*ei)) {
-		printf("Size is %u, needs to be %u, slot %d\n", item_size,
-		       sizeof(*ei), path->slots[0]);
+		printf("Size is %u, needs to be %u, slot %d\n",
+		       (unsigned)item_size,
+		       (unsigned)sizeof(*ei), path->slots[0]);
 		btrfs_print_leaf(root, leaf);
 		return -EINVAL;
 	}
@@ -1084,7 +1083,9 @@
 		ptr += sizeof(struct btrfs_tree_block_info);
 		BUG_ON(ptr > end);
 	} else {
-		BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
+		if (!(flags & BTRFS_EXTENT_FLAG_DATA)) {
+			return -EIO;
+		}
 	}
 
 	err = -ENOENT;
@@ -1460,10 +1461,8 @@
 	if (ret < 0)
 		goto out;
 	if (ret != 0) {
-		btrfs_print_leaf(root, path->nodes[0]);
-		printk("failed to find block number %Lu\n",
-		       (unsigned long long)bytenr);
-		BUG();
+		ret = -EIO;
+		goto out;
 	}
 
 	l = path->nodes[0];
@@ -1484,9 +1483,8 @@
 			extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
 #else
 			BUG();
-#endif		
-		}
-		BUG_ON(num_refs == 0);
+#endif
+	}
 	item = btrfs_item_ptr(l, path->slots[0], struct btrfs_extent_item);
 	if (refs)
 		*refs = num_refs;
@@ -1705,7 +1703,6 @@
 
 		cache = (struct btrfs_block_group_cache *)(unsigned long)ptr;
 		ret = write_one_cache_group(trans, root, path, cache);
-		BUG_ON(ret);
 	}
 	btrfs_free_path(path);
 	return 0;
@@ -1736,7 +1733,12 @@
 	if (found) {
 		found->total_bytes += total_bytes;
 		found->bytes_used += bytes_used;
-		WARN_ON(found->total_bytes < found->bytes_used);
+		if (found->total_bytes < found->bytes_used) {
+			fprintf(stderr, "warning, bad space info total_bytes "
+				"%llu used %llu\n",
+			       (unsigned long long)found->total_bytes,
+			       (unsigned long long)found->bytes_used);
+		}
 		*space_info = found;
 		return 0;
 	}
@@ -1855,6 +1857,7 @@
 
 		old_val = btrfs_block_group_used(&cache->item);
 		num_bytes = min(total, cache->key.offset - byte_in_group);
+
 		if (alloc) {
 			old_val += num_bytes;
 			cache->space_info->bytes_used += num_bytes;
@@ -1890,6 +1893,10 @@
 	}
 	while (num > 0) {
 		cache = btrfs_lookup_block_group(fs_info, bytenr);
+		if (!cache) {
+			len = min((u64)root->sectorsize, num);
+			goto next;
+		}
 		WARN_ON(!cache);
 		len = min(num, cache->key.offset -
 			  (bytenr - cache->key.objectid));
@@ -1902,6 +1909,7 @@
 			cache->space_info->bytes_pinned -= len;
 			fs_info->total_pinned -= len;
 		}
+next:
 		bytenr += len;
 		num -= len;
 	}
@@ -1949,6 +1957,21 @@
 	return 0;
 }
 
+static int extent_root_pending_ops(struct btrfs_fs_info *info)
+{
+	u64 start;
+	u64 end;
+	int ret;
+
+	ret = find_first_extent_bit(&info->extent_ins, 0, &start,
+				    &end, EXTENT_LOCKED);
+	if (!ret) {
+		ret = find_first_extent_bit(&info->pending_del, 0, &start, &end,
+					    EXTENT_LOCKED);
+	}
+	return ret == 0;
+
+}
 static int finish_current_insert(struct btrfs_trans_handle *trans,
 				 struct btrfs_root *extent_root)
 {
@@ -2033,6 +2056,12 @@
 	return 0;
 }
 
+void btrfs_pin_extent(struct btrfs_fs_info *fs_info,
+		       u64 bytenr, u64 num_bytes)
+{
+	update_pinned_extents(fs_info->extent_root, bytenr, num_bytes, 1);
+}
+
 /*
  * remove an extent from the root, returns 0 on success
  */
@@ -2058,6 +2087,12 @@
 	u32 item_size;
 	u64 refs;
 
+	if (root->fs_info->free_extent_hook) {
+		root->fs_info->free_extent_hook(trans, root, bytenr, num_bytes,
+						parent, root_objectid, owner_objectid,
+						owner_offset, refs_to_drop);
+
+	}
 	path = btrfs_alloc_path();
 	if (!path)
 		return -ENOMEM;
@@ -2118,8 +2153,6 @@
 			extent_slot = path->slots[0];
 		}
 	} else {
-		btrfs_print_leaf(extent_root, path->nodes[0]);
-		WARN_ON(1);
 		printk(KERN_ERR "btrfs unable to find ref byte nr %llu "
 		       "parent %llu root %llu  owner %llu offset %llu\n",
 		       (unsigned long long)bytenr,
@@ -2127,6 +2160,8 @@
 		       (unsigned long long)root_objectid,
 		       (unsigned long long)owner_objectid,
 		       (unsigned long long)owner_offset);
+		ret = -EIO;
+		goto fail;
 	}
 
 	leaf = path->nodes[0];
@@ -2232,10 +2267,9 @@
 			BUG_ON(ret);
 		}
 
-		ret = update_block_group(trans, root, bytenr, num_bytes, 0,
-					 mark_free);
-		BUG_ON(ret);
+		update_block_group(trans, root, bytenr, num_bytes, 0, mark_free);
 	}
+fail:
 	btrfs_free_path(path);
 	finish_current_insert(trans, extent_root);
 	return ret;
@@ -2564,13 +2598,7 @@
 
 	ret = update_block_group(trans, root, ins->objectid, ins->offset,
 				 1, 0);
-	if (ret) {
-		printk(KERN_ERR "btrfs update block group failed for %llu "
-		       "%llu\n", (unsigned long long)ins->objectid,
-		       (unsigned long long)ins->offset);
-		BUG();
-	}
-	return ret;
+	return 0;
 }
 
 static int alloc_tree_block(struct btrfs_trans_handle *trans,
@@ -3153,7 +3181,6 @@
 
 	finish_current_insert(trans, extent_root);
 	ret = del_pending_extents(trans, extent_root);
-	BUG_ON(ret);
 	set_avail_alloc_bits(extent_root->fs_info, type);
 	return 0;
 }
@@ -3269,3 +3296,158 @@
 	return update_block_group(trans, root, bytenr, num_bytes,
 				  alloc, mark_free);
 }
+
+static int btrfs_count_extents_in_block_group(struct btrfs_root *root,
+					      struct btrfs_path *path, u64 start,
+					      u64 len,
+					      u64 *total)
+{
+	struct btrfs_key key;
+	struct extent_buffer *leaf;
+	u64 bytes_used = 0;
+	int ret;
+	int slot;
+
+	key.offset = 0;
+	key.objectid = start;
+	btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
+	ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
+				&key, path, 0, 0);
+	if (ret < 0)
+		return ret;
+	while(1) {
+		leaf = path->nodes[0];
+		slot = path->slots[0];
+		if (slot >= btrfs_header_nritems(leaf)) {
+			ret = btrfs_next_leaf(root, path);
+			if (ret < 0)
+				return ret;
+			if (ret > 0)
+				break;
+			leaf = path->nodes[0];
+			slot = path->slots[0];
+		}
+		btrfs_item_key_to_cpu(leaf, &key, slot);
+		if (key.objectid > start + len)
+			break;
+		if (key.type == BTRFS_EXTENT_ITEM_KEY)
+			bytes_used += key.offset;
+		path->slots[0]++;
+	}
+	*total = bytes_used;
+	btrfs_release_path(root, path);
+	return 0;
+}
+
+int btrfs_check_block_accounting(struct btrfs_root *root)
+{
+	int ret;
+	u64 start = 0;
+	u64 bytes_used = 0;
+	struct btrfs_path path;
+	struct btrfs_block_group_cache *cache;
+	struct btrfs_fs_info *fs_info = root->fs_info;
+
+	btrfs_init_path(&path);
+
+	while(1) {
+		cache = btrfs_lookup_block_group(fs_info, start);
+		if (!cache)
+			break;
+
+		ret = btrfs_count_extents_in_block_group(root, &path,
+							 cache->key.objectid,
+							 cache->key.offset,
+							 &bytes_used);
+
+		if (ret == 0) {
+			u64 on_disk = btrfs_block_group_used(&cache->item);
+			if (on_disk != bytes_used) {
+				fprintf(stderr, "bad block group accounting found %llu "
+					"expected %llu block group %llu\n",
+					(unsigned long long)bytes_used,
+					(unsigned long long)on_disk,
+					(unsigned long long)cache->key.objectid);
+			}
+		}
+		start = cache->key.objectid + cache->key.offset;
+
+		cache->space_info->bytes_used = 0;
+	}
+	return 0;
+}
+
+/*
+ * Fixup block accounting. The initial block accounting created by
+ * make_block_groups isn't accuracy in this case.
+ */
+int btrfs_fix_block_accounting(struct btrfs_trans_handle *trans,
+			       struct btrfs_root *root)
+{
+	int ret;
+	int slot;
+	u64 start = 0;
+	u64 bytes_used = 0;
+	struct btrfs_path path;
+	struct btrfs_key key;
+	struct extent_buffer *leaf;
+	struct btrfs_block_group_cache *cache;
+	struct btrfs_fs_info *fs_info = root->fs_info;
+
+	root = root->fs_info->extent_root;
+
+	while(extent_root_pending_ops(fs_info)) {
+		ret = finish_current_insert(trans, root);
+		if (ret)
+			return ret;
+		ret = del_pending_extents(trans, root);
+		if (ret)
+			return ret;
+	}
+
+	while(1) {
+		cache = btrfs_lookup_block_group(fs_info, start);
+		if (!cache)
+			break;
+		start = cache->key.objectid + cache->key.offset;
+		btrfs_set_block_group_used(&cache->item, 0);
+		cache->space_info->bytes_used = 0;
+		set_extent_bits(&root->fs_info->block_group_cache,
+				cache->key.objectid,
+				cache->key.objectid + cache->key.offset -1,
+				BLOCK_GROUP_DIRTY, GFP_NOFS);
+	}
+
+	btrfs_init_path(&path);
+	key.offset = 0;
+	key.objectid = 0;
+	btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
+	ret = btrfs_search_slot(trans, root->fs_info->extent_root,
+				&key, &path, 0, 0);
+	if (ret < 0)
+		return ret;
+	while(1) {
+		leaf = path.nodes[0];
+		slot = path.slots[0];
+		if (slot >= btrfs_header_nritems(leaf)) {
+			ret = btrfs_next_leaf(root, &path);
+			if (ret < 0)
+				return ret;
+			if (ret > 0)
+				break;
+			leaf = path.nodes[0];
+			slot = path.slots[0];
+		}
+		btrfs_item_key_to_cpu(leaf, &key, slot);
+		if (key.type == BTRFS_EXTENT_ITEM_KEY) {
+			bytes_used += key.offset;
+			ret = btrfs_update_block_group(trans, root,
+				  key.objectid, key.offset, 1, 0);
+			BUG_ON(ret);
+		}
+		path.slots[0]++;
+	}
+	btrfs_set_super_bytes_used(&root->fs_info->super_copy, bytes_used);
+	btrfs_release_path(root, &path);
+	return 0;
+}
diff -Nru btrfs-tools-0.19+20111121/.git/COMMIT_EDITMSG btrfs-tools-0.19+20120328/.git/COMMIT_EDITMSG
--- btrfs-tools-0.19+20111121/.git/COMMIT_EDITMSG	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/COMMIT_EDITMSG	2012-05-05 18:51:39.000000000 +0000
@@ -1,8 +1,37 @@
-
+added: debian folder
 # Please enter the commit message for your changes. Lines starting
 # with '#' will be ignored, and an empty message aborts the commit.
-# On branch master
+# On branch joggler
+# Changes to be committed:
+#   (use "git reset HEAD <file>..." to unstage)
+#
+#	new file:   debian/README.source
+#	new file:   debian/btrfs-tools-udeb.install
+#	new file:   debian/btrfs-tools.README.Debian
+#	new file:   debian/btrfs-tools.install
+#	new file:   debian/btrfs-tools.links
+#	new file:   debian/changelog
+#	new file:   debian/compat
+#	new file:   debian/control
+#	new file:   debian/copyright
+#	new file:   debian/files
+#	new file:   debian/local/btrfs.hook
+#	new file:   debian/local/btrfs.local-premount
+#	new file:   debian/local/btrfs.modules
+#	new file:   debian/patches/01-labels.patch
+#	new file:   debian/patches/02-ftbfs.patch
+#	new file:   debian/patches/03-glibc.patch
+#	new file:   debian/patches/08-allow-fsck-options.patch
+#	new file:   debian/patches/09-pthreadlink.patch
+#	new file:   debian/patches/series
+#	new file:   debian/rules
+#	new file:   debian/source/format
+#
 # Untracked files:
 #   (use "git add <file>..." to include in what will be committed)
 #
-#	debian/
+#	.pc/
+#	btrfs-corrupt-block
+#	btrfsck.c.orig
+#	calc-size
+#	test.patch
diff -Nru btrfs-tools-0.19+20111121/.git/FETCH_HEAD btrfs-tools-0.19+20120328/.git/FETCH_HEAD
--- btrfs-tools-0.19+20111121/.git/FETCH_HEAD	2011-11-22 23:55:20.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/FETCH_HEAD	2012-05-05 18:21:19.000000000 +0000
@@ -1,3 +1,5 @@
+1957076ab4fefa47b6efed3da541bc974c83eed7		branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs
+1957076ab4fefa47b6efed3da541bc974c83eed7	not-for-merge	branch 'dangerdonteveruse' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs
 882895d4119992af2c9b654dbb3ac88cd17fa810	not-for-merge	branch 'integration-scrub' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs
-6da41f2a740569440e88539779cb94f169b1f1b6		branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs
+6cd813b6fc18ba75edfcfad5857d27f0265c2c28	not-for-merge	branch 'parser' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs
 f25e1d16a5f35fb43c577cd33163c6aa290a587b	not-for-merge	branch 'recovery-beta' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs
diff -Nru btrfs-tools-0.19+20111121/.git/HEAD btrfs-tools-0.19+20120328/.git/HEAD
--- btrfs-tools-0.19+20111121/.git/HEAD	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/HEAD	2012-05-05 18:22:55.000000000 +0000
@@ -1 +1 @@
-ref: refs/heads/master
+ref: refs/heads/joggler
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/index and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/index differ
diff -Nru btrfs-tools-0.19+20111121/.git/logs/HEAD btrfs-tools-0.19+20120328/.git/logs/HEAD
--- btrfs-tools-0.19+20111121/.git/logs/HEAD	2011-11-22 23:55:20.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/logs/HEAD	2012-05-05 18:51:39.000000000 +0000
@@ -1,3 +1,11 @@
 0000000000000000000000000000000000000000 1b444cd2e6ab8dcafdd47dbaeaae369dd1517c17 Jools Wills <buzz@exotica.org.uk> 1299541439 +0000	clone: from git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs-unstable.git
 1b444cd2e6ab8dcafdd47dbaeaae369dd1517c17 13eced9a0c2b6bd6bc38e6f0f46a1977b1167e67 Jools Wills <buzz@exotica.org.uk> 1321646047 +0000	pull : Fast-forward
 13eced9a0c2b6bd6bc38e6f0f46a1977b1167e67 6da41f2a740569440e88539779cb94f169b1f1b6 Jools Wills <buzz@exotica.org.uk> 1322006120 +0000	pull : Fast-forward
+6da41f2a740569440e88539779cb94f169b1f1b6 fdb6c0402337d9607c7a39155088eaf033742752 Jools Wills <buzz@exotica.org.uk> 1324953471 +0000	pull: Fast-forward
+fdb6c0402337d9607c7a39155088eaf033742752 fdb6c0402337d9607c7a39155088eaf033742752 Jools Wills <buzz@exotica.org.uk> 1336242035 +0100	checkout: moving from master to joggler
+fdb6c0402337d9607c7a39155088eaf033742752 b2a3699a59876a5ef665f41710c9344e17f46fdb Jools Wills <buzz@exotica.org.uk> 1336242062 +0100	commit: ignore -a
+b2a3699a59876a5ef665f41710c9344e17f46fdb fdb6c0402337d9607c7a39155088eaf033742752 Jools Wills <buzz@exotica.org.uk> 1336242078 +0100	checkout: moving from joggler to master
+fdb6c0402337d9607c7a39155088eaf033742752 1957076ab4fefa47b6efed3da541bc974c83eed7 Jools Wills <buzz@exotica.org.uk> 1336242080 +0100	pull: Fast-forward
+1957076ab4fefa47b6efed3da541bc974c83eed7 b2a3699a59876a5ef665f41710c9344e17f46fdb Jools Wills <buzz@exotica.org.uk> 1336242175 +0100	checkout: moving from master to joggler
+b2a3699a59876a5ef665f41710c9344e17f46fdb acf9aeaeba27720d8c0352ae52f5fb70cbfa8195 Jools Wills <buzz@exotica.org.uk> 1336243129 +0100	commit (merge): Merge branch 'master' into joggler
+acf9aeaeba27720d8c0352ae52f5fb70cbfa8195 cee725d761b6ea4aa9e4ab17f21f4651a394c9d1 Jools Wills <buzz@exotica.org.uk> 1336243893 +0100	commit: added: debian folder
diff -Nru btrfs-tools-0.19+20111121/.git/logs/refs/heads/joggler btrfs-tools-0.19+20120328/.git/logs/refs/heads/joggler
--- btrfs-tools-0.19+20111121/.git/logs/refs/heads/joggler	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/logs/refs/heads/joggler	2012-05-05 18:51:39.000000000 +0000
@@ -0,0 +1,4 @@
+0000000000000000000000000000000000000000 fdb6c0402337d9607c7a39155088eaf033742752 Jools Wills <buzz@exotica.org.uk> 1336242035 +0100	branch: Created from master
+fdb6c0402337d9607c7a39155088eaf033742752 b2a3699a59876a5ef665f41710c9344e17f46fdb Jools Wills <buzz@exotica.org.uk> 1336242062 +0100	commit: ignore -a
+b2a3699a59876a5ef665f41710c9344e17f46fdb acf9aeaeba27720d8c0352ae52f5fb70cbfa8195 Jools Wills <buzz@exotica.org.uk> 1336243129 +0100	commit (merge): Merge branch 'master' into joggler
+acf9aeaeba27720d8c0352ae52f5fb70cbfa8195 cee725d761b6ea4aa9e4ab17f21f4651a394c9d1 Jools Wills <buzz@exotica.org.uk> 1336243893 +0100	commit: added: debian folder
diff -Nru btrfs-tools-0.19+20111121/.git/logs/refs/heads/master btrfs-tools-0.19+20120328/.git/logs/refs/heads/master
--- btrfs-tools-0.19+20111121/.git/logs/refs/heads/master	2011-11-22 23:55:20.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/logs/refs/heads/master	2012-05-05 18:21:20.000000000 +0000
@@ -1,3 +1,5 @@
 0000000000000000000000000000000000000000 1b444cd2e6ab8dcafdd47dbaeaae369dd1517c17 Jools Wills <buzz@exotica.org.uk> 1299541439 +0000	clone: from git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-progs-unstable.git
 1b444cd2e6ab8dcafdd47dbaeaae369dd1517c17 13eced9a0c2b6bd6bc38e6f0f46a1977b1167e67 Jools Wills <buzz@exotica.org.uk> 1321646047 +0000	pull : Fast-forward
 13eced9a0c2b6bd6bc38e6f0f46a1977b1167e67 6da41f2a740569440e88539779cb94f169b1f1b6 Jools Wills <buzz@exotica.org.uk> 1322006120 +0000	pull : Fast-forward
+6da41f2a740569440e88539779cb94f169b1f1b6 fdb6c0402337d9607c7a39155088eaf033742752 Jools Wills <buzz@exotica.org.uk> 1324953471 +0000	pull: Fast-forward
+fdb6c0402337d9607c7a39155088eaf033742752 1957076ab4fefa47b6efed3da541bc974c83eed7 Jools Wills <buzz@exotica.org.uk> 1336242080 +0100	pull: Fast-forward
diff -Nru btrfs-tools-0.19+20111121/.git/logs/refs/remotes/origin/dangerdonteveruse btrfs-tools-0.19+20120328/.git/logs/refs/remotes/origin/dangerdonteveruse
--- btrfs-tools-0.19+20111121/.git/logs/refs/remotes/origin/dangerdonteveruse	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/logs/refs/remotes/origin/dangerdonteveruse	2012-05-05 18:19:51.000000000 +0000
@@ -0,0 +1,3 @@
+0000000000000000000000000000000000000000 62b79931546bca1b95a4b23ecec8378c372b26f7 Jools Wills <buzz@exotica.org.uk> 1329637437 +0000	pull: storing head
+62b79931546bca1b95a4b23ecec8378c372b26f7 e22827e9bb9634540d32bf29b23b26989e384902 Jools Wills <buzz@exotica.org.uk> 1330130656 +0000	pull: fast-forward
+e22827e9bb9634540d32bf29b23b26989e384902 1957076ab4fefa47b6efed3da541bc974c83eed7 Jools Wills <buzz@exotica.org.uk> 1336241991 +0100	pull: fast-forward
diff -Nru btrfs-tools-0.19+20111121/.git/logs/refs/remotes/origin/master btrfs-tools-0.19+20120328/.git/logs/refs/remotes/origin/master
--- btrfs-tools-0.19+20111121/.git/logs/refs/remotes/origin/master	2011-11-22 23:55:20.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/logs/refs/remotes/origin/master	2012-05-05 18:19:51.000000000 +0000
@@ -1,2 +1,4 @@
 1b444cd2e6ab8dcafdd47dbaeaae369dd1517c17 13eced9a0c2b6bd6bc38e6f0f46a1977b1167e67 Jools Wills <buzz@exotica.org.uk> 1321646047 +0000	pull : fast-forward
 13eced9a0c2b6bd6bc38e6f0f46a1977b1167e67 6da41f2a740569440e88539779cb94f169b1f1b6 Jools Wills <buzz@exotica.org.uk> 1322006120 +0000	pull : fast-forward
+6da41f2a740569440e88539779cb94f169b1f1b6 fdb6c0402337d9607c7a39155088eaf033742752 Jools Wills <buzz@exotica.org.uk> 1324953471 +0000	pull: fast-forward
+fdb6c0402337d9607c7a39155088eaf033742752 1957076ab4fefa47b6efed3da541bc974c83eed7 Jools Wills <buzz@exotica.org.uk> 1336241991 +0100	pull: fast-forward
diff -Nru btrfs-tools-0.19+20111121/.git/logs/refs/remotes/origin/parser btrfs-tools-0.19+20120328/.git/logs/refs/remotes/origin/parser
--- btrfs-tools-0.19+20111121/.git/logs/refs/remotes/origin/parser	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/logs/refs/remotes/origin/parser	2012-02-07 07:36:07.000000000 +0000
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 6cd813b6fc18ba75edfcfad5857d27f0265c2c28 Jools Wills <buzz@exotica.org.uk> 1328600167 +0000	pull: storing head
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/00/a1f124370ede943c78612535fb580455254124 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/00/a1f124370ede943c78612535fb580455254124 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/01/dfa3f65c7cecf4b5f19bf04b02688d38c5f5b7 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/01/dfa3f65c7cecf4b5f19bf04b02688d38c5f5b7 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/03/f657039ed14b8c8a96fd995699d1e1a4a08ce0 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/03/f657039ed14b8c8a96fd995699d1e1a4a08ce0 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/07/cf333420d832b54082fe6bdf4b4a104c126205 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/07/cf333420d832b54082fe6bdf4b4a104c126205 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/08/b51bd731467ac8da182d69c827a8a5c7877079 btrfs-tools-0.19+20120328/.git/objects/08/b51bd731467ac8da182d69c827a8a5c7877079
--- btrfs-tools-0.19+20111121/.git/objects/08/b51bd731467ac8da182d69c827a8a5c7877079	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/08/b51bd731467ac8da182d69c827a8a5c7877079	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1 @@
+x
�ŽËJÅ0Eç+Î\*y4MzqâØ/Èëôò(Iªôï½¢s�m6¬År5ç8@0u7Z0‹3Rª¤·J‡À˜¢hW\Р\™Ú{$»i¡Xœ×LØÓÖ(<:4^j©<WHù"w\sŒkmð–N¯í¬¹~Àcô?ëyË&¦Wó0Áµbr•3ÜSN)¹½·Äþ
sÊ$û…ÉËhا½Õ­_À¤T?!iÄ)ÅàÛmŠ‡­Õc‡~–º÷Ø	y�[	~ªˆ“=/W“/Vÿj¬
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/08/e2cb625eb553e1317e137b279eb7547cef6ae8 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/08/e2cb625eb553e1317e137b279eb7547cef6ae8 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/09/2b36870ce949e8dfd3d632adbcf0fe5ad62a4d and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/09/2b36870ce949e8dfd3d632adbcf0fe5ad62a4d differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0a/3c61bff711740803b729ab0cc99d0e61e65533 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0a/3c61bff711740803b729ab0cc99d0e61e65533 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0a/6fc8b6c4466ed5ed0f74400d778c024281de8a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0a/6fc8b6c4466ed5ed0f74400d778c024281de8a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0a/707babe042fc64ed10c50c06496bf4f62a4a50 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0a/707babe042fc64ed10c50c06496bf4f62a4a50 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0a/eb526b2c4dabde1b8cdda2f8c1a7eadb8a290a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0a/eb526b2c4dabde1b8cdda2f8c1a7eadb8a290a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0b/c5e18aace8d2535adc57cfa95c2481e94d60f7 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0b/c5e18aace8d2535adc57cfa95c2481e94d60f7 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/0c/496f113aadc92b01b6c6df5960b7a29e5cb009 btrfs-tools-0.19+20120328/.git/objects/0c/496f113aadc92b01b6c6df5960b7a29e5cb009
--- btrfs-tools-0.19+20111121/.git/objects/0c/496f113aadc92b01b6c6df5960b7a29e5cb009	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/0c/496f113aadc92b01b6c6df5960b7a29e5cb009	2012-05-05 18:47:57.000000000 +0000
@@ -0,0 +1,2 @@
+x
+)JMU020d040031QH*)J+ÖMÎÏ+K-*aø´,ôÃzƒãÇO.×>ðwö3ÿ#jè
+‹ŠJJt“rò“³¦½ÐsUzðÿ‘WK=ÿ#£gs$PÌÍÌMLOe(_±,_ïæýÍ‹ž®ÜÉ1mçéÏ“®•"++)ÍKe¸|RÝs5�³åê{&mÏ»ßð/¹U”œ˜“¬[œY•Ê0mӶƇWDÎ)Ï+^wôVôê–=ûd
üµY%
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0c/e1abf1ce4acc73a8c325936d5b7a33ea712de7 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0c/e1abf1ce4acc73a8c325936d5b7a33ea712de7 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0d/3fae779225d9f5eb40381ee14c175bf45fb34e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0d/3fae779225d9f5eb40381ee14c175bf45fb34e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0d/47bd514bfd2d01837e3da22e9a0e609a5c7586 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0d/47bd514bfd2d01837e3da22e9a0e609a5c7586 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0d/518799b2670c442a3cc2d7c008999576ba918e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0d/518799b2670c442a3cc2d7c008999576ba918e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0d/5a7bbbaf1b3004fe4292faf9f54dd98e5e0837 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0d/5a7bbbaf1b3004fe4292faf9f54dd98e5e0837 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0d/e079e895ca56525459a8d71e6d325a32f6d8ac and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0d/e079e895ca56525459a8d71e6d325a32f6d8ac differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0f/0df7cb920080d16df0c13e5fc3feefcd99208a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0f/0df7cb920080d16df0c13e5fc3feefcd99208a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0f/7c25e580902925cfa15fd4a6e86651fd29ae39 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0f/7c25e580902925cfa15fd4a6e86651fd29ae39 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/0f/c4c7fae739967711c32d62abced4e65006b770 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/0f/c4c7fae739967711c32d62abced4e65006b770 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/10/3a17a83cca8221b73fff8e6be542410c876ed6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/10/3a17a83cca8221b73fff8e6be542410c876ed6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/11/5fbadc77074788f7affc0f097e09eff8c79997 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/11/5fbadc77074788f7affc0f097e09eff8c79997 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/12/7f119263d9b3b471ed7c3902ca0cc6eb8ec6bd and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/12/7f119263d9b3b471ed7c3902ca0cc6eb8ec6bd differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/18/b6b245bf0ea8f80e9efbaea056fcd101666f8d and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/18/b6b245bf0ea8f80e9efbaea056fcd101666f8d differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/19/35dd704649ddf11fed484647e790c8c5581ecd and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/19/35dd704649ddf11fed484647e790c8c5581ecd differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/19/57076ab4fefa47b6efed3da541bc974c83eed7 btrfs-tools-0.19+20120328/.git/objects/19/57076ab4fefa47b6efed3da541bc974c83eed7
--- btrfs-tools-0.19+20111121/.git/objects/19/57076ab4fefa47b6efed3da541bc974c83eed7	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/19/57076ab4fefa47b6efed3da541bc974c83eed7	2012-05-05 18:19:50.000000000 +0000
@@ -0,0 +1,2 @@
+x
�ŽAnà E»æs
GÀ@€ªªuÝUO0à ÙdÑÛ×¹AÕåû_ÿëqo­@e_Æ–3x/ƒQ¬Ê€ñÉH92ž½õŒ1s2ÖŠ;my —£A£µ	Ñ[ÐXm”“!£sÚɤµô×¾Áçu«;|ÑÞWxã'œÚ>úF¼ä÷ö
+Q+�v0I#¥8ÒÃräÿîÅ%%¨ëqs§
e¡Ê!ë-J4âÒù¶ñ]ç5§©—2ÅŸ×?	‹_Ÿgdî
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/objects/19/cf368342249b8579345241709e3772540ca220 btrfs-tools-0.19+20120328/.git/objects/19/cf368342249b8579345241709e3772540ca220
--- btrfs-tools-0.19+20111121/.git/objects/19/cf368342249b8579345241709e3772540ca220	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/19/cf368342249b8579345241709e3772540ca220	2012-05-05 18:19:50.000000000 +0000
@@ -0,0 +1,4 @@
+x
�PËN1䜯ð�[m�ì#BHœ9qàœ‡Ó
ÝÄÕ&U_OÚ/@œ,Ïx<;N)VP8<Ô�T@I^j§ý^šAMSУ(H;ŽÓ0joqf'Îf£\�gœH[ÛÆÔ z/ÑÔ¥ÅQÏšä¬t�Â\ê¼-[,ðn
+gxv·f—nÍ+oÆ­´sœ^`/%NZö8C׫¾
mWVú¯^¤S(HæDЭ`²‡.·f�¦@h‡‘qp]hâ“Às~¬�^ù
+>†@÷´+™pWgövew*ñ‡Êuiɾ.¥Þ}
+´]P¯|®‘s�DÍð“³Ä|â#3ùŽCèì÷áOï¿.mŒ

\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1a/7b172f918260f36bc14a86c26ed490e5a29c1e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1a/7b172f918260f36bc14a86c26ed490e5a29c1e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1a/b2e5bc535a20680b75f11c931bec795fb6b2f6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1a/b2e5bc535a20680b75f11c931bec795fb6b2f6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1a/d20fd35b2c354409a6ffd79220ede3c1bbdc4e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1a/d20fd35b2c354409a6ffd79220ede3c1bbdc4e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1b/c67199f0e6d224c272885b4e3dc4cd31024bca and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1b/c67199f0e6d224c272885b4e3dc4cd31024bca differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1c/3740cf06a974fba180f5202b455baa9bb5e5f0 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1c/3740cf06a974fba180f5202b455baa9bb5e5f0 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1d/004a8d5cde391213a16cad9c70dd22e99ddd7e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1d/004a8d5cde391213a16cad9c70dd22e99ddd7e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1f/139924746303df4561c6e771196667c782a5f6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1f/139924746303df4561c6e771196667c782a5f6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1f/53d1cfcd7ec110c1e25b532dacb2e2eee617d9 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1f/53d1cfcd7ec110c1e25b532dacb2e2eee617d9 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/1f/9f7bf40f5a4b7f41e62fcd9056627c0861b7d4 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/1f/9f7bf40f5a4b7f41e62fcd9056627c0861b7d4 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/20/85ae1e97a259612cade73cc5e672845867ff9c and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/20/85ae1e97a259612cade73cc5e672845867ff9c differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/20/cdffa8b1b6294bbaad5effadac1f779bf185db and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/20/cdffa8b1b6294bbaad5effadac1f779bf185db differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/22/5e8d31722f8696b587994f766fd53af0ee82d1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/22/5e8d31722f8696b587994f766fd53af0ee82d1 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/24/9c895668c8771cc9a08ece870f221d8cdc1328 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/24/9c895668c8771cc9a08ece870f221d8cdc1328 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/25/889d9d37f26e4c796c2955032a2dfbe645e47d and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/25/889d9d37f26e4c796c2955032a2dfbe645e47d differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/28/2c868ccbe47a2623c146bcf1531f5e1ab219c6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/28/2c868ccbe47a2623c146bcf1531f5e1ab219c6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/29/ed330112e8ff5c5d1f1aeba78333e7305291aa and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/29/ed330112e8ff5c5d1f1aeba78333e7305291aa differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/2d/86b1e7b544a56aa39bc50e42aaf51371a598bd and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/2d/86b1e7b544a56aa39bc50e42aaf51371a598bd differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/2d/e1b8bff3131df55fe27cab961c54bc21163044 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/2d/e1b8bff3131df55fe27cab961c54bc21163044 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/2e/607d2cc4c6d15eef50d8d9f614b4f9513c27c6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/2e/607d2cc4c6d15eef50d8d9f614b4f9513c27c6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/2f/0228f7a50ef0fa1edaa696fb99b5868f0f6a34 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/2f/0228f7a50ef0fa1edaa696fb99b5868f0f6a34 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/31/8fa0abeda9d6f9e6f3e169a3354da7eb68cacd and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/31/8fa0abeda9d6f9e6f3e169a3354da7eb68cacd differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/32/eff71182a6aff67324357572308c225b2d5e34 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/32/eff71182a6aff67324357572308c225b2d5e34 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/34/7c41789dda9674f1113d61f71a7392cc6f6a4d btrfs-tools-0.19+20120328/.git/objects/34/7c41789dda9674f1113d61f71a7392cc6f6a4d
--- btrfs-tools-0.19+20111121/.git/objects/34/7c41789dda9674f1113d61f71a7392cc6f6a4d	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/34/7c41789dda9674f1113d61f71a7392cc6f6a4d	2012-05-05 18:47:53.000000000 +0000
@@ -0,0 +1,3 @@
+x
…’QoÓ0Çy�?ÅijJêÔNºUËÖ©ÝÒ¤Áã	Šª4µ©…G¶Hlß}ç&Õ
+<�—ÜýïçŸ/Yk³†)㯭ß[ÀÍÖ*ïKgj¸¬B’îB27¶¬´H+³»"o…«¬j¼2u
­ÍO¨t¹Ú¥„l””@?”­m`í­tÔƒcÕ·ñî»tiu¬÷¡”ËÇö(c윲œòSày‘Mž¥ìð@Â8c$I’ãþ~lß:¡|
++Nó¿[q4™Ï�fç“Ñ’ð:œ/½ª =›@SZ'V�5RiWÛÒÂ7$@¦Nêlû5ô&U7­GãoB#U{Pö�5Ì°Ûbw.,…¢„8¯àúÓÇw«ûÅõíýêáîóí§Îœe#žA’3þèÿ¢(úgdÀ‰Ä/åc>ñrJc!VHÇ.@Á% 
IΧÑpüE}…Ùã
<>â÷Ç›¤årл#ÙX¼¸Œ�ßkGp¢ê¥V›îo�×nYŸŒºn$Àù/8˜ž'ä²Â·¶ûÚ´Í˾°Dž
raÎ*
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/objects/34/c0fea109b6c4827cb8568ac35a54c66be97a5c btrfs-tools-0.19+20120328/.git/objects/34/c0fea109b6c4827cb8568ac35a54c66be97a5c
--- btrfs-tools-0.19+20111121/.git/objects/34/c0fea109b6c4827cb8568ac35a54c66be97a5c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/34/c0fea109b6c4827cb8568ac35a54c66be97a5c	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1,2 @@
+x
•PËNÄ0㜯˜h•GÓfW!qæ?0ÉLiµmS¥©x|=©v%8ÂÑž±e;Äy34ÒÝåÄÙ[ÝzBO¬¼D¨{vŒäê“D±bâ%C§tІ�cêÈß²D2Êt®Ñ(õ‰)X´Z
+Üó<
iÜà·¸À}8@=à1&×!ΠŒvÖ´Mc¡’VJQØ’2ó?ô­Ò�S7½ð9õ[bJûš+?Åp9AÅ×<–49Âíy`à�|ôK\Hâu(±ßÇi‚/NâžáTñjs¬xUmЗÆ?fµ/ãÛÂTž¯üçùOkˆo2–ŠÄ
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/36/15c42febac6822dc7cb49ebd900abb1addbb05 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/36/15c42febac6822dc7cb49ebd900abb1addbb05 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/37/5713f202d7c1fd415c07091606660e9e784c73 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/37/5713f202d7c1fd415c07091606660e9e784c73 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/38/a742693f76aee89976a7526bdd2ea185329a35 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/38/a742693f76aee89976a7526bdd2ea185329a35 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/38/e6307b0a902ce9c77d641dff468ac8a9968e81 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/38/e6307b0a902ce9c77d641dff468ac8a9968e81 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/39/0b703329ce3e63980865b2b04e44acc59f87a0 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/39/0b703329ce3e63980865b2b04e44acc59f87a0 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/3b/0b276c6403353e8cc2b3a61c60d827f80675b3 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/3b/0b276c6403353e8cc2b3a61c60d827f80675b3 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/3b/887e1806d5217318e5a17260d7c2f4fb168ad6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/3b/887e1806d5217318e5a17260d7c2f4fb168ad6 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/3d/0dcb9065bd814b56cc9764ca679e5ca1ec5f9b btrfs-tools-0.19+20120328/.git/objects/3d/0dcb9065bd814b56cc9764ca679e5ca1ec5f9b
--- btrfs-tools-0.19+20111121/.git/objects/3d/0dcb9065bd814b56cc9764ca679e5ca1ec5f9b	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/3d/0dcb9065bd814b56cc9764ca679e5ca1ec5f9b	2012-02-25 00:44:16.000000000 +0000
@@ -0,0 +1,3 @@
+x
�“ÑkÛ0Æ÷Zÿô¥
në¤ëÆÈ“’6Ð&Áv(y2²}®E)Èrº0ö¿ï”t)efH�twŸ÷�\(S E7_®z
z™ÍÎÊçÆáltŽAÔ`nE©èˆ•Â>ÖÂRKvKÕ%×ø²¬‘-6Ö<[±/kK„ÖÔîUXbg:”BsY%[geÑ9‚tºº2Ö¬M%ë�?ëtE®!8²ë¦ÞoîfKÜ‘&+]¡déËdIº%làÏÛ†*»}ÑÄc¤o˜ÖNýö;]©÷�Ù0I#œg{•lAAèZª;znOÓì~¾ÌÏVxŠ“$že«!'»Æp”¶t�’ë�’ÇžX¡ÝŽ[ó
+�ãdtÏ%ñíôaš­`,&Ól6NSLæ	b,â$›Ž–q‚Å2YÌÓ1#åμIì‹ùhÍÑ—šÅÖÆ*rBªöoã+HËtªB#¶Äƒ)Iò<!Pò
ø?Ó…2úyß&“¼ÏYCâÕJž³3ÔC~6ŽS]^†¸ù�ŒØ$ÂB‰’p�´ó
+××ÑÞë[Ó:£C<ƈý~?ºè_GßC,ÓØ7v§²æëS#Ïo³d’æÉxO“<NùTjú7ð}ìJ‡ÂÙºÍKcm·qy¡Lù‚_ÁÉ[´eC9ýt¤ßdÞ�±CåíÀ?>–œ¢xèjü�ßRDU_p�ÊÙwc«³Œ!umÐóÿapÂøù�ãßÖ«¥m]ÎË÷¤îÛWN–Í÷KEìÖ‘çœiNIó‡ü
õÞHÔ
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/3d/4155ce21b643b2f531210bb8f196a21b11e9a1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/3d/4155ce21b643b2f531210bb8f196a21b11e9a1 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/3e/5b13bfb5011687da4283c02117af789c13b8fc btrfs-tools-0.19+20120328/.git/objects/3e/5b13bfb5011687da4283c02117af789c13b8fc
--- btrfs-tools-0.19+20111121/.git/objects/3e/5b13bfb5011687da4283c02117af789c13b8fc	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/3e/5b13bfb5011687da4283c02117af789c13b8fc	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1 @@
+x
�ŽKNÄ0DYû}�Œü�;!$Ö¬àm»ÍXŒmäxÜžäˆå+U•^ìµ–	FâÃÌ€Ê騬“a�1ØÀ¨mö*èmÓH>e4Á[Râ›·	Yª´ƈž‘(Ùͪ•�×›T“Y¡5–Ýçµx½Ž²Ãí½ÁS<áROxéƒâ�/±×gPF£wNI	‹tRŠ#=,'ÿw/>î£AÏö^Î;ji‡Ò•/ÎåÆB¼—ÏÆi9ZKøyü“©øXƒcò
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/3f/b47212ae733bd40f9aa62a73d2c2c9adcf4b11 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/3f/b47212ae733bd40f9aa62a73d2c2c9adcf4b11 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/40/9e54586508d5bc4809dba26e6233c06a306435 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/40/9e54586508d5bc4809dba26e6233c06a306435 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/43/04b2798a932cd004d48f4a35a936d91aa08fcd and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/43/04b2798a932cd004d48f4a35a936d91aa08fcd differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/43/bf4f0075db78ee1170fb9f96cefaf591b38ddf and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/43/bf4f0075db78ee1170fb9f96cefaf591b38ddf differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/47/b104b7f17b37813244691829daf4302831acf1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/47/b104b7f17b37813244691829daf4302831acf1 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/49/4ba8b580bd28a1990f73e8f434ddbb4f1b5cd1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/49/4ba8b580bd28a1990f73e8f434ddbb4f1b5cd1 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/4c/0a1cb4d1ea85d68680983939b0e1e3cae4886f and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/4c/0a1cb4d1ea85d68680983939b0e1e3cae4886f differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/4e/85b51970b226193960ea192ca51c04abb9d3f6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/4e/85b51970b226193960ea192ca51c04abb9d3f6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/4f/23ed39c9d13a5477f9635ef3b667569db21f8c and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/4f/23ed39c9d13a5477f9635ef3b667569db21f8c differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/4f/268331932819fb5e002e4a88449de6f76bb0b2 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/4f/268331932819fb5e002e4a88449de6f76bb0b2 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/4f/3a15d09a4172f7c82ad943a944d86328fa504c btrfs-tools-0.19+20120328/.git/objects/4f/3a15d09a4172f7c82ad943a944d86328fa504c
--- btrfs-tools-0.19+20111121/.git/objects/4f/3a15d09a4172f7c82ad943a944d86328fa504c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/4f/3a15d09a4172f7c82ad943a944d86328fa504c	2012-02-07 07:36:06.000000000 +0000
@@ -0,0 +1 @@
+x
��AKÄ0„=çW¼»t‰yIÓ,"*^<û^’—n`Ó”4+ôß[ñ*Þ†f˜™PKÉP�w½1:é­DT.0òˆn’Óh¼òR³Ö‚qi²$ÅJ�—q´FN†F›<¡2Á4Ñ'ôŠƒÑ�NÖj%èÖ/µÁûu'xk{-õsüQÏs¡|=…Zžà
Õ¤œ±ÚÁ½TRŠƒ;ÿË,^{KÛ°¶:og ¡ñÖ[^�¸Sä¶	ñòZ"ÜÖH�amyéÃ÷A§ ÄGžŽCMiðûùïIâ[Írc
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/4f/5d2513e7b25abb16ec709abf770c368cc75a40 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/4f/5d2513e7b25abb16ec709abf770c368cc75a40 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/51/089baee759f7733870342bb8de88e503aa04a6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/51/089baee759f7733870342bb8de88e503aa04a6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/51/32f1e7473617c69253eae768dce5c05ae7cdad and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/51/32f1e7473617c69253eae768dce5c05ae7cdad differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/53/090591e29a10345fd12b5ca7b30e1b9a31350f and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/53/090591e29a10345fd12b5ca7b30e1b9a31350f differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/53/e9b17a4c23f269bc78b5d7b491edd41706d2c1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/53/e9b17a4c23f269bc78b5d7b491edd41706d2c1 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/54/4ab2ff701e6844b23161b81922a26a4184c047 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/54/4ab2ff701e6844b23161b81922a26a4184c047 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/54/cf17b2633df5c08f1f776354080801f4b0e7d7 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/54/cf17b2633df5c08f1f776354080801f4b0e7d7 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/58/178e8a1e44fcaa8a2f314cb7780d663e544afc and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/58/178e8a1e44fcaa8a2f314cb7780d663e544afc differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/58/8f0ccb78ad29c7b24bd7eaec0a039abded2150 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/58/8f0ccb78ad29c7b24bd7eaec0a039abded2150 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/58/aec02ba016500e56344ce8a7d491166ffb926a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/58/aec02ba016500e56344ce8a7d491166ffb926a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/59/9a3e778abb86e36808d4cfbd297f53e0581f6b and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/59/9a3e778abb86e36808d4cfbd297f53e0581f6b differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/59/e7cb486c5b8d09ab81247e33a56d0c09bac3b9 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/59/e7cb486c5b8d09ab81247e33a56d0c09bac3b9 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5a/0fcc60b37438b8de05275e33b3f8fded040b40 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5a/0fcc60b37438b8de05275e33b3f8fded040b40 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5a/d701c8374888dcbc8ad4d5dc7205bcc37bc16a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5a/d701c8374888dcbc8ad4d5dc7205bcc37bc16a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5c/4057e698a1594f89710343ae3f60e45910c551 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5c/4057e698a1594f89710343ae3f60e45910c551 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5d/024c25006a1e47dc10bbadabaf38bbb0f2afed and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5d/024c25006a1e47dc10bbadabaf38bbb0f2afed differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5d/05ea71db0214bbcfebead98942a7bf1937ba3e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5d/05ea71db0214bbcfebead98942a7bf1937ba3e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5e/770d284e2927b1ba28ba46ff3d648ae35a7334 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5e/770d284e2927b1ba28ba46ff3d648ae35a7334 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/5f/76be27fa2f20ffc3c745457e5dda8bac08e550 btrfs-tools-0.19+20120328/.git/objects/5f/76be27fa2f20ffc3c745457e5dda8bac08e550
--- btrfs-tools-0.19+20111121/.git/objects/5f/76be27fa2f20ffc3c745457e5dda8bac08e550	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/5f/76be27fa2f20ffc3c745457e5dda8bac08e550	2012-05-05 18:47:53.000000000 +0000
@@ -0,0 +1 @@
+x
e�AO„0…½Ú_1a/,´(uÅÍ]ÃÑ‹&ž¡¨Ô–´%«ÿÞe]ÄfÒL¾7ïe2•2Ü°ôìaô�±쌒ÞJ
ß»¼•,udl»EOÂq+/�Π�ŸÂAñúX¼À^úZ%+ID¸Ø)ã„»‡Uºf”ÒË¡Z6
àçr´TÞ6{c”;$Ë6Ž�„÷Ÿk'Š0Æseé:O%˜0LR waÙõ:"?B’‚Â0œgœÒÝ”
eÙTäŸ;Ï
'ôŠAxøo!Ϭ¤æj¬lœ¯¥‰ºí‚.²€
×^M,œ™¿\ì|éÿŽ½°š›�a‚YpÀ½bÁjéz<­ ob�
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5f/889ea08ff6e02035f503228796e9ef45f7f411 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5f/889ea08ff6e02035f503228796e9ef45f7f411 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/5f/b2fda9ff4ebb1ba36b6568f5c432693859b466 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/5f/b2fda9ff4ebb1ba36b6568f5c432693859b466 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/5f/d54bc94b6cdf78706b0f078b4abee2cbae8651 btrfs-tools-0.19+20120328/.git/objects/5f/d54bc94b6cdf78706b0f078b4abee2cbae8651
--- btrfs-tools-0.19+20111121/.git/objects/5f/d54bc94b6cdf78706b0f078b4abee2cbae8651	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/5f/d54bc94b6cdf78706b0f078b4abee2cbae8651	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1,2 @@
+x
�NKjÃ0ìZ§xpЧ²”J!ë®z½ç'G$–Œ,CzûÊ7(ÝÌ0ÃÌ0T–%50Ú¼µÊèƒ&¤1 çÀh£Žc`bš”=K-‘‘ÔHJ¬¡rn =÷ü¨mÏZÃÊ(×Á¡vgFgßñ1àEØÛ½T¸ÝkÚà+l%ÕqZñYj 'Ÿ¨, Œö½Ûa�VJÑÝþ²ñû[�=.ÓðYè
s-û
+�¨ì¹¥<ô׃*¯!U!¾ÓœyJŒþ\þt\üëYl
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/60/6ebfca0847a8d6220486e06e8df978d59861b5 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/60/6ebfca0847a8d6220486e06e8df978d59861b5 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/60/eadd708202429de536f986c3b0fb8190a9f305 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/60/eadd708202429de536f986c3b0fb8190a9f305 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/62/a1575463fc771b1ef80932ba2fa5326a4c4cb5 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/62/a1575463fc771b1ef80932ba2fa5326a4c4cb5 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/62/b79931546bca1b95a4b23ecec8378c372b26f7 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/62/b79931546bca1b95a4b23ecec8378c372b26f7 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/63/70b8f894c5779bf6c57dd2a4e8fc45d1593e79 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/63/70b8f894c5779bf6c57dd2a4e8fc45d1593e79 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/65/45c50a8d65d520343b233fa22a0af2bde62dbb and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/65/45c50a8d65d520343b233fa22a0af2bde62dbb differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/66/8f7c30d48821a964628310cac427fb8b10c624 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/66/8f7c30d48821a964628310cac427fb8b10c624 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/68/182eabd957d2ff19cfed67cc58877c733867c7 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/68/182eabd957d2ff19cfed67cc58877c733867c7 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/68/8c060c343bce543f12620c4beb29665085f022 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/68/8c060c343bce543f12620c4beb29665085f022 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/68/ebd402b81cea90b29d05e390f23410d6159ff5 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/68/ebd402b81cea90b29d05e390f23410d6159ff5 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6a/39fb7cc653ca6dbfde485fb3c7c4e27d6c8616 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6a/39fb7cc653ca6dbfde485fb3c7c4e27d6c8616 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/6a/4903c8ad95a592a80a5b56ab53bd81ae9e1c56 btrfs-tools-0.19+20120328/.git/objects/6a/4903c8ad95a592a80a5b56ab53bd81ae9e1c56
--- btrfs-tools-0.19+20111121/.git/objects/6a/4903c8ad95a592a80a5b56ab53bd81ae9e1c56	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/6a/4903c8ad95a592a80a5b56ab53bd81ae9e1c56	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1 @@
+x
�ŽKj1³Ö)úcÔú�	Á�uV9�ÔjÙC¢‘‘äEnŸñ
Bv¯µZ·	ZâËìÌ€RGô1h¢”Âäu)%°Kl�2()xÇÙ‰{ì¼O`oƒLI­ÎT!ãJ…½Œèrñ¨S&²!-âcÞZ‡÷[ß|ÄÑvx¥'œê.­Gúæµú¨U°Jy»Â"­”âx�ÊÉÿõEš½ú:ýoGõh•�Ù®�ÇŸÛuç¼´R–ôsþS¢ø„b­
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6a/89671f0cc50187a0972eb484340cb8772eb17a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6a/89671f0cc50187a0972eb484340cb8772eb17a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6b/5316afe6fc5f84a4d6c7f82874ffa1cc6e85f6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6b/5316afe6fc5f84a4d6c7f82874ffa1cc6e85f6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6c/d813b6fc18ba75edfcfad5857d27f0265c2c28 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6c/d813b6fc18ba75edfcfad5857d27f0265c2c28 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6c/f565de5bcbafa8c3133a8b1d2843ab23123ebe and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6c/f565de5bcbafa8c3133a8b1d2843ab23123ebe differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6d/042931830f7cca221ebaa651c0f962e3ea4378 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6d/042931830f7cca221ebaa651c0f962e3ea4378 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6f/128696fba591b66541ba89eedd71305c146887 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6f/128696fba591b66541ba89eedd71305c146887 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/6f/fdac5e77017cd6d73dd79344eb37da8d1766d0 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/6f/fdac5e77017cd6d73dd79344eb37da8d1766d0 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/70/45d05c20350654b38aec53a7aa55a19fff065f and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/70/45d05c20350654b38aec53a7aa55a19fff065f differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/70/51e99c8b9b169f6c877f29ea0de4ea5afcef19 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/70/51e99c8b9b169f6c877f29ea0de4ea5afcef19 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/71/2c23e38ed7dbcb6e0ad3137842a029edc5a520 btrfs-tools-0.19+20120328/.git/objects/71/2c23e38ed7dbcb6e0ad3137842a029edc5a520
--- btrfs-tools-0.19+20111121/.git/objects/71/2c23e38ed7dbcb6e0ad3137842a029edc5a520	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/71/2c23e38ed7dbcb6e0ad3137842a029edc5a520	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1,2 @@
+x
��½N1„©ýÛQùo}E
+*JÀÞ]+Q¸s´çH<>¾W œÍèjËríàÓôÔUjÁ¹„ìÐ¥#Šu6SÌŒS¹f\£óGsÏ*k‡2�(Ïú‰J`[¢”„âÈ–`kò<›üè—¦ðqÑë_yk+œh‡eoM3ýÈ�ÚrÆVHÑx±h­î ìòß¾)]ëF·Wà¶>wxÿþ„
@Mõqï ¿}£2,Þ̘ZV:
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/71/de078cf7975a24f57f2fd2c6a04d66e01cc643 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/71/de078cf7975a24f57f2fd2c6a04d66e01cc643 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/74/7bdd0eef25be9613e5837a7a7ab13ee48c2707 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/74/7bdd0eef25be9613e5837a7a7ab13ee48c2707 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/75/69d55193c0a219c1629591d9292c6e15d83827 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/75/69d55193c0a219c1629591d9292c6e15d83827 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/76/f725a961cc7474b9349c0b45b74ef14ba2812f and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/76/f725a961cc7474b9349c0b45b74ef14ba2812f differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/77/a8a66f2ed9dfb3a2e5a9b90896b9cbf392d675 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/77/a8a66f2ed9dfb3a2e5a9b90896b9cbf392d675 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/78/70cdcb077193cc20982dbf43279575d4f839d0 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/78/70cdcb077193cc20982dbf43279575d4f839d0 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/79/818e6998e710f6537bcc8bb5ca05cb5b3a51c2 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/79/818e6998e710f6537bcc8bb5ca05cb5b3a51c2 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/7a/ac736a4c617a4c7f46ee65858879da893fd2ac and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/7a/ac736a4c617a4c7f46ee65858879da893fd2ac differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/7c/ff30bd9561dc7c4633bc1aa06c4c5ab81a14fb and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/7c/ff30bd9561dc7c4633bc1aa06c4c5ab81a14fb differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/7e/cac5dde7f840ea6a9fcc2eca21afc9951e9304 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/7e/cac5dde7f840ea6a9fcc2eca21afc9951e9304 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/7f/8f011eb73d6043d2e6db9d2c101195ae2801f2 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/7f/8f011eb73d6043d2e6db9d2c101195ae2801f2 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/81/0e5247489a6d3210c7ecabcbbe3d6d8dc0338a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/81/0e5247489a6d3210c7ecabcbbe3d6d8dc0338a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/81/52c1450b6ccb4be824f71b29928a7df83b74a1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/81/52c1450b6ccb4be824f71b29928a7df83b74a1 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/81/9507cd9b2364dade60a04c108fec3bc864c4ad and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/81/9507cd9b2364dade60a04c108fec3bc864c4ad differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/81/eefb9db37572dd1d47c34e9506e1b70364308c and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/81/eefb9db37572dd1d47c34e9506e1b70364308c differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/82/8ca0c7fc98d518b54b18bccf972b94974c9073 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/82/8ca0c7fc98d518b54b18bccf972b94974c9073 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/83/4be475c13c8b19aaf3078be3d4a6091cade2ef and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/83/4be475c13c8b19aaf3078be3d4a6091cade2ef differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/83/58341fdcc0504f16ac9fbc7ac63c095c5eb187 btrfs-tools-0.19+20120328/.git/objects/83/58341fdcc0504f16ac9fbc7ac63c095c5eb187
--- btrfs-tools-0.19+20111121/.git/objects/83/58341fdcc0504f16ac9fbc7ac63c095c5eb187	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/83/58341fdcc0504f16ac9fbc7ac63c095c5eb187	2012-02-07 07:36:06.000000000 +0000
@@ -0,0 +1 @@
+x
�OIjÄ0ÌÙ¯èÛœf¬]r!�ó<¢ÕjÙ†ÈdM ¿�}Èr)¨¢Šj)k­åKoÌRVÄnÑ:—µ6„’'?%Q°Ôd´
rx`ã­Ç>g¥8¬ó¨%¥NR Ì�OþÏŸœ·"Xt>GÔÊ’'mSÌ:*&kŽn“½7jÀg_jƒÏ¥­;Üq¯¼ÑInå$µ!}ñ�jy©U0Ö#á*¬á¯:ÿ7?ܹÍ±áF\Ž¯;·ÔóÚ_ÇñÀåÏñqMí§–ú=ÆÞò~}´:ïÃ/Úßj
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/88/0941c193093ab3691a0baebc36858c3becd455 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/88/0941c193093ab3691a0baebc36858c3becd455 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/88/0f357d733774fdb230140c2e0920775ef7b623 btrfs-tools-0.19+20120328/.git/objects/88/0f357d733774fdb230140c2e0920775ef7b623
--- btrfs-tools-0.19+20111121/.git/objects/88/0f357d733774fdb230140c2e0920775ef7b623	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/88/0f357d733774fdb230140c2e0920775ef7b623	2012-05-05 18:47:52.000000000 +0000
@@ -0,0 +1,2 @@
+x
}RMoÔ0åì_1ÇV�즥ˆ�Úª´©H•Áy’L’Ñú#²ÇlÃ�ßÎ$E ^°ìƒíyoÞ›™Æ†.vÛW�Øp ‰}*$›Š®Ì>äؾ|7ß(&¾†mYí^Ÿm+]gUqž›ì%W¿¦	+ó!¶#µ’£ÂÑuïÞš/È^ôP¬á=“…[̽‡Ën½ßXN’ÊŽF_¸¿ñ©q¸6Ÿ}´–ºbÏ?•öb÷þÜÜÓD¾K/´ÃÉÕÿÔ�š½*[=hª<˜ÇÈ!²Ì5ГD4Ÿ‚£i-È(2Õ›ÍZ—òÈ.=ÙEÐFs§6òôLu7R{HÙ9öÜ…i†àá»Ò|dKiNB²°eaJp²æ>5p»8
‚§#´ ÇÚÿƒö!ÂûüÈŽ:@
v“%G^4§
ì~ oõ§'\
+Ÿà8*úÐæ´¨RA=f+ ÁR\bß@T§
}„i^XÔ�ö!ââ«4 ûë¨ò¦ç)Q�kÈH°šò4»Fç¦4¿
÷˜Ñ
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/88/238d6db94b8d378e939396231bcc1ac5fc5502 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/88/238d6db94b8d378e939396231bcc1ac5fc5502 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/88/8b7005ca03316ac930ad762fa86b04d9f28a5a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/88/8b7005ca03316ac930ad762fa86b04d9f28a5a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/8b/4e3d8b5b9e3cb65b244fec55d93608d1a1e319 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/8b/4e3d8b5b9e3cb65b244fec55d93608d1a1e319 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/8b/b16c37b139deb1feba14fdd852e6556ff78fff and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/8b/b16c37b139deb1feba14fdd852e6556ff78fff differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/8d/ca5e10a12b1c1273cd1d3f8c345a0298f416ba and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/8d/ca5e10a12b1c1273cd1d3f8c345a0298f416ba differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/8d/f2ce690eba566f334ca1e979da0b0e13c43581 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/8d/f2ce690eba566f334ca1e979da0b0e13c43581 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/8f/01235dd8cf65c064f1b979d24a989ca296ea33 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/8f/01235dd8cf65c064f1b979d24a989ca296ea33 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/8f/572effb7f4c8e3cbceeb71441f90fc9abe2625 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/8f/572effb7f4c8e3cbceeb71441f90fc9abe2625 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/93/1506c838e8ae956d5088de1448a9d14a44ba77 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/93/1506c838e8ae956d5088de1448a9d14a44ba77 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/93/2bdf26d8a406664e91a4aed0e962dd8eecd810 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/93/2bdf26d8a406664e91a4aed0e962dd8eecd810 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/95/0fa8f0ff882a98e93a7c30a54cb94b93b101fc and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/95/0fa8f0ff882a98e93a7c30a54cb94b93b101fc differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/95/7c640525f493e03640f136860570dee022cdab and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/95/7c640525f493e03640f136860570dee022cdab differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/96/b2b681e1d414ce239e73aec5da5bab84bcbe1d and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/96/b2b681e1d414ce239e73aec5da5bab84bcbe1d differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/96/e829564522e0ffe24a847f0fe232e6109c2018 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/96/e829564522e0ffe24a847f0fe232e6109c2018 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/98/0a006d26aa5ba992ac801e2d47e1d7892995aa and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/98/0a006d26aa5ba992ac801e2d47e1d7892995aa differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/98/118a8be90dc8dcba7a2129fd618d5793e6ab30 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/98/118a8be90dc8dcba7a2129fd618d5793e6ab30 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/99/8a605d752543d50dfb10ba2806995dbabdb909 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/99/8a605d752543d50dfb10ba2806995dbabdb909 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/99/90338b4c700c3f4121948bba32a1352abeac75 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/99/90338b4c700c3f4121948bba32a1352abeac75 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/9a/8cc3818e95a75c34e2b7efbd4b9a7462d450be and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/9a/8cc3818e95a75c34e2b7efbd4b9a7462d450be differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/9a/d3e051b545b9782fbdc7a03d54afbf615ab418 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/9a/d3e051b545b9782fbdc7a03d54afbf615ab418 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/9a/de7b95de52c9c369d40e5033ad7b8ef6b292b2 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/9a/de7b95de52c9c369d40e5033ad7b8ef6b292b2 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/9f/c448cb77aa6abef5fd5ca003c646baa8b12e4c and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/9f/c448cb77aa6abef5fd5ca003c646baa8b12e4c differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/9f/f6182efcf1c43d8d582452ea13ddd1710dda7c and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/9f/f6182efcf1c43d8d582452ea13ddd1710dda7c differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a2/efb9383f5058359a62a9a931f1c8d742306afd and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a2/efb9383f5058359a62a9a931f1c8d742306afd differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a3/03a50d280684fac46b3f9f2f4202930af054ff and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a3/03a50d280684fac46b3f9f2f4202930af054ff differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a3/3b422ffd5e2b3f53477a00b36e193933fe4b07 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a3/3b422ffd5e2b3f53477a00b36e193933fe4b07 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a3/facae60d6b292d211046ee8f6dbc01dd1cc2a3 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a3/facae60d6b292d211046ee8f6dbc01dd1cc2a3 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/a4/6e7ff22ed8e0e8567a36cd226a910a1fab47d7 btrfs-tools-0.19+20120328/.git/objects/a4/6e7ff22ed8e0e8567a36cd226a910a1fab47d7
--- btrfs-tools-0.19+20111121/.git/objects/a4/6e7ff22ed8e0e8567a36cd226a910a1fab47d7	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/a4/6e7ff22ed8e0e8567a36cd226a910a1fab47d7	2012-02-07 07:36:06.000000000 +0000
@@ -0,0 +1,3 @@
+x
�’ÝjÜ0…{­§r“‹fÿÄko(¥´iB ôfŸ@’Gö°²d$Ù[¿}G›¤½,Œ0öÌœs¾‘öÓD	Úcõ!Dè”*ºnUY{T¥A%Ë{Ó÷]Sá¡iÆ´�1FÌ2 KÐ7m}�]W·…Ò­2ØÕxìëZLSêcÑÈΨc‰B.iô
^ì&á1l~ò+|¢þõíË0I²{í§ÏPÖUÝ–UW5𱨊BðW¶˜ð¿šÅ×LÜÍÁñ
ô(Ý€�F„‹Ü`:›3és„ ©®2d1
+ñm	9ž}«!
ãì]äf/\[÷*φ]í.èq-óQ	A.&”=x	­%7ÀÍæÐÒÝ25Ïdº
P&Œ áôòóùÇwðÒÅç!¤1Þ	éx†c�a¥Ó˜G@
+ÒEãü¼ä¯Š=À3:ÒÚí.ÿp¸2µ‹.Š%b`å–GM‘8M.šä9`J·œO ù±¼ZÉ/.#éñŽà–Wd—Ý^ˆ'úÅa(‚Ú˜/êsΚ	»eR,ÏÐÔ‰V|Ïu•8û�rµ’ú,ˆIqWœÙœ!ü³
àÑ4Í>FR6ãƒÆiýÕî+Dx:
9¡%ïˆÜ*íß…2‚ëg¿'ö;oÌNmÿ¾�â7<F(
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a4/9bce48e3d5273531d4bdf622a39307b4ddf52b and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a4/9bce48e3d5273531d4bdf622a39307b4ddf52b differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a5/6bb4bf868c8312ddfd4a22101370852a47ab00 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a5/6bb4bf868c8312ddfd4a22101370852a47ab00 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a5/dbbee1dd59226bb8bf7211b0c392a92a5f4a86 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a5/dbbee1dd59226bb8bf7211b0c392a92a5f4a86 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a6/886a06cf625985b3f4e42b7de5a48947a92303 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a6/886a06cf625985b3f4e42b7de5a48947a92303 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/a7/bd547671b69ed65f217aa343dd1b4e996220a7 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/a7/bd547671b69ed65f217aa343dd1b4e996220a7 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/ab/66b122e72fb31243fb85691f4cf3a2470831a2 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/ab/66b122e72fb31243fb85691f4cf3a2470831a2 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/ab/aff50384ecdc1101e166cb163a1533c383c090 btrfs-tools-0.19+20120328/.git/objects/ab/aff50384ecdc1101e166cb163a1533c383c090
--- btrfs-tools-0.19+20111121/.git/objects/ab/aff50384ecdc1101e166cb163a1533c383c090	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/ab/aff50384ecdc1101e166cb163a1533c383c090	2012-05-05 18:47:52.000000000 +0000
@@ -0,0 +1,2 @@
+x
UPÁjÃ0ÝÙ_¡cÖP§M a+ÛZ;
+�íì8Z*êØÁ²Ýaß>7”A:HOzïI�q¬ªúî ôI
Ø@ü7çÁ9Ãyì±­‹^ßâ=“³
,¹¹/—2E)óUì¢
QþN“’âÅë#Ô!ú´®Æ¾^‹E6¤DßÀ^YB¯*ŽÊZxìçúÙ.’2)›�ÿó\8?lŻ堌Á>oé'Ñ®7•Øㄶçuºž]Ãbûe!«ìáÒ�‘zyÔ™h“µùˆ«]©½8xržÂ¹
7]F”I¬=ÍU»#êÇq$;ÀÎMgp¾ÒÂä3!2—Gfâû:|ˆ
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/ab/d3ebebc30de133ecc51d80b32908bd4a077b9a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/ab/d3ebebc30de133ecc51d80b32908bd4a077b9a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/ac/c6b13bcd39a3cf630462057a6e7a582cd269e8 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/ac/c6b13bcd39a3cf630462057a6e7a582cd269e8 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/ac/f9aeaeba27720d8c0352ae52f5fb70cbfa8195 btrfs-tools-0.19+20120328/.git/objects/ac/f9aeaeba27720d8c0352ae52f5fb70cbfa8195
--- btrfs-tools-0.19+20111121/.git/objects/ac/f9aeaeba27720d8c0352ae52f5fb70cbfa8195	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/ac/f9aeaeba27720d8c0352ae52f5fb70cbfa8195	2012-05-05 18:38:54.000000000 +0000
@@ -0,0 +1,4 @@
+x
�ϽjÄ0à´ÑS¨»"`ô³’¬Žƒt�Ô©¥õ®Ï9Û
+²áž>&�H3Õ7ƒeY¦&­Q­Iß÷¨¼B6#9°¬�7
+!S6Ñ{§zÇÊñ•*­Mf“¬�1¹ØŸñAtÐ
+£ <ùÏëè‚:d&N²'¦ÁÉ�Î`o‰† ÒÞ®¥Ê·RæM~Ló‘/y¿ß/ô]Ú„©+uìöÛYjk½
«M”OJ+%ð÷R£•Å;Õ‘d®iÅ«<-i;†NrZ[‘ŸegªB¼–•ç	Ûö,s«¼á­CñCkd®
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/objects/ae/1822f73f92adca8ccfac24bc0e6e440f776fa4 btrfs-tools-0.19+20120328/.git/objects/ae/1822f73f92adca8ccfac24bc0e6e440f776fa4
--- btrfs-tools-0.19+20111121/.git/objects/ae/1822f73f92adca8ccfac24bc0e6e440f776fa4	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/ae/1822f73f92adca8ccfac24bc0e6e440f776fa4	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1,4 @@
+x
��Mj1…»ö)t�ÿ%3J)tÝUs
Y#g†ùq°=$½}mZJ7…Ò•�Ðûôô(,Ë˜á »‡™Áxg­4rcŒë­ôâQcczMš:ìÉ[§”¸bä5ƒmœ’Ö5^5Î4­2ÚÚc§ZÝõè­‘º5
+É+�[B„—!Ž	^1…©6û¥6Ï!"ͼ§°<A¡´­<Ze`'RŠ2-.3ÿW/\Ž>Ñt‚'†´E†ƒï�7šàÃv$
+ÛšÇõýk‰|Å1
+qþ}³¼TXÜúj² ià‚¬p¾ç”CšDdÏ%6â´8EVý¤OCuùÇõoæ¶ÎœR�Š[Ã2 ›rø²öùCá|Úñ6^VîwÁû�{?ý)rñ
0_¬q
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/af/00db292e74b22c51cd95f1db5db2a594804d09 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/af/00db292e74b22c51cd95f1db5db2a594804d09 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/af/855baaf962e4e70321374a9fda285570002d83 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/af/855baaf962e4e70321374a9fda285570002d83 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/b2/1a87f827a6250da45f2fb6a1c3a6b651062243 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/b2/1a87f827a6250da45f2fb6a1c3a6b651062243 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/b2/a3699a59876a5ef665f41710c9344e17f46fdb and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/b2/a3699a59876a5ef665f41710c9344e17f46fdb differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/b6/b3be12de97de313b69cc75510a171a16ddf66f and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/b6/b3be12de97de313b69cc75510a171a16ddf66f differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/b7/ad5a84565285ccb3d0b4eb65e1c0b30f62d7cd btrfs-tools-0.19+20120328/.git/objects/b7/ad5a84565285ccb3d0b4eb65e1c0b30f62d7cd
--- btrfs-tools-0.19+20111121/.git/objects/b7/ad5a84565285ccb3d0b4eb65e1c0b30f62d7cd	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/b7/ad5a84565285ccb3d0b4eb65e1c0b30f62d7cd	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1,3 @@
+x
•�KOÅ …]ó+f©‹{C´`ŒÑ¸v¥û›)…¤€¡4Wÿ½46®u7¯sòÍÑ)_ ê¦d"0Ô7ÒØiÀI5Ji”覦ï;%ùhp°œ·­ÙfŠìï´Äz‡Bµ(9ŠITy•Ù )j´nÅ¥/.û^qMôÞœÃÞ<¥Œz¡³Náš®•¢mÇQ‰ÎY�VÊBÿÓK9zö¼,é
+ôY*óeÚ¬¥¼BI°­!e‚Œ�±wWÙ´Ã8Ó
+¶ÆqYS ßû[�ËBµƒâÁ• Ž’ÆR‹xø³ÿ»Ýß^
ÁùÙUz‡ÙÀâ÷ÄëÿÅÄ-Lu‘ì!†Žù¸Ã�{ós$sJÖž¦¯û?Ⱦ
�†š«
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/b8/a2cbc6ab8eaeb5f2f6aececd159020bebc16c1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/b8/a2cbc6ab8eaeb5f2f6aececd159020bebc16c1 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/bb/1279c6665f114a4d49688105358fa0c6d61566 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/bb/1279c6665f114a4d49688105358fa0c6d61566 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/bb/51c2126f2779bd9209a6397b2d78ba19b6e2f9 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/bb/51c2126f2779bd9209a6397b2d78ba19b6e2f9 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/bd/0965c935c4f5deeee25cb3259eae318c19dc5f and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/bd/0965c935c4f5deeee25cb3259eae318c19dc5f differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/bd/261d82575a8659d30dc1e97dc8e70049679a72 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/bd/261d82575a8659d30dc1e97dc8e70049679a72 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/be/34b0699a8706251f5b1a99a4044d44fa96d647 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/be/34b0699a8706251f5b1a99a4044d44fa96d647 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/be/4fdc3517270c3c17154b4cf8898383657d26b9 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/be/4fdc3517270c3c17154b4cf8898383657d26b9 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/c4/503f444fbcabc7eaece28468373ab2be894aae and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/c4/503f444fbcabc7eaece28468373ab2be894aae differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/c4/97892e7e77eb89c47c0b40b5fcef02f29523cf and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/c4/97892e7e77eb89c47c0b40b5fcef02f29523cf differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/c5/31ef25905bd7cc243a5533c0ca2e766c34df5b and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/c5/31ef25905bd7cc243a5533c0ca2e766c34df5b differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/c5/3f65a8dc18ede0698785b06c461e52df70316b and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/c5/3f65a8dc18ede0698785b06c461e52df70316b differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/c7/065a3f4660c103ee07b938dd06aacb8b520702 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/c7/065a3f4660c103ee07b938dd06aacb8b520702 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/c9/6c85974dc01a30b9b1022c637fd05ead29c2db and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/c9/6c85974dc01a30b9b1022c637fd05ead29c2db differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/ca/42d7f55bfe6435ea322073e61e4865d2e92d9d and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/ca/42d7f55bfe6435ea322073e61e4865d2e92d9d differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/cb/42df31fd5b8fb9dd1f31c0c26f21004ed543b0 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/cb/42df31fd5b8fb9dd1f31c0c26f21004ed543b0 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/cc/e486c3b073918d95720f8d79d8e4d7ccccd13e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/cc/e486c3b073918d95720f8d79d8e4d7ccccd13e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/cd/5f7f12ce36bdf1d763d34e2a96f8d2aa5cf1cb and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/cd/5f7f12ce36bdf1d763d34e2a96f8d2aa5cf1cb differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/cd/a2761443bc07ce5eb83048955ded84274ef271 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/cd/a2761443bc07ce5eb83048955ded84274ef271 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/ce/e725d761b6ea4aa9e4ab17f21f4651a394c9d1 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/ce/e725d761b6ea4aa9e4ab17f21f4651a394c9d1 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d0/1fcebeb5187569d2ac29ba8aa2518f76e4f2b0 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d0/1fcebeb5187569d2ac29ba8aa2518f76e4f2b0 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d1/41b461a0be3043bb5efacaf476e74c5fbe6c28 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d1/41b461a0be3043bb5efacaf476e74c5fbe6c28 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d3/827e75a5cadb9fe4a27e1cb9b6d192e7323120 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d3/827e75a5cadb9fe4a27e1cb9b6d192e7323120 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d3/c50adfd97422ecbab4c21ea73137130320f407 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d3/c50adfd97422ecbab4c21ea73137130320f407 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d3/c92749ab0c3e0339abde3486e7fb47d84f74da and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d3/c92749ab0c3e0339abde3486e7fb47d84f74da differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d3/f45bdfc9b8c8e117ae1a6f132c65a81cc8a615 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d3/f45bdfc9b8c8e117ae1a6f132c65a81cc8a615 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/d5/734e88370bc7bfe83e9d33b6f51c905a8fb91e btrfs-tools-0.19+20120328/.git/objects/d5/734e88370bc7bfe83e9d33b6f51c905a8fb91e
--- btrfs-tools-0.19+20111121/.git/objects/d5/734e88370bc7bfe83e9d33b6f51c905a8fb91e	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/d5/734e88370bc7bfe83e9d33b6f51c905a8fb91e	2012-02-07 07:36:06.000000000 +0000
@@ -0,0 +1,4 @@
+x
��MNÃ0…Yû³¡VŽ�ÔM…B°`Í
ÐÄ»VíLä8ˆÜ€ÄîéÍÏûô,§
+´�¼)™Pë¡Uʹ±#5h×éÖ”rÐjzÝkí¨¤3fš
+¸q8XÙJ¥µûƒ4Ö î›®“Ç#¡“Õn•é”Àµœ9Ã[Ü^òƉ?á!Œ¿êÉ'qo9=B£•6�:ªRT·"ú×±x.Ù-»9³_Nàj
+øŒ–Üã<
å\±\æ<Óôa¯5ÜÞ	ñú3°g²—0y"Ûx.PÉi„–‚šêúšy¹î¬„™Kí&`ùT%–P£®±ì…x~¢qÇÎí†íôw%â¬@‰¨
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d6/75085a67fba325c7c35dbf3b2ec544354f7742 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d6/75085a67fba325c7c35dbf3b2ec544354f7742 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d7/735d5d72940081b8459928128672187725a386 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d7/735d5d72940081b8459928128672187725a386 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d7/efe6e6c6600a9e284a16e5ceeb652dbbc542e6 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d7/efe6e6c6600a9e284a16e5ceeb652dbbc542e6 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d7/fcef660062a77dc36e77490994869d66d49019 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d7/fcef660062a77dc36e77490994869d66d49019 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/d8/ff58af10195e9e0864dd5c6deb14f7ac4de4ed and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/d8/ff58af10195e9e0864dd5c6deb14f7ac4de4ed differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/db/625a698ffe350db1ec45d18eb5a3b094b3004b and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/db/625a698ffe350db1ec45d18eb5a3b094b3004b differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/dc/2d2e819c9e7e4a5df78b033a81870dcee01ddb and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/dc/2d2e819c9e7e4a5df78b033a81870dcee01ddb differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/dd/593fe68dcf0b37ce2a7ebe5979f8c65943089a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/dd/593fe68dcf0b37ce2a7ebe5979f8c65943089a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/de/2c75cad43f231aeb61db165e967503aed6ab73 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/de/2c75cad43f231aeb61db165e967503aed6ab73 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/de/418dfb6abc59788d953b14439807da6f002257 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/de/418dfb6abc59788d953b14439807da6f002257 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/de/afda6af7784116640be1af68b0232da4dbba1e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/de/afda6af7784116640be1af68b0232da4dbba1e differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/e0/956c2a789d7d5a68687ee2a9e7b1049e379111 btrfs-tools-0.19+20120328/.git/objects/e0/956c2a789d7d5a68687ee2a9e7b1049e379111
--- btrfs-tools-0.19+20111121/.git/objects/e0/956c2a789d7d5a68687ee2a9e7b1049e379111	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/e0/956c2a789d7d5a68687ee2a9e7b1049e379111	2012-05-05 18:47:53.000000000 +0000
@@ -0,0 +1,2 @@
+x
e�½n1„ÓÞ<ÅâP„â0	%¢¤OhQ¼
+ØÄkÄ!tï£$UºOó£Ñô‡ÔÓËrñð8±½D«
P.Ô2ðºÝl7okc€SæÌ_ú4Ã

»�ÈLo?þh0®S¾kÏ£!‰h~34X‰)´¨°Z�µsÀœìYs]í2[‰RrwôÚ–”jCJŸ­?GW$EÄÓŽÚ�ÌþÄêKöº7ôŽ¸nºtº~ðÀî_Âjý/ø+WHm
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/objects/e1/3987bec02817f35b88ddb48027a46599aca90d btrfs-tools-0.19+20120328/.git/objects/e1/3987bec02817f35b88ddb48027a46599aca90d
--- btrfs-tools-0.19+20111121/.git/objects/e1/3987bec02817f35b88ddb48027a46599aca90d	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/e1/3987bec02817f35b88ddb48027a46599aca90d	2012-05-05 18:47:52.000000000 +0000
@@ -0,0 +1 @@
+x
�R[rà ìwNÑKdzkH‘¤·¯ ®Gùë«eW/X­Ÿ_×ëGØ—ïŽIvâ÷‹†®-žÊ†±W8™UUጚŒ€+ð8±4q)¬íÔœ¹60�ŸÊCäwW"$Š–„§ËœÀRÙ“Ä;-úîñ•¬"À:F1ÈÎ7°Ü:z¼Qe£ááŸÖ™©ÎY�V± 
3”nÒgÌsg‡8Sèïh¿~3¥*‰kd—�‚Ùn¹¸›Ë‡U>7*b7ˆ`y-víqãŸîçZÁ×Vã¹*3CM£Ro5‘w«a6ï)ëë·©Ûð©ÒÜ.t‡Z1À¢¦&ùóŒ4“ »´=á:Ý`Û¶>ÜF(Ú‹Tš¥s¸¶®Uôb~ÇCôüúÕ	tÒ_¦ç&`
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/e2/2827e9bb9634540d32bf29b23b26989e384902 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/e2/2827e9bb9634540d32bf29b23b26989e384902 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/e2/ff8cd9fc5d4aba5449ac6a2af4cef15b53839e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/e2/ff8cd9fc5d4aba5449ac6a2af4cef15b53839e differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/e5/981d1fe7871fae9a05c579085de3d9ada77c57 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/e5/981d1fe7871fae9a05c579085de3d9ada77c57 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/e6/404653971cf8dfa0ef8bb5157e97878ebd8125 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/e6/404653971cf8dfa0ef8bb5157e97878ebd8125 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/e6/8e22b45e6c37e5bd6a400ad897d4fc84708e96 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/e6/8e22b45e6c37e5bd6a400ad897d4fc84708e96 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/e6/fe926efc8fb7d08cb9bd4549a9d2b1303de76e and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/e6/fe926efc8fb7d08cb9bd4549a9d2b1303de76e differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/e7/580bb29644128d19cfe70a16df713bdcc58a43 btrfs-tools-0.19+20120328/.git/objects/e7/580bb29644128d19cfe70a16df713bdcc58a43
--- btrfs-tools-0.19+20111121/.git/objects/e7/580bb29644128d19cfe70a16df713bdcc58a43	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/e7/580bb29644128d19cfe70a16df713bdcc58a43	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1 @@
+x
�‘ÍNÃ0„9û)ö
H”:q~B $nœÊ½Úx×MDbW¶CÕ·Çi¥ª½!n^Ë3ó�W»y#¨Z>DÏRµmG•�‘5Wºéj-;¥ŠR¢$Ós])®ôl#ÔšÚMÙ×FoÚÅd´AR­jH6¦�µÒRËVàçá}ðc€Oγ^‡|^‡WçQOœk7¿À¦”mÕÔeÑBV¨¢é6QFþ¯^¼�;°Ýéµå΄Ýh�“ˆR‘8âÛó‹ „	ú,3ˆzì'^�« θgJŠG8£`f´á&à¢÷jÏqñ÷ú\ˆ¯!ýRʤ:Þ˜\)/íʲ„”|e±'@K€Ó$¼s1
!­~p)è£7!#î—}vÞpŠÓÚµ@²Iv0Æı÷–)sÆdýééO{¿½
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/objects/e8/9c970f597bd8a7984aad89245e158fb82f512e btrfs-tools-0.19+20120328/.git/objects/e8/9c970f597bd8a7984aad89245e158fb82f512e
--- btrfs-tools-0.19+20111121/.git/objects/e8/9c970f597bd8a7984aad89245e158fb82f512e	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/e8/9c970f597bd8a7984aad89245e158fb82f512e	2012-02-07 07:36:06.000000000 +0000
@@ -0,0 +1,2 @@
+x
�OËjÄ0ë9_1·=íÆ^;~”R
+=ïGŒÇã$ÐÄaâ-ôï›ú½$$$Q]–¹�1ö¥	3˜ÀÎ(ŸFu'Žä}vVçR¬H
ct�ƒî6^3cuÉDjP¶h‡K"�ä©8ÐÀIÿçw¥d<4ï•ö”]ö&g�µœŒÏ²öÎeÕá³MUàs’y‡îu…7:Ém9ÉG¤/¾Q]ÞA›{°ƒ
6ÂõX¡ºC=^5þo¾{°ŒIp¥	.Â{“yc¹@-0Îíµïœžéìïç,?u©ß}jRöë&uÜ»_!)k¨
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/eb/b35b28c44e98547adc2d61877686e8b29419fb and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/eb/b35b28c44e98547adc2d61877686e8b29419fb differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/ee/7fa1b877d2a3815d349aa465fa088bace7a0ab and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/ee/7fa1b877d2a3815d349aa465fa088bace7a0ab differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/ee/87f1f12c738168a5672b045f6b50569ccc0ff5 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/ee/87f1f12c738168a5672b045f6b50569ccc0ff5 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/ef/ca7c51b4d41d5cb69e4f5770f1231739b366bb btrfs-tools-0.19+20120328/.git/objects/ef/ca7c51b4d41d5cb69e4f5770f1231739b366bb
--- btrfs-tools-0.19+20111121/.git/objects/ef/ca7c51b4d41d5cb69e4f5770f1231739b366bb	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/ef/ca7c51b4d41d5cb69e4f5770f1231739b366bb	2012-02-07 07:36:07.000000000 +0000
@@ -0,0 +1,6 @@
+x
•TKoâ0ÞsÅ»(åU­ª§´*-RK	ª8EŽ=!–ÙNûëwœ…¢]-
½ÅÎÌçï1v®L£»ñøÛ w=HKé`kÍƲ
+è³°ˆàLáwÌâö¦Î4XÒy+óÚ#HL‹�±
 2Bû°Wk�|‰àÑVLÑ.žæ+xB�–)XÔ¹’<´½HŽÚ!4c`D ì»äû¶ih$05„ͼ4ºO½ÿ£}b'@ê¢4[bR2¸í¤R�#Ô‹ZE
‚¤Àû,}~[¥Ï×ð/—ñ<]O¨Ø—†þbƒ dµU’È‘'–i¿'i
áõqùðL-ñýìe–®ÁX˜ÎÒùc’Àôm	1,âe:{X½ÄKX¬–‹·ä±��²`ù@þ¶æׂÀ*cz&•;
+_S ŽØ)
%k�‚á(âÆ€›m`vÿ9œu4�)£7­L*>å?
Y€6>‚�•”³7
+4ž‹#‚™æý~ü„É$„…bá’: ÜÞ[¯ï�óFGðÃp<�†7£Ûá]«$ÂWW
+ÄÛÂe¼®ÏiKjÂdœ¸âuXhf7.^2½-šï“c•@…3Wç�QuÕÝÀ-²�†Nø¹½æ�eË6mÑãg¸R|»¬�
+ÝÞy¬:Q™ÙgªÜɆœ)¦y·zÇm�gÎ3ë;�ÿ¨õµë”ÖâZtÇ>³¡­¥Ç…£ê$a±2
^jƒ#Ô �üu�UíHeô<]`úŒf€ÕÊF±“Åæë-¢øÊôR‹LãmWxt±ô3ÅòC 磇U·2c3!í57ÚùÃÅ,4«ð4‘R›Ì›lË|Ùé…2É™
+õÔv¾ü7o$IY
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/objects/f0/1d6a8cc87e8aad49416e57290138d7bf18434a btrfs-tools-0.19+20120328/.git/objects/f0/1d6a8cc87e8aad49416e57290138d7bf18434a
--- btrfs-tools-0.19+20111121/.git/objects/f0/1d6a8cc87e8aad49416e57290138d7bf18434a	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/f0/1d6a8cc87e8aad49416e57290138d7bf18434a	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1,3 @@
+x
�OIjÄ0ÌÙ¯ÐmN·dµ–B çyD·Û0¶YÈïcò�\
+ª¨…
+e]—&ÆQ¿´š’ðÞ‘
Œê1"Ä̘”ã=F&ŽìÁwªiksDÍÁk6!fë,†Ö±&NI¦äÊ??8FÉÑŽRKÁE’NEãƒS–a8*,XßѳͥŠÏ¹.»¸Ñ^6ñNr]OòQ*…{º†²¾9*gQ£7¢èõxÕÒóÝ-Õ)	®´…Y\r©ýïöE”,¦¥½Ã�ó“Ïýa‰õ»¬åkàVóÞ?j™öîÁujè
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/f0/9945f5411cd02a9a6f7a0d9fd31f29ad55a8bb and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/f0/9945f5411cd02a9a6f7a0d9fd31f29ad55a8bb differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/f0/dd5270cf12e22a5ebdfa8aa86e5a8d7be9b4b9 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/f0/dd5270cf12e22a5ebdfa8aa86e5a8d7be9b4b9 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/f2/a655f0af30c7c7c871a72bc0fd9be64fc42600 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/f2/a655f0af30c7c7c871a72bc0fd9be64fc42600 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/f2/e5d8de628286748fb4acf590d201890768586a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/f2/e5d8de628286748fb4acf590d201890768586a differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/f4/766575001815e0219d0d0281c21f3ebcaf1df2 btrfs-tools-0.19+20120328/.git/objects/f4/766575001815e0219d0d0281c21f3ebcaf1df2
--- btrfs-tools-0.19+20111121/.git/objects/f4/766575001815e0219d0d0281c21f3ebcaf1df2	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/f4/766575001815e0219d0d0281c21f3ebcaf1df2	2012-02-07 07:36:06.000000000 +0000
@@ -0,0 +1,3 @@
+x
��½N1„©ýÛQ ‹ìûM¢…Ÿ†‚
+^`Ï^ç¬øì“íÝÛãB4Ðyfý�fWúq4	¾¹I�*U‹¦‘TŠ¾­«¾ÔM%JÁû~­Å¦ÅlAlÂ@.A«µBÙP×qÑIÕª®RªÛTuM}Õ)\+ѵ­âOið
ž†`"¼bôvr«q{PZZI?Þƒ¨ÊuÝ´MYBÁÎYvsËD
^ìŒðf?ú3ìŒúzí#ûîx)j¸ãe†Ùc
+:Sð‡¸�ÖB�òÉCÎŒ—É‚Ñíè#Ï-:I×�ÎÙ‘±÷!7÷ÎΗŒør…&‹ÆÁ™B4y1¯¿bÂ� ƒ§HjÅÜF<Rö Ðäó‡¥ÈµEt·	âiZüaoæàH^뢟·ÿºàoæÏ«±Ov«Ž
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/objects/f5/c4c4f3b75bde259640584761fc74a395056aad btrfs-tools-0.19+20120328/.git/objects/f5/c4c4f3b75bde259640584761fc74a395056aad
--- btrfs-tools-0.19+20111121/.git/objects/f5/c4c4f3b75bde259640584761fc74a395056aad	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/f5/c4c4f3b75bde259640584761fc74a395056aad	2012-02-19 07:43:57.000000000 +0000
@@ -0,0 +1 @@
+x
•�ÁNÄ0D9ç+ü­Ò¦IÛBHHÜ8Á8ŽK#Úx•fµ»O+ÁŽciÆ3�d]c�Î4%3C7ÙÐÚÆpï[‹Þ7Ž©×#ú©ï57õ;­Î˜90鉱ѣwÔ
mO~°n@2mGÎy{´¤ðRfÉð2ç¸Án’à‘Q¯‡x–Œ´pM²>AcÚÁéÑé*mµVûuoYø?~£MÓþø•/yÚèë�†"�Ù_â€o嘒™$‡M©�y¯ˆË&-—À»‚ÄW¨ªÌgŒ~â@Î%Jª
^÷iI®°£$LJÒr‡)Þ€s–¼í9Pfþ}„Ë"„‡æµRïñ3q¨dš*?ý	’ú2u�g
\ No newline at end of file
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/f6/733b5deba3e6dd807f8edbc3fbaa3855289260 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/f6/733b5deba3e6dd807f8edbc3fbaa3855289260 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/f7/4c66da5881f73912e92fda16b9be98503af1ae and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/f7/4c66da5881f73912e92fda16b9be98503af1ae differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/f9/70d5ca98f6a40da166cca8b40e53580cf1647a and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/f9/70d5ca98f6a40da166cca8b40e53580cf1647a differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/fa/7bf8c52ee98b6047ef0ff3536fb8ee559fd903 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/fa/7bf8c52ee98b6047ef0ff3536fb8ee559fd903 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/fa/d8d75272e4441990bf0d9d6f001578e27628ed and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/fa/d8d75272e4441990bf0d9d6f001578e27628ed differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/fb/58b3a151695e010332464ad57658fad3df4129 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/fb/58b3a151695e010332464ad57658fad3df4129 differ
Binary files /tmp/Jy4WuOqx6b/btrfs-tools-0.19+20111121/.git/objects/fc/134c08295056e7622a63bf4e4cd5ac52e4c2e4 and /tmp/H_TlOVbluE/btrfs-tools-0.19+20120328/.git/objects/fc/134c08295056e7622a63bf4e4cd5ac52e4c2e4 differ
diff -Nru btrfs-tools-0.19+20111121/.git/objects/fd/b6c0402337d9607c7a39155088eaf033742752 btrfs-tools-0.19+20120328/.git/objects/fd/b6c0402337d9607c7a39155088eaf033742752
--- btrfs-tools-0.19+20111121/.git/objects/fd/b6c0402337d9607c7a39155088eaf033742752	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/objects/fd/b6c0402337d9607c7a39155088eaf033742752	2011-12-27 02:37:51.000000000 +0000
@@ -0,0 +1,4 @@
+x
µTmkÛ0Þ×úWe°¶`ÇNl'ctƒ:6ÖíSWRE>ÅjdÉHr_þýNN²Ž2h;ØYÏùt÷HwÏqÓ¶ÒC–Ù+o¡³Y…,�	Qb:N'…(ÒÉx<›V%V(òBLEžeQÇ,jeÍòLŒÙ4O‹²Êóg³bRM§_V¹ÈÊj™‰lYF¬÷�±ðÞê>1­±¥Þ2ÂÇaÑè“ßAFɦÅtœf§EšF| èчÆJŸ™3t��´
˸„<ÿr>:ñV¸¸³fåæð
•áÌ#Īó�EVƒÔв5
+©0Š¾7”¢cž7 ä:ð
‚0J™[©W@):ò´–.sÛ Þ™j¸•¾‰VœÃ
Z'‰cž”I?–½öýèLjfÍÆWý`œΣáÈ›xñ—bËÀ{³&[´àmí8nû%}F{{<Ô�öµtëXÚYVË»xkÆ;OuÚ¡ÎÊ`�ùý£–6–[:b·—ÚÔ�@Ë:râ–OÆ<$#šCþm"Îxèlàb tcTßb Þ{©Âw¸[¬¤ó; Ø
*LßË:Ú^q§D¯¹/z5XÎ3ëßÌ£QcZ…î}µæ×Gk´Õh“`(úhŠÏ³I>žC¯kªµÆ,
+¤&æÞÀÕ¶œšÂã›—/Óÿ|š?üÚHýrÞùä9¼=“ú—àÏxñ
oN"CîÉ_…ÒøžêXCF�DŠ*î{�Îáèè.†_ÂÇAˆY.B�Òï
+Á±{ÒûþE’$—ƒŠ;Å8¶ah1b¦úŠ4ïäJK!9Ó>Ùg@¡w4¸êë?§…7+¤™@â'¹az×3¯ÎNOΣèœa!âåýüÉ�÷Øÿ9C.úyÙõ¦
\ No newline at end of file
diff -Nru btrfs-tools-0.19+20111121/.git/ORIG_HEAD btrfs-tools-0.19+20120328/.git/ORIG_HEAD
--- btrfs-tools-0.19+20111121/.git/ORIG_HEAD	2011-11-23 00:02:03.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/ORIG_HEAD	2012-05-05 18:53:48.000000000 +0000
@@ -1 +1 @@
-6da41f2a740569440e88539779cb94f169b1f1b6
+cee725d761b6ea4aa9e4ab17f21f4651a394c9d1
diff -Nru btrfs-tools-0.19+20111121/.git/refs/heads/joggler btrfs-tools-0.19+20120328/.git/refs/heads/joggler
--- btrfs-tools-0.19+20111121/.git/refs/heads/joggler	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/refs/heads/joggler	2012-05-05 18:51:39.000000000 +0000
@@ -0,0 +1 @@
+cee725d761b6ea4aa9e4ab17f21f4651a394c9d1
diff -Nru btrfs-tools-0.19+20111121/.git/refs/heads/master btrfs-tools-0.19+20120328/.git/refs/heads/master
--- btrfs-tools-0.19+20111121/.git/refs/heads/master	2011-11-22 23:55:20.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/refs/heads/master	2012-05-05 18:21:20.000000000 +0000
@@ -1 +1 @@
-6da41f2a740569440e88539779cb94f169b1f1b6
+1957076ab4fefa47b6efed3da541bc974c83eed7
diff -Nru btrfs-tools-0.19+20111121/.git/refs/remotes/origin/dangerdonteveruse btrfs-tools-0.19+20120328/.git/refs/remotes/origin/dangerdonteveruse
--- btrfs-tools-0.19+20111121/.git/refs/remotes/origin/dangerdonteveruse	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/refs/remotes/origin/dangerdonteveruse	2012-05-05 18:19:51.000000000 +0000
@@ -0,0 +1 @@
+1957076ab4fefa47b6efed3da541bc974c83eed7
diff -Nru btrfs-tools-0.19+20111121/.git/refs/remotes/origin/master btrfs-tools-0.19+20120328/.git/refs/remotes/origin/master
--- btrfs-tools-0.19+20111121/.git/refs/remotes/origin/master	2011-11-22 23:55:20.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/refs/remotes/origin/master	2012-05-05 18:19:51.000000000 +0000
@@ -1 +1 @@
-6da41f2a740569440e88539779cb94f169b1f1b6
+1957076ab4fefa47b6efed3da541bc974c83eed7
diff -Nru btrfs-tools-0.19+20111121/.git/refs/remotes/origin/parser btrfs-tools-0.19+20120328/.git/refs/remotes/origin/parser
--- btrfs-tools-0.19+20111121/.git/refs/remotes/origin/parser	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/.git/refs/remotes/origin/parser	2012-02-07 07:36:07.000000000 +0000
@@ -0,0 +1 @@
+6cd813b6fc18ba75edfcfad5857d27f0265c2c28
diff -Nru btrfs-tools-0.19+20111121/help.c btrfs-tools-0.19+20120328/help.c
--- btrfs-tools-0.19+20111121/help.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/help.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,214 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "commands.h"
+
+extern char argv0_buf[ARGV0_BUF_SIZE];
+
+#define USAGE_SHORT		1U
+#define USAGE_LONG		2U
+#define USAGE_OPTIONS		4U
+#define USAGE_LISTING		8U
+
+static int do_usage_one_command(const char * const *usagestr,
+				unsigned int flags, FILE *outf)
+{
+	int pad = 4;
+
+	if (!usagestr || !*usagestr)
+		return -1;
+
+	fprintf(outf, "%s%s\n", (flags & USAGE_LISTING) ? "    " : "usage: ",
+		*usagestr++);
+
+	/* a short one-line description (mandatory) */
+	if ((flags & USAGE_SHORT) == 0)
+		return 0;
+	else if (!*usagestr)
+		return -2;
+
+	if (flags & USAGE_LISTING)
+		pad = 8;
+	else
+		fputc('\n', outf);
+
+	fprintf(outf, "%*s%s\n", pad, "", *usagestr++);
+
+	/* a long (possibly multi-line) description (optional) */
+	if (!*usagestr || ((flags & USAGE_LONG) == 0))
+		return 0;
+
+	if (**usagestr)
+		fputc('\n', outf);
+	while (*usagestr && **usagestr)
+		fprintf(outf, "%*s%s\n", pad, "", *usagestr++);
+
+	/* options (optional) */
+	if (!*usagestr || ((flags & USAGE_OPTIONS) == 0))
+		return 0;
+
+	/*
+	 * options (if present) should always (even if there is no long
+	 * description) be prepended with an empty line, skip it
+	 */
+	usagestr++;
+
+	fputc('\n', outf);
+	while (*usagestr)
+		fprintf(outf, "%*s%s\n", pad, "", *usagestr++);
+
+	return 0;
+}
+
+static int usage_command_internal(const char * const *usagestr,
+				  const char *token, int full, int lst,
+				  FILE *outf)
+{
+	unsigned int flags = USAGE_SHORT;
+	int ret;
+
+	if (full)
+		flags |= USAGE_LONG | USAGE_OPTIONS;
+	if (lst)
+		flags |= USAGE_LISTING;
+
+	ret = do_usage_one_command(usagestr, flags, outf);
+	switch (ret) {
+	case -1:
+		fprintf(outf, "No usage for '%s'\n", token);
+		break;
+	case -2:
+		fprintf(outf, "No short description for '%s'\n", token);
+		break;
+	}
+
+	return ret;
+}
+
+static void usage_command_usagestr(const char * const *usagestr,
+				   const char *token, int full, int err)
+{
+	FILE *outf = err ? stderr : stdout;
+	int ret;
+
+	ret = usage_command_internal(usagestr, token, full, 0, outf);
+	if (!ret)
+		fputc('\n', outf);
+}
+
+void usage_command(const struct cmd_struct *cmd, int full, int err)
+{
+	usage_command_usagestr(cmd->usagestr, cmd->token, full, err);
+}
+
+void usage(const char * const *usagestr)
+{
+	usage_command_usagestr(usagestr, NULL, 1, 1);
+	exit(129);
+}
+
+static void usage_command_group_internal(const struct cmd_group *grp, int full,
+					 FILE *outf)
+{
+	const struct cmd_struct *cmd = grp->commands;
+	int do_sep = 0;
+
+	for (; cmd->token; cmd++) {
+		if (cmd->hidden)
+			continue;
+
+		if (full && cmd != grp->commands)
+			fputc('\n', outf);
+
+		if (!cmd->next) {
+			if (do_sep) {
+				fputc('\n', outf);
+				do_sep = 0;
+			}
+
+			usage_command_internal(cmd->usagestr, cmd->token, full,
+					       1, outf);
+			continue;
+		}
+
+		/* this is an entry point to a nested command group */
+
+		if (!full && cmd != grp->commands)
+			fputc('\n', outf);
+
+		usage_command_group_internal(cmd->next, full, outf);
+
+		if (!full)
+			do_sep = 1;
+	}
+}
+
+void usage_command_group(const struct cmd_group *grp, int full, int err)
+{
+	const char * const *usagestr = grp->usagestr;
+	FILE *outf = err ? stderr : stdout;
+
+	if (usagestr && *usagestr) {
+		fprintf(outf, "usage: %s\n", *usagestr++);
+		while (*usagestr)
+			fprintf(outf, "   or: %s\n", *usagestr++);
+	}
+
+	fputc('\n', outf);
+	usage_command_group_internal(grp, full, outf);
+	fputc('\n', outf);
+
+	if (grp->infostr)
+		fprintf(outf, "%s\n", grp->infostr);
+}
+
+void help_unknown_token(const char *arg, const struct cmd_group *grp)
+{
+	fprintf(stderr, "%s: unknown token '%s'\n", argv0_buf, arg);
+	usage_command_group(grp, 0, 1);
+	exit(1);
+}
+
+void help_ambiguous_token(const char *arg, const struct cmd_group *grp)
+{
+	const struct cmd_struct *cmd = grp->commands;
+
+	fprintf(stderr, "%s: ambiguous token '%s'\n", argv0_buf, arg);
+	fprintf(stderr, "\nDid you mean one of these ?\n");
+
+	for (; cmd->token; cmd++) {
+		if (!prefixcmp(cmd->token, arg))
+			fprintf(stderr, "\t%s\n", cmd->token);
+	}
+
+	exit(1);
+}
+
+void help_command_group(const struct cmd_group *grp, int argc, char **argv)
+{
+	int full = 0;
+
+	if (argc > 1) {
+		if (!strcmp(argv[1], "--full"))
+			full = 1;
+	}
+
+	usage_command_group(grp, full, 0);
+}
diff -Nru btrfs-tools-0.19+20111121/ioctl.h btrfs-tools-0.19+20120328/ioctl.h
--- btrfs-tools-0.19+20111121/ioctl.h	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/ioctl.h	2012-05-05 18:22:58.000000000 +0000
@@ -91,6 +91,54 @@
 	__u64 reserved[124];			/* pad to 1k */
 };
 
+/* balance control ioctl modes */
+#define BTRFS_BALANCE_CTL_PAUSE		1
+#define BTRFS_BALANCE_CTL_CANCEL	2
+#define BTRFS_BALANCE_CTL_RESUME	3
+
+/*
+ * this is packed, because it should be exactly the same as its disk
+ * byte order counterpart (struct btrfs_disk_balance_args)
+ */
+struct btrfs_balance_args {
+	__u64 profiles;
+	__u64 usage;
+	__u64 devid;
+	__u64 pstart;
+	__u64 pend;
+	__u64 vstart;
+	__u64 vend;
+
+	__u64 target;
+
+	__u64 flags;
+
+	__u64 unused[8];
+} __attribute__ ((__packed__));
+
+struct btrfs_balance_progress {
+	__u64 expected;
+	__u64 considered;
+	__u64 completed;
+};
+
+#define BTRFS_BALANCE_STATE_RUNNING	(1ULL << 0)
+#define BTRFS_BALANCE_STATE_PAUSE_REQ	(1ULL << 1)
+#define BTRFS_BALANCE_STATE_CANCEL_REQ	(1ULL << 2)
+
+struct btrfs_ioctl_balance_args {
+	__u64 flags;				/* in/out */
+	__u64 state;				/* out */
+
+	struct btrfs_balance_args data;		/* in/out */
+	struct btrfs_balance_args meta;		/* in/out */
+	struct btrfs_balance_args sys;		/* in/out */
+
+	struct btrfs_balance_progress stat;	/* out */
+
+	__u64 unused[72];			/* pad to 1k */
+};
+
 struct btrfs_ioctl_search_key {
 	/* which root are we searching.  0 is the tree of tree roots */
 	__u64 tree_id;
@@ -273,6 +321,11 @@
 					struct btrfs_ioctl_dev_info_args)
 #define BTRFS_IOC_FS_INFO _IOR(BTRFS_IOCTL_MAGIC, 31, \
                                  struct btrfs_ioctl_fs_info_args)
+#define BTRFS_IOC_BALANCE_V2 _IOWR(BTRFS_IOCTL_MAGIC, 32, \
+				   struct btrfs_ioctl_balance_args)
+#define BTRFS_IOC_BALANCE_CTL _IOW(BTRFS_IOCTL_MAGIC, 33, int)
+#define BTRFS_IOC_BALANCE_PROGRESS _IOR(BTRFS_IOCTL_MAGIC, 34, \
+					struct btrfs_ioctl_balance_args)
 #define BTRFS_IOC_INO_PATHS _IOWR(BTRFS_IOCTL_MAGIC, 35, \
 					struct btrfs_ioctl_ino_path_args)
 #define BTRFS_IOC_LOGICAL_INO _IOWR(BTRFS_IOCTL_MAGIC, 36, \
diff -Nru btrfs-tools-0.19+20111121/Makefile btrfs-tools-0.19+20120328/Makefile
--- btrfs-tools-0.19+20111121/Makefile	2011-11-23 00:03:58.000000000 +0000
+++ btrfs-tools-0.19+20120328/Makefile	2012-05-05 18:22:58.000000000 +0000
@@ -4,7 +4,9 @@
 objects = ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
 	  root-tree.o dir-item.o file-item.o inode-item.o \
 	  inode-map.o crc32c.o rbtree.o extent-cache.o extent_io.o \
-	  volumes.o utils.o btrfs-list.o btrfslabel.o
+	  volumes.o utils.o btrfs-list.o btrfslabel.o repair.o
+cmds_objects = cmds-subvolume.o cmds-filesystem.o cmds-device.o cmds-scrub.o \
+	       cmds-inspect.o cmds-balance.o
 
 CHECKFLAGS= -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise \
 	    -Wuninitialized -Wshadow -Wundef
@@ -17,7 +19,8 @@
 RESTORE_LIBS=-lz
 
 progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck \
-	btrfs btrfs-map-logical restore find-root calc-size btrfs-corrupt-block
+	btrfs btrfs-map-logical btrfs-image btrfs-zero-log btrfs-convert \
+	btrfs-find-root btrfs-restore btrfstune
 
 # make C=1 to enable sparse
 ifdef C
@@ -36,18 +39,18 @@
 version:
 	bash version.sh
 
-btrfs: $(objects) btrfs.o btrfs_cmds.o scrub.o
-	$(CC) -lpthread $(CFLAGS) -o btrfs btrfs.o btrfs_cmds.o scrub.o \
-		$(objects) $(LDFLAGS) $(LIBS)
+btrfs: $(objects) btrfs.o help.o common.o $(cmds_objects)
+	$(CC) $(CFLAGS) -o btrfs btrfs.o help.o common.o $(cmds_objects) \
+		$(objects) $(LDFLAGS) $(LIBS) -lpthread
 
 calc-size: $(objects) calc-size.o
 	gcc $(CFLAGS) -o calc-size calc-size.o $(objects) $(LDFLAGS) $(LIBS)
 
-find-root: $(objects) find-root.o
-	gcc $(CFLAGS) -o find-root find-root.o $(objects) $(LDFLAGS) $(LIBS)
+btrfs-find-root: $(objects) find-root.o
+	gcc $(CFLAGS) -o btrfs-find-root find-root.o $(objects) $(LDFLAGS) $(LIBS)
 
-restore: $(objects) restore.o
-	gcc $(CFLAGS) -o restore restore.o $(objects) $(LDFLAGS) $(LIBS) $(RESTORE_LIBS)
+btrfs-restore: $(objects) restore.o
+	gcc $(CFLAGS) -o btrfs-restore restore.o $(objects) $(LDFLAGS) $(LIBS) $(RESTORE_LIBS)
 
 btrfsctl: $(objects) btrfsctl.o
 	$(CC) $(CFLAGS) -o btrfsctl btrfsctl.o $(objects) $(LDFLAGS) $(LIBS)
@@ -91,7 +94,7 @@
 quick-test: $(objects) quick-test.o
 	$(CC) $(CFLAGS) -o quick-test $(objects) quick-test.o $(LDFLAGS) $(LIBS)
 
-convert: $(objects) convert.o
+btrfs-convert: $(objects) convert.o
 	$(CC) $(CFLAGS) -o btrfs-convert $(objects) convert.o -lext2fs -lcom_err $(LDFLAGS) $(LIBS)
 
 ioctl-test: $(objects) ioctl-test.o
@@ -111,6 +114,5 @@
 install: $(progs) install-man
 	$(INSTALL) -m755 -d $(DESTDIR)$(bindir)
 	$(INSTALL) $(progs) $(DESTDIR)$(bindir)
-	if [ -e btrfs-convert ]; then $(INSTALL) btrfs-convert $(DESTDIR)$(bindir); fi
 
 -include .*.d
diff -Nru btrfs-tools-0.19+20111121/mkfs.c btrfs-tools-0.19+20120328/mkfs.c
--- btrfs-tools-0.19+20111121/mkfs.c	2011-11-23 00:03:58.000000000 +0000
+++ btrfs-tools-0.19+20120328/mkfs.c	2012-05-05 18:53:48.000000000 +0000
@@ -59,6 +59,9 @@
 	int len = strlen(s);
 	char c;
 	u64 mult = 1;
+	u64 ret;
+
+	s = strdup(s);
 
 	if (!isdigit(s[len - 1])) {
 		c = tolower(s[len - 1]);
@@ -77,7 +80,9 @@
 		}
 		s[len - 1] = '\0';
 	}
-	return atol(s) * mult;
+	ret = atol(s) * mult;
+	free(s);
+	return ret;
 }
 
 static int make_root_dir(struct btrfs_root *root, int mixed)
@@ -228,12 +233,26 @@
 
 static int create_raid_groups(struct btrfs_trans_handle *trans,
 			      struct btrfs_root *root, u64 data_profile,
-			      u64 metadata_profile, int mixed)
+			      int data_profile_opt, u64 metadata_profile,
+			      int metadata_profile_opt, int mixed)
 {
 	u64 num_devices = btrfs_super_num_devices(&root->fs_info->super_copy);
 	u64 allowed;
 	int ret;
 
+	/*
+	 * Set default profiles according to number of added devices.
+	 * For mixed groups defaults are single/single.
+	 */
+	if (!metadata_profile_opt && !mixed) {
+		metadata_profile = (num_devices > 1) ?
+			BTRFS_BLOCK_GROUP_RAID1 : BTRFS_BLOCK_GROUP_DUP;
+	}
+	if (!data_profile_opt && !mixed) {
+		data_profile = (num_devices > 1) ?
+			BTRFS_BLOCK_GROUP_RAID0 : 0; /* raid0 or single */
+	}
+
 	if (num_devices == 1)
 		allowed = BTRFS_BLOCK_GROUP_DUP;
 	else if (num_devices >= 4) {
@@ -242,6 +261,19 @@
 	} else
 		allowed = BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1;
 
+	if (metadata_profile & ~allowed) {
+		fprintf(stderr,	"unable to create FS with metadata "
+			"profile %llu (%llu devices)\n", metadata_profile,
+			num_devices);
+		exit(1);
+	}
+	if (data_profile & ~allowed) {
+		fprintf(stderr, "unable to create FS with data "
+			"profile %llu (%llu devices)\n", data_profile,
+			num_devices);
+		exit(1);
+	}
+
 	if (allowed & metadata_profile) {
 		u64 meta_flags = BTRFS_BLOCK_GROUP_METADATA;
 
@@ -325,21 +357,21 @@
 	if (strcmp(s, "raid0") == 0) {
 		return BTRFS_BLOCK_GROUP_RAID0;
 	} else if (strcmp(s, "raid1") == 0) {
-		return BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP;
+		return BTRFS_BLOCK_GROUP_RAID1;
 	} else if (strcmp(s, "raid10") == 0) {
-		return BTRFS_BLOCK_GROUP_RAID10 | BTRFS_BLOCK_GROUP_DUP;
+		return BTRFS_BLOCK_GROUP_RAID10;
 	} else if (strcmp(s, "single") == 0) {
 		return 0;
 	} else {
 		fprintf(stderr, "Unknown option %s\n", s);
 		print_usage();
 	}
+	/* not reached */
 	return 0;
 }
 
 static char *parse_label(char *input)
 {
-	int i;
 	int len = strlen(input);
 
 	if (len >= BTRFS_LABEL_SIZE) {
@@ -347,12 +379,6 @@
 			BTRFS_LABEL_SIZE - 1);
 		exit(1);
 	}
-	for (i = 0; i < len; i++) {
-		if (input[i] == '/' || input[i] == '\\') {
-			fprintf(stderr, "invalid label %s\n", input);
-			exit(1);
-		}
-	}
 	return strdup(input);
 }
 
@@ -1170,8 +1196,8 @@
 	u64 dev_block_count = 0;
 	u64 blocks[7];
 	u64 alloc_start = 0;
-	u64 metadata_profile = BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP;
-	u64 data_profile = BTRFS_BLOCK_GROUP_RAID0;
+	u64 metadata_profile = 0;
+	u64 data_profile = 0;
 	u32 leafsize = getpagesize();
 	u32 sectorsize = 4096;
 	u32 nodesize = leafsize;
@@ -1207,6 +1233,8 @@
 				data_profile_opt = 1;
 				break;
 			case 'l':
+			case 'n':
+				nodesize = parse_size(optarg);
 				leafsize = parse_size(optarg);
 				break;
 			case 'L':
@@ -1219,9 +1247,6 @@
 			case 'M':
 				mixed = 1;
 				break;
-			case 'n':
-				nodesize = parse_size(optarg);
-				break;
 			case 's':
 				sectorsize = parse_size(optarg);
 				break;
@@ -1303,11 +1328,6 @@
 		}
 	}
 	if (mixed) {
-		if (!metadata_profile_opt)
-			metadata_profile = 0;
-		if (!data_profile_opt)
-			data_profile = 0;
-
 		if (metadata_profile != data_profile) {
 			fprintf(stderr, "With mixed block groups data and metadata "
 				"profiles must be the same\n");
@@ -1328,7 +1348,12 @@
 		fprintf(stderr, "error during mkfs %d\n", ret);
 		exit(1);
 	}
+
 	root = open_ctree(file, 0, O_RDWR);
+	if (!root) {
+		fprintf(stderr, "ctree init failed\n");
+		exit(1);
+	}
 	root->fs_info->alloc_start = alloc_start;
 
 	ret = make_root_dir(root, mixed);
@@ -1343,10 +1368,6 @@
 		goto raid_groups;
 
 	btrfs_register_one_device(file);
-	if (!root) {
-		fprintf(stderr, "ctree init failed\n");
-		return -1;
-	}
 
 	zero_end = 1;
 	while(ac-- > 0) {
@@ -1390,7 +1411,8 @@
 raid_groups:
 	if (!source_dir_set) {
 		ret = create_raid_groups(trans, root, data_profile,
-				 metadata_profile, mixed);
+				 data_profile_opt, metadata_profile,
+				 metadata_profile_opt, mixed);
 		BUG_ON(ret);
 	}
 
diff -Nru btrfs-tools-0.19+20111121/print-tree.c btrfs-tools-0.19+20120328/print-tree.c
--- btrfs-tools-0.19+20111121/print-tree.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/print-tree.c	2012-05-05 18:22:58.000000000 +0000
@@ -239,7 +239,7 @@
 			       btrfs_shared_data_ref_count(eb, sref));
 			break;
 		default:
-			BUG();
+			return;
 		}
 		ptr += btrfs_extent_inline_ref_size(type);
 	}
@@ -351,6 +351,9 @@
 	case BTRFS_DEV_EXTENT_KEY:
 		printf("DEV_EXTENT");
 		break;
+	case BTRFS_BALANCE_ITEM_KEY:
+		printf("BALANCE_ITEM");
+		break;
 	case BTRFS_STRING_ITEM_KEY:
 		printf("STRING_ITEM");
 		break;
@@ -391,6 +394,9 @@
 	case BTRFS_CSUM_TREE_OBJECTID:
 		printf("CSUM_TREE");
 		break;
+	case BTRFS_BALANCE_OBJECTID:
+		printf("BALANCE");
+		break;
 	case BTRFS_ORPHAN_OBJECTID:
 		printf("ORPHAN");
 		break;
diff -Nru btrfs-tools-0.19+20111121/repair.c btrfs-tools-0.19+20120328/repair.c
--- btrfs-tools-0.19+20111121/repair.c	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/repair.c	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2012 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include "ctree.h"
+#include "extent-cache.h"
+#include "utils.h"
+#include "repair.h"
+
+int btrfs_add_corrupt_extent_record(struct btrfs_fs_info *info,
+				    struct btrfs_key *first_key,
+				    u64 start, u64 len, int level)
+
+{
+	int ret = 0;
+	struct btrfs_corrupt_block *corrupt;
+
+	if (!info->corrupt_blocks)
+		return 0;
+
+	corrupt = malloc(sizeof(*corrupt));
+	if (!corrupt)
+		return -ENOMEM;
+
+	memcpy(&corrupt->key, first_key, sizeof(*first_key));
+	corrupt->cache.start = start;
+	corrupt->cache.size = len;
+	corrupt->level = level;
+
+	ret = insert_existing_cache_extent(info->corrupt_blocks, &corrupt->cache);
+	if (ret)
+		free(corrupt);
+	BUG_ON(ret && ret != -EEXIST);
+	return ret;
+}
+
diff -Nru btrfs-tools-0.19+20111121/repair.h btrfs-tools-0.19+20120328/repair.h
--- btrfs-tools-0.19+20111121/repair.h	1970-01-01 00:00:00.000000000 +0000
+++ btrfs-tools-0.19+20120328/repair.h	2012-05-05 18:22:58.000000000 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2012 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#ifndef __BTRFS_REPAIR__
+#define __BTRFS_REPAIR__
+
+struct btrfs_corrupt_block {
+	struct cache_extent cache;
+	struct btrfs_key key;
+	int level;
+};
+
+int btrfs_add_corrupt_extent_record(struct btrfs_fs_info *info,
+				    struct btrfs_key *first_key,
+				    u64 start, u64 len, int level);
+
+#endif
diff -Nru btrfs-tools-0.19+20111121/scrub.c btrfs-tools-0.19+20120328/scrub.c
--- btrfs-tools-0.19+20111121/scrub.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/scrub.c	1970-01-01 00:00:00.000000000 +0000
@@ -1,1666 +0,0 @@
-/*
- * Copyright (C) 2011 STRATO.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
-
-#include <sys/ioctl.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <poll.h>
-#include <sys/file.h>
-#include <uuid/uuid.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <pthread.h>
-#include <ctype.h>
-#include <signal.h>
-#include <stdarg.h>
-
-#include "ctree.h"
-#include "ioctl.h"
-#include "btrfs_cmds.h"
-#include "utils.h"
-#include "volumes.h"
-#include "disk-io.h"
-
-#define SCRUB_DATA_FILE "/var/lib/btrfs/scrub.status"
-#define SCRUB_PROGRESS_SOCKET_PATH "/var/lib/btrfs/scrub.progress"
-#define SCRUB_FILE_VERSION_PREFIX "scrub status"
-#define SCRUB_FILE_VERSION "1"
-
-struct scrub_stats {
-	time_t t_start;
-	time_t t_resumed;
-	u64 duration;
-	u64 finished;
-	u64 canceled;
-};
-
-struct scrub_progress {
-	struct btrfs_ioctl_scrub_args scrub_args;
-	int fd;
-	int ret;
-	int skip;
-	struct scrub_stats stats;
-	struct scrub_file_record *resumed;
-	int ioctl_errno;
-	pthread_mutex_t progress_mutex;
-};
-
-struct scrub_file_record {
-	u8 fsid[BTRFS_FSID_SIZE];
-	u64 devid;
-	struct scrub_stats stats;
-	struct btrfs_scrub_progress p;
-};
-
-struct scrub_progress_cycle {
-	int fdmnt;
-	int prg_fd;
-	int do_record;
-	struct btrfs_ioctl_fs_info_args *fi;
-	struct scrub_progress *progress;
-	struct scrub_progress *shared_progress;
-	pthread_mutex_t *write_mutex;
-};
-
-struct scrub_fs_stat {
-	struct btrfs_scrub_progress p;
-	struct scrub_stats s;
-	int i;
-};
-
-static void print_scrub_full(struct btrfs_scrub_progress *sp)
-{
-	printf("\tdata_extents_scrubbed: %lld\n", sp->data_extents_scrubbed);
-	printf("\ttree_extents_scrubbed: %lld\n", sp->tree_extents_scrubbed);
-	printf("\tdata_bytes_scrubbed: %lld\n", sp->data_bytes_scrubbed);
-	printf("\ttree_bytes_scrubbed: %lld\n", sp->tree_bytes_scrubbed);
-	printf("\tread_errors: %lld\n", sp->read_errors);
-	printf("\tcsum_errors: %lld\n", sp->csum_errors);
-	printf("\tverify_errors: %lld\n", sp->verify_errors);
-	printf("\tno_csum: %lld\n", sp->no_csum);
-	printf("\tcsum_discards: %lld\n", sp->csum_discards);
-	printf("\tsuper_errors: %lld\n", sp->super_errors);
-	printf("\tmalloc_errors: %lld\n", sp->malloc_errors);
-	printf("\tuncorrectable_errors: %lld\n", sp->uncorrectable_errors);
-	printf("\tunverified_errors: %lld\n", sp->unverified_errors);
-	printf("\tcorrected_errors: %lld\n", sp->corrected_errors);
-	printf("\tlast_physical: %lld\n", sp->last_physical);
-}
-
-#define ERR(test, ...) do {			\
-	if (test)				\
-		fprintf(stderr, __VA_ARGS__);	\
-} while (0)
-
-#define PRINT_SCRUB_ERROR(test, desc) do {	\
-	if (test)				\
-		printf(" %s=%llu", desc, test);	\
-} while (0)
-
-static void print_scrub_summary(struct btrfs_scrub_progress *p)
-{
-	u64 err_cnt;
-	u64 err_cnt2;
-	char *bytes;
-
-	err_cnt = p->read_errors +
-			p->csum_errors +
-			p->verify_errors +
-			p->super_errors;
-
-	err_cnt2 = p->corrected_errors + p->uncorrectable_errors;
-
-	if (p->malloc_errors)
-		printf("*** WARNING: memory allocation failed while scrubbing. "
-		       "results may be inaccurate\n");
-	bytes = pretty_sizes(p->data_bytes_scrubbed + p->tree_bytes_scrubbed);
-	printf("\ttotal bytes scrubbed: %s with %llu errors\n", bytes,
-		max(err_cnt, err_cnt2));
-	free(bytes);
-	if (err_cnt || err_cnt2) {
-		printf("\terror details:");
-		PRINT_SCRUB_ERROR(p->read_errors, "read");
-		PRINT_SCRUB_ERROR(p->super_errors, "super");
-		PRINT_SCRUB_ERROR(p->verify_errors, "verify");
-		PRINT_SCRUB_ERROR(p->csum_errors, "csum");
-		printf("\n");
-		printf("\tcorrected errors: %llu, uncorrectable errors: %llu, "
-			"unverified errors: %llu\n", p->corrected_errors,
-			p->uncorrectable_errors, p->unverified_errors);
-	}
-}
-
-#define _SCRUB_FS_STAT(p, name, fs_stat) do {	\
-	fs_stat->p.name += p->name;		\
-} while (0)
-
-#define _SCRUB_FS_STAT_MIN(ss, name, fs_stat)	\
-do {						\
-	if (fs_stat->s.name > ss->name) {	\
-		fs_stat->s.name = ss->name;	\
-	}					\
-} while (0)
-
-#define _SCRUB_FS_STAT_ZMIN(ss, name, fs_stat)			\
-do {								\
-	if (!fs_stat->s.name || fs_stat->s.name > ss->name) {	\
-		fs_stat->s.name = ss->name;			\
-	}							\
-} while (0)
-
-#define _SCRUB_FS_STAT_ZMAX(ss, name, fs_stat)				\
-do {									\
-	if (!(fs_stat)->s.name || (fs_stat)->s.name < (ss)->name) {	\
-		(fs_stat)->s.name = (ss)->name;				\
-	}								\
-} while (0)
-
-static void add_to_fs_stat(struct btrfs_scrub_progress *p,
-				struct scrub_stats *ss,
-				struct scrub_fs_stat *fs_stat)
-{
-	_SCRUB_FS_STAT(p, data_extents_scrubbed, fs_stat);
-	_SCRUB_FS_STAT(p, tree_extents_scrubbed, fs_stat);
-	_SCRUB_FS_STAT(p, data_bytes_scrubbed, fs_stat);
-	_SCRUB_FS_STAT(p, tree_bytes_scrubbed, fs_stat);
-	_SCRUB_FS_STAT(p, read_errors, fs_stat);
-	_SCRUB_FS_STAT(p, csum_errors, fs_stat);
-	_SCRUB_FS_STAT(p, verify_errors, fs_stat);
-	_SCRUB_FS_STAT(p, no_csum, fs_stat);
-	_SCRUB_FS_STAT(p, csum_discards, fs_stat);
-	_SCRUB_FS_STAT(p, super_errors, fs_stat);
-	_SCRUB_FS_STAT(p, malloc_errors, fs_stat);
-	_SCRUB_FS_STAT(p, uncorrectable_errors, fs_stat);
-	_SCRUB_FS_STAT(p, corrected_errors, fs_stat);
-	_SCRUB_FS_STAT(p, last_physical, fs_stat);
-	_SCRUB_FS_STAT_ZMIN(ss, t_start, fs_stat);
-	_SCRUB_FS_STAT_ZMIN(ss, t_resumed, fs_stat);
-	_SCRUB_FS_STAT_ZMAX(ss, duration, fs_stat);
-	_SCRUB_FS_STAT_ZMAX(ss, canceled, fs_stat);
-	_SCRUB_FS_STAT_MIN(ss, finished, fs_stat);
-}
-
-static void init_fs_stat(struct scrub_fs_stat *fs_stat)
-{
-	memset(fs_stat, 0, sizeof(*fs_stat));
-	fs_stat->s.finished = 1;
-}
-
-static void _print_scrub_ss(struct scrub_stats *ss)
-{
-	char t[4096];
-	struct tm tm;
-
-	if (!ss || !ss->t_start) {
-		printf("\tno stats available\n");
-		return;
-	}
-	if (ss->t_resumed) {
-		localtime_r(&ss->t_resumed, &tm);
-		strftime(t, sizeof(t), "%c", &tm);
-		t[sizeof(t) - 1] = '\0';
-		printf("\tscrub resumed at %s", t);
-	} else {
-		localtime_r(&ss->t_start, &tm);
-		strftime(t, sizeof(t), "%c", &tm);
-		t[sizeof(t) - 1] = '\0';
-		printf("\tscrub started at %s", t);
-	}
-	if (ss->finished && !ss->canceled) {
-		printf(" and finished after %llu seconds\n",
-		       ss->duration);
-	} else if (ss->canceled) {
-		printf(" and was aborted after %llu seconds\n",
-		       ss->duration);
-	} else {
-		printf(", running for %llu seconds\n", ss->duration);
-	}
-}
-
-static void print_scrub_dev(struct btrfs_ioctl_dev_info_args *di,
-				struct btrfs_scrub_progress *p, int raw,
-				const char *append, struct scrub_stats *ss)
-{
-	printf("scrub device %s (id %llu) %s\n", di->path, di->devid,
-	       append ? append : "");
-
-	_print_scrub_ss(ss);
-
-	if (p) {
-		if (raw)
-			print_scrub_full(p);
-		else
-			print_scrub_summary(p);
-	}
-}
-
-static void print_fs_stat(struct scrub_fs_stat *fs_stat, int raw)
-{
-	_print_scrub_ss(&fs_stat->s);
-
-	if (raw)
-		print_scrub_full(&fs_stat->p);
-	else
-		print_scrub_summary(&fs_stat->p);
-}
-
-static void free_history(struct scrub_file_record **last_scrubs)
-{
-	struct scrub_file_record **l = last_scrubs;
-	if (!l)
-		return;
-	while (*l)
-		free(*l++);
-	free(last_scrubs);
-}
-
-/*
- * cancels a running scrub and makes the master process record the current
- * progress status before exiting.
- */
-static int cancel_fd = -1;
-static void scrub_sigint_record_progress(int signal)
-{
-	ioctl(cancel_fd, BTRFS_IOC_SCRUB_CANCEL, NULL);
-}
-
-static int scrub_handle_sigint_parent(void)
-{
-	struct sigaction sa = {
-		.sa_handler = SIG_IGN,
-		.sa_flags = SA_RESTART,
-	};
-
-	return sigaction(SIGINT, &sa, NULL);
-}
-
-static int scrub_handle_sigint_child(int fd)
-{
-	struct sigaction sa = {
-		.sa_handler = fd == -1 ? SIG_DFL : scrub_sigint_record_progress,
-	};
-
-	cancel_fd = fd;
-	return sigaction(SIGINT, &sa, NULL);
-}
-
-static int scrub_datafile(const char *fn_base, const char *fn_local,
-				const char *fn_tmp, char *datafile, int size)
-{
-	int ret;
-	int end = size - 2;
-
-	datafile[end + 1] = '\0';
-	strncpy(datafile, fn_base, end);
-	ret = strlen(datafile);
-
-	if (ret + 1 > end)
-		return -EOVERFLOW;
-
-	datafile[ret] = '.';
-	strncpy(datafile + ret + 1, fn_local, end - ret - 1);
-	ret = strlen(datafile);
-
-	if (ret + 1 > end)
-		return -EOVERFLOW;
-
-	if (fn_tmp) {
-		datafile[ret] = '_';
-		strncpy(datafile + ret + 1, fn_tmp, end - ret - 1);
-		ret = strlen(datafile);
-
-		if (ret > end)
-			return -EOVERFLOW;
-	}
-
-	return 0;
-}
-
-static int scrub_open_file(const char *datafile, int m)
-{
-	int fd;
-	int ret;
-
-	fd = open(datafile, m, 0600);
-	if (fd < 0)
-		return -errno;
-
-	ret = flock(fd, LOCK_EX|LOCK_NB);
-	if (ret) {
-		ret = errno;
-		close(fd);
-		return -ret;
-	}
-
-	return fd;
-}
-
-static int scrub_open_file_r(const char *fn_base, const char *fn_local)
-{
-	int ret;
-	char datafile[BTRFS_PATH_NAME_MAX + 1];
-	ret = scrub_datafile(fn_base, fn_local, NULL,
-				datafile, sizeof(datafile));
-	if (ret < 0)
-		return ret;
-	return scrub_open_file(datafile, O_RDONLY);
-}
-
-static int scrub_open_file_w(const char *fn_base, const char *fn_local,
-				const char *tmp)
-{
-	int ret;
-	char datafile[BTRFS_PATH_NAME_MAX + 1];
-	ret = scrub_datafile(fn_base, fn_local, tmp,
-				datafile, sizeof(datafile));
-	if (ret < 0)
-		return ret;
-	return scrub_open_file(datafile, O_WRONLY|O_CREAT);
-}
-
-static int scrub_rename_file(const char *fn_base, const char *fn_local,
-				const char *tmp)
-{
-	int ret;
-	char datafile_old[BTRFS_PATH_NAME_MAX + 1];
-	char datafile_new[BTRFS_PATH_NAME_MAX + 1];
-	ret = scrub_datafile(fn_base, fn_local, tmp,
-				datafile_old, sizeof(datafile_old));
-	if (ret < 0)
-		return ret;
-	ret = scrub_datafile(fn_base, fn_local, NULL,
-				datafile_new, sizeof(datafile_new));
-	if (ret < 0)
-		return ret;
-	ret = rename(datafile_old, datafile_new);
-	return ret ? -errno : 0;
-}
-
-#define _SCRUB_KVREAD(ret, i, name, avail, l, dest) if (ret == 0) {	  \
-	ret = scrub_kvread(i, sizeof(#name), avail, l, #name, dest.name); \
-}
-
-/*
- * returns 0 if the key did not match (nothing was read)
- *         1 if the key did match (success)
- *        -1 if the key did match and an error occured
- */
-static int scrub_kvread(int *i, int len, int avail, const char *buf,
-			const char *key, u64 *dest)
-{
-	int j;
-
-	if (*i + len + 1 < avail && strncmp(&buf[*i], key, len - 1) == 0) {
-		*i += len - 1;
-		if (buf[*i] != ':')
-			return -1;
-		*i += 1;
-		for (j = 0; isdigit(buf[*i + j]) && *i + j < avail; ++j)
-			;
-		if (*i + j >= avail)
-			return -1;
-		*dest = atoll(&buf[*i]);
-		*i += j;
-		return 1;
-	}
-
-	return 0;
-}
-
-#define _SCRUB_INVALID do {						\
-	if (report_errors)						\
-		fprintf(stderr, "WARNING: invalid data in line %d pos "	\
-			"%d state %d (near \"%.*s\") at %s:%d\n",	\
-			lineno, i, state, 20 > avail ? avail : 20,	\
-			l + i,	__FILE__, __LINE__);			\
-	goto skip;							\
-} while (0)
-
-static struct scrub_file_record **scrub_read_file(int fd, int report_errors)
-{
-	int avail = 0;
-	int old_avail = 0;
-	char l[16 * 1024];
-	int state = 0;
-	int curr = -1;
-	int i = 0;
-	int j;
-	int ret;
-	int eof = 0;
-	int lineno = 0;
-	u64 version;
-	char empty_uuid[BTRFS_FSID_SIZE] = {0};
-	struct scrub_file_record **p = NULL;
-
-	if (fd < 0)
-		return ERR_PTR(-EINVAL);
-
-again:
-	old_avail = avail - i;
-	BUG_ON(old_avail < 0);
-	if (old_avail)
-		memmove(l, l + i, old_avail);
-	avail = read(fd, l + old_avail, sizeof(l) - old_avail);
-	if (avail == 0)
-		eof = 1;
-	if (avail == 0 && old_avail == 0) {
-		if (curr >= 0 &&
-		    memcmp(p[curr]->fsid, empty_uuid, BTRFS_FSID_SIZE) == 0) {
-			p[curr] = NULL;
-		} else if (curr == -1) {
-			p = ERR_PTR(-ENODATA);
-		}
-		return p;
-	}
-	if (avail == -1)
-		return ERR_PTR(-errno);
-	avail += old_avail;
-
-	i = 0;
-	while (i < avail) {
-		switch (state) {
-		case 0: /* start of file */
-			ret = scrub_kvread(&i,
-				sizeof(SCRUB_FILE_VERSION_PREFIX), avail, l,
-				SCRUB_FILE_VERSION_PREFIX, &version);
-			if (ret != 1)
-				_SCRUB_INVALID;
-			if (version != atoll(SCRUB_FILE_VERSION))
-				return ERR_PTR(-ENOTSUP);
-			state = 6;
-			continue;
-		case 1: /* start of line, alloc */
-			/*
-			 * this state makes sure we have a complete line in
-			 * further processing, so we don't need wrap-tracking
-			 * everywhere.
-			 */
-			if (!eof && !memchr(l + i, '\n', avail - i))
-				goto again;
-			++lineno;
-			if (curr > -1 && memcmp(p[curr]->fsid, empty_uuid,
-						BTRFS_FSID_SIZE) == 0) {
-				state = 2;
-				continue;
-			}
-			++curr;
-			p = realloc(p, (curr + 2) * sizeof(*p));
-			if (p)
-				p[curr] = malloc(sizeof(**p));
-			if (!p || !p[curr])
-				return ERR_PTR(-errno);
-			memset(p[curr], 0, sizeof(**p));
-			p[curr + 1] = NULL;
-			++state;
-			/* fall through */
-		case 2: /* start of line, skip space */
-			while (isspace(l[i]) && i < avail) {
-				if (l[i] == '\n')
-					++lineno;
-				++i;
-			}
-			if (i >= avail ||
-			    (!eof && !memchr(l + i, '\n', avail - i)))
-				goto again;
-			++state;
-			/* fall through */
-		case 3: /* read fsid */
-			if (i == avail)
-				continue;
-			for (j = 0; l[i + j] != ':' && i + j < avail; ++j)
-				;
-			if (i + j + 1 >= avail)
-				_SCRUB_INVALID;
-			if (j != 36)
-				_SCRUB_INVALID;
-			l[i + j] = '\0';
-			ret = uuid_parse(l + i, p[curr]->fsid);
-			if (ret)
-				_SCRUB_INVALID;
-			i += j + 1;
-			++state;
-			/* fall through */
-		case 4: /* read dev id */
-			for (j = 0; isdigit(l[i + j]) && i+j < avail; ++j)
-				;
-			if (j == 0 || i + j + 1 >= avail)
-				_SCRUB_INVALID;
-			p[curr]->devid = atoll(&l[i]);
-			i += j + 1;
-			++state;
-			/* fall through */
-		case 5: /* read key/value pair */
-			ret = 0;
-			_SCRUB_KVREAD(ret, &i, data_extents_scrubbed, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, data_extents_scrubbed, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, tree_extents_scrubbed, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, data_bytes_scrubbed, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, tree_bytes_scrubbed, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, read_errors, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, csum_errors, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, verify_errors, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, no_csum, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, csum_discards, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, super_errors, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, malloc_errors, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, uncorrectable_errors, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, corrected_errors, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, last_physical, avail, l,
-					&p[curr]->p);
-			_SCRUB_KVREAD(ret, &i, finished, avail, l,
-					&p[curr]->stats);
-			_SCRUB_KVREAD(ret, &i, t_start, avail, l,
-					(u64 *)&p[curr]->stats);
-			_SCRUB_KVREAD(ret, &i, t_resumed, avail, l,
-					(u64 *)&p[curr]->stats);
-			_SCRUB_KVREAD(ret, &i, duration, avail, l,
-					(u64 *)&p[curr]->stats);
-			_SCRUB_KVREAD(ret, &i, canceled, avail, l,
-					&p[curr]->stats);
-			if (ret != 1)
-				_SCRUB_INVALID;
-			++state;
-			/* fall through */
-		case 6: /* after number */
-			if (l[i] == '|')
-				state = 5;
-			else if (l[i] == '\n')
-				state = 1;
-			else
-				_SCRUB_INVALID;
-			++i;
-			continue;
-		case 99: /* skip rest of line */
-skip:
-			state = 99;
-			do {
-				++i;
-				if (l[i - 1] == '\n') {
-					state = 1;
-					break;
-				}
-			} while (i < avail);
-			continue;
-		}
-		BUG();
-	}
-	goto again;
-}
-
-static int scrub_write_buf(int fd, const void *data, int len)
-{
-	int ret;
-	ret = write(fd, data, len);
-	return ret - len;
-}
-
-static int scrub_writev(int fd, char *buf, int max, const char *fmt, ...)
-				__attribute__ ((format (printf, 4, 5)));
-static int scrub_writev(int fd, char *buf, int max, const char *fmt, ...)
-{
-	int ret;
-	va_list args;
-
-	va_start(args, fmt);
-	ret = vsnprintf(buf, max, fmt, args);
-	va_end(args);
-	if (ret >= max)
-		return ret - max;
-	return scrub_write_buf(fd, buf, ret);
-}
-
-#define _SCRUB_SUM(dest, data, name) dest->scrub_args.progress.name =	\
-			data->resumed->p.name + data->scrub_args.progress.name
-
-static struct scrub_progress *scrub_resumed_stats(struct scrub_progress *data,
-						  struct scrub_progress *dest)
-{
-	if (!data->resumed || data->skip)
-		return data;
-
-	_SCRUB_SUM(dest, data, data_extents_scrubbed);
-	_SCRUB_SUM(dest, data, tree_extents_scrubbed);
-	_SCRUB_SUM(dest, data, data_bytes_scrubbed);
-	_SCRUB_SUM(dest, data, tree_bytes_scrubbed);
-	_SCRUB_SUM(dest, data, read_errors);
-	_SCRUB_SUM(dest, data, csum_errors);
-	_SCRUB_SUM(dest, data, verify_errors);
-	_SCRUB_SUM(dest, data, no_csum);
-	_SCRUB_SUM(dest, data, csum_discards);
-	_SCRUB_SUM(dest, data, super_errors);
-	_SCRUB_SUM(dest, data, malloc_errors);
-	_SCRUB_SUM(dest, data, uncorrectable_errors);
-	_SCRUB_SUM(dest, data, corrected_errors);
-	_SCRUB_SUM(dest, data, last_physical);
-	dest->stats.canceled = data->stats.canceled;
-	dest->stats.finished = data->stats.finished;
-	dest->stats.t_resumed = data->stats.t_start;
-	dest->stats.t_start = data->resumed->stats.t_start;
-	dest->stats.duration = data->resumed->stats.duration +
-							data->stats.duration;
-	dest->scrub_args.devid = data->scrub_args.devid;
-	return dest;
-}
-
-#define _SCRUB_KVWRITE(fd, buf, name, use)		\
-	scrub_kvwrite(fd, buf, sizeof(buf), #name,	\
-			use->scrub_args.progress.name)
-
-#define _SCRUB_KVWRITE_STATS(fd, buf, name, use)	\
-	scrub_kvwrite(fd, buf, sizeof(buf), #name,	\
-			use->stats.name)
-
-static int scrub_kvwrite(int fd, char *buf, int max, const char *key, u64 val)
-{
-	return scrub_writev(fd, buf, max, "|%s:%lld", key, val);
-}
-
-static int scrub_write_file(int fd, const char *fsid,
-				struct scrub_progress *data, int n)
-{
-	int ret = 0;
-	int i;
-	char buf[1024];
-	struct scrub_progress local;
-	struct scrub_progress *use;
-
-	if (n < 1)
-		return -EINVAL;
-
-	/* each -1 is to subtract one \0 byte, the + 2 is for ':' and '\n' */
-	ret = scrub_write_buf(fd, SCRUB_FILE_VERSION_PREFIX ":"
-				SCRUB_FILE_VERSION "\n",
-				(sizeof(SCRUB_FILE_VERSION_PREFIX) - 1) +
-				(sizeof(SCRUB_FILE_VERSION) - 1) + 2);
-	if (ret)
-		return -EOVERFLOW;
-
-	for (i = 0; i < n; ++i) {
-		use = scrub_resumed_stats(&data[i], &local);
-		if (scrub_write_buf(fd, fsid, strlen(fsid)) ||
-		    scrub_write_buf(fd, ":", 1) ||
-		    scrub_writev(fd, buf, sizeof(buf), "%lld",
-					use->scrub_args.devid) ||
-		    scrub_write_buf(fd, buf, ret) ||
-		    _SCRUB_KVWRITE(fd, buf, data_extents_scrubbed, use) ||
-		    _SCRUB_KVWRITE(fd, buf, tree_extents_scrubbed, use) ||
-		    _SCRUB_KVWRITE(fd, buf, data_bytes_scrubbed, use) ||
-		    _SCRUB_KVWRITE(fd, buf, tree_bytes_scrubbed, use) ||
-		    _SCRUB_KVWRITE(fd, buf, read_errors, use) ||
-		    _SCRUB_KVWRITE(fd, buf, csum_errors, use) ||
-		    _SCRUB_KVWRITE(fd, buf, verify_errors, use) ||
-		    _SCRUB_KVWRITE(fd, buf, no_csum, use) ||
-		    _SCRUB_KVWRITE(fd, buf, csum_discards, use) ||
-		    _SCRUB_KVWRITE(fd, buf, super_errors, use) ||
-		    _SCRUB_KVWRITE(fd, buf, malloc_errors, use) ||
-		    _SCRUB_KVWRITE(fd, buf, uncorrectable_errors, use) ||
-		    _SCRUB_KVWRITE(fd, buf, corrected_errors, use) ||
-		    _SCRUB_KVWRITE(fd, buf, last_physical, use) ||
-		    _SCRUB_KVWRITE_STATS(fd, buf, t_start, use) ||
-		    _SCRUB_KVWRITE_STATS(fd, buf, t_resumed, use) ||
-		    _SCRUB_KVWRITE_STATS(fd, buf, duration, use) ||
-		    _SCRUB_KVWRITE_STATS(fd, buf, canceled, use) ||
-		    _SCRUB_KVWRITE_STATS(fd, buf, finished, use) ||
-		    scrub_write_buf(fd, "\n", 1)) {
-			return -EOVERFLOW;
-		}
-	}
-
-	return 0;
-}
-
-static int scrub_write_progress(pthread_mutex_t *m, const char *fsid,
-				struct scrub_progress *data, int n)
-{
-	int ret;
-	int err;
-	int fd = 0;
-	int old;
-
-	ret = pthread_mutex_lock(m);
-	if (ret) {
-		err = -errno;
-		goto out;
-	}
-
-	ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old);
-	if (ret) {
-		err = -ret;
-		goto out;
-	}
-
-	fd = scrub_open_file_w(SCRUB_DATA_FILE, fsid, "tmp");
-	if (fd < 0) {
-		err = fd;
-		goto out;
-	}
-	err = scrub_write_file(fd, fsid, data, n);
-	if (err)
-		goto out;
-	err = scrub_rename_file(SCRUB_DATA_FILE, fsid, "tmp");
-	if (err)
-		goto out;
-
-out:
-	if (fd > 0) {
-		ret = close(fd);
-		if (ret)
-			err = -errno;
-	}
-
-	ret = pthread_mutex_unlock(m);
-	if (ret && !err)
-		err = -ret;
-
-	ret = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old);
-	if (ret && !err)
-		err = -ret;
-
-	return err;
-}
-
-static void *scrub_one_dev(void *ctx)
-{
-	struct scrub_progress *sp = ctx;
-	int ret;
-	struct timeval tv;
-
-	sp->stats.canceled = 0;
-	sp->stats.duration = 0;
-	sp->stats.finished = 0;
-
-	ret = ioctl(sp->fd, BTRFS_IOC_SCRUB, &sp->scrub_args);
-	gettimeofday(&tv, NULL);
-	sp->ret = ret;
-	sp->stats.duration = tv.tv_sec - sp->stats.t_start;
-	sp->stats.canceled = !!ret;
-	sp->ioctl_errno = errno;
-	ret = pthread_mutex_lock(&sp->progress_mutex);
-	if (ret)
-		return ERR_PTR(-ret);
-	sp->stats.finished = 1;
-	ret = pthread_mutex_unlock(&sp->progress_mutex);
-	if (ret)
-		return ERR_PTR(-ret);
-
-	return NULL;
-}
-
-static void *progress_one_dev(void *ctx)
-{
-	struct scrub_progress *sp = ctx;
-
-	sp->ret = ioctl(sp->fd, BTRFS_IOC_SCRUB_PROGRESS, &sp->scrub_args);
-	sp->ioctl_errno = errno;
-
-	return NULL;
-}
-
-static void *scrub_progress_cycle(void *ctx)
-{
-	int ret;
-	int old;
-	int i;
-	char fsid[37];
-	struct scrub_progress *sp;
-	struct scrub_progress *sp_last;
-	struct scrub_progress *sp_shared;
-	struct timeval tv;
-	struct scrub_progress_cycle *spc = ctx;
-	int ndev = spc->fi->num_devices;
-	int this = 1;
-	int last = 0;
-	int peer_fd = -1;
-	struct pollfd accept_poll_fd = {
-		.fd = spc->prg_fd,
-		.events = POLLIN,
-		.revents = 0,
-	};
-	struct pollfd write_poll_fd = {
-		.events = POLLOUT,
-		.revents = 0,
-	};
-	struct sockaddr_un peer;
-	socklen_t peer_size = sizeof(peer);
-
-	ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);
-	if (ret)
-		return ERR_PTR(-ret);
-
-	uuid_unparse(spc->fi->fsid, fsid);
-
-	for (i = 0; i < ndev; ++i) {
-		sp = &spc->progress[i];
-		sp_last = &spc->progress[i + ndev];
-		sp_shared = &spc->shared_progress[i];
-		sp->scrub_args.devid = sp_last->scrub_args.devid =
-						sp_shared->scrub_args.devid;
-		sp->fd = sp_last->fd = spc->fdmnt;
-		sp->stats.t_start = sp_last->stats.t_start =
-						sp_shared->stats.t_start;
-		sp->resumed = sp_last->resumed = sp_shared->resumed;
-		sp->skip = sp_last->skip = sp_shared->skip;
-		sp->stats.finished = sp_last->stats.finished =
-						sp_shared->stats.finished;
-	}
-
-	while (1) {
-		ret = poll(&accept_poll_fd, 1, 5 * 1000);
-		if (ret == -1)
-			return ERR_PTR(-errno);
-		if (ret)
-			peer_fd = accept(spc->prg_fd, (struct sockaddr *)&peer,
-					 &peer_size);
-		gettimeofday(&tv, NULL);
-		this = (this + 1)%2;
-		last = (last + 1)%2;
-		for (i = 0; i < ndev; ++i) {
-			sp = &spc->progress[this * ndev + i];
-			sp_last = &spc->progress[last * ndev + i];
-			sp_shared = &spc->shared_progress[i];
-			if (sp->stats.finished)
-				continue;
-			progress_one_dev(sp);
-			sp->stats.duration = tv.tv_sec - sp->stats.t_start;
-			if (!sp->ret)
-				continue;
-			if (sp->ioctl_errno != ENOTCONN &&
-			    sp->ioctl_errno != ENODEV)
-				return ERR_PTR(-sp->ioctl_errno);
-			/*
-			 * scrub finished or device removed, check the
-			 * finished flag. if unset, just use the last
-			 * result we got for the current write and go
-			 * on. flag should be set on next cycle, then.
-			 */
-			ret = pthread_mutex_lock(&sp_shared->progress_mutex);
-			if (ret)
-				return ERR_PTR(-ret);
-			if (!sp_shared->stats.finished) {
-				ret = pthread_mutex_unlock(
-						&sp_shared->progress_mutex);
-				if (ret)
-					return ERR_PTR(-ret);
-				memcpy(sp, sp_last, sizeof(*sp));
-				continue;
-			}
-			ret = pthread_mutex_unlock(&sp_shared->progress_mutex);
-			if (ret)
-				return ERR_PTR(-ret);
-			memcpy(sp, sp_shared, sizeof(*sp));
-			memcpy(sp_last, sp_shared, sizeof(*sp));
-		}
-		if (peer_fd != -1) {
-			write_poll_fd.fd = peer_fd;
-			ret = poll(&write_poll_fd, 1, 0);
-			if (ret == -1)
-				return ERR_PTR(-errno);
-			if (ret) {
-				ret = scrub_write_file(
-					peer_fd, fsid,
-					&spc->progress[this * ndev], ndev);
-				if (ret)
-					return ERR_PTR(ret);
-			}
-			close(peer_fd);
-			peer_fd = -1;
-		}
-		if (!spc->do_record)
-			continue;
-		ret = scrub_write_progress(spc->write_mutex, fsid,
-					   &spc->progress[this * ndev], ndev);
-		if (ret)
-			return ERR_PTR(ret);
-	}
-}
-
-static struct scrub_file_record *last_dev_scrub(
-		struct scrub_file_record *const *const past_scrubs, u64 devid)
-{
-	int i;
-
-	if (!past_scrubs || IS_ERR(past_scrubs))
-		return NULL;
-
-	for (i = 0; past_scrubs[i]; ++i)
-		if (past_scrubs[i]->devid == devid)
-			return past_scrubs[i];
-
-	return NULL;
-}
-
-static int scrub_device_info(int fd, u64 devid,
-			     struct btrfs_ioctl_dev_info_args *di_args)
-{
-	int ret;
-
-	di_args->devid = devid;
-	memset(&di_args->uuid, '\0', sizeof(di_args->uuid));
-
-	ret = ioctl(fd, BTRFS_IOC_DEV_INFO, di_args);
-	return ret ? -errno : 0;
-}
-
-static int scrub_fs_info(int fd, char *path,
-				struct btrfs_ioctl_fs_info_args *fi_args,
-				struct btrfs_ioctl_dev_info_args **di_ret)
-{
-	int ret = 0;
-	int ndevs = 0;
-	int i = 1;
-	struct btrfs_fs_devices *fs_devices_mnt = NULL;
-	struct btrfs_ioctl_dev_info_args *di_args;
-	char mp[BTRFS_PATH_NAME_MAX + 1];
-
-	memset(fi_args, 0, sizeof(*fi_args));
-
-	ret = ioctl(fd, BTRFS_IOC_FS_INFO, fi_args);
-	if (ret && errno == EINVAL) {
-		/* path is no mounted btrfs. try if it's a device */
-		ret = check_mounted_where(fd, path, mp, sizeof(mp),
-						&fs_devices_mnt);
-		if (!ret)
-			return -EINVAL;
-		if (ret < 0)
-			return ret;
-		fi_args->num_devices = 1;
-		fi_args->max_id = fs_devices_mnt->latest_devid;
-		i = fs_devices_mnt->latest_devid;
-		memcpy(fi_args->fsid, fs_devices_mnt->fsid, BTRFS_FSID_SIZE);
-		close(fd);
-		fd = open_file_or_dir(mp);
-		if (fd < 0)
-			return -errno;
-	} else if (ret) {
-		return -errno;
-	}
-
-	if (!fi_args->num_devices)
-		return 0;
-
-	di_args = *di_ret = malloc(fi_args->num_devices * sizeof(*di_args));
-	if (!di_args)
-		return -errno;
-
-	for (; i <= fi_args->max_id; ++i) {
-		BUG_ON(ndevs >= fi_args->num_devices);
-		ret = scrub_device_info(fd, i, &di_args[ndevs]);
-		if (ret == -ENODEV)
-			continue;
-		if (ret)
-			return ret;
-		++ndevs;
-	}
-
-	BUG_ON(ndevs == 0);
-
-	return 0;
-}
-
-int mkdir_p(char *path)
-{
-	int i;
-	int ret;
-
-	for (i = 1; i < strlen(path); ++i) {
-		if (path[i] != '/')
-			continue;
-		path[i] = '\0';
-		ret = mkdir(path, 0777);
-		if (ret && errno != EEXIST)
-			return 1;
-		path[i] = '/';
-	}
-
-	return 0;
-}
-
-static int scrub_start(int argc, char **argv, int resume)
-{
-	int fdmnt;
-	int prg_fd = -1;
-	int fdres = -1;
-	int ret;
-	pid_t pid;
-	int c;
-	int i;
-	int err = 0;
-	int e_uncorrectable = 0;
-	int e_correctable = 0;
-	int print_raw = 0;
-	char *path;
-	int do_background = 1;
-	int do_wait = 0;
-	int do_print = 0;
-	int do_quiet = 0;
-	int do_record = 1;
-	int readonly = 0;
-	int do_stats_per_dev = 0;
-	int n_start = 0;
-	int n_skip = 0;
-	int n_resume = 0;
-	struct btrfs_ioctl_fs_info_args fi_args;
-	struct btrfs_ioctl_dev_info_args *di_args = NULL;
-	struct scrub_progress *sp = NULL;
-	struct scrub_fs_stat fs_stat;
-	struct timeval tv;
-	struct sockaddr_un addr = {
-		.sun_family = AF_UNIX,
-	};
-	pthread_t *t_devs = NULL;
-	pthread_t t_prog;
-	pthread_attr_t t_attr;
-	struct scrub_file_record **past_scrubs = NULL;
-	struct scrub_file_record *last_scrub = NULL;
-	char *datafile = strdup(SCRUB_DATA_FILE);
-	char fsid[37];
-	char sock_path[BTRFS_PATH_NAME_MAX + 1] = "";
-	struct scrub_progress_cycle spc;
-	pthread_mutex_t spc_write_mutex = PTHREAD_MUTEX_INITIALIZER;
-	void *terr;
-	u64 devid;
-
-	optind = 1;
-	while ((c = getopt(argc, argv, "BdqrR")) != -1) {
-		switch (c) {
-		case 'B':
-			do_background = 0;
-			do_wait = 1;
-			do_print = 1;
-			break;
-		case 'd':
-			do_stats_per_dev = 1;
-			break;
-		case 'q':
-			do_quiet = 1;
-			break;
-		case 'r':
-			readonly = 1;
-			break;
-		case 'R':
-			print_raw = 1;
-			break;
-		case '?':
-		default:
-			fprintf(stderr, "ERROR: scrub args invalid.\n"
-					" -B  do not background\n"
-					" -d  stats per device (-B only)\n"
-					" -q  quiet\n"
-					" -r  read only mode\n");
-			return 1;
-		}
-	}
-
-	/* try to catch most error cases before forking */
-
-	if (optind + 1 != argc) {
-		fprintf(stderr, "ERROR: scrub start needs path as last "
-			"argument\n");
-		return 1;
-	}
-
-	spc.progress = NULL;
-	if (do_quiet && do_print)
-		do_print = 0;
-
-	if (mkdir_p(datafile)) {
-		ERR(!do_quiet, "WARNING: cannot create scrub data "
-			       "file, mkdir %s failed: %s. Status recording "
-			       "disabled\n", datafile, strerror(errno));
-		do_record = 0;
-	}
-	free(datafile);
-
-	path = argv[optind];
-
-	fdmnt = open_file_or_dir(path);
-	if (fdmnt < 0) {
-		ERR(!do_quiet, "ERROR: can't access '%s'\n", path);
-		return 12;
-	}
-
-	ret = scrub_fs_info(fdmnt, path, &fi_args, &di_args);
-	if (ret) {
-		ERR(!do_quiet, "ERROR: getting dev info for scrub failed: "
-		    "%s\n", strerror(-ret));
-		err = 1;
-		goto out;
-	}
-	if (!fi_args.num_devices) {
-		ERR(!do_quiet, "ERROR: no devices found\n");
-		err = 1;
-		goto out;
-	}
-
-	uuid_unparse(fi_args.fsid, fsid);
-	fdres = scrub_open_file_r(SCRUB_DATA_FILE, fsid);
-	if (fdres < 0 && fdres != -ENOENT) {
-		ERR(!do_quiet, "WARNING: failed to open status file: "
-		    "%s\n", strerror(-fdres));
-	} else if (fdres >= 0) {
-		past_scrubs = scrub_read_file(fdres, !do_quiet);
-		if (IS_ERR(past_scrubs))
-			ERR(!do_quiet, "WARNING: failed to read status file: "
-			    "%s\n", strerror(-PTR_ERR(past_scrubs)));
-		close(fdres);
-	}
-
-	t_devs = malloc(fi_args.num_devices * sizeof(*t_devs));
-	sp = calloc(fi_args.num_devices, sizeof(*sp));
-	spc.progress = calloc(fi_args.num_devices * 2, sizeof(*spc.progress));
-
-	if (!t_devs || !sp || !spc.progress) {
-		ERR(!do_quiet, "ERROR: scrub failed: %s", strerror(errno));
-		err = 1;
-		goto out;
-	}
-
-	ret = pthread_attr_init(&t_attr);
-	if (ret) {
-		ERR(!do_quiet, "ERROR: pthread_attr_init failed: %s\n",
-		    strerror(ret));
-		err = 1;
-		goto out;
-	}
-
-	for (i = 0; i < fi_args.num_devices; ++i) {
-		devid = di_args[i].devid;
-		ret = pthread_mutex_init(&sp[i].progress_mutex, NULL);
-		if (ret) {
-			ERR(!do_quiet, "ERROR: pthread_mutex_init failed: "
-			    "%s\n", strerror(ret));
-			err = 1;
-			goto out;
-		}
-		last_scrub = last_dev_scrub(past_scrubs, devid);
-		sp[i].scrub_args.devid = devid;
-		sp[i].fd = fdmnt;
-		if (resume && last_scrub && (last_scrub->stats.canceled ||
-					     !last_scrub->stats.finished)) {
-			++n_resume;
-			sp[i].scrub_args.start = last_scrub->p.last_physical;
-			sp[i].resumed = last_scrub;
-		} else if (resume) {
-			++n_skip;
-			sp[i].skip = 1;
-			sp[i].resumed = last_scrub;
-			continue;
-		} else {
-			++n_start;
-			sp[i].scrub_args.start = 0ll;
-			sp[i].resumed = NULL;
-		}
-		sp[i].skip = 0;
-		sp[i].scrub_args.end = (u64)-1ll;
-		sp[i].scrub_args.flags = readonly ? BTRFS_SCRUB_READONLY : 0;
-	}
-
-	if (!n_start && !n_resume) {
-		if (!do_quiet)
-			printf("scrub: nothing to resume for %s, fsid %s\n",
-			       path, fsid);
-		err = 0;
-		goto out;
-	}
-
-	ret = prg_fd = socket(AF_UNIX, SOCK_STREAM, 0);
-	while (ret != -1) {
-		ret = scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH, fsid, NULL,
-					sock_path, sizeof(sock_path));
-		/* ignore EOVERFLOW, try using a shorter path for the socket */
-		addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
-		strncpy(addr.sun_path, sock_path, sizeof(addr.sun_path) - 1);
-		ret = bind(prg_fd, (struct sockaddr *)&addr, sizeof(addr));
-		if (ret != -1 || errno != EADDRINUSE)
-			break;
-		/*
-		 * bind failed with EADDRINUSE. so let's see if anyone answers
-		 * when we make a call to the socket ...
-		 */
-		ret = connect(prg_fd, (struct sockaddr *)&addr, sizeof(addr));
-		if (!ret || errno != ECONNREFUSED) {
-			/* ... yes, so scrub must be running. error out */
-			fprintf(stderr, "ERROR: scrub already running\n");
-			close(prg_fd);
-			goto out;
-		}
-		/*
-		 * ... no, this means someone left us alone with an unused
-		 * socket in the file system. remove it and try again.
-		 */
-		ret = unlink(sock_path);
-	}
-	if (ret != -1)
-		ret = listen(prg_fd, 100);
-	if (ret == -1) {
-		ERR(!do_quiet, "WARNING: failed to open the progress status "
-		    "socket at %s: %s. Progress cannot be queried\n",
-		    sock_path[0] ? sock_path : SCRUB_PROGRESS_SOCKET_PATH,
-		    strerror(errno));
-		if (prg_fd != -1) {
-			close(prg_fd);
-			prg_fd = -1;
-			if (sock_path[0])
-				unlink(sock_path);
-		}
-	}
-
-	if (do_record) {
-		/* write all-zero progress file for a start */
-		ret = scrub_write_progress(&spc_write_mutex, fsid, sp,
-					   fi_args.num_devices);
-		if (ret) {
-			ERR(!do_quiet, "WARNING: failed to write the progress "
-			    "status file: %s. Status recording disabled\n",
-			    strerror(-ret));
-			do_record = 0;
-		}
-	}
-
-	if (do_background) {
-		pid = fork();
-		if (pid == -1) {
-			ERR(!do_quiet, "ERROR: cannot scrub, fork failed: "
-					"%s\n", strerror(errno));
-			err = 1;
-			goto out;
-		}
-
-		if (pid) {
-			int stat;
-			scrub_handle_sigint_parent();
-			if (!do_quiet)
-				printf("scrub %s on %s, fsid %s (pid=%d)\n",
-				       n_start ? "started" : "resumed",
-				       path, fsid, pid);
-			if (!do_wait) {
-				err = 0;
-				goto out;
-			}
-			ret = wait(&stat);
-			if (ret != pid) {
-				ERR(!do_quiet, "ERROR: wait failed: (ret=%d) "
-				    "%s\n", ret, strerror(errno));
-				err = 1;
-				goto out;
-			}
-			if (!WIFEXITED(stat) || WEXITSTATUS(stat)) {
-				ERR(!do_quiet, "ERROR: scrub process failed\n");
-				err = WIFEXITED(stat) ? WEXITSTATUS(stat) : -1;
-				goto out;
-			}
-			err = 0;
-			goto out;
-		}
-	}
-
-	scrub_handle_sigint_child(fdmnt);
-
-	for (i = 0; i < fi_args.num_devices; ++i) {
-		if (sp[i].skip) {
-			sp[i].scrub_args.progress = sp[i].resumed->p;
-			sp[i].stats = sp[i].resumed->stats;
-			sp[i].ret = 0;
-			sp[i].stats.finished = 1;
-			continue;
-		}
-		devid = di_args[i].devid;
-		gettimeofday(&tv, NULL);
-		sp[i].stats.t_start = tv.tv_sec;
-		ret = pthread_create(&t_devs[i], &t_attr,
-					scrub_one_dev, &sp[i]);
-		if (ret) {
-			if (do_print)
-				fprintf(stderr, "ERROR: creating "
-					"scrub_one_dev[%llu] thread failed: "
-					"%s\n", devid, strerror(ret));
-			err = 1;
-			goto out;
-		}
-	}
-
-	spc.fdmnt = fdmnt;
-	spc.prg_fd = prg_fd;
-	spc.do_record = do_record;
-	spc.write_mutex = &spc_write_mutex;
-	spc.shared_progress = sp;
-	spc.fi = &fi_args;
-	ret = pthread_create(&t_prog, &t_attr, scrub_progress_cycle, &spc);
-	if (ret) {
-		if (do_print)
-			fprintf(stderr, "ERROR: creating progress thread "
-				"failed: %s\n", strerror(ret));
-		err = 1;
-		goto out;
-	}
-
-	err = 0;
-	for (i = 0; i < fi_args.num_devices; ++i) {
-		if (sp[i].skip)
-			continue;
-		devid = di_args[i].devid;
-		ret = pthread_join(t_devs[i], NULL);
-		if (ret) {
-			if (do_print)
-				fprintf(stderr, "ERROR: pthread_join failed "
-					"for scrub_one_dev[%llu]: %s\n", devid,
-					strerror(ret));
-			++err;
-			continue;
-		}
-		if (sp[i].ret && sp[i].ioctl_errno == ENODEV) {
-			if (do_print)
-				fprintf(stderr, "WARNING: device %lld not "
-					"present\n", devid);
-			continue;
-		}
-		if (sp[i].ret && sp[i].ioctl_errno == ECANCELED) {
-			++err;
-		} else if (sp[i].ret) {
-			if (do_print)
-				fprintf(stderr, "ERROR: scrubbing %s failed "
-					"for device id %lld (%s)\n", path,
-					devid, strerror(sp[i].ioctl_errno));
-			++err;
-			continue;
-		}
-		if (sp[i].scrub_args.progress.uncorrectable_errors > 0)
-			e_uncorrectable++;
-		if (sp[i].scrub_args.progress.corrected_errors > 0
-		    || sp[i].scrub_args.progress.unverified_errors > 0)
-			e_correctable++;
-	}
-
-	if (do_print) {
-		const char *append = "done";
-		if (!do_stats_per_dev)
-			init_fs_stat(&fs_stat);
-		for (i = 0; i < fi_args.num_devices; ++i) {
-			if (do_stats_per_dev) {
-				print_scrub_dev(&di_args[i],
-						&sp[i].scrub_args.progress,
-						print_raw,
-						sp[i].ret ? "canceled" : "done",
-						&sp[i].stats);
-			} else {
-				if (sp[i].ret)
-					append = "canceled";
-				add_to_fs_stat(&sp[i].scrub_args.progress,
-						&sp[i].stats, &fs_stat);
-			}
-		}
-		if (!do_stats_per_dev) {
-			printf("scrub %s for %s\n", append, fsid);
-			print_fs_stat(&fs_stat, print_raw);
-		}
-	}
-
-	ret = pthread_cancel(t_prog);
-	if (!ret)
-		ret = pthread_join(t_prog, &terr);
-	if (do_print && ret) {
-		fprintf(stderr, "ERROR: progress thead handling failed: %s\n",
-			strerror(ret));
-	}
-
-	if (do_print && terr && terr != PTHREAD_CANCELED) {
-		fprintf(stderr, "ERROR: recording progress "
-			"failed: %s\n", strerror(-PTR_ERR(terr)));
-	}
-
-	if (do_record) {
-		ret = scrub_write_progress(&spc_write_mutex, fsid, sp,
-					   fi_args.num_devices);
-		if (ret && do_print) {
-			fprintf(stderr, "ERROR: failed to record the result: "
-				"%s\n", strerror(-ret));
-		}
-	}
-
-	scrub_handle_sigint_child(-1);
-
-out:
-	free_history(past_scrubs);
-	free(di_args);
-	free(t_devs);
-	free(sp);
-	free(spc.progress);
-	if (prg_fd > -1) {
-		close(prg_fd);
-		if (sock_path[0])
-			unlink(sock_path);
-	}
-	close(fdmnt);
-
-	if (err)
-		return 1;
-	if (e_correctable)
-		return 7;
-	if (e_uncorrectable)
-		return 8;
-	return 0;
-}
-
-int do_scrub_start(int argc, char **argv)
-{
-	return scrub_start(argc, argv, 0);
-}
-
-int do_scrub_resume(int argc, char **argv)
-{
-	return scrub_start(argc, argv, 1);
-}
-
-int do_scrub_cancel(int argc, char **argv)
-{
-	char *path = argv[1];
-	int ret;
-	int fdmnt;
-	int err;
-	char mp[BTRFS_PATH_NAME_MAX + 1];
-	struct btrfs_fs_devices *fs_devices_mnt = NULL;
-
-	fdmnt = open_file_or_dir(path);
-	if (fdmnt < 0) {
-		fprintf(stderr, "ERROR: scrub cancel failed\n");
-		return 12;
-	}
-
-again:
-	ret = ioctl(fdmnt, BTRFS_IOC_SCRUB_CANCEL, NULL);
-	err = errno;
-	close(fdmnt);
-
-	if (ret && err == EINVAL) {
-		/* path is no mounted btrfs. try if it's a device */
-		ret = check_mounted_where(fdmnt, path, mp, sizeof(mp),
-					  &fs_devices_mnt);
-		close(fdmnt);
-		if (ret) {
-			fdmnt = open_file_or_dir(mp);
-			if (fdmnt >= 0) {
-				path = mp;
-				goto again;
-			}
-		}
-	}
-
-	if (ret) {
-		fprintf(stderr, "ERROR: scrub cancel failed on %s: %s\n", path,
-			err == ENOTCONN ? "not running" : strerror(errno));
-		return 1;
-	}
-
-	printf("scrub cancelled\n");
-
-	return 0;
-}
-
-int do_scrub_status(int argc, char **argv)
-{
-
-	char *path;
-	struct btrfs_ioctl_fs_info_args fi_args;
-	struct btrfs_ioctl_dev_info_args *di_args = NULL;
-	struct scrub_file_record **past_scrubs = NULL;
-	struct scrub_file_record *last_scrub;
-	struct scrub_fs_stat fs_stat;
-	struct sockaddr_un addr = {
-		.sun_family = AF_UNIX,
-	};
-	int ret;
-	int fdmnt;
-	int i;
-	optind = 1;
-	int print_raw = 0;
-	int do_stats_per_dev = 0;
-	char c;
-	char fsid[37];
-	int fdres = -1;
-	int err = 0;
-
-	while ((c = getopt(argc, argv, "dR")) != -1) {
-		switch (c) {
-		case 'd':
-			do_stats_per_dev = 1;
-			break;
-		case 'R':
-			print_raw = 1;
-			break;
-		case '?':
-		default:
-			fprintf(stderr, "ERROR: scrub status args invalid.\n"
-					" -d  stats per device\n");
-			return 1;
-		}
-	}
-
-	if (optind + 1 != argc) {
-		fprintf(stderr, "ERROR: scrub status needs path as last "
-			"argument\n");
-		return 1;
-	}
-
-	path = argv[optind];
-
-	fdmnt = open_file_or_dir(path);
-	if (fdmnt < 0) {
-		fprintf(stderr, "ERROR: can't access to '%s'\n", path);
-		return 12;
-	}
-
-	ret = scrub_fs_info(fdmnt, path, &fi_args, &di_args);
-	if (ret) {
-		fprintf(stderr, "ERROR: getting dev info for scrub failed: "
-				"%s\n", strerror(-ret));
-		err = 1;
-		goto out;
-	}
-	if (!fi_args.num_devices) {
-		fprintf(stderr, "ERROR: no devices found\n");
-		err = 1;
-		goto out;
-	}
-
-	uuid_unparse(fi_args.fsid, fsid);
-
-	fdres = socket(AF_UNIX, SOCK_STREAM, 0);
-	if (fdres == -1) {
-		fprintf(stderr, "ERROR: failed to create socket to "
-			"receive progress information: %s\n",
-			strerror(errno));
-		err = 1;
-		goto out;
-	}
-	scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH, fsid,
-			NULL, addr.sun_path, sizeof(addr.sun_path));
-	/* ignore EOVERFLOW, just use shorter name and hope for the best */
-	addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
-	ret = connect(fdres, (struct sockaddr *)&addr, sizeof(addr));
-	if (ret == -1) {
-		fdres = scrub_open_file_r(SCRUB_DATA_FILE, fsid);
-		if (fdres < 0 && fdres != -ENOENT) {
-			fprintf(stderr, "WARNING: failed to open status file: "
-				"%s\n", strerror(-fdres));
-			err = 1;
-			goto out;
-		}
-	}
-
-	if (fdres >= 0) {
-		past_scrubs = scrub_read_file(fdres, 1);
-		if (IS_ERR(past_scrubs))
-			fprintf(stderr, "WARNING: failed to read status: %s\n",
-				strerror(-PTR_ERR(past_scrubs)));
-	}
-
-	printf("scrub status for %s\n", fsid);
-
-	if (do_stats_per_dev) {
-		for (i = 0; i < fi_args.num_devices; ++i) {
-			last_scrub = last_dev_scrub(past_scrubs,
-							di_args[i].devid);
-			if (!last_scrub) {
-				print_scrub_dev(&di_args[i], NULL, print_raw,
-						NULL, NULL);
-				continue;
-			}
-			print_scrub_dev(&di_args[i], &last_scrub->p, print_raw,
-					last_scrub->stats.finished ?
-							"history" : "status",
-					&last_scrub->stats);
-		}
-	} else {
-		init_fs_stat(&fs_stat);
-		for (i = 0; i < fi_args.num_devices; ++i) {
-			last_scrub = last_dev_scrub(past_scrubs,
-							di_args[i].devid);
-			if (!last_scrub)
-				continue;
-			add_to_fs_stat(&last_scrub->p, &last_scrub->stats,
-					&fs_stat);
-		}
-		print_fs_stat(&fs_stat, print_raw);
-	}
-
-out:
-	free_history(past_scrubs);
-	free(di_args);
-	close(fdmnt);
-	if (fdres > -1)
-		close(fdres);
-
-	return err;
-}
diff -Nru btrfs-tools-0.19+20111121/show-blocks btrfs-tools-0.19+20120328/show-blocks
--- btrfs-tools-0.19+20111121/show-blocks	2011-11-18 19:53:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/show-blocks	1970-01-01 00:00:00.000000000 +0000
@@ -1,325 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2007 Oracle.  All rights reserved.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public
-# License v2 as published by the Free Software Foundation.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public
-# License along with this program; if not, write to the
-# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-# Boston, MA 021110-1307, USA.
-#
-import sys, os, signal, time, commands, tempfile, random
-
-# numpy seems to override random() with something else.  Instantiate our
-# own here
-randgen = random.Random()
-randgen.seed(50)
-
-from optparse import OptionParser
-from matplotlib import rcParams
-from matplotlib.font_manager import fontManager, FontProperties
-import numpy
-
-rcParams['numerix'] = 'numpy'
-rcParams['backend'] = 'Agg'
-rcParams['interactive'] = 'False'
-from pylab import *
-
-class AnnoteFinder:
-  """
-  callback for matplotlib to display an annotation when points are clicked on.  The
-  point which is closest to the click and within xtol and ytol is identified.
-    
-  Register this function like this:
-    
-  scatter(xdata, ydata)
-  af = AnnoteFinder(xdata, ydata, annotes)
-  connect('button_press_event', af)
-  """
-
-  def __init__(self, axis=None):
-    if axis is None:
-      self.axis = gca()
-    else:
-      self.axis= axis
-    self.drawnAnnotations = {}
-    self.links = []
-    
-  def clear(self):
-    for k in self.drawnAnnotations.keys():
-        self.drawnAnnotations[k].set_visible(False)
-
-  def __call__(self, event):
-    if event.inaxes:
-      if event.button != 1:
-        self.clear()
-        draw()
-        return
-      clickX = event.xdata
-      clickY = event.ydata
-      if (self.axis is None) or (self.axis==event.inaxes):
-        self.drawAnnote(event.inaxes, clickX, clickY)
-    
-  def drawAnnote(self, axis, x, y):
-    """
-    Draw the annotation on the plot
-    """
-    if self.drawnAnnotations.has_key((x,y)):
-      markers = self.drawnAnnotations[(x,y)]
-      markers.set_visible(not markers.get_visible())
-      draw()
-    else:
-      t = axis.text(x,y, "(%3.2f, %3.2f)"%(x,y), bbox=dict(facecolor='red',
-                    alpha=0.8))
-      self.drawnAnnotations[(x,y)] = t
-      draw()
-
-def loaddata(fh,delimiter=None, converters=None):
-
-    #14413824 8192 extent back ref root 5 gen 10 owner 282 num_refs 1
-    def iter(fh, delimiter, converters):
-        global total_data
-        global total_metadata
-        for i,line in enumerate(fh):
-            line = line.split(' ')
-            start = float(line[0])
-            len = float(line[1])
-            owner = float(line[10])
-            root = float(line[6])
-            if owner <= 255:
-                total_metadata += int(len)
-            else:
-                total_data += int(len)
-            if start < zoommin or (zoommax != 0 and start > zoommax):
-                continue
-            yield start
-            yield len
-            yield owner
-            yield root
-    X = numpy.fromiter(iter(fh, delimiter, converters), dtype=float)
-    return X
-
-def run_debug_tree(device):
-    p = os.popen('btrfs-debug-tree -e ' + device)
-    data = loaddata(p)
-    return data
-
-def shapeit(X):
-    lines = len(X) / 4
-    X.shape = (lines, 4)
-
-def line_picker(line, mouseevent):
-    if mouseevent.xdata is None: return False, dict()
-    print "%d %d\n", mouseevent.xdata, mouseevent.ydata
-    return False, dict()
-
-def xycalc(byte):
-    byte = byte / bytes_per_cell
-    yval = floor(byte / num_cells)
-    xval = byte % num_cells
-    return (xval, yval + 1)
-
-# record the color used for each root the first time we find it
-root_colors = {}
-# there are lots of good colormaps to choose from
-# http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps
-#
-meta_cmap = get_cmap("gist_ncar")
-data_done = False
-
-def plotone(a, xvals, yvals, owner, root, lines, labels):
-    global data_done
-    add_label = False
-
-    if owner:
-        if options.meta_only:
-            return
-        color = "blue"
-        label = "Data"
-        if not data_done:
-            add_label = True
-            data_done = True
-    else:
-        if options.data_only:
-            return
-        if root not in root_colors:
-            color = meta_cmap(randgen.random())
-            label = "Meta %d" % int(root)
-            root_colors[root] = (color, label)
-            add_label = True
-        else:
-            color, label = root_colors[root]
-
-    plotlines = a.plot(xvals, yvals, 's', color=color, mfc=color, mec=color,
-           markersize=.23, label=label)
-    if add_label:
-        lines += plotlines
-        labels.append(label)
-        print "add label %s" % label
-
-def parse_zoom():
-    def parse_num(s):
-        mult = 1
-        c = s.lower()[-1]
-        if c == 't':
-            mult = 1024 * 1024 * 1024 * 1024
-        elif c == 'g':
-            mult = 1024 * 1024 * 1024
-        elif c == 'm':
-            mult = 1024 * 1024
-        elif c == 'k':
-            mult = 1024
-        else:
-            c = None
-        if c:
-            num = int(s[:-1]) * mult
-        else:
-            num = int(s)
-        return num
-        
-    if not options.zoom:
-        return (0, 0)
-
-    vals = options.zoom.split(':')
-    if len(vals) != 2:
-        sys.stderr.write("warning: unable to parse zoom %s\n" % options.zoom)
-        return (0, 0)
-    zoommin = parse_num(vals[0])
-    zoommax = parse_num(vals[1])
-    return (zoommin, zoommax)
-
-usage = "usage: %prog [options]"
-parser = OptionParser(usage=usage)
-parser.add_option("-d", "--device", help="Btrfs device", default="")
-parser.add_option("-i", "--input-file", help="debug-tree data", default="")
-parser.add_option("-o", "--output", help="Output file", default="blocks.png")
-parser.add_option("-z", "--zoom", help="Zoom", default=None)
-parser.add_option("", "--data-only", help="Only print data blocks",
-                  default=False, action="store_true")
-parser.add_option("", "--meta-only", help="Only print metadata blocks",
-                  default=False, action="store_true")
-
-(options,args) = parser.parse_args()
-
-if not options.device and not options.input_file:
-    parser.print_help()
-    sys.exit(1)
-
-zoommin, zoommax = parse_zoom()
-total_data = 0
-total_metadata = 0
-
-if options.device:
-    data = run_debug_tree(options.device)
-elif options.input_file:
-    data = loaddata(file(options.input_file))
-shapeit(data)
-
-# try to drop out the least common data points by creating
-# a historgram of the sectors seen.
-sectors = data[:,0]
-sizes = data[:,1]
-datalen = len(data)
-sectormax = numpy.max(sectors)
-sectormin = 0
-num_cells = 800
-total_cells = num_cells * num_cells
-byte_range = sectormax - sectormin
-bytes_per_cell = byte_range / total_cells
-
-f = figure(figsize=(8,6))
-
-# Throughput goes at the botoom
-a = subplot(1, 1, 1)
-subplots_adjust(right=0.7)
-datai = 0
-xvals = []
-yvals = []
-last_owner = 0
-last_root = 0
-lines = []
-labels = []
-while datai < datalen:
-    row = data[datai]
-    datai += 1
-    byte = row[0]
-    size = row[1]
-    owner = row[2]
-    root = row[3]
-
-    if owner <= 255:
-        owner = 0
-    else:
-        owner = 1
-
-    if len(xvals) and (owner != last_owner or last_root != root):
-        plotone(a, xvals, yvals, last_owner, last_root, lines, labels)
-        xvals = []
-        yvals = []
-    cell = 0
-    while cell < size:
-        xy = xycalc(byte)
-        byte += bytes_per_cell
-        cell += bytes_per_cell
-        if xy:
-            xvals.append(xy[0])
-            yvals.append(xy[1])
-    last_owner = owner
-    last_root = root
-
-if xvals:
-    plotone(a, xvals, yvals, last_owner, last_root, lines, labels)
-
-# make sure the final second goes on the x axes
-ticks = []
-a.set_xticks(ticks)
-ticks = a.get_yticks()
-
-first_tick = ticks[1] * bytes_per_cell * num_cells
-if first_tick > 1024 * 1024 * 1024 * 1024:
-    scale = 1024 * 1024 * 1024 * 1024;
-    scalestr = "TB"
-elif first_tick > 1024 * 1024 * 1024:
-    scale = 1024 * 1024 * 1024;
-    scalestr = "GB"
-elif first_tick > 1024 * 1024:
-    scale = 1024 * 1024;
-    scalestr = "MB"
-elif first_tick > 1024:
-    scale = 1024;
-    scalestr = "KB"
-else:
-    scalestr = "Bytes"
-    scale = 1
-
-ylabels = [ str(int((x * bytes_per_cell * num_cells) / scale)) for x in ticks ]
-a.set_yticklabels(ylabels)
-a.set_ylabel('Disk offset (%s)' % scalestr)
-a.set_xlim(0, num_cells)
-a.set_title('Blocks')
-
-a.legend(lines, labels, loc=(1.05, 0.8), shadow=True, pad=0.1, numpoints=1,
-              handletextsep = 0.005,
-              labelsep = 0.01,
-              markerscale=10,
-              prop=FontProperties(size='x-small') )
-
-if total_data == 0:
-    percent_meta = 100
-else:
-    percent_meta = (float(total_metadata) / float(total_data)) * 100
-
-print "Total metadata bytes %d data %d ratio %.3f" % (total_metadata,
-                                                    total_data, percent_meta)
-print "saving graph to %s" % options.output
-savefig(options.output, orientation='landscape')
-show()
-
diff -Nru btrfs-tools-0.19+20111121/utils.c btrfs-tools-0.19+20120328/utils.c
--- btrfs-tools-0.19+20111121/utils.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/utils.c	2012-05-05 18:22:58.000000000 +0000
@@ -1034,7 +1034,12 @@
 int btrfs_scan_for_fsid(struct btrfs_fs_devices *fs_devices, u64 total_devs,
 			int run_ioctls)
 {
-	return btrfs_scan_one_dir("/dev", run_ioctls);
+	int ret;
+
+	ret = btrfs_scan_block_devices(run_ioctls);
+	if (ret)
+		ret = btrfs_scan_one_dir("/dev", run_ioctls);
+	return ret;
 }
 
 int btrfs_device_already_in_root(struct btrfs_root *root, int fd,
@@ -1133,7 +1138,10 @@
 	int i;
 	char buf[1024];
 	char fullpath[110];
+	int scans = 0;
+	int special;
 
+scan_again:
 	proc_partitions = fopen("/proc/partitions","r");
 	if (!proc_partitions) {
 		fprintf(stderr, "Unable to open '/proc/partitions' for scanning\n");
@@ -1149,8 +1157,23 @@
 
 	strcpy(fullpath,"/dev/");
 	while(fgets(buf, 1023, proc_partitions)) {
-
 		i = sscanf(buf," %*d %*d %*d %99s", fullpath+5);
+
+		/*
+		 * multipath and MD devices may register as a btrfs filesystem
+		 * both through the original block device and through
+		 * the special (/dev/mapper or /dev/mdX) entry.
+		 * This scans the special entries last
+		 */
+		special = strncmp(fullpath, "/dev/dm-", strlen("/dev/dm-")) == 0;
+		if (!special)
+			special = strncmp(fullpath, "/dev/md", strlen("/dev/md")) == 0;
+
+		if (scans == 0 && special)
+			continue;
+		if (scans > 0 && !special)
+			continue;
+
 		ret = lstat(fullpath, &st);
 		if (ret < 0) {
 			fprintf(stderr, "failed to stat %s\n", fullpath);
@@ -1175,6 +1198,11 @@
 	}
 
 	fclose(proc_partitions);
+
+	if (scans == 0) {
+		scans++;
+		goto scan_again;
+	}
 	return 0;
 }
 
diff -Nru btrfs-tools-0.19+20111121/volumes.c btrfs-tools-0.19+20120328/volumes.c
--- btrfs-tools-0.19+20111121/volumes.c	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/volumes.c	2012-05-05 18:22:58.000000000 +0000
@@ -35,18 +35,6 @@
 	u64 physical;
 };
 
-struct map_lookup {
-	struct cache_extent ce;
-	u64 type;
-	int io_align;
-	int io_width;
-	int stripe_len;
-	int sector_size;
-	int num_stripes;
-	int sub_stripes;
-	struct btrfs_bio_stripe stripes[];
-};
-
 #define map_lookup_size(n) (sizeof(struct map_lookup) + \
 			    (sizeof(struct btrfs_bio_stripe) * (n)))
 
@@ -128,7 +116,14 @@
 			btrfs_stack_device_bytes_used(&disk_super->dev_item);
 		list_add(&device->dev_list, &fs_devices->devices);
 		device->fs_devices = fs_devices;
-	}
+	} else if (!device->name || strcmp(device->name, path)) {
+		char *name = strdup(path);
+                if (!name)
+                        return -ENOMEM;
+                kfree(device->name);
+                device->name = name;
+        }
+
 
 	if (found_transid > fs_devices->latest_trans) {
 		fs_devices->latest_devid = devid;
diff -Nru btrfs-tools-0.19+20111121/volumes.h btrfs-tools-0.19+20120328/volumes.h
--- btrfs-tools-0.19+20111121/volumes.h	2011-11-18 19:54:07.000000000 +0000
+++ btrfs-tools-0.19+20120328/volumes.h	2012-05-05 18:22:58.000000000 +0000
@@ -18,6 +18,7 @@
 
 #ifndef __BTRFS_VOLUMES_
 #define __BTRFS_VOLUMES_
+
 struct btrfs_device {
 	struct list_head dev_list;
 	struct btrfs_root *dev_root;
@@ -88,9 +89,52 @@
 	struct btrfs_bio_stripe stripes[];
 };
 
+struct map_lookup {
+	struct cache_extent ce;
+	u64 type;
+	int io_align;
+	int io_width;
+	int stripe_len;
+	int sector_size;
+	int num_stripes;
+	int sub_stripes;
+	struct btrfs_bio_stripe stripes[];
+};
+
 #define btrfs_multi_bio_size(n) (sizeof(struct btrfs_multi_bio) + \
 			    (sizeof(struct btrfs_bio_stripe) * (n)))
 
+/*
+ * Restriper's general type filter
+ */
+#define BTRFS_BALANCE_DATA		(1ULL << 0)
+#define BTRFS_BALANCE_SYSTEM		(1ULL << 1)
+#define BTRFS_BALANCE_METADATA		(1ULL << 2)
+
+#define BTRFS_BALANCE_TYPE_MASK		(BTRFS_BALANCE_DATA |	    \
+					 BTRFS_BALANCE_SYSTEM |	    \
+					 BTRFS_BALANCE_METADATA)
+
+#define BTRFS_BALANCE_FORCE		(1ULL << 3)
+#define BTRFS_BALANCE_RESUME		(1ULL << 4)
+
+/*
+ * Balance filters
+ */
+#define BTRFS_BALANCE_ARGS_PROFILES	(1ULL << 0)
+#define BTRFS_BALANCE_ARGS_USAGE	(1ULL << 1)
+#define BTRFS_BALANCE_ARGS_DEVID	(1ULL << 2)
+#define BTRFS_BALANCE_ARGS_DRANGE	(1ULL << 3)
+#define BTRFS_BALANCE_ARGS_VRANGE	(1ULL << 4)
+
+/*
+ * Profile changing flags.  When SOFT is set we won't relocate chunk if
+ * it already has the target profile (even though it may be
+ * half-filled).
+ */
+#define BTRFS_BALANCE_ARGS_CONVERT	(1ULL << 8)
+#define BTRFS_BALANCE_ARGS_SOFT		(1ULL << 9)
+
 int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
 			   struct btrfs_device *device,
 			   u64 chunk_tree, u64 chunk_objectid,