From 0b8f9cff0018e92f9cf3a110f1fda259d60d4606 Mon Sep 17 00:00:00 2001
From: Josef Bacik <josef@fedoraproject.org>
Date: Mar 24 2010 19:33:27 +0000
Subject: - bring btrfs-progs uptodate with upstream, add btrfs command and other

    features.

---

diff --git a/btrfs-progs-build-everything.patch b/btrfs-progs-build-everything.patch
index 522e6c8..b70a656 100644
--- a/btrfs-progs-build-everything.patch
+++ b/btrfs-progs-build-everything.patch
@@ -1,12 +1,12 @@
-diff -up btrfs-progs-0.19/Makefile.orig btrfs-progs-0.19/Makefile
---- btrfs-progs-0.19/Makefile.orig	2009-06-19 08:05:49.151573429 -0400
-+++ btrfs-progs-0.19/Makefile	2009-06-19 08:08:35.192509803 -0400
-@@ -16,7 +16,7 @@ prefix ?= /usr/local
- bindir = $(prefix)/bin
+--- 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
-+progs = btrfsctl mkfs.btrfs btrfs-debug-tree btrfs-show btrfs-vol btrfsck btrfs-image btrfstune
+ 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-upstream.patch b/btrfs-progs-upstream.patch
index 3186e28..2f41e3d 100644
--- a/btrfs-progs-upstream.patch
+++ b/btrfs-progs-upstream.patch
@@ -1,3 +1,2524 @@
+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
@@ -682,10 +3203,18 @@ index 40c90f8..73f1836 100644
  		/*
  		 * there was a disk format change when mixed
 diff --git a/btrfsctl.c b/btrfsctl.c
-index b323818..66c4e89 100644
+index b323818..be6bf25 100644
 --- a/btrfsctl.c
 +++ b/btrfsctl.c
-@@ -46,7 +46,7 @@ static inline int ioctl(int fd, int define, void *arg) { return 0; }
+@@ -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");
@@ -694,15 +3223,25 @@ index b323818..66c4e89 100644
  	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 +55,7 @@ static void print_usage(void)
+@@ -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);
  }
-@@ -158,6 +159,18 @@ int main(int ac, char **av)
+@@ -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;
@@ -721,6 +3260,33 @@ index b323818..66c4e89 100644
  		} 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
@@ -753,15 +3319,434 @@ index d2c9efa..d037c98 100644
  		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..4410ac0 100644
+index a084f33..776d7a9 100644
 --- a/ioctl.h
 +++ b/ioctl.h
-@@ -56,4 +56,7 @@ struct btrfs_ioctl_vol_args {
+@@ -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@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
++volume(s).
++
++The \fBresize\fR command \fBdoes not\fR manipulate the size of underlying
++partition.  If you wish to enlarge/reduce a filesystem, you must make sure you
++can expand the partition before enlarging the filesystem and shrink the
++partition after reducing the size of the filesystem.
++.TP
++
++\fBfilesystem show\fR [<uuid>|<label>]\fR
++Show the btrfs filesystem with some additional info. If no UUID or label is
++passed, \fBbtrfs\fR show info of all the btrfs filesystem.
++.TP
++
++\fBdevice balance\fR \fI<path>\fR
++Balance the chunks of the filesystem identified by \fI<path>\fR
++across the devices.
++.TP
++
++\fBdevice add\fR\fI <dev> [<dev>..] <path>\fR
++Add device(s) to the filesystem identified by \fI<path>\fR.
++.TP
++
++\fBdevice delete\fR\fI <dev> [<dev>..] <path>\fR
++Remove device(s) from a filesystem identified by \fI<path>\fR.
++.PP
++
++.SH EXIT STATUS
++\fBbtrfs\fR returns a zero exist status if it succeeds. Non zero is returned in
++case of failure.
++
++.SH AVAILABILITY
++.B btrfs
++is part of btrfs-progs. Btrfs filesystem is currently under heavy development,
++and not suitable for any uses other than benchmarking and review.
++Please refer to the btrfs wiki http://btrfs.wiki.kernel.org for
++further details.
++.SH SEE ALSO
++.BR mkfs.btrfs (8)
diff --git a/btrfs-progs.spec b/btrfs-progs.spec
index 5b2286b..12a54be 100644
--- a/btrfs-progs.spec
+++ b/btrfs-progs.spec
@@ -1,6 +1,6 @@
 Name:           btrfs-progs
 Version:        0.19
-Release:        10%{?dist}
+Release:        11%{?dist}
 Summary:        Userspace programs for btrfs
 
 Group:          System Environment/Base
@@ -26,11 +26,11 @@ check, modify and correct any inconsistencies in the btrfs filesystem.
 %prep
 %setup -q
 %patch0 -p1
-%patch1 -p1
 %patch2 -p1
 %patch3 -p1
 %patch4 -p1
 %patch5 -p1
+%patch1 -p1
 
 %build
 make CFLAGS="$RPM_OPT_FLAGS" %{?_smp_mflags}
@@ -55,13 +55,20 @@ rm -rf $RPM_BUILD_ROOT
 %{_root_sbindir}/btrfs-vol
 %{_root_sbindir}/btrfs-convert
 %{_root_sbindir}/btrfstune
+%{_root_sbindir}/btrfs
+%{_root_sbindir}/btrfs-map-logical
 %{_mandir}/man8/btrfs-image.8.gz
 %{_mandir}/man8/btrfs-show.8.gz
 %{_mandir}/man8/btrfsck.8.gz
 %{_mandir}/man8/btrfsctl.8.gz
 %{_mandir}/man8/mkfs.btrfs.8.gz
+%{_mandir}/man8/btrfs.8.gz
 
 %changelog
+* Wed Mar 24 2010 Josef Bacik <josef@toxicpanda.com> 0.19-11
+- bring btrfs-progs uptodate with upstream, add btrfs command and other
+  features.
+
 * Thu Mar 11 2010 Josef Bacik <josef@toxicpanda.com> 0.19-10
 - fix dso linking issue and bring btrfs-progs uptodate with upstream