X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=btrfs-list.c;h=e01c58991dad9e16f46ec00fcc2546b73642a612;hb=e181c03d420ef36c8bedd86492dc5c7b229be8a9;hp=1246a2538eb943a8c38219559242d5365c2a7c35;hpb=147525f11bc205ee05dc32643567d22fa60465c9;p=platform%2Fupstream%2Fbtrfs-progs.git

diff --git a/btrfs-list.c b/btrfs-list.c
index 1246a25..e01c589 100644
--- a/btrfs-list.c
+++ b/btrfs-list.c
@@ -16,12 +16,8 @@
  * Boston, MA 021110-1307, USA.
  */
 
-#define _GNU_SOURCE
-#ifndef __CHECKER__
 #include <sys/ioctl.h>
 #include <sys/mount.h>
-#include "ioctl.h"
-#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -33,8 +29,10 @@
 #include "ctree.h"
 #include "transaction.h"
 #include "utils.h"
+#include "ioctl.h"
 #include <uuid/uuid.h>
 #include "btrfs-list.h"
+#include "rbtree-utils.h"
 
 #define BTRFS_LIST_NFILTERS_INCREASE	(2 * BTRFS_LIST_FILTER_MAX)
 #define BTRFS_LIST_NCOMPS_INCREASE	(2 * BTRFS_LIST_COMP_MAX)
@@ -46,7 +44,7 @@ struct root_lookup {
 	struct rb_root root;
 };
 
-struct {
+static struct {
 	char	*name;
 	char	*column_name;
 	int	need_print;
@@ -87,6 +85,11 @@ struct {
 		.need_print	= 0,
 	},
 	{
+		.name		= "received_uuid",
+		.column_name	= "Received UUID",
+		.need_print	= 0,
+	},
+	{
 		.name		= "uuid",
 		.column_name	= "UUID",
 		.need_print	= 0,
@@ -110,7 +113,7 @@ void btrfs_list_setup_print_column(enum btrfs_list_column_enum column)
 {
 	int i;
 
-	BUG_ON(column < 0 || column > BTRFS_LIST_ALL);
+	ASSERT(0 <= column && column <= BTRFS_LIST_ALL);
 
 	if (column < BTRFS_LIST_ALL) {
 		btrfs_list_columns[column].need_print = 1;
@@ -121,11 +124,6 @@ void btrfs_list_setup_print_column(enum btrfs_list_column_enum column)
 		btrfs_list_columns[i].need_print = 1;
 }
 
-static void root_lookup_init(struct root_lookup *tree)
-{
-	tree->root.rb_node = NULL;
-}
-
 static int comp_entry_with_rootid(struct root_info *entry1,
 				  struct root_info *entry2,
 				  int is_descending)
@@ -223,40 +221,37 @@ struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void)
 
 	size = sizeof(struct btrfs_list_comparer_set) +
 	       BTRFS_LIST_NCOMPS_INCREASE * sizeof(struct btrfs_list_comparer);
-	set = malloc(size);
+	set = calloc(1, size);
 	if (!set) {
 		fprintf(stderr, "memory allocation failed\n");
 		exit(1);
 	}
 
-	memset(set, 0, size);
 	set->total = BTRFS_LIST_NCOMPS_INCREASE;
 
 	return set;
 }
 
-void btrfs_list_free_comparer_set(struct btrfs_list_comparer_set *comp_set)
-{
-	free(comp_set);
-}
-
-int btrfs_list_setup_comparer(struct btrfs_list_comparer_set  **comp_set,
-			      enum btrfs_list_comp_enum comparer,
-			      int is_descending)
+static int btrfs_list_setup_comparer(struct btrfs_list_comparer_set **comp_set,
+		enum btrfs_list_comp_enum comparer, int is_descending)
 {
 	struct btrfs_list_comparer_set *set = *comp_set;
 	int size;
 
-	BUG_ON(!set);
-	BUG_ON(comparer >= BTRFS_LIST_COMP_MAX);
-	BUG_ON(set->ncomps > set->total);
+	ASSERT(set != NULL);
+	ASSERT(comparer < BTRFS_LIST_COMP_MAX);
+	ASSERT(set->ncomps <= set->total);
 
 	if (set->ncomps == set->total) {
+		void *tmp;
+
 		size = set->total + BTRFS_LIST_NCOMPS_INCREASE;
 		size = sizeof(*set) + size * sizeof(struct btrfs_list_comparer);
+		tmp = set;
 		set = realloc(set, size);
 		if (!set) {
 			fprintf(stderr, "memory allocation failed\n");
+			free(tmp);
 			exit(1);
 		}
 
@@ -267,7 +262,7 @@ int btrfs_list_setup_comparer(struct btrfs_list_comparer_set  **comp_set,
 		*comp_set = set;
 	}
 
-	BUG_ON(set->comps[set->ncomps].comp_func);
+	ASSERT(set->comps[set->ncomps].comp_func == NULL);
 
 	set->comps[set->ncomps].comp_func = all_comp_funcs[comparer];
 	set->comps[set->ncomps].is_descending = is_descending;
@@ -282,7 +277,7 @@ static int sort_comp(struct root_info *entry1, struct root_info *entry2,
 	int i, ret = 0;
 
 	if (!set || !set->ncomps)
-		goto comp_rootid;
+		return comp_entry_with_rootid(entry1, entry2, 0);
 
 	for (i = 0; i < set->ncomps; i++) {
 		if (!set->comps[i].comp_func)
@@ -297,10 +292,8 @@ static int sort_comp(struct root_info *entry1, struct root_info *entry2,
 			rootid_compared = 1;
 	}
 
-	if (!rootid_compared) {
-comp_rootid:
+	if (!rootid_compared)
 		ret = comp_entry_with_rootid(entry1, entry2, 0);
-	}
 
 	return ret;
 }
@@ -394,7 +387,7 @@ static struct root_info *root_tree_search(struct root_lookup *root_tree,
 static int update_root(struct root_lookup *root_lookup,
 		       u64 root_id, u64 ref_tree, u64 root_offset, u64 flags,
 		       u64 dir_id, char *name, int name_len, u64 ogen, u64 gen,
-		       time_t ot, void *uuid, void *puuid)
+		       time_t otime, u8 *uuid, u8 *puuid, u8 *ruuid)
 {
 	struct root_info *ri;
 
@@ -402,8 +395,7 @@ static int update_root(struct root_lookup *root_lookup,
 	if (!ri || ri->root_id != root_id)
 		return -ENOENT;
 	if (name && name_len > 0) {
-		if (ri->name)
-			free(ri->name);
+		free(ri->name);
 
 		ri->name = malloc(name_len + 1);
 		if (!ri->name) {
@@ -427,12 +419,14 @@ static int update_root(struct root_lookup *root_lookup,
 		ri->ogen = ogen;
 	if (!ri->ogen && root_offset)
 		ri->ogen = root_offset;
-	if (ot)
-		ri->otime = ot;
+	if (otime)
+		ri->otime = otime;
 	if (uuid)
 		memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE);
 	if (puuid)
 		memcpy(&ri->puuid, puuid, BTRFS_UUID_SIZE);
+	if (ruuid)
+		memcpy(&ri->ruuid, ruuid, BTRFS_UUID_SIZE);
 
 	return 0;
 }
@@ -448,29 +442,30 @@ static int update_root(struct root_lookup *root_lookup,
  * name_len: the length of name
  * ogen: the original generation of the root
  * gen: the current generation of the root
- * ot: the original time(create time) of the root
+ * otime: the original time (creation time) of the root
  * uuid: uuid of the root
  * puuid: uuid of the root parent if any
+ * ruuid: uuid of the received subvol, if any
  */
 static int add_root(struct root_lookup *root_lookup,
 		    u64 root_id, u64 ref_tree, u64 root_offset, u64 flags,
 		    u64 dir_id, char *name, int name_len, u64 ogen, u64 gen,
-		    time_t ot, void *uuid, void *puuid)
+		    time_t otime, u8 *uuid, u8 *puuid, u8 *ruuid)
 {
 	struct root_info *ri;
 	int ret;
 
 	ret = update_root(root_lookup, root_id, ref_tree, root_offset, flags,
-			  dir_id, name, name_len, ogen, gen, ot, uuid, puuid);
+			  dir_id, name, name_len, ogen, gen, otime,
+			  uuid, puuid, ruuid);
 	if (!ret)
 		return 0;
 
-	ri = malloc(sizeof(*ri));
+	ri = calloc(1, sizeof(*ri));
 	if (!ri) {
 		printf("memory allocation failed\n");
 		exit(1);
 	}
-	memset(ri, 0, sizeof(*ri));
 	ri->root_id = root_id;
 
 	if (name && name_len > 0) {
@@ -496,8 +491,8 @@ static int add_root(struct root_lookup *root_lookup,
 		ri->ogen = ogen;
 	if (!ri->ogen && root_offset)
 		ri->ogen = root_offset;
-	if (ot)
-		ri->otime = ot;
+	if (otime)
+		ri->otime = otime;
 
 	if (uuid)
 		memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE);
@@ -505,41 +500,39 @@ static int add_root(struct root_lookup *root_lookup,
 	if (puuid)
 		memcpy(&ri->puuid, puuid, BTRFS_UUID_SIZE);
 
+	if (ruuid)
+		memcpy(&ri->ruuid, ruuid, BTRFS_UUID_SIZE);
+
 	ret = root_tree_insert(root_lookup, ri);
-	if (ret) {
-		printf("failed to insert tree %llu\n", (unsigned long long)root_id);
+	if (ret < 0) {
+		error("failed to insert subvolume %llu to tree: %s",
+				(unsigned long long)root_id, strerror(-ret));
 		exit(1);
 	}
 	return 0;
 }
 
-void __free_root_info(struct root_info *ri)
+/*
+ * Simplified add_root for back references, omits the uuid and original info
+ * parameters, root offset and flags.
+ */
+static int add_root_backref(struct root_lookup *root_lookup, u64 root_id,
+		u64 ref_tree, u64 dir_id, char *name, int name_len)
 {
-	if (ri->name)
-		free(ri->name);
-
-	if (ri->path)
-		free(ri->path);
-
-	if (ri->full_path)
-		free(ri->full_path);
-
-	free(ri);
+	return add_root(root_lookup, root_id, ref_tree, 0, 0, dir_id, name,
+			name_len, 0, 0, 0, NULL, NULL, NULL);
 }
 
-void __free_all_subvolumn(struct root_lookup *root_tree)
-{
-	struct root_info *entry;
-	struct rb_node *n;
 
-	n = rb_first(&root_tree->root);
-	while (n) {
-		entry = rb_entry(n, struct root_info, rb_node);
-		rb_erase(n, &root_tree->root);
-		__free_root_info(entry);
+static void free_root_info(struct rb_node *node)
+{
+	struct root_info *ri;
 
-		n = rb_first(&root_tree->root);
-	}
+	ri = rb_entry(node, struct root_info, rb_node);
+	free(ri->name);
+	free(ri->path);
+	free(ri->full_path);
+	free(ri);
 }
 
 /*
@@ -567,7 +560,7 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
 		int add_len;
 
 		/*
-		 * ref_tree = 0 indicates the subvolumes
+		 * ref_tree = 0 indicates the subvolume
 		 * has been deleted.
 		 */
 		if (!found->ref_tree) {
@@ -595,23 +588,18 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
 			full_path = strdup(found->path);
 			len = add_len;
 		}
+		if (!ri->top_id)
+			ri->top_id = found->ref_tree;
 
 		next = found->ref_tree;
-
-		if (next == top_id) {
-			ri->top_id = top_id;
+		if (next == top_id)
 			break;
-		}
-
 		/*
 		* if the ref_tree = BTRFS_FS_TREE_OBJECTID,
 		* we are at the top
 		*/
-		if (next == BTRFS_FS_TREE_OBJECTID) {
-			ri->top_id = next;
+		if (next == BTRFS_FS_TREE_OBJECTID)
 			break;
-		}
-
 		/*
 		* if the ref_tree wasn't in our tree of roots, the
 		* subvolume was deleted.
@@ -638,7 +626,7 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
 static int lookup_ino_path(int fd, struct root_info *ri)
 {
 	struct btrfs_ioctl_ino_lookup_args args;
-	int ret, e;
+	int ret;
 
 	if (ri->path)
 		return 0;
@@ -651,15 +639,13 @@ static int lookup_ino_path(int fd, struct root_info *ri)
 	args.objectid = ri->dir_id;
 
 	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
-	e = errno;
-	if (ret) {
-		if (e == ENOENT) {
+	if (ret < 0) {
+		if (errno == ENOENT) {
 			ri->ref_tree = 0;
 			return -ENOENT;
 		}
-		fprintf(stderr, "ERROR: Failed to lookup path for root %llu - %s\n",
-			(unsigned long long)ri->ref_tree,
-			strerror(e));
+		error("failed to lookup path for root %llu: %m",
+			(unsigned long long)ri->ref_tree);
 		return ret;
 	}
 
@@ -687,7 +673,7 @@ static int lookup_ino_path(int fd, struct root_info *ri)
 }
 
 /* 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
+ * First we use the inode lookup 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
@@ -702,24 +688,21 @@ static u64 find_root_gen(int fd)
 	unsigned long off = 0;
 	u64 max_found = 0;
 	int i;
-	int e;
 
 	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);
-	e = errno;
-	if (ret) {
-		fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu - %s\n",
-			(unsigned long long)BTRFS_FIRST_FREE_OBJECTID,
-			strerror(e));
+	if (ret < 0) {
+		error("failed to lookup path for dirid %llu: %m",
+			(unsigned long long)BTRFS_FIRST_FREE_OBJECTID);
 		return 0;
 	}
 
 	memset(&args, 0, sizeof(args));
 
-	sk->tree_id = 1;
+	sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
 
 	/*
 	 * there may be more than one ROOT_ITEM key if there are
@@ -736,10 +719,8 @@ static u64 find_root_gen(int fd)
 
 	while (1) {
 		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
-		e = errno;
 		if (ret < 0) {
-			fprintf(stderr, "ERROR: can't perform the search - %s\n",
-				strerror(e));
+			error("can't perform the search: %m");
 			return 0;
 		}
 		/* the ioctl returns the number of item it found in nr_items */
@@ -793,16 +774,14 @@ static char *__ino_resolve(int fd, u64 dirid)
 	struct btrfs_ioctl_ino_lookup_args args;
 	int ret;
 	char *full;
-	int e;
 
 	memset(&args, 0, sizeof(args));
 	args.objectid = dirid;
 
 	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
-	e = errno;
-	if (ret) {
-		fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu - %s\n",
-			(unsigned long long)dirid, strerror(e) );
+	if (ret < 0) {
+		error("failed to lookup path for dirid %llu: %m",
+			(unsigned long long)dirid);
 		return ERR_PTR(ret);
 	}
 
@@ -827,9 +806,10 @@ static char *__ino_resolve(int fd, u64 dirid)
  * simple string builder, returning a new string with both
  * dirid and name
  */
-char *build_name(char *dirid, char *name)
+static char *build_name(const char *dirid, const char *name)
 {
 	char *full;
+
 	if (!dirid)
 		return strdup(name);
 
@@ -860,7 +840,6 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
 	struct btrfs_ioctl_search_header *sh;
 	unsigned long off = 0;
 	int namelen;
-	int e;
 
 	memset(&args, 0, sizeof(args));
 
@@ -879,10 +858,8 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
 	sk->nr_items = 1;
 
 	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
-	e = errno;
 	if (ret < 0) {
-		fprintf(stderr, "ERROR: can't perform the search - %s\n",
-			strerror(e));
+		error("can't perform the search: %m");
 		return NULL;
 	}
 	/* the ioctl returns the number of item it found in nr_items */
@@ -892,9 +869,9 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
 	off = 0;
 	sh = (struct btrfs_ioctl_search_header *)(args.buf + off);
 
-	if (sh->type == BTRFS_INODE_REF_KEY) {
+	if (btrfs_search_header_type(sh) == BTRFS_INODE_REF_KEY) {
 		struct btrfs_inode_ref *ref;
-		dirid = sh->offset;
+		dirid = btrfs_search_header_offset(sh);
 
 		ref = (struct btrfs_inode_ref *)(sh + 1);
 		namelen = btrfs_stack_inode_ref_name_len(ref);
@@ -941,7 +918,7 @@ int btrfs_list_get_default_subvolume(int fd, u64 *default_id)
 	 * search for a dir item with a name 'default' in the tree of
 	 * tree roots, it should point us to a default root
 	 */
-	sk->tree_id = 1;
+	sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
 
 	/* don't worry about ancient format and request only one item */
 	sk->nr_items = 1;
@@ -963,7 +940,7 @@ int btrfs_list_get_default_subvolume(int fd, u64 *default_id)
 
 	sh = (struct btrfs_ioctl_search_header *)args.buf;
 
-	if (sh->type == BTRFS_DIR_ITEM_KEY) {
+	if (btrfs_search_header_type(sh) == BTRFS_DIR_ITEM_KEY) {
 		struct btrfs_dir_item *di;
 		int name_len;
 		char *name;
@@ -981,7 +958,7 @@ out:
 	return 0;
 }
 
-static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
+static int list_subvol_search(int fd, struct root_lookup *root_lookup)
 {
 	int ret;
 	struct btrfs_ioctl_search_args args;
@@ -989,7 +966,7 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
 	struct btrfs_ioctl_search_header sh;
 	struct btrfs_root_ref *ref;
 	struct btrfs_root_item *ri;
-	unsigned long off = 0;
+	unsigned long off;
 	int name_len;
 	char *name;
 	u64 dir_id;
@@ -997,41 +974,24 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
 	u64 ogen;
 	u64 flags;
 	int i;
-	time_t t;
-	u8 uuid[BTRFS_UUID_SIZE];
-	u8 puuid[BTRFS_UUID_SIZE];
 
-	root_lookup_init(root_lookup);
+	root_lookup->root.rb_node = NULL;
 	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->tree_id = BTRFS_ROOT_TREE_OBJECTID;
+	/* Search both live and deleted subvolumes */
 	sk->min_type = BTRFS_ROOT_ITEM_KEY;
-
-	sk->min_objectid = BTRFS_FIRST_FREE_OBJECTID;
-
-	/*
-	 * set all the other params to the max, we'll take any objectid
-	 * and any trans
-	 */
+	sk->max_type = BTRFS_ROOT_BACKREF_KEY;
+	sk->min_objectid = BTRFS_FS_TREE_OBJECTID;
 	sk->max_objectid = BTRFS_LAST_FREE_OBJECTID;
 	sk->max_offset = (u64)-1;
 	sk->max_transid = (u64)-1;
 
-	/* just a big number, doesn't matter much */
-	sk->nr_items = 4096;
-
 	while(1) {
+		sk->nr_items = 4096;
 		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
 		if (ret < 0)
 			return ret;
-		/* the ioctl returns the number of item it found in nr_items */
 		if (sk->nr_items == 0)
 			break;
 
@@ -1050,44 +1010,48 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
 				name = (char *)(ref + 1);
 				dir_id = btrfs_stack_root_ref_dirid(ref);
 
-				add_root(root_lookup, sh.objectid, sh.offset,
-					 0, 0, dir_id, name, name_len, 0, 0, 0,
-					 NULL, NULL);
-			} else if (sh.type == BTRFS_ROOT_ITEM_KEY) {
+				add_root_backref(root_lookup, sh.objectid,
+						sh.offset, dir_id, name,
+						name_len);
+			} else if (sh.type == BTRFS_ROOT_ITEM_KEY &&
+				   (sh.objectid >= BTRFS_FIRST_FREE_OBJECTID ||
+				    sh.objectid == BTRFS_FS_TREE_OBJECTID)) {
+				time_t otime;
+				u8 uuid[BTRFS_UUID_SIZE];
+				u8 puuid[BTRFS_UUID_SIZE];
+				u8 ruuid[BTRFS_UUID_SIZE];
+
 				ri = (struct btrfs_root_item *)(args.buf + off);
 				gen = btrfs_root_generation(ri);
 				flags = btrfs_root_flags(ri);
 				if(sh.len >
 				   sizeof(struct btrfs_root_item_v0)) {
-					t = ri->otime.sec;
+					otime = btrfs_stack_timespec_sec(&ri->otime);
 					ogen = btrfs_root_otransid(ri);
 					memcpy(uuid, ri->uuid, BTRFS_UUID_SIZE);
 					memcpy(puuid, ri->parent_uuid, BTRFS_UUID_SIZE);
+					memcpy(ruuid, ri->received_uuid, BTRFS_UUID_SIZE);
 				} else {
-					t = 0;
+					otime = 0;
 					ogen = 0;
 					memset(uuid, 0, BTRFS_UUID_SIZE);
 					memset(puuid, 0, BTRFS_UUID_SIZE);
+					memset(ruuid, 0, BTRFS_UUID_SIZE);
 				}
 
 				add_root(root_lookup, sh.objectid, 0,
 					 sh.offset, flags, 0, NULL, 0, ogen,
-					 gen, t, uuid, puuid);
+					 gen, otime, uuid, puuid, ruuid);
 			}
 
 			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;
 		sk->min_offset++;
-		if (!sk->min_offset)	/* overflow */
+		if (!sk->min_offset)
 			sk->min_type++;
 		else
 			continue;
@@ -1180,7 +1144,12 @@ static int filter_full_path(struct root_info *ri, u64 data)
 
 static int filter_by_parent(struct root_info *ri, u64 data)
 {
-	return !uuid_compare(ri->puuid, (u8 *)data);
+	return !uuid_compare(ri->puuid, (u8 *)(unsigned long)data);
+}
+
+static int filter_deleted(struct root_info *ri, u64 data)
+{
+	return ri->deleted;
 }
 
 static btrfs_list_filter_func all_filter_funcs[] = {
@@ -1196,6 +1165,7 @@ static btrfs_list_filter_func all_filter_funcs[] = {
 	[BTRFS_LIST_FILTER_TOPID_EQUAL]		= filter_topid_equal,
 	[BTRFS_LIST_FILTER_FULL_PATH]		= filter_full_path,
 	[BTRFS_LIST_FILTER_BY_PARENT]		= filter_by_parent,
+	[BTRFS_LIST_FILTER_DELETED]		= filter_deleted,
 };
 
 struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void)
@@ -1205,39 +1175,41 @@ struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void)
 
 	size = sizeof(struct btrfs_list_filter_set) +
 	       BTRFS_LIST_NFILTERS_INCREASE * sizeof(struct btrfs_list_filter);
-	set = malloc(size);
+	set = calloc(1, size);
 	if (!set) {
 		fprintf(stderr, "memory allocation failed\n");
 		exit(1);
 	}
 
-	memset(set, 0, size);
 	set->total = BTRFS_LIST_NFILTERS_INCREASE;
 
 	return set;
 }
 
-void btrfs_list_free_filter_set(struct btrfs_list_filter_set *filter_set)
-{
-	free(filter_set);
-}
-
-int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
+/*
+ * Setup list filters. Exit if there's not enough memory, as we can't continue
+ * without the structures set up properly.
+ */
+void btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
 			    enum btrfs_list_filter_enum filter, u64 data)
 {
 	struct btrfs_list_filter_set *set = *filter_set;
 	int size;
 
-	BUG_ON(!set);
-	BUG_ON(filter >= BTRFS_LIST_FILTER_MAX);
-	BUG_ON(set->nfilters > set->total);
+	ASSERT(set != NULL);
+	ASSERT(filter < BTRFS_LIST_FILTER_MAX);
+	ASSERT(set->nfilters <= set->total);
 
 	if (set->nfilters == set->total) {
+		void *tmp;
+
 		size = set->total + BTRFS_LIST_NFILTERS_INCREASE;
 		size = sizeof(*set) + size * sizeof(struct btrfs_list_filter);
+		tmp = set;
 		set = realloc(set, size);
 		if (!set) {
 			fprintf(stderr, "memory allocation failed\n");
+			free(tmp);
 			exit(1);
 		}
 
@@ -1248,12 +1220,14 @@ int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
 		*filter_set = set;
 	}
 
-	BUG_ON(set->filters[set->nfilters].filter_func);
+	ASSERT(set->filters[set->nfilters].filter_func == NULL);
+
+	if (filter == BTRFS_LIST_FILTER_DELETED)
+		set->only_deleted = 1;
 
 	set->filters[set->nfilters].filter_func = all_filter_funcs[filter];
 	set->filters[set->nfilters].data = data;
 	set->nfilters++;
-	return 0;
 }
 
 static int filter_root(struct root_info *ri,
@@ -1261,9 +1235,15 @@ static int filter_root(struct root_info *ri,
 {
 	int i, ret;
 
-	if (!set || !set->nfilters)
+	if (!set)
 		return 1;
 
+	if (set->only_deleted && !ri->deleted)
+		return 0;
+
+	if (!set->only_deleted && ri->deleted)
+		return 0;
+
 	for (i = 0; i < set->nfilters; i++) {
 		if (!set->filters[i].filter_func)
 			break;
@@ -1274,7 +1254,7 @@ static int filter_root(struct root_info *ri,
 	return 1;
 }
 
-static void __filter_and_sort_subvol(struct root_lookup *all_subvols,
+static void filter_and_sort_subvol(struct root_lookup *all_subvols,
 				    struct root_lookup *sort_tree,
 				    struct btrfs_list_filter_set *filter_set,
 				    struct btrfs_list_comparer_set *comp_set,
@@ -1284,24 +1264,35 @@ static void __filter_and_sort_subvol(struct root_lookup *all_subvols,
 	struct root_info *entry;
 	int ret;
 
-	root_lookup_init(sort_tree);
+	sort_tree->root.rb_node = NULL;
 
 	n = rb_last(&all_subvols->root);
 	while (n) {
 		entry = rb_entry(n, struct root_info, rb_node);
 
 		ret = resolve_root(all_subvols, entry, top_id);
-		if (ret == -ENOENT)
-			goto skip;
+		if (ret == -ENOENT) {
+			if (entry->root_id != BTRFS_FS_TREE_OBJECTID) {
+				entry->full_path = strdup("DELETED");
+				entry->deleted = 1;
+			} else {
+				/*
+				 * The full path is not supposed to be printed,
+				 * but we don't want to print an empty string,
+				 * in case it appears somewhere.
+				 */
+				entry->full_path = strdup("TOPLEVEL");
+				entry->deleted = 0;
+			}
+		}
 		ret = filter_root(entry, filter_set);
 		if (ret)
 			sort_tree_insert(sort_tree, entry, comp_set);
-skip:
 		n = rb_prev(n);
 	}
 }
 
-static int __list_subvol_fill_paths(int fd, struct root_lookup *root_lookup)
+static int list_subvol_fill_paths(int fd, struct root_lookup *root_lookup)
 {
 	struct rb_node *n;
 
@@ -1323,9 +1314,9 @@ static void print_subvolume_column(struct root_info *subv,
 				   enum btrfs_list_column_enum column)
 {
 	char tstr[256];
-	char uuidparse[37];
+	char uuidparse[BTRFS_UUID_UNPARSED_SIZE];
 
-	BUG_ON(column >= BTRFS_LIST_ALL || column < 0);
+	ASSERT(0 <= column && column < BTRFS_LIST_ALL);
 
 	switch (column) {
 	case BTRFS_LIST_OBJECTID:
@@ -1344,10 +1335,12 @@ static void print_subvolume_column(struct root_info *subv,
 		printf("%llu", subv->top_id);
 		break;
 	case BTRFS_LIST_OTIME:
-		if (subv->otime)
-			strftime(tstr, 256, "%Y-%m-%d %X",
-				 localtime(&subv->otime));
-		else
+		if (subv->otime) {
+			struct tm tm;
+
+			localtime_r(&subv->otime, &tm);
+			strftime(tstr, 256, "%Y-%m-%d %X", &tm);
+		} else
 			strcpy(tstr, "-");
 		printf("%s", tstr);
 		break;
@@ -1356,14 +1349,21 @@ static void print_subvolume_column(struct root_info *subv,
 			strcpy(uuidparse, "-");
 		else
 			uuid_unparse(subv->uuid, uuidparse);
-		printf("%s", uuidparse);
+		printf("%-36s", uuidparse);
 		break;
 	case BTRFS_LIST_PUUID:
 		if (uuid_is_null(subv->puuid))
 			strcpy(uuidparse, "-");
 		else
 			uuid_unparse(subv->puuid, uuidparse);
-		printf("%s", uuidparse);
+		printf("%-36s", uuidparse);
+		break;
+	case BTRFS_LIST_RUUID:
+		if (uuid_is_null(subv->ruuid))
+			strcpy(uuidparse, "-");
+		else
+			uuid_unparse(subv->ruuid, uuidparse);
+		printf("%-36s", uuidparse);
 		break;
 	case BTRFS_LIST_PATH:
 		BUG_ON(!subv->full_path);
@@ -1374,7 +1374,8 @@ static void print_subvolume_column(struct root_info *subv,
 	}
 }
 
-static void print_single_volume_info_raw(struct root_info *subv, char *raw_prefix)
+static void print_one_subvol_info_raw(struct root_info *subv,
+		const char *raw_prefix)
 {
 	int i;
 
@@ -1390,7 +1391,7 @@ static void print_single_volume_info_raw(struct root_info *subv, char *raw_prefi
 	printf("\n");
 }
 
-static void print_single_volume_info_table(struct root_info *subv)
+static void print_one_subvol_info_table(struct root_info *subv)
 {
 	int i;
 
@@ -1409,7 +1410,7 @@ static void print_single_volume_info_table(struct root_info *subv)
 	printf("\n");
 }
 
-static void print_single_volume_info_default(struct root_info *subv)
+static void print_one_subvol_info_default(struct root_info *subv)
 {
 	int i;
 
@@ -1426,7 +1427,7 @@ static void print_single_volume_info_default(struct root_info *subv)
 	printf("\n");
 }
 
-static void print_all_volume_info_tab_head()
+static void print_all_subvol_info_tab_head(void)
 {
 	int i;
 	int len;
@@ -1455,41 +1456,46 @@ static void print_all_volume_info_tab_head()
 	}
 }
 
-static void print_all_volume_info(struct root_lookup *sorted_tree,
-				  int layout, char *raw_prefix)
+static void print_all_subvol_info(struct root_lookup *sorted_tree,
+		  enum btrfs_list_layout layout, const char *raw_prefix)
 {
 	struct rb_node *n;
 	struct root_info *entry;
 
 	if (layout == BTRFS_LIST_LAYOUT_TABLE)
-		print_all_volume_info_tab_head();
+		print_all_subvol_info_tab_head();
 
 	n = rb_first(&sorted_tree->root);
 	while (n) {
 		entry = rb_entry(n, struct root_info, sort_node);
+
+		/* The toplevel subvolume is not listed by default */
+		if (entry->root_id == BTRFS_FS_TREE_OBJECTID)
+			goto next;
+
 		switch (layout) {
 		case BTRFS_LIST_LAYOUT_DEFAULT:
-			print_single_volume_info_default(entry);
+			print_one_subvol_info_default(entry);
 			break;
 		case BTRFS_LIST_LAYOUT_TABLE:
-			print_single_volume_info_table(entry);
+			print_one_subvol_info_table(entry);
 			break;
 		case BTRFS_LIST_LAYOUT_RAW:
-			print_single_volume_info_raw(entry, raw_prefix);
+			print_one_subvol_info_raw(entry, raw_prefix);
 			break;
 		}
+next:
 		n = rb_next(n);
 	}
 }
 
-int btrfs_list_subvols(int fd, struct root_lookup *root_lookup)
+static int btrfs_list_subvols(int fd, struct root_lookup *root_lookup)
 {
 	int ret;
 
-	ret = __list_subvol_search(fd, root_lookup);
+	ret = list_subvol_search(fd, root_lookup);
 	if (ret) {
-		fprintf(stderr, "ERROR: can't perform the search - %s\n",
-				strerror(errno));
+		error("can't perform the search: %m");
 		return ret;
 	}
 
@@ -1497,13 +1503,14 @@ int btrfs_list_subvols(int fd, struct root_lookup *root_lookup)
 	 * 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.
 	 */
-	ret = __list_subvol_fill_paths(fd, root_lookup);
+	ret = list_subvol_fill_paths(fd, root_lookup);
 	return ret;
 }
 
 int btrfs_list_subvols_print(int fd, struct btrfs_list_filter_set *filter_set,
 		       struct btrfs_list_comparer_set *comp_set,
-		       int layout, int full_path, char *raw_prefix)
+		       enum btrfs_list_layout layout, int full_path,
+		       const char *raw_prefix)
 {
 	struct root_lookup root_lookup;
 	struct root_lookup root_sort;
@@ -1518,22 +1525,53 @@ int btrfs_list_subvols_print(int fd, struct btrfs_list_filter_set *filter_set,
 	ret = btrfs_list_subvols(fd, &root_lookup);
 	if (ret)
 		return ret;
-	__filter_and_sort_subvol(&root_lookup, &root_sort, filter_set,
+	filter_and_sort_subvol(&root_lookup, &root_sort, filter_set,
 				 comp_set, top_id);
 
-	print_all_volume_info(&root_sort, layout, raw_prefix);
-	__free_all_subvolumn(&root_lookup);
+	print_all_subvol_info(&root_sort, layout, raw_prefix);
+	rb_free_nodes(&root_lookup.root, free_root_info);
 
 	return 0;
 }
 
-char *strdup_or_null(const char *s)
+static char *strdup_or_null(const char *s)
 {
 	if (!s)
 		return NULL;
 	return strdup(s);
 }
 
+int btrfs_get_toplevel_subvol(int fd, struct root_info *the_ri)
+{
+	int ret;
+	struct root_lookup rl;
+	struct rb_node *rbn;
+	struct root_info *ri;
+	u64 root_id;
+
+	ret = btrfs_list_get_path_rootid(fd, &root_id);
+	if (ret)
+		return ret;
+
+	ret = btrfs_list_subvols(fd, &rl);
+	if (ret)
+		return ret;
+
+	rbn = rb_first(&rl.root);
+	ri = rb_entry(rbn, struct root_info, rb_node);
+
+	if (ri->root_id != BTRFS_FS_TREE_OBJECTID)
+		return -ENOENT;
+
+	memcpy(the_ri, ri, offsetof(struct root_info, path));
+	the_ri->path = strdup_or_null("/");
+	the_ri->name = strdup_or_null("<FS_TREE>");
+	the_ri->full_path = strdup_or_null("/");
+	rb_free_nodes(&rl.root, free_root_info);
+
+	return ret;
+}
+
 int btrfs_get_subvol(int fd, struct root_info *the_ri)
 {
 	int ret, rr;
@@ -1559,7 +1597,9 @@ int btrfs_get_subvol(int fd, struct root_info *the_ri)
 			rbn = rb_next(rbn);
 			continue;
 		}
-		if (!comp_entry_with_rootid(the_ri, ri, 0)) {
+
+		if (!comp_entry_with_rootid(the_ri, ri, 0) ||
+			!uuid_compare(the_ri->uuid, ri->uuid)) {
 			memcpy(the_ri, ri, offsetof(struct root_info, path));
 			the_ri->path = strdup_or_null(ri->path);
 			the_ri->name = strdup_or_null(ri->name);
@@ -1569,7 +1609,7 @@ int btrfs_get_subvol(int fd, struct root_info *the_ri)
 		}
 		rbn = rb_next(rbn);
 	}
-	__free_all_subvolumn(&rl);
+	rb_free_nodes(&rl.root, free_root_info);
 	return ret;
 }
 
@@ -1587,17 +1627,18 @@ static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh,
 	int flags = 0;
 	char *name = NULL;
 
-	if (sh->objectid == *cache_ino) {
+	if (btrfs_search_header_objectid(sh) == *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,
+		name = ino_resolve(fd, btrfs_search_header_objectid(sh),
+				   cache_dirid,
 				   cache_dir_name);
 		*cache_full_name = name;
-		*cache_ino = sh->objectid;
+		*cache_ino = btrfs_search_header_objectid(sh);
 	}
 	if (!name)
 		return -EIO;
@@ -1615,19 +1656,19 @@ static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh,
 		disk_offset = 0;
 		len = btrfs_stack_file_extent_ram_bytes(item);
 	} else {
-		printf("unhandled extent type %d for inode %llu "
-		       "file offset %llu gen %llu\n",
+		error(
+	"unhandled extent type %d for inode %llu file offset %llu gen %llu",
 			type,
-			(unsigned long long)sh->objectid,
-			(unsigned long long)sh->offset,
+			(unsigned long long)btrfs_search_header_objectid(sh),
+			(unsigned long long)btrfs_search_header_offset(sh),
 			(unsigned long long)found_gen);
 
 		return -EIO;
 	}
 	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)btrfs_search_header_objectid(sh),
+	       (unsigned long long)btrfs_search_header_offset(sh),
 	       (unsigned long long)len,
 	       (unsigned long long)disk_start,
 	       (unsigned long long)disk_offset,
@@ -1663,7 +1704,6 @@ int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen)
 	u64 found_gen;
 	u64 max_found = 0;
 	int i;
-	int e;
 	u64 cache_dirid = 0;
 	u64 cache_ino = 0;
 	char *cache_dir_name = NULL;
@@ -1690,11 +1730,9 @@ int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen)
 	max_found = find_root_gen(fd);
 	while(1) {
 		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
-		e = errno;
 		if (ret < 0) {
-			fprintf(stderr, "ERROR: can't perform the search- %s\n",
-				strerror(e));
-			return ret;
+			error("can't perform the search: %m");
+			break;
 		}
 		/* the ioctl returns the number of item it found in nr_items */
 		if (sk->nr_items == 0)
@@ -1764,11 +1802,11 @@ char *btrfs_list_path_for_root(int fd, u64 root)
 	if (ret)
 		return ERR_PTR(ret);
 
-	ret = __list_subvol_search(fd, &root_lookup);
+	ret = list_subvol_search(fd, &root_lookup);
 	if (ret < 0)
 		return ERR_PTR(ret);
 
-	ret = __list_subvol_fill_paths(fd, &root_lookup);
+	ret = list_subvol_fill_paths(fd, &root_lookup);
 	if (ret < 0)
 		return ERR_PTR(ret);
 
@@ -1789,12 +1827,12 @@ char *btrfs_list_path_for_root(int fd, u64 root)
 
 		n = rb_prev(n);
 	}
-	__free_all_subvolumn(&root_lookup);
+	rb_free_nodes(&root_lookup.root, free_root_info);
 
 	return ret_path;
 }
 
-int btrfs_list_parse_sort_string(char *optarg,
+int btrfs_list_parse_sort_string(char *opt_arg,
 				 struct btrfs_list_comparer_set **comps)
 {
 	int order;
@@ -1803,7 +1841,7 @@ int btrfs_list_parse_sort_string(char *optarg,
 	char **ptr_argv;
 	int what_to_sort;
 
-	while ((p = strtok(optarg, ",")) != NULL) {
+	while ((p = strtok(opt_arg, ",")) != NULL) {
 		flag = 0;
 		ptr_argv = all_sort_items;
 
@@ -1839,7 +1877,7 @@ int btrfs_list_parse_sort_string(char *optarg,
 			what_to_sort = btrfs_list_get_sort_item(p);
 			btrfs_list_setup_comparer(comps, what_to_sort, order);
 		}
-		optarg = NULL;
+		opt_arg = NULL;
 	}
 
 	return 0;
@@ -1850,38 +1888,30 @@ int btrfs_list_parse_sort_string(char *optarg,
  *
  * type is the filter object.
  */
-int btrfs_list_parse_filter_string(char *optarg,
+int btrfs_list_parse_filter_string(char *opt_arg,
 				   struct btrfs_list_filter_set **filters,
 				   enum btrfs_list_filter_enum type)
 {
 
 	u64 arg;
-	char *ptr_parse_end = NULL;
-	char *ptr_optarg_end = optarg + strlen(optarg);
 
-	switch (*(optarg++)) {
+	switch (*(opt_arg++)) {
 	case '+':
-		arg = (u64)strtol(optarg, &ptr_parse_end, 10);
+		arg = arg_strtou64(opt_arg);
 		type += 2;
-		if (ptr_parse_end != ptr_optarg_end)
-			return -1;
 
 		btrfs_list_setup_filter(filters, type, arg);
 		break;
 	case '-':
-		arg = (u64)strtoll(optarg, &ptr_parse_end, 10);
+		arg = arg_strtou64(opt_arg);
 		type += 1;
-		if (ptr_parse_end != ptr_optarg_end)
-			return -1;
 
 		btrfs_list_setup_filter(filters, type, arg);
 		break;
 	default:
-		optarg--;
-		arg = (u64)strtoll(optarg, &ptr_parse_end, 10);
+		opt_arg--;
+		arg = arg_strtou64(opt_arg);
 
-		if (ptr_parse_end != ptr_optarg_end)
-			return -1;
 		btrfs_list_setup_filter(filters, type, arg);
 		break;
 	}
@@ -1891,19 +1921,11 @@ int btrfs_list_parse_filter_string(char *optarg,
 
 int btrfs_list_get_path_rootid(int fd, u64 *treeid)
 {
-	int  ret;
-	struct btrfs_ioctl_ino_lookup_args args;
+	int ret;
 
-	memset(&args, 0, sizeof(args));
-	args.objectid = BTRFS_FIRST_FREE_OBJECTID;
+	ret = lookup_path_rootid(fd, treeid);
+	if (ret < 0)
+		error("cannot resolve rootid for path: %m");
 
-	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
-	if (ret < 0) {
-		fprintf(stderr,
-			"ERROR: can't perform the search -%s\n",
-			strerror(errno));
-		return ret;
-	}
-	*treeid = args.treeid;
-	return 0;
+	return ret;
 }