X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cmds-send.c;h=07070ad82e220ef6aca33aeafc41a09354e7ef1a;hb=bd2cc320aff5789fe4034736fa6da8b4ebae475f;hp=41ea5236b873aea599bd35a640f92c2b3e5cb696;hpb=f99b1f1a631f3dfb8dc9ad03b9a00bdc2a231d31;p=platform%2Fupstream%2Fbtrfs-progs.git

diff --git a/cmds-send.c b/cmds-send.c
index 41ea523..07070ad 100644
--- a/cmds-send.c
+++ b/cmds-send.c
@@ -16,7 +16,8 @@
  * Boston, MA 021110-1307, USA.
  */
 
-#define _GNU_SOURCE
+
+#include "kerncompat.h"
 
 #include <unistd.h>
 #include <stdint.h>
@@ -29,13 +30,16 @@
 #include <sys/ioctl.h>
 #include <libgen.h>
 #include <mntent.h>
-
+#include <assert.h>
+#include <getopt.h>
 #include <uuid/uuid.h>
+#include <limits.h>
 
 #include "ctree.h"
 #include "ioctl.h"
 #include "commands.h"
 #include "list.h"
+#include "utils.h"
 
 #include "send.h"
 #include "send-utils.h"
@@ -54,39 +58,6 @@ struct btrfs_send {
 	struct subvol_uuid_search sus;
 };
 
-int find_mount_root(const char *path, char **mount_root)
-{
-	FILE *mnttab;
-	int fd;
-	struct mntent *ent;
-	int len;
-	int longest_matchlen = 0;
-	char *longest_match = NULL;
-
-	fd = open(path, O_RDONLY | O_NOATIME);
-	if (fd < 0)
-		return -errno;
-	close(fd);
-
-	mnttab = fopen("/etc/mtab", "r");
-	while ((ent = getmntent(mnttab))) {
-		len = strlen(ent->mnt_dir);
-		if (strncmp(ent->mnt_dir, path, len) == 0) {
-			/* match found */
-			if (longest_matchlen < len) {
-				free(longest_match);
-				longest_matchlen = len;
-				longest_match = strdup(ent->mnt_dir);
-			}
-		}
-	}
-
-	*mount_root = realpath(longest_match, NULL);
-	free(longest_match);
-
-	return 0;
-}
-
 static int get_root_id(struct btrfs_send *s, const char *path, u64 *root_id)
 {
 	struct subvol_info *si;
@@ -96,30 +67,33 @@ static int get_root_id(struct btrfs_send *s, const char *path, u64 *root_id)
 	if (!si)
 		return -ENOENT;
 	*root_id = si->root_id;
+	free(si->path);
+	free(si);
 	return 0;
 }
 
 static struct subvol_info *get_parent(struct btrfs_send *s, u64 root_id)
 {
+	struct subvol_info *si_tmp;
 	struct subvol_info *si;
 
-	si = subvol_uuid_search(&s->sus, root_id, NULL, 0, NULL,
+	si_tmp = subvol_uuid_search(&s->sus, root_id, NULL, 0, NULL,
 			subvol_search_by_root_id);
-	if (!si)
+	if (!si_tmp)
 		return NULL;
 
-	si = subvol_uuid_search(&s->sus, 0, si->parent_uuid, 0, NULL,
+	si = subvol_uuid_search(&s->sus, 0, si_tmp->parent_uuid, 0, NULL,
 			subvol_search_by_uuid);
-	if (!si)
-		return NULL;
+	free(si_tmp->path);
+	free(si_tmp);
 	return si;
 }
 
 static int find_good_parent(struct btrfs_send *s, u64 root_id, u64 *found)
 {
 	int ret;
-	struct subvol_info *parent;
-	struct subvol_info *parent2;
+	struct subvol_info *parent = NULL;
+	struct subvol_info *parent2 = NULL;
 	struct subvol_info *best_parent = NULL;
 	__s64 tmp;
 	u64 best_diff = (u64)-1;
@@ -134,24 +108,46 @@ static int find_good_parent(struct btrfs_send *s, u64 root_id, u64 *found)
 	for (i = 0; i < s->clone_sources_count; i++) {
 		if (s->clone_sources[i] == parent->root_id) {
 			best_parent = parent;
+			parent = NULL;
 			goto out_found;
 		}
 	}
 
 	for (i = 0; i < s->clone_sources_count; i++) {
 		parent2 = get_parent(s, s->clone_sources[i]);
-		if (parent2 != parent)
+		if (!parent2)
 			continue;
+		if (parent2->root_id != parent->root_id) {
+			free(parent2->path);
+			free(parent2);
+			parent2 = NULL;
+			continue;
+		}
 
+		free(parent2->path);
+		free(parent2);
 		parent2 = subvol_uuid_search(&s->sus, s->clone_sources[i], NULL,
 				0, NULL, subvol_search_by_root_id);
 
+		if (!parent2) {
+			ret = -ENOENT;
+			goto out;
+		}
 		tmp = parent2->ctransid - parent->ctransid;
 		if (tmp < 0)
 			tmp *= -1;
 		if (tmp < best_diff) {
-			best_parent = parent;
+			if (best_parent) {
+				free(best_parent->path);
+				free(best_parent);
+			}
+			best_parent = parent2;
+			parent2 = NULL;
 			best_diff = tmp;
+		} else {
+			free(parent2->path);
+			free(parent2);
+			parent2 = NULL;
 		}
 	}
 
@@ -165,14 +161,32 @@ out_found:
 	ret = 0;
 
 out:
+	if (parent) {
+		free(parent->path);
+		free(parent);
+	}
+	if (best_parent) {
+		free(best_parent->path);
+		free(best_parent);
+	}
 	return ret;
 }
 
-static void add_clone_source(struct btrfs_send *s, u64 root_id)
+static int add_clone_source(struct btrfs_send *s, u64 root_id)
 {
+	void *tmp;
+
+	tmp = s->clone_sources;
 	s->clone_sources = realloc(s->clone_sources,
 		sizeof(*s->clone_sources) * (s->clone_sources_count + 1));
+
+	if (!s->clone_sources) {
+		free(tmp);
+		return -ENOMEM;
+	}
 	s->clone_sources[s->clone_sources_count++] = root_id;
+
+	return 0;
 }
 
 static int write_buf(int fd, const void *buf, int size)
@@ -184,14 +198,12 @@ static int write_buf(int fd, const void *buf, int size)
 		ret = write(fd, (char*)buf + pos, size - pos);
 		if (ret < 0) {
 			ret = -errno;
-			fprintf(stderr, "ERROR: failed to dump stream. %s",
-					strerror(-ret));
+			error("failed to dump stream: %s", strerror(-ret));
 			goto out;
 		}
 		if (!ret) {
 			ret = -EIO;
-			fprintf(stderr, "ERROR: failed to dump stream. %s",
-					strerror(-ret));
+			error("failed to dump stream: %s", strerror(-ret));
 			goto out;
 		}
 		pos += ret;
@@ -213,8 +225,8 @@ static void *dump_thread(void *arg_)
 		readed = read(s->send_fd, buf, sizeof(buf));
 		if (readed < 0) {
 			ret = -errno;
-			fprintf(stderr, "ERROR: failed to read stream from "
-					"kernel. %s\n", strerror(-ret));
+			error("failed to read stream from kernel: %s\n",
+				strerror(-ret));
 			goto out;
 		}
 		if (!readed) {
@@ -234,64 +246,59 @@ out:
 	return ERR_PTR(ret);
 }
 
-static int do_send(struct btrfs_send *send, u64 root_id, u64 parent_root)
+static int do_send(struct btrfs_send *send, u64 parent_root_id,
+		   int is_first_subvol, int is_last_subvol, char *subvol,
+		   u64 flags)
 {
 	int ret;
 	pthread_t t_read;
-	pthread_attr_t t_attr;
 	struct btrfs_ioctl_send_args io_send;
-	struct subvol_info *si;
 	void *t_err = NULL;
 	int subvol_fd = -1;
-	int pipefd[2];
+	int pipefd[2] = {-1, -1};
 
-	si = subvol_uuid_search(&send->sus, root_id, NULL, 0, NULL,
-			subvol_search_by_root_id);
-	if (!si) {
-		ret = -ENOENT;
-		fprintf(stderr, "ERROR: could not find subvol info for %llu",
-				root_id);
-		goto out;
-	}
-
-	subvol_fd = openat(send->mnt_fd, si->path, O_RDONLY | O_NOATIME);
+	subvol_fd = openat(send->mnt_fd, subvol, O_RDONLY | O_NOATIME);
 	if (subvol_fd < 0) {
 		ret = -errno;
-		fprintf(stderr, "ERROR: open %s failed. %s\n", si->path,
-				strerror(-ret));
+		error("cannot open %s: %s", subvol, strerror(-ret));
 		goto out;
 	}
 
-	ret = pthread_attr_init(&t_attr);
-
 	ret = pipe(pipefd);
 	if (ret < 0) {
 		ret = -errno;
-		fprintf(stderr, "ERROR: pipe failed. %s\n", strerror(-ret));
+		error("pipe failed: %s", strerror(-ret));
 		goto out;
 	}
 
+	memset(&io_send, 0, sizeof(io_send));
 	io_send.send_fd = pipefd[1];
 	send->send_fd = pipefd[0];
 
 	if (!ret)
-		ret = pthread_create(&t_read, &t_attr, dump_thread,
+		ret = pthread_create(&t_read, NULL, dump_thread,
 					send);
 	if (ret) {
 		ret = -ret;
-		fprintf(stderr, "ERROR: thread setup failed: %s\n",
-			strerror(-ret));
+		error("thread setup failed: %s", strerror(-ret));
 		goto out;
 	}
 
+	io_send.flags = flags;
 	io_send.clone_sources = (__u64*)send->clone_sources;
 	io_send.clone_sources_count = send->clone_sources_count;
-	io_send.parent_root = parent_root;
+	io_send.parent_root = parent_root_id;
+	if (!is_first_subvol)
+		io_send.flags |= BTRFS_SEND_FLAG_OMIT_STREAM_HEADER;
+	if (!is_last_subvol)
+		io_send.flags |= BTRFS_SEND_FLAG_OMIT_END_CMD;
 	ret = ioctl(subvol_fd, BTRFS_IOC_SEND, &io_send);
-	if (ret) {
+	if (ret < 0) {
 		ret = -errno;
-		fprintf(stderr, "ERROR: send ioctl failed with %d: %s\n", ret,
-			strerror(-ret));
+		error("send ioctl failed with %d: %s", ret, strerror(-ret));
+		if (ret == -EINVAL && (!is_first_subvol || !is_last_subvol))
+			fprintf(stderr,
+				"Try upgrading your kernel or don't use -e.\n");
 		goto out;
 	}
 	if (g_verbose > 0)
@@ -301,47 +308,33 @@ static int do_send(struct btrfs_send *send, u64 root_id, u64 parent_root)
 		fprintf(stderr, "joining genl thread\n");
 
 	close(pipefd[1]);
-	pipefd[1] = 0;
+	pipefd[1] = -1;
 
 	ret = pthread_join(t_read, &t_err);
 	if (ret) {
 		ret = -ret;
-		fprintf(stderr, "ERROR: pthread_join failed: %s\n",
-			strerror(-ret));
+		error("pthread_join failed: %s", strerror(-ret));
 		goto out;
 	}
 	if (t_err) {
 		ret = (long int)t_err;
-		fprintf(stderr, "ERROR: failed to process send stream, ret=%ld "
-			"(%s)\n", (long int)t_err, strerror(-ret));
+		error("failed to process send stream, ret=%ld (%s)",
+				(long int)t_err, strerror(-ret));
 		goto out;
 	}
 
-	pthread_attr_destroy(&t_attr);
-
 	ret = 0;
 
 out:
 	if (subvol_fd != -1)
 		close(subvol_fd);
-	if (pipefd[0])
+	if (pipefd[0] != -1)
 		close(pipefd[0]);
-	if (pipefd[1])
+	if (pipefd[1] != -1)
 		close(pipefd[1]);
 	return ret;
 }
 
-static const char *get_subvol_name(struct btrfs_send *s, const char *full_path)
-{
-	int len = strlen(s->root_path);
-	if (!len)
-		return full_path;
-	if (s->root_path[len - 1] != '/')
-		len += 1;
-
-	return full_path + len;
-}
-
 static int init_root_path(struct btrfs_send *s, const char *subvol)
 {
 	int ret = 0;
@@ -351,24 +344,28 @@ static int init_root_path(struct btrfs_send *s, const char *subvol)
 
 	ret = find_mount_root(subvol, &s->root_path);
 	if (ret < 0) {
+		error("failed to determine mount point for %s: %s",
+			subvol, strerror(-ret));
+		ret = -EINVAL;
+		goto out;
+	}
+	if (ret > 0) {
+		error("%s doesn't belong to btrfs mount point", subvol);
 		ret = -EINVAL;
-		fprintf(stderr, "ERROR: failed to determine mount point "
-				"for %s\n", subvol);
 		goto out;
 	}
 
 	s->mnt_fd = open(s->root_path, O_RDONLY | O_NOATIME);
 	if (s->mnt_fd < 0) {
 		ret = -errno;
-		fprintf(stderr, "ERROR: can't open '%s': %s\n", s->root_path,
-			strerror(-ret));
+		error("cannot open '%s': %s", s->root_path, strerror(-ret));
 		goto out;
 	}
 
 	ret = subvol_uuid_search_init(s->mnt_fd, &s->sus);
 	if (ret < 0) {
-		fprintf(stderr, "ERROR: failed to initialize subvol search. "
-				"%s\n", strerror(-ret));
+		error("failed to initialize subvol search: %s",
+			strerror(-ret));
 		goto out;
 	}
 
@@ -386,16 +383,15 @@ static int is_subvol_ro(struct btrfs_send *s, char *subvol)
 	fd = openat(s->mnt_fd, subvol, O_RDONLY | O_NOATIME);
 	if (fd < 0) {
 		ret = -errno;
-		fprintf(stderr, "ERROR: failed to open %s. %s\n",
-				subvol, strerror(-ret));
+		error("cannot open %s: %s", subvol, strerror(-ret));
 		goto out;
 	}
 
 	ret = ioctl(fd, BTRFS_IOC_SUBVOL_GETFLAGS, &flags);
 	if (ret < 0) {
 		ret = -errno;
-		fprintf(stderr, "ERROR: failed to get flags for subvolume. "
-				"%s\n", strerror(-ret));
+		error("failed to get flags for subvolume %s: %s",
+			subvol, strerror(-ret));
 		goto out;
 	}
 
@@ -411,33 +407,47 @@ out:
 	return ret;
 }
 
-int cmd_send_start(int argc, char **argv)
+int cmd_send(int argc, char **argv)
 {
 	char *subvol = NULL;
-	char c;
 	int ret;
-	char *outname = NULL;
+	char outname[PATH_MAX];
 	struct btrfs_send send;
 	u32 i;
 	char *mount_root = NULL;
 	char *snapshot_parent = NULL;
-	u64 root_id;
+	u64 root_id = 0;
 	u64 parent_root_id = 0;
+	int full_send = 1;
+	int new_end_cmd_semantic = 0;
+	u64 send_flags = 0;
 
 	memset(&send, 0, sizeof(send));
 	send.dump_fd = fileno(stdout);
+	outname[0] = 0;
+
+	while (1) {
+		enum { GETOPT_VAL_SEND_NO_DATA = 256 };
+		static const struct option long_options[] = {
+			{ "no-data", no_argument, NULL, GETOPT_VAL_SEND_NO_DATA }
+		};
+		int c = getopt_long(argc, argv, "vec:f:i:p:", long_options, NULL);
+
+		if (c < 0)
+			break;
 
-	while ((c = getopt(argc, argv, "vf:i:p:")) != -1) {
 		switch (c) {
 		case 'v':
 			g_verbose++;
 			break;
-		case 'i': {
+		case 'e':
+			new_end_cmd_semantic = 1;
+			break;
+		case 'c':
 			subvol = realpath(optarg, NULL);
 			if (!subvol) {
 				ret = -errno;
-				fprintf(stderr, "ERROR: realpath %s failed. "
-						"%s\n", optarg, strerror(-ret));
+				error("realpath %s failed: %s\n", optarg, strerror(-ret));
 				goto out;
 			}
 
@@ -445,57 +455,112 @@ int cmd_send_start(int argc, char **argv)
 			if (ret < 0)
 				goto out;
 
-			ret = get_root_id(&send, get_subvol_name(&send, subvol),
-					&root_id);
+			ret = get_root_id(&send,
+				subvol_strip_mountpoint(send.root_path, subvol),
+				&root_id);
 			if (ret < 0) {
-				fprintf(stderr, "ERROR: could not resolve "
-						"root_id for %s\n", subvol);
+				error("cannot resolve rootid for %s", subvol);
+				goto out;
+			}
+
+			ret = is_subvol_ro(&send, subvol);
+			if (ret < 0)
+				goto out;
+			if (!ret) {
+				ret = -EINVAL;
+				error("cloned subvolume %s is not read-only", subvol);
 				goto out;
 			}
-			add_clone_source(&send, root_id);
+
+			ret = add_clone_source(&send, root_id);
+			if (ret < 0) {
+				error("cannot add clone source: %s", strerror(-ret));
+				goto out;
+			}
+			subvol_uuid_search_finit(&send.sus);
 			free(subvol);
+			subvol = NULL;
+			if (send.mnt_fd >= 0) {
+				close(send.mnt_fd);
+				send.mnt_fd = -1;
+			}
+			free(send.root_path);
+			send.root_path = NULL;
+			full_send = 0;
 			break;
-		}
 		case 'f':
-			outname = optarg;
+			if (arg_copy_path(outname, optarg, sizeof(outname))) {
+				error("output file path too long (%zu)", strlen(optarg));
+				ret = 1;
+				goto out;
+			}
 			break;
 		case 'p':
+			if (snapshot_parent) {
+				error("you cannot have more than one parent (-p)");
+				ret = 1;
+				goto out;
+			}
 			snapshot_parent = realpath(optarg, NULL);
 			if (!snapshot_parent) {
 				ret = -errno;
-				fprintf(stderr, "ERROR: realpath %s failed. "
-						"%s\n", optarg, strerror(-ret));
+				error("realpath %s failed: %s", optarg, strerror(-ret));
+				goto out;
+			}
+
+			ret = is_subvol_ro(&send, snapshot_parent);
+			if (ret < 0)
+				goto out;
+			if (!ret) {
+				ret = -EINVAL;
+				error("parent subvolume %s is not read-only",
+					snapshot_parent);
 				goto out;
 			}
+
+			full_send = 0;
+			break;
+		case 'i':
+			error("option -i was removed, use -c instead");
+			ret = 1;
+			goto out;
+		case GETOPT_VAL_SEND_NO_DATA:
+			send_flags |= BTRFS_SEND_FLAG_NO_FILE_DATA;
 			break;
 		case '?':
 		default:
-			fprintf(stderr, "ERROR: send args invalid.\n");
-			return 1;
+			error("send arguments invalid");
+			ret = 1;
+			goto out;
 		}
 	}
 
-	if (optind == argc) {
-		fprintf(stderr, "ERROR: send needs path to snapshot\n");
-		return 1;
-	}
+	if (check_argc_min(argc - optind, 1))
+		usage(cmd_send_usage);
 
-	if (outname != NULL) {
+	if (outname[0]) {
 		send.dump_fd = creat(outname, 0600);
 		if (send.dump_fd == -1) {
 			ret = -errno;
-			fprintf(stderr, "ERROR: can't create '%s': %s\n",
-					outname, strerror(-ret));
+			error("cannot create '%s': %s", outname, strerror(-ret));
 			goto out;
 		}
 	}
 
+	if (isatty(send.dump_fd)) {
+		error(
+	    "not dumping send stream into a terminal, redirect it into a file");
+		ret = 1;
+		goto out;
+	}
+
 	/* use first send subvol to determine mount_root */
 	subvol = argv[optind];
 
 	subvol = realpath(argv[optind], NULL);
 	if (!subvol) {
-		fprintf(stderr, "ERROR: unable to resolve %s\n", argv[optind]);
+		ret = -errno;
+		error("unable to resolve %s", argv[optind]);
 		goto out;
 	}
 
@@ -505,35 +570,44 @@ int cmd_send_start(int argc, char **argv)
 
 	if (snapshot_parent != NULL) {
 		ret = get_root_id(&send,
-				get_subvol_name(&send, snapshot_parent),
-				&parent_root_id);
+			subvol_strip_mountpoint(send.root_path, snapshot_parent),
+			&parent_root_id);
 		if (ret < 0) {
-			fprintf(stderr, "ERROR: could not resolve root_id "
-					"for %s\n", snapshot_parent);
+			error("could not resolve rootid for %s", snapshot_parent);
 			goto out;
 		}
 
-		add_clone_source(&send, parent_root_id);
+		ret = add_clone_source(&send, parent_root_id);
+		if (ret < 0) {
+			error("cannot add clone source: %s", strerror(-ret));
+			goto out;
+		}
 	}
 
 	for (i = optind; i < argc; i++) {
+		free(subvol);
 		subvol = realpath(argv[i], NULL);
 		if (!subvol) {
-			fprintf(stderr, "ERROR: unable to resolve %s\n", argv[i]);
+			ret = -errno;
+			error("unable to resolve %s", argv[i]);
 			goto out;
 		}
 
 		ret = find_mount_root(subvol, &mount_root);
 		if (ret < 0) {
-			fprintf(stderr, "ERROR: find_mount_root failed on %s: "
-					"%s\n", subvol,
+			error("find_mount_root failed on %s: %s", subvol,
 				strerror(-ret));
 			goto out;
 		}
+		if (ret > 0) {
+			error("%s does not belong to btrfs mount point",
+				subvol);
+			ret = -EINVAL;
+			goto out;
+		}
 		if (strcmp(send.root_path, mount_root) != 0) {
 			ret = -EINVAL;
-			fprintf(stderr, "ERROR: all subvols must be from the "
-					"same fs.\n");
+			error("all subvolumes must be from the same filesystem");
 			goto out;
 		}
 		free(mount_root);
@@ -543,14 +617,19 @@ int cmd_send_start(int argc, char **argv)
 			goto out;
 		if (!ret) {
 			ret = -EINVAL;
-			fprintf(stderr, "ERROR: %s is not read-only.\n",
-					subvol);
+			error("subvolume %s is not read-only", subvol);
 			goto out;
 		}
-		free(subvol);
 	}
 
+	if (send_flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
+		printf("Mode NO_FILE_DATA enabled\n");
+
 	for (i = optind; i < argc; i++) {
+		int is_first_subvol;
+		int is_last_subvol;
+
+		free(subvol);
 		subvol = argv[i];
 
 		fprintf(stderr, "At subvol %s\n", subvol);
@@ -558,23 +637,17 @@ int cmd_send_start(int argc, char **argv)
 		subvol = realpath(subvol, NULL);
 		if (!subvol) {
 			ret = -errno;
-			fprintf(stderr, "ERROR: realpath %s failed. "
-					"%s\n", argv[i], strerror(-ret));
-			goto out;
-		}
-
-		ret = get_root_id(&send, get_subvol_name(&send, subvol),
-				&root_id);
-		if (ret < 0) {
-			fprintf(stderr, "ERROR: could not resolve root_id "
-					"for %s\n", subvol);
+			error("realpath %s failed: %s", argv[i], strerror(-ret));
 			goto out;
 		}
 
-		if (!parent_root_id) {
+		if (!full_send && !parent_root_id) {
 			ret = find_good_parent(&send, root_id, &parent_root_id);
-			if (ret < 0)
-				parent_root_id = 0;
+			if (ret < 0) {
+				error("parent determination failed for %lld",
+					root_id);
+				goto out;
+			}
 		}
 
 		ret = is_subvol_ro(&send, subvol);
@@ -582,73 +655,78 @@ int cmd_send_start(int argc, char **argv)
 			goto out;
 		if (!ret) {
 			ret = -EINVAL;
-			fprintf(stderr, "ERROR: %s is not read-only.\n",
-					subvol);
+			error("subvolume %s is not read-only", subvol);
 			goto out;
 		}
 
-		ret = do_send(&send, root_id, parent_root_id);
+		if (new_end_cmd_semantic) {
+			/* require new kernel */
+			is_first_subvol = (i == optind);
+			is_last_subvol = (i == argc - 1);
+		} else {
+			/* be compatible to old and new kernel */
+			is_first_subvol = 1;
+			is_last_subvol = 1;
+		}
+		ret = do_send(&send, parent_root_id, is_first_subvol,
+			      is_last_subvol, subvol, send_flags);
 		if (ret < 0)
 			goto out;
 
-		/* done with this subvol, so add it to the clone sources */
-		add_clone_source(&send, root_id);
+		if (!full_send) {
+			/* done with this subvol, so add it to the clone sources */
+			ret = add_clone_source(&send, root_id);
+			if (ret < 0) {
+				error("cannot add clone source: %s", strerror(-ret));
+				goto out;
+			}
+		}
 
 		parent_root_id = 0;
-		free(subvol);
 	}
 
 	ret = 0;
 
 out:
+	free(subvol);
+	free(snapshot_parent);
+	free(send.clone_sources);
 	if (send.mnt_fd >= 0)
 		close(send.mnt_fd);
-	return ret;
+	free(send.root_path);
+	subvol_uuid_search_finit(&send.sus);
+	return !!ret;
 }
 
-static const char * const send_cmd_group_usage[] = {
-	"btrfs send <command> <args>",
+const char * const cmd_send_usage[] = {
+	"btrfs send [-ve] [-p <parent>] [-c <clone-src>] [-f <outfile>] <subvol> [<subvol>...]",
+	"Send the subvolume(s) to stdout.",
+	"Sends the subvolume(s) specified by <subvol> to stdout.",
+	"<subvol> should be read-only here.",
+	"By default, this will send the whole subvolume. To do an incremental",
+	"send, use '-p <parent>'. If you want to allow btrfs to clone from",
+	"any additional local snapshots, use '-c <clone-src>' (multiple times",
+	"where applicable). You must not specify clone sources unless you",
+	"guarantee that these snapshots are exactly in the same state on both",
+	"sides, the sender and the receiver. It is allowed to omit the",
+	"'-p <parent>' option when '-c <clone-src>' options are given, in",
+	"which case 'btrfs send' will determine a suitable parent among the",
+	"clone sources itself.",
+	"\n",
+	"-v               Enable verbose debug output. Each occurrence of",
+	"                 this option increases the verbose level more.",
+	"-e               If sending multiple subvols at once, use the new",
+	"                 format and omit the end-cmd between the subvols.",
+	"-p <parent>      Send an incremental stream from <parent> to",
+	"                 <subvol>.",
+	"-c <clone-src>   Use this snapshot as a clone source for an ",
+	"                 incremental send (multiple allowed)",
+	"-f <outfile>     Output is normally written to stdout. To write to",
+	"                 a file, use this option. An alternative would be to",
+	"                 use pipes.",
+	"--no-data        send in NO_FILE_DATA mode, Note: the output stream",
+	"                 does not contain any file data and thus cannot be used",
+	"                 to transfer changes. This mode is faster and useful to",
+	"                 show the differences in metadata.",
 	NULL
 };
-
-static const char * const cmd_send_usage[] = {
-	"btrfs send [-v] [-i <subvol>] [-p <parent>] <subvol>",
-	"Send the subvolume to stdout.",
-	"Sends the subvolume specified by <subvol> to stdout.",
-	"By default, this will send the whole subvolume. To do",
-	"an incremental send, one or multiple '-i <clone_source>'",
-	"arguments have to be specified. A 'clone source' is",
-	"a subvolume that is known to exist on the receiving",
-	"side in exactly the same state as on the sending side.\n",
-	"Normally, a good snapshot parent is searched automatically",
-	"in the list of 'clone sources'. To override this, use",
-	"'-p <parent>' to manually specify a snapshot parent.",
-	"A manually specified snapshot parent is also regarded",
-	"as 'clone source'.\n",
-	"-v               Enable verbose debug output. Each",
-	"                 occurrency of this option increases the",
-	"                 verbose level more.",
-	"-i <subvol>      Informs btrfs send that this subvolume,",
-	"                 can be taken as 'clone source'. This can",
-	"                 be used for incremental sends.",
-	"-p <subvol>      Disable automatic snaphot parent",
-	"                 determination and use <subvol> as parent.",
-	"                 This subvolume is also added to the list",
-	"                 of 'clone sources' (see -i).",
-	"-f <outfile>     Output is normally written to stdout.",
-	"                 To write to a file, use this option.",
-	"                 An alternative would be to use pipes.",
-	NULL
-};
-
-const struct cmd_group send_cmd_group = {
-	send_cmd_group_usage, NULL, {
-		{ "send", cmd_send_start, cmd_send_usage, NULL, 0 },
-		{ 0, 0, 0, 0, 0 },
-        },
-};
-
-int cmd_send(int argc, char **argv)
-{
-	return cmd_send_start(argc, argv);
-}