#include <sys/ioctl.h>
#include <libgen.h>
#include <mntent.h>
+#include <assert.h>
#include <uuid/uuid.h>
#include "ioctl.h"
#include "commands.h"
#include "list.h"
+#include "utils.h"
#include "send.h"
#include "send-utils.h"
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;
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;
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);
+ assert(parent2);
tmp = parent2->ctransid - parent->ctransid;
if (tmp < 0)
tmp *= -1;
if (tmp < best_diff) {
+ 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;
}
}
ret = 0;
out:
+ if (parent) {
+ free(parent->path);
+ free(parent);
+ }
+ if (best_parent) {
+ free(best_parent->path);
+ free(best_parent);
+ }
return ret;
}
return ERR_PTR(ret);
}
-static int do_send(struct btrfs_send *send, u64 root_id, u64 parent_root_id)
+static int do_send(struct btrfs_send *send, u64 parent_root_id,
+ int is_first_subvol, int is_last_subvol, char *subvol)
{
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,
+ fprintf(stderr, "ERROR: open %s failed. %s\n", subvol,
strerror(-ret));
goto out;
}
- ret = pthread_attr_init(&t_attr);
-
ret = pipe(pipefd);
if (ret < 0) {
ret = -errno;
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;
io_send.clone_sources = (__u64*)send->clone_sources;
io_send.clone_sources_count = send->clone_sources_count;
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) {
ret = -errno;
fprintf(stderr, "ERROR: send ioctl failed with %d: %s\n", 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)
fprintf(stderr, "joining genl thread\n");
close(pipefd[1]);
- pipefd[1] = 0;
+ pipefd[1] = -1;
ret = pthread_join(t_read, &t_err);
if (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)
+char *get_subvol_name(char *mnt, char *full_path)
{
- int len = strlen(s->root_path);
+ int len = strlen(mnt);
if (!len)
return full_path;
- if (s->root_path[len - 1] != '/')
+ if (mnt[len - 1] != '/')
len += 1;
return full_path + len;
return ret;
}
-int cmd_send_start(int argc, char **argv)
+int cmd_send(int argc, char **argv)
{
char *subvol = NULL;
int c;
u64 root_id;
u64 parent_root_id = 0;
int full_send = 1;
+ int new_end_cmd_semantic = 0;
memset(&send, 0, sizeof(send));
send.dump_fd = fileno(stdout);
- while ((c = getopt(argc, argv, "vc:f:i:p:")) != -1) {
+ while ((c = getopt(argc, argv, "vec:f:i:p:")) != -1) {
switch (c) {
case 'v':
g_verbose++;
break;
+ case 'e':
+ new_end_cmd_semantic = 1;
+ break;
case 'c':
subvol = realpath(optarg, NULL);
if (!subvol) {
if (ret < 0)
goto out;
- ret = get_root_id(&send, get_subvol_name(&send, subvol),
+ ret = get_root_id(&send, get_subvol_name(send.root_path, subvol),
&root_id);
if (ret < 0) {
fprintf(stderr, "ERROR: could not resolve "
"root_id for %s\n", subvol);
goto out;
}
+
+ ret = is_subvol_ro(&send, subvol);
+ if (ret < 0)
+ goto out;
+ if (!ret) {
+ ret = -EINVAL;
+ fprintf(stderr,
+ "ERROR: cloned subvol %s is not read-only.\n",
+ subvol);
+ goto out;
+ }
+
add_clone_source(&send, root_id);
+ 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':
case 'p':
if (snapshot_parent) {
fprintf(stderr, "ERROR: you cannot have more than one parent (-p)\n");
- return 1;
+ ret = 1;
+ goto out;
}
snapshot_parent = realpath(optarg, NULL);
if (!snapshot_parent) {
"%s\n", optarg, strerror(-ret));
goto out;
}
+
+ ret = is_subvol_ro(&send, snapshot_parent);
+ if (ret < 0)
+ goto out;
+ if (!ret) {
+ ret = -EINVAL;
+ fprintf(stderr,
+ "ERROR: parent %s is not read-only.\n",
+ snapshot_parent);
+ goto out;
+ }
+
full_send = 0;
break;
case 'i':
fprintf(stderr,
"ERROR: -i was removed, use -c instead\n");
- return 1;
+ ret = 1;
+ goto out;
case '?':
default:
fprintf(stderr, "ERROR: send args invalid.\n");
- return 1;
+ ret = 1;
+ goto out;
}
}
- if (optind == argc) {
- fprintf(stderr, "ERROR: send needs path to snapshot\n");
- return 1;
- }
+ if (optind == argc)
+ usage(cmd_send_usage);
if (outname != NULL) {
send.dump_fd = creat(outname, 0600);
fprintf(stderr,
"ERROR: not dumping send stream into a terminal, "
"redirect it into a file\n");
- return 1;
+ ret = 1;
+ goto out;
}
/* use first send subvol to determine mount_root */
if (snapshot_parent != NULL) {
ret = get_root_id(&send,
- get_subvol_name(&send, snapshot_parent),
+ get_subvol_name(send.root_path, snapshot_parent),
&parent_root_id);
if (ret < 0) {
fprintf(stderr, "ERROR: could not resolve root_id "
}
for (i = optind; i < argc; i++) {
+ free(subvol);
subvol = realpath(argv[i], NULL);
if (!subvol) {
ret = -errno;
subvol);
goto out;
}
- free(subvol);
}
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);
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);
- goto out;
- }
-
if (!full_send && !parent_root_id) {
ret = find_good_parent(&send, root_id, &parent_root_id);
if (ret < 0) {
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);
if (ret < 0)
goto out;
parent_root_id = 0;
full_send = 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>",
- NULL
-};
-
-static const char * const cmd_send_usage[] = {
- "btrfs send [-v] [-p <parent>] [-c <clone-src>] <subvol>",
- "Send the subvolume to stdout.",
- "Sends the subvolume specified by <subvol> to stdout.",
+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.",
"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",
+ "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",
"which case 'btrfs send' will determine a suitable parent among the",
"clone sources itself.",
"\n",
- "-v Enable verbose debug output. Each occurrency of",
+ "-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 ",
" 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);
-}
projects / platform / upstream / btrfs-progs.git / blobdiff