diff --git a/btrfs-list.c b/btrfs-list.c
index e01c5899..a2fdb3f9 100644
--- a/btrfs-list.c
+++ b/btrfs-list.c
@@ -34,9 +34,6 @@
 #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)
-
 /* we store all the roots we find in an rbtree so that we can
  * search for them later.
  */
@@ -44,285 +41,14 @@ struct root_lookup {
 	struct rb_root root;
 };
 
-static struct {
-	char	*name;
-	char	*column_name;
-	int	need_print;
-} btrfs_list_columns[] = {
-	{
-		.name		= "ID",
-		.column_name	= "ID",
-		.need_print	= 0,
-	},
-	{
-		.name		= "gen",
-		.column_name	= "Gen",
-		.need_print	= 0,
-	},
-	{
-		.name		= "cgen",
-		.column_name	= "CGen",
-		.need_print	= 0,
-	},
-	{
-		.name		= "parent",
-		.column_name	= "Parent",
-		.need_print	= 0,
-	},
-	{
-		.name		= "top level",
-		.column_name	= "Top Level",
-		.need_print	= 0,
-	},
-	{
-		.name		= "otime",
-		.column_name	= "OTime",
-		.need_print	= 0,
-	},
-	{
-		.name		= "parent_uuid",
-		.column_name	= "Parent UUID",
-		.need_print	= 0,
-	},
-	{
-		.name		= "received_uuid",
-		.column_name	= "Received UUID",
-		.need_print	= 0,
-	},
-	{
-		.name		= "uuid",
-		.column_name	= "UUID",
-		.need_print	= 0,
-	},
-	{
-		.name		= "path",
-		.column_name	= "Path",
-		.need_print	= 0,
-	},
-	{
-		.name		= NULL,
-		.column_name	= NULL,
-		.need_print	= 0,
-	},
-};
-
-static btrfs_list_filter_func all_filter_funcs[];
-static btrfs_list_comp_func all_comp_funcs[];
-
-void btrfs_list_setup_print_column(enum btrfs_list_column_enum column)
+static int comp_rootid(struct root_info *entry1, struct root_info *entry2)
 {
-	int i;
-
-	ASSERT(0 <= column && column <= BTRFS_LIST_ALL);
-
-	if (column < BTRFS_LIST_ALL) {
-		btrfs_list_columns[column].need_print = 1;
-		return;
-	}
-
-	for (i = 0; i < BTRFS_LIST_ALL; i++)
-		btrfs_list_columns[i].need_print = 1;
-}
-
-static int comp_entry_with_rootid(struct root_info *entry1,
-				  struct root_info *entry2,
-				  int is_descending)
-{
-	int ret;
-
 	if (entry1->root_id > entry2->root_id)
-		ret = 1;
+		return 1;
 	else if (entry1->root_id < entry2->root_id)
-		ret = -1;
-	else
-		ret = 0;
-
-	return is_descending ? -ret : ret;
-}
-
-static int comp_entry_with_gen(struct root_info *entry1,
-			       struct root_info *entry2,
-			       int is_descending)
-{
-	int ret;
-
-	if (entry1->gen > entry2->gen)
-		ret = 1;
-	else if (entry1->gen < entry2->gen)
-		ret = -1;
-	else
-		ret = 0;
-
-	return is_descending ? -ret : ret;
-}
-
-static int comp_entry_with_ogen(struct root_info *entry1,
-				struct root_info *entry2,
-				int is_descending)
-{
-	int ret;
-
-	if (entry1->ogen > entry2->ogen)
-		ret = 1;
-	else if (entry1->ogen < entry2->ogen)
-		ret = -1;
+		return -1;
 	else
-		ret = 0;
-
-	return is_descending ? -ret : ret;
-}
-
-static int comp_entry_with_path(struct root_info *entry1,
-				struct root_info *entry2,
-				int is_descending)
-{
-	int ret;
-
-	if (strcmp(entry1->full_path, entry2->full_path) > 0)
-		ret = 1;
-	else if (strcmp(entry1->full_path, entry2->full_path) < 0)
-		ret = -1;
-	else
-		ret = 0;
-
-	return is_descending ? -ret : ret;
-}
-
-static btrfs_list_comp_func all_comp_funcs[] = {
-	[BTRFS_LIST_COMP_ROOTID]	= comp_entry_with_rootid,
-	[BTRFS_LIST_COMP_OGEN]		= comp_entry_with_ogen,
-	[BTRFS_LIST_COMP_GEN]		= comp_entry_with_gen,
-	[BTRFS_LIST_COMP_PATH]		= comp_entry_with_path,
-};
-
-static char *all_sort_items[] = {
-	[BTRFS_LIST_COMP_ROOTID]	= "rootid",
-	[BTRFS_LIST_COMP_OGEN]		= "ogen",
-	[BTRFS_LIST_COMP_GEN]		= "gen",
-	[BTRFS_LIST_COMP_PATH]		= "path",
-	[BTRFS_LIST_COMP_MAX]		= NULL,
-};
-
-static int  btrfs_list_get_sort_item(char *sort_name)
-{
-	int i;
-
-	for (i = 0; i < BTRFS_LIST_COMP_MAX; i++) {
-		if (strcmp(sort_name, all_sort_items[i]) == 0)
-			return i;
-	}
-	return -1;
-}
-
-struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void)
-{
-	struct btrfs_list_comparer_set *set;
-	int size;
-
-	size = sizeof(struct btrfs_list_comparer_set) +
-	       BTRFS_LIST_NCOMPS_INCREASE * sizeof(struct btrfs_list_comparer);
-	set = calloc(1, size);
-	if (!set) {
-		fprintf(stderr, "memory allocation failed\n");
-		exit(1);
-	}
-
-	set->total = BTRFS_LIST_NCOMPS_INCREASE;
-
-	return set;
-}
-
-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;
-
-	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);
-		}
-
-		memset(&set->comps[set->total], 0,
-		       BTRFS_LIST_NCOMPS_INCREASE *
-		       sizeof(struct btrfs_list_comparer));
-		set->total += BTRFS_LIST_NCOMPS_INCREASE;
-		*comp_set = set;
-	}
-
-	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;
-	set->ncomps++;
-	return 0;
-}
-
-static int sort_comp(struct root_info *entry1, struct root_info *entry2,
-		     struct btrfs_list_comparer_set *set)
-{
-	int rootid_compared = 0;
-	int i, ret = 0;
-
-	if (!set || !set->ncomps)
-		return comp_entry_with_rootid(entry1, entry2, 0);
-
-	for (i = 0; i < set->ncomps; i++) {
-		if (!set->comps[i].comp_func)
-			break;
-
-		ret = set->comps[i].comp_func(entry1, entry2,
-					      set->comps[i].is_descending);
-		if (ret)
-			return ret;
-
-		if (set->comps[i].comp_func == comp_entry_with_rootid)
-			rootid_compared = 1;
-	}
-
-	if (!rootid_compared)
-		ret = comp_entry_with_rootid(entry1, entry2, 0);
-
-	return ret;
-}
-
-static int sort_tree_insert(struct root_lookup *sort_tree,
-			    struct root_info *ins,
-			    struct btrfs_list_comparer_set *comp_set)
-{
-	struct rb_node **p = &sort_tree->root.rb_node;
-	struct rb_node *parent = NULL;
-	struct root_info *curr;
-	int ret;
-
-	while (*p) {
-		parent = *p;
-		curr = rb_entry(parent, struct root_info, sort_node);
-
-		ret = sort_comp(ins, curr, comp_set);
-		if (ret < 0)
-			p = &(*p)->rb_left;
-		else if (ret > 0)
-			p = &(*p)->rb_right;
-		else
-			return -EEXIST;
-	}
-
-	rb_link_node(&ins->sort_node, parent, p);
-	rb_insert_color(&ins->sort_node, &sort_tree->root);
-	return 0;
+		return 0;
 }
 
 /*
@@ -342,7 +68,7 @@ static int root_tree_insert(struct root_lookup *root_tree,
 		parent = *p;
 		curr = rb_entry(parent, struct root_info, rb_node);
 
-		ret = comp_entry_with_rootid(ins, curr, 0);
+		ret = comp_rootid(ins, curr);
 		if (ret < 0)
 			p = &(*p)->rb_left;
 		else if (ret > 0)
@@ -373,7 +99,7 @@ static struct root_info *root_tree_search(struct root_lookup *root_tree,
 	while(n) {
 		entry = rb_entry(n, struct root_info, rb_node);
 
-		ret = comp_entry_with_rootid(&tmp, entry, 0);
+		ret = comp_rootid(&tmp, entry);
 		if (ret < 0)
 			n = n->rb_left;
 		else if (ret > 0)
@@ -1069,229 +795,6 @@ static int list_subvol_search(int fd, struct root_lookup *root_lookup)
 	return 0;
 }
 
-static int filter_by_rootid(struct root_info *ri, u64 data)
-{
-	return ri->root_id == data;
-}
-
-static int filter_snapshot(struct root_info *ri, u64 data)
-{
-	return !!ri->root_offset;
-}
-
-static int filter_flags(struct root_info *ri, u64 flags)
-{
-	return ri->flags & flags;
-}
-
-static int filter_gen_more(struct root_info *ri, u64 data)
-{
-	return ri->gen >= data;
-}
-
-static int filter_gen_less(struct root_info *ri, u64 data)
-{
-	return ri->gen <= data;
-}
-
-static int filter_gen_equal(struct root_info  *ri, u64 data)
-{
-	return ri->gen == data;
-}
-
-static int filter_cgen_more(struct root_info *ri, u64 data)
-{
-	return ri->ogen >= data;
-}
-
-static int filter_cgen_less(struct root_info *ri, u64 data)
-{
-	return ri->ogen <= data;
-}
-
-static int filter_cgen_equal(struct root_info *ri, u64 data)
-{
-	return ri->ogen == data;
-}
-
-static int filter_topid_equal(struct root_info *ri, u64 data)
-{
-	return ri->top_id == data;
-}
-
-static int filter_full_path(struct root_info *ri, u64 data)
-{
-	if (ri->full_path && ri->top_id != data) {
-		char *tmp;
-		char p[] = "<FS_TREE>";
-		int add_len = strlen(p);
-		int len = strlen(ri->full_path);
-
-		tmp = malloc(len + add_len + 2);
-		if (!tmp) {
-			fprintf(stderr, "memory allocation failed\n");
-			exit(1);
-		}
-		memcpy(tmp + add_len + 1, ri->full_path, len);
-		tmp[len + add_len + 1] = '\0';
-		tmp[add_len] = '/';
-		memcpy(tmp, p, add_len);
-		free(ri->full_path);
-		ri->full_path = tmp;
-	}
-	return 1;
-}
-
-static int filter_by_parent(struct root_info *ri, u64 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[] = {
-	[BTRFS_LIST_FILTER_ROOTID]		= filter_by_rootid,
-	[BTRFS_LIST_FILTER_SNAPSHOT_ONLY]	= filter_snapshot,
-	[BTRFS_LIST_FILTER_FLAGS]		= filter_flags,
-	[BTRFS_LIST_FILTER_GEN_MORE]		= filter_gen_more,
-	[BTRFS_LIST_FILTER_GEN_LESS]		= filter_gen_less,
-	[BTRFS_LIST_FILTER_GEN_EQUAL]           = filter_gen_equal,
-	[BTRFS_LIST_FILTER_CGEN_MORE]		= filter_cgen_more,
-	[BTRFS_LIST_FILTER_CGEN_LESS]		= filter_cgen_less,
-	[BTRFS_LIST_FILTER_CGEN_EQUAL]          = filter_cgen_equal,
-	[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)
-{
-	struct btrfs_list_filter_set *set;
-	int size;
-
-	size = sizeof(struct btrfs_list_filter_set) +
-	       BTRFS_LIST_NFILTERS_INCREASE * sizeof(struct btrfs_list_filter);
-	set = calloc(1, size);
-	if (!set) {
-		fprintf(stderr, "memory allocation failed\n");
-		exit(1);
-	}
-
-	set->total = BTRFS_LIST_NFILTERS_INCREASE;
-
-	return 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;
-
-	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);
-		}
-
-		memset(&set->filters[set->total], 0,
-		       BTRFS_LIST_NFILTERS_INCREASE *
-		       sizeof(struct btrfs_list_filter));
-		set->total += BTRFS_LIST_NFILTERS_INCREASE;
-		*filter_set = set;
-	}
-
-	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++;
-}
-
-static int filter_root(struct root_info *ri,
-		       struct btrfs_list_filter_set *set)
-{
-	int i, ret;
-
-	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;
-		ret = set->filters[i].filter_func(ri, set->filters[i].data);
-		if (!ret)
-			return 0;
-	}
-	return 1;
-}
-
-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,
-				    u64 top_id)
-{
-	struct rb_node *n;
-	struct root_info *entry;
-	int ret;
-
-	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) {
-			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);
-		n = rb_prev(n);
-	}
-}
-
 static int list_subvol_fill_paths(int fd, struct root_lookup *root_lookup)
 {
 	struct rb_node *n;
@@ -1310,185 +813,6 @@ static int list_subvol_fill_paths(int fd, struct root_lookup *root_lookup)
 	return 0;
 }
 
-static void print_subvolume_column(struct root_info *subv,
-				   enum btrfs_list_column_enum column)
-{
-	char tstr[256];
-	char uuidparse[BTRFS_UUID_UNPARSED_SIZE];
-
-	ASSERT(0 <= column && column < BTRFS_LIST_ALL);
-
-	switch (column) {
-	case BTRFS_LIST_OBJECTID:
-		printf("%llu", subv->root_id);
-		break;
-	case BTRFS_LIST_GENERATION:
-		printf("%llu", subv->gen);
-		break;
-	case BTRFS_LIST_OGENERATION:
-		printf("%llu", subv->ogen);
-		break;
-	case BTRFS_LIST_PARENT:
-		printf("%llu", subv->ref_tree);
-		break;
-	case BTRFS_LIST_TOP_LEVEL:
-		printf("%llu", subv->top_id);
-		break;
-	case BTRFS_LIST_OTIME:
-		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;
-	case BTRFS_LIST_UUID:
-		if (uuid_is_null(subv->uuid))
-			strcpy(uuidparse, "-");
-		else
-			uuid_unparse(subv->uuid, uuidparse);
-		printf("%-36s", uuidparse);
-		break;
-	case BTRFS_LIST_PUUID:
-		if (uuid_is_null(subv->puuid))
-			strcpy(uuidparse, "-");
-		else
-			uuid_unparse(subv->puuid, 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);
-		printf("%s", subv->full_path);
-		break;
-	default:
-		break;
-	}
-}
-
-static void print_one_subvol_info_raw(struct root_info *subv,
-		const char *raw_prefix)
-{
-	int i;
-
-	for (i = 0; i < BTRFS_LIST_ALL; i++) {
-		if (!btrfs_list_columns[i].need_print)
-			continue;
-
-		if (raw_prefix)
-			printf("%s",raw_prefix);
-
-		print_subvolume_column(subv, i);
-	}
-	printf("\n");
-}
-
-static void print_one_subvol_info_table(struct root_info *subv)
-{
-	int i;
-
-	for (i = 0; i < BTRFS_LIST_ALL; i++) {
-		if (!btrfs_list_columns[i].need_print)
-			continue;
-
-		print_subvolume_column(subv, i);
-
-		if (i != BTRFS_LIST_PATH)
-			printf("\t");
-
-		if (i == BTRFS_LIST_TOP_LEVEL)
-			printf("\t");
-	}
-	printf("\n");
-}
-
-static void print_one_subvol_info_default(struct root_info *subv)
-{
-	int i;
-
-	for (i = 0; i < BTRFS_LIST_ALL; i++) {
-		if (!btrfs_list_columns[i].need_print)
-			continue;
-
-		printf("%s ", btrfs_list_columns[i].name);
-		print_subvolume_column(subv, i);
-
-		if (i != BTRFS_LIST_PATH)
-			printf(" ");
-	}
-	printf("\n");
-}
-
-static void print_all_subvol_info_tab_head(void)
-{
-	int i;
-	int len;
-	char barrier[20];
-
-	for (i = 0; i < BTRFS_LIST_ALL; i++) {
-		if (btrfs_list_columns[i].need_print)
-			printf("%s\t", btrfs_list_columns[i].name);
-
-		if (i == BTRFS_LIST_ALL-1)
-			printf("\n");
-	}
-
-	for (i = 0; i < BTRFS_LIST_ALL; i++) {
-		memset(barrier, 0, sizeof(barrier));
-
-		if (btrfs_list_columns[i].need_print) {
-			len = strlen(btrfs_list_columns[i].name);
-			while (len--)
-				strcat(barrier, "-");
-
-			printf("%s\t", barrier);
-		}
-		if (i == BTRFS_LIST_ALL-1)
-			printf("\n");
-	}
-}
-
-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_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_one_subvol_info_default(entry);
-			break;
-		case BTRFS_LIST_LAYOUT_TABLE:
-			print_one_subvol_info_table(entry);
-			break;
-		case BTRFS_LIST_LAYOUT_RAW:
-			print_one_subvol_info_raw(entry, raw_prefix);
-			break;
-		}
-next:
-		n = rb_next(n);
-	}
-}
-
 static int btrfs_list_subvols(int fd, struct root_lookup *root_lookup)
 {
 	int ret;
@@ -1507,33 +831,6 @@ static int btrfs_list_subvols(int fd, struct root_lookup *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,
-		       enum btrfs_list_layout layout, int full_path,
-		       const char *raw_prefix)
-{
-	struct root_lookup root_lookup;
-	struct root_lookup root_sort;
-	int ret = 0;
-	u64 top_id = 0;
-
-	if (full_path)
-		ret = btrfs_list_get_path_rootid(fd, &top_id);
-	if (ret)
-		return ret;
-
-	ret = btrfs_list_subvols(fd, &root_lookup);
-	if (ret)
-		return ret;
-	filter_and_sort_subvol(&root_lookup, &root_sort, filter_set,
-				 comp_set, top_id);
-
-	print_all_subvol_info(&root_sort, layout, raw_prefix);
-	rb_free_nodes(&root_lookup.root, free_root_info);
-
-	return 0;
-}
-
 static char *strdup_or_null(const char *s)
 {
 	if (!s)
@@ -1598,8 +895,8 @@ int btrfs_get_subvol(int fd, struct root_info *the_ri)
 			continue;
 		}
 
-		if (!comp_entry_with_rootid(the_ri, ri, 0) ||
-			!uuid_compare(the_ri->uuid, ri->uuid)) {
+		if (!comp_rootid(the_ri, ri) ||
+		    !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);
@@ -1832,93 +1129,6 @@ char *btrfs_list_path_for_root(int fd, u64 root)
 	return ret_path;
 }
 
-int btrfs_list_parse_sort_string(char *opt_arg,
-				 struct btrfs_list_comparer_set **comps)
-{
-	int order;
-	int flag;
-	char *p;
-	char **ptr_argv;
-	int what_to_sort;
-
-	while ((p = strtok(opt_arg, ",")) != NULL) {
-		flag = 0;
-		ptr_argv = all_sort_items;
-
-		while (*ptr_argv) {
-			if (strcmp(*ptr_argv, p) == 0) {
-				flag = 1;
-				break;
-			} else {
-				p++;
-				if (strcmp(*ptr_argv, p) == 0) {
-					flag = 1;
-					p--;
-					break;
-				}
-				p--;
-			}
-			ptr_argv++;
-		}
-
-		if (flag == 0)
-			return -1;
-
-		else {
-			if (*p == '+') {
-				order = 0;
-				p++;
-			} else if (*p == '-') {
-				order = 1;
-				p++;
-			} else
-				order = 0;
-
-			what_to_sort = btrfs_list_get_sort_item(p);
-			btrfs_list_setup_comparer(comps, what_to_sort, order);
-		}
-		opt_arg = NULL;
-	}
-
-	return 0;
-}
-
-/*
- * This function is used to parse the argument of filter condition.
- *
- * type is the filter object.
- */
-int btrfs_list_parse_filter_string(char *opt_arg,
-				   struct btrfs_list_filter_set **filters,
-				   enum btrfs_list_filter_enum type)
-{
-
-	u64 arg;
-
-	switch (*(opt_arg++)) {
-	case '+':
-		arg = arg_strtou64(opt_arg);
-		type += 2;
-
-		btrfs_list_setup_filter(filters, type, arg);
-		break;
-	case '-':
-		arg = arg_strtou64(opt_arg);
-		type += 1;
-
-		btrfs_list_setup_filter(filters, type, arg);
-		break;
-	default:
-		opt_arg--;
-		arg = arg_strtou64(opt_arg);
-
-		btrfs_list_setup_filter(filters, type, arg);
-		break;
-	}
-
-	return 0;
-}
-
 int btrfs_list_get_path_rootid(int fd, u64 *treeid)
 {
 	int ret;
diff --git a/btrfs-list.h b/btrfs-list.h
index 6e5fc778..54e1888f 100644
--- a/btrfs-list.h
+++ b/btrfs-list.h
@@ -31,12 +31,6 @@
 
 #include <time.h>
 
-enum btrfs_list_layout {
-	BTRFS_LIST_LAYOUT_DEFAULT = 0,
-	BTRFS_LIST_LAYOUT_TABLE,
-	BTRFS_LIST_LAYOUT_RAW
-};
-
 /*
  * one of these for each root we find.
  */
@@ -87,89 +81,6 @@ struct root_info {
 	int deleted;
 };
 
-typedef int (*btrfs_list_filter_func)(struct root_info *, u64);
-typedef int (*btrfs_list_comp_func)(struct root_info *, struct root_info *,
-				    int);
-
-struct btrfs_list_filter {
-	btrfs_list_filter_func filter_func;
-	u64 data;
-};
-
-struct btrfs_list_comparer {
-	btrfs_list_comp_func comp_func;
-	int is_descending;
-};
-
-struct btrfs_list_filter_set {
-	int total;
-	int nfilters;
-	int only_deleted;
-	struct btrfs_list_filter filters[0];
-};
-
-struct btrfs_list_comparer_set {
-	int total;
-	int ncomps;
-	struct btrfs_list_comparer comps[0];
-};
-
-enum btrfs_list_column_enum {
-	BTRFS_LIST_OBJECTID,
-	BTRFS_LIST_GENERATION,
-	BTRFS_LIST_OGENERATION,
-	BTRFS_LIST_PARENT,
-	BTRFS_LIST_TOP_LEVEL,
-	BTRFS_LIST_OTIME,
-	BTRFS_LIST_PUUID,
-	BTRFS_LIST_RUUID,
-	BTRFS_LIST_UUID,
-	BTRFS_LIST_PATH,
-	BTRFS_LIST_ALL,
-};
-
-enum btrfs_list_filter_enum {
-	BTRFS_LIST_FILTER_ROOTID,
-	BTRFS_LIST_FILTER_SNAPSHOT_ONLY,
-	BTRFS_LIST_FILTER_FLAGS,
-	BTRFS_LIST_FILTER_GEN,
-	BTRFS_LIST_FILTER_GEN_EQUAL	=	BTRFS_LIST_FILTER_GEN,
-	BTRFS_LIST_FILTER_GEN_LESS,
-	BTRFS_LIST_FILTER_GEN_MORE,
-	BTRFS_LIST_FILTER_CGEN,
-	BTRFS_LIST_FILTER_CGEN_EQUAL	=	BTRFS_LIST_FILTER_CGEN,
-	BTRFS_LIST_FILTER_CGEN_LESS,
-	BTRFS_LIST_FILTER_CGEN_MORE,
-	BTRFS_LIST_FILTER_TOPID_EQUAL,
-	BTRFS_LIST_FILTER_FULL_PATH,
-	BTRFS_LIST_FILTER_BY_PARENT,
-	BTRFS_LIST_FILTER_DELETED,
-	BTRFS_LIST_FILTER_MAX,
-};
-
-enum btrfs_list_comp_enum {
-	BTRFS_LIST_COMP_ROOTID,
-	BTRFS_LIST_COMP_OGEN,
-	BTRFS_LIST_COMP_GEN,
-	BTRFS_LIST_COMP_PATH,
-	BTRFS_LIST_COMP_MAX,
-};
-
-int btrfs_list_parse_sort_string(char *optarg,
-				 struct btrfs_list_comparer_set **comps);
-int btrfs_list_parse_filter_string(char *optarg,
-				   struct btrfs_list_filter_set **filters,
-				   enum btrfs_list_filter_enum type);
-void btrfs_list_setup_print_column(enum btrfs_list_column_enum column);
-struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void);
-void btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
-			    enum btrfs_list_filter_enum filter, u64 data);
-struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void);
-
-int btrfs_list_subvols_print(int fd, struct btrfs_list_filter_set *filter_set,
-		       struct btrfs_list_comparer_set *comp_set,
-		       enum btrfs_list_layout layot, int full_path,
-		       const char *raw_prefix);
 int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen);
 int btrfs_list_get_default_subvolume(int fd, u64 *default_id);
 char *btrfs_list_path_for_root(int fd, u64 root);
diff --git a/cmds-subvolume.c b/cmds-subvolume.c
index 101ba4ca..392e4660 100644
--- a/cmds-subvolume.c
+++ b/cmds-subvolume.c
@@ -371,6 +371,954 @@ keep_fd:
 	return ret;
 }
 
+enum btrfs_list_layout {
+	BTRFS_LIST_LAYOUT_DEFAULT = 0,
+	BTRFS_LIST_LAYOUT_TABLE,
+	BTRFS_LIST_LAYOUT_RAW
+};
+
+enum btrfs_list_column_enum {
+	BTRFS_LIST_OBJECTID,
+	BTRFS_LIST_GENERATION,
+	BTRFS_LIST_OGENERATION,
+	BTRFS_LIST_PARENT,
+	BTRFS_LIST_TOP_LEVEL,
+	BTRFS_LIST_OTIME,
+	BTRFS_LIST_PUUID,
+	BTRFS_LIST_RUUID,
+	BTRFS_LIST_UUID,
+	BTRFS_LIST_PATH,
+	BTRFS_LIST_ALL,
+};
+
+enum btrfs_list_filter_enum {
+	BTRFS_LIST_FILTER_ROOTID,
+	BTRFS_LIST_FILTER_SNAPSHOT_ONLY,
+	BTRFS_LIST_FILTER_FLAGS,
+	BTRFS_LIST_FILTER_GEN,
+	BTRFS_LIST_FILTER_GEN_EQUAL	=	BTRFS_LIST_FILTER_GEN,
+	BTRFS_LIST_FILTER_GEN_LESS,
+	BTRFS_LIST_FILTER_GEN_MORE,
+	BTRFS_LIST_FILTER_CGEN,
+	BTRFS_LIST_FILTER_CGEN_EQUAL	=	BTRFS_LIST_FILTER_CGEN,
+	BTRFS_LIST_FILTER_CGEN_LESS,
+	BTRFS_LIST_FILTER_CGEN_MORE,
+	BTRFS_LIST_FILTER_TOPID_EQUAL,
+	BTRFS_LIST_FILTER_FULL_PATH,
+	BTRFS_LIST_FILTER_BY_PARENT,
+	BTRFS_LIST_FILTER_DELETED,
+	BTRFS_LIST_FILTER_MAX,
+};
+
+enum btrfs_list_comp_enum {
+	BTRFS_LIST_COMP_ROOTID,
+	BTRFS_LIST_COMP_OGEN,
+	BTRFS_LIST_COMP_GEN,
+	BTRFS_LIST_COMP_PATH,
+	BTRFS_LIST_COMP_MAX,
+};
+
+#define BTRFS_LIST_NFILTERS_INCREASE	(2 * BTRFS_LIST_FILTER_MAX)
+#define BTRFS_LIST_NCOMPS_INCREASE	(2 * BTRFS_LIST_COMP_MAX)
+
+struct listed_subvol {
+	struct btrfs_util_subvolume_info info;
+	char *path;
+};
+
+struct subvol_list {
+	size_t num;
+	struct listed_subvol subvols[];
+};
+
+typedef int (*btrfs_list_filter_func)(struct listed_subvol *, uint64_t);
+typedef int (*btrfs_list_comp_func)(const struct listed_subvol *,
+				    const struct listed_subvol *,
+				    int);
+
+struct btrfs_list_filter {
+	btrfs_list_filter_func filter_func;
+	u64 data;
+};
+
+struct btrfs_list_comparer {
+	btrfs_list_comp_func comp_func;
+	int is_descending;
+};
+
+struct btrfs_list_filter_set {
+	int total;
+	int nfilters;
+	int only_deleted;
+	struct btrfs_list_filter filters[0];
+};
+
+struct btrfs_list_comparer_set {
+	int total;
+	int ncomps;
+	struct btrfs_list_comparer comps[0];
+};
+
+static struct {
+	char	*name;
+	char	*column_name;
+	int	need_print;
+} btrfs_list_columns[] = {
+	{
+		.name		= "ID",
+		.column_name	= "ID",
+		.need_print	= 0,
+	},
+	{
+		.name		= "gen",
+		.column_name	= "Gen",
+		.need_print	= 0,
+	},
+	{
+		.name		= "cgen",
+		.column_name	= "CGen",
+		.need_print	= 0,
+	},
+	{
+		.name		= "parent",
+		.column_name	= "Parent",
+		.need_print	= 0,
+	},
+	{
+		.name		= "top level",
+		.column_name	= "Top Level",
+		.need_print	= 0,
+	},
+	{
+		.name		= "otime",
+		.column_name	= "OTime",
+		.need_print	= 0,
+	},
+	{
+		.name		= "parent_uuid",
+		.column_name	= "Parent UUID",
+		.need_print	= 0,
+	},
+	{
+		.name		= "received_uuid",
+		.column_name	= "Received UUID",
+		.need_print	= 0,
+	},
+	{
+		.name		= "uuid",
+		.column_name	= "UUID",
+		.need_print	= 0,
+	},
+	{
+		.name		= "path",
+		.column_name	= "Path",
+		.need_print	= 0,
+	},
+	{
+		.name		= NULL,
+		.column_name	= NULL,
+		.need_print	= 0,
+	},
+};
+
+static btrfs_list_filter_func all_filter_funcs[];
+static btrfs_list_comp_func all_comp_funcs[];
+
+static void btrfs_list_setup_print_column(enum btrfs_list_column_enum column)
+{
+	int i;
+
+	ASSERT(0 <= column && column <= BTRFS_LIST_ALL);
+
+	if (column < BTRFS_LIST_ALL) {
+		btrfs_list_columns[column].need_print = 1;
+		return;
+	}
+
+	for (i = 0; i < BTRFS_LIST_ALL; i++)
+		btrfs_list_columns[i].need_print = 1;
+}
+
+static int comp_entry_with_rootid(const struct listed_subvol *entry1,
+				  const struct listed_subvol *entry2,
+				  int is_descending)
+{
+	int ret;
+
+	if (entry1->info.id > entry2->info.id)
+		ret = 1;
+	else if (entry1->info.id < entry2->info.id)
+		ret = -1;
+	else
+		ret = 0;
+
+	return is_descending ? -ret : ret;
+}
+
+static int comp_entry_with_gen(const struct listed_subvol *entry1,
+			       const struct listed_subvol *entry2,
+			       int is_descending)
+{
+	int ret;
+
+	if (entry1->info.generation > entry2->info.generation)
+		ret = 1;
+	else if (entry1->info.generation < entry2->info.generation)
+		ret = -1;
+	else
+		ret = 0;
+
+	return is_descending ? -ret : ret;
+}
+
+static int comp_entry_with_ogen(const struct listed_subvol *entry1,
+				const struct listed_subvol *entry2,
+				int is_descending)
+{
+	int ret;
+
+	if (entry1->info.otransid > entry2->info.otransid)
+		ret = 1;
+	else if (entry1->info.otransid < entry2->info.otransid)
+		ret = -1;
+	else
+		ret = 0;
+
+	return is_descending ? -ret : ret;
+}
+
+static int comp_entry_with_path(const struct listed_subvol *entry1,
+				const struct listed_subvol *entry2,
+				int is_descending)
+{
+	int ret;
+
+	if (strcmp(entry1->path, entry2->path) > 0)
+		ret = 1;
+	else if (strcmp(entry1->path, entry2->path) < 0)
+		ret = -1;
+	else
+		ret = 0;
+
+	return is_descending ? -ret : ret;
+}
+
+static btrfs_list_comp_func all_comp_funcs[] = {
+	[BTRFS_LIST_COMP_ROOTID]	= comp_entry_with_rootid,
+	[BTRFS_LIST_COMP_OGEN]		= comp_entry_with_ogen,
+	[BTRFS_LIST_COMP_GEN]		= comp_entry_with_gen,
+	[BTRFS_LIST_COMP_PATH]		= comp_entry_with_path,
+};
+
+static char *all_sort_items[] = {
+	[BTRFS_LIST_COMP_ROOTID]	= "rootid",
+	[BTRFS_LIST_COMP_OGEN]		= "ogen",
+	[BTRFS_LIST_COMP_GEN]		= "gen",
+	[BTRFS_LIST_COMP_PATH]		= "path",
+	[BTRFS_LIST_COMP_MAX]		= NULL,
+};
+
+static int btrfs_list_get_sort_item(char *sort_name)
+{
+	int i;
+
+	for (i = 0; i < BTRFS_LIST_COMP_MAX; i++) {
+		if (strcmp(sort_name, all_sort_items[i]) == 0)
+			return i;
+	}
+	return -1;
+}
+
+static struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void)
+{
+	struct btrfs_list_comparer_set *set;
+	int size;
+
+	size = sizeof(struct btrfs_list_comparer_set) +
+	       BTRFS_LIST_NCOMPS_INCREASE * sizeof(struct btrfs_list_comparer);
+	set = calloc(1, size);
+	if (!set) {
+		fprintf(stderr, "memory allocation failed\n");
+		exit(1);
+	}
+
+	set->total = BTRFS_LIST_NCOMPS_INCREASE;
+
+	return set;
+}
+
+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;
+
+	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);
+		}
+
+		memset(&set->comps[set->total], 0,
+		       BTRFS_LIST_NCOMPS_INCREASE *
+		       sizeof(struct btrfs_list_comparer));
+		set->total += BTRFS_LIST_NCOMPS_INCREASE;
+		*comp_set = set;
+	}
+
+	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;
+	set->ncomps++;
+	return 0;
+}
+
+static int subvol_comp(const void *entry1, const void *entry2, void *arg)
+{
+	const struct btrfs_list_comparer_set * const set = arg;
+	int rootid_compared = 0;
+	int ret;
+	int i;
+
+	for (i = 0; set && i < set->ncomps; i++) {
+		if (!set->comps[i].comp_func)
+			break;
+
+		ret = set->comps[i].comp_func(entry1, entry2,
+					      set->comps[i].is_descending);
+		if (ret)
+			return ret;
+
+		if (set->comps[i].comp_func == comp_entry_with_rootid)
+			rootid_compared = 1;
+	}
+
+	if (!rootid_compared)
+		return comp_entry_with_rootid(entry1, entry2, 0);
+
+	return 0;
+}
+
+static void sort_subvols(struct btrfs_list_comparer_set *comp_set,
+			 struct subvol_list *subvols)
+{
+	qsort_r(subvols->subvols, subvols->num, sizeof(subvols->subvols[0]),
+		subvol_comp, comp_set);
+}
+
+static int filter_by_rootid(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.id == data;
+}
+
+static int filter_snapshot(struct listed_subvol *subvol, uint64_t data)
+{
+	return !uuid_is_null(subvol->info.parent_uuid);
+}
+
+static int filter_flags(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.flags & data;
+}
+
+static int filter_gen_more(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.generation >= data;
+}
+
+static int filter_gen_less(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.generation <= data;
+}
+
+static int filter_gen_equal(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.generation == data;
+}
+
+static int filter_cgen_more(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.otransid >= data;
+}
+
+static int filter_cgen_less(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.otransid <= data;
+}
+
+static int filter_cgen_equal(struct listed_subvol *subvol, uint64_t data)
+{
+	return subvol->info.otransid == data;
+}
+
+static int filter_topid_equal(struct listed_subvol *subvol, uint64_t data)
+{
+	/* See the comment in print_subvolume_column() about top level. */
+	return subvol->info.parent_id == data;
+}
+
+static int filter_full_path(struct listed_subvol *subvol, uint64_t data)
+{
+	/*
+	 * This implements the same behavior as before the conversion to
+	 * libbtrfsutil, which is mostly nonsensical.
+	 */
+	if (subvol->info.parent_id != data) {
+		char *tmp;
+		int ret;
+
+		ret = asprintf(&tmp, "<FS_TREE>/%s", subvol->path);
+		if (ret == -1) {
+			error("out of memory");
+			exit(1);
+		}
+
+		free(subvol->path);
+		subvol->path = tmp;
+	}
+	return 1;
+}
+
+static int filter_by_parent(struct listed_subvol *subvol, uint64_t data)
+{
+	return !uuid_compare(subvol->info.parent_uuid,
+			     (u8 *)(unsigned long)data);
+}
+
+static btrfs_list_filter_func all_filter_funcs[] = {
+	[BTRFS_LIST_FILTER_ROOTID]		= filter_by_rootid,
+	[BTRFS_LIST_FILTER_SNAPSHOT_ONLY]	= filter_snapshot,
+	[BTRFS_LIST_FILTER_FLAGS]		= filter_flags,
+	[BTRFS_LIST_FILTER_GEN_MORE]		= filter_gen_more,
+	[BTRFS_LIST_FILTER_GEN_LESS]		= filter_gen_less,
+	[BTRFS_LIST_FILTER_GEN_EQUAL]           = filter_gen_equal,
+	[BTRFS_LIST_FILTER_CGEN_MORE]		= filter_cgen_more,
+	[BTRFS_LIST_FILTER_CGEN_LESS]		= filter_cgen_less,
+	[BTRFS_LIST_FILTER_CGEN_EQUAL]          = filter_cgen_equal,
+	[BTRFS_LIST_FILTER_TOPID_EQUAL]		= filter_topid_equal,
+	[BTRFS_LIST_FILTER_FULL_PATH]		= filter_full_path,
+	[BTRFS_LIST_FILTER_BY_PARENT]		= filter_by_parent,
+};
+
+static struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void)
+{
+	struct btrfs_list_filter_set *set;
+	int size;
+
+	size = sizeof(struct btrfs_list_filter_set) +
+	       BTRFS_LIST_NFILTERS_INCREASE * sizeof(struct btrfs_list_filter);
+	set = calloc(1, size);
+	if (!set) {
+		fprintf(stderr, "memory allocation failed\n");
+		exit(1);
+	}
+
+	set->total = BTRFS_LIST_NFILTERS_INCREASE;
+
+	return set;
+}
+
+/*
+ * Setup list filters. Exit if there's not enough memory, as we can't continue
+ * without the structures set up properly.
+ */
+static 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;
+
+	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);
+		}
+
+		memset(&set->filters[set->total], 0,
+		       BTRFS_LIST_NFILTERS_INCREASE *
+		       sizeof(struct btrfs_list_filter));
+		set->total += BTRFS_LIST_NFILTERS_INCREASE;
+		*filter_set = set;
+	}
+
+	ASSERT(set->filters[set->nfilters].filter_func == NULL);
+
+	if (filter == BTRFS_LIST_FILTER_DELETED) {
+		set->only_deleted = 1;
+	} else {
+		set->filters[set->nfilters].filter_func = all_filter_funcs[filter];
+		set->filters[set->nfilters].data = data;
+		set->nfilters++;
+	}
+}
+
+static int filters_match(struct listed_subvol *subvol,
+			 struct btrfs_list_filter_set *set)
+{
+	int i, ret;
+
+	if (!set)
+		return 1;
+
+	for (i = 0; i < set->nfilters; i++) {
+		if (!set->filters[i].filter_func)
+			break;
+		ret = set->filters[i].filter_func(subvol, set->filters[i].data);
+		if (!ret)
+			return 0;
+	}
+	return 1;
+}
+
+static void print_subvolume_column(struct listed_subvol *subvol,
+				   enum btrfs_list_column_enum column)
+{
+	char tstr[256];
+	char uuidparse[BTRFS_UUID_UNPARSED_SIZE];
+
+	ASSERT(0 <= column && column < BTRFS_LIST_ALL);
+
+	switch (column) {
+	case BTRFS_LIST_OBJECTID:
+		printf("%" PRIu64, subvol->info.id);
+		break;
+	case BTRFS_LIST_GENERATION:
+		printf("%" PRIu64, subvol->info.generation);
+		break;
+	case BTRFS_LIST_OGENERATION:
+		printf("%" PRIu64, subvol->info.otransid);
+		break;
+	case BTRFS_LIST_PARENT:
+	/*
+	 * Top level used to mean something else, but since 4f5ebb3ef553
+	 * ("Btrfs-progs: fix to make list specified directory's subvolumes
+	 * work") it was always set to the parent ID. See
+	 * https://www.spinics.net/lists/linux-btrfs/msg69820.html.
+	 */
+	case BTRFS_LIST_TOP_LEVEL:
+		printf("%" PRIu64, subvol->info.parent_id);
+		break;
+	case BTRFS_LIST_OTIME:
+		if (subvol->info.otime.tv_sec) {
+			struct tm tm;
+
+			localtime_r(&subvol->info.otime.tv_sec, &tm);
+			strftime(tstr, sizeof(tstr), "%Y-%m-%d %X", &tm);
+		} else
+			strcpy(tstr, "-");
+		printf("%s", tstr);
+		break;
+	case BTRFS_LIST_UUID:
+		if (uuid_is_null(subvol->info.uuid))
+			strcpy(uuidparse, "-");
+		else
+			uuid_unparse(subvol->info.uuid, uuidparse);
+		printf("%-36s", uuidparse);
+		break;
+	case BTRFS_LIST_PUUID:
+		if (uuid_is_null(subvol->info.parent_uuid))
+			strcpy(uuidparse, "-");
+		else
+			uuid_unparse(subvol->info.parent_uuid, uuidparse);
+		printf("%-36s", uuidparse);
+		break;
+	case BTRFS_LIST_RUUID:
+		if (uuid_is_null(subvol->info.received_uuid))
+			strcpy(uuidparse, "-");
+		else
+			uuid_unparse(subvol->info.received_uuid, uuidparse);
+		printf("%-36s", uuidparse);
+		break;
+	case BTRFS_LIST_PATH:
+		printf("%s", subvol->path);
+		break;
+	default:
+		break;
+	}
+}
+
+static void print_one_subvol_info_raw(struct listed_subvol *subvol,
+				      const char *raw_prefix)
+{
+	int i;
+
+	for (i = 0; i < BTRFS_LIST_ALL; i++) {
+		if (!btrfs_list_columns[i].need_print)
+			continue;
+
+		if (raw_prefix)
+			printf("%s",raw_prefix);
+
+		print_subvolume_column(subvol, i);
+	}
+	printf("\n");
+}
+
+static void print_one_subvol_info_table(struct listed_subvol *subvol)
+{
+	int i;
+
+	for (i = 0; i < BTRFS_LIST_ALL; i++) {
+		if (!btrfs_list_columns[i].need_print)
+			continue;
+
+		print_subvolume_column(subvol, i);
+
+		if (i != BTRFS_LIST_PATH)
+			printf("\t");
+
+		if (i == BTRFS_LIST_TOP_LEVEL)
+			printf("\t");
+	}
+	printf("\n");
+}
+
+static void print_one_subvol_info_default(struct listed_subvol *subvol)
+{
+	int i;
+
+	for (i = 0; i < BTRFS_LIST_ALL; i++) {
+		if (!btrfs_list_columns[i].need_print)
+			continue;
+
+		printf("%s ", btrfs_list_columns[i].name);
+		print_subvolume_column(subvol, i);
+
+		if (i != BTRFS_LIST_PATH)
+			printf(" ");
+	}
+	printf("\n");
+}
+
+static void print_all_subvol_info_tab_head(void)
+{
+	int i;
+	int len;
+	char barrier[20];
+
+	for (i = 0; i < BTRFS_LIST_ALL; i++) {
+		if (btrfs_list_columns[i].need_print)
+			printf("%s\t", btrfs_list_columns[i].name);
+
+		if (i == BTRFS_LIST_ALL-1)
+			printf("\n");
+	}
+
+	for (i = 0; i < BTRFS_LIST_ALL; i++) {
+		memset(barrier, 0, sizeof(barrier));
+
+		if (btrfs_list_columns[i].need_print) {
+			len = strlen(btrfs_list_columns[i].name);
+			while (len--)
+				strcat(barrier, "-");
+
+			printf("%s\t", barrier);
+		}
+		if (i == BTRFS_LIST_ALL-1)
+			printf("\n");
+	}
+}
+
+static void print_all_subvol_info(struct subvol_list *subvols,
+				  enum btrfs_list_layout layout,
+				  const char *raw_prefix)
+{
+	size_t i;
+
+	if (layout == BTRFS_LIST_LAYOUT_TABLE)
+		print_all_subvol_info_tab_head();
+
+	for (i = 0; i < subvols->num; i++) {
+		struct listed_subvol *subvol = &subvols->subvols[i];
+
+		switch (layout) {
+		case BTRFS_LIST_LAYOUT_DEFAULT:
+			print_one_subvol_info_default(subvol);
+			break;
+		case BTRFS_LIST_LAYOUT_TABLE:
+			print_one_subvol_info_table(subvol);
+			break;
+		case BTRFS_LIST_LAYOUT_RAW:
+			print_one_subvol_info_raw(subvol, raw_prefix);
+			break;
+		}
+	}
+}
+
+static void free_subvol_list(struct subvol_list *subvols)
+{
+	size_t i;
+
+	if (subvols) {
+		for (i = 0; i < subvols->num; i++)
+			free(subvols->subvols[i].path);
+		free(subvols);
+	}
+}
+
+static struct subvol_list *btrfs_list_deleted_subvols(int fd,
+						      struct btrfs_list_filter_set *filter_set)
+{
+	struct subvol_list *subvols = NULL;
+	uint64_t *ids = NULL;
+	size_t i, n;
+	enum btrfs_util_error err;
+	int ret = -1;
+
+	err = btrfs_util_deleted_subvolumes_fd(fd, &ids, &n);
+	if (err) {
+		error_btrfs_util(err);
+		return NULL;
+	}
+
+	subvols = malloc(sizeof(*subvols) + n * sizeof(subvols->subvols[0]));
+	if (!subvols) {
+		error("out of memory");
+		goto out;
+	}
+
+	subvols->num = 0;
+	for (i = 0; i < n; i++) {
+		struct listed_subvol *subvol = &subvols->subvols[subvols->num];
+
+		err = btrfs_util_subvolume_info_fd(fd, ids[i], &subvol->info);
+		if (err) {
+			error_btrfs_util(err);
+			goto out;
+		}
+
+		subvol->path = strdup("DELETED");
+		if (!subvol->path)
+			goto out;
+
+		if (!filters_match(subvol, filter_set)) {
+			free(subvol->path);
+			continue;
+		}
+
+		subvols->num++;
+	}
+
+	ret = 0;
+out:
+	if (ret) {
+		free_subvol_list(subvols);
+		subvols = NULL;
+		free(ids);
+	}
+	return subvols;
+}
+
+static struct subvol_list *btrfs_list_subvols(int fd,
+					      struct btrfs_list_filter_set *filter_set)
+{
+	struct subvol_list *subvols;
+	size_t capacity = 0;
+	struct btrfs_util_subvolume_iterator *iter;
+	enum btrfs_util_error err;
+	int ret = -1;
+
+	subvols = malloc(sizeof(*subvols));
+	if (!subvols) {
+		error("out of memory");
+		return NULL;
+	}
+	subvols->num = 0;
+
+	err = btrfs_util_create_subvolume_iterator_fd(fd,
+						      BTRFS_FS_TREE_OBJECTID, 0,
+						      &iter);
+	if (err) {
+		iter = NULL;
+		error_btrfs_util(err);
+		goto out;
+	}
+
+	for (;;) {
+		struct listed_subvol subvol;
+
+		err = btrfs_util_subvolume_iterator_next_info(iter,
+							      &subvol.path,
+							      &subvol.info);
+		if (err == BTRFS_UTIL_ERROR_STOP_ITERATION) {
+			break;
+		} else if (err) {
+			error_btrfs_util(err);
+			goto out;
+		}
+
+		if (!filters_match(&subvol, filter_set)) {
+			free(subvol.path);
+			continue;
+		}
+
+		if (subvols->num >= capacity) {
+			struct subvol_list *new_subvols;
+			size_t new_capacity = max_t(size_t, 1, capacity * 2);
+
+			new_subvols = realloc(subvols,
+					      sizeof(*new_subvols) +
+					      new_capacity *
+					      sizeof(new_subvols->subvols[0]));
+			if (!new_subvols) {
+				error("out of memory");
+				goto out;
+			}
+
+			subvols = new_subvols;
+			capacity = new_capacity;
+		}
+
+		subvols->subvols[subvols->num] = subvol;
+		subvols->num++;
+	}
+
+	ret = 0;
+out:
+	if (iter)
+		btrfs_util_destroy_subvolume_iterator(iter);
+	if (ret)
+		free_subvol_list(subvols);
+	return subvols;
+}
+
+static int btrfs_list_subvols_print(int fd,
+				    struct btrfs_list_filter_set *filter_set,
+				    struct btrfs_list_comparer_set *comp_set,
+				    enum btrfs_list_layout layout,
+				    int full_path, const char *raw_prefix)
+{
+	struct subvol_list *subvols;
+
+	/*
+	 * full_path hasn't done anything since 4f5ebb3ef553 ("Btrfs-progs: fix
+	 * to make list specified directory's subvolumes work"). See
+	 * https://www.spinics.net/lists/linux-btrfs/msg69820.html
+	 */
+
+	if (filter_set->only_deleted)
+		subvols = btrfs_list_deleted_subvols(fd, filter_set);
+	else
+		subvols = btrfs_list_subvols(fd, filter_set);
+	if (!subvols)
+		return -1;
+
+	sort_subvols(comp_set, subvols);
+
+	print_all_subvol_info(subvols, layout, raw_prefix);
+
+	free_subvol_list(subvols);
+
+	return 0;
+}
+
+static int btrfs_list_parse_sort_string(char *opt_arg,
+					struct btrfs_list_comparer_set **comps)
+{
+	int order;
+	int flag;
+	char *p;
+	char **ptr_argv;
+	int what_to_sort;
+
+	while ((p = strtok(opt_arg, ",")) != NULL) {
+		flag = 0;
+		ptr_argv = all_sort_items;
+
+		while (*ptr_argv) {
+			if (strcmp(*ptr_argv, p) == 0) {
+				flag = 1;
+				break;
+			} else {
+				p++;
+				if (strcmp(*ptr_argv, p) == 0) {
+					flag = 1;
+					p--;
+					break;
+				}
+				p--;
+			}
+			ptr_argv++;
+		}
+
+		if (flag == 0)
+			return -1;
+
+		else {
+			if (*p == '+') {
+				order = 0;
+				p++;
+			} else if (*p == '-') {
+				order = 1;
+				p++;
+			} else
+				order = 0;
+
+			what_to_sort = btrfs_list_get_sort_item(p);
+			btrfs_list_setup_comparer(comps, what_to_sort, order);
+		}
+		opt_arg = NULL;
+	}
+
+	return 0;
+}
+
+static int btrfs_list_parse_filter_string(char *opt_arg,
+					  struct btrfs_list_filter_set **filters,
+					  enum btrfs_list_filter_enum type)
+{
+
+	u64 arg;
+
+	switch (*(opt_arg++)) {
+	case '+':
+		arg = arg_strtou64(opt_arg);
+		type += 2;
+
+		btrfs_list_setup_filter(filters, type, arg);
+		break;
+	case '-':
+		arg = arg_strtou64(opt_arg);
+		type += 1;
+
+		btrfs_list_setup_filter(filters, type, arg);
+		break;
+	default:
+		opt_arg--;
+		arg = arg_strtou64(opt_arg);
+
+		btrfs_list_setup_filter(filters, type, arg);
+		break;
+	}
+
+	return 0;
+}
+
 /*
  * Naming of options:
  * - uppercase for filters and sort options
