[packages/btrfs-progs] up to 3.12; drop all patches

glen glen at pld-linux.org
Thu Jan 16 22:57:56 CET 2014


commit 7172bf1cdc82f892d7a59f2af645c8ce81b55a3c
Author: Elan Ruusamäe <glen at delfi.ee>
Date:   Thu Jan 16 23:55:45 2014 +0200

    up to 3.12; drop all patches
    
    if you need any of them, feel free to rebase them to current codebase
    they were all copied from fedora. so...

 btrfs-progs-build-everything.patch |   12 -
 btrfs-progs-build-fixes.patch      |   32 -
 btrfs-progs-fix-labels.patch       |   25 -
 btrfs-progs-fix-return-value.patch |   32 -
 btrfs-progs-upstream.patch         | 3752 ------------------------------------
 btrfs-progs-valgrind.patch         |  247 ---
 btrfs-progs.spec                   |   81 +-
 7 files changed, 58 insertions(+), 4123 deletions(-)
---
diff --git a/btrfs-progs.spec b/btrfs-progs.spec
index 7f5cf43..e18b51d 100644
--- a/btrfs-progs.spec
+++ b/btrfs-progs.spec
@@ -1,19 +1,19 @@
 Summary:	Utilities belonging to the btrfs filesystem
 Name:		btrfs-progs
-Version:	0.19
-Release:	2
+Version:	3.12
+Release:	1
 License:	GPL v2
 Group:		Applications/System
-Source0:	http://www.kernel.org/pub/linux/kernel/people/mason/btrfs/%{name}-%{version}.tar.bz2
-# Source0-md5:	5854728d080cc76f21a83bdc99b6ddaa
-Patch0:		%{name}-fix-labels.patch
-Patch1:		%{name}-build-everything.patch
-Patch2:		%{name}-valgrind.patch
-Patch3:		%{name}-fix-return-value.patch
-Patch4:		%{name}-build-fixes.patch
-Patch5:		%{name}-upstream.patch
+Source0:	https://www.kernel.org/pub/linux/kernel/people/mason/btrfs-progs/%{name}-v%{version}.tar.xz
+# Source0-md5:	cd96bb73acd864e577cddba5fe310650
 URL:		http://btrfs.wiki.kernel.org/
+BuildRequires:	acl-devel
+BuildRequires:	e2fsprogs-devel
+BuildRequires:	libblkid-devel
 BuildRequires:	libuuid-devel
+BuildRequires:	lzo-devel
+BuildRequires:	tar >= 1:1.22
+BuildRequires:	xz
 BuildRequires:	zlib-devel
 BuildRoot:	%{tmpdir}/%{name}-%{version}-root-%(id -u -n)
 
@@ -24,39 +24,74 @@ Btrfs is a new copy on write filesystem for Linux aimed at
 implementing advanced features while focusing on fault tolerance,
 repair and easy administration.
 
-%prep
-%setup -q
-%patch0 -p1
-%patch2 -p1
-%patch3 -p1
-%patch4 -p1
-%patch5 -p1
-%patch1 -p1
+%package devel
+Summary:	btrfs filesystem-specific libraries and headers
+Group:		Development/Libraries
+Requires:	%{name} = %{version}-%{release}
+
+%description devel
+btrfs-progs-devel contains the libraries and header files needed to
+develop btrfs filesystem-specific programs.
 
-sed -i -e 's#gcc#$(CC)#g' Makefile
+You should install btrfs-progs-devel if you want to develop btrfs
+filesystem-specific programs.
+
+%prep
+%setup -q -n %{name}-v%{version}
 
 %build
 %{__make} \
+	V=1 \
 	CC="%{__cc}" \
-	CFLAGS="%{rpmcppflags} %{rpmcflags}"
+	CFLAGS="%{rpmcppflags} %{rpmcflags} -fno-strict-aliasing"
 
 %install
 rm -rf $RPM_BUILD_ROOT
 install -d $RPM_BUILD_ROOT{%{_sbindir},%{_mandir}/man8}
-
 %{__make} install \
 	prefix=%{_prefix} \
 	bindir=%{_sbindir} \
 	mandir=%{_mandir} \
+	libdir=%{_libdir} \
 	DESTDIR=$RPM_BUILD_ROOT
 
 ln -sf btrfsck $RPM_BUILD_ROOT%{_sbindir}/fsck.btrfs
 
+rm $RPM_BUILD_ROOT%{_libdir}/*.a
+
 %clean
 rm -rf $RPM_BUILD_ROOT
 
 %files
 %defattr(644,root,root,755)
 %doc INSTALL
-%attr(755,root,root) %{_sbindir}/*
-%{_mandir}/man8/*.8*
+%attr(755,root,root) %{_sbindir}/btrfsck
+%attr(755,root,root) %{_sbindir}/mkfs.btrfs
+%attr(755,root,root) %{_sbindir}/fsck.btrfs
+%attr(755,root,root) %{_sbindir}/btrfs-debug-tree
+%attr(755,root,root) %{_sbindir}/btrfs-image
+%attr(755,root,root) %{_sbindir}/btrfs-convert
+%attr(755,root,root) %{_sbindir}/btrfstune
+%attr(755,root,root) %{_sbindir}/btrfs
+%attr(755,root,root) %{_sbindir}/btrfs-map-logical
+%attr(755,root,root) %{_sbindir}/btrfs-zero-log
+%attr(755,root,root) %{_sbindir}/btrfs-find-root
+%attr(755,root,root) %{_sbindir}/btrfs-show-super
+%attr(755,root,root) %{_libdir}/libbtrfs.so.*.*
+%ghost %{_libdir}/libbtrfs.so.0
+%{_mandir}/man8/btrfs-image.8*
+%{_mandir}/man8/btrfsck.8*
+%{_mandir}/man8/mkfs.btrfs.8*
+%{_mandir}/man8/btrfs.8*
+%{_mandir}/man8/btrfs-convert.8*
+%{_mandir}/man8/btrfs-debug-tree.8*
+%{_mandir}/man8/btrfs-find-root.8*
+%{_mandir}/man8/btrfs-map-logical.8*
+%{_mandir}/man8/btrfs-show-super.8*
+%{_mandir}/man8/btrfs-zero-log.8*
+%{_mandir}/man8/btrfstune.8*
+
+%files devel
+%defattr(644,root,root,755)
+%{_includedir}/btrfs
+%{_libdir}/libbtrfs.so
diff --git a/btrfs-progs-build-everything.patch b/btrfs-progs-build-everything.patch
deleted file mode 100644
index b70a656..0000000
--- a/btrfs-progs-build-everything.patch
+++ /dev/null
@@ -1,12 +0,0 @@
---- btrfs-progs-0.19/Makefile.orig	2010-03-24 14:45:18.001490900 -0400
-+++ btrfs-progs-0.19/Makefile	2010-03-24 14:45:35.745491310 -0400
-@@ -17,8 +17,7 @@
- LIBS=-luuid
- 
- progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck \
--	btrfs \
--	btrfs-map-logical
-+	btrfs btrfs-map-logical btrfstune btrfs-image
- 
- # make C=1 to enable sparse
- ifdef C
diff --git a/btrfs-progs-build-fixes.patch b/btrfs-progs-build-fixes.patch
deleted file mode 100644
index d189c5a..0000000
--- a/btrfs-progs-build-fixes.patch
+++ /dev/null
@@ -1,32 +0,0 @@
---- btrfs-progs-0.19/btrfsck.c	
-+++ btrfs-progs-0.19/btrfsck.c	
-@@ -21,6 +21,9 @@ 
- #include <stdio.h>
- #include <stdlib.h>
- #include <fcntl.h>
-+#include <sys/types.h>
-+#include <sys/stat.h>
-+#include <unistd.h>
- #include "kerncompat.h"
- #include "ctree.h"
- #include "disk-io.h"
---- btrfs-progs-0.19/mkfs.c	
-+++ btrfs-progs-0.19/mkfs.c	
-@@ -341,7 +341,7 @@ int main(int ac, char **av)
- 	u64 alloc_start = 0;
- 	u64 metadata_profile = BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_DUP;
- 	u64 data_profile = BTRFS_BLOCK_GROUP_RAID0;
--	u32 leafsize = getpagesize();
-+	u32 leafsize = sysconf(_SC_PAGESIZE);
- 	u32 sectorsize = 4096;
- 	u32 nodesize = leafsize;
- 	u32 stripesize = 4096;
-@@ -398,7 +398,7 @@ int main(int ac, char **av)
- 				print_usage();
- 		}
- 	}
--	sectorsize = max(sectorsize, (u32)getpagesize());
-+	sectorsize = max(sectorsize, (u32)sysconf(_SC_PAGESIZE));
- 	if (leafsize < sectorsize || (leafsize & (sectorsize - 1))) {
- 		fprintf(stderr, "Illegal leafsize %u\n", leafsize);
- 		exit(1);
diff --git a/btrfs-progs-fix-labels.patch b/btrfs-progs-fix-labels.patch
deleted file mode 100644
index 92a52e4..0000000
--- a/btrfs-progs-fix-labels.patch
+++ /dev/null
@@ -1,25 +0,0 @@
-diff --git a/mkfs.c b/mkfs.c
-index d664254..138bcc9 100644
---- a/mkfs.c
-+++ b/mkfs.c
-@@ -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 --git a/btrfs-progs-fix-return-value.patch b/btrfs-progs-fix-return-value.patch
deleted file mode 100644
index 1b899b9..0000000
--- a/btrfs-progs-fix-return-value.patch
+++ /dev/null
@@ -1,32 +0,0 @@
-From 8b6be4c65eda396e0c42182f4ebf2794c62b442c Mon Sep 17 00:00:00 2001
-From: Josef Bacik <josef at redhat.com>
-Date: Tue, 2 Feb 2010 09:51:15 -0500
-Subject: [PATCH] Btrfs-progs: make btrfsctl return values like everybody else
-
-This patch makes btrfsctl return 0 for success and 1 for failure, which is the
-behavior of all other userspace applications.  Thanks,
-
-Signed-off-by: Josef Bacik <josef at redhat.com>
----
- btrfsctl.c |    6 ++----
- 1 files changed, 2 insertions(+), 4 deletions(-)
-
-diff --git a/btrfsctl.c b/btrfsctl.c
-index 66c4e89..73d9c30 100644
---- a/btrfsctl.c
-+++ b/btrfsctl.c
-@@ -231,9 +231,7 @@ int main(int ac, char **av)
- 		printf("ioctl failed with error %d\n", ret);
- 	}
- 	printf("%s\n", BTRFS_BUILD_VERSION);
--	if (ret)
--		exit(0);
--	else
--		exit(1);
-+
-+	return ret ? 1 : 0;
- }
- 
--- 
-1.6.6
-
diff --git a/btrfs-progs-upstream.patch b/btrfs-progs-upstream.patch
deleted file mode 100644
index 2f41e3d..0000000
--- a/btrfs-progs-upstream.patch
+++ /dev/null
@@ -1,3752 +0,0 @@
-diff --git a/Makefile b/Makefile
-index 8097b5a..525676e 100644
---- a/Makefile
-+++ b/Makefile
-@@ -4,7 +4,7 @@ CFLAGS = -g -Werror -Os
- 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
-+	  volumes.o utils.o btrfs-list.o
- 
- #
- CHECKFLAGS=-D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise \
-@@ -16,7 +16,9 @@ prefix ?= /usr/local
- bindir = $(prefix)/bin
- LIBS=-luuid
- 
--progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck
-+progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck \
-+	btrfs \
-+	btrfs-map-logical
- 
- # make C=1 to enable sparse
- ifdef C
-@@ -35,6 +37,10 @@ all: version $(progs) manpages
- version:
- 	bash version.sh
- 
-+btrfs: $(objects) btrfs.o btrfs_cmds.o
-+	gcc $(CFLAGS) -o btrfs btrfs.o btrfs_cmds.o \
-+		$(objects) $(LDFLAGS) $(LIBS)
-+
- btrfsctl: $(objects) btrfsctl.o
- 	gcc $(CFLAGS) -o btrfsctl btrfsctl.o $(objects) $(LDFLAGS) $(LIBS)
- 
-@@ -56,6 +62,9 @@ btrfs-debug-tree: $(objects) debug-tree.o
- btrfstune: $(objects) btrfstune.o
- 	gcc $(CFLAGS) -o btrfstune $(objects) btrfstune.o $(LDFLAGS) $(LIBS)
- 
-+btrfs-map-logical: $(objects) btrfs-map-logical.o
-+	gcc $(CFLAGS) -o btrfs-map-logical $(objects) btrfs-map-logical.o $(LDFLAGS) $(LIBS)
-+
- btrfs-image: $(objects) btrfs-image.o
- 	gcc $(CFLAGS) -o btrfs-image $(objects) btrfs-image.o -lpthread -lz $(LDFLAGS) $(LIBS)
- 
-@@ -68,6 +77,9 @@ quick-test: $(objects) quick-test.o
- convert: $(objects) convert.o
- 	gcc $(CFLAGS) -o btrfs-convert $(objects) convert.o -lext2fs $(LDFLAGS) $(LIBS)
- 
-+ioctl-test: $(objects) ioctl-test.o
-+	gcc $(CFLAGS) -o ioctl-test $(objects) ioctl-test.o $(LDFLAGS) $(LIBS)
-+
- manpages:
- 	cd man; make
- 
-diff --git a/btrfs-defrag.c b/btrfs-defrag.c
-new file mode 100644
-index 0000000..8f1525a
---- /dev/null
-+++ b/btrfs-defrag.c
-@@ -0,0 +1,39 @@
-+/*
-+ * Copyright (C) 2010 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 __CHECKER__
-+#include <sys/ioctl.h>
-+#include <sys/mount.h>
-+#include "ioctl.h"
-+#endif
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <sys/types.h>
-+#include <sys/stat.h>
-+#include <fcntl.h>
-+#include <ctype.h>
-+#include <unistd.h>
-+#include <dirent.h>
-+#include <libgen.h>
-+#include <getopt.h>
-+#include "kerncompat.h"
-+#include "ctree.h"
-+#include "transaction.h"
-+#include "utils.h"
-+#include "version.h"
-+
-diff --git a/btrfs-list.c b/btrfs-list.c
-new file mode 100644
-index 0000000..7741705
---- /dev/null
-+++ b/btrfs-list.c
-@@ -0,0 +1,825 @@
-+/*
-+ * Copyright (C) 2010 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 __CHECKER__
-+#include <sys/ioctl.h>
-+#include <sys/mount.h>
-+#include "ioctl.h"
-+#endif
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <sys/types.h>
-+#include <sys/stat.h>
-+#include <fcntl.h>
-+#include <unistd.h>
-+#include <dirent.h>
-+#include <libgen.h>
-+#include "kerncompat.h"
-+#include "ctree.h"
-+#include "transaction.h"
-+#include "utils.h"
-+#include "version.h"
-+
-+/* we store all the roots we find in an rbtree so that we can
-+ * search for them later.
-+ */
-+struct root_lookup {
-+	struct rb_root root;
-+};
-+
-+/*
-+ * one of these for each root we find.
-+ */
-+struct root_info {
-+	struct rb_node rb_node;
-+
-+	/* this root's id */
-+	u64 root_id;
-+
-+	/* the id of the root that references this one */
-+	u64 ref_tree;
-+
-+	/* the dir id we're in from ref_tree */
-+	u64 dir_id;
-+
-+	/* path from the subvol we live in to this root, including the
-+	 * root's name.  This is null until we do the extra lookup ioctl.
-+	 */
-+	char *path;
-+
-+	/* the name of this root in the directory it lives in */
-+	char name[];
-+};
-+
-+static void root_lookup_init(struct root_lookup *tree)
-+{
-+	tree->root.rb_node = NULL;
-+}
-+
-+static int comp_entry(struct root_info *entry, u64 root_id, u64 ref_tree)
-+{
-+	if (entry->root_id > root_id)
-+		return 1;
-+	if (entry->root_id < root_id)
-+		return -1;
-+	if (entry->ref_tree > ref_tree)
-+		return 1;
-+	if (entry->ref_tree < ref_tree)
-+		return -1;
-+	return 0;
-+}
-+
-+/*
-+ * insert a new root into the tree.  returns the existing root entry
-+ * if one is already there.  Both root_id and ref_tree are used
-+ * as the key
-+ */
-+static struct rb_node *tree_insert(struct rb_root *root, u64 root_id,
-+				   u64 ref_tree, struct rb_node *node)
-+{
-+	struct rb_node ** p = &root->rb_node;
-+	struct rb_node * parent = NULL;
-+	struct root_info *entry;
-+	int comp;
-+
-+	while(*p) {
-+		parent = *p;
-+		entry = rb_entry(parent, struct root_info, rb_node);
-+
-+		comp = comp_entry(entry, root_id, ref_tree);
-+
-+		if (comp < 0)
-+			p = &(*p)->rb_left;
-+		else if (comp > 0)
-+			p = &(*p)->rb_right;
-+		else
-+			return parent;
-+	}
-+
-+	entry = rb_entry(parent, struct root_info, rb_node);
-+	rb_link_node(node, parent, p);
-+	rb_insert_color(node, root);
-+	return NULL;
-+}
-+
-+/*
-+ * find a given root id in the tree.  We return the smallest one,
-+ * rb_next can be used to move forward looking for more if required
-+ */
-+static struct root_info *tree_search(struct rb_root *root, u64 root_id)
-+{
-+	struct rb_node * n = root->rb_node;
-+	struct root_info *entry;
-+
-+	while(n) {
-+		entry = rb_entry(n, struct root_info, rb_node);
-+
-+		if (entry->root_id < root_id)
-+			n = n->rb_left;
-+		else if (entry->root_id > root_id)
-+			n = n->rb_right;
-+		else {
-+			struct root_info *prev;
-+			struct rb_node *prev_n;
-+			while (1) {
-+				prev_n = rb_prev(n);
-+				if (!prev_n)
-+					break;
-+				prev = rb_entry(prev_n, struct root_info,
-+						      rb_node);
-+				if (prev->root_id != root_id)
-+					break;
-+				entry = prev;
-+				n = prev_n;
-+			}
-+			return entry;
-+		}
-+	}
-+	return NULL;
-+}
-+
-+/*
-+ * this allocates a new root in the lookup tree.
-+ *
-+ * root_id should be the object id of the root
-+ *
-+ * ref_tree is the objectid of the referring root.
-+ *
-+ * dir_id is the directory in ref_tree where this root_id can be found.
-+ *
-+ * name is the name of root_id in that directory
-+ *
-+ * name_len is the length of name
-+ */
-+static int add_root(struct root_lookup *root_lookup,
-+		    u64 root_id, u64 ref_tree, u64 dir_id, char *name,
-+		    int name_len)
-+{
-+	struct root_info *ri;
-+	struct rb_node *ret;
-+	ri = malloc(sizeof(*ri) + name_len + 1);
-+	if (!ri) {
-+		printf("memory allocation failed\n");
-+		exit(1);
-+	}
-+	memset(ri, 0, sizeof(*ri) + name_len + 1);
-+	ri->path = NULL;
-+	ri->dir_id = dir_id;
-+	ri->root_id = root_id;
-+	ri->ref_tree = ref_tree;
-+	strncpy(ri->name, name, name_len);
-+
-+	ret = tree_insert(&root_lookup->root, root_id, ref_tree, &ri->rb_node);
-+	if (ret) {
-+		printf("failed to insert tree %llu\n", (unsigned long long)root_id);
-+		exit(1);
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * for a given root_info, search through the root_lookup tree to construct
-+ * the full path name to it.
-+ *
-+ * This can't be called until all the root_info->path fields are filled
-+ * in by lookup_ino_path
-+ */
-+static int resolve_root(struct root_lookup *rl, struct root_info *ri)
-+{
-+	u64 top_id;
-+	char *full_path = NULL;
-+	int len = 0;
-+	struct root_info *found;
-+
-+	/*
-+	 * we go backwards from the root_info object and add pathnames
-+	 * from parent directories as we go.
-+	 */
-+	found = ri;
-+	while (1) {
-+		char *tmp;
-+		u64 next;
-+		int add_len = strlen(found->path);
-+
-+		/* room for / and for null */
-+		tmp = malloc(add_len + 2 + len);
-+		if (full_path) {
-+			memcpy(tmp + add_len + 1, full_path, len);
-+			tmp[add_len] = '/';
-+			memcpy(tmp, found->path, add_len);
-+			tmp [add_len + len + 1] = '\0';
-+			free(full_path);
-+			full_path = tmp;
-+			len += add_len + 1;
-+		} else {
-+			full_path = strdup(found->path);
-+			len = add_len;
-+		}
-+
-+		next = found->ref_tree;
-+		/* if the ref_tree refers to ourselves, we're at the top */
-+		if (next == found->root_id) {
-+			top_id = next;
-+			break;
-+		}
-+
-+		/*
-+		 * if the ref_tree wasn't in our tree of roots, we're
-+		 * at the top
-+		 */
-+		found = tree_search(&rl->root, next);
-+		if (!found) {
-+			top_id = next;
-+			break;
-+		}
-+	}
-+	printf("ID %llu top level %llu path %s\n", ri->root_id, top_id,
-+	       full_path);
-+	free(full_path);
-+	return 0;
-+}
-+
-+/*
-+ * for a single root_info, ask the kernel to give us a path name
-+ * inside it's ref_root for the dir_id where it lives.
-+ *
-+ * This fills in root_info->path with the path to the directory and and
-+ * appends this root's name.
-+ */
-+static int lookup_ino_path(int fd, struct root_info *ri)
-+{
-+	struct btrfs_ioctl_ino_lookup_args args;
-+	int ret;
-+
-+	if (ri->path)
-+		return 0;
-+
-+	memset(&args, 0, sizeof(args));
-+	args.treeid = ri->ref_tree;
-+	args.objectid = ri->dir_id;
-+
-+	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
-+	if (ret) {
-+		fprintf(stderr, "ERROR: Failed to lookup path for root %llu\n",
-+			(unsigned long long)ri->ref_tree);
-+		return ret;
-+	}
-+
-+	if (args.name[0]) {
-+		/*
-+		 * we're in a subdirectory of ref_tree, the kernel ioctl
-+		 * puts a / in there for us
-+		 */
-+		ri->path = malloc(strlen(ri->name) + strlen(args.name) + 1);
-+		if (!ri->path) {
-+			perror("malloc failed");
-+			exit(1);
-+		}
-+		strcpy(ri->path, args.name);
-+		strcat(ri->path, ri->name);
-+	} else {
-+		/* we're at the root of ref_tree */
-+		ri->path = strdup(ri->name);
-+		if (!ri->path) {
-+			perror("strdup failed");
-+			exit(1);
-+		}
-+	}
-+	return 0;
-+}
-+
-+/* finding the generation for a given path is a two step process.
-+ * First we use the inode loookup routine to find out the root id
-+ *
-+ * Then we use the tree search ioctl to scan all the root items for a
-+ * given root id and spit out the latest generation we can find
-+ */
-+static u64 find_root_gen(int fd)
-+{
-+	struct btrfs_ioctl_ino_lookup_args ino_args;
-+	int ret;
-+	struct btrfs_ioctl_search_args args;
-+	struct btrfs_ioctl_search_key *sk = &args.key;
-+	struct btrfs_ioctl_search_header *sh;
-+	unsigned long off = 0;
-+	u64 max_found = 0;
-+	int i;
-+
-+	memset(&ino_args, 0, sizeof(ino_args));
-+	ino_args.objectid = BTRFS_FIRST_FREE_OBJECTID;
-+
-+	/* this ioctl fills in ino_args->treeid */
-+	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &ino_args);
-+	if (ret) {
-+		fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu\n",
-+			(unsigned long long)BTRFS_FIRST_FREE_OBJECTID);
-+		return 0;
-+	}
-+
-+	memset(&args, 0, sizeof(args));
-+
-+	sk->tree_id = 1;
-+
-+	/*
-+	 * there may be more than one ROOT_ITEM key if there are
-+	 * snapshots pending deletion, we have to loop through
-+	 * them.
-+	 */
-+	sk->min_objectid = ino_args.treeid;
-+	sk->max_objectid = ino_args.treeid;
-+	sk->max_type = BTRFS_ROOT_ITEM_KEY;
-+	sk->min_type = BTRFS_ROOT_ITEM_KEY;
-+	sk->max_offset = (u64)-1;
-+	sk->max_transid = (u64)-1;
-+	sk->nr_items = 4096;
-+
-+	while (1) {
-+		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
-+		if (ret < 0) {
-+			fprintf(stderr, "ERROR: can't perform the search\n");
-+			return 0;
-+		}
-+		/* the ioctl returns the number of item it found in nr_items */
-+		if (sk->nr_items == 0)
-+			break;
-+
-+		off = 0;
-+		for (i = 0; i < sk->nr_items; i++) {
-+			struct btrfs_root_item *item;
-+			sh = (struct btrfs_ioctl_search_header *)(args.buf +
-+								  off);
-+
-+			off += sizeof(*sh);
-+			item = (struct btrfs_root_item *)(args.buf + off);
-+			off += sh->len;
-+
-+			sk->min_objectid = sh->objectid;
-+			sk->min_type = sh->type;
-+			sk->min_offset = sh->offset;
-+
-+			if (sh->objectid > ino_args.treeid)
-+				break;
-+
-+			if (sh->objectid == ino_args.treeid &&
-+			    sh->type == BTRFS_ROOT_ITEM_KEY) {
-+				max_found = max(max_found,
-+						btrfs_root_generation(item));
-+			}
-+		}
-+		if (sk->min_offset < (u64)-1)
-+			sk->min_offset++;
-+		else
-+			break;
-+
-+		if (sk->min_type != BTRFS_ROOT_ITEM_KEY)
-+			break;
-+		if (sk->min_objectid != BTRFS_ROOT_ITEM_KEY)
-+			break;
-+	}
-+	return max_found;
-+}
-+
-+/* pass in a directory id and this will return
-+ * the full path of the parent directory inside its
-+ * subvolume root.
-+ *
-+ * It may return NULL if it is in the root, or an ERR_PTR if things
-+ * go badly.
-+ */
-+static char *__ino_resolve(int fd, u64 dirid)
-+{
-+	struct btrfs_ioctl_ino_lookup_args args;
-+	int ret;
-+	char *full;
-+
-+	memset(&args, 0, sizeof(args));
-+	args.objectid = dirid;
-+
-+	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
-+	if (ret) {
-+		fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu\n",
-+			(unsigned long long)dirid);
-+		return ERR_PTR(ret);
-+	}
-+
-+	if (args.name[0]) {
-+		/*
-+		 * we're in a subdirectory of ref_tree, the kernel ioctl
-+		 * puts a / in there for us
-+		 */
-+		full = strdup(args.name);
-+		if (!full) {
-+			perror("malloc failed");
-+			return ERR_PTR(-ENOMEM);
-+		}
-+	} else {
-+		/* we're at the root of ref_tree */
-+		full = NULL;
-+	}
-+	return full;
-+}
-+
-+/*
-+ * simple string builder, returning a new string with both
-+ * dirid and name
-+ */
-+char *build_name(char *dirid, char *name)
-+{
-+	char *full;
-+	if (!dirid)
-+		return strdup(name);
-+
-+	full = malloc(strlen(dirid) + strlen(name) + 1);
-+	if (!full)
-+		return NULL;
-+	strcpy(full, dirid);
-+	strcat(full, name);
-+	return full;
-+}
-+
-+/*
-+ * given an inode number, this returns the full path name inside the subvolume
-+ * to that file/directory.  cache_dirid and cache_name are used to
-+ * cache the results so we can avoid tree searches if a later call goes
-+ * to the same directory or file name
-+ */
-+static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
-+
-+{
-+	u64 dirid;
-+	char *dirname;
-+	char *name;
-+	char *full;
-+	int ret;
-+	struct btrfs_ioctl_search_args args;
-+	struct btrfs_ioctl_search_key *sk = &args.key;
-+	struct btrfs_ioctl_search_header *sh;
-+	unsigned long off = 0;
-+	int namelen;
-+
-+	memset(&args, 0, sizeof(args));
-+
-+	sk->tree_id = 0;
-+
-+	/*
-+	 * step one, we search for the inode back ref.  We just use the first
-+	 * one
-+	 */
-+	sk->min_objectid = ino;
-+	sk->max_objectid = ino;
-+	sk->max_type = BTRFS_INODE_REF_KEY;
-+	sk->max_offset = (u64)-1;
-+	sk->min_type = BTRFS_INODE_REF_KEY;
-+	sk->max_transid = (u64)-1;
-+	sk->nr_items = 1;
-+
-+	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
-+	if (ret < 0) {
-+		fprintf(stderr, "ERROR: can't perform the search\n");
-+		return NULL;
-+	}
-+	/* the ioctl returns the number of item it found in nr_items */
-+	if (sk->nr_items == 0)
-+		return NULL;
-+
-+	off = 0;
-+	sh = (struct btrfs_ioctl_search_header *)(args.buf + off);
-+
-+	if (sh->type == BTRFS_INODE_REF_KEY) {
-+		struct btrfs_inode_ref *ref;
-+		dirid = sh->offset;
-+
-+		ref = (struct btrfs_inode_ref *)(sh + 1);
-+		namelen = btrfs_stack_inode_ref_name_len(ref);
-+
-+		name = (char *)(ref + 1);
-+		name = strndup(name, namelen);
-+
-+		/* use our cached value */
-+		if (dirid == *cache_dirid && *cache_name) {
-+			dirname = *cache_name;
-+			goto build;
-+		}
-+	} else {
-+		return NULL;
-+	}
-+	/*
-+	 * the inode backref gives us the file name and the parent directory id.
-+	 * From here we use __ino_resolve to get the path to the parent
-+	 */
-+	dirname = __ino_resolve(fd, dirid);
-+build:
-+	full = build_name(dirname, name);
-+	if (*cache_name && dirname != *cache_name)
-+		free(*cache_name);
-+
-+	*cache_name = dirname;
-+	*cache_dirid = dirid;
-+	free(name);
-+
-+	return full;
-+}
-+
-+int list_subvols(int fd)
-+{
-+	struct root_lookup root_lookup;
-+	struct rb_node *n;
-+	int ret;
-+	struct btrfs_ioctl_search_args args;
-+	struct btrfs_ioctl_search_key *sk = &args.key;
-+	struct btrfs_ioctl_search_header *sh;
-+	struct btrfs_root_ref *ref;
-+	unsigned long off = 0;
-+	int name_len;
-+	char *name;
-+	u64 dir_id;
-+	int i;
-+
-+	root_lookup_init(&root_lookup);
-+
-+	memset(&args, 0, sizeof(args));
-+
-+	/* search in the tree of tree roots */
-+	sk->tree_id = 1;
-+
-+	/*
-+	 * set the min and max to backref keys.  The search will
-+	 * only send back this type of key now.
-+	 */
-+	sk->max_type = BTRFS_ROOT_BACKREF_KEY;
-+	sk->min_type = BTRFS_ROOT_BACKREF_KEY;
-+
-+	/*
-+	 * set all the other params to the max, we'll take any objectid
-+	 * and any trans
-+	 */
-+	sk->max_objectid = (u64)-1;
-+	sk->max_offset = (u64)-1;
-+	sk->max_transid = (u64)-1;
-+
-+	/* just a big number, doesn't matter much */
-+	sk->nr_items = 4096;
-+
-+	while(1) {
-+		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
-+		if (ret < 0) {
-+			fprintf(stderr, "ERROR: can't perform the search\n");
-+			return ret;
-+		}
-+		/* the ioctl returns the number of item it found in nr_items */
-+		if (sk->nr_items == 0)
-+			break;
-+
-+		off = 0;
-+
-+		/*
-+		 * for each item, pull the key out of the header and then
-+		 * read the root_ref item it contains
-+		 */
-+		for (i = 0; i < sk->nr_items; i++) {
-+			sh = (struct btrfs_ioctl_search_header *)(args.buf +
-+								  off);
-+			off += sizeof(*sh);
-+			if (sh->type == BTRFS_ROOT_BACKREF_KEY) {
-+				ref = (struct btrfs_root_ref *)(args.buf + off);
-+				name_len = btrfs_stack_root_ref_name_len(ref);
-+				name = (char *)(ref + 1);
-+				dir_id = btrfs_stack_root_ref_dirid(ref);
-+
-+				add_root(&root_lookup, sh->objectid, sh->offset,
-+					 dir_id, name, name_len);
-+			}
-+
-+			off += sh->len;
-+
-+			/*
-+			 * record the mins in sk so we can make sure the
-+			 * next search doesn't repeat this root
-+			 */
-+			sk->min_objectid = sh->objectid;
-+			sk->min_type = sh->type;
-+			sk->min_offset = sh->offset;
-+		}
-+		sk->nr_items = 4096;
-+		/* this iteration is done, step forward one root for the next
-+		 * ioctl
-+		 */
-+		if (sk->min_objectid < (u64)-1) {
-+			sk->min_objectid++;
-+			sk->min_type = BTRFS_ROOT_BACKREF_KEY;
-+			sk->min_offset = 0;
-+		} else
-+			break;
-+	}
-+	/*
-+	 * now we have an rbtree full of root_info objects, but we need to fill
-+	 * in their path names within the subvol that is referencing each one.
-+	 */
-+	n = rb_first(&root_lookup.root);
-+	while (n) {
-+		struct root_info *entry;
-+		int ret;
-+		entry = rb_entry(n, struct root_info, rb_node);
-+		ret = lookup_ino_path(fd, entry);
-+		if(ret < 0)
-+			return ret;
-+		n = rb_next(n);
-+	}
-+
-+	/* now that we have all the subvol-relative paths filled in,
-+	 * we have to string the subvols together so that we can get
-+	 * a path all the way back to the FS root
-+	 */
-+	n = rb_last(&root_lookup.root);
-+	while (n) {
-+		struct root_info *entry;
-+		entry = rb_entry(n, struct root_info, rb_node);
-+		resolve_root(&root_lookup, entry);
-+		n = rb_prev(n);
-+	}
-+
-+	return ret;
-+}
-+
-+static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh,
-+			    struct btrfs_file_extent_item *item,
-+			    u64 found_gen, u64 *cache_dirid,
-+			    char **cache_dir_name, u64 *cache_ino,
-+			    char **cache_full_name)
-+{
-+	u64 len;
-+	u64 disk_start;
-+	u64 disk_offset;
-+	u8 type;
-+	int compressed = 0;
-+	int flags = 0;
-+	char *name = NULL;
-+
-+	if (sh->objectid == *cache_ino) {
-+		name = *cache_full_name;
-+	} else if (*cache_full_name) {
-+		free(*cache_full_name);
-+		*cache_full_name = NULL;
-+	}
-+	if (!name) {
-+		name = ino_resolve(fd, sh->objectid, cache_dirid,
-+				   cache_dir_name);
-+		*cache_full_name = name;
-+		*cache_ino = sh->objectid;
-+	}
-+	if (!name)
-+		return -EIO;
-+
-+	type = btrfs_stack_file_extent_type(item);
-+	compressed = btrfs_stack_file_extent_compression(item);
-+
-+	if (type == BTRFS_FILE_EXTENT_REG ||
-+	    type == BTRFS_FILE_EXTENT_PREALLOC) {
-+		disk_start = btrfs_stack_file_extent_disk_bytenr(item);
-+		disk_offset = btrfs_stack_file_extent_offset(item);
-+		len = btrfs_stack_file_extent_num_bytes(item);
-+	} else if (type == BTRFS_FILE_EXTENT_INLINE) {
-+		disk_start = 0;
-+		disk_offset = 0;
-+		len = btrfs_stack_file_extent_ram_bytes(item);
-+	}
-+	printf("inode %llu file offset %llu len %llu disk start %llu "
-+	       "offset %llu gen %llu flags ",
-+	       (unsigned long long)sh->objectid,
-+	       (unsigned long long)sh->offset,
-+	       (unsigned long long)len,
-+	       (unsigned long long)disk_start,
-+	       (unsigned long long)disk_offset,
-+	       (unsigned long long)found_gen);
-+
-+	if (compressed) {
-+		printf("COMPRESS");
-+		flags++;
-+	}
-+	if (type == BTRFS_FILE_EXTENT_PREALLOC) {
-+		printf("%sPREALLOC", flags ? "|" : "");
-+		flags++;
-+	}
-+	if (type == BTRFS_FILE_EXTENT_INLINE) {
-+		printf("%sINLINE", flags ? "|" : "");
-+		flags++;
-+	}
-+	if (!flags)
-+		printf("NONE");
-+
-+	printf(" %s\n", name);
-+	return 0;
-+}
-+
-+int find_updated_files(int fd, u64 root_id, u64 oldest_gen)
-+{
-+	int ret;
-+	struct btrfs_ioctl_search_args args;
-+	struct btrfs_ioctl_search_key *sk = &args.key;
-+	struct btrfs_ioctl_search_header *sh;
-+	struct btrfs_file_extent_item *item;
-+	unsigned long off = 0;
-+	u64 found_gen;
-+	u64 max_found = 0;
-+	int i;
-+	u64 cache_dirid = 0;
-+	u64 cache_ino = 0;
-+	char *cache_dir_name = NULL;
-+	char *cache_full_name = NULL;
-+	struct btrfs_file_extent_item backup;
-+
-+	memset(&backup, 0, sizeof(backup));
-+	memset(&args, 0, sizeof(args));
-+
-+	sk->tree_id = root_id;
-+
-+	/*
-+	 * set all the other params to the max, we'll take any objectid
-+	 * and any trans
-+	 */
-+	sk->max_objectid = (u64)-1;
-+	sk->max_offset = (u64)-1;
-+	sk->max_transid = (u64)-1;
-+	sk->max_type = BTRFS_EXTENT_DATA_KEY;
-+	sk->min_transid = oldest_gen;
-+	/* just a big number, doesn't matter much */
-+	sk->nr_items = 4096;
-+
-+	max_found = find_root_gen(fd);
-+	while(1) {
-+		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
-+		if (ret < 0) {
-+			fprintf(stderr, "ERROR: can't perform the search\n");
-+			return ret;
-+		}
-+		/* the ioctl returns the number of item it found in nr_items */
-+		if (sk->nr_items == 0)
-+			break;
-+
-+		off = 0;
-+
-+		/*
-+		 * for each item, pull the key out of the header and then
-+		 * read the root_ref item it contains
-+		 */
-+		for (i = 0; i < sk->nr_items; i++) {
-+			sh = (struct btrfs_ioctl_search_header *)(args.buf +
-+								  off);
-+			off += sizeof(*sh);
-+
-+			/*
-+			 * just in case the item was too big, pass something other
-+			 * than garbage
-+			 */
-+			if (sh->len == 0)
-+				item = &backup;
-+			else
-+				item = (struct btrfs_file_extent_item *)(args.buf +
-+								 off);
-+			found_gen = btrfs_stack_file_extent_generation(item);
-+			if (sh->type == BTRFS_EXTENT_DATA_KEY &&
-+			    found_gen >= oldest_gen) {
-+				print_one_extent(fd, sh, item, found_gen,
-+						 &cache_dirid, &cache_dir_name,
-+						 &cache_ino, &cache_full_name);
-+			}
-+			off += sh->len;
-+
-+			/*
-+			 * record the mins in sk so we can make sure the
-+			 * next search doesn't repeat this root
-+			 */
-+			sk->min_objectid = sh->objectid;
-+			sk->min_offset = sh->offset;
-+			sk->min_type = sh->type;
-+		}
-+		sk->nr_items = 4096;
-+		if (sk->min_offset < (u64)-1)
-+			sk->min_offset++;
-+		else if (sk->min_objectid < (u64)-1) {
-+			sk->min_objectid++;
-+			sk->min_offset = 0;
-+			sk->min_type = 0;
-+		} else
-+			break;
-+	}
-+	free(cache_dir_name);
-+	free(cache_full_name);
-+	printf("transid marker was %llu\n", (unsigned long long)max_found);
-+	return ret;
-+}
-diff --git a/btrfs-map-logical.c b/btrfs-map-logical.c
-new file mode 100644
-index 0000000..a109c6a
---- /dev/null
-+++ b/btrfs-map-logical.c
-@@ -0,0 +1,221 @@
-+/*
-+ * Copyright (C) 2009 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.
-+ */
-+
-+#define _XOPEN_SOURCE 500
-+#define _GNU_SOURCE 1
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <fcntl.h>
-+#include <unistd.h>
-+#include <getopt.h>
-+#include "kerncompat.h"
-+#include "ctree.h"
-+#include "volumes.h"
-+#include "disk-io.h"
-+#include "print-tree.h"
-+#include "transaction.h"
-+#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_read_block(struct btrfs_root *root, u64 bytenr,
-+				     u32 blocksize, int copy)
-+{
-+	int ret;
-+	int dev_nr;
-+	struct extent_buffer *eb;
-+	u64 length;
-+	struct btrfs_multi_bio *multi = NULL;
-+	struct btrfs_device *device;
-+	int num_copies;
-+	int mirror_num = 1;
-+
-+	eb = btrfs_find_create_tree_block(root, bytenr, blocksize);
-+	if (!eb)
-+		return NULL;
-+
-+	dev_nr = 0;
-+	length = blocksize;
-+	while (1) {
-+		ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
-+				      eb->start, &length, &multi, mirror_num);
-+		BUG_ON(ret);
-+		device = multi->stripes[0].dev;
-+		eb->fd = device->fd;
-+		device->total_ios++;
-+		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);
-+		kfree(multi);
-+
-+		if (!copy || mirror_num == copy)
-+			ret = read_extent_from_disk(eb);
-+
-+		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
-+					      eb->start, eb->len);
-+		if (num_copies == 1)
-+			break;
-+
-+		mirror_num++;
-+		if (mirror_num > num_copies)
-+			break;
-+	}
-+	return eb;
-+}
-+
-+static void print_usage(void)
-+{
-+	fprintf(stderr, "usage: btrfs-map-logical [options] mount_point\n");
-+	fprintf(stderr, "\t-l Logical extent to map\n");
-+	fprintf(stderr, "\t-c Copy of the extent to read (usually 1 or 2)\n");
-+	fprintf(stderr, "\t-o Output file to hold the extent\n");
-+	fprintf(stderr, "\t-s Number of bytes to read\n");
-+	exit(1);
-+}
-+
-+static struct option long_options[] = {
-+	/* { "byte-count", 1, NULL, 'b' }, */
-+	{ "logical", 1, NULL, 'l' },
-+	{ "copy", 1, NULL, 'c' },
-+	{ "output", 1, NULL, 'c' },
-+	{ "bytes", 1, NULL, 'b' },
-+	{ 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 = 0;
-+	int out_fd = 0;
-+	int err;
-+
-+	while(1) {
-+		int c;
-+		c = getopt_long(ac, av, "l:c:o:b:", long_options,
-+				&option_index);
-+		if (c < 0)
-+			break;
-+		switch(c) {
-+			case 'l':
-+				logical = atoll(optarg);
-+				if (logical == 0) {
-+					fprintf(stderr,
-+						"invalid extent number\n");
-+					print_usage();
-+				}
-+				break;
-+			case 'c':
-+				copy = atoi(optarg);
-+				if (copy == 0) {
-+					fprintf(stderr,
-+						"invalid copy number\n");
-+					print_usage();
-+				}
-+				break;
-+			case 'b':
-+				bytes = atoll(optarg);
-+				if (bytes == 0) {
-+					fprintf(stderr,
-+						"invalid byte count\n");
-+					print_usage();
-+				}
-+				break;
-+			case 'o':
-+				output_file = strdup(optarg);
-+				break;
-+			default:
-+				print_usage();
-+		}
-+	}
-+	ac = ac - optind;
-+	if (ac == 0)
-+		print_usage();
-+	if (logical == 0)
-+		print_usage();
-+	if (copy < 0)
-+		print_usage();
-+
-+	dev = av[optind];
-+
-+	radix_tree_init();
-+	cache_tree_init(&root_cache);
-+
-+	root = open_ctree(dev, 0, 0);
-+	if (!root) {
-+		fprintf(stderr, "Open ctree failed\n");
-+		exit(1);
-+	}
-+
-+	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 (bytes == 0)
-+		bytes = root->sectorsize;
-+
-+	bytes = (bytes + root->sectorsize - 1) / root->sectorsize;
-+	bytes *= root->sectorsize;
-+
-+	while (bytes > 0) {
-+		eb = debug_read_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;
-+			}
-+		}
-+		free_extent_buffer(eb);
-+		logical += root->sectorsize;
-+		bytes -= root->sectorsize;
-+	}
-+
-+out_close_fd:
-+	if (output_file && out_fd != 1)
-+		close(out_fd);
-+close:
-+	close_ctree(root);
-+	return ret;
-+}
-diff --git a/btrfs.c b/btrfs.c
-new file mode 100644
-index 0000000..ab5e57f
---- /dev/null
-+++ b/btrfs.c
-@@ -0,0 +1,387 @@
-+/*
-+ * 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 "kerncompat.h"
-+#include "btrfs_cmds.h"
-+#include "version.h"
-+
-+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; form the 2nd onward they are
-+				   indented */
-+
-+	/* the following fields are run-time filled by the program */
-+	char	**cmds;		/* array of subcommands */
-+	int	ncmds;		/* number of subcommand */
-+};
-+
-+static struct Command commands[] = {
-+
-+	/*
-+		avoid short commands different for the case only
-+	*/
-+	{ do_clone, 2,
-+	  "subvolume snapshot", "<source> [<dest>/]<name>\n"
-+		"Create a writable snapshot of the subvolume <source> with\n"
-+		"the name <name> in the <dest> directory."
-+	},
-+	{ do_delete_subvolume, 1,
-+	  "subvolume delete", "<subvolume>\n"
-+		"Delete the subvolume <subvolume>."
-+	},
-+	{ do_create_subvol, 1,
-+	  "subvolume create", "[<dest>/]<name>\n"
-+		"Create a subvolume in <dest> (or the current directory if\n"
-+		"not passed)."
-+	},
-+	{ do_subvol_list, 1, "subvolume list", "<path>\n"
-+		"List the snapshot/subvolume of a filesystem."
-+	},
-+	{ do_find_newer, 2, "subvolume find-new", "<path> <last_gen>\n"
-+		"List the recently modified files in a filesystem."
-+	},
-+	{ do_defrag, -1,
-+	  "filesystem defragment", "[-vcf] [-s start] [-l len] [-t size] <file>|<dir> [<file>|<dir>...]\n"
-+		"Defragment a file or a directory."
-+	},
-+	{ 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."
-+	},
-+	{ do_fssync, 1,
-+	  "filesystem sync", "<path>\n"
-+		"Force a sync on the filesystem <path>."
-+	},
-+	{ 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."
-+	},
-+	{ do_show_filesystem, 999,
-+	  "filesystem show", "[<uuid>|<label>]\n"
-+		"Show the info of a btrfs filesystem. If no <uuid> or <label>\n"
-+		"is passed, info of all the btrfs filesystem are shown."
-+	},
-+	{ do_df_filesystem, 1,
-+	  "filesystem df", "<path>\n"
-+		"Show space usage information for a mount point\n."
-+	},
-+	{ do_balance, 1,
-+	  "filesystem balance", "<path>\n"
-+		"Balance the chunks across the device."
-+	},
-+	{ do_scan,
-+	  999, "device scan", "[<device> [<device>..]\n"
-+		"Scan all device for or the passed device for a btrfs\n"
-+		"filesystem."
-+	},
-+	{ do_add_volume, -2,
-+	  "device add", "<dev> [<dev>..] <path>\n"
-+		"Add a device to a filesystem."
-+	},
-+	{ do_remove_volume, -2,
-+	  "device delete", "<dev> [<dev>..] <path>\n"
-+		"Remove a device from a filesystem."
-+	},
-+	/* coming soon
-+	{ 2, "filesystem label", "<label> <path>\n"
-+		"Set the label of a filesystem"
-+	}
-+	*/
-+	{ 0, 0 , 0 }
-+};
-+
-+static char *get_prgname(char *programname)
-+{
-+	char	*np;
-+	np = strrchr(programname,'/');
-+	if(!np)
-+		np = programname;
-+	else
-+		np++;
-+
-+	return np;
-+}
-+
-+static void print_help(char *programname, struct Command *cmd)
-+{
-+	char	*pc;
-+
-+	printf("\t%s %s ", programname, cmd->verb );
-+
-+	for(pc = cmd->help; *pc; pc++){
-+		putchar(*pc);
-+		if(*pc == '\n')
-+			printf("\t\t");
-+	}
-+	putchar('\n');
-+}
-+
-+static void help(char *np)
-+{
-+	struct Command *cp;
-+
-+	printf("Usage:\n");
-+	for( cp = commands; cp->verb; cp++ )
-+		print_help(np, cp);
-+
-+	printf("\n\t%s help|--help|-h\n\t\tShow the help.\n",np);
-+	printf("\n%s\n", BTRFS_BUILD_VERSION);
-+}
-+
-+static int split_command(char *cmd, char ***commands)
-+{
-+	int	c, l;
-+	char	*p, *s;
-+
-+	for( *commands = 0, l = c = 0, p = s = cmd ; ; p++, l++ ){
-+		if ( *p && *p != ' ' )
-+			continue;
-+
-+		/* 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;
-+	}
-+
-+	(*commands)[c] = 0;
-+	return c;
-+}
-+
-+/*
-+	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;
-+
-+			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;
-+		}
-+	}
-+	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;
-+	}
-+
-+	ret[0] = newname;
-+	for(i=0; i < *ac ; i++ )
-+		ret[i+1] = (*av)[i];
-+
-+	strcpy(newname, prgname);
-+	strcat(newname, " ");
-+	strcat(newname, cmd->verb);
-+
-+	(*ac)++;
-+	*av = ret;
-+
-+	return 0;
-+
-+}
-+
-+
-+
-+/*
-+
-+	This function perform 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 the help
-+	  for all the matching commands
-+	- if the command doesn't' match show an error
-+	- finally, if a command match, they return which command is 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;
-+	}
-+
-+	for( cp = commands; cp->verb; cp++ )
-+		if( !cp->ncmds)
-+			cp->ncmds = split_command(cp->verb, &(cp->cmds));
-+
-+	for( cp = commands; cp->verb; cp++ ){
-+		int     match;
-+
-+		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;
-+			}
-+		}
-+
-+		/* 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);
-+			helprequested=1;
-+			continue;
-+		}
-+
-+		if(!match)
-+			continue;
-+
-+		matchcmd = cp;
-+		*nargs_  = argc-matchcmd->ncmds-1;
-+		*cmd_ = matchcmd->verb;
-+		*args_ = argv+matchcmd->ncmds+1;
-+		*func_ = cp->func;
-+
-+		break;
-+	}
-+
-+	if(helprequested){
-+		printf("\n%s\n", BTRFS_BUILD_VERSION);
-+		return 0;
-+	}
-+
-+	if(!matchcmd){
-+		fprintf( stderr, "ERROR: unknown command '%s'\n",argv[1]);
-+		help(prgname);
-+		return -1;
-+	}
-+
-+	if(check_ambiguity(matchcmd, argv))
-+		return -2;
-+
-+	/* 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;
-+	}
-+	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;
-+}
-+int main(int ac, char **av )
-+{
-+
-+	char		*cmd=0, **args=0;
-+	int		nargs=0, r;
-+	CommandFunction func=0;
-+
-+	r = parse_args(ac, av, &func, &nargs, &cmd, &args);
-+	if( r <= 0 ){
-+		/* error or no command to parse*/
-+		exit(-r);
-+	}
-+
-+	exit(func(nargs, args));
-+
-+}
-+
-diff --git a/btrfs_cmds.c b/btrfs_cmds.c
-new file mode 100644
-index 0000000..8031c58
---- /dev/null
-+++ b/btrfs_cmds.c
-@@ -0,0 +1,924 @@
-+/*
-+ * 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"
-+
-+#ifdef __CHECKER__
-+#define BLKGETSIZE64 0
-+#define BTRFS_IOC_SNAP_CREATE 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);
-+
-+}
-+
-+static 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;
-+}
-+
-+int do_defrag(int ac, char **av)
-+{
-+	int fd;
-+	int compress = 0;
-+	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;
-+
-+	optind = 1;
-+	while(1) {
-+		int c = getopt(ac, av, "vcfs:l:t:");
-+		if (c < 0)
-+			break;
-+		switch(c) {
-+		case 'c':
-+			compress = 1;
-+			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)
-+		range.flags |= BTRFS_DEFRAG_RANGE_COMPRESS;
-+	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);
-+		} else {
-+			ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, &range);
-+			if (ret && errno == ENOTTY) {
-+				fprintf(stderr, "defrag range ioctl not "
-+					"supported in this kernel, please try "
-+					"without any options.\n");
-+				errors++;
-+				break;
-+			}
-+		}
-+		if (ret) {
-+			fprintf(stderr, "ioctl failed on %s ret %d errno %d\n",
-+				av[i], ret, errno);
-+			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;
-+	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);
-+	if (ret)
-+		return 19;
-+	return 0;
-+}
-+
-+int do_clone(int argc, char **argv)
-+{
-+	char	*subvol, *dst;
-+	int	res, fd, fddst, len;
-+	char	*newname;
-+	char	*dstdir;
-+
-+	subvol = argv[1];
-+	dst = argv[2];
-+	struct btrfs_ioctl_vol_args	args;
-+
-+	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;
-+	}
-+
-+	printf("Create a snapshot of '%s' in '%s/%s'\n",
-+	       subvol, dstdir, newname);
-+	args.fd = fd;
-+	strcpy(args.name, newname);
-+	res = ioctl(fddst, BTRFS_IOC_SNAP_CREATE, &args);
-+
-+	close(fd);
-+	close(fddst);
-+
-+	if(res < 0 ){
-+		fprintf( stderr, "ERROR: cannot snapshot '%s'\n",subvol);
-+		return 11;
-+	}
-+
-+	return 0;
-+
-+}
-+
-+int do_delete_subvolume(int argc, char **argv)
-+{
-+	int	res, fd, len;
-+	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);
-+	strcpy(args.name, vname);
-+	res = ioctl(fd, BTRFS_IOC_SNAP_DESTROY, &args);
-+
-+	close(fd);
-+
-+	if(res < 0 ){
-+		fprintf( stderr, "ERROR: cannot delete '%s/%s'\n",dname, vname);
-+		return 11;
-+	}
-+
-+	return 0;
-+
-+}
-+
-+int do_create_subvol(int argc, char **argv)
-+{
-+	int	res, fddst, len;
-+	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);
-+	strcpy(args.name, newname);
-+	res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE, &args);
-+
-+	close(fddst);
-+
-+	if(res < 0 ){
-+		fprintf( stderr, "ERROR: cannot create subvolume\n");
-+		return 11;
-+	}
-+
-+	return 0;
-+
-+}
-+
-+int do_fssync(int argc, char **argv)
-+{
-+	int fd, res;
-+	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);
-+	close(fd);
-+	if( res < 0 ){
-+		fprintf(stderr, "ERROR: unable to fs-syncing '%s'\n", path);
-+		return 16;
-+	}
-+
-+	return 0;
-+}
-+
-+int do_scan(int argc, char **argv)
-+{
-+	int	i, fd;
-+	if(argc<=1){
-+		int ret;
-+
-+		printf("Scanning for Btrfs filesystems\n");
-+		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 = 1 ; i < argc ; i++ ){
-+		struct btrfs_ioctl_vol_args args;
-+		int ret;
-+
-+		printf("Scanning for Btrfs filesystems in '%s'\n", argv[i]);
-+
-+		strcpy(args.name, argv[i]);
-+		/*
-+		 * 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);
-+
-+		if( ret < 0 ){
-+			close(fd);
-+			fprintf(stderr, "ERROR: unable to scan the device '%s'\n", argv[i]);
-+			return 11;
-+		}
-+	}
-+
-+	close(fd);
-+	return 0;
-+
-+}
-+
-+int do_resize(int argc, char **argv)
-+{
-+
-+	struct btrfs_ioctl_vol_args	args;
-+	int	fd, res, len;
-+	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);
-+	strcpy(args.name, amount);
-+	res = ioctl(fd, BTRFS_IOC_RESIZE, &args);
-+	close(fd);
-+	if( res < 0 ){
-+		fprintf(stderr, "ERROR: unable to resize '%s'\n", path);
-+		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 = argv[1];
-+	int ret;
-+
-+	ret = btrfs_scan_one_dir("/dev", 0);
-+	if (ret){
-+		fprintf(stderr, "ERROR: error %d while scanning\n", ret);
-+		return 18;
-+	}
-+
-+	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;
-+
-+
-+	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;
-+
-+		devfd = open(args[i], O_RDWR);
-+		if (!devfd) {
-+			fprintf(stderr, "ERROR: Unable to open device '%s'\n", args[i]);
-+			close(devfd);
-+			ret++;
-+			continue;
-+		}
-+		ret = fstat(devfd, &st);
-+		if (ret) {
-+			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);
-+		if (res) {
-+			fprintf(stderr, "ERROR: Unable to init '%s'\n", args[i]);
-+			close(devfd);
-+			ret++;
-+			continue;
-+		}
-+		close(devfd);
-+
-+		strcpy(ioctl_args.name, args[i]);
-+		res = ioctl(fdmnt, BTRFS_IOC_ADD_DEV, &ioctl_args);
-+		if(res<0){
-+			fprintf(stderr, "ERROR: error adding the device '%s'\n", args[i]);
-+			ret++;
-+		}
-+
-+	}
-+
-+	close(fdmnt);
-+	if( ret)
-+		return ret+20;
-+	else
-+		return 0;
-+
-+}
-+
-+int do_balance(int argc, char **argv)
-+{
-+
-+	int	fdmnt, ret=0;
-+	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);
-+	close(fdmnt);
-+	if(ret<0){
-+		fprintf(stderr, "ERROR: balancing '%s'\n", path);
-+
-+		return 19;
-+	}
-+	return 0;
-+}
-+int do_remove_volume(int nargs, char **args)
-+{
-+
-+	char	*mntpnt = args[nargs-1];
-+	int	i, fdmnt, ret=0;
-+
-+	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;
-+
-+		strcpy(arg.name, args[i]);
-+		res = ioctl(fdmnt, BTRFS_IOC_RM_DEV, &arg);
-+		if(res<0){
-+			fprintf(stderr, "ERROR: error removing the device '%s'\n", args[i]);
-+			ret++;
-+		}
-+	}
-+
-+	close(fdmnt);
-+	if( ret)
-+		return ret+20;
-+	else
-+		return 0;
-+}
-+
-+int do_set_default_subvol(int nargs, char **argv)
-+{
-+	int	ret=0, fd;
-+	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);
-+	close(fd);
-+	if( ret < 0 ){
-+		fprintf(stderr, "ERROR: unable to set a new default subvolume\n");
-+		return 30;
-+	}
-+	return 0;
-+}
-+
-+int do_df_filesystem(int nargs, char **argv)
-+{
-+	struct btrfs_ioctl_space_args *sargs;
-+	u64 count = 0, i;
-+	int ret;
-+	int fd;
-+	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);
-+	if (ret) {
-+		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);
-+	if (ret) {
-+		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) {
-+			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;
-+}
-diff --git a/btrfs_cmds.h b/btrfs_cmds.h
-new file mode 100644
-index 0000000..7bde191
---- /dev/null
-+++ b/btrfs_cmds.h
-@@ -0,0 +1,34 @@
-+/*
-+ * 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_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 list_subvols(int fd);
-+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);
-diff --git a/btrfsck.c b/btrfsck.c
-index 40c90f8..73f1836 100644
---- a/btrfsck.c
-+++ b/btrfsck.c
-@@ -36,7 +36,7 @@ static u64 total_fs_tree_bytes = 0;
- static u64 btree_space_waste = 0;
- static u64 data_bytes_allocated = 0;
- static u64 data_bytes_referenced = 0;
--int found_old_backref = 0;
-+static int found_old_backref = 0;
- 
- struct extent_backref {
- 	struct list_head list;
-@@ -100,7 +100,11 @@ struct inode_backref {
- #define REF_ERR_DUP_INODE_REF		(1 << 5)
- #define REF_ERR_INDEX_UNMATCH		(1 << 6)
- #define REF_ERR_FILETYPE_UNMATCH	(1 << 7)
--#define REF_ERR_NAME_TOO_LONG		(1 << 8)
-+#define REF_ERR_NAME_TOO_LONG		(1 << 8) // 100
-+#define REF_ERR_NO_ROOT_REF		(1 << 9)
-+#define REF_ERR_NO_ROOT_BACKREF		(1 << 10)
-+#define REF_ERR_DUP_ROOT_REF		(1 << 11)
-+#define REF_ERR_DUP_ROOT_BACKREF	(1 << 12)
- 
- struct inode_record {
- 	struct list_head backrefs;
-@@ -144,6 +148,29 @@ struct inode_record {
- #define I_ERR_SOME_CSUM_MISSING		(1 << 12)
- #define I_ERR_LINK_COUNT_WRONG		(1 << 13)
- 
-+struct root_backref {
-+	struct list_head list;
-+	unsigned int found_dir_item:1;
-+	unsigned int found_dir_index:1;
-+	unsigned int found_back_ref:1;
-+	unsigned int found_forward_ref:1;
-+	unsigned int reachable:1;
-+	int errors;
-+	u64 ref_root;
-+	u64 dir;
-+	u64 index;
-+	u16 namelen;
-+	char name[0];
-+};
-+
-+struct root_record {
-+	struct list_head backrefs;
-+	struct cache_extent cache;
-+	unsigned int found_root_item:1;
-+	u64 objectid;
-+	u32 found_ref;
-+};
-+
- struct ptr_node {
- 	struct cache_extent cache;
- 	void *data;
-@@ -151,6 +178,7 @@ struct ptr_node {
- 
- struct shared_node {
- 	struct cache_extent cache;
-+	struct cache_tree root_cache;
- 	struct cache_tree inode_cache;
- 	struct inode_record *current;
- 	u32 refs;
-@@ -258,6 +286,14 @@ static void free_inode_rec(struct inode_record *rec)
- 	free(rec);
- }
- 
-+static int can_free_inode_rec(struct inode_record *rec)
-+{
-+	if (!rec->errors && rec->checked && rec->found_inode_item &&
-+	    rec->nlink == rec->found_link && list_empty(&rec->backrefs))
-+		return 1;
-+	return 0;
-+}
-+
- static void maybe_free_inode_rec(struct cache_tree *inode_cache,
- 				 struct inode_record *rec)
- {
-@@ -309,8 +345,7 @@ static void maybe_free_inode_rec(struct cache_tree *inode_cache,
- 	}
- 
- 	BUG_ON(rec->refs != 1);
--	if (!rec->errors && rec->nlink == rec->found_link &&
--	    list_empty(&rec->backrefs)) {
-+	if (can_free_inode_rec(rec)) {
- 		cache = find_cache_extent(inode_cache, rec->ino, 1);
- 		node = container_of(cache, struct ptr_node, cache);
- 		BUG_ON(node->data != rec);
-@@ -338,14 +373,12 @@ static int check_orphan_item(struct btrfs_root *root, u64 ino)
- 	return ret;
- }
- 
--static int process_inode_item(struct btrfs_root *root,
--			      struct extent_buffer *eb,
-+static int process_inode_item(struct extent_buffer *eb,
- 			      int slot, struct btrfs_key *key,
- 			      struct shared_node *active_node)
- {
- 	struct inode_record *rec;
- 	struct btrfs_inode_item *item;
--	int ret;
- 
- 	rec = active_node->current;
- 	BUG_ON(rec->ino != key->objectid || rec->refs > 1);
-@@ -361,11 +394,8 @@ static int process_inode_item(struct btrfs_root *root,
- 	if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
- 		rec->nodatasum = 1;
- 	rec->found_inode_item = 1;
--	if (rec->nlink == 0) {
--		ret = check_orphan_item(root, rec->ino);
--		if (ret == -ENOENT)
--			rec->errors |= I_ERR_NO_ORPHAN_ITEM;
--	}
-+	if (rec->nlink == 0)
-+		rec->errors |= I_ERR_NO_ORPHAN_ITEM;
- 	maybe_free_inode_rec(&active_node->inode_cache, rec);
- 	return 0;
- }
-@@ -443,10 +473,9 @@ static int add_inode_backref(struct cache_tree *inode_cache,
- }
- 
- static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
--			    struct shared_node *dst_node)
-+			    struct cache_tree *dst_cache)
- {
- 	struct inode_backref *backref;
--	struct cache_tree *dst_cache = &dst_node->inode_cache;
- 
- 	dst->merging = 1;
- 	list_for_each_entry(backref, &src->backrefs, list) {
-@@ -510,14 +539,8 @@ static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
- 			dst->errors |= I_ERR_DUP_INODE_ITEM;
- 		}
- 	}
--
--	if (src->checked) {
--		dst->checked = 1;
--		if (dst_node->current == dst)
--			dst_node->current = NULL;
--	}
- 	dst->merging = 0;
--	maybe_free_inode_rec(dst_cache, dst);
-+
- 	return 0;
- }
- 
-@@ -537,8 +560,9 @@ static int splice_shared_node(struct shared_node *src_node,
- 	if (src_node->current)
- 		current_ino = src_node->current->ino;
- 
--	src = &src_node->inode_cache;
--	dst = &dst_node->inode_cache;
-+	src = &src_node->root_cache;
-+	dst = &dst_node->root_cache;
-+again:
- 	cache = find_first_cache_extent(src, 0);
- 	while (cache) {
- 		node = container_of(cache, struct ptr_node, cache);
-@@ -557,14 +581,28 @@ static int splice_shared_node(struct shared_node *src_node,
- 		}
- 		ret = insert_existing_cache_extent(dst, &ins->cache);
- 		if (ret == -EEXIST) {
-+			WARN_ON(src == &src_node->root_cache);
- 			conflict = get_inode_rec(dst, rec->ino, 1);
--			merge_inode_recs(rec, conflict, dst_node);
-+			merge_inode_recs(rec, conflict, dst);
-+			if (rec->checked) {
-+				conflict->checked = 1;
-+				if (dst_node->current == conflict)
-+					dst_node->current = NULL;
-+			}
-+			maybe_free_inode_rec(dst, conflict);
- 			free_inode_rec(rec);
- 			free(ins);
- 		} else {
- 			BUG_ON(ret);
- 		}
- 	}
-+
-+	if (src == &src_node->root_cache) {
-+		src = &src_node->inode_cache;
-+		dst = &dst_node->inode_cache;
-+		goto again;
-+	}
-+
- 	if (current_ino > 0 && (!dst_node->current ||
- 	    current_ino > dst_node->current->ino)) {
- 		if (dst_node->current) {
-@@ -616,6 +654,7 @@ static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
- 	node = calloc(1, sizeof(*node));
- 	node->cache.start = bytenr;
- 	node->cache.size = 1;
-+	cache_tree_init(&node->root_cache);
- 	cache_tree_init(&node->inode_cache);
- 	node->refs = refs;
- 
-@@ -646,6 +685,7 @@ static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
- 	if (wc->root_level == wc->active_node &&
- 	    btrfs_root_refs(&root->root_item) == 0) {
- 		if (--node->refs == 0) {
-+			free_inode_recs(&node->root_cache);
- 			free_inode_recs(&node->inode_cache);
- 			remove_cache_extent(&wc->shared, &node->cache);
- 			free(node);
-@@ -708,10 +748,12 @@ static int process_dir_item(struct extent_buffer *eb,
- 	int filetype;
- 	struct btrfs_dir_item *di;
- 	struct inode_record *rec;
-+	struct cache_tree *root_cache;
- 	struct cache_tree *inode_cache;
- 	struct btrfs_key location;
- 	char namebuf[BTRFS_NAME_LEN];
- 
-+	root_cache = &active_node->root_cache;
- 	inode_cache = &active_node->inode_cache;
- 	rec = active_node->current;
- 	rec->found_dir_item = 1;
-@@ -740,7 +782,9 @@ static int process_dir_item(struct extent_buffer *eb,
- 					  key->objectid, key->offset, namebuf,
- 					  len, filetype, key->type, error);
- 		} else if (location.type == BTRFS_ROOT_ITEM_KEY) {
--			/* fixme: check root back & forward references */
-+			add_inode_backref(root_cache, location.objectid,
-+					  key->objectid, key->offset, namebuf,
-+					  len, filetype, key->type, error);
- 		} else {
- 			fprintf(stderr, "warning line %d\n", __LINE__);
- 		}
-@@ -977,8 +1021,7 @@ static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
- 			ret = process_inode_ref(eb, i, &key, active_node);
- 			break;
- 		case BTRFS_INODE_ITEM_KEY:
--			ret = process_inode_item(root, eb, i, &key,
--						 active_node);
-+			ret = process_inode_item(eb, i, &key, active_node);
- 			break;
- 		case BTRFS_EXTENT_DATA_KEY:
- 			ret = process_file_extent(root, eb, i, &key,
-@@ -1176,13 +1219,23 @@ static int check_inode_recs(struct btrfs_root *root,
- 		node = container_of(cache, struct ptr_node, cache);
- 		rec = node->data;
- 		remove_cache_extent(inode_cache, &node->cache);
-+		free(node);
- 		if (rec->ino == root_dirid ||
- 		    rec->ino == BTRFS_ORPHAN_OBJECTID) {
--			free(node);
- 			free_inode_rec(rec);
- 			continue;
- 		}
- 
-+		if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
-+			ret = check_orphan_item(root, rec->ino);
-+			if (ret == 0)
-+				rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
-+			if (can_free_inode_rec(rec)) {
-+				free_inode_rec(rec);
-+				continue;
-+			}
-+		}
-+
- 		error++;
- 		if (!rec->found_inode_item)
- 			rec->errors |= I_ERR_NO_INODE_ITEM;
-@@ -1205,13 +1258,314 @@ static int check_inode_recs(struct btrfs_root *root,
- 				backref->namelen, backref->name,
- 				backref->filetype, backref->errors);
- 		}
--		free(node);
- 		free_inode_rec(rec);
- 	}
- 	return (error > 0) ? -1 : 0;
- }
- 
-+static struct root_record *get_root_rec(struct cache_tree *root_cache,
-+					u64 objectid)
-+{
-+	struct cache_extent *cache;
-+	struct root_record *rec = NULL;
-+	int ret;
-+
-+	cache = find_cache_extent(root_cache, objectid, 1);
-+	if (cache) {
-+		rec = container_of(cache, struct root_record, cache);
-+	} else {
-+		rec = calloc(1, sizeof(*rec));
-+		rec->objectid = objectid;
-+		INIT_LIST_HEAD(&rec->backrefs);
-+		rec->cache.start = objectid;
-+		rec->cache.size = 1;
-+
-+		ret = insert_existing_cache_extent(root_cache, &rec->cache);
-+		BUG_ON(ret);
-+	}
-+	return rec;
-+}
-+
-+static struct root_backref *get_root_backref(struct root_record *rec,
-+					     u64 ref_root, u64 dir, u64 index,
-+					     const char *name, int namelen)
-+{
-+	struct root_backref *backref;
-+
-+	list_for_each_entry(backref, &rec->backrefs, list) {
-+		if (backref->ref_root != ref_root || backref->dir != dir ||
-+		    backref->namelen != namelen)
-+			continue;
-+		if (memcmp(name, backref->name, namelen))
-+			continue;
-+		return backref;
-+	}
-+
-+	backref = malloc(sizeof(*backref) + namelen + 1);
-+	memset(backref, 0, sizeof(*backref));
-+	backref->ref_root = ref_root;
-+	backref->dir = dir;
-+	backref->index = index;
-+	backref->namelen = namelen;
-+	memcpy(backref->name, name, namelen);
-+	backref->name[namelen] = '\0';
-+	list_add_tail(&backref->list, &rec->backrefs);
-+	return backref;
-+}
-+
-+static void free_root_recs(struct cache_tree *root_cache)
-+{
-+	struct cache_extent *cache;
-+	struct root_record *rec;
-+	struct root_backref *backref;
-+
-+	while (1) {
-+		cache = find_first_cache_extent(root_cache, 0);
-+		if (!cache)
-+			break;
-+		rec = container_of(cache, struct root_record, cache);
-+		remove_cache_extent(root_cache, &rec->cache);
-+
-+		while (!list_empty(&rec->backrefs)) {
-+			backref = list_entry(rec->backrefs.next,
-+					     struct root_backref, list);
-+			list_del(&backref->list);
-+			free(backref);
-+		}
-+		kfree(rec);
-+	}
-+}
-+
-+static int add_root_backref(struct cache_tree *root_cache,
-+			    u64 root_id, u64 ref_root, u64 dir, u64 index,
-+			    const char *name, int namelen,
-+			    int item_type, int errors)
-+{
-+	struct root_record *rec;
-+	struct root_backref *backref;
-+
-+	rec = get_root_rec(root_cache, root_id);
-+	backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
-+
-+	backref->errors |= errors;
-+
-+	if (item_type != BTRFS_DIR_ITEM_KEY) {
-+		if (backref->found_dir_index || backref->found_back_ref ||
-+		    backref->found_forward_ref) {
-+			if (backref->index != index)
-+				backref->errors |= REF_ERR_INDEX_UNMATCH;
-+		} else {
-+			backref->index = index;
-+		}
-+	}
-+
-+	if (item_type == BTRFS_DIR_ITEM_KEY) {
-+		backref->found_dir_item = 1;
-+		backref->reachable = 1;
-+		rec->found_ref++;
-+	} else if (item_type == BTRFS_DIR_INDEX_KEY) {
-+		backref->found_dir_index = 1;
-+	} else if (item_type == BTRFS_ROOT_REF_KEY) {
-+		if (backref->found_forward_ref)
-+			backref->errors |= REF_ERR_DUP_ROOT_REF;
-+		backref->found_forward_ref = 1;
-+	} else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
-+		if (backref->found_back_ref)
-+			backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
-+		backref->found_back_ref = 1;
-+	} else {
-+		BUG_ON(1);
-+	}
-+
-+	return 0;
-+}
-+
-+static int merge_root_recs(struct btrfs_root *root,
-+			   struct cache_tree *src_cache,
-+			   struct cache_tree *dst_cache)
-+{
-+	struct cache_extent *cache;
-+	struct ptr_node *node;
-+	struct inode_record *rec;
-+	struct inode_backref *backref;
-+
-+	if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
-+		free_inode_recs(src_cache);
-+		return 0;
-+	}
-+
-+	while (1) {
-+		cache = find_first_cache_extent(src_cache, 0);
-+		if (!cache)
-+			break;
-+		node = container_of(cache, struct ptr_node, cache);
-+		rec = node->data;
-+		remove_cache_extent(src_cache, &node->cache);
-+		free(node);
-+
-+		list_for_each_entry(backref, &rec->backrefs, list) {
-+			BUG_ON(backref->found_inode_ref);
-+			if (backref->found_dir_item)
-+				add_root_backref(dst_cache, rec->ino,
-+					root->root_key.objectid, backref->dir,
-+					backref->index, backref->name,
-+					backref->namelen, BTRFS_DIR_ITEM_KEY,
-+					backref->errors);
-+			if (backref->found_dir_index)
-+				add_root_backref(dst_cache, rec->ino,
-+					root->root_key.objectid, backref->dir,
-+					backref->index, backref->name,
-+					backref->namelen, BTRFS_DIR_INDEX_KEY,
-+					backref->errors);
-+		}
-+		free_inode_rec(rec);
-+	}
-+	return 0;
-+}
-+
-+static int check_root_refs(struct btrfs_root *root,
-+			   struct cache_tree *root_cache)
-+{
-+	struct root_record *rec;
-+	struct root_record *ref_root;
-+	struct root_backref *backref;
-+	struct cache_extent *cache;
-+	int loop = 1;
-+	int ret;
-+	int error;
-+	int errors = 0;
-+
-+	rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
-+	rec->found_ref = 1;
-+
-+	/* fixme: this can not detect circular references */
-+	while (loop) {
-+		loop = 0;
-+		cache = find_first_cache_extent(root_cache, 0);
-+		while (1) {
-+			if (!cache)
-+				break;
-+			rec = container_of(cache, struct root_record, cache);
-+			cache = next_cache_extent(cache);
-+
-+			if (rec->found_ref == 0)
-+				continue;
-+
-+			list_for_each_entry(backref, &rec->backrefs, list) {
-+				if (!backref->reachable)
-+					continue;
-+
-+				ref_root = get_root_rec(root_cache,
-+							backref->ref_root);
-+				if (ref_root->found_ref > 0)
-+					continue;
-+
-+				backref->reachable = 0;
-+				rec->found_ref--;
-+				if (rec->found_ref == 0)
-+					loop = 1;
-+			}
-+		}
-+	}
-+
-+	cache = find_first_cache_extent(root_cache, 0);
-+	while (1) {
-+		if (!cache)
-+			break;
-+		rec = container_of(cache, struct root_record, cache);
-+		cache = next_cache_extent(cache);
-+
-+		if (rec->found_ref == 0 &&
-+		    rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
-+		    rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
-+			ret = check_orphan_item(root->fs_info->tree_root,
-+						rec->objectid);
-+			if (ret == 0)
-+				continue;
-+			errors++;
-+			fprintf(stderr, "fs tree %llu not referenced\n",
-+				(unsigned long long)rec->objectid);
-+		}
-+
-+		error = 0;
-+		if (rec->found_ref > 0 && !rec->found_root_item)
-+			error = 1;
-+		list_for_each_entry(backref, &rec->backrefs, list) {
-+			if (!backref->found_dir_item)
-+				backref->errors |= REF_ERR_NO_DIR_ITEM;
-+			if (!backref->found_dir_index)
-+				backref->errors |= REF_ERR_NO_DIR_INDEX;
-+			if (!backref->found_back_ref)
-+				backref->errors |= REF_ERR_NO_ROOT_BACKREF;
-+			if (!backref->found_forward_ref)
-+				backref->errors |= REF_ERR_NO_ROOT_REF;
-+			if (backref->reachable && backref->errors)
-+				error = 1;
-+		}
-+		if (!error)
-+			continue;
-+
-+		errors++;
-+		fprintf(stderr, "fs tree %llu refs %u %s\n",
-+			(unsigned long long)rec->objectid, rec->found_ref,
-+			 rec->found_root_item ? "" : "not found");
-+
-+		list_for_each_entry(backref, &rec->backrefs, list) {
-+			if (!backref->reachable)
-+				continue;
-+			if (!backref->errors && rec->found_root_item)
-+				continue;
-+			fprintf(stderr, "\tunresolved ref root %llu dir %llu"
-+				" index %llu namelen %u name %s error %x\n",
-+				(unsigned long long)backref->ref_root,
-+				(unsigned long long)backref->dir,
-+				(unsigned long long)backref->index,
-+				backref->namelen, backref->name,
-+				backref->errors);
-+		}
-+	}
-+	return errors > 0 ? 1 : 0;
-+}
-+
-+static int process_root_ref(struct extent_buffer *eb, int slot,
-+			    struct btrfs_key *key,
-+			    struct cache_tree *root_cache)
-+{
-+	u64 dirid;
-+	u64 index;
-+	u32 len;
-+	u32 name_len;
-+	struct btrfs_root_ref *ref;
-+	char namebuf[BTRFS_NAME_LEN];
-+	int error;
-+
-+	ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
-+
-+	dirid = btrfs_root_ref_dirid(eb, ref);
-+	index = btrfs_root_ref_sequence(eb, ref);
-+	name_len = btrfs_root_ref_name_len(eb, ref);
-+
-+	if (name_len <= BTRFS_NAME_LEN) {
-+		len = name_len;
-+		error = 0;
-+	} else {
-+		len = BTRFS_NAME_LEN;
-+		error = REF_ERR_NAME_TOO_LONG;
-+	}
-+	read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
-+
-+	if (key->type == BTRFS_ROOT_REF_KEY) {
-+		add_root_backref(root_cache, key->offset, key->objectid, dirid,
-+				 index, namebuf, len, key->type, error);
-+	} else {
-+		add_root_backref(root_cache, key->objectid, key->offset, dirid,
-+				 index, namebuf, len, key->type, error);
-+	}
-+	return 0;
-+}
-+
- static int check_fs_root(struct btrfs_root *root,
-+			 struct cache_tree *root_cache,
- 			 struct walk_control *wc)
- {
- 	int ret = 0;
-@@ -1219,10 +1573,18 @@ static int check_fs_root(struct btrfs_root *root,
- 	int level;
- 	struct btrfs_path path;
- 	struct shared_node root_node;
-+	struct root_record *rec;
- 	struct btrfs_root_item *root_item = &root->root_item;
- 
-+	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
-+		rec = get_root_rec(root_cache, root->root_key.objectid);
-+		if (btrfs_root_refs(root_item) > 0)
-+			rec->found_root_item = 1;
-+	}
-+
- 	btrfs_init_path(&path);
- 	memset(&root_node, 0, sizeof(root_node));
-+	cache_tree_init(&root_node.root_cache);
- 	cache_tree_init(&root_node.inode_cache);
- 
- 	level = btrfs_header_level(root->node);
-@@ -1266,6 +1628,8 @@ static int check_fs_root(struct btrfs_root *root,
- 	}
- 	btrfs_release_path(root, &path);
- 
-+	merge_root_recs(root, &root_node.root_cache, root_cache);
-+
- 	if (root_node.current) {
- 		root_node.current->checked = 1;
- 		maybe_free_inode_rec(&root_node.inode_cache,
-@@ -1280,13 +1644,15 @@ static int fs_root_objectid(u64 objectid)
- {
- 	if (objectid == BTRFS_FS_TREE_OBJECTID ||
- 	    objectid == BTRFS_TREE_RELOC_OBJECTID ||
-+	    objectid == BTRFS_DATA_RELOC_TREE_OBJECTID ||
- 	    (objectid >= BTRFS_FIRST_FREE_OBJECTID &&
--	     objectid < BTRFS_LAST_FREE_OBJECTID))
-+	     objectid <= BTRFS_LAST_FREE_OBJECTID))
- 		return 1;
- 	return 0;
- }
- 
--static int check_fs_roots(struct btrfs_root *root)
-+static int check_fs_roots(struct btrfs_root *root,
-+			  struct cache_tree *root_cache)
- {
- 	struct btrfs_path path;
- 	struct btrfs_key key;
-@@ -1319,10 +1685,14 @@ static int check_fs_roots(struct btrfs_root *root)
- 		    fs_root_objectid(key.objectid)) {
- 			tmp_root = btrfs_read_fs_root_no_cache(root->fs_info,
- 							       &key);
--			ret = check_fs_root(tmp_root, &wc);
-+			ret = check_fs_root(tmp_root, root_cache, &wc);
- 			if (ret)
- 				err = 1;
- 			btrfs_free_fs_root(root->fs_info, tmp_root);
-+		} else if (key.type == BTRFS_ROOT_REF_KEY ||
-+			   key.type == BTRFS_ROOT_BACKREF_KEY) {
-+			process_root_ref(leaf, path.slots[0], &key,
-+					 root_cache);
- 		}
- 		path.slots[0]++;
- 	}
-@@ -1895,7 +2265,6 @@ static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
- 	return 0;
- }
- 
--
- static int add_pending(struct cache_tree *pending,
- 		       struct cache_tree *seen, u64 bytenr, u32 size)
- {
-@@ -2443,6 +2812,7 @@ static void print_usage(void)
- 
- int main(int ac, char **av)
- {
-+	struct cache_tree root_cache;
- 	struct btrfs_root *root;
- 	int ret;
- 
-@@ -2450,6 +2820,7 @@ int main(int ac, char **av)
- 		print_usage();
- 
- 	radix_tree_init();
-+	cache_tree_init(&root_cache);
- 	root = open_ctree(av[1], 0, 0);
- 
- 	if (root == NULL)
-@@ -2458,10 +2829,15 @@ int main(int ac, char **av)
- 	ret = check_extents(root);
- 	if (ret)
- 		goto out;
--	ret = check_fs_roots(root);
-+	ret = check_fs_roots(root, &root_cache);
-+	if (ret)
-+		goto out;
- 
-+	ret = check_root_refs(root, &root_cache);
- out:
-+	free_root_recs(&root_cache);
- 	close_ctree(root);
-+
- 	if (found_old_backref) {
- 		/*
- 		 * there was a disk format change when mixed
-diff --git a/btrfsctl.c b/btrfsctl.c
-index b323818..be6bf25 100644
---- a/btrfsctl.c
-+++ b/btrfsctl.c
-@@ -29,6 +29,7 @@
- #include <unistd.h>
- #include <dirent.h>
- #include <libgen.h>
-+#include <stdlib.h>
- #include "kerncompat.h"
- #include "ctree.h"
- #include "transaction.h"
-@@ -46,7 +47,7 @@ static inline int ioctl(int fd, int define, void *arg) { return 0; }
- static void print_usage(void)
- {
- 	printf("usage: btrfsctl [ -d file|dir] [ -s snap_name subvol|tree ]\n");
--	printf("                [-r size] [-A device] [-a] [-c]\n");
-+	printf("                [-r size] [-A device] [-a] [-c] [-D dir .]\n");
- 	printf("\t-d filename: defragments one file\n");
- 	printf("\t-d directory: defragments the entire Btree\n");
- 	printf("\t-s snap_name dir: creates a new snapshot of dir\n");
-@@ -55,6 +56,9 @@ static void print_usage(void)
- 	printf("\t-A device: scans the device file for a Btrfs filesystem\n");
- 	printf("\t-a: scans all devices for Btrfs filesystems\n");
- 	printf("\t-c: forces a single FS sync\n");
-+	printf("\t-D: delete snapshot\n");
-+	printf("\t-m [tree id] directory: set the default mounted subvolume"
-+	       " to the [tree id] or the directory\n");
- 	printf("%s\n", BTRFS_BUILD_VERSION);
- 	exit(1);
- }
-@@ -100,6 +104,7 @@ int main(int ac, char **av)
- 	unsigned long command = 0;
- 	int len;
- 	char *fullpath;
-+	u64 objectid = 0;
- 
- 	if (ac == 2 && strcmp(av[1], "-a") == 0) {
- 		fprintf(stderr, "Scanning for Btrfs filesystems\n");
-@@ -158,6 +163,18 @@ int main(int ac, char **av)
- 				print_usage();
- 			}
- 			command = BTRFS_IOC_DEFRAG;
-+		} else if (strcmp(av[i], "-D") == 0) {
-+			if (i >= ac - 1) {
-+				fprintf(stderr, "-D requires an arg\n");
-+				print_usage();
-+			}
-+			command = BTRFS_IOC_SNAP_DESTROY;
-+			name = av[i + 1];
-+			len = strlen(name);
-+			if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
-+				fprintf(stderr, "-D size too long\n");
-+				exit(1);
-+			}
- 		} else if (strcmp(av[i], "-A") == 0) {
- 			if (i >= ac - 1) {
- 				fprintf(stderr, "-A requires an arg\n");
-@@ -178,6 +195,16 @@ int main(int ac, char **av)
- 			command = BTRFS_IOC_RESIZE;
- 		} else if (strcmp(av[i], "-c") == 0) {
- 			command = BTRFS_IOC_SYNC;
-+		} else if (strcmp(av[i], "-m") == 0) {
-+			command = BTRFS_IOC_DEFAULT_SUBVOL;
-+			if (i == ac - 3) {
-+				objectid = (unsigned long long)
-+					    strtoll(av[i + 1], NULL, 0);
-+				if (errno == ERANGE) {
-+					fprintf(stderr, "invalid tree id\n");
-+					exit(1);
-+				}
-+			}
- 		}
- 	}
- 	if (command == 0) {
-@@ -206,6 +233,9 @@ int main(int ac, char **av)
- 	if (command == BTRFS_IOC_SNAP_CREATE) {
- 		args.fd = fd;
- 		ret = ioctl(snap_fd, command, &args);
-+	} else if (command == BTRFS_IOC_DEFAULT_SUBVOL) {
-+		printf("objectid is %llu\n", objectid);
-+		ret = ioctl(fd, command, &objectid);
- 	} else
- 		ret = ioctl(fd, command, &args);
- 	if (ret < 0) {
-diff --git a/convert.c b/convert.c
-index d2c9efa..d037c98 100644
---- a/convert.c
-+++ b/convert.c
-@@ -370,7 +370,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans,
- 	struct btrfs_extent_item *ei;
- 	u32 blocksize = root->sectorsize;
- 	u64 nbytes;
--	u64 bytes_used;
- 
- 	if (disk_bytenr == 0) {
- 		ret = btrfs_insert_file_extent(trans, root, objectid,
-@@ -432,9 +431,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans,
- 	nbytes = btrfs_stack_inode_nbytes(inode) + num_bytes;
- 	btrfs_set_stack_inode_nbytes(inode, nbytes);
- 
--	bytes_used = btrfs_root_used(&root->root_item);
--	btrfs_set_root_used(&root->root_item, bytes_used + num_bytes);
--
- 	btrfs_release_path(root, &path);
- 
- 	ins_key.objectid = disk_bytenr;
-@@ -454,9 +450,6 @@ static int record_file_extent(struct btrfs_trans_handle *trans,
- 
- 		btrfs_mark_buffer_dirty(leaf);
- 
--		bytes_used = btrfs_super_bytes_used(&info->super_copy);
--		btrfs_set_super_bytes_used(&info->super_copy, bytes_used +
--					   num_bytes);
- 		ret = btrfs_update_block_group(trans, root, disk_bytenr,
- 					       num_bytes, 1, 0);
- 		if (ret)
-diff --git a/ctree.h b/ctree.h
-index a9062ea..64ecf12 100644
---- a/ctree.h
-+++ b/ctree.h
-@@ -1047,6 +1047,7 @@ BTRFS_SETGET_STACK_FUNCS(block_group_flags,
- 
- /* struct btrfs_inode_ref */
- BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
-+BTRFS_SETGET_STACK_FUNCS(stack_inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
- BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
- 
- /* struct btrfs_inode_item */
-@@ -1325,6 +1326,10 @@ BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
- BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
- BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
- 
-+BTRFS_SETGET_STACK_FUNCS(stack_root_ref_dirid, struct btrfs_root_ref, dirid, 64);
-+BTRFS_SETGET_STACK_FUNCS(stack_root_ref_sequence, struct btrfs_root_ref, sequence, 64);
-+BTRFS_SETGET_STACK_FUNCS(stack_root_ref_name_len, struct btrfs_root_ref, name_len, 16);
-+
- /* struct btrfs_dir_item */
- BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
- BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
-@@ -1572,6 +1577,7 @@ static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
- 
- /* struct btrfs_file_extent_item */
- BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
-+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item, type, 8);
- 
- static inline unsigned long btrfs_file_extent_inline_start(struct
- 						   btrfs_file_extent_item *e)
-@@ -1588,18 +1594,30 @@ static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
- 
- BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
- 		   disk_bytenr, 64);
-+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr, struct btrfs_file_extent_item,
-+		   disk_bytenr, 64);
- BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
- 		   generation, 64);
-+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation, struct btrfs_file_extent_item,
-+		   generation, 64);
- BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
- 		   disk_num_bytes, 64);
- BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
- 		  offset, 64);
-+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset, struct btrfs_file_extent_item,
-+		  offset, 64);
- BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
- 		   num_bytes, 64);
-+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes, struct btrfs_file_extent_item,
-+		   num_bytes, 64);
- BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
- 		   ram_bytes, 64);
-+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_ram_bytes, struct btrfs_file_extent_item,
-+		   ram_bytes, 64);
- BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
- 		   compression, 8);
-+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression, struct btrfs_file_extent_item,
-+		   compression, 8);
- BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
- 		   encryption, 8);
- BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
-diff --git a/ioctl-test.c b/ioctl-test.c
-new file mode 100644
-index 0000000..7cf3bc2
---- /dev/null
-+++ b/ioctl-test.c
-@@ -0,0 +1,36 @@
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include "kerncompat.h"
-+#include "ioctl.h"
-+
-+unsigned long ioctls[] = {
-+	BTRFS_IOC_SNAP_CREATE,
-+	BTRFS_IOC_DEFRAG,
-+	BTRFS_IOC_RESIZE,
-+	BTRFS_IOC_SCAN_DEV,
-+	BTRFS_IOC_TRANS_START,
-+	BTRFS_IOC_TRANS_END,
-+	BTRFS_IOC_SYNC,
-+	BTRFS_IOC_CLONE,
-+	BTRFS_IOC_ADD_DEV,
-+	BTRFS_IOC_RM_DEV,
-+	BTRFS_IOC_BALANCE,
-+	BTRFS_IOC_SUBVOL_CREATE,
-+	BTRFS_IOC_SNAP_DESTROY,
-+	BTRFS_IOC_DEFRAG_RANGE,
-+	BTRFS_IOC_TREE_SEARCH,
-+	BTRFS_IOC_INO_LOOKUP,
-+	BTRFS_IOC_DEFAULT_SUBVOL,
-+	BTRFS_IOC_SPACE_INFO,
-+	0 };
-+
-+int main(int ac, char **av)
-+{
-+	int i = 0;
-+	while(ioctls[i]) {
-+		printf("%lu\n" ,ioctls[i]);
-+		i++;
-+	}
-+	return 0;
-+}
-+
-diff --git a/ioctl.h b/ioctl.h
-index a084f33..776d7a9 100644
---- a/ioctl.h
-+++ b/ioctl.h
-@@ -30,6 +30,108 @@ struct btrfs_ioctl_vol_args {
- 	char name[BTRFS_PATH_NAME_MAX + 1];
- };
- 
-+struct btrfs_ioctl_search_key {
-+	/* which root are we searching.  0 is the tree of tree roots */
-+	__u64 tree_id;
-+
-+	/* keys returned will be >= min and <= max */
-+	__u64 min_objectid;
-+	__u64 max_objectid;
-+
-+	/* keys returned will be >= min and <= max */
-+	__u64 min_offset;
-+	__u64 max_offset;
-+
-+	/* max and min transids to search for */
-+	__u64 min_transid;
-+	__u64 max_transid;
-+
-+	/* keys returned will be >= min and <= max */
-+	__u32 min_type;
-+	__u32 max_type;
-+
-+	/*
-+	 * how many items did userland ask for, and how many are we
-+	 * returning
-+	 */
-+	__u32 nr_items;
-+
-+	/* align to 64 bits */
-+	__u32 unused;
-+
-+	/* some extra for later */
-+	__u64 unused1;
-+	__u64 unused2;
-+	__u64 unused3;
-+	__u64 unused4;
-+};
-+
-+struct btrfs_ioctl_search_header {
-+	__u64 transid;
-+	__u64 objectid;
-+	__u64 offset;
-+	__u32 type;
-+	__u32 len;
-+} __attribute__((may_alias));
-+
-+#define BTRFS_SEARCH_ARGS_BUFSIZE (4096 - sizeof(struct btrfs_ioctl_search_key))
-+/*
-+ * the buf is an array of search headers where
-+ * each header is followed by the actual item
-+ * the type field is expanded to 32 bits for alignment
-+ */
-+struct btrfs_ioctl_search_args {
-+	struct btrfs_ioctl_search_key key;
-+	char buf[BTRFS_SEARCH_ARGS_BUFSIZE];
-+};
-+
-+#define BTRFS_INO_LOOKUP_PATH_MAX 4080
-+struct btrfs_ioctl_ino_lookup_args {
-+	__u64 treeid;
-+	__u64 objectid;
-+	char name[BTRFS_INO_LOOKUP_PATH_MAX];
-+};
-+
-+/* flags for the defrag range ioctl */
-+#define BTRFS_DEFRAG_RANGE_COMPRESS 1
-+#define BTRFS_DEFRAG_RANGE_START_IO 2
-+
-+struct btrfs_ioctl_defrag_range_args {
-+	/* start of the defrag operation */
-+	__u64 start;
-+
-+	/* number of bytes to defrag, use (u64)-1 to say all */
-+	__u64 len;
-+
-+	/*
-+	 * flags for the operation, which can include turning
-+	 * on compression for this one defrag
-+	 */
-+	__u64 flags;
-+
-+	/*
-+	 * any extent bigger than this will be considered
-+	 * already defragged.  Use 0 to take the kernel default
-+	 * Use 1 to say every single extent must be rewritten
-+	 */
-+	__u32 extent_thresh;
-+
-+	/* spare for later */
-+	__u32 unused[5];
-+};
-+
-+struct btrfs_ioctl_space_info {
-+	__u64 flags;
-+	__u64 total_bytes;
-+	__u64 used_bytes;
-+};
-+
-+struct btrfs_ioctl_space_args {
-+	__u64 space_slots;
-+	__u64 total_spaces;
-+	struct btrfs_ioctl_space_info spaces[0];
-+};
-+
- #define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \
- 				   struct btrfs_ioctl_vol_args)
- #define BTRFS_IOC_DEFRAG _IOW(BTRFS_IOCTL_MAGIC, 2, \
-@@ -56,4 +158,15 @@ struct btrfs_ioctl_vol_args {
- /* 13 is for CLONE_RANGE */
- #define BTRFS_IOC_SUBVOL_CREATE _IOW(BTRFS_IOCTL_MAGIC, 14, \
- 				   struct btrfs_ioctl_vol_args)
-+#define BTRFS_IOC_SNAP_DESTROY _IOW(BTRFS_IOCTL_MAGIC, 15, \
-+				   struct btrfs_ioctl_vol_args)
-+#define BTRFS_IOC_DEFRAG_RANGE _IOW(BTRFS_IOCTL_MAGIC, 16, \
-+				struct btrfs_ioctl_defrag_range_args)
-+#define BTRFS_IOC_TREE_SEARCH _IOWR(BTRFS_IOCTL_MAGIC, 17, \
-+				   struct btrfs_ioctl_search_args)
-+#define BTRFS_IOC_INO_LOOKUP _IOWR(BTRFS_IOCTL_MAGIC, 18, \
-+				   struct btrfs_ioctl_ino_lookup_args)
-+#define BTRFS_IOC_DEFAULT_SUBVOL _IOW(BTRFS_IOCTL_MAGIC, 19, u64)
-+#define BTRFS_IOC_SPACE_INFO _IOWR(BTRFS_IOCTL_MAGIC, 20, \
-+				    struct btrfs_ioctl_space_args)
- #endif
-diff --git a/man/Makefile b/man/Makefile
-index 4e8893b..4a90b75 100644
---- a/man/Makefile
-+++ b/man/Makefile
-@@ -7,13 +7,16 @@ mandir = $(prefix)/man
- man8dir = $(mandir)/man8
- 
- MANPAGES = mkfs.btrfs.8.gz btrfsctl.8.gz btrfsck.8.gz btrfs-image.8.gz \
--	   btrfs-show.8.gz
-+	   btrfs-show.8.gz btrfs.8.gz
- 
- all: $(MANPAGES)
- 
- mkfs.btrfs.8.gz: mkfs.btrfs.8.in
- 	$(GZIP) -n -c mkfs.btrfs.8.in > mkfs.btrfs.8.gz
- 
-+btrfs.8.gz: btrfs.8.in
-+	$(GZIP) -n -c btrfs.8.in > btrfs.8.gz
-+
- btrfsctl.8.gz: btrfsctl.8.in
- 	$(GZIP) -n -c btrfsctl.8.in > btrfsctl.8.gz
- 
-diff --git a/man/btrfs.8.in b/man/btrfs.8.in
-new file mode 100644
-index 0000000..26ef982
---- /dev/null
-+++ b/man/btrfs.8.in
-@@ -0,0 +1,170 @@
-+.TH BTRFS 8 "" "btrfs" "btrfs"
-+.\"
-+.\" Man page written by Goffredo Baroncelli <kreijack at inwind.it> (Feb 2010)
-+.\"
-+.SH NAME
-+btrfs \- control a btrfs filesystem
-+.SH SYNOPSIS
-+\fBbtrfs\fP \fBsubvolume snapshot\fP\fI <source> [<dest>/]<name>\fP
-+.PP
-+\fBbtrfs\fP \fBsubvolume delete\fP\fI <subvolume>\fP
-+.PP
-+\fBbtrfs\fP \fBsubvolume create\fP\fI [<dest>/]<name>\fP
-+.PP
-+\fBbtrfs\fP \fBsubvolume list\fP\fI <path>\fP
-+.PP
-+\fBbtrfs\fP \fBsubvolume set-default\fP\fI <id> <path>\fP
-+.PP
-+\fBbtrfs\fP \fBfilesystem defrag\fP\fI <file>|<dir> [<file>|<dir>...]\fP
-+.PP
-+\fBbtrfs\fP \fBfilesystem sync\fP\fI <path> \fP
-+.PP
-+\fBbtrfs\fP \fBfilesystem resize\fP\fI [+/\-]<size>[gkm]|max <filesystem>\fP
-+.PP
-+\fBbtrfs\fP \fBdevice scan\fP\fI [<device> [<device>..]]\fP
-+.PP
-+\fBbtrfs\fP \fBdevice show\fP\fI <dev>|<label> [<dev>|<label>...]\fP
-+.PP
-+\fBbtrfs\fP \fBdevice balance\fP\fI <path> \fP
-+.PP
-+\fBbtrfs\fP \fBdevice add\fP\fI <dev> [<dev>..] <path> \fP
-+.PP
-+\fBbtrfs\fP \fBdevice delete\fP\fI <dev> [<dev>..] <path> \fP]
-+
-+.PP
-+\fBbtrfs\fP \fBhelp|\-\-help|\-h \fP\fI\fP
-+.PP
-+.SH DESCRIPTION
-+.B btrfs
-+is used to control the filesystem and the files and directories stored. It is
-+the tool to create or destroy a snapshot or a subvolume for the
-+filesystem, to defrag a file or a directory, flush the data to the disk,
-+to resize the filesystem, to scan the device.
-+
-+It is possible to abbreviate the commands unless the commands  are ambiguous.
-+For example: it is possible to run
-+.I btrfs sub snaps
-+instead of
-+.I btrfs subvolume snapshot.
-+But
-+.I btrfs dev s
-+is not allowed, because
-+.I dev s
-+may be interpreted both as
-+.I device show
-+and as
-+.I device scan.
-+In this case
-+.I btrfs
-+returns an error.
-+
-+If a command is terminated by
-+.I --help
-+, the relevant help is showed. If the passed command matches more commands,
-+the help of all the matched commands are showed. For example
-+.I btrfs dev --help
-+shows the help of all
-+.I device*
-+command.
-+
-+.SH COMMANDS
-+.TP
-+
-+\fBsubvolume snapshot\fR\fI <source> [<dest>/]<name>\fR
-+Create a writable snapshot of the subvolume \fI<source>\fR with the name
-+\fI<name>\fR in the \fI<dest>\fR directory. If \fI<source>\fR is not a
-+subvolume, \fBbtrfs\fR returns an error.
-+.TP
-+
-+\fBsubvolume delete\fR\fI <subvolume>\fR
-+Delete the subvolume \fI<subvolume>\fR. If \fI<subvolume>\fR is not a
-+subvolume, \fBbtrfs\fR returns an error.
-+.TP
-+
-+\fBsubvolume create\fR\fI [<dest>/]<name>\fR
-+Create a subvolume in \fI<dest>\fR (or in the current directory if
-+\fI<dest>\fR is omitted).
-+.TP
-+
-+\fBsubvolume list\fR\fI <path>\fR
-+List the subvolumes present in the filesystem \fI<path>\fR. For every
-+subvolume is showed the subvolume ID (second column), 
-+the ID of the \fItop level\fR 
-+subvolume (fifth column), and the path (seventh column) relative to the
-+\fItop level\fR subvolume.
-+These <ID> may be used by the \fBsubvolume set-default\fR command, or at
-+mount time via the \fIsubvol=\fR option.
-+.TP
-+
-+\fBsubvolume set-default\fR\fI <id> <path>\fR
-+Set the subvolume of the filesystem \fI<path>\fR which is mounted as 
-+\fIdefault\fR. The subvolume is identified by \fB<id>\fR, which 
-+is returned by the \fBsubvolume list\fR command.
-+.TP
-+
-+\fBfilesystem defragment\fP\fI <file>|<dir> [<file>|<dir>...]\fR
-+Defragment files and/or directories.
-+.TP
-+
-+\fBdevice scan\fR \fI[<device> [<device>..]]\fR
-+Scan devices for a btrfs filesystem. If no devices are passed, \fBbtrfs\fR scans
-+all the block devices.
-+.TP
-+
-+\fBfilesystem sync\fR\fI <path> \fR
-+Force a sync for the filesystem identified by \fI<path>\fR.
-+.TP
-+
-+.\"
-+.\" Some wording are extracted by the resize2fs man page
-+.\"
-+
-+\fBfilesystem resize\fR\fI [+/\-]<size>[gkm]|max <path>\fR
-+Resize a filesystem identified by \fI<path>\fR.
-+The \fI<size>\fR parameter specifies the new size of the filesystem.
-+If the prefix \fI+\fR or \fI\-\fR is present the size is increased or decreased
-+by the quantity \fI<size>\fR.
-+If no units are specified, the unit of the \fI<size>\fR parameter defaults to
-+bytes. Optionally, the size parameter may be suffixed by one of the following
-+the units designators: 'K', 'M', or 'G', kilobytes, megabytes, or gigabytes,
-+respectively.
-+
-+If 'max' is passed, the filesystem will occupy all available space on the
<Skipped 290 lines>
================================================================

---- gitweb:

http://git.pld-linux.org/gitweb.cgi/packages/btrfs-progs.git/commitdiff/7172bf1cdc82f892d7a59f2af645c8ce81b55a3c



More information about the pld-cvs-commit mailing list