btrfstune.c

   1 /*
   2  * Copyright (C) 2008 Oracle.  All rights reserved.
   3  *
   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.
   7  *
   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.
  12  *
  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.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include <dirent.h>
  26 #include <uuid/uuid.h>
  27 #include <getopt.h>
  28
  29 #include "kerncompat.h"
  30 #include "ctree.h"
  31 #include "disk-io.h"
  32 #include "transaction.h"
  33 #include "utils.h"
  34 #include "volumes.h"
  35
  36 static char *device;
  37 static int force = 0;
  38
  39 static int update_seeding_flag(struct btrfs_root *root, int set_flag)
  40 {
  41         struct btrfs_trans_handle *trans;
  42         struct btrfs_super_block *disk_super;
  43         u64 super_flags;
  44         int ret;
  45
  46         disk_super = root->fs_info->super_copy;
  47         super_flags = btrfs_super_flags(disk_super);
  48         if (set_flag) {
  49                 if (super_flags & BTRFS_SUPER_FLAG_SEEDING) {
  50                         if (force)
  51                                 return 0;
  52                         else
  53                                 warning("seeding flag is already set on %s",
  54                                                 device);
  55                         return 1;
  56                 }
  57                 super_flags |= BTRFS_SUPER_FLAG_SEEDING;
  58         } else {
  59                 if (!(super_flags & BTRFS_SUPER_FLAG_SEEDING)) {
  60                         warning("seeding flag is not set on %s", device);
  61                         return 1;
  62                 }
  63                 super_flags &= ~BTRFS_SUPER_FLAG_SEEDING;
  64                 warning("seeding flag cleared on %s", device);
  65         }
  66
  67         trans = btrfs_start_transaction(root, 1);
  68         btrfs_set_super_flags(disk_super, super_flags);
  69         ret = btrfs_commit_transaction(trans, root);
  70
  71         return ret;
  72 }
  73
  74 static int set_super_incompat_flags(struct btrfs_root *root, u64 flags)
  75 {
  76         struct btrfs_trans_handle *trans;
  77         struct btrfs_super_block *disk_super;
  78         u64 super_flags;
  79         int ret;
  80
  81         disk_super = root->fs_info->super_copy;
  82         super_flags = btrfs_super_incompat_flags(disk_super);
  83         super_flags |= flags;
  84         trans = btrfs_start_transaction(root, 1);
  85         btrfs_set_super_incompat_flags(disk_super, super_flags);
  86         ret = btrfs_commit_transaction(trans, root);
  87
  88         return ret;
  89 }
  90
  91 static int change_header_uuid(struct btrfs_root *root, struct extent_buffer *eb)
  92 {
  93         struct btrfs_fs_info *fs_info = root->fs_info;
  94         int same_fsid = 1;
  95         int same_chunk_tree_uuid = 1;
  96         int ret;
  97
  98         same_fsid = !memcmp_extent_buffer(eb, fs_info->new_fsid,
  99                         btrfs_header_fsid(), BTRFS_FSID_SIZE);
 100         same_chunk_tree_uuid =
 101                 !memcmp_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
 102                                 btrfs_header_chunk_tree_uuid(eb),
 103                                 BTRFS_UUID_SIZE);
 104         if (same_fsid && same_chunk_tree_uuid)
 105                 return 0;
 106         if (!same_fsid)
 107                 write_extent_buffer(eb, fs_info->new_fsid, btrfs_header_fsid(),
 108                                     BTRFS_FSID_SIZE);
 109         if (!same_chunk_tree_uuid)
 110                 write_extent_buffer(eb, fs_info->new_chunk_tree_uuid,
 111                                     btrfs_header_chunk_tree_uuid(eb),
 112                                     BTRFS_UUID_SIZE);
 113         ret = write_tree_block(NULL, root, eb);
 114
 115         return ret;
 116 }
 117
 118 static int change_extents_uuid(struct btrfs_fs_info *fs_info)
 119 {
 120         struct btrfs_root *root = fs_info->extent_root;
 121         struct btrfs_path *path;
 122         struct btrfs_key key = {0, 0, 0};
 123         int ret = 0;
 124
 125         path = btrfs_alloc_path();
 126         if (!path)
 127                 return -ENOMEM;
 128
 129         /*
 130          * Here we don't use transaction as it will takes a lot of reserve
 131          * space, and that will make a near-full btrfs unable to change uuid
 132          */
 133         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 134         if (ret < 0)
 135                 goto out;
 136
 137         while (1) {
 138                 struct btrfs_extent_item *ei;
 139                 struct extent_buffer *eb;
 140                 u64 flags;
 141                 u64 bytenr;
 142
 143                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
 144                 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
 145                     key.type != BTRFS_METADATA_ITEM_KEY)
 146                         goto next;
 147                 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
 148                                     struct btrfs_extent_item);
 149                 flags = btrfs_extent_flags(path->nodes[0], ei);
 150                 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
 151                         goto next;
 152
 153                 bytenr = key.objectid;
 154                 eb = read_tree_block(root, bytenr, root->nodesize, 0);
 155                 if (IS_ERR(eb)) {
 156                         error("failed to read tree block: %llu", bytenr);
 157                         ret = PTR_ERR(eb);
 158                         goto out;
 159                 }
 160                 ret = change_header_uuid(root, eb);
 161                 free_extent_buffer(eb);
 162                 if (ret < 0) {
 163                         error("failed to change uuid of tree block: %llu",
 164                                 bytenr);
 165                         goto out;
 166                 }
 167 next:
 168                 ret = btrfs_next_item(root, path);
 169                 if (ret < 0)
 170                         goto out;
 171                 if (ret > 0) {
 172                         ret = 0;
 173                         goto out;
 174                 }
 175         }
 176
 177 out:
 178         btrfs_free_path(path);
 179         return ret;
 180 }
 181
 182 static int change_device_uuid(struct btrfs_root *root, struct extent_buffer *eb,
 183                               int slot)
 184 {
 185         struct btrfs_fs_info *fs_info = root->fs_info;
 186         struct btrfs_dev_item *di;
 187         int ret = 0;
 188
 189         di = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
 190         if (!memcmp_extent_buffer(eb, fs_info->new_fsid,
 191                                   (unsigned long)btrfs_device_fsid(di),
 192                                   BTRFS_FSID_SIZE))
 193                 return ret;
 194
 195         write_extent_buffer(eb, fs_info->new_fsid,
 196                             (unsigned long)btrfs_device_fsid(di),
 197                             BTRFS_FSID_SIZE);
 198         ret = write_tree_block(NULL, root, eb);
 199
 200         return ret;
 201 }
 202
 203 static int change_devices_uuid(struct btrfs_fs_info *fs_info)
 204 {
 205         struct btrfs_root *root = fs_info->chunk_root;
 206         struct btrfs_path *path;
 207         struct btrfs_key key = {0, 0, 0};
 208         int ret = 0;
 209
 210         path = btrfs_alloc_path();
 211         if (!path)
 212                 return -ENOMEM;
 213         /* No transaction again */
 214         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 215         if (ret < 0)
 216                 goto out;
 217
 218         while (1) {
 219                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
 220                 if (key.type != BTRFS_DEV_ITEM_KEY ||
 221                     key.objectid != BTRFS_DEV_ITEMS_OBJECTID)
 222                         goto next;
 223                 ret = change_device_uuid(root, path->nodes[0], path->slots[0]);
 224                 if (ret < 0)
 225                         goto out;
 226 next:
 227                 ret = btrfs_next_item(root, path);
 228                 if (ret < 0)
 229                         goto out;
 230                 if (ret > 0) {
 231                         ret = 0;
 232                         goto out;
 233                 }
 234         }
 235 out:
 236         btrfs_free_path(path);
 237         return ret;
 238 }
 239
 240 static int change_fsid_prepare(struct btrfs_fs_info *fs_info)
 241 {
 242         struct btrfs_root *tree_root = fs_info->tree_root;
 243         u64 flags = btrfs_super_flags(fs_info->super_copy);
 244         int ret = 0;
 245
 246         flags |= BTRFS_SUPER_FLAG_CHANGING_FSID;
 247         btrfs_set_super_flags(fs_info->super_copy, flags);
 248
 249         memcpy(fs_info->super_copy->fsid, fs_info->new_fsid, BTRFS_FSID_SIZE);
 250         ret = write_all_supers(tree_root);
 251         if (ret < 0)
 252                 return ret;
 253
 254         /* also restore new chunk_tree_id into tree_root for restore */
 255         write_extent_buffer(tree_root->node, fs_info->new_chunk_tree_uuid,
 256                             btrfs_header_chunk_tree_uuid(tree_root->node),
 257                             BTRFS_UUID_SIZE);
 258         return write_tree_block(NULL, tree_root, tree_root->node);
 259 }
 260
 261 static int change_fsid_done(struct btrfs_fs_info *fs_info)
 262 {
 263         u64 flags = btrfs_super_flags(fs_info->super_copy);
 264
 265         flags &= ~BTRFS_SUPER_FLAG_CHANGING_FSID;
 266         btrfs_set_super_flags(fs_info->super_copy, flags);
 267
 268         return write_all_supers(fs_info->tree_root);
 269 }
 270
 271 /*
 272  * Return 0 for no unfinished fsid change.
 273  * Return >0 for unfinished fsid change, and restore unfinished fsid/
 274  * chunk_tree_id into fsid_ret/chunk_id_ret.
 275  */
 276 static int check_unfinished_fsid_change(struct btrfs_fs_info *fs_info,
 277                                         uuid_t fsid_ret, uuid_t chunk_id_ret)
 278 {
 279         struct btrfs_root *tree_root = fs_info->tree_root;
 280         u64 flags = btrfs_super_flags(fs_info->super_copy);
 281
 282         if (flags & BTRFS_SUPER_FLAG_CHANGING_FSID) {
 283                 memcpy(fsid_ret, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
 284                 read_extent_buffer(tree_root->node, chunk_id_ret,
 285                                 btrfs_header_chunk_tree_uuid(tree_root->node),
 286                                 BTRFS_UUID_SIZE);
 287                 return 1;
 288         }
 289         return 0;
 290 }
 291
 292 /*
 293  * Change fsid of a given fs.
 294  *
 295  * If new_fsid_str is not given, use a random generated UUID.
 296  * Caller should check new_fsid_str is valid
 297  */
 298 static int change_uuid(struct btrfs_fs_info *fs_info, const char *new_fsid_str)
 299 {
 300         uuid_t new_fsid;
 301         uuid_t new_chunk_id;
 302         uuid_t old_fsid;
 303         char uuid_buf[BTRFS_UUID_UNPARSED_SIZE];
 304         int ret = 0;
 305
 306         if (check_unfinished_fsid_change(fs_info, new_fsid, new_chunk_id)) {
 307                 if (new_fsid_str) {
 308                         uuid_t tmp;
 309
 310                         uuid_parse(new_fsid_str, tmp);
 311                         if (memcmp(tmp, new_fsid, BTRFS_FSID_SIZE)) {
 312                                 error(
 313                 "new fsid %s is not the same with unfinished fsid change",
 314                                         new_fsid_str);
 315                                 return -EINVAL;
 316                         }
 317                 }
 318         } else {
 319                 if (new_fsid_str)
 320                         uuid_parse(new_fsid_str, new_fsid);
 321                 else
 322                         uuid_generate(new_fsid);
 323
 324                 uuid_generate(new_chunk_id);
 325         }
 326         fs_info->new_fsid = new_fsid;
 327         fs_info->new_chunk_tree_uuid = new_chunk_id;
 328
 329         memcpy(old_fsid, (const char*)fs_info->fsid, BTRFS_UUID_SIZE);
 330         uuid_unparse(old_fsid, uuid_buf);
 331         printf("Current fsid: %s\n", uuid_buf);
 332
 333         uuid_unparse(new_fsid, uuid_buf);
 334         printf("New fsid: %s\n", uuid_buf);
 335         /* Now we can begin fsid change */
 336         printf("Set superblock flag CHANGING_FSID\n");
 337         ret = change_fsid_prepare(fs_info);
 338         if (ret < 0)
 339                 goto out;
 340
 341         /* Change extents first */
 342         printf("Change fsid in extents\n");
 343         ret = change_extents_uuid(fs_info);
 344         if (ret < 0) {
 345                 error("failed to change UUID of metadata: %d", ret);
 346                 goto out;
 347         }
 348
 349         /* Then devices */
 350         printf("Change fsid on devices\n");
 351         ret = change_devices_uuid(fs_info);
 352         if (ret < 0) {
 353                 error("failed to change UUID of devices: %d", ret);
 354                 goto out;
 355         }
 356
 357         /* Last, change fsid in super */
 358         memcpy(fs_info->fs_devices->fsid, fs_info->new_fsid,
 359                BTRFS_FSID_SIZE);
 360         memcpy(fs_info->super_copy->fsid, fs_info->new_fsid,
 361                BTRFS_FSID_SIZE);
 362         ret = write_all_supers(fs_info->tree_root);
 363         if (ret < 0)
 364                 goto out;
 365
 366         /* Now fsid change is done */
 367         printf("Clear superblock flag CHANGING_FSID\n");
 368         ret = change_fsid_done(fs_info);
 369         fs_info->new_fsid = NULL;
 370         fs_info->new_chunk_tree_uuid = NULL;
 371         printf("Fsid change finished\n");
 372 out:
 373         return ret;
 374 }
 375
 376 static void print_usage(void)
 377 {
 378         printf("usage: btrfstune [options] device\n");
 379         printf("\t-S value\tpositive value will enable seeding, zero to disable, negative is not allowed\n");
 380         printf("\t-r \t\tenable extended inode refs\n");
 381         printf("\t-x \t\tenable skinny metadata extent refs\n");
 382         printf("\t-n \t\tenable no-holes feature (more efficient sparse file representation)\n");
 383         printf("\t-f \t\tforce to do dangerous operation, make sure that you are aware of the dangers\n");
 384         printf("\t-u \t\tchange fsid, use a random one\n");
 385         printf("\t-U UUID\t\tchange fsid to UUID\n");
 386 }
 387
 388 int main(int argc, char *argv[])
 389 {
 390         struct btrfs_root *root;
 391         unsigned ctree_flags = OPEN_CTREE_WRITES;
 392         int success = 0;
 393         int total = 0;
 394         int seeding_flag = 0;
 395         u64 seeding_value = 0;
 396         int random_fsid = 0;
 397         char *new_fsid_str = NULL;
 398         int ret;
 399         u64 super_flags = 0;
 400
 401         while(1) {
 402                 static const struct option long_options[] = {
 403                         { "help", no_argument, NULL, GETOPT_VAL_HELP},
 404                         { NULL, 0, NULL, 0 }
 405                 };
 406                 int c = getopt_long(argc, argv, "S:rxfuU:n", long_options, NULL);
 407
 408                 if (c < 0)
 409                         break;
 410                 switch(c) {
 411                 case 'S':
 412                         seeding_flag = 1;
 413                         seeding_value = arg_strtou64(optarg);
 414                         break;
 415                 case 'r':
 416                         super_flags |= BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF;
 417                         break;
 418                 case 'x':
 419                         super_flags |= BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA;
 420                         break;
 421                 case 'n':
 422                         super_flags |= BTRFS_FEATURE_INCOMPAT_NO_HOLES;
 423                         break;
 424                 case 'f':
 425                         force = 1;
 426                         break;
 427                 case 'U':
 428                         ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH;
 429                         new_fsid_str = optarg;
 430                         break;
 431                 case 'u':
 432                         ctree_flags |= OPEN_CTREE_IGNORE_FSID_MISMATCH;
 433                         random_fsid = 1;
 434                         break;
 435                 case GETOPT_VAL_HELP:
 436                 default:
 437                         print_usage();
 438                         return c != GETOPT_VAL_HELP;
 439                 }
 440         }
 441
 442         set_argv0(argv);
 443         device = argv[optind];
 444         if (check_argc_exact(argc - optind, 1)) {
 445                 print_usage();
 446                 return 1;
 447         }
 448
 449         if (random_fsid && new_fsid_str) {
 450                 error("random fsid can't be used with specified fsid");
 451                 return 1;
 452         }
 453         if (!super_flags && !seeding_flag && !(random_fsid || new_fsid_str)) {
 454                 error("at least one option should be specified");
 455                 print_usage();
 456                 return 1;
 457         }
 458
 459         if (new_fsid_str) {
 460                 uuid_t tmp;
 461
 462                 ret = uuid_parse(new_fsid_str, tmp);
 463                 if (ret < 0) {
 464                         error("could not parse UUID: %s", new_fsid_str);
 465                         return 1;
 466                 }
 467                 if (!test_uuid_unique(new_fsid_str)) {
 468                         error("fsid %s is not unique", new_fsid_str);
 469                         return 1;
 470                 }
 471         }
 472
 473         ret = check_mounted(device);
 474         if (ret < 0) {
 475                 error("could not check mount status of %s: %s", device,
 476                         strerror(-ret));
 477                 return 1;
 478         } else if (ret) {
 479                 error("%s is mounted", device);
 480                 return 1;
 481         }
 482
 483         root = open_ctree(device, 0, ctree_flags);
 484
 485         if (!root) {
 486                 error("open ctree failed");
 487                 return 1;
 488         }
 489
 490         if (seeding_flag) {
 491                 if (!seeding_value && !force) {
 492                         warning(
 493 "this is dangerous, clearing the seeding flag may cause the derived device not to be mountable!");
 494                         ret = ask_user("We are going to clear the seeding flag, are you sure?");
 495                         if (!ret) {
 496                                 fprintf(stderr, "Clear seeding flag canceled\n");
 497                                 ret = 1;
 498                                 goto out;
 499                         }
 500                 }
 501
 502                 ret = update_seeding_flag(root, seeding_value);
 503                 if (!ret)
 504                         success++;
 505                 total++;
 506         }
 507
 508         if (super_flags) {
 509                 ret = set_super_incompat_flags(root, super_flags);
 510                 if (!ret)
 511                         success++;
 512                 total++;
 513         }
 514
 515         if (random_fsid || new_fsid_str) {
 516                 if (!force) {
 517                         warning(
 518         "it's highly recommended to run 'btrfs check' before this operation");
 519                         warning(
 520         "also canceling running UUID change progress may cause corruption");
 521                         ret = ask_user("We are going to change UUID, are your sure?");
 522                         if (!ret) {
 523                                 fprintf(stderr, "UUID change canceled\n");
 524                                 ret = 1;
 525                                 goto out;
 526                         }
 527                 }
 528                 ret = change_uuid(root->fs_info, new_fsid_str);
 529                 if (!ret)
 530                         success++;
 531                 total++;
 532         }
 533
 534         if (success == total) {
 535                 ret = 0;
 536         } else {
 537                 root->fs_info->readonly = 1;
 538                 ret = 1;
 539                 error("btrfstune failed");
 540         }
 541 out:
 542         close_ctree(root);
 543         btrfs_close_all_devices();
 544
 545         return ret;
 546 }