btrfs-progs: use TREE_SEARCH ioctl wrappers for all non-library code

Use tree search ioctl wrappers for code that is considered internal, ie.
leaving out libbtrfs (legacy), libbtrfsutil (needs own API for that).

Conversion is mostly direct of what the API provides.

Signed-off-by: David Sterba <dsterba@suse.com>

7 files changed, 181 insertions, 170 deletions

diff --git a/cmds/filesystem-usage.c b/cmds/filesystem-usage.c
index e664ed84..102c7653 100644
--- a/cmds/filesystem-usage.c
+++ b/cmds/filesystem-usage.c
@@ -44,6 +44,7 @@
 #include "common/sysfs-utils.h"
 #include "common/messages.h"
 #include "common/path-utils.h"
+#include "common/tree-search.h"
 #include "cmds/filesystem-usage.h"
 #include "cmds/commands.h"
 
@@ -144,13 +145,13 @@ static int cmp_chunk_info(const void *a, const void *b)
 static int load_chunk_info(int fd, struct array *chunkinfos)
 {
 	int ret;
-	struct btrfs_ioctl_search_args args;
-	struct btrfs_ioctl_search_key *sk = &args.key;
-	struct btrfs_ioctl_search_header *sh;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	unsigned long off = 0;
 	int i;
 
 	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
 
 	/*
 	 * there may be more than one ROOT_ITEM key if there are
@@ -170,7 +171,7 @@ static int load_chunk_info(int fd, struct array *chunkinfos)
 	sk->nr_items = 4096;
 
 	while (1) {
-		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+		ret = btrfs_tree_search_ioctl(fd, &args);
 		if (ret < 0) {
 			if (errno == EPERM)
 				return -errno;
@@ -185,11 +186,11 @@ static int load_chunk_info(int fd, struct array *chunkinfos)
 		off = 0;
 		for (i = 0; i < sk->nr_items; i++) {
 			struct btrfs_chunk *item;
-			sh = (struct btrfs_ioctl_search_header *)(args.buf +
-								  off);
+			struct btrfs_ioctl_search_header *sh;
 
+			sh = btrfs_tree_search_data(&args, off);
 			off += sizeof(*sh);
-			item = (struct btrfs_chunk *)(args.buf + off);
+			item = btrfs_tree_search_data(&args, off);
 
 			ret = add_info_to_list(chunkinfos, item);
 			if (ret)
diff --git a/cmds/inspect.c b/cmds/inspect.c
index f0875fca..577ed43e 100644
--- a/cmds/inspect.c
+++ b/cmds/inspect.c
@@ -47,6 +47,7 @@
 #include "common/string-utils.h"
 #include "common/string-table.h"
 #include "common/sort-utils.h"
+#include "common/tree-search.h"
 #include "cmds/commands.h"
 
 static const char * const inspect_cmd_group_usage[] = {
@@ -559,13 +560,14 @@ static int print_min_dev_size(int fd, u64 devid)
 	 * ignore it here.
 	 */
 	u64 min_size = SZ_1M;
-	struct btrfs_ioctl_search_args args;
-	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	u64 last_pos = (u64)-1;
 	LIST_HEAD(extents);
 	LIST_HEAD(holes);
 
 	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = BTRFS_DEV_TREE_OBJECTID;
 	sk->min_objectid = devid;
 	sk->max_objectid = devid;
@@ -582,7 +584,7 @@ static int print_min_dev_size(int fd, u64 devid)
 		struct btrfs_ioctl_search_header *sh;
 		unsigned long off = 0;
 
-		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+		ret = btrfs_tree_search_ioctl(fd, &args);
 		if (ret < 0) {
 			error("tree search ioctl: %m");
 			ret = 1;
@@ -596,10 +598,9 @@ static int print_min_dev_size(int fd, u64 devid)
 			struct btrfs_dev_extent *extent;
 			u64 len;
 
-			sh = (struct btrfs_ioctl_search_header *)(args.buf +
-								  off);
+			sh = btrfs_tree_search_data(&args, off);
 			off += sizeof(*sh);
-			extent = (struct btrfs_dev_extent *)(args.buf + off);
+			extent = btrfs_tree_search_data(&args, off);
 			off += btrfs_search_header_len(sh);
 
 			sk->min_objectid = btrfs_search_header_objectid(sh);
@@ -973,13 +974,14 @@ static int print_list_chunks(struct list_chunks_ctx *ctx, const char* sortmode,
 
 static u64 fill_usage(int fd, u64 lstart)
 {
-	struct btrfs_ioctl_search_args args;
-	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_search_header sh;
 	struct btrfs_block_group_item *item;
 	int ret;
 
 	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = BTRFS_EXTENT_TREE_OBJECTID;
 	sk->min_objectid = lstart;
 	sk->max_objectid = lstart;
@@ -990,7 +992,7 @@ static u64 fill_usage(int fd, u64 lstart)
 	sk->max_transid = (u64)-1;
 	sk->nr_items = 1;
 
-	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+	ret = btrfs_tree_search_ioctl(fd, &args);
 	if (ret < 0) {
 		error("cannot perform the search: %m");
 		return 1;
@@ -1002,8 +1004,8 @@ static u64 fill_usage(int fd, u64 lstart)
 	if (sk->nr_items > 1)
 		warning("found more than one blockgroup %llu", lstart);
 
-	memcpy(&sh, args.buf, sizeof(sh));
-	item = (struct btrfs_block_group_item*)(args.buf + sizeof(sh));
+	memcpy(&sh, btrfs_tree_search_data(&args, 0), sizeof(sh));
+	item = btrfs_tree_search_data(&args, sizeof(sh));
 
 	return item->used;
 }
@@ -1011,8 +1013,8 @@ static u64 fill_usage(int fd, u64 lstart)
 static int cmd_inspect_list_chunks(const struct cmd_struct *cmd,
 				   int argc, char **argv)
 {
-	struct btrfs_ioctl_search_args args;
-	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_search_header sh;
 	unsigned long off = 0;
 	u64 *lnumber = NULL;
@@ -1087,6 +1089,7 @@ static int cmd_inspect_list_chunks(const struct cmd_struct *cmd,
 		return 1;
 
 	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = BTRFS_CHUNK_TREE_OBJECTID;
 	sk->min_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
 	sk->max_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
@@ -1103,7 +1106,7 @@ static int cmd_inspect_list_chunks(const struct cmd_struct *cmd,
 
 	while (1) {
 		sk->nr_items = 1;
-		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+		ret = btrfs_tree_search_ioctl(fd, &args);
 		if (ret < 0) {
 			error("cannot perform the search: %m");
 			return 1;
@@ -1118,9 +1121,9 @@ static int cmd_inspect_list_chunks(const struct cmd_struct *cmd,
 			int sidx;
 			u64 used = (u64)-1;
 
-			memcpy(&sh, args.buf + off, sizeof(sh));
+			memcpy(&sh, btrfs_tree_search_data(&args, off), sizeof(sh));
 			off += sizeof(sh);
-			item = (struct btrfs_chunk*)(args.buf + off);
+			item = btrfs_tree_search_data(&args, off);
 			off += sh.len;
 
 			stripes = &item->stripe;
@@ -1230,24 +1233,25 @@ struct chunk_tree {
 
 static int read_chunk_tree(int fd, struct chunk **chunks, size_t *num_chunks)
 {
-	struct btrfs_ioctl_search_args search = {
-		.key = {
-			.tree_id = BTRFS_CHUNK_TREE_OBJECTID,
-			.min_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID,
-			.min_type = BTRFS_CHUNK_ITEM_KEY,
-			.min_offset = 0,
-			.max_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID,
-			.max_type = BTRFS_CHUNK_ITEM_KEY,
-			.max_offset = (u64)-1,
-			.min_transid = 0,
-			.max_transid = (u64)-1,
-			.nr_items = 0,
-		},
-	};
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	size_t items_pos = 0, buf_off = 0;
 	size_t capacity = 0;
 	int ret;
 
+	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
+	sk->tree_id = BTRFS_CHUNK_TREE_OBJECTID;
+	sk->min_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
+	sk->min_type = BTRFS_CHUNK_ITEM_KEY;
+	sk->min_offset = 0;
+	sk->max_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
+	sk->max_type = BTRFS_CHUNK_ITEM_KEY;
+	sk->max_offset = (u64)-1;
+	sk->min_transid = 0;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = 0;
+
 	*chunks = NULL;
 	*num_chunks = 0;
 	for (;;) {
@@ -1256,9 +1260,9 @@ static int read_chunk_tree(int fd, struct chunk **chunks, size_t *num_chunks)
 		struct chunk *chunk;
 		size_t i;
 
-		if (items_pos >= search.key.nr_items) {
-			search.key.nr_items = 4096;
-			ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search);
+		if (items_pos >= sk->nr_items) {
+			sk->nr_items = 4096;
+			ret = btrfs_tree_search_ioctl(fd, &args);
 			if (ret == -1) {
 				perror("BTRFS_IOC_TREE_SEARCH");
 				return -1;
@@ -1266,11 +1270,11 @@ static int read_chunk_tree(int fd, struct chunk **chunks, size_t *num_chunks)
 			items_pos = 0;
 			buf_off = 0;
 
-			if (search.key.nr_items == 0)
+			if (sk->nr_items == 0)
 				break;
 		}
 
-		header = (struct btrfs_ioctl_search_header *)(search.buf + buf_off);
+		header = btrfs_tree_search_data(&args, buf_off);
 		if (header->type != BTRFS_CHUNK_ITEM_KEY)
 			goto next;
 
@@ -1319,7 +1323,7 @@ next:
 		if (header->offset == (u64)-1)
 			break;
 		else
-			search.key.min_offset = header->offset + 1;
+			sk->min_offset = header->offset + 1;
 	}
 	return 0;
 }
@@ -1349,18 +1353,9 @@ static struct chunk *find_chunk(struct chunk *chunks, size_t num_chunks, u64 log
 static int map_physical_start(int fd, struct chunk *chunks, size_t num_chunks,
 			      u64 *physical_start)
 {
-	struct btrfs_ioctl_search_args search = {
-		.key = {
-			.min_type = BTRFS_EXTENT_DATA_KEY,
-			.max_type = BTRFS_EXTENT_DATA_KEY,
-			.min_offset = 0,
-			.max_offset = (u64)-1,
-			.min_transid = 0,
-			.max_transid = (u64)-1,
-			.nr_items = 0,
-		},
-	};
-	struct btrfs_ioctl_ino_lookup_args args = {
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
+	struct btrfs_ioctl_ino_lookup_args ino_args = {
 		.treeid = 0,
 		.objectid = BTRFS_FIRST_FREE_OBJECTID,
 	};
@@ -1381,14 +1376,23 @@ static int map_physical_start(int fd, struct chunk *chunks, size_t num_chunks,
 		return -EINVAL;
 	}
 
-	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
+	ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &ino_args);
 	if (ret == -1) {
 		error("cannot lookup parent subvolume: %m");
 		return -errno;
 	}
 
-	search.key.tree_id = args.treeid;
-	search.key.min_objectid = search.key.max_objectid = st.st_ino;
+	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
+	sk->min_type = BTRFS_EXTENT_DATA_KEY;
+	sk->max_type = BTRFS_EXTENT_DATA_KEY;
+	sk->min_offset = 0;
+	sk->max_offset = (u64)-1;
+	sk->min_transid = 0;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = 0;
+	sk->tree_id = ino_args.treeid;
+	sk->min_objectid = sk->max_objectid = st.st_ino;
 	for (;;) {
 		const struct btrfs_ioctl_search_header *header;
 		const struct btrfs_file_extent_item *item;
@@ -1396,9 +1400,9 @@ static int map_physical_start(int fd, struct chunk *chunks, size_t num_chunks,
 		u64 logical_offset = 0;
 		struct chunk *chunk = NULL;
 
-		if (items_pos >= search.key.nr_items) {
-			search.key.nr_items = 4096;
-			ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search);
+		if (items_pos >= sk->nr_items) {
+			sk->nr_items = 4096;
+			ret = btrfs_tree_search_ioctl(fd, &args);
 			if (ret == -1) {
 				error("cannot search tree: %m");
 				return -errno;
@@ -1406,11 +1410,11 @@ static int map_physical_start(int fd, struct chunk *chunks, size_t num_chunks,
 			items_pos = 0;
 			buf_off = 0;
 
-			if (search.key.nr_items == 0)
+			if (sk->nr_items == 0)
 				break;
 		}
 
-		header = (struct btrfs_ioctl_search_header *)(search.buf + buf_off);
+		header = btrfs_tree_search_data(&args, buf_off);
 		if (header->type != BTRFS_EXTENT_DATA_KEY)
 			goto next;
 
@@ -1497,7 +1501,7 @@ next:
 		if (header->offset == (u64)-1)
 			break;
 		else
-			search.key.min_offset = header->offset + 1;
+			sk->min_offset = header->offset + 1;
 	}
 	return 0;
 
diff --git a/cmds/qgroup.c b/cmds/qgroup.c
index 72d68d91..c39ad264 100644
--- a/cmds/qgroup.c
+++ b/cmds/qgroup.c
@@ -43,6 +43,7 @@
 #include "common/string-utils.h"
 #include "common/format-output.h"
 #include "common/messages.h"
+#include "common/tree-search.h"
 #include "cmds/commands.h"
 #include "cmds/qgroup.h"
 
@@ -1255,12 +1256,12 @@ static bool key_in_range(const struct btrfs_key *key,
 	return true;
 }
 
-static int __qgroups_search(int fd, struct btrfs_ioctl_search_args *args,
+static int __qgroups_search(int fd, struct btrfs_tree_search_args *args,
 			    struct qgroup_lookup *qgroup_lookup)
 {
 	int ret;
-	struct btrfs_ioctl_search_key *sk = &args->key;
-	struct btrfs_ioctl_search_key filter_key = args->key;
+	struct btrfs_ioctl_search_key *sk;
+	struct btrfs_ioctl_search_key filter_key;
 	struct btrfs_ioctl_search_header *sh;
 	unsigned long off = 0;
 	unsigned int i;
@@ -1271,10 +1272,13 @@ static int __qgroups_search(int fd, struct btrfs_ioctl_search_args *args,
 	u64 qgroupid;
 	u64 child, parent;
 
+	sk = btrfs_tree_search_sk(args);
+	filter_key = *sk;
+
 	qgroup_lookup_init(qgroup_lookup);
 
 	while (1) {
-		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, args);
+		ret = btrfs_tree_search_ioctl(fd, args);
 		if (ret < 0) {
 			if (errno == ENOENT)
 				ret = -ENOTTY;
@@ -1295,8 +1299,7 @@ static int __qgroups_search(int fd, struct btrfs_ioctl_search_args *args,
 		for (i = 0; i < sk->nr_items; i++) {
 			struct btrfs_key key;
 
-			sh = (struct btrfs_ioctl_search_header *)(args->buf +
-								  off);
+			sh = btrfs_tree_search_data(args, off);
 			off += sizeof(*sh);
 
 			key.objectid = btrfs_search_header_objectid(sh);
@@ -1308,24 +1311,21 @@ static int __qgroups_search(int fd, struct btrfs_ioctl_search_args *args,
 
 			switch (key.type) {
 			case BTRFS_QGROUP_STATUS_KEY:
-				si = (struct btrfs_qgroup_status_item *)
-				     (args->buf + off);
+				si = btrfs_tree_search_data(args, off);
 				flags = btrfs_stack_qgroup_status_flags(si);
 
 				print_status_flag_warning(flags);
 				break;
 			case BTRFS_QGROUP_INFO_KEY:
 				qgroupid = key.offset;
-				info = (struct btrfs_qgroup_info_item *)
-				       (args->buf + off);
+				info = btrfs_tree_search_data(args, off);
 
 				ret = update_qgroup_info(fd, qgroup_lookup,
 							 qgroupid, info);
 				break;
 			case BTRFS_QGROUP_LIMIT_KEY:
 				qgroupid = key.offset;
-				limit = (struct btrfs_qgroup_limit_item *)
-					(args->buf + off);
+				limit = btrfs_tree_search_data(args, off);
 
 				ret = update_qgroup_limit(fd, qgroup_lookup,
 							  qgroupid, limit);
@@ -1374,19 +1374,20 @@ next:
 
 static int qgroups_search_all(int fd, struct qgroup_lookup *qgroup_lookup)
 {
-	struct btrfs_ioctl_search_args args = {
-		.key = {
-			.tree_id = BTRFS_QUOTA_TREE_OBJECTID,
-			.max_type = BTRFS_QGROUP_RELATION_KEY,
-			.min_type = BTRFS_QGROUP_STATUS_KEY,
-			.max_objectid = (u64)-1,
-			.max_offset = (u64)-1,
-			.max_transid = (u64)-1,
-			.nr_items = 4096,
-		},
-	};
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	int ret;
 
+	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
+	sk->tree_id = BTRFS_QUOTA_TREE_OBJECTID;
+	sk->max_type = BTRFS_QGROUP_RELATION_KEY;
+	sk->min_type = BTRFS_QGROUP_STATUS_KEY;
+	sk->max_objectid = (u64)-1;
+	sk->max_offset = (u64)-1;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = 4096;
+
 	ret = __qgroups_search(fd, &args, qgroup_lookup);
 	if (ret == -ENOTTY) {
 		error("can't list qgroups: quotas not enabled");
@@ -1399,23 +1400,24 @@ static int qgroups_search_all(int fd, struct qgroup_lookup *qgroup_lookup)
 
 int btrfs_qgroup_query(int fd, u64 qgroupid, struct btrfs_qgroup_stats *stats)
 {
-	struct btrfs_ioctl_search_args args = {
-		.key = {
-			.tree_id = BTRFS_QUOTA_TREE_OBJECTID,
-			.min_type = BTRFS_QGROUP_INFO_KEY,
-			.max_type = BTRFS_QGROUP_LIMIT_KEY,
-			.max_objectid = 0,
-			.min_offset = qgroupid,
-			.max_offset = qgroupid,
-			.max_transid = (u64)-1,
-			.nr_items = 4096,
-		},
-	};
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct qgroup_lookup qgroup_lookup;
 	struct btrfs_qgroup *qgroup;
 	struct rb_node *n;
 	int ret;
 
+	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
+	sk->tree_id = BTRFS_QUOTA_TREE_OBJECTID;
+	sk->min_type = BTRFS_QGROUP_INFO_KEY;
+	sk->max_type = BTRFS_QGROUP_LIMIT_KEY;
+	sk->max_objectid = 0;
+	sk->min_offset = qgroupid;
+	sk->max_offset = qgroupid;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = 4096;
+
 	ret = __qgroups_search(fd, &args, &qgroup_lookup);
 	if (ret < 0)
 		return ret;
diff --git a/cmds/subvolume-list.c b/cmds/subvolume-list.c
index c9ad9830..6389f9d0 100644
--- a/cmds/subvolume-list.c
+++ b/cmds/subvolume-list.c
@@ -40,6 +40,7 @@
 #include "common/string-utils.h"
 #include "common/utils.h"
 #include "common/format-output.h"
+#include "common/tree-search.h"
 #include "cmds/commands.h"
 #include "cmds/subvolume.h"
 
@@ -817,8 +818,8 @@ static int lookup_ino_path(int fd, struct root_info *ri)
 static int list_subvol_search(int fd, struct rb_root *root_lookup)
 {
 	int ret;
-	struct btrfs_ioctl_search_args args;
-	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_search_header sh;
 	struct btrfs_root_ref *ref;
 	struct btrfs_root_item *ri;
@@ -832,8 +833,9 @@ static int list_subvol_search(int fd, struct rb_root *root_lookup)
 	int i;
 
 	root_lookup->rb_node = NULL;
-	memset(&args, 0, sizeof(args));
 
+	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
 	/* Search both live and deleted subvolumes */
 	sk->min_type = BTRFS_ROOT_ITEM_KEY;
@@ -845,7 +847,7 @@ static int list_subvol_search(int fd, struct rb_root *root_lookup)
 
 	while(1) {
 		sk->nr_items = 4096;
-		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+		ret = btrfs_tree_search_ioctl(fd, &args);
 		if (ret < 0)
 			return ret;
 		if (sk->nr_items == 0)
@@ -858,10 +860,10 @@ static int list_subvol_search(int fd, struct rb_root *root_lookup)
 		 * read the root_ref item it contains
 		 */
 		for (i = 0; i < sk->nr_items; i++) {
-			memcpy(&sh, args.buf + off, sizeof(sh));
+			memcpy(&sh, btrfs_tree_search_data(&args, off), sizeof(sh));
 			off += sizeof(sh);
 			if (sh.type == BTRFS_ROOT_BACKREF_KEY) {
-				ref = (struct btrfs_root_ref *)(args.buf + off);
+				ref = btrfs_tree_search_data(&args, off);
 				name_len = btrfs_stack_root_ref_name_len(ref);
 				name = (char *)(ref + 1);
 				dir_id = btrfs_stack_root_ref_dirid(ref);
@@ -877,7 +879,7 @@ static int list_subvol_search(int fd, struct rb_root *root_lookup)
 				u8 puuid[BTRFS_UUID_SIZE];
 				u8 ruuid[BTRFS_UUID_SIZE];
 
-				ri = (struct btrfs_root_item *)(args.buf + off);
+				ri = btrfs_tree_search_data(&args, off);
 				gen = btrfs_root_generation(ri);
 				flags = btrfs_root_flags(ri);
 				if(sh.len >= sizeof(struct btrfs_root_item)) {
diff --git a/cmds/subvolume.c b/cmds/subvolume.c
index 16eda56a..77fdc2c4 100644
--- a/cmds/subvolume.c
+++ b/cmds/subvolume.c
@@ -46,6 +46,7 @@
 #include "common/string-utils.h"
 #include "common/units.h"
 #include "common/format-output.h"
+#include "common/tree-search.h"
 #include "cmds/commands.h"
 #include "cmds/qgroup.h"
 
@@ -945,8 +946,8 @@ 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_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_search_header sh;
 	unsigned long off = 0;
 	u64 max_found = 0;
@@ -963,7 +964,7 @@ static u64 find_root_gen(int fd)
 	}
 
 	memset(&args, 0, sizeof(args));
-
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
 
 	/*
@@ -980,7 +981,7 @@ static u64 find_root_gen(int fd)
 	sk->nr_items = 4096;
 
 	while (1) {
-		ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+		ret = btrfs_tree_search_ioctl(fd, &args);
 		if (ret < 0) {
 			error("can't perform the search: %m");
 			return 0;
@@ -993,9 +994,9 @@ static u64 find_root_gen(int fd)
 		for (i = 0; i < sk->nr_items; i++) {
 			struct btrfs_root_item *item;
 
-			memcpy(&sh, args.buf + off, sizeof(sh));
+			memcpy(&sh, btrfs_tree_search_data(&args, off), sizeof(sh));
 			off += sizeof(sh);
-			item = (struct btrfs_root_item *)(args.buf + off);
+			item = btrfs_tree_search_data(&args, off);
 			off += sh.len;
 
 			sk->min_objectid = sh.objectid;
@@ -1096,14 +1097,13 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
 	char *name;
 	char *full;
 	int ret;
-	struct btrfs_ioctl_search_args args;
-	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_search_header *sh;
-	unsigned long off = 0;
 	int namelen;
 
 	memset(&args, 0, sizeof(args));
-
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = 0;
 
 	/*
@@ -1118,7 +1118,7 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
 	sk->max_transid = (u64)-1;
 	sk->nr_items = 1;
 
-	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
+	ret = btrfs_tree_search_ioctl(fd, &args);
 	if (ret < 0) {
 		error("can't perform the search: %m");
 		return NULL;
@@ -1127,11 +1127,10 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name)
 	if (sk->nr_items == 0)
 		return NULL;
 
-	off = 0;
-	sh = (struct btrfs_ioctl_search_header *)(args.buf + off);
-
+	sh = btrfs_tree_search_data(&args, 0);
 	if (btrfs_search_header_type(sh) == BTRFS_INODE_REF_KEY) {
 		struct btrfs_inode_ref *ref;
+
 		dirid = btrfs_search_header_offset(sh);
 
 		ref = (struct btrfs_inode_ref *)(sh + 1);
@@ -1244,8 +1243,8 @@ static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh,
 static int btrfs_list_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_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_search_header sh;
 	struct btrfs_file_extent_item *item;
 	unsigned long off = 0;
@@ -1260,7 +1259,7 @@ static int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen)
 
 	memset(&backup, 0, sizeof(backup));
 	memset(&args, 0, sizeof(args));
-
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = root_id;
 
 	/*
@@ -1277,7 +1276,7 @@ static 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);
+		ret = btrfs_tree_search_ioctl(fd, &args);
 		if (ret < 0) {
 			error("can't perform the search: %m");
 			break;
@@ -1293,7 +1292,7 @@ static int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen)
 		 * read the root_ref item it contains
 		 */
 		for (i = 0; i < sk->nr_items; i++) {
-			memcpy(&sh, args.buf + off, sizeof(sh));
+			memcpy(&sh, btrfs_tree_search_data(&args, off), sizeof(sh));
 			off += sizeof(sh);
 
 			/*
@@ -1303,8 +1302,8 @@ static int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen)
 			if (sh.len == 0)
 				item = &backup;
 			else
-				item = (struct btrfs_file_extent_item *)(args.buf +
-								 off);
+				item = btrfs_tree_search_data(&args, off);
+
 			found_gen = btrfs_stack_file_extent_generation(item);
 			if (sh.type == BTRFS_EXTENT_DATA_KEY &&
 			    found_gen >= oldest_gen) {
diff --git a/common/send-utils.c b/common/send-utils.c
index 54fb782b..ed20c2a5 100644
--- a/common/send-utils.c
+++ b/common/send-utils.c
@@ -32,6 +32,7 @@
 #include "common/send-utils.h"
 #include "common/messages.h"
 #include "common/utils.h"
+#include "common/tree-search.h"
 
 static int btrfs_subvolid_resolve_sub(int fd, char *path, size_t *path_len,
 				      u64 subvol_id);
@@ -62,8 +63,8 @@ static int btrfs_read_root_item_raw(int mnt_fd, u64 root_id, size_t buf_len,
 				    u32 *read_len, void *buf)
 {
 	int ret;
-	struct btrfs_ioctl_search_args args;
-	struct btrfs_ioctl_search_key *sk = &args.key;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_search_header *sh;
 	unsigned long off = 0;
 	int found = 0;
@@ -71,7 +72,7 @@ static int btrfs_read_root_item_raw(int mnt_fd, u64 root_id, size_t buf_len,
 
 	*read_len = 0;
 	memset(&args, 0, sizeof(args));
-
+	sk = btrfs_tree_search_sk(&args);
 	sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
 
 	/*
@@ -88,7 +89,7 @@ static int btrfs_read_root_item_raw(int mnt_fd, u64 root_id, size_t buf_len,
 	sk->nr_items = 4096;
 
 	while (1) {
-		ret = ioctl(mnt_fd, BTRFS_IOC_TREE_SEARCH, &args);
+		ret = btrfs_tree_search_ioctl(mnt_fd, &args);
 		if (ret < 0) {
 			error("can't perform the search: %m");
 			return 0;
@@ -100,11 +101,11 @@ static int btrfs_read_root_item_raw(int mnt_fd, u64 root_id, size_t buf_len,
 		off = 0;
 		for (i = 0; i < sk->nr_items; i++) {
 			struct btrfs_root_item *item;
-			sh = (struct btrfs_ioctl_search_header *)(args.buf +
-								  off);
 
+			sh = btrfs_tree_search_data(&args, off);
 			off += sizeof(*sh);
-			item = (struct btrfs_root_item *)(args.buf + off);
+
+			item = btrfs_tree_search_data(&args, off);
 			off += btrfs_search_header_len(sh);
 
 			sk->min_objectid = btrfs_search_header_objectid(sh);
@@ -192,7 +193,8 @@ static int btrfs_subvolid_resolve_sub(int fd, char *path, size_t *path_len,
 				      u64 subvol_id)
 {
 	int ret;
-	struct btrfs_ioctl_search_args search_arg;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 	struct btrfs_ioctl_ino_lookup_args ino_lookup_arg;
 	struct btrfs_ioctl_search_header *search_header;
 	struct btrfs_root_ref *backref_item;
@@ -205,16 +207,17 @@ static int btrfs_subvolid_resolve_sub(int fd, char *path, size_t *path_len,
 		return 0;
 	}
 
-	memset(&search_arg, 0, sizeof(search_arg));
-	search_arg.key.tree_id = BTRFS_ROOT_TREE_OBJECTID;
-	search_arg.key.min_objectid = subvol_id;
-	search_arg.key.max_objectid = subvol_id;
-	search_arg.key.min_type = BTRFS_ROOT_BACKREF_KEY;
-	search_arg.key.max_type = BTRFS_ROOT_BACKREF_KEY;
-	search_arg.key.max_offset = (u64)-1;
-	search_arg.key.max_transid = (u64)-1;
-	search_arg.key.nr_items = 1;
-	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search_arg);
+	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
+	sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
+	sk->min_objectid = subvol_id;
+	sk->max_objectid = subvol_id;
+	sk->min_type = BTRFS_ROOT_BACKREF_KEY;
+	sk->max_type = BTRFS_ROOT_BACKREF_KEY;
+	sk->max_offset = (u64)-1;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = 1;
+	ret = btrfs_tree_search_ioctl(fd, &args);
 	if (ret < 0) {
 		fprintf(stderr,
 			"ioctl(BTRFS_IOC_TREE_SEARCH, subvol_id %llu) ret=%d, error: %m\n",
@@ -222,11 +225,11 @@ static int btrfs_subvolid_resolve_sub(int fd, char *path, size_t *path_len,
 		return ret;
 	}
 
-	if (search_arg.key.nr_items < 1) {
+	if (sk->nr_items < 1) {
 		fprintf(stderr, "failed to lookup subvol_id %llu!\n", subvol_id);
 		return -ENOENT;
 	}
-	search_header = (struct btrfs_ioctl_search_header *)search_arg.buf;
+	search_header = btrfs_tree_search_data(&args, 0);
 	backref_item = (struct btrfs_root_ref *)(search_header + 1);
 	if (btrfs_search_header_offset(search_header)
 	    != BTRFS_FS_TREE_OBJECTID) {
diff --git a/common/utils.c b/common/utils.c
index 3791f0b6..c303462c 100644
--- a/common/utils.c
+++ b/common/utils.c
@@ -45,6 +45,7 @@
 #include "common/open-utils.h"
 #include "common/sysfs-utils.h"
 #include "common/messages.h"
+#include "common/tree-search.h"
 #include "cmds/commands.h"
 #include "mkfs/common.h"
 
@@ -120,11 +121,10 @@ int get_df(int fd, struct btrfs_ioctl_space_args **sargs_ret)
 }
 
 
-static u64 find_max_device_id(struct btrfs_ioctl_search_args *search_args,
-			      int nr_items)
+static u64 find_max_device_id(struct btrfs_tree_search_args *args, int nr_items)
 {
 	struct btrfs_dev_item *dev_item;
-	char *buf = search_args->buf;
+	char *buf = btrfs_tree_search_data(args, 0);
 
 	buf += (nr_items - 1) * (sizeof(struct btrfs_ioctl_search_header)
 				       + sizeof(struct btrfs_dev_item));
@@ -141,8 +141,8 @@ static int search_chunk_tree_for_fs_info(int fd,
 	int ret;
 	int max_items;
 	u64 start_devid = 1;
-	struct btrfs_ioctl_search_args search_args;
-	struct btrfs_ioctl_search_key *search_key = &search_args.key;
+	struct btrfs_tree_search_args args;
+	struct btrfs_ioctl_search_key *sk;
 
 	fi_args->num_devices = 0;
 
@@ -150,41 +150,41 @@ static int search_chunk_tree_for_fs_info(int fd,
 	       / (sizeof(struct btrfs_ioctl_search_header)
 			       + sizeof(struct btrfs_dev_item));
 
-	search_key->tree_id = BTRFS_CHUNK_TREE_OBJECTID;
-	search_key->min_objectid = BTRFS_DEV_ITEMS_OBJECTID;
-	search_key->max_objectid = BTRFS_DEV_ITEMS_OBJECTID;
-	search_key->min_type = BTRFS_DEV_ITEM_KEY;
-	search_key->max_type = BTRFS_DEV_ITEM_KEY;
-	search_key->min_transid = 0;
-	search_key->max_transid = (u64)-1;
-	search_key->nr_items = max_items;
-	search_key->max_offset = (u64)-1;
+	memset(&args, 0, sizeof(args));
+	sk = btrfs_tree_search_sk(&args);
+	sk->tree_id = BTRFS_CHUNK_TREE_OBJECTID;
+	sk->min_objectid = BTRFS_DEV_ITEMS_OBJECTID;
+	sk->max_objectid = BTRFS_DEV_ITEMS_OBJECTID;
+	sk->min_type = BTRFS_DEV_ITEM_KEY;
+	sk->max_type = BTRFS_DEV_ITEM_KEY;
+	sk->min_transid = 0;
+	sk->max_transid = (u64)-1;
+	sk->nr_items = max_items;
+	sk->max_offset = (u64)-1;
 
 again:
-	search_key->min_offset = start_devid;
+	sk->min_offset = start_devid;
 
-	ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &search_args);
+	ret = btrfs_tree_search_ioctl(fd, &args);
 	if (ret < 0)
 		return -errno;
 
-	fi_args->num_devices += (u64)search_key->nr_items;
+	fi_args->num_devices += (u64)sk->nr_items;
 
-	if (search_key->nr_items == max_items) {
-		start_devid = find_max_device_id(&search_args,
-					search_key->nr_items) + 1;
+	if (sk->nr_items == max_items) {
+		start_devid = find_max_device_id(&args, sk->nr_items) + 1;
 		goto again;
 	}
 
 	/* Get the latest max_id to stay consistent with the num_devices */
-	if (search_key->nr_items == 0)
+	if (sk->nr_items == 0)
 		/*
 		 * last tree_search returns an empty buf, use the devid of
 		 * the last dev_item of the previous tree_search
 		 */
 		fi_args->max_id = start_devid - 1;
 	else
-		fi_args->max_id = find_max_device_id(&search_args,
-						search_key->nr_items);
+		fi_args->max_id = find_max_device_id(&args, sk->nr_items);
 
 	return 0;
 }