X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cmds-receive.c;h=e584cef02ffe831f3b22f093535a6a5c48160656;hb=926272e766c6cc23b58b674bcaf72f25b8d74aa5;hp=cbb16421b14963e9edd98f3c27ffa1d6214bb969;hpb=3f248d2431424e79445131514c5f558a14a2b9f2;p=platform%2Fupstream%2Fbtrfs-progs.git

diff --git a/cmds-receive.c b/cmds-receive.c
index cbb1642..e584cef 100644
--- a/cmds-receive.c
+++ b/cmds-receive.c
@@ -49,6 +49,8 @@
 #include "send.h"
 #include "send-stream.h"
 #include "send-utils.h"
+#include "send-dump.h"
+#include "help.h"
 
 static int g_verbose = 0;
 
@@ -86,7 +88,7 @@ struct btrfs_receive
 	int cached_capabilities_len;
 };
 
-static int finish_subvol(struct btrfs_receive *r)
+static int finish_subvol(struct btrfs_receive *rctx)
 {
 	int ret;
 	int subvol_fd = -1;
@@ -94,21 +96,21 @@ static int finish_subvol(struct btrfs_receive *r)
 	char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
 	u64 flags;
 
-	if (r->cur_subvol_path[0] == 0)
+	if (rctx->cur_subvol_path[0] == 0)
 		return 0;
 
-	subvol_fd = openat(r->mnt_fd, r->cur_subvol_path,
-			O_RDONLY | O_NOATIME);
+	subvol_fd = openat(rctx->mnt_fd, rctx->cur_subvol_path,
+			   O_RDONLY | O_NOATIME);
 	if (subvol_fd < 0) {
 		ret = -errno;
-		error("cannot open %s: %s\n",
-				r->cur_subvol_path, strerror(-ret));
+		error("cannot open %s: %s",
+				rctx->cur_subvol_path, strerror(-ret));
 		goto out;
 	}
 
 	memset(&rs_args, 0, sizeof(rs_args));
-	memcpy(rs_args.uuid, r->cur_subvol.received_uuid, BTRFS_UUID_SIZE);
-	rs_args.stransid = r->cur_subvol.stransid;
+	memcpy(rs_args.uuid, rctx->cur_subvol.received_uuid, BTRFS_UUID_SIZE);
+	rs_args.stransid = rctx->cur_subvol.stransid;
 
 	if (g_verbose >= 1) {
 		uuid_unparse((u8*)rs_args.uuid, uuid_str);
@@ -123,7 +125,7 @@ static int finish_subvol(struct btrfs_receive *r)
 				strerror(-ret));
 		goto out;
 	}
-	r->cur_subvol.rtransid = rs_args.rtransid;
+	rctx->cur_subvol.rtransid = rs_args.rtransid;
 
 	ret = ioctl(subvol_fd, BTRFS_IOC_SUBVOL_GETFLAGS, &flags);
 	if (ret < 0) {
@@ -146,8 +148,8 @@ static int finish_subvol(struct btrfs_receive *r)
 	ret = 0;
 
 out:
-	if (r->cur_subvol_path[0]) {
-		r->cur_subvol_path[0] = 0;
+	if (rctx->cur_subvol_path[0]) {
+		rctx->cur_subvol_path[0] = 0;
 	}
 	if (subvol_fd != -1)
 		close(subvol_fd);
@@ -158,28 +160,39 @@ static int process_subvol(const char *path, const u8 *uuid, u64 ctransid,
 			  void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	struct btrfs_ioctl_vol_args args_v1;
 	char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
 
-	ret = finish_subvol(r);
+	ret = finish_subvol(rctx);
 	if (ret < 0)
 		goto out;
 
-	BUG_ON(r->cur_subvol.path);
-	BUG_ON(r->cur_subvol_path[0]);
+	if (rctx->cur_subvol.path) {
+		error("subvol: another one already started, path ptr: %s",
+				rctx->cur_subvol.path);
+		ret = -EINVAL;
+		goto out;
+	}
+	if (rctx->cur_subvol_path[0]) {
+		error("subvol: another one already started, path buf: %s",
+				rctx->cur_subvol.path);
+		ret = -EINVAL;
+		goto out;
+	}
 
-	if (*r->dest_dir_path == 0) {
-		strncpy_null(r->cur_subvol_path, path);
+	if (*rctx->dest_dir_path == 0) {
+		strncpy_null(rctx->cur_subvol_path, path);
 	} else {
-		ret = path_cat_out(r->cur_subvol_path, r->dest_dir_path, path);
+		ret = path_cat_out(rctx->cur_subvol_path, rctx->dest_dir_path,
+				   path);
 		if (ret < 0) {
-			error("subvol: path invalid: %s\n", path);
+			error("subvol: path invalid: %s", path);
 			goto out;
 		}
 	}
-	ret = path_cat3_out(r->full_subvol_path, r->root_path,
-			r->dest_dir_path, path);
+	ret = path_cat3_out(rctx->full_subvol_path, rctx->root_path,
+			    rctx->dest_dir_path, path);
 	if (ret < 0) {
 		error("subvol: path invalid: %s", path);
 		goto out;
@@ -187,19 +200,19 @@ static int process_subvol(const char *path, const u8 *uuid, u64 ctransid,
 
 	fprintf(stderr, "At subvol %s\n", path);
 
-	memcpy(r->cur_subvol.received_uuid, uuid, BTRFS_UUID_SIZE);
-	r->cur_subvol.stransid = ctransid;
+	memcpy(rctx->cur_subvol.received_uuid, uuid, BTRFS_UUID_SIZE);
+	rctx->cur_subvol.stransid = ctransid;
 
 	if (g_verbose) {
-		uuid_unparse((u8*)r->cur_subvol.received_uuid, uuid_str);
+		uuid_unparse((u8*)rctx->cur_subvol.received_uuid, uuid_str);
 		fprintf(stderr, "receiving subvol %s uuid=%s, stransid=%llu\n",
 				path, uuid_str,
-				r->cur_subvol.stransid);
+				rctx->cur_subvol.stransid);
 	}
 
 	memset(&args_v1, 0, sizeof(args_v1));
 	strncpy_null(args_v1.name, path);
-	ret = ioctl(r->dest_dir_fd, BTRFS_IOC_SUBVOL_CREATE, &args_v1);
+	ret = ioctl(rctx->dest_dir_fd, BTRFS_IOC_SUBVOL_CREATE, &args_v1);
 	if (ret < 0) {
 		ret = -errno;
 		error("creating subvolume %s failed: %s", path, strerror(-ret));
@@ -215,29 +228,40 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
 			    void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
 	struct btrfs_ioctl_vol_args_v2 args_v2;
 	struct subvol_info *parent_subvol = NULL;
 
-	ret = finish_subvol(r);
+	ret = finish_subvol(rctx);
 	if (ret < 0)
 		goto out;
 
-	BUG_ON(r->cur_subvol.path);
-	BUG_ON(r->cur_subvol_path[0]);
+	if (rctx->cur_subvol.path) {
+		error("snapshot: another one already started, path ptr: %s",
+				rctx->cur_subvol.path);
+		ret = -EINVAL;
+		goto out;
+	}
+	if (rctx->cur_subvol_path[0]) {
+		error("snapshot: another one already started, path buf: %s",
+				rctx->cur_subvol.path);
+		ret = -EINVAL;
+		goto out;
+	}
 
-	if (*r->dest_dir_path == 0) {
-		strncpy_null(r->cur_subvol_path, path);
+	if (*rctx->dest_dir_path == 0) {
+		strncpy_null(rctx->cur_subvol_path, path);
 	} else {
-		ret = path_cat_out(r->cur_subvol_path, r->dest_dir_path, path);
+		ret = path_cat_out(rctx->cur_subvol_path, rctx->dest_dir_path,
+				   path);
 		if (ret < 0) {
 			error("snapshot: path invalid: %s", path);
 			goto out;
 		}
 	}
-	ret = path_cat3_out(r->full_subvol_path, r->root_path,
-			r->dest_dir_path, path);
+	ret = path_cat3_out(rctx->full_subvol_path, rctx->root_path,
+			    rctx->dest_dir_path, path);
 	if (ret < 0) {
 		error("snapshot: path invalid: %s", path);
 		goto out;
@@ -245,14 +269,14 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
 
 	fprintf(stdout, "At snapshot %s\n", path);
 
-	memcpy(r->cur_subvol.received_uuid, uuid, BTRFS_UUID_SIZE);
-	r->cur_subvol.stransid = ctransid;
+	memcpy(rctx->cur_subvol.received_uuid, uuid, BTRFS_UUID_SIZE);
+	rctx->cur_subvol.stransid = ctransid;
 
 	if (g_verbose) {
-		uuid_unparse((u8*)r->cur_subvol.received_uuid, uuid_str);
+		uuid_unparse((u8*)rctx->cur_subvol.received_uuid, uuid_str);
 		fprintf(stderr, "receiving snapshot %s uuid=%s, "
 				"ctransid=%llu ", path, uuid_str,
-				r->cur_subvol.stransid);
+				rctx->cur_subvol.stransid);
 		uuid_unparse(parent_uuid, uuid_str);
 		fprintf(stderr, "parent_uuid=%s, parent_ctransid=%llu\n",
 				uuid_str, parent_ctransid);
@@ -261,14 +285,19 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
 	memset(&args_v2, 0, sizeof(args_v2));
 	strncpy_null(args_v2.name, path);
 
-	parent_subvol = subvol_uuid_search(&r->sus, 0, parent_uuid,
-			parent_ctransid, NULL, subvol_search_by_received_uuid);
-	if (!parent_subvol) {
-		parent_subvol = subvol_uuid_search(&r->sus, 0, parent_uuid,
-				parent_ctransid, NULL, subvol_search_by_uuid);
+	parent_subvol = subvol_uuid_search(&rctx->sus, 0, parent_uuid,
+					   parent_ctransid, NULL,
+					   subvol_search_by_received_uuid);
+	if (IS_ERR_OR_NULL(parent_subvol)) {
+		parent_subvol = subvol_uuid_search(&rctx->sus, 0, parent_uuid,
+						   parent_ctransid, NULL,
+						   subvol_search_by_uuid);
 	}
-	if (!parent_subvol) {
-		ret = -ENOENT;
+	if (IS_ERR_OR_NULL(parent_subvol)) {
+		if (!parent_subvol)
+			ret = -ENOENT;
+		else
+			ret = PTR_ERR(parent_subvol);
 		error("cannot find parent subvolume");
 		goto out;
 	}
@@ -278,16 +307,16 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
 	 * subvolume under the root subvolume, so try and adjust the path to be
 	 * relative to our root path.
 	 */
-	if (r->full_root_path) {
+	if (rctx->full_root_path) {
 		size_t root_len;
 		size_t sub_len;
 
-		root_len = strlen(r->full_root_path);
+		root_len = strlen(rctx->full_root_path);
 		sub_len = strlen(parent_subvol->path);
 
 		/* First make sure the parent subvol is actually in our path */
-		if (sub_len < root_len ||
-		    strstr(parent_subvol->path, r->full_root_path) == NULL) {
+		if (strstr(parent_subvol->path, rctx->full_root_path) != parent_subvol->path ||
+		    (sub_len > root_len && parent_subvol->path[root_len] != '/')) {
 			error(
 		"parent subvol is not reachable from inside the root subvol");
 			ret = -ENOENT;
@@ -295,7 +324,7 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
 		}
 
 		if (sub_len == root_len) {
-			parent_subvol->path[0] = '/';
+			parent_subvol->path[0] = '.';
 			parent_subvol->path[1] = '\0';
 		} else {
 			/*
@@ -324,10 +353,10 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
 	}*/
 
 	if (*parent_subvol->path == 0)
-		args_v2.fd = dup(r->mnt_fd);
+		args_v2.fd = dup(rctx->mnt_fd);
 	else
-		args_v2.fd = openat(r->mnt_fd, parent_subvol->path,
-				O_RDONLY | O_NOATIME);
+		args_v2.fd = openat(rctx->mnt_fd, parent_subvol->path,
+				    O_RDONLY | O_NOATIME);
 	if (args_v2.fd < 0) {
 		ret = -errno;
 		if (errno != ENOENT)
@@ -342,7 +371,7 @@ static int process_snapshot(const char *path, const u8 *uuid, u64 ctransid,
 		goto out;
 	}
 
-	ret = ioctl(r->dest_dir_fd, BTRFS_IOC_SNAP_CREATE_V2, &args_v2);
+	ret = ioctl(rctx->dest_dir_fd, BTRFS_IOC_SNAP_CREATE_V2, &args_v2);
 	close(args_v2.fd);
 	if (ret < 0) {
 		ret = -errno;
@@ -362,10 +391,10 @@ out:
 static int process_mkfile(const char *path, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("mkfile: path invalid: %s", path);
 		goto out;
@@ -390,10 +419,10 @@ out:
 static int process_mkdir(const char *path, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("mkdir: path invalid: %s", path);
 		goto out;
@@ -415,10 +444,10 @@ out:
 static int process_mknod(const char *path, u64 mode, u64 dev, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("mknod: path invalid: %s", path);
 		goto out;
@@ -441,10 +470,10 @@ out:
 static int process_mkfifo(const char *path, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("mkfifo: path invalid: %s", path);
 		goto out;
@@ -466,10 +495,10 @@ out:
 static int process_mksock(const char *path, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("mksock: path invalid: %s", path);
 		goto out;
@@ -491,10 +520,10 @@ out:
 static int process_symlink(const char *path, const char *lnk, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("symlink: path invalid: %s", path);
 		goto out;
@@ -517,17 +546,17 @@ out:
 static int process_rename(const char *from, const char *to, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_from[PATH_MAX];
 	char full_to[PATH_MAX];
 
-	ret = path_cat_out(full_from, r->full_subvol_path, from);
+	ret = path_cat_out(full_from, rctx->full_subvol_path, from);
 	if (ret < 0) {
 		error("rename: source path invalid: %s", from);
 		goto out;
 	}
 
-	ret = path_cat_out(full_to, r->full_subvol_path, to);
+	ret = path_cat_out(full_to, rctx->full_subvol_path, to);
 	if (ret < 0) {
 		error("rename: target path invalid: %s", to);
 		goto out;
@@ -550,17 +579,17 @@ out:
 static int process_link(const char *path, const char *lnk, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 	char full_link_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("link: source path invalid: %s", full_path);
 		goto out;
 	}
 
-	ret = path_cat_out(full_link_path, r->full_subvol_path, lnk);
+	ret = path_cat_out(full_link_path, rctx->full_subvol_path, lnk);
 	if (ret < 0) {
 		error("link: target path invalid: %s", full_link_path);
 		goto out;
@@ -583,10 +612,10 @@ out:
 static int process_unlink(const char *path, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("unlink: path invalid: %s", path);
 		goto out;
@@ -608,10 +637,10 @@ out:
 static int process_rmdir(const char *path, void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("rmdir: path invalid: %s", path);
 		goto out;
@@ -630,64 +659,64 @@ out:
 	return ret;
 }
 
-static int open_inode_for_write(struct btrfs_receive *r, const char *path)
+static int open_inode_for_write(struct btrfs_receive *rctx, const char *path)
 {
 	int ret = 0;
 
-	if (r->write_fd != -1) {
-		if (strcmp(r->write_path, path) == 0)
+	if (rctx->write_fd != -1) {
+		if (strcmp(rctx->write_path, path) == 0)
 			goto out;
-		close(r->write_fd);
-		r->write_fd = -1;
+		close(rctx->write_fd);
+		rctx->write_fd = -1;
 	}
 
-	r->write_fd = open(path, O_RDWR);
-	if (r->write_fd < 0) {
+	rctx->write_fd = open(path, O_RDWR);
+	if (rctx->write_fd < 0) {
 		ret = -errno;
-		error("cannont open %s: %s", path, strerror(-ret));
+		error("cannot open %s: %s", path, strerror(-ret));
 		goto out;
 	}
-	strncpy_null(r->write_path, path);
+	strncpy_null(rctx->write_path, path);
 
 out:
 	return ret;
 }
 
-static void close_inode_for_write(struct btrfs_receive *r)
+static void close_inode_for_write(struct btrfs_receive *rctx)
 {
-	if(r->write_fd == -1)
+	if(rctx->write_fd == -1)
 		return;
 
-	close(r->write_fd);
-	r->write_fd = -1;
-	r->write_path[0] = 0;
+	close(rctx->write_fd);
+	rctx->write_fd = -1;
+	rctx->write_path[0] = 0;
 }
 
 static int process_write(const char *path, const void *data, u64 offset,
 			 u64 len, void *user)
 {
 	int ret = 0;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 	u64 pos = 0;
 	int w;
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("write: path invalid: %s", path);
 		goto out;
 	}
 
-	ret = open_inode_for_write(r, full_path);
+	ret = open_inode_for_write(rctx, full_path);
 	if (ret < 0)
 		goto out;
 
 	while (pos < len) {
-		w = pwrite(r->write_fd, (char*)data + pos, len - pos,
+		w = pwrite(rctx->write_fd, (char*)data + pos, len - pos,
 				offset + pos);
 		if (w < 0) {
 			ret = -errno;
-			error("writing to %s failed: %s\n",
+			error("writing to %s failed: %s",
 					path, strerror(-ret));
 			goto out;
 		}
@@ -704,7 +733,7 @@ static int process_clone(const char *path, u64 offset, u64 len,
 			 void *user)
 {
 	int ret;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	struct btrfs_ioctl_clone_range_args clone_args;
 	struct subvol_info *si = NULL;
 	char full_path[PATH_MAX];
@@ -712,25 +741,29 @@ static int process_clone(const char *path, u64 offset, u64 len,
 	char full_clone_path[PATH_MAX];
 	int clone_fd = -1;
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("clone: source path invalid: %s", path);
 		goto out;
 	}
 
-	ret = open_inode_for_write(r, full_path);
+	ret = open_inode_for_write(rctx, full_path);
 	if (ret < 0)
 		goto out;
 
-	si = subvol_uuid_search(&r->sus, 0, clone_uuid, clone_ctransid, NULL,
-			subvol_search_by_received_uuid);
-	if (!si) {
-		if (memcmp(clone_uuid, r->cur_subvol.received_uuid,
+	si = subvol_uuid_search(&rctx->sus, 0, clone_uuid, clone_ctransid,
+				NULL,
+				subvol_search_by_received_uuid);
+	if (IS_ERR_OR_NULL(si)) {
+		if (memcmp(clone_uuid, rctx->cur_subvol.received_uuid,
 				BTRFS_UUID_SIZE) == 0) {
 			/* TODO check generation of extent */
-			subvol_path = strdup(r->cur_subvol_path);
+			subvol_path = strdup(rctx->cur_subvol_path);
 		} else {
-			ret = -ENOENT;
+			if (!si)
+				ret = -ENOENT;
+			else
+				ret = PTR_ERR(si);
 			error("clone: did not find source subvol");
 			goto out;
 		}
@@ -750,7 +783,24 @@ static int process_clone(const char *path, u64 offset, u64 len,
 						r->subvol_parent_name);
 			}
 		}*/
-		subvol_path = strdup(si->path);
+
+		/* strip the subvolume that we are receiving to from the start of subvol_path */
+		if (rctx->full_root_path) {
+			size_t root_len = strlen(rctx->full_root_path);
+			size_t sub_len = strlen(si->path);
+
+			if (sub_len > root_len &&
+			    strstr(si->path, rctx->full_root_path) == si->path &&
+			    si->path[root_len] == '/') {
+				subvol_path = strdup(si->path + root_len + 1);
+			} else {
+				error("clone: source subvol path %s unreachable from %s",
+					si->path, rctx->full_root_path);
+				goto out;
+			}
+		} else {
+			subvol_path = strdup(si->path);
+		}
 	}
 
 	ret = path_cat_out(full_clone_path, subvol_path, clone_path);
@@ -759,7 +809,7 @@ static int process_clone(const char *path, u64 offset, u64 len,
 		goto out;
 	}
 
-	clone_fd = openat(r->mnt_fd, full_clone_path, O_RDONLY | O_NOATIME);
+	clone_fd = openat(rctx->mnt_fd, full_clone_path, O_RDONLY | O_NOATIME);
 	if (clone_fd < 0) {
 		ret = -errno;
 		error("cannot open %s: %s", full_clone_path, strerror(-ret));
@@ -770,10 +820,10 @@ static int process_clone(const char *path, u64 offset, u64 len,
 	clone_args.src_offset = clone_offset;
 	clone_args.src_length = len;
 	clone_args.dest_offset = offset;
-	ret = ioctl(r->write_fd, BTRFS_IOC_CLONE_RANGE, &clone_args);
+	ret = ioctl(rctx->write_fd, BTRFS_IOC_CLONE_RANGE, &clone_args);
 	if (ret < 0) {
 		ret = -errno;
-		error("failed to clone extents to %s\n%s\n",
+		error("failed to clone extents to %s\n%s",
 				path, strerror(-ret));
 		goto out;
 	}
@@ -794,10 +844,10 @@ static int process_set_xattr(const char *path, const char *name,
 			     const void *data, int len, void *user)
 {
 	int ret = 0;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("set_xattr: path invalid: %s", path);
 		goto out;
@@ -806,17 +856,17 @@ static int process_set_xattr(const char *path, const char *name,
 	if (strcmp("security.capability", name) == 0) {
 		if (g_verbose >= 3)
 			fprintf(stderr, "set_xattr: cache capabilities\n");
-		if (r->cached_capabilities_len)
+		if (rctx->cached_capabilities_len)
 			warning("capabilities set multiple times per file: %s",
 				full_path);
-		if (len > sizeof(r->cached_capabilities)) {
+		if (len > sizeof(rctx->cached_capabilities)) {
 			error("capabilities encoded to %d bytes, buffer too small",
 				len);
 			ret = -E2BIG;
 			goto out;
 		}
-		r->cached_capabilities_len = len;
-		memcpy(r->cached_capabilities, data, len);
+		rctx->cached_capabilities_len = len;
+		memcpy(rctx->cached_capabilities, data, len);
 	}
 
 	if (g_verbose >= 2) {
@@ -840,10 +890,10 @@ out:
 static int process_remove_xattr(const char *path, const char *name, void *user)
 {
 	int ret = 0;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("remove_xattr: path invalid: %s", path);
 		goto out;
@@ -869,10 +919,10 @@ out:
 static int process_truncate(const char *path, u64 size, void *user)
 {
 	int ret = 0;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("truncate: path invalid: %s", path);
 		goto out;
@@ -895,10 +945,10 @@ out:
 static int process_chmod(const char *path, u64 mode, void *user)
 {
 	int ret = 0;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("chmod: path invalid: %s", path);
 		goto out;
@@ -921,10 +971,10 @@ out:
 static int process_chown(const char *path, u64 uid, u64 gid, void *user)
 {
 	int ret = 0;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("chown: path invalid: %s", path);
 		goto out;
@@ -941,15 +991,15 @@ static int process_chown(const char *path, u64 uid, u64 gid, void *user)
 		goto out;
 	}
 
-	if (r->cached_capabilities_len) {
+	if (rctx->cached_capabilities_len) {
 		if (g_verbose >= 2)
 			fprintf(stderr, "chown: restore capabilities\n");
 		ret = lsetxattr(full_path, "security.capability",
-				r->cached_capabilities,
-				r->cached_capabilities_len, 0);
-		memset(r->cached_capabilities, 0,
-				sizeof(r->cached_capabilities));
-		r->cached_capabilities_len = 0;
+				rctx->cached_capabilities,
+				rctx->cached_capabilities_len, 0);
+		memset(rctx->cached_capabilities, 0,
+				sizeof(rctx->cached_capabilities));
+		rctx->cached_capabilities_len = 0;
 		if (ret < 0) {
 			ret = -errno;
 			error("restoring capabilities %s: %s",
@@ -967,11 +1017,11 @@ static int process_utimes(const char *path, struct timespec *at,
 			  void *user)
 {
 	int ret = 0;
-	struct btrfs_receive *r = user;
+	struct btrfs_receive *rctx = user;
 	char full_path[PATH_MAX];
 	struct timespec tv[2];
 
-	ret = path_cat_out(full_path, r->full_subvol_path, path);
+	ret = path_cat_out(full_path, rctx->full_subvol_path, path);
 	if (ret < 0) {
 		error("utimes: path invalid: %s", path);
 		goto out;
@@ -1033,7 +1083,7 @@ static struct btrfs_send_ops send_ops = {
 	.update_extent = process_update_extent,
 };
 
-static int do_receive(struct btrfs_receive *r, const char *tomnt,
+static int do_receive(struct btrfs_receive *rctx, const char *tomnt,
 		      char *realmnt, int r_fd, u64 max_errors)
 {
 	u64 subvol_id;
@@ -1041,6 +1091,7 @@ static int do_receive(struct btrfs_receive *r, const char *tomnt,
 	char *dest_dir_full_path;
 	char root_subvol_path[PATH_MAX];
 	int end = 0;
+	int iterations = 0;
 
 	dest_dir_full_path = realpath(tomnt, NULL);
 	if (!dest_dir_full_path) {
@@ -1048,8 +1099,8 @@ static int do_receive(struct btrfs_receive *r, const char *tomnt,
 		error("realpath(%s) failed: %s", tomnt, strerror(-ret));
 		goto out;
 	}
-	r->dest_dir_fd = open(dest_dir_full_path, O_RDONLY | O_NOATIME);
-	if (r->dest_dir_fd < 0) {
+	rctx->dest_dir_fd = open(dest_dir_full_path, O_RDONLY | O_NOATIME);
+	if (rctx->dest_dir_fd < 0) {
 		ret = -errno;
 		error("cannot open destination directory %s: %s",
 			dest_dir_full_path, strerror(-ret));
@@ -1057,9 +1108,9 @@ static int do_receive(struct btrfs_receive *r, const char *tomnt,
 	}
 
 	if (realmnt[0]) {
-		r->root_path = realmnt;
+		rctx->root_path = realmnt;
 	} else {
-		ret = find_mount_root(dest_dir_full_path, &r->root_path);
+		ret = find_mount_root(dest_dir_full_path, &rctx->root_path);
 		if (ret < 0) {
 			error("failed to determine mount point for %s: %s",
 				dest_dir_full_path, strerror(-ret));
@@ -1073,10 +1124,10 @@ static int do_receive(struct btrfs_receive *r, const char *tomnt,
 			goto out;
 		}
 	}
-	r->mnt_fd = open(r->root_path, O_RDONLY | O_NOATIME);
-	if (r->mnt_fd < 0) {
+	rctx->mnt_fd = open(rctx->root_path, O_RDONLY | O_NOATIME);
+	if (rctx->mnt_fd < 0) {
 		ret = -errno;
-		error("cannot open %s: %s", r->root_path, strerror(-ret));
+		error("cannot open %s: %s", rctx->root_path, strerror(-ret));
 		goto out;
 	}
 
@@ -1085,15 +1136,12 @@ static int do_receive(struct btrfs_receive *r, const char *tomnt,
 	 * subvolume we're sitting in so that we can adjust the paths of any
 	 * subvols we want to receive in.
 	 */
-	ret = btrfs_list_get_path_rootid(r->mnt_fd, &subvol_id);
-	if (ret) {
-		error("cannot resolve our subvolid: %d",
-			ret);
+	ret = btrfs_list_get_path_rootid(rctx->mnt_fd, &subvol_id);
+	if (ret)
 		goto out;
-	}
 
 	root_subvol_path[0] = 0;
-	ret = btrfs_subvolid_resolve(r->mnt_fd, root_subvol_path,
+	ret = btrfs_subvolid_resolve(rctx->mnt_fd, root_subvol_path,
 				     PATH_MAX, subvol_id);
 	if (ret) {
 		error("cannot resolve our subvol path");
@@ -1105,9 +1153,9 @@ static int do_receive(struct btrfs_receive *r, const char *tomnt,
 	 * actually set full_root_path.
 	 */
 	if (*root_subvol_path)
-		r->full_root_path = root_subvol_path;
+		rctx->full_root_path = root_subvol_path;
 
-	if (r->dest_dir_chroot) {
+	if (rctx->dest_dir_chroot) {
 		if (chroot(dest_dir_full_path)) {
 			ret = -errno;
 			error("failed to chroot to %s: %s",
@@ -1121,66 +1169,80 @@ static int do_receive(struct btrfs_receive *r, const char *tomnt,
 			goto out;
 		}
 		fprintf(stderr, "Chroot to %s\n", dest_dir_full_path);
-		r->root_path = strdup("/");
-		r->dest_dir_path = r->root_path;
+		rctx->root_path = strdup("/");
+		rctx->dest_dir_path = rctx->root_path;
 	} else {
 		/*
 		 * find_mount_root returns a root_path that is a subpath of
 		 * dest_dir_full_path. Now get the other part of root_path,
 		 * which is the destination dir relative to root_path.
 		 */
-		r->dest_dir_path = dest_dir_full_path + strlen(r->root_path);
-		while (r->dest_dir_path[0] == '/')
-			r->dest_dir_path++;
+		rctx->dest_dir_path = dest_dir_full_path + strlen(rctx->root_path);
+		while (rctx->dest_dir_path[0] == '/')
+			rctx->dest_dir_path++;
 	}
 
-	ret = subvol_uuid_search_init(r->mnt_fd, &r->sus);
+	ret = subvol_uuid_search_init(rctx->mnt_fd, &rctx->sus);
 	if (ret < 0)
 		goto out;
 
 	while (!end) {
-		if (r->cached_capabilities_len) {
+		if (rctx->cached_capabilities_len) {
 			if (g_verbose >= 3)
 				fprintf(stderr, "clear cached capabilities\n");
-			memset(r->cached_capabilities, 0,
-					sizeof(r->cached_capabilities));
-			r->cached_capabilities_len = 0;
+			memset(rctx->cached_capabilities, 0,
+					sizeof(rctx->cached_capabilities));
+			rctx->cached_capabilities_len = 0;
 		}
 
-		ret = btrfs_read_and_process_send_stream(r_fd, &send_ops, r,
-							 r->honor_end_cmd,
+		ret = btrfs_read_and_process_send_stream(r_fd, &send_ops,
+							 rctx,
+							 rctx->honor_end_cmd,
 							 max_errors);
-		if (ret < 0)
-			goto out;
-		if (ret)
+		if (ret < 0) {
+			if (ret != -ENODATA)
+				goto out;
+
+			/* Empty stream is invalid */
+			if (iterations == 0) {
+				error("empty stream is not considered valid");
+				ret = -EINVAL;
+				goto out;
+			}
+
+			ret = 1;
+		}
+		if (ret > 0)
 			end = 1;
 
-		close_inode_for_write(r);
-		ret = finish_subvol(r);
+		close_inode_for_write(rctx);
+		ret = finish_subvol(rctx);
 		if (ret < 0)
 			goto out;
+
+		iterations++;
 	}
 	ret = 0;
 
 out:
-	if (r->write_fd != -1) {
-		close(r->write_fd);
-		r->write_fd = -1;
+	if (rctx->write_fd != -1) {
+		close(rctx->write_fd);
+		rctx->write_fd = -1;
 	}
 
-	if (r->root_path != realmnt)
-		free(r->root_path);
-	r->root_path = NULL;
-	r->dest_dir_path = NULL;
+	if (rctx->root_path != realmnt)
+		free(rctx->root_path);
+	rctx->root_path = NULL;
+	rctx->dest_dir_path = NULL;
 	free(dest_dir_full_path);
-	subvol_uuid_search_finit(&r->sus);
-	if (r->mnt_fd != -1) {
-		close(r->mnt_fd);
-		r->mnt_fd = -1;
+	subvol_uuid_search_finit(&rctx->sus);
+	if (rctx->mnt_fd != -1) {
+		close(rctx->mnt_fd);
+		rctx->mnt_fd = -1;
 	}
-	if (r->dest_dir_fd != -1) {
-		close(r->dest_dir_fd);
-		r->dest_dir_fd = -1;
+	if (rctx->dest_dir_fd != -1) {
+		close(rctx->dest_dir_fd);
+		rctx->dest_dir_fd = -1;
 	}
 
 	return ret;
@@ -1191,28 +1253,31 @@ int cmd_receive(int argc, char **argv)
 	char *tomnt = NULL;
 	char fromfile[PATH_MAX];
 	char realmnt[PATH_MAX];
-	struct btrfs_receive r;
+	struct btrfs_receive rctx;
 	int receive_fd = fileno(stdin);
 	u64 max_errors = 1;
+	int dump = 0;
 	int ret = 0;
 
-	memset(&r, 0, sizeof(r));
-	r.mnt_fd = -1;
-	r.write_fd = -1;
-	r.dest_dir_fd = -1;
-	r.dest_dir_chroot = 0;
+	memset(&rctx, 0, sizeof(rctx));
+	rctx.mnt_fd = -1;
+	rctx.write_fd = -1;
+	rctx.dest_dir_fd = -1;
+	rctx.dest_dir_chroot = 0;
 	realmnt[0] = 0;
 	fromfile[0] = 0;
 
 	while (1) {
 		int c;
+		enum { GETOPT_VAL_DUMP = 257 };
 		static const struct option long_opts[] = {
 			{ "max-errors", required_argument, NULL, 'E' },
 			{ "chroot", no_argument, NULL, 'C' },
+			{ "dump", no_argument, NULL, GETOPT_VAL_DUMP },
 			{ NULL, 0, NULL, 0 }
 		};
 
-		c = getopt_long(argc, argv, "Cevf:m:", long_opts, NULL);
+		c = getopt_long(argc, argv, "Cevf:m:E:", long_opts, NULL);
 		if (c < 0)
 			break;
 
@@ -1229,10 +1294,10 @@ int cmd_receive(int argc, char **argv)
 			}
 			break;
 		case 'e':
-			r.honor_end_cmd = 1;
+			rctx.honor_end_cmd = 1;
 			break;
 		case 'C':
-			r.dest_dir_chroot = 1;
+			rctx.dest_dir_chroot = 1;
 			break;
 		case 'E':
 			max_errors = arg_strtou64(optarg);
@@ -1245,6 +1310,9 @@ int cmd_receive(int argc, char **argv)
 				goto out;
 			}
 			break;
+		case GETOPT_VAL_DUMP:
+			dump = 1;
+			break;
 		case '?':
 		default:
 			error("receive args invalid");
@@ -1252,7 +1320,9 @@ int cmd_receive(int argc, char **argv)
 		}
 	}
 
-	if (check_argc_exact(argc - optind, 1))
+	if (dump && check_argc_exact(argc - optind, 0))
+		usage(cmd_receive_usage);
+	if (!dump && check_argc_exact(argc - optind, 1))
 		usage(cmd_receive_usage);
 
 	tomnt = argv[optind];
@@ -1265,42 +1335,56 @@ int cmd_receive(int argc, char **argv)
 		}
 	}
 
-	ret = do_receive(&r, tomnt, realmnt, receive_fd, max_errors);
+	if (dump) {
+		struct btrfs_dump_send_args dump_args;
+
+		dump_args.root_path[0] = '.';
+		dump_args.root_path[1] = '\0';
+		dump_args.full_subvol_path[0] = '.';
+		dump_args.full_subvol_path[1] = '\0';
+		ret = btrfs_read_and_process_send_stream(receive_fd,
+				&btrfs_print_send_ops, &dump_args, 0, 0);
+		if (ret < 0)
+			error("failed to dump the send stream: %s",
+			      strerror(-ret));
+	} else {
+		ret = do_receive(&rctx, tomnt, realmnt, receive_fd, max_errors);
+	}
+
 	if (receive_fd != fileno(stdin))
 		close(receive_fd);
-
 out:
 
 	return !!ret;
 }
 
 const char * const cmd_receive_usage[] = {
-	"btrfs receive [-ve] [-f <infile>] [--max-errors <N>] <mount>",
-	"Receive subvolumes from stdin.",
+	"btrfs receive [options] <mount>\n"
+	"btrfs receive --dump [options]",
+	"Receive subvolumes from a stream",
 	"Receives one or more subvolumes that were previously",
 	"sent with btrfs send. The received subvolumes are stored",
-	"into <mount>.",
-	"btrfs receive will fail in case a receiving subvolume",
+	"into MOUNT.",
+	"The receive will fail in case the receiving subvolume",
 	"already exists. It will also fail in case a previously",
-	"received subvolume was changed after it was received.",
+	"received subvolume has been changed after it was received.",
 	"After receiving a subvolume, it is immediately set to",
-	"read only.\n",
-	"-v               Enable verbose debug output. Each",
-	"                 occurrence of this option increases the",
-	"                 verbose level more.",
-	"-f <infile>      By default, btrfs receive uses stdin",
-	"                 to receive the subvolumes. Use this",
-	"                 option to specify a file to use instead.",
-	"-e               Terminate after receiving an <end cmd>",
-	"                 in the data stream. Without this option,",
-	"                 the receiver terminates only if an error",
-	"                 is recognized or on EOF.",
+	"read-only.",
+	"",
+	"-v               increase verbosity about performed actions",
+	"-f FILE          read the stream from FILE instead of stdin",
+	"-e               terminate after receiving an <end cmd> marker in the stream.",
+	"                 Without this option the receiver side terminates only in case",
+	"                 of an error on end of file.",
 	"-C|--chroot      confine the process to <mount> using chroot",
-	"--max-errors <N> Terminate as soon as N errors happened while",
-	"                 processing commands from the send stream.",
+	"-E|--max-errors NERR",
+	"                 terminate as soon as NERR errors occur while",
+	"                 stream processing commands from the stream.",
 	"                 Default value is 1. A value of 0 means no limit.",
-	"-m <mountpoint>  The root mount point of the destination fs.",
-	"                 If you do not have /proc use this to tell us where ",
+	"-m ROOTMOUNT     the root mount point of the destination filesystem.",
+	"                 If /proc is not accessible, use this to tell us where",
 	"                 this file system is mounted.",
+	"--dump           dump stream metadata, one line per operation,",
+	"                 does not require the MOUNT parameter",
 	NULL
 };