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;
44 disk_super = root->fs_info->super_copy;
45 super_flags = btrfs_super_flags(disk_super);
47 if (super_flags & BTRFS_SUPER_FLAG_SEEDING) {
51 fprintf(stderr, "seeding flag is already set on %s\n", device);
54 super_flags |= BTRFS_SUPER_FLAG_SEEDING;
56 if (!(super_flags & BTRFS_SUPER_FLAG_SEEDING)) {
57 fprintf(stderr, "seeding flag is not set on %s\n",
61 super_flags &= ~BTRFS_SUPER_FLAG_SEEDING;
62 fprintf(stderr, "Warning: Seeding flag cleared.\n");
65 trans = btrfs_start_transaction(root, 1);
66 btrfs_set_super_flags(disk_super, super_flags);
67 btrfs_commit_transaction(trans, root);
72 static int enable_extrefs_flag(struct btrfs_root *root)
74 struct btrfs_trans_handle *trans;
75 struct btrfs_super_block *disk_super;
78 disk_super = root->fs_info->super_copy;
79 super_flags = btrfs_super_incompat_flags(disk_super);
80 super_flags |= BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF;
81 trans = btrfs_start_transaction(root, 1);
82 btrfs_set_super_incompat_flags(disk_super, super_flags);
83 btrfs_commit_transaction(trans, root);
88 static int enable_skinny_metadata(struct btrfs_root *root)
90 struct btrfs_trans_handle *trans;
91 struct btrfs_super_block *disk_super;
94 disk_super = root->fs_info->super_copy;
95 super_flags = btrfs_super_incompat_flags(disk_super);
96 super_flags |= BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA;
97 trans = btrfs_start_transaction(root, 1);
98 btrfs_set_super_incompat_flags(disk_super, super_flags);
99 btrfs_commit_transaction(trans, root);
104 static int change_header_uuid(struct btrfs_root *root, struct extent_buffer *eb)
106 struct btrfs_fs_info *fs_info = root->fs_info;
108 int same_chunk_tree_uuid = 1;
111 /* Check for whether we need to change fs/chunk id */
112 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
114 if (fs_info->new_fsid)
115 same_fsid = !memcmp_extent_buffer(eb, fs_info->new_fsid,
116 btrfs_header_fsid(), BTRFS_FSID_SIZE);
117 if (fs_info->new_chunk_tree_uuid)
118 same_chunk_tree_uuid =
119 !memcmp_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
120 btrfs_header_chunk_tree_uuid(eb),
122 if (same_fsid && same_chunk_tree_uuid)
125 write_extent_buffer(eb, fs_info->new_fsid, btrfs_header_fsid(),
127 if (!same_chunk_tree_uuid)
128 write_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
129 btrfs_header_chunk_tree_uuid(eb),
131 ret = write_tree_block(NULL, root, eb);
136 static int change_extents_uuid(struct btrfs_fs_info *fs_info)
138 struct btrfs_root *root = fs_info->extent_root;
139 struct btrfs_path *path;
140 struct btrfs_key key = {0, 0, 0};
143 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
146 path = btrfs_alloc_path();
151 * Here we don't use transaction as it will takes a lot of reserve
152 * space, and that will make a near-full btrfs unable to change uuid
154 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
159 struct btrfs_extent_item *ei;
160 struct extent_buffer *eb;
164 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
165 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
166 key.type != BTRFS_METADATA_ITEM_KEY)
168 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
169 struct btrfs_extent_item);
170 flags = btrfs_extent_flags(path->nodes[0], ei);
171 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
174 bytenr = key.objectid;
175 eb = read_tree_block(root, bytenr, root->nodesize, 0);
177 fprintf(stderr, "Failed to read tree block: %llu\n",
182 ret = change_header_uuid(root, eb);
183 free_extent_buffer(eb);
185 fprintf(stderr, "Failed to change uuid of tree block: %llu\n",
190 ret = btrfs_next_item(root, path);
200 btrfs_free_path(path);
204 static int change_device_uuid(struct btrfs_root *root, struct extent_buffer *eb,
207 struct btrfs_fs_info *fs_info = root->fs_info;
208 struct btrfs_dev_item *di;
211 di = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
212 if (fs_info->new_fsid) {
213 if (!memcmp_extent_buffer(eb, fs_info->new_fsid,
214 (unsigned long)btrfs_device_fsid(di),
217 write_extent_buffer(eb, fs_info->new_fsid,
218 (unsigned long)btrfs_device_fsid(di),
220 ret = write_tree_block(NULL, root, eb);
225 static int change_devices_uuid(struct btrfs_fs_info *fs_info)
227 struct btrfs_root *root = fs_info->chunk_root;
228 struct btrfs_path *path;
229 struct btrfs_key key = {0, 0, 0};
233 * Unlike change_extents_uuid, we only need to change fsid in dev_item
235 if (!fs_info->new_fsid)
238 path = btrfs_alloc_path();
241 /* No transaction again */
242 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
247 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
248 if (key.type != BTRFS_DEV_ITEM_KEY ||
249 key.objectid != BTRFS_DEV_ITEMS_OBJECTID)
251 ret = change_device_uuid(root, path->nodes[0], path->slots[0]);
255 ret = btrfs_next_item(root, path);
264 btrfs_free_path(path);
268 static int change_fsid_prepare(struct btrfs_fs_info *fs_info)
270 struct btrfs_root *tree_root = fs_info->tree_root;
271 u64 flags = btrfs_super_flags(fs_info->super_copy);
274 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
277 if (fs_info->new_fsid)
278 flags |= BTRFS_SUPER_FLAG_CHANGING_FSID;
279 btrfs_set_super_flags(fs_info->super_copy, flags);
281 memcpy(fs_info->super_copy->fsid, fs_info->new_fsid, BTRFS_FSID_SIZE);
282 ret = write_all_supers(tree_root);
286 /* also restore new chunk_tree_id into tree_root for restore */
287 write_extent_buffer(tree_root->node, fs_info->new_chunk_tree_uuid,
288 btrfs_header_chunk_tree_uuid(tree_root->node),
290 return write_tree_block(NULL, tree_root, tree_root->node);
293 static int change_fsid_done(struct btrfs_fs_info *fs_info)
295 u64 flags = btrfs_super_flags(fs_info->super_copy);
297 if (!fs_info->new_fsid && !fs_info->new_chunk_tree_uuid)
300 if (fs_info->new_fsid)
301 flags &= ~BTRFS_SUPER_FLAG_CHANGING_FSID;
302 btrfs_set_super_flags(fs_info->super_copy, flags);
304 return write_all_supers(fs_info->tree_root);
308 * Return 0 for no unfinished fsid change.
309 * Return >0 for unfinished fsid change, and restore unfinished fsid/
310 * chunk_tree_id into fsid_ret/chunk_id_ret.
312 static int check_unfinished_fsid_change(struct btrfs_fs_info *fs_info,
313 uuid_t fsid_ret, uuid_t chunk_id_ret)
315 struct btrfs_root *tree_root = fs_info->tree_root;
316 u64 flags = btrfs_super_flags(fs_info->super_copy);
318 if (flags & BTRFS_SUPER_FLAG_CHANGING_FSID) {
319 memcpy(fsid_ret, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
320 read_extent_buffer(tree_root->node, chunk_id_ret,
321 btrfs_header_chunk_tree_uuid(tree_root->node),
329 * Change fsid of a given fs.
331 * If new_fsid_str is not given, use a random generated UUID.
332 * Caller should check new_fsid_str is valid
334 static int change_uuid(struct btrfs_fs_info *fs_info, const char *new_fsid_str)
338 char uuid_buf[BTRFS_UUID_UNPARSED_SIZE];
341 if (check_unfinished_fsid_change(fs_info, new_fsid, new_chunk_id)) {
345 uuid_parse(new_fsid_str, tmp);
346 if (memcmp(tmp, new_fsid, BTRFS_FSID_SIZE)) {
348 "ERROR: New fsid %s is not the same with unfinished fsid change\n",
355 uuid_parse(new_fsid_str, new_fsid);
357 uuid_generate(new_fsid);
359 uuid_generate(new_chunk_id);
361 fs_info->new_fsid = new_fsid;
362 fs_info->new_chunk_tree_uuid = new_chunk_id;
364 uuid_unparse_upper(new_fsid, uuid_buf);
365 printf("Changing fsid to %s\n", uuid_buf);
366 /* Now we can begin fsid change */
367 ret = change_fsid_prepare(fs_info);
371 /* Change extents first */
372 ret = change_extents_uuid(fs_info);
374 fprintf(stderr, "Failed to change UUID of metadata\n");
379 ret = change_devices_uuid(fs_info);
381 fprintf(stderr, "Failed to change UUID of devices\n");
385 /* Last, change fsid in super */
386 memcpy(fs_info->fs_devices->fsid, fs_info->new_fsid,
388 memcpy(fs_info->super_copy->fsid, fs_info->new_fsid,
390 ret = write_all_supers(fs_info->tree_root);
394 /* Now fsid change is done */
395 ret = change_fsid_done(fs_info);
396 fs_info->new_fsid = NULL;
397 fs_info->new_chunk_tree_uuid = NULL;
398 printf("Fsid changed to %s\n", uuid_buf);
403 static void print_usage(void)
405 fprintf(stderr, "usage: btrfstune [options] device\n");
406 fprintf(stderr, "\t-S value\tpositive value will enable seeding, zero to disable, negative is not allowed\n");
407 fprintf(stderr, "\t-r \t\tenable extended inode refs\n");
408 fprintf(stderr, "\t-x \t\tenable skinny metadata extent refs\n");
409 fprintf(stderr, "\t-f \t\tforce to do dangerous operation, make sure that you are aware of the dangers\n");
410 fprintf(stderr, "\t-u \t\tchange fsid, use a random one\n");
411 fprintf(stderr, "\t-U UUID\t\tchange fsid to UUID\n");
414 int main(int argc, char *argv[])
416 struct btrfs_root *root;
417 enum btrfs_open_ctree_flags ctree_flags = OPEN_CTREE_WRITES;
420 int extrefs_flag = 0;
421 int seeding_flag = 0;
422 u64 seeding_value = 0;
425 char *new_fsid_str = NULL;
430 int c = getopt(argc, argv, "S:rxfuU:");
436 seeding_value = arg_strtou64(optarg);
448 ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH;
449 new_fsid_str = optarg;
452 ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH;
462 argc = argc - optind;
463 device = argv[optind];
464 if (check_argc_exact(argc, 1)) {
469 if (random_fsid && new_fsid_str) {
471 "ERROR: Random fsid can't be used with specified fsid\n");
474 if (!(seeding_flag + extrefs_flag + skinny_flag) &&
475 !(random_fsid || new_fsid_str)) {
477 "ERROR: At least one option should be assigned.\n");
485 ret = uuid_parse(new_fsid_str, tmp);
488 "ERROR: Could not parse UUID: %s\n",
492 if (!test_uuid_unique(new_fsid_str)) {
494 "ERROR: Fsid %s is not unique\n",
500 ret = check_mounted(device);
502 fprintf(stderr, "Could not check mount status: %s\n",
506 fprintf(stderr, "%s is mounted\n", device);
510 root = open_ctree(device, 0, ctree_flags);
513 fprintf(stderr, "Open ctree failed\n");
518 if (!seeding_value && !force) {
519 fprintf(stderr, "Warning: This is dangerous, clearing the seeding flag may cause the derived device not to be mountable!\n");
520 ret = ask_user("We are going to clear the seeding flag, are you sure?");
522 fprintf(stderr, "Clear seeding flag canceled\n");
528 ret = update_seeding_flag(root, seeding_value);
535 enable_extrefs_flag(root);
541 enable_skinny_metadata(root);
546 if (random_fsid || new_fsid_str) {
549 "Warning: It's highly recommended to run 'btrfs check' before this operation\n");
551 "Also canceling running UUID change progress may cause corruption\n");
552 ret = ask_user("We are going to change UUID, are your sure?");
554 fprintf(stderr, "UUID change canceled\n");
559 ret = change_uuid(root->fs_info, new_fsid_str);
565 if (success == total) {
568 root->fs_info->readonly = 1;
570 fprintf(stderr, "btrfstune failed\n");