#include <unistd.h>
#include <dirent.h>
#include <uuid/uuid.h>
+#include <getopt.h>
#include "kerncompat.h"
#include "ctree.h"
#include "transaction.h"
#include "utils.h"
#include "volumes.h"
+#include "help.h"
static char *device;
static int force = 0;
if (force)
return 0;
else
- fprintf(stderr, "seeding flag is already set on %s\n", device);
+ warning("seeding flag is already set on %s",
+ device);
return 1;
}
super_flags |= BTRFS_SUPER_FLAG_SEEDING;
} else {
if (!(super_flags & BTRFS_SUPER_FLAG_SEEDING)) {
- fprintf(stderr, "seeding flag is not set on %s\n",
- device);
+ warning("seeding flag is not set on %s", device);
return 1;
}
super_flags &= ~BTRFS_SUPER_FLAG_SEEDING;
- fprintf(stderr, "Warning: Seeding flag cleared.\n");
+ warning("seeding flag cleared on %s", device);
}
trans = btrfs_start_transaction(root, 1);
+ BUG_ON(IS_ERR(trans));
btrfs_set_super_flags(disk_super, super_flags);
ret = btrfs_commit_transaction(trans, root);
super_flags = btrfs_super_incompat_flags(disk_super);
super_flags |= flags;
trans = btrfs_start_transaction(root, 1);
+ BUG_ON(IS_ERR(trans));
btrfs_set_super_incompat_flags(disk_super, super_flags);
ret = btrfs_commit_transaction(trans, root);
int same_chunk_tree_uuid = 1;
int ret;
- /* Check for whether we need to change fs/chunk id */
- if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
- return 0;
- if (fs_info->new_fsid)
- same_fsid = !memcmp_extent_buffer(eb, fs_info->new_fsid,
- btrfs_header_fsid(), BTRFS_FSID_SIZE);
- if (fs_info->new_chunk_tree_uuid)
- same_chunk_tree_uuid =
- !memcmp_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
- btrfs_header_chunk_tree_uuid(eb),
- BTRFS_UUID_SIZE);
+ same_fsid = !memcmp_extent_buffer(eb, fs_info->new_fsid,
+ btrfs_header_fsid(), BTRFS_FSID_SIZE);
+ same_chunk_tree_uuid =
+ !memcmp_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
+ btrfs_header_chunk_tree_uuid(eb),
+ BTRFS_UUID_SIZE);
if (same_fsid && same_chunk_tree_uuid)
return 0;
if (!same_fsid)
write_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
btrfs_header_chunk_tree_uuid(eb),
BTRFS_UUID_SIZE);
- ret = write_tree_block(NULL, root, eb);
+ ret = write_tree_block(NULL, fs_info, eb);
return ret;
}
static int change_extents_uuid(struct btrfs_fs_info *fs_info)
{
struct btrfs_root *root = fs_info->extent_root;
- struct btrfs_path *path;
+ struct btrfs_path path;
struct btrfs_key key = {0, 0, 0};
int ret = 0;
- if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
- return 0;
-
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
-
+ btrfs_init_path(&path);
/*
* Here we don't use transaction as it will takes a lot of reserve
* space, and that will make a near-full btrfs unable to change uuid
*/
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+ ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
if (ret < 0)
goto out;
u64 flags;
u64 bytenr;
- btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
+ btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
if (key.type != BTRFS_EXTENT_ITEM_KEY &&
key.type != BTRFS_METADATA_ITEM_KEY)
goto next;
- ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
+ ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
struct btrfs_extent_item);
- flags = btrfs_extent_flags(path->nodes[0], ei);
+ flags = btrfs_extent_flags(path.nodes[0], ei);
if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
goto next;
bytenr = key.objectid;
- eb = read_tree_block(root, bytenr, root->nodesize, 0);
+ eb = read_tree_block(fs_info, bytenr, 0);
if (IS_ERR(eb)) {
- fprintf(stderr, "Failed to read tree block: %llu\n",
- bytenr);
+ error("failed to read tree block: %llu", bytenr);
ret = PTR_ERR(eb);
goto out;
}
ret = change_header_uuid(root, eb);
free_extent_buffer(eb);
if (ret < 0) {
- fprintf(stderr, "Failed to change uuid of tree block: %llu\n",
+ error("failed to change uuid of tree block: %llu",
bytenr);
goto out;
}
next:
- ret = btrfs_next_item(root, path);
+ ret = btrfs_next_item(root, &path);
if (ret < 0)
goto out;
if (ret > 0) {
}
out:
- btrfs_free_path(path);
+ btrfs_release_path(&path);
return ret;
}
-static int change_device_uuid(struct btrfs_root *root, struct extent_buffer *eb,
+static int change_device_uuid(struct btrfs_fs_info *fs_info, struct extent_buffer *eb,
int slot)
{
- struct btrfs_fs_info *fs_info = root->fs_info;
struct btrfs_dev_item *di;
int ret = 0;
di = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
- if (fs_info->new_fsid) {
- if (!memcmp_extent_buffer(eb, fs_info->new_fsid,
- (unsigned long)btrfs_device_fsid(di),
- BTRFS_FSID_SIZE))
- return ret;
- write_extent_buffer(eb, fs_info->new_fsid,
- (unsigned long)btrfs_device_fsid(di),
- BTRFS_FSID_SIZE);
- ret = write_tree_block(NULL, root, eb);
- }
+ if (!memcmp_extent_buffer(eb, fs_info->new_fsid,
+ (unsigned long)btrfs_device_fsid(di),
+ BTRFS_FSID_SIZE))
+ return ret;
+
+ write_extent_buffer(eb, fs_info->new_fsid,
+ (unsigned long)btrfs_device_fsid(di),
+ BTRFS_FSID_SIZE);
+ ret = write_tree_block(NULL, fs_info, eb);
+
return ret;
}
static int change_devices_uuid(struct btrfs_fs_info *fs_info)
{
struct btrfs_root *root = fs_info->chunk_root;
- struct btrfs_path *path;
+ struct btrfs_path path;
struct btrfs_key key = {0, 0, 0};
int ret = 0;
- /*
- * Unlike change_extents_uuid, we only need to change fsid in dev_item
- */
- if (!fs_info->new_fsid)
- return 0;
-
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
+ btrfs_init_path(&path);
/* No transaction again */
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+ ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
if (ret < 0)
goto out;
while (1) {
- btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
+ btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
if (key.type != BTRFS_DEV_ITEM_KEY ||
key.objectid != BTRFS_DEV_ITEMS_OBJECTID)
goto next;
- ret = change_device_uuid(root, path->nodes[0], path->slots[0]);
+ ret = change_device_uuid(fs_info, path.nodes[0], path.slots[0]);
if (ret < 0)
goto out;
next:
- ret = btrfs_next_item(root, path);
+ ret = btrfs_next_item(root, &path);
if (ret < 0)
goto out;
if (ret > 0) {
}
}
out:
- btrfs_free_path(path);
+ btrfs_release_path(&path);
return ret;
}
u64 flags = btrfs_super_flags(fs_info->super_copy);
int ret = 0;
- if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
- return 0;
-
- if (fs_info->new_fsid)
- flags |= BTRFS_SUPER_FLAG_CHANGING_FSID;
+ 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);
+ ret = write_all_supers(fs_info);
if (ret < 0)
return ret;
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);
+ return write_tree_block(NULL, fs_info, tree_root->node);
}
static int change_fsid_done(struct btrfs_fs_info *fs_info)
{
u64 flags = btrfs_super_flags(fs_info->super_copy);
- if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
- return 0;
-
- if (fs_info->new_fsid)
- flags &= ~BTRFS_SUPER_FLAG_CHANGING_FSID;
+ flags &= ~BTRFS_SUPER_FLAG_CHANGING_FSID;
btrfs_set_super_flags(fs_info->super_copy, flags);
- return write_all_supers(fs_info->tree_root);
+ return write_all_supers(fs_info);
}
/*
uuid_parse(new_fsid_str, tmp);
if (memcmp(tmp, new_fsid, BTRFS_FSID_SIZE)) {
- fprintf(stderr,
- "ERROR: New fsid %s is not the same with unfinished fsid change\n",
+ error(
+ "new fsid %s is not the same with unfinished fsid change",
new_fsid_str);
return -EINVAL;
}
fs_info->new_fsid = new_fsid;
fs_info->new_chunk_tree_uuid = new_chunk_id;
- uuid_parse((const char*)fs_info->fsid, old_fsid);
- uuid_unparse_upper(old_fsid, uuid_buf);
+ 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_upper(new_fsid, 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");
printf("Change fsid in extents\n");
ret = change_extents_uuid(fs_info);
if (ret < 0) {
- fprintf(stderr, "Failed to change UUID of metadata\n");
+ error("failed to change UUID of metadata: %d", ret);
goto out;
}
printf("Change fsid on devices\n");
ret = change_devices_uuid(fs_info);
if (ret < 0) {
- fprintf(stderr, "Failed to change UUID of devices\n");
+ error("failed to change UUID of devices: %d", ret);
goto out;
}
BTRFS_FSID_SIZE);
memcpy(fs_info->super_copy->fsid, fs_info->new_fsid,
BTRFS_FSID_SIZE);
- ret = write_all_supers(fs_info->tree_root);
+ ret = write_all_supers(fs_info);
if (ret < 0)
goto out;
static void print_usage(void)
{
- fprintf(stderr, "usage: btrfstune [options] device\n");
- fprintf(stderr, "\t-S value\tpositive value will enable seeding, zero to disable, negative is not allowed\n");
- fprintf(stderr, "\t-r \t\tenable extended inode refs\n");
- fprintf(stderr, "\t-x \t\tenable skinny metadata extent refs\n");
- fprintf(stderr, "\t-n \t\tenable no-holes feature (more efficient sparse file representation)\n");
- fprintf(stderr, "\t-f \t\tforce to do dangerous operation, make sure that you are aware of the dangers\n");
- fprintf(stderr, "\t-u \t\tchange fsid, use a random one\n");
- fprintf(stderr, "\t-U UUID\t\tchange fsid to UUID\n");
+ printf("usage: btrfstune [options] device\n");
+ printf("\t-S value\tpositive value will enable seeding, zero to disable, negative is not allowed\n");
+ printf("\t-r \t\tenable extended inode refs\n");
+ printf("\t-x \t\tenable skinny metadata extent refs\n");
+ printf("\t-n \t\tenable no-holes feature (more efficient sparse file representation)\n");
+ printf("\t-f \t\tforce to do dangerous operation, make sure that you are aware of the dangers\n");
+ printf("\t-u \t\tchange fsid, use a random one\n");
+ printf("\t-U UUID\t\tchange fsid to UUID\n");
}
int main(int argc, char *argv[])
{
struct btrfs_root *root;
- enum btrfs_open_ctree_flags ctree_flags = OPEN_CTREE_WRITES;
+ unsigned ctree_flags = OPEN_CTREE_WRITES;
int success = 0;
int total = 0;
int seeding_flag = 0;
int ret;
u64 super_flags = 0;
- optind = 1;
while(1) {
- int c = getopt(argc, argv, "S:rxfuU:n");
+ static const struct option long_options[] = {
+ { "help", no_argument, NULL, GETOPT_VAL_HELP},
+ { NULL, 0, NULL, 0 }
+ };
+ int c = getopt_long(argc, argv, "S:rxfuU:n", long_options, NULL);
+
if (c < 0)
break;
switch(c) {
ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH;
random_fsid = 1;
break;
+ case GETOPT_VAL_HELP:
default:
print_usage();
- return 1;
+ return c != GETOPT_VAL_HELP;
}
}
set_argv0(argv);
- argc = argc - optind;
device = argv[optind];
- if (check_argc_exact(argc, 1)) {
+ if (check_argc_exact(argc - optind, 1)) {
print_usage();
return 1;
}
if (random_fsid && new_fsid_str) {
- fprintf(stderr,
- "ERROR: Random fsid can't be used with specified fsid\n");
+ error("random fsid can't be used with specified fsid");
return 1;
}
if (!super_flags && !seeding_flag && !(random_fsid || new_fsid_str)) {
- fprintf(stderr,
- "ERROR: At least one option should be assigned.\n");
+ error("at least one option should be specified");
print_usage();
return 1;
}
ret = uuid_parse(new_fsid_str, tmp);
if (ret < 0) {
- fprintf(stderr,
- "ERROR: Could not parse UUID: %s\n",
- new_fsid_str);
+ error("could not parse UUID: %s", new_fsid_str);
return 1;
}
if (!test_uuid_unique(new_fsid_str)) {
- fprintf(stderr,
- "ERROR: Fsid %s is not unique\n",
- new_fsid_str);
+ error("fsid %s is not unique", new_fsid_str);
return 1;
}
}
ret = check_mounted(device);
if (ret < 0) {
- fprintf(stderr, "Could not check mount status: %s\n",
+ error("could not check mount status of %s: %s", device,
strerror(-ret));
return 1;
} else if (ret) {
- fprintf(stderr, "%s is mounted\n", device);
+ error("%s is mounted", device);
return 1;
}
root = open_ctree(device, 0, ctree_flags);
if (!root) {
- fprintf(stderr, "Open ctree failed\n");
+ error("open ctree failed");
return 1;
}
if (seeding_flag) {
if (!seeding_value && !force) {
- fprintf(stderr, "Warning: This is dangerous, clearing the seeding flag may cause the derived device not to be mountable!\n");
+ warning(
+"this is dangerous, clearing the seeding flag may cause the derived device not to be mountable!");
ret = ask_user("We are going to clear the seeding flag, are you sure?");
if (!ret) {
fprintf(stderr, "Clear seeding flag canceled\n");
if (random_fsid || new_fsid_str) {
if (!force) {
- fprintf(stderr,
- "Warning: It's highly recommended to run 'btrfs check' before this operation\n");
- fprintf(stderr,
- "Also canceling running UUID change progress may cause corruption\n");
+ warning(
+ "it's highly recommended to run 'btrfs check' before this operation");
+ warning(
+ "also canceling running UUID change progress may cause corruption");
ret = ask_user("We are going to change UUID, are your sure?");
if (!ret) {
fprintf(stderr, "UUID change canceled\n");
} else {
root->fs_info->readonly = 1;
ret = 1;
- fprintf(stderr, "btrfstune failed\n");
+ error("btrfstune failed");
}
out:
close_ctree(root);
+ btrfs_close_all_devices();
return ret;
}