static int change_fsid_done(struct btrfs_fs_info *fs_info)
{
u64 flags = btrfs_super_flags(fs_info->super_copy);
flags &= ~BTRFS_SUPER_FLAG_CHANGING_FSID;
btrfs_set_super_flags(fs_info->super_copy, flags);
return write_all_supers(fs_info->tree_root);
}
static int change_fsid_prepare(struct btrfs_fs_info *fs_info)
{
struct btrfs_root *tree_root = fs_info->tree_root;
u64 flags = btrfs_super_flags(fs_info->super_copy);
int ret = 0;
flags |= BTRFS_SUPER_FLAG_CHANGING_FSID;
btrfs_set_super_flags(fs_info->super_copy, flags);
memcpy(fs_info->super_copy->fsid, fs_info->new_fsid, BTRFS_FSID_SIZE);
ret = write_all_supers(tree_root);
if (ret < 0)
return ret;
/* also restore new chunk_tree_id into tree_root for restore */
write_extent_buffer(tree_root->node, fs_info->new_chunk_tree_uuid,
btrfs_header_chunk_tree_uuid(tree_root->node),
BTRFS_UUID_SIZE);
return write_tree_block(NULL, tree_root, tree_root->node);
}
/*
* Change fsid of a given fs.
*
* If new_fsid_str is not given, use a random generated UUID.
* Caller should check new_fsid_str is valid
*/
static int change_uuid(struct btrfs_fs_info *fs_info, const char *new_fsid_str)
{
uuid_t new_fsid;
uuid_t new_chunk_id;
uuid_t old_fsid;
char uuid_buf[BTRFS_UUID_UNPARSED_SIZE];
int ret = 0;
if (check_unfinished_fsid_change(fs_info, new_fsid, new_chunk_id)) {
if (new_fsid_str) {
uuid_t tmp;
uuid_parse(new_fsid_str, tmp);
if (memcmp(tmp, new_fsid, BTRFS_FSID_SIZE)) {
error(
"new fsid %s is not the same with unfinished fsid change",
new_fsid_str);
return -EINVAL;
}
}
} else {
if (new_fsid_str)
uuid_parse(new_fsid_str, new_fsid);
else
uuid_generate(new_fsid);
uuid_generate(new_chunk_id);
}
fs_info->new_fsid = new_fsid;
fs_info->new_chunk_tree_uuid = new_chunk_id;
memcpy(old_fsid, (const char*)fs_info->fsid, BTRFS_UUID_SIZE);
uuid_unparse(old_fsid, uuid_buf);
printf("Current fsid: %s\n", uuid_buf);
uuid_unparse(new_fsid, uuid_buf);
printf("New fsid: %s\n", uuid_buf);
/* Now we can begin fsid change */
printf("Set superblock flag CHANGING_FSID\n");
ret = change_fsid_prepare(fs_info);
if (ret < 0)
goto out;
/* Change extents first */
printf("Change fsid in extents\n");
ret = change_extents_uuid(fs_info);
if (ret < 0) {
error("failed to change UUID of metadata: %d", ret);
goto out;
}
/* Then devices */
printf("Change fsid on devices\n");
ret = change_devices_uuid(fs_info);
if (ret < 0) {
error("failed to change UUID of devices: %d", ret);
goto out;
}
/* Last, change fsid in super */
memcpy(fs_info->fs_devices->fsid, fs_info->new_fsid,
BTRFS_FSID_SIZE);
memcpy(fs_info->super_copy->fsid, fs_info->new_fsid,
BTRFS_FSID_SIZE);
ret = write_all_supers(fs_info->tree_root);
if (ret < 0)
goto out;
/* Now fsid change is done */
printf("Clear superblock flag CHANGING_FSID\n");
ret = change_fsid_done(fs_info);
fs_info->new_fsid = NULL;
fs_info->new_chunk_tree_uuid = NULL;
printf("Fsid change finished\n");
out:
return ret;
}
int main(int ac, char **av)
{
struct btrfs_root *root;
int ret;
u64 num = 0;
u64 bytenr = 0;
while(1) {
int c;
c = getopt(ac, av, "s:");
if (c < 0)
break;
switch(c) {
case 's':
num = arg_strtou64(optarg);
if (num >= BTRFS_SUPER_MIRROR_MAX) {
fprintf(stderr,
"ERROR: super mirror should be less than: %d\n",
BTRFS_SUPER_MIRROR_MAX);
exit(1);
}
bytenr = btrfs_sb_offset(((int)num));
break;
default:
print_usage();
}
}
set_argv0(av);
ac = ac - optind;
if (check_argc_exact(ac, 1))
print_usage();
if (bytenr == 0) {
fprintf(stderr, "Please select the super copy with -s\n");
print_usage();
}
radix_tree_init();
if((ret = check_mounted(av[optind])) < 0) {
fprintf(stderr, "Could not check mount status: %s\n", strerror(-ret));
return ret;
} else if(ret) {
fprintf(stderr, "%s is currently mounted. Aborting.\n", av[optind]);
return -EBUSY;
}
root = open_ctree(av[optind], bytenr, 1);
if (!root) {
fprintf(stderr, "Open ctree failed\n");
return 1;
}
/* make the super writing code think we've read the first super */
root->fs_info->super_bytenr = BTRFS_SUPER_INFO_OFFSET;
ret = write_all_supers(root);
/* we don't close the ctree or anything, because we don't want a real
* transaction commit. We just want the super copy we pulled off the
* disk to overwrite all the other copies
*/
printf("using SB copy %llu, bytenr %llu\n", (unsigned long long)num,
(unsigned long long)bytenr);
close_ctree(root);
btrfs_close_all_devices();
return ret;
}
