X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=btrfstune.c;h=eccedf79a8039641693739dd2d58c1d4c5478748;hb=50417091a076a84ed06ea8d7158b749ece0d0914;hp=3183631361a376407e47d9a1958ffee8dda5bf32;hpb=c476696b824ed593d0ed4494b32fa492875ca2db;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/btrfstune.c b/btrfstune.c index 3183631..eccedf7 100644 --- a/btrfstune.c +++ b/btrfstune.c @@ -24,6 +24,7 @@ #include #include #include +#include #include "kerncompat.h" #include "ctree.h" @@ -31,6 +32,7 @@ #include "transaction.h" #include "utils.h" #include "volumes.h" +#include "help.h" static char *device; static int force = 0; @@ -49,21 +51,22 @@ 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); ret = btrfs_commit_transaction(trans, root); @@ -81,6 +84,7 @@ static int set_super_incompat_flags(struct btrfs_root *root, u64 flags) 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); @@ -94,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) @@ -114,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; } @@ -122,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; @@ -147,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) { @@ -183,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) { @@ -247,7 +230,7 @@ next: } } out: - btrfs_free_path(path); + btrfs_release_path(&path); return ret; } @@ -257,15 +240,11 @@ static int change_fsid_prepare(struct btrfs_fs_info *fs_info) 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; @@ -273,21 +252,17 @@ static int change_fsid_prepare(struct btrfs_fs_info *fs_info) 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); } /* @@ -321,6 +296,7 @@ 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; @@ -330,8 +306,8 @@ static int change_uuid(struct btrfs_fs_info *fs_info, const char *new_fsid_str) 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; } @@ -347,24 +323,31 @@ static int change_uuid(struct btrfs_fs_info *fs_info, const char *new_fsid_str) fs_info->new_fsid = new_fsid; fs_info->new_chunk_tree_uuid = new_chunk_id; - uuid_unparse_upper(new_fsid, uuid_buf); - printf("Changing fsid to %s\n", 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(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) { - fprintf(stderr, "Failed to change UUID of metadata\n"); + 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) { - fprintf(stderr, "Failed to change UUID of devices\n"); + error("failed to change UUID of devices: %d", ret); goto out; } @@ -373,34 +356,36 @@ static int change_uuid(struct btrfs_fs_info *fs_info, const char *new_fsid_str) 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; /* 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 changed to %s\n", uuid_buf); + 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 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; @@ -410,9 +395,13 @@ int main(int argc, char *argv[]) int ret; u64 super_flags = 0; - optind = 1; while(1) { - int c = getopt(argc, argv, "S:rxfuU:"); + 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) { @@ -426,6 +415,9 @@ int main(int argc, char *argv[]) case 'x': super_flags |= BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA; break; + case 'n': + super_flags |= BTRFS_FEATURE_INCOMPAT_NO_HOLES; + break; case 'f': force = 1; break; @@ -437,28 +429,26 @@ int main(int argc, char *argv[]) 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; } @@ -468,39 +458,36 @@ int main(int argc, char *argv[]) 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"); @@ -524,10 +511,10 @@ int main(int argc, char *argv[]) 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"); @@ -546,10 +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; }