X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=btrfstune.c;h=eccedf79a8039641693739dd2d58c1d4c5478748;hb=50417091a076a84ed06ea8d7158b749ece0d0914;hp=9a63f41bee59fc2232aa7bef80ef64cbea7d6e97;hpb=d275dbd1832bcfad6338dd14d16d619fd016b94a;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/btrfstune.c b/btrfstune.c index 9a63f41..eccedf7 100644 --- a/btrfstune.c +++ b/btrfstune.c @@ -23,11 +23,16 @@ #include #include #include +#include +#include + #include "kerncompat.h" #include "ctree.h" #include "disk-io.h" #include "transaction.h" #include "utils.h" +#include "volumes.h" +#include "help.h" static char *device; static int force = 0; @@ -37,6 +42,7 @@ static int update_seeding_flag(struct btrfs_root *root, int set_flag) struct btrfs_trans_handle *trans; struct btrfs_super_block *disk_super; u64 super_flags; + int ret; disk_super = root->fs_info->super_copy; super_flags = btrfs_super_flags(disk_super); @@ -45,57 +51,44 @@ static int update_seeding_flag(struct btrfs_root *root, int set_flag) 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); - btrfs_commit_transaction(trans, root); - - return 0; -} - -static int enable_extrefs_flag(struct btrfs_root *root) -{ - struct btrfs_trans_handle *trans; - struct btrfs_super_block *disk_super; - u64 super_flags; - - disk_super = root->fs_info->super_copy; - super_flags = btrfs_super_incompat_flags(disk_super); - super_flags |= BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF; - trans = btrfs_start_transaction(root, 1); - btrfs_set_super_incompat_flags(disk_super, super_flags); - btrfs_commit_transaction(trans, root); + ret = btrfs_commit_transaction(trans, root); - return 0; + return ret; } -static int enable_skinny_metadata(struct btrfs_root *root) +static int set_super_incompat_flags(struct btrfs_root *root, u64 flags) { struct btrfs_trans_handle *trans; struct btrfs_super_block *disk_super; u64 super_flags; + int ret; disk_super = root->fs_info->super_copy; super_flags = btrfs_super_incompat_flags(disk_super); - super_flags |= BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA; + super_flags |= flags; trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); btrfs_set_super_incompat_flags(disk_super, super_flags); - btrfs_commit_transaction(trans, root); + ret = btrfs_commit_transaction(trans, root); - return 0; + return ret; } static int change_header_uuid(struct btrfs_root *root, struct extent_buffer *eb) @@ -105,17 +98,12 @@ static int change_header_uuid(struct btrfs_root *root, struct extent_buffer *eb) 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) @@ -125,7 +113,7 @@ static int change_header_uuid(struct btrfs_root *root, struct extent_buffer *eb) 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; } @@ -133,22 +121,16 @@ static int change_header_uuid(struct btrfs_root *root, struct extent_buffer *eb) 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; @@ -158,33 +140,32 @@ static int change_extents_uuid(struct btrfs_fs_info *fs_info) 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) { @@ -194,62 +175,53 @@ next: } 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) { @@ -258,61 +230,178 @@ next: } } out: - btrfs_free_path(path); + btrfs_release_path(&path); return ret; } 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; - 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); + memcpy(fs_info->super_copy->fsid, fs_info->new_fsid, BTRFS_FSID_SIZE); + ret = write_all_supers(fs_info); + 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, 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); +} + +/* + * Return 0 for no unfinished fsid change. + * Return >0 for unfinished fsid change, and restore unfinished fsid/ + * chunk_tree_id into fsid_ret/chunk_id_ret. + */ +static int check_unfinished_fsid_change(struct btrfs_fs_info *fs_info, + uuid_t fsid_ret, uuid_t chunk_id_ret) +{ + struct btrfs_root *tree_root = fs_info->tree_root; + u64 flags = btrfs_super_flags(fs_info->super_copy); + + if (flags & BTRFS_SUPER_FLAG_CHANGING_FSID) { + memcpy(fsid_ret, fs_info->super_copy->fsid, BTRFS_FSID_SIZE); + read_extent_buffer(tree_root->node, chunk_id_ret, + btrfs_header_chunk_tree_uuid(tree_root->node), + BTRFS_UUID_SIZE); + return 1; + } + return 0; +} + +/* + * 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); + 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; } 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-f \t\tforce to set or clear flags, make sure that you are aware of the dangers\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; + unsigned ctree_flags = OPEN_CTREE_WRITES; int success = 0; int total = 0; - int extrefs_flag = 0; int seeding_flag = 0; u64 seeding_value = 0; - int skinny_flag = 0; + int random_fsid = 0; + char *new_fsid_str = NULL; int ret; + u64 super_flags = 0; - optind = 1; while(1) { - int c = getopt(argc, argv, "S:rxf"); + 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) { @@ -321,59 +410,89 @@ int main(int argc, char *argv[]) seeding_value = arg_strtou64(optarg); break; case 'r': - extrefs_flag = 1; + super_flags |= BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF; break; case 'x': - skinny_flag = 1; + super_flags |= BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA; + break; + case 'n': + super_flags |= BTRFS_FEATURE_INCOMPAT_NO_HOLES; break; case 'f': force = 1; break; + case 'U': + ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH; + new_fsid_str = optarg; + break; + case 'u': + 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 (!(seeding_flag + extrefs_flag + skinny_flag)) { - fprintf(stderr, - "ERROR: At least one option should be assigned.\n"); + if (random_fsid && new_fsid_str) { + error("random fsid can't be used with specified fsid"); + return 1; + } + if (!super_flags && !seeding_flag && !(random_fsid || new_fsid_str)) { + error("at least one option should be specified"); print_usage(); return 1; } + if (new_fsid_str) { + uuid_t tmp; + + ret = uuid_parse(new_fsid_str, tmp); + if (ret < 0) { + error("could not parse UUID: %s", new_fsid_str); + return 1; + } + if (!test_uuid_unique(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, OPEN_CTREE_WRITES); + 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"); - return 1; + ret = 1; + goto out; } } @@ -383,15 +502,29 @@ int main(int argc, char *argv[]) total++; } - if (extrefs_flag) { - enable_extrefs_flag(root); - success++; + if (super_flags) { + ret = set_super_incompat_flags(root, super_flags); + if (!ret) + success++; total++; } - if (skinny_flag) { - enable_skinny_metadata(root); - success++; + if (random_fsid || new_fsid_str) { + if (!force) { + 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"); + ret = 1; + goto out; + } + } + ret = change_uuid(root->fs_info, new_fsid_str); + if (!ret) + success++; total++; } @@ -400,9 +533,11 @@ int main(int argc, char *argv[]) } 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; }