2 * Copyright (C) 2008 Oracle. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
21 #include <sys/types.h>
26 #include <uuid/uuid.h>
28 #include "kerncompat.h"
31 #include "transaction.h"
38 static int update_seeding_flag(struct btrfs_root *root, int set_flag)
40 struct btrfs_trans_handle *trans;
41 struct btrfs_super_block *disk_super;
45 disk_super = root->fs_info->super_copy;
46 super_flags = btrfs_super_flags(disk_super);
48 if (super_flags & BTRFS_SUPER_FLAG_SEEDING) {
52 fprintf(stderr, "seeding flag is already set on %s\n", device);
55 super_flags |= BTRFS_SUPER_FLAG_SEEDING;
57 if (!(super_flags & BTRFS_SUPER_FLAG_SEEDING)) {
58 fprintf(stderr, "seeding flag is not set on %s\n",
62 super_flags &= ~BTRFS_SUPER_FLAG_SEEDING;
63 fprintf(stderr, "Warning: Seeding flag cleared.\n");
66 trans = btrfs_start_transaction(root, 1);
67 btrfs_set_super_flags(disk_super, super_flags);
68 ret = btrfs_commit_transaction(trans, root);
73 static int set_super_incompat_flags(struct btrfs_root *root, u64 flags)
75 struct btrfs_trans_handle *trans;
76 struct btrfs_super_block *disk_super;
80 disk_super = root->fs_info->super_copy;
81 super_flags = btrfs_super_incompat_flags(disk_super);
83 trans = btrfs_start_transaction(root, 1);
84 btrfs_set_super_incompat_flags(disk_super, super_flags);
85 ret = btrfs_commit_transaction(trans, root);
90 static int change_header_uuid(struct btrfs_root *root, struct extent_buffer *eb)
92 struct btrfs_fs_info *fs_info = root->fs_info;
94 int same_chunk_tree_uuid = 1;
97 /* Check for whether we need to change fs/chunk id */
98 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
100 if (fs_info->new_fsid)
101 same_fsid = !memcmp_extent_buffer(eb, fs_info->new_fsid,
102 btrfs_header_fsid(), BTRFS_FSID_SIZE);
103 if (fs_info->new_chunk_tree_uuid)
104 same_chunk_tree_uuid =
105 !memcmp_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
106 btrfs_header_chunk_tree_uuid(eb),
108 if (same_fsid && same_chunk_tree_uuid)
111 write_extent_buffer(eb, fs_info->new_fsid, btrfs_header_fsid(),
113 if (!same_chunk_tree_uuid)
114 write_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
115 btrfs_header_chunk_tree_uuid(eb),
117 ret = write_tree_block(NULL, root, eb);
122 static int change_extents_uuid(struct btrfs_fs_info *fs_info)
124 struct btrfs_root *root = fs_info->extent_root;
125 struct btrfs_path *path;
126 struct btrfs_key key = {0, 0, 0};
129 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
132 path = btrfs_alloc_path();
137 * Here we don't use transaction as it will takes a lot of reserve
138 * space, and that will make a near-full btrfs unable to change uuid
140 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
145 struct btrfs_extent_item *ei;
146 struct extent_buffer *eb;
150 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
151 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
152 key.type != BTRFS_METADATA_ITEM_KEY)
154 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
155 struct btrfs_extent_item);
156 flags = btrfs_extent_flags(path->nodes[0], ei);
157 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
160 bytenr = key.objectid;
161 eb = read_tree_block(root, bytenr, root->nodesize, 0);
163 fprintf(stderr, "Failed to read tree block: %llu\n",
168 ret = change_header_uuid(root, eb);
169 free_extent_buffer(eb);
171 fprintf(stderr, "Failed to change uuid of tree block: %llu\n",
176 ret = btrfs_next_item(root, path);
186 btrfs_free_path(path);
190 static int change_device_uuid(struct btrfs_root *root, struct extent_buffer *eb,
193 struct btrfs_fs_info *fs_info = root->fs_info;
194 struct btrfs_dev_item *di;
197 di = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
198 if (fs_info->new_fsid) {
199 if (!memcmp_extent_buffer(eb, fs_info->new_fsid,
200 (unsigned long)btrfs_device_fsid(di),
203 write_extent_buffer(eb, fs_info->new_fsid,
204 (unsigned long)btrfs_device_fsid(di),
206 ret = write_tree_block(NULL, root, eb);
211 static int change_devices_uuid(struct btrfs_fs_info *fs_info)
213 struct btrfs_root *root = fs_info->chunk_root;
214 struct btrfs_path *path;
215 struct btrfs_key key = {0, 0, 0};
219 * Unlike change_extents_uuid, we only need to change fsid in dev_item
221 if (!fs_info->new_fsid)
224 path = btrfs_alloc_path();
227 /* No transaction again */
228 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
233 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
234 if (key.type != BTRFS_DEV_ITEM_KEY ||
235 key.objectid != BTRFS_DEV_ITEMS_OBJECTID)
237 ret = change_device_uuid(root, path->nodes[0], path->slots[0]);
241 ret = btrfs_next_item(root, path);
250 btrfs_free_path(path);
254 static int change_fsid_prepare(struct btrfs_fs_info *fs_info)
256 struct btrfs_root *tree_root = fs_info->tree_root;
257 u64 flags = btrfs_super_flags(fs_info->super_copy);
260 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
263 if (fs_info->new_fsid)
264 flags |= BTRFS_SUPER_FLAG_CHANGING_FSID;
265 btrfs_set_super_flags(fs_info->super_copy, flags);
267 memcpy(fs_info->super_copy->fsid, fs_info->new_fsid, BTRFS_FSID_SIZE);
268 ret = write_all_supers(tree_root);
272 /* also restore new chunk_tree_id into tree_root for restore */
273 write_extent_buffer(tree_root->node, fs_info->new_chunk_tree_uuid,
274 btrfs_header_chunk_tree_uuid(tree_root->node),
276 return write_tree_block(NULL, tree_root, tree_root->node);
279 static int change_fsid_done(struct btrfs_fs_info *fs_info)
281 u64 flags = btrfs_super_flags(fs_info->super_copy);
283 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
286 if (fs_info->new_fsid)
287 flags &= ~BTRFS_SUPER_FLAG_CHANGING_FSID;
288 btrfs_set_super_flags(fs_info->super_copy, flags);
290 return write_all_supers(fs_info->tree_root);
294 * Return 0 for no unfinished fsid change.
295 * Return >0 for unfinished fsid change, and restore unfinished fsid/
296 * chunk_tree_id into fsid_ret/chunk_id_ret.
298 static int check_unfinished_fsid_change(struct btrfs_fs_info *fs_info,
299 uuid_t fsid_ret, uuid_t chunk_id_ret)
301 struct btrfs_root *tree_root = fs_info->tree_root;
302 u64 flags = btrfs_super_flags(fs_info->super_copy);
304 if (flags & BTRFS_SUPER_FLAG_CHANGING_FSID) {
305 memcpy(fsid_ret, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
306 read_extent_buffer(tree_root->node, chunk_id_ret,
307 btrfs_header_chunk_tree_uuid(tree_root->node),
315 * Change fsid of a given fs.
317 * If new_fsid_str is not given, use a random generated UUID.
318 * Caller should check new_fsid_str is valid
320 static int change_uuid(struct btrfs_fs_info *fs_info, const char *new_fsid_str)
324 char uuid_buf[BTRFS_UUID_UNPARSED_SIZE];
327 if (check_unfinished_fsid_change(fs_info, new_fsid, new_chunk_id)) {
331 uuid_parse(new_fsid_str, tmp);
332 if (memcmp(tmp, new_fsid, BTRFS_FSID_SIZE)) {
334 "ERROR: New fsid %s is not the same with unfinished fsid change\n",
341 uuid_parse(new_fsid_str, new_fsid);
343 uuid_generate(new_fsid);
345 uuid_generate(new_chunk_id);
347 fs_info->new_fsid = new_fsid;
348 fs_info->new_chunk_tree_uuid = new_chunk_id;
350 uuid_unparse_upper(new_fsid, uuid_buf);
351 printf("Changing fsid to %s\n", uuid_buf);
352 /* Now we can begin fsid change */
353 ret = change_fsid_prepare(fs_info);
357 /* Change extents first */
358 ret = change_extents_uuid(fs_info);
360 fprintf(stderr, "Failed to change UUID of metadata\n");
365 ret = change_devices_uuid(fs_info);
367 fprintf(stderr, "Failed to change UUID of devices\n");
371 /* Last, change fsid in super */
372 memcpy(fs_info->fs_devices->fsid, fs_info->new_fsid,
374 memcpy(fs_info->super_copy->fsid, fs_info->new_fsid,
376 ret = write_all_supers(fs_info->tree_root);
380 /* Now fsid change is done */
381 ret = change_fsid_done(fs_info);
382 fs_info->new_fsid = NULL;
383 fs_info->new_chunk_tree_uuid = NULL;
384 printf("Fsid changed to %s\n", uuid_buf);
389 static void print_usage(void)
391 fprintf(stderr, "usage: btrfstune [options] device\n");
392 fprintf(stderr, "\t-S value\tpositive value will enable seeding, zero to disable, negative is not allowed\n");
393 fprintf(stderr, "\t-r \t\tenable extended inode refs\n");
394 fprintf(stderr, "\t-x \t\tenable skinny metadata extent refs\n");
395 fprintf(stderr, "\t-f \t\tforce to do dangerous operation, make sure that you are aware of the dangers\n");
396 fprintf(stderr, "\t-u \t\tchange fsid, use a random one\n");
397 fprintf(stderr, "\t-U UUID\t\tchange fsid to UUID\n");
400 int main(int argc, char *argv[])
402 struct btrfs_root *root;
403 enum btrfs_open_ctree_flags ctree_flags = OPEN_CTREE_WRITES;
406 int seeding_flag = 0;
407 u64 seeding_value = 0;
409 char *new_fsid_str = NULL;
415 int c = getopt(argc, argv, "S:rxfuU:");
421 seeding_value = arg_strtou64(optarg);
424 super_flags |= BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF;
427 super_flags |= BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA;
433 ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH;
434 new_fsid_str = optarg;
437 ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH;
447 argc = argc - optind;
448 device = argv[optind];
449 if (check_argc_exact(argc, 1)) {
454 if (random_fsid && new_fsid_str) {
456 "ERROR: Random fsid can't be used with specified fsid\n");
459 if (!super_flags && !seeding_flag && !(random_fsid || new_fsid_str)) {
461 "ERROR: At least one option should be assigned.\n");
469 ret = uuid_parse(new_fsid_str, tmp);
472 "ERROR: Could not parse UUID: %s\n",
476 if (!test_uuid_unique(new_fsid_str)) {
478 "ERROR: Fsid %s is not unique\n",
484 ret = check_mounted(device);
486 fprintf(stderr, "Could not check mount status: %s\n",
490 fprintf(stderr, "%s is mounted\n", device);
494 root = open_ctree(device, 0, ctree_flags);
497 fprintf(stderr, "Open ctree failed\n");
502 if (!seeding_value && !force) {
503 fprintf(stderr, "Warning: This is dangerous, clearing the seeding flag may cause the derived device not to be mountable!\n");
504 ret = ask_user("We are going to clear the seeding flag, are you sure?");
506 fprintf(stderr, "Clear seeding flag canceled\n");
512 ret = update_seeding_flag(root, seeding_value);
519 ret = set_super_incompat_flags(root, super_flags);
525 if (random_fsid || new_fsid_str) {
528 "Warning: It's highly recommended to run 'btrfs check' before this operation\n");
530 "Also canceling running UUID change progress may cause corruption\n");
531 ret = ask_user("We are going to change UUID, are your sure?");
533 fprintf(stderr, "UUID change canceled\n");
538 ret = change_uuid(root->fs_info, new_fsid_str);
544 if (success == total) {
547 root->fs_info->readonly = 1;
549 fprintf(stderr, "btrfstune failed\n");