1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2007 Oracle. All rights reserved. 4 */ 5 6 #include <linux/sched.h> 7 #include <linux/sched/mm.h> 8 #include <linux/bio.h> 9 #include <linux/slab.h> 10 #include <linux/blkdev.h> 11 #include <linux/ratelimit.h> 12 #include <linux/kthread.h> 13 #include <linux/raid/pq.h> 14 #include <linux/semaphore.h> 15 #include <linux/uuid.h> 16 #include <linux/list_sort.h> 17 #include <linux/namei.h> 18 #include "misc.h" 19 #include "ctree.h" 20 #include "extent_map.h" 21 #include "disk-io.h" 22 #include "transaction.h" 23 #include "print-tree.h" 24 #include "volumes.h" 25 #include "raid56.h" 26 #include "async-thread.h" 27 #include "check-integrity.h" 28 #include "rcu-string.h" 29 #include "dev-replace.h" 30 #include "sysfs.h" 31 #include "tree-checker.h" 32 #include "space-info.h" 33 #include "block-group.h" 34 #include "discard.h" 35 #include "zoned.h" 36 37 #define BTRFS_BLOCK_GROUP_STRIPE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \ 38 BTRFS_BLOCK_GROUP_RAID10 | \ 39 BTRFS_BLOCK_GROUP_RAID56_MASK) 40 41 const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = { 42 [BTRFS_RAID_RAID10] = { 43 .sub_stripes = 2, 44 .dev_stripes = 1, 45 .devs_max = 0, /* 0 == as many as possible */ 46 .devs_min = 2, 47 .tolerated_failures = 1, 48 .devs_increment = 2, 49 .ncopies = 2, 50 .nparity = 0, 51 .raid_name = "raid10", 52 .bg_flag = BTRFS_BLOCK_GROUP_RAID10, 53 .mindev_error = BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET, 54 }, 55 [BTRFS_RAID_RAID1] = { 56 .sub_stripes = 1, 57 .dev_stripes = 1, 58 .devs_max = 2, 59 .devs_min = 2, 60 .tolerated_failures = 1, 61 .devs_increment = 2, 62 .ncopies = 2, 63 .nparity = 0, 64 .raid_name = "raid1", 65 .bg_flag = BTRFS_BLOCK_GROUP_RAID1, 66 .mindev_error = BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET, 67 }, 68 [BTRFS_RAID_RAID1C3] = { 69 .sub_stripes = 1, 70 .dev_stripes = 1, 71 .devs_max = 3, 72 .devs_min = 3, 73 .tolerated_failures = 2, 74 .devs_increment = 3, 75 .ncopies = 3, 76 .nparity = 0, 77 .raid_name = "raid1c3", 78 .bg_flag = BTRFS_BLOCK_GROUP_RAID1C3, 79 .mindev_error = BTRFS_ERROR_DEV_RAID1C3_MIN_NOT_MET, 80 }, 81 [BTRFS_RAID_RAID1C4] = { 82 .sub_stripes = 1, 83 .dev_stripes = 1, 84 .devs_max = 4, 85 .devs_min = 4, 86 .tolerated_failures = 3, 87 .devs_increment = 4, 88 .ncopies = 4, 89 .nparity = 0, 90 .raid_name = "raid1c4", 91 .bg_flag = BTRFS_BLOCK_GROUP_RAID1C4, 92 .mindev_error = BTRFS_ERROR_DEV_RAID1C4_MIN_NOT_MET, 93 }, 94 [BTRFS_RAID_DUP] = { 95 .sub_stripes = 1, 96 .dev_stripes = 2, 97 .devs_max = 1, 98 .devs_min = 1, 99 .tolerated_failures = 0, 100 .devs_increment = 1, 101 .ncopies = 2, 102 .nparity = 0, 103 .raid_name = "dup", 104 .bg_flag = BTRFS_BLOCK_GROUP_DUP, 105 .mindev_error = 0, 106 }, 107 [BTRFS_RAID_RAID0] = { 108 .sub_stripes = 1, 109 .dev_stripes = 1, 110 .devs_max = 0, 111 .devs_min = 1, 112 .tolerated_failures = 0, 113 .devs_increment = 1, 114 .ncopies = 1, 115 .nparity = 0, 116 .raid_name = "raid0", 117 .bg_flag = BTRFS_BLOCK_GROUP_RAID0, 118 .mindev_error = 0, 119 }, 120 [BTRFS_RAID_SINGLE] = { 121 .sub_stripes = 1, 122 .dev_stripes = 1, 123 .devs_max = 1, 124 .devs_min = 1, 125 .tolerated_failures = 0, 126 .devs_increment = 1, 127 .ncopies = 1, 128 .nparity = 0, 129 .raid_name = "single", 130 .bg_flag = 0, 131 .mindev_error = 0, 132 }, 133 [BTRFS_RAID_RAID5] = { 134 .sub_stripes = 1, 135 .dev_stripes = 1, 136 .devs_max = 0, 137 .devs_min = 2, 138 .tolerated_failures = 1, 139 .devs_increment = 1, 140 .ncopies = 1, 141 .nparity = 1, 142 .raid_name = "raid5", 143 .bg_flag = BTRFS_BLOCK_GROUP_RAID5, 144 .mindev_error = BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET, 145 }, 146 [BTRFS_RAID_RAID6] = { 147 .sub_stripes = 1, 148 .dev_stripes = 1, 149 .devs_max = 0, 150 .devs_min = 3, 151 .tolerated_failures = 2, 152 .devs_increment = 1, 153 .ncopies = 1, 154 .nparity = 2, 155 .raid_name = "raid6", 156 .bg_flag = BTRFS_BLOCK_GROUP_RAID6, 157 .mindev_error = BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET, 158 }, 159 }; 160 161 /* 162 * Convert block group flags (BTRFS_BLOCK_GROUP_*) to btrfs_raid_types, which 163 * can be used as index to access btrfs_raid_array[]. 164 */ 165 enum btrfs_raid_types __attribute_const__ btrfs_bg_flags_to_raid_index(u64 flags) 166 { 167 if (flags & BTRFS_BLOCK_GROUP_RAID10) 168 return BTRFS_RAID_RAID10; 169 else if (flags & BTRFS_BLOCK_GROUP_RAID1) 170 return BTRFS_RAID_RAID1; 171 else if (flags & BTRFS_BLOCK_GROUP_RAID1C3) 172 return BTRFS_RAID_RAID1C3; 173 else if (flags & BTRFS_BLOCK_GROUP_RAID1C4) 174 return BTRFS_RAID_RAID1C4; 175 else if (flags & BTRFS_BLOCK_GROUP_DUP) 176 return BTRFS_RAID_DUP; 177 else if (flags & BTRFS_BLOCK_GROUP_RAID0) 178 return BTRFS_RAID_RAID0; 179 else if (flags & BTRFS_BLOCK_GROUP_RAID5) 180 return BTRFS_RAID_RAID5; 181 else if (flags & BTRFS_BLOCK_GROUP_RAID6) 182 return BTRFS_RAID_RAID6; 183 184 return BTRFS_RAID_SINGLE; /* BTRFS_BLOCK_GROUP_SINGLE */ 185 } 186 187 const char *btrfs_bg_type_to_raid_name(u64 flags) 188 { 189 const int index = btrfs_bg_flags_to_raid_index(flags); 190 191 if (index >= BTRFS_NR_RAID_TYPES) 192 return NULL; 193 194 return btrfs_raid_array[index].raid_name; 195 } 196 197 /* 198 * Fill @buf with textual description of @bg_flags, no more than @size_buf 199 * bytes including terminating null byte. 200 */ 201 void btrfs_describe_block_groups(u64 bg_flags, char *buf, u32 size_buf) 202 { 203 int i; 204 int ret; 205 char *bp = buf; 206 u64 flags = bg_flags; 207 u32 size_bp = size_buf; 208 209 if (!flags) { 210 strcpy(bp, "NONE"); 211 return; 212 } 213 214 #define DESCRIBE_FLAG(flag, desc) \ 215 do { \ 216 if (flags & (flag)) { \ 217 ret = snprintf(bp, size_bp, "%s|", (desc)); \ 218 if (ret < 0 || ret >= size_bp) \ 219 goto out_overflow; \ 220 size_bp -= ret; \ 221 bp += ret; \ 222 flags &= ~(flag); \ 223 } \ 224 } while (0) 225 226 DESCRIBE_FLAG(BTRFS_BLOCK_GROUP_DATA, "data"); 227 DESCRIBE_FLAG(BTRFS_BLOCK_GROUP_SYSTEM, "system"); 228 DESCRIBE_FLAG(BTRFS_BLOCK_GROUP_METADATA, "metadata"); 229 230 DESCRIBE_FLAG(BTRFS_AVAIL_ALLOC_BIT_SINGLE, "single"); 231 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) 232 DESCRIBE_FLAG(btrfs_raid_array[i].bg_flag, 233 btrfs_raid_array[i].raid_name); 234 #undef DESCRIBE_FLAG 235 236 if (flags) { 237 ret = snprintf(bp, size_bp, "0x%llx|", flags); 238 size_bp -= ret; 239 } 240 241 if (size_bp < size_buf) 242 buf[size_buf - size_bp - 1] = '\0'; /* remove last | */ 243 244 /* 245 * The text is trimmed, it's up to the caller to provide sufficiently 246 * large buffer 247 */ 248 out_overflow:; 249 } 250 251 static int init_first_rw_device(struct btrfs_trans_handle *trans); 252 static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info); 253 static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev); 254 static void btrfs_dev_stat_print_on_load(struct btrfs_device *device); 255 static int __btrfs_map_block(struct btrfs_fs_info *fs_info, 256 enum btrfs_map_op op, 257 u64 logical, u64 *length, 258 struct btrfs_io_context **bioc_ret, 259 int mirror_num, int need_raid_map); 260 261 /* 262 * Device locking 263 * ============== 264 * 265 * There are several mutexes that protect manipulation of devices and low-level 266 * structures like chunks but not block groups, extents or files 267 * 268 * uuid_mutex (global lock) 269 * ------------------------ 270 * protects the fs_uuids list that tracks all per-fs fs_devices, resulting from 271 * the SCAN_DEV ioctl registration or from mount either implicitly (the first 272 * device) or requested by the device= mount option 273 * 274 * the mutex can be very coarse and can cover long-running operations 275 * 276 * protects: updates to fs_devices counters like missing devices, rw devices, 277 * seeding, structure cloning, opening/closing devices at mount/umount time 278 * 279 * global::fs_devs - add, remove, updates to the global list 280 * 281 * does not protect: manipulation of the fs_devices::devices list in general 282 * but in mount context it could be used to exclude list modifications by eg. 283 * scan ioctl 284 * 285 * btrfs_device::name - renames (write side), read is RCU 286 * 287 * fs_devices::device_list_mutex (per-fs, with RCU) 288 * ------------------------------------------------ 289 * protects updates to fs_devices::devices, ie. adding and deleting 290 * 291 * simple list traversal with read-only actions can be done with RCU protection 292 * 293 * may be used to exclude some operations from running concurrently without any 294 * modifications to the list (see write_all_supers) 295 * 296 * Is not required at mount and close times, because our device list is 297 * protected by the uuid_mutex at that point. 298 * 299 * balance_mutex 300 * ------------- 301 * protects balance structures (status, state) and context accessed from 302 * several places (internally, ioctl) 303 * 304 * chunk_mutex 305 * ----------- 306 * protects chunks, adding or removing during allocation, trim or when a new 307 * device is added/removed. Additionally it also protects post_commit_list of 308 * individual devices, since they can be added to the transaction's 309 * post_commit_list only with chunk_mutex held. 310 * 311 * cleaner_mutex 312 * ------------- 313 * a big lock that is held by the cleaner thread and prevents running subvolume 314 * cleaning together with relocation or delayed iputs 315 * 316 * 317 * Lock nesting 318 * ============ 319 * 320 * uuid_mutex 321 * device_list_mutex 322 * chunk_mutex 323 * balance_mutex 324 * 325 * 326 * Exclusive operations 327 * ==================== 328 * 329 * Maintains the exclusivity of the following operations that apply to the 330 * whole filesystem and cannot run in parallel. 331 * 332 * - Balance (*) 333 * - Device add 334 * - Device remove 335 * - Device replace (*) 336 * - Resize 337 * 338 * The device operations (as above) can be in one of the following states: 339 * 340 * - Running state 341 * - Paused state 342 * - Completed state 343 * 344 * Only device operations marked with (*) can go into the Paused state for the 345 * following reasons: 346 * 347 * - ioctl (only Balance can be Paused through ioctl) 348 * - filesystem remounted as read-only 349 * - filesystem unmounted and mounted as read-only 350 * - system power-cycle and filesystem mounted as read-only 351 * - filesystem or device errors leading to forced read-only 352 * 353 * The status of exclusive operation is set and cleared atomically. 354 * During the course of Paused state, fs_info::exclusive_operation remains set. 355 * A device operation in Paused or Running state can be canceled or resumed 356 * either by ioctl (Balance only) or when remounted as read-write. 357 * The exclusive status is cleared when the device operation is canceled or 358 * completed. 359 */ 360 361 DEFINE_MUTEX(uuid_mutex); 362 static LIST_HEAD(fs_uuids); 363 struct list_head * __attribute_const__ btrfs_get_fs_uuids(void) 364 { 365 return &fs_uuids; 366 } 367 368 /* 369 * alloc_fs_devices - allocate struct btrfs_fs_devices 370 * @fsid: if not NULL, copy the UUID to fs_devices::fsid 371 * @metadata_fsid: if not NULL, copy the UUID to fs_devices::metadata_fsid 372 * 373 * Return a pointer to a new struct btrfs_fs_devices on success, or ERR_PTR(). 374 * The returned struct is not linked onto any lists and can be destroyed with 375 * kfree() right away. 376 */ 377 static struct btrfs_fs_devices *alloc_fs_devices(const u8 *fsid, 378 const u8 *metadata_fsid) 379 { 380 struct btrfs_fs_devices *fs_devs; 381 382 fs_devs = kzalloc(sizeof(*fs_devs), GFP_KERNEL); 383 if (!fs_devs) 384 return ERR_PTR(-ENOMEM); 385 386 mutex_init(&fs_devs->device_list_mutex); 387 388 INIT_LIST_HEAD(&fs_devs->devices); 389 INIT_LIST_HEAD(&fs_devs->alloc_list); 390 INIT_LIST_HEAD(&fs_devs->fs_list); 391 INIT_LIST_HEAD(&fs_devs->seed_list); 392 if (fsid) 393 memcpy(fs_devs->fsid, fsid, BTRFS_FSID_SIZE); 394 395 if (metadata_fsid) 396 memcpy(fs_devs->metadata_uuid, metadata_fsid, BTRFS_FSID_SIZE); 397 else if (fsid) 398 memcpy(fs_devs->metadata_uuid, fsid, BTRFS_FSID_SIZE); 399 400 return fs_devs; 401 } 402 403 void btrfs_free_device(struct btrfs_device *device) 404 { 405 WARN_ON(!list_empty(&device->post_commit_list)); 406 rcu_string_free(device->name); 407 extent_io_tree_release(&device->alloc_state); 408 bio_put(device->flush_bio); 409 btrfs_destroy_dev_zone_info(device); 410 kfree(device); 411 } 412 413 static void free_fs_devices(struct btrfs_fs_devices *fs_devices) 414 { 415 struct btrfs_device *device; 416 WARN_ON(fs_devices->opened); 417 while (!list_empty(&fs_devices->devices)) { 418 device = list_entry(fs_devices->devices.next, 419 struct btrfs_device, dev_list); 420 list_del(&device->dev_list); 421 btrfs_free_device(device); 422 } 423 kfree(fs_devices); 424 } 425 426 void __exit btrfs_cleanup_fs_uuids(void) 427 { 428 struct btrfs_fs_devices *fs_devices; 429 430 while (!list_empty(&fs_uuids)) { 431 fs_devices = list_entry(fs_uuids.next, 432 struct btrfs_fs_devices, fs_list); 433 list_del(&fs_devices->fs_list); 434 free_fs_devices(fs_devices); 435 } 436 } 437 438 static noinline struct btrfs_fs_devices *find_fsid( 439 const u8 *fsid, const u8 *metadata_fsid) 440 { 441 struct btrfs_fs_devices *fs_devices; 442 443 ASSERT(fsid); 444 445 /* Handle non-split brain cases */ 446 list_for_each_entry(fs_devices, &fs_uuids, fs_list) { 447 if (metadata_fsid) { 448 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0 449 && memcmp(metadata_fsid, fs_devices->metadata_uuid, 450 BTRFS_FSID_SIZE) == 0) 451 return fs_devices; 452 } else { 453 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0) 454 return fs_devices; 455 } 456 } 457 return NULL; 458 } 459 460 static struct btrfs_fs_devices *find_fsid_with_metadata_uuid( 461 struct btrfs_super_block *disk_super) 462 { 463 464 struct btrfs_fs_devices *fs_devices; 465 466 /* 467 * Handle scanned device having completed its fsid change but 468 * belonging to a fs_devices that was created by first scanning 469 * a device which didn't have its fsid/metadata_uuid changed 470 * at all and the CHANGING_FSID_V2 flag set. 471 */ 472 list_for_each_entry(fs_devices, &fs_uuids, fs_list) { 473 if (fs_devices->fsid_change && 474 memcmp(disk_super->metadata_uuid, fs_devices->fsid, 475 BTRFS_FSID_SIZE) == 0 && 476 memcmp(fs_devices->fsid, fs_devices->metadata_uuid, 477 BTRFS_FSID_SIZE) == 0) { 478 return fs_devices; 479 } 480 } 481 /* 482 * Handle scanned device having completed its fsid change but 483 * belonging to a fs_devices that was created by a device that 484 * has an outdated pair of fsid/metadata_uuid and 485 * CHANGING_FSID_V2 flag set. 486 */ 487 list_for_each_entry(fs_devices, &fs_uuids, fs_list) { 488 if (fs_devices->fsid_change && 489 memcmp(fs_devices->metadata_uuid, 490 fs_devices->fsid, BTRFS_FSID_SIZE) != 0 && 491 memcmp(disk_super->metadata_uuid, fs_devices->metadata_uuid, 492 BTRFS_FSID_SIZE) == 0) { 493 return fs_devices; 494 } 495 } 496 497 return find_fsid(disk_super->fsid, disk_super->metadata_uuid); 498 } 499 500 501 static int 502 btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder, 503 int flush, struct block_device **bdev, 504 struct btrfs_super_block **disk_super) 505 { 506 int ret; 507 508 *bdev = blkdev_get_by_path(device_path, flags, holder); 509 510 if (IS_ERR(*bdev)) { 511 ret = PTR_ERR(*bdev); 512 goto error; 513 } 514 515 if (flush) 516 sync_blockdev(*bdev); 517 ret = set_blocksize(*bdev, BTRFS_BDEV_BLOCKSIZE); 518 if (ret) { 519 blkdev_put(*bdev, flags); 520 goto error; 521 } 522 invalidate_bdev(*bdev); 523 *disk_super = btrfs_read_dev_super(*bdev); 524 if (IS_ERR(*disk_super)) { 525 ret = PTR_ERR(*disk_super); 526 blkdev_put(*bdev, flags); 527 goto error; 528 } 529 530 return 0; 531 532 error: 533 *bdev = NULL; 534 return ret; 535 } 536 537 /** 538 * Search and remove all stale devices (which are not mounted). 539 * When both inputs are NULL, it will search and release all stale devices. 540 * 541 * @devt: Optional. When provided will it release all unmounted devices 542 * matching this devt only. 543 * @skip_device: Optional. Will skip this device when searching for the stale 544 * devices. 545 * 546 * Return: 0 for success or if @devt is 0. 547 * -EBUSY if @devt is a mounted device. 548 * -ENOENT if @devt does not match any device in the list. 549 */ 550 static int btrfs_free_stale_devices(dev_t devt, struct btrfs_device *skip_device) 551 { 552 struct btrfs_fs_devices *fs_devices, *tmp_fs_devices; 553 struct btrfs_device *device, *tmp_device; 554 int ret = 0; 555 556 lockdep_assert_held(&uuid_mutex); 557 558 if (devt) 559 ret = -ENOENT; 560 561 list_for_each_entry_safe(fs_devices, tmp_fs_devices, &fs_uuids, fs_list) { 562 563 mutex_lock(&fs_devices->device_list_mutex); 564 list_for_each_entry_safe(device, tmp_device, 565 &fs_devices->devices, dev_list) { 566 if (skip_device && skip_device == device) 567 continue; 568 if (devt && devt != device->devt) 569 continue; 570 if (fs_devices->opened) { 571 /* for an already deleted device return 0 */ 572 if (devt && ret != 0) 573 ret = -EBUSY; 574 break; 575 } 576 577 /* delete the stale device */ 578 fs_devices->num_devices--; 579 list_del(&device->dev_list); 580 btrfs_free_device(device); 581 582 ret = 0; 583 } 584 mutex_unlock(&fs_devices->device_list_mutex); 585 586 if (fs_devices->num_devices == 0) { 587 btrfs_sysfs_remove_fsid(fs_devices); 588 list_del(&fs_devices->fs_list); 589 free_fs_devices(fs_devices); 590 } 591 } 592 593 return ret; 594 } 595 596 /* 597 * This is only used on mount, and we are protected from competing things 598 * messing with our fs_devices by the uuid_mutex, thus we do not need the 599 * fs_devices->device_list_mutex here. 600 */ 601 static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices, 602 struct btrfs_device *device, fmode_t flags, 603 void *holder) 604 { 605 struct block_device *bdev; 606 struct btrfs_super_block *disk_super; 607 u64 devid; 608 int ret; 609 610 if (device->bdev) 611 return -EINVAL; 612 if (!device->name) 613 return -EINVAL; 614 615 ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1, 616 &bdev, &disk_super); 617 if (ret) 618 return ret; 619 620 devid = btrfs_stack_device_id(&disk_super->dev_item); 621 if (devid != device->devid) 622 goto error_free_page; 623 624 if (memcmp(device->uuid, disk_super->dev_item.uuid, BTRFS_UUID_SIZE)) 625 goto error_free_page; 626 627 device->generation = btrfs_super_generation(disk_super); 628 629 if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) { 630 if (btrfs_super_incompat_flags(disk_super) & 631 BTRFS_FEATURE_INCOMPAT_METADATA_UUID) { 632 pr_err( 633 "BTRFS: Invalid seeding and uuid-changed device detected\n"); 634 goto error_free_page; 635 } 636 637 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 638 fs_devices->seeding = true; 639 } else { 640 if (bdev_read_only(bdev)) 641 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 642 else 643 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 644 } 645 646 if (!blk_queue_nonrot(bdev_get_queue(bdev))) 647 fs_devices->rotating = true; 648 649 device->bdev = bdev; 650 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 651 device->mode = flags; 652 653 fs_devices->open_devices++; 654 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && 655 device->devid != BTRFS_DEV_REPLACE_DEVID) { 656 fs_devices->rw_devices++; 657 list_add_tail(&device->dev_alloc_list, &fs_devices->alloc_list); 658 } 659 btrfs_release_disk_super(disk_super); 660 661 return 0; 662 663 error_free_page: 664 btrfs_release_disk_super(disk_super); 665 blkdev_put(bdev, flags); 666 667 return -EINVAL; 668 } 669 670 /* 671 * Handle scanned device having its CHANGING_FSID_V2 flag set and the fs_devices 672 * being created with a disk that has already completed its fsid change. Such 673 * disk can belong to an fs which has its FSID changed or to one which doesn't. 674 * Handle both cases here. 675 */ 676 static struct btrfs_fs_devices *find_fsid_inprogress( 677 struct btrfs_super_block *disk_super) 678 { 679 struct btrfs_fs_devices *fs_devices; 680 681 list_for_each_entry(fs_devices, &fs_uuids, fs_list) { 682 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, 683 BTRFS_FSID_SIZE) != 0 && 684 memcmp(fs_devices->metadata_uuid, disk_super->fsid, 685 BTRFS_FSID_SIZE) == 0 && !fs_devices->fsid_change) { 686 return fs_devices; 687 } 688 } 689 690 return find_fsid(disk_super->fsid, NULL); 691 } 692 693 694 static struct btrfs_fs_devices *find_fsid_changed( 695 struct btrfs_super_block *disk_super) 696 { 697 struct btrfs_fs_devices *fs_devices; 698 699 /* 700 * Handles the case where scanned device is part of an fs that had 701 * multiple successful changes of FSID but currently device didn't 702 * observe it. Meaning our fsid will be different than theirs. We need 703 * to handle two subcases : 704 * 1 - The fs still continues to have different METADATA/FSID uuids. 705 * 2 - The fs is switched back to its original FSID (METADATA/FSID 706 * are equal). 707 */ 708 list_for_each_entry(fs_devices, &fs_uuids, fs_list) { 709 /* Changed UUIDs */ 710 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, 711 BTRFS_FSID_SIZE) != 0 && 712 memcmp(fs_devices->metadata_uuid, disk_super->metadata_uuid, 713 BTRFS_FSID_SIZE) == 0 && 714 memcmp(fs_devices->fsid, disk_super->fsid, 715 BTRFS_FSID_SIZE) != 0) 716 return fs_devices; 717 718 /* Unchanged UUIDs */ 719 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, 720 BTRFS_FSID_SIZE) == 0 && 721 memcmp(fs_devices->fsid, disk_super->metadata_uuid, 722 BTRFS_FSID_SIZE) == 0) 723 return fs_devices; 724 } 725 726 return NULL; 727 } 728 729 static struct btrfs_fs_devices *find_fsid_reverted_metadata( 730 struct btrfs_super_block *disk_super) 731 { 732 struct btrfs_fs_devices *fs_devices; 733 734 /* 735 * Handle the case where the scanned device is part of an fs whose last 736 * metadata UUID change reverted it to the original FSID. At the same 737 * time * fs_devices was first created by another constitutent device 738 * which didn't fully observe the operation. This results in an 739 * btrfs_fs_devices created with metadata/fsid different AND 740 * btrfs_fs_devices::fsid_change set AND the metadata_uuid of the 741 * fs_devices equal to the FSID of the disk. 742 */ 743 list_for_each_entry(fs_devices, &fs_uuids, fs_list) { 744 if (memcmp(fs_devices->fsid, fs_devices->metadata_uuid, 745 BTRFS_FSID_SIZE) != 0 && 746 memcmp(fs_devices->metadata_uuid, disk_super->fsid, 747 BTRFS_FSID_SIZE) == 0 && 748 fs_devices->fsid_change) 749 return fs_devices; 750 } 751 752 return NULL; 753 } 754 /* 755 * Add new device to list of registered devices 756 * 757 * Returns: 758 * device pointer which was just added or updated when successful 759 * error pointer when failed 760 */ 761 static noinline struct btrfs_device *device_list_add(const char *path, 762 struct btrfs_super_block *disk_super, 763 bool *new_device_added) 764 { 765 struct btrfs_device *device; 766 struct btrfs_fs_devices *fs_devices = NULL; 767 struct rcu_string *name; 768 u64 found_transid = btrfs_super_generation(disk_super); 769 u64 devid = btrfs_stack_device_id(&disk_super->dev_item); 770 dev_t path_devt; 771 int error; 772 bool has_metadata_uuid = (btrfs_super_incompat_flags(disk_super) & 773 BTRFS_FEATURE_INCOMPAT_METADATA_UUID); 774 bool fsid_change_in_progress = (btrfs_super_flags(disk_super) & 775 BTRFS_SUPER_FLAG_CHANGING_FSID_V2); 776 777 error = lookup_bdev(path, &path_devt); 778 if (error) 779 return ERR_PTR(error); 780 781 if (fsid_change_in_progress) { 782 if (!has_metadata_uuid) 783 fs_devices = find_fsid_inprogress(disk_super); 784 else 785 fs_devices = find_fsid_changed(disk_super); 786 } else if (has_metadata_uuid) { 787 fs_devices = find_fsid_with_metadata_uuid(disk_super); 788 } else { 789 fs_devices = find_fsid_reverted_metadata(disk_super); 790 if (!fs_devices) 791 fs_devices = find_fsid(disk_super->fsid, NULL); 792 } 793 794 795 if (!fs_devices) { 796 if (has_metadata_uuid) 797 fs_devices = alloc_fs_devices(disk_super->fsid, 798 disk_super->metadata_uuid); 799 else 800 fs_devices = alloc_fs_devices(disk_super->fsid, NULL); 801 802 if (IS_ERR(fs_devices)) 803 return ERR_CAST(fs_devices); 804 805 fs_devices->fsid_change = fsid_change_in_progress; 806 807 mutex_lock(&fs_devices->device_list_mutex); 808 list_add(&fs_devices->fs_list, &fs_uuids); 809 810 device = NULL; 811 } else { 812 struct btrfs_dev_lookup_args args = { 813 .devid = devid, 814 .uuid = disk_super->dev_item.uuid, 815 }; 816 817 mutex_lock(&fs_devices->device_list_mutex); 818 device = btrfs_find_device(fs_devices, &args); 819 820 /* 821 * If this disk has been pulled into an fs devices created by 822 * a device which had the CHANGING_FSID_V2 flag then replace the 823 * metadata_uuid/fsid values of the fs_devices. 824 */ 825 if (fs_devices->fsid_change && 826 found_transid > fs_devices->latest_generation) { 827 memcpy(fs_devices->fsid, disk_super->fsid, 828 BTRFS_FSID_SIZE); 829 830 if (has_metadata_uuid) 831 memcpy(fs_devices->metadata_uuid, 832 disk_super->metadata_uuid, 833 BTRFS_FSID_SIZE); 834 else 835 memcpy(fs_devices->metadata_uuid, 836 disk_super->fsid, BTRFS_FSID_SIZE); 837 838 fs_devices->fsid_change = false; 839 } 840 } 841 842 if (!device) { 843 if (fs_devices->opened) { 844 mutex_unlock(&fs_devices->device_list_mutex); 845 return ERR_PTR(-EBUSY); 846 } 847 848 device = btrfs_alloc_device(NULL, &devid, 849 disk_super->dev_item.uuid); 850 if (IS_ERR(device)) { 851 mutex_unlock(&fs_devices->device_list_mutex); 852 /* we can safely leave the fs_devices entry around */ 853 return device; 854 } 855 856 name = rcu_string_strdup(path, GFP_NOFS); 857 if (!name) { 858 btrfs_free_device(device); 859 mutex_unlock(&fs_devices->device_list_mutex); 860 return ERR_PTR(-ENOMEM); 861 } 862 rcu_assign_pointer(device->name, name); 863 device->devt = path_devt; 864 865 list_add_rcu(&device->dev_list, &fs_devices->devices); 866 fs_devices->num_devices++; 867 868 device->fs_devices = fs_devices; 869 *new_device_added = true; 870 871 if (disk_super->label[0]) 872 pr_info( 873 "BTRFS: device label %s devid %llu transid %llu %s scanned by %s (%d)\n", 874 disk_super->label, devid, found_transid, path, 875 current->comm, task_pid_nr(current)); 876 else 877 pr_info( 878 "BTRFS: device fsid %pU devid %llu transid %llu %s scanned by %s (%d)\n", 879 disk_super->fsid, devid, found_transid, path, 880 current->comm, task_pid_nr(current)); 881 882 } else if (!device->name || strcmp(device->name->str, path)) { 883 /* 884 * When FS is already mounted. 885 * 1. If you are here and if the device->name is NULL that 886 * means this device was missing at time of FS mount. 887 * 2. If you are here and if the device->name is different 888 * from 'path' that means either 889 * a. The same device disappeared and reappeared with 890 * different name. or 891 * b. The missing-disk-which-was-replaced, has 892 * reappeared now. 893 * 894 * We must allow 1 and 2a above. But 2b would be a spurious 895 * and unintentional. 896 * 897 * Further in case of 1 and 2a above, the disk at 'path' 898 * would have missed some transaction when it was away and 899 * in case of 2a the stale bdev has to be updated as well. 900 * 2b must not be allowed at all time. 901 */ 902 903 /* 904 * For now, we do allow update to btrfs_fs_device through the 905 * btrfs dev scan cli after FS has been mounted. We're still 906 * tracking a problem where systems fail mount by subvolume id 907 * when we reject replacement on a mounted FS. 908 */ 909 if (!fs_devices->opened && found_transid < device->generation) { 910 /* 911 * That is if the FS is _not_ mounted and if you 912 * are here, that means there is more than one 913 * disk with same uuid and devid.We keep the one 914 * with larger generation number or the last-in if 915 * generation are equal. 916 */ 917 mutex_unlock(&fs_devices->device_list_mutex); 918 return ERR_PTR(-EEXIST); 919 } 920 921 /* 922 * We are going to replace the device path for a given devid, 923 * make sure it's the same device if the device is mounted 924 * 925 * NOTE: the device->fs_info may not be reliable here so pass 926 * in a NULL to message helpers instead. This avoids a possible 927 * use-after-free when the fs_info and fs_info->sb are already 928 * torn down. 929 */ 930 if (device->bdev) { 931 if (device->devt != path_devt) { 932 mutex_unlock(&fs_devices->device_list_mutex); 933 btrfs_warn_in_rcu(NULL, 934 "duplicate device %s devid %llu generation %llu scanned by %s (%d)", 935 path, devid, found_transid, 936 current->comm, 937 task_pid_nr(current)); 938 return ERR_PTR(-EEXIST); 939 } 940 btrfs_info_in_rcu(NULL, 941 "devid %llu device path %s changed to %s scanned by %s (%d)", 942 devid, rcu_str_deref(device->name), 943 path, current->comm, 944 task_pid_nr(current)); 945 } 946 947 name = rcu_string_strdup(path, GFP_NOFS); 948 if (!name) { 949 mutex_unlock(&fs_devices->device_list_mutex); 950 return ERR_PTR(-ENOMEM); 951 } 952 rcu_string_free(device->name); 953 rcu_assign_pointer(device->name, name); 954 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { 955 fs_devices->missing_devices--; 956 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 957 } 958 device->devt = path_devt; 959 } 960 961 /* 962 * Unmount does not free the btrfs_device struct but would zero 963 * generation along with most of the other members. So just update 964 * it back. We need it to pick the disk with largest generation 965 * (as above). 966 */ 967 if (!fs_devices->opened) { 968 device->generation = found_transid; 969 fs_devices->latest_generation = max_t(u64, found_transid, 970 fs_devices->latest_generation); 971 } 972 973 fs_devices->total_devices = btrfs_super_num_devices(disk_super); 974 975 mutex_unlock(&fs_devices->device_list_mutex); 976 return device; 977 } 978 979 static struct btrfs_fs_devices *clone_fs_devices(struct btrfs_fs_devices *orig) 980 { 981 struct btrfs_fs_devices *fs_devices; 982 struct btrfs_device *device; 983 struct btrfs_device *orig_dev; 984 int ret = 0; 985 986 lockdep_assert_held(&uuid_mutex); 987 988 fs_devices = alloc_fs_devices(orig->fsid, NULL); 989 if (IS_ERR(fs_devices)) 990 return fs_devices; 991 992 fs_devices->total_devices = orig->total_devices; 993 994 list_for_each_entry(orig_dev, &orig->devices, dev_list) { 995 struct rcu_string *name; 996 997 device = btrfs_alloc_device(NULL, &orig_dev->devid, 998 orig_dev->uuid); 999 if (IS_ERR(device)) { 1000 ret = PTR_ERR(device); 1001 goto error; 1002 } 1003 1004 /* 1005 * This is ok to do without rcu read locked because we hold the 1006 * uuid mutex so nothing we touch in here is going to disappear. 1007 */ 1008 if (orig_dev->name) { 1009 name = rcu_string_strdup(orig_dev->name->str, 1010 GFP_KERNEL); 1011 if (!name) { 1012 btrfs_free_device(device); 1013 ret = -ENOMEM; 1014 goto error; 1015 } 1016 rcu_assign_pointer(device->name, name); 1017 } 1018 1019 list_add(&device->dev_list, &fs_devices->devices); 1020 device->fs_devices = fs_devices; 1021 fs_devices->num_devices++; 1022 } 1023 return fs_devices; 1024 error: 1025 free_fs_devices(fs_devices); 1026 return ERR_PTR(ret); 1027 } 1028 1029 static void __btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices, 1030 struct btrfs_device **latest_dev) 1031 { 1032 struct btrfs_device *device, *next; 1033 1034 /* This is the initialized path, it is safe to release the devices. */ 1035 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { 1036 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)) { 1037 if (!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, 1038 &device->dev_state) && 1039 !test_bit(BTRFS_DEV_STATE_MISSING, 1040 &device->dev_state) && 1041 (!*latest_dev || 1042 device->generation > (*latest_dev)->generation)) { 1043 *latest_dev = device; 1044 } 1045 continue; 1046 } 1047 1048 /* 1049 * We have already validated the presence of BTRFS_DEV_REPLACE_DEVID, 1050 * in btrfs_init_dev_replace() so just continue. 1051 */ 1052 if (device->devid == BTRFS_DEV_REPLACE_DEVID) 1053 continue; 1054 1055 if (device->bdev) { 1056 blkdev_put(device->bdev, device->mode); 1057 device->bdev = NULL; 1058 fs_devices->open_devices--; 1059 } 1060 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 1061 list_del_init(&device->dev_alloc_list); 1062 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 1063 fs_devices->rw_devices--; 1064 } 1065 list_del_init(&device->dev_list); 1066 fs_devices->num_devices--; 1067 btrfs_free_device(device); 1068 } 1069 1070 } 1071 1072 /* 1073 * After we have read the system tree and know devids belonging to this 1074 * filesystem, remove the device which does not belong there. 1075 */ 1076 void btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices) 1077 { 1078 struct btrfs_device *latest_dev = NULL; 1079 struct btrfs_fs_devices *seed_dev; 1080 1081 mutex_lock(&uuid_mutex); 1082 __btrfs_free_extra_devids(fs_devices, &latest_dev); 1083 1084 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list) 1085 __btrfs_free_extra_devids(seed_dev, &latest_dev); 1086 1087 fs_devices->latest_dev = latest_dev; 1088 1089 mutex_unlock(&uuid_mutex); 1090 } 1091 1092 static void btrfs_close_bdev(struct btrfs_device *device) 1093 { 1094 if (!device->bdev) 1095 return; 1096 1097 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 1098 sync_blockdev(device->bdev); 1099 invalidate_bdev(device->bdev); 1100 } 1101 1102 blkdev_put(device->bdev, device->mode); 1103 } 1104 1105 static void btrfs_close_one_device(struct btrfs_device *device) 1106 { 1107 struct btrfs_fs_devices *fs_devices = device->fs_devices; 1108 1109 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && 1110 device->devid != BTRFS_DEV_REPLACE_DEVID) { 1111 list_del_init(&device->dev_alloc_list); 1112 fs_devices->rw_devices--; 1113 } 1114 1115 if (device->devid == BTRFS_DEV_REPLACE_DEVID) 1116 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); 1117 1118 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { 1119 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 1120 fs_devices->missing_devices--; 1121 } 1122 1123 btrfs_close_bdev(device); 1124 if (device->bdev) { 1125 fs_devices->open_devices--; 1126 device->bdev = NULL; 1127 } 1128 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 1129 btrfs_destroy_dev_zone_info(device); 1130 1131 device->fs_info = NULL; 1132 atomic_set(&device->dev_stats_ccnt, 0); 1133 extent_io_tree_release(&device->alloc_state); 1134 1135 /* 1136 * Reset the flush error record. We might have a transient flush error 1137 * in this mount, and if so we aborted the current transaction and set 1138 * the fs to an error state, guaranteeing no super blocks can be further 1139 * committed. However that error might be transient and if we unmount the 1140 * filesystem and mount it again, we should allow the mount to succeed 1141 * (btrfs_check_rw_degradable() should not fail) - if after mounting the 1142 * filesystem again we still get flush errors, then we will again abort 1143 * any transaction and set the error state, guaranteeing no commits of 1144 * unsafe super blocks. 1145 */ 1146 device->last_flush_error = 0; 1147 1148 /* Verify the device is back in a pristine state */ 1149 ASSERT(!test_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state)); 1150 ASSERT(!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); 1151 ASSERT(list_empty(&device->dev_alloc_list)); 1152 ASSERT(list_empty(&device->post_commit_list)); 1153 } 1154 1155 static void close_fs_devices(struct btrfs_fs_devices *fs_devices) 1156 { 1157 struct btrfs_device *device, *tmp; 1158 1159 lockdep_assert_held(&uuid_mutex); 1160 1161 if (--fs_devices->opened > 0) 1162 return; 1163 1164 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) 1165 btrfs_close_one_device(device); 1166 1167 WARN_ON(fs_devices->open_devices); 1168 WARN_ON(fs_devices->rw_devices); 1169 fs_devices->opened = 0; 1170 fs_devices->seeding = false; 1171 fs_devices->fs_info = NULL; 1172 } 1173 1174 void btrfs_close_devices(struct btrfs_fs_devices *fs_devices) 1175 { 1176 LIST_HEAD(list); 1177 struct btrfs_fs_devices *tmp; 1178 1179 mutex_lock(&uuid_mutex); 1180 close_fs_devices(fs_devices); 1181 if (!fs_devices->opened) 1182 list_splice_init(&fs_devices->seed_list, &list); 1183 1184 list_for_each_entry_safe(fs_devices, tmp, &list, seed_list) { 1185 close_fs_devices(fs_devices); 1186 list_del(&fs_devices->seed_list); 1187 free_fs_devices(fs_devices); 1188 } 1189 mutex_unlock(&uuid_mutex); 1190 } 1191 1192 static int open_fs_devices(struct btrfs_fs_devices *fs_devices, 1193 fmode_t flags, void *holder) 1194 { 1195 struct btrfs_device *device; 1196 struct btrfs_device *latest_dev = NULL; 1197 struct btrfs_device *tmp_device; 1198 1199 flags |= FMODE_EXCL; 1200 1201 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices, 1202 dev_list) { 1203 int ret; 1204 1205 ret = btrfs_open_one_device(fs_devices, device, flags, holder); 1206 if (ret == 0 && 1207 (!latest_dev || device->generation > latest_dev->generation)) { 1208 latest_dev = device; 1209 } else if (ret == -ENODATA) { 1210 fs_devices->num_devices--; 1211 list_del(&device->dev_list); 1212 btrfs_free_device(device); 1213 } 1214 } 1215 if (fs_devices->open_devices == 0) 1216 return -EINVAL; 1217 1218 fs_devices->opened = 1; 1219 fs_devices->latest_dev = latest_dev; 1220 fs_devices->total_rw_bytes = 0; 1221 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR; 1222 fs_devices->read_policy = BTRFS_READ_POLICY_PID; 1223 1224 return 0; 1225 } 1226 1227 static int devid_cmp(void *priv, const struct list_head *a, 1228 const struct list_head *b) 1229 { 1230 const struct btrfs_device *dev1, *dev2; 1231 1232 dev1 = list_entry(a, struct btrfs_device, dev_list); 1233 dev2 = list_entry(b, struct btrfs_device, dev_list); 1234 1235 if (dev1->devid < dev2->devid) 1236 return -1; 1237 else if (dev1->devid > dev2->devid) 1238 return 1; 1239 return 0; 1240 } 1241 1242 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices, 1243 fmode_t flags, void *holder) 1244 { 1245 int ret; 1246 1247 lockdep_assert_held(&uuid_mutex); 1248 /* 1249 * The device_list_mutex cannot be taken here in case opening the 1250 * underlying device takes further locks like open_mutex. 1251 * 1252 * We also don't need the lock here as this is called during mount and 1253 * exclusion is provided by uuid_mutex 1254 */ 1255 1256 if (fs_devices->opened) { 1257 fs_devices->opened++; 1258 ret = 0; 1259 } else { 1260 list_sort(NULL, &fs_devices->devices, devid_cmp); 1261 ret = open_fs_devices(fs_devices, flags, holder); 1262 } 1263 1264 return ret; 1265 } 1266 1267 void btrfs_release_disk_super(struct btrfs_super_block *super) 1268 { 1269 struct page *page = virt_to_page(super); 1270 1271 put_page(page); 1272 } 1273 1274 static struct btrfs_super_block *btrfs_read_disk_super(struct block_device *bdev, 1275 u64 bytenr, u64 bytenr_orig) 1276 { 1277 struct btrfs_super_block *disk_super; 1278 struct page *page; 1279 void *p; 1280 pgoff_t index; 1281 1282 /* make sure our super fits in the device */ 1283 if (bytenr + PAGE_SIZE >= bdev_nr_bytes(bdev)) 1284 return ERR_PTR(-EINVAL); 1285 1286 /* make sure our super fits in the page */ 1287 if (sizeof(*disk_super) > PAGE_SIZE) 1288 return ERR_PTR(-EINVAL); 1289 1290 /* make sure our super doesn't straddle pages on disk */ 1291 index = bytenr >> PAGE_SHIFT; 1292 if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_SHIFT != index) 1293 return ERR_PTR(-EINVAL); 1294 1295 /* pull in the page with our super */ 1296 page = read_cache_page_gfp(bdev->bd_inode->i_mapping, index, GFP_KERNEL); 1297 1298 if (IS_ERR(page)) 1299 return ERR_CAST(page); 1300 1301 p = page_address(page); 1302 1303 /* align our pointer to the offset of the super block */ 1304 disk_super = p + offset_in_page(bytenr); 1305 1306 if (btrfs_super_bytenr(disk_super) != bytenr_orig || 1307 btrfs_super_magic(disk_super) != BTRFS_MAGIC) { 1308 btrfs_release_disk_super(p); 1309 return ERR_PTR(-EINVAL); 1310 } 1311 1312 if (disk_super->label[0] && disk_super->label[BTRFS_LABEL_SIZE - 1]) 1313 disk_super->label[BTRFS_LABEL_SIZE - 1] = 0; 1314 1315 return disk_super; 1316 } 1317 1318 int btrfs_forget_devices(dev_t devt) 1319 { 1320 int ret; 1321 1322 mutex_lock(&uuid_mutex); 1323 ret = btrfs_free_stale_devices(devt, NULL); 1324 mutex_unlock(&uuid_mutex); 1325 1326 return ret; 1327 } 1328 1329 /* 1330 * Look for a btrfs signature on a device. This may be called out of the mount path 1331 * and we are not allowed to call set_blocksize during the scan. The superblock 1332 * is read via pagecache 1333 */ 1334 struct btrfs_device *btrfs_scan_one_device(const char *path, fmode_t flags, 1335 void *holder) 1336 { 1337 struct btrfs_super_block *disk_super; 1338 bool new_device_added = false; 1339 struct btrfs_device *device = NULL; 1340 struct block_device *bdev; 1341 u64 bytenr, bytenr_orig; 1342 int ret; 1343 1344 lockdep_assert_held(&uuid_mutex); 1345 1346 /* 1347 * we would like to check all the supers, but that would make 1348 * a btrfs mount succeed after a mkfs from a different FS. 1349 * So, we need to add a special mount option to scan for 1350 * later supers, using BTRFS_SUPER_MIRROR_MAX instead 1351 */ 1352 flags |= FMODE_EXCL; 1353 1354 bdev = blkdev_get_by_path(path, flags, holder); 1355 if (IS_ERR(bdev)) 1356 return ERR_CAST(bdev); 1357 1358 bytenr_orig = btrfs_sb_offset(0); 1359 ret = btrfs_sb_log_location_bdev(bdev, 0, READ, &bytenr); 1360 if (ret) { 1361 device = ERR_PTR(ret); 1362 goto error_bdev_put; 1363 } 1364 1365 disk_super = btrfs_read_disk_super(bdev, bytenr, bytenr_orig); 1366 if (IS_ERR(disk_super)) { 1367 device = ERR_CAST(disk_super); 1368 goto error_bdev_put; 1369 } 1370 1371 device = device_list_add(path, disk_super, &new_device_added); 1372 if (!IS_ERR(device) && new_device_added) 1373 btrfs_free_stale_devices(device->devt, device); 1374 1375 btrfs_release_disk_super(disk_super); 1376 1377 error_bdev_put: 1378 blkdev_put(bdev, flags); 1379 1380 return device; 1381 } 1382 1383 /* 1384 * Try to find a chunk that intersects [start, start + len] range and when one 1385 * such is found, record the end of it in *start 1386 */ 1387 static bool contains_pending_extent(struct btrfs_device *device, u64 *start, 1388 u64 len) 1389 { 1390 u64 physical_start, physical_end; 1391 1392 lockdep_assert_held(&device->fs_info->chunk_mutex); 1393 1394 if (!find_first_extent_bit(&device->alloc_state, *start, 1395 &physical_start, &physical_end, 1396 CHUNK_ALLOCATED, NULL)) { 1397 1398 if (in_range(physical_start, *start, len) || 1399 in_range(*start, physical_start, 1400 physical_end - physical_start)) { 1401 *start = physical_end + 1; 1402 return true; 1403 } 1404 } 1405 return false; 1406 } 1407 1408 static u64 dev_extent_search_start(struct btrfs_device *device, u64 start) 1409 { 1410 switch (device->fs_devices->chunk_alloc_policy) { 1411 case BTRFS_CHUNK_ALLOC_REGULAR: 1412 /* 1413 * We don't want to overwrite the superblock on the drive nor 1414 * any area used by the boot loader (grub for example), so we 1415 * make sure to start at an offset of at least 1MB. 1416 */ 1417 return max_t(u64, start, SZ_1M); 1418 case BTRFS_CHUNK_ALLOC_ZONED: 1419 /* 1420 * We don't care about the starting region like regular 1421 * allocator, because we anyway use/reserve the first two zones 1422 * for superblock logging. 1423 */ 1424 return ALIGN(start, device->zone_info->zone_size); 1425 default: 1426 BUG(); 1427 } 1428 } 1429 1430 static bool dev_extent_hole_check_zoned(struct btrfs_device *device, 1431 u64 *hole_start, u64 *hole_size, 1432 u64 num_bytes) 1433 { 1434 u64 zone_size = device->zone_info->zone_size; 1435 u64 pos; 1436 int ret; 1437 bool changed = false; 1438 1439 ASSERT(IS_ALIGNED(*hole_start, zone_size)); 1440 1441 while (*hole_size > 0) { 1442 pos = btrfs_find_allocatable_zones(device, *hole_start, 1443 *hole_start + *hole_size, 1444 num_bytes); 1445 if (pos != *hole_start) { 1446 *hole_size = *hole_start + *hole_size - pos; 1447 *hole_start = pos; 1448 changed = true; 1449 if (*hole_size < num_bytes) 1450 break; 1451 } 1452 1453 ret = btrfs_ensure_empty_zones(device, pos, num_bytes); 1454 1455 /* Range is ensured to be empty */ 1456 if (!ret) 1457 return changed; 1458 1459 /* Given hole range was invalid (outside of device) */ 1460 if (ret == -ERANGE) { 1461 *hole_start += *hole_size; 1462 *hole_size = 0; 1463 return true; 1464 } 1465 1466 *hole_start += zone_size; 1467 *hole_size -= zone_size; 1468 changed = true; 1469 } 1470 1471 return changed; 1472 } 1473 1474 /** 1475 * dev_extent_hole_check - check if specified hole is suitable for allocation 1476 * @device: the device which we have the hole 1477 * @hole_start: starting position of the hole 1478 * @hole_size: the size of the hole 1479 * @num_bytes: the size of the free space that we need 1480 * 1481 * This function may modify @hole_start and @hole_size to reflect the suitable 1482 * position for allocation. Returns 1 if hole position is updated, 0 otherwise. 1483 */ 1484 static bool dev_extent_hole_check(struct btrfs_device *device, u64 *hole_start, 1485 u64 *hole_size, u64 num_bytes) 1486 { 1487 bool changed = false; 1488 u64 hole_end = *hole_start + *hole_size; 1489 1490 for (;;) { 1491 /* 1492 * Check before we set max_hole_start, otherwise we could end up 1493 * sending back this offset anyway. 1494 */ 1495 if (contains_pending_extent(device, hole_start, *hole_size)) { 1496 if (hole_end >= *hole_start) 1497 *hole_size = hole_end - *hole_start; 1498 else 1499 *hole_size = 0; 1500 changed = true; 1501 } 1502 1503 switch (device->fs_devices->chunk_alloc_policy) { 1504 case BTRFS_CHUNK_ALLOC_REGULAR: 1505 /* No extra check */ 1506 break; 1507 case BTRFS_CHUNK_ALLOC_ZONED: 1508 if (dev_extent_hole_check_zoned(device, hole_start, 1509 hole_size, num_bytes)) { 1510 changed = true; 1511 /* 1512 * The changed hole can contain pending extent. 1513 * Loop again to check that. 1514 */ 1515 continue; 1516 } 1517 break; 1518 default: 1519 BUG(); 1520 } 1521 1522 break; 1523 } 1524 1525 return changed; 1526 } 1527 1528 /* 1529 * find_free_dev_extent_start - find free space in the specified device 1530 * @device: the device which we search the free space in 1531 * @num_bytes: the size of the free space that we need 1532 * @search_start: the position from which to begin the search 1533 * @start: store the start of the free space. 1534 * @len: the size of the free space. that we find, or the size 1535 * of the max free space if we don't find suitable free space 1536 * 1537 * this uses a pretty simple search, the expectation is that it is 1538 * called very infrequently and that a given device has a small number 1539 * of extents 1540 * 1541 * @start is used to store the start of the free space if we find. But if we 1542 * don't find suitable free space, it will be used to store the start position 1543 * of the max free space. 1544 * 1545 * @len is used to store the size of the free space that we find. 1546 * But if we don't find suitable free space, it is used to store the size of 1547 * the max free space. 1548 * 1549 * NOTE: This function will search *commit* root of device tree, and does extra 1550 * check to ensure dev extents are not double allocated. 1551 * This makes the function safe to allocate dev extents but may not report 1552 * correct usable device space, as device extent freed in current transaction 1553 * is not reported as available. 1554 */ 1555 static int find_free_dev_extent_start(struct btrfs_device *device, 1556 u64 num_bytes, u64 search_start, u64 *start, 1557 u64 *len) 1558 { 1559 struct btrfs_fs_info *fs_info = device->fs_info; 1560 struct btrfs_root *root = fs_info->dev_root; 1561 struct btrfs_key key; 1562 struct btrfs_dev_extent *dev_extent; 1563 struct btrfs_path *path; 1564 u64 hole_size; 1565 u64 max_hole_start; 1566 u64 max_hole_size; 1567 u64 extent_end; 1568 u64 search_end = device->total_bytes; 1569 int ret; 1570 int slot; 1571 struct extent_buffer *l; 1572 1573 search_start = dev_extent_search_start(device, search_start); 1574 1575 WARN_ON(device->zone_info && 1576 !IS_ALIGNED(num_bytes, device->zone_info->zone_size)); 1577 1578 path = btrfs_alloc_path(); 1579 if (!path) 1580 return -ENOMEM; 1581 1582 max_hole_start = search_start; 1583 max_hole_size = 0; 1584 1585 again: 1586 if (search_start >= search_end || 1587 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { 1588 ret = -ENOSPC; 1589 goto out; 1590 } 1591 1592 path->reada = READA_FORWARD; 1593 path->search_commit_root = 1; 1594 path->skip_locking = 1; 1595 1596 key.objectid = device->devid; 1597 key.offset = search_start; 1598 key.type = BTRFS_DEV_EXTENT_KEY; 1599 1600 ret = btrfs_search_backwards(root, &key, path); 1601 if (ret < 0) 1602 goto out; 1603 1604 while (1) { 1605 l = path->nodes[0]; 1606 slot = path->slots[0]; 1607 if (slot >= btrfs_header_nritems(l)) { 1608 ret = btrfs_next_leaf(root, path); 1609 if (ret == 0) 1610 continue; 1611 if (ret < 0) 1612 goto out; 1613 1614 break; 1615 } 1616 btrfs_item_key_to_cpu(l, &key, slot); 1617 1618 if (key.objectid < device->devid) 1619 goto next; 1620 1621 if (key.objectid > device->devid) 1622 break; 1623 1624 if (key.type != BTRFS_DEV_EXTENT_KEY) 1625 goto next; 1626 1627 if (key.offset > search_start) { 1628 hole_size = key.offset - search_start; 1629 dev_extent_hole_check(device, &search_start, &hole_size, 1630 num_bytes); 1631 1632 if (hole_size > max_hole_size) { 1633 max_hole_start = search_start; 1634 max_hole_size = hole_size; 1635 } 1636 1637 /* 1638 * If this free space is greater than which we need, 1639 * it must be the max free space that we have found 1640 * until now, so max_hole_start must point to the start 1641 * of this free space and the length of this free space 1642 * is stored in max_hole_size. Thus, we return 1643 * max_hole_start and max_hole_size and go back to the 1644 * caller. 1645 */ 1646 if (hole_size >= num_bytes) { 1647 ret = 0; 1648 goto out; 1649 } 1650 } 1651 1652 dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent); 1653 extent_end = key.offset + btrfs_dev_extent_length(l, 1654 dev_extent); 1655 if (extent_end > search_start) 1656 search_start = extent_end; 1657 next: 1658 path->slots[0]++; 1659 cond_resched(); 1660 } 1661 1662 /* 1663 * At this point, search_start should be the end of 1664 * allocated dev extents, and when shrinking the device, 1665 * search_end may be smaller than search_start. 1666 */ 1667 if (search_end > search_start) { 1668 hole_size = search_end - search_start; 1669 if (dev_extent_hole_check(device, &search_start, &hole_size, 1670 num_bytes)) { 1671 btrfs_release_path(path); 1672 goto again; 1673 } 1674 1675 if (hole_size > max_hole_size) { 1676 max_hole_start = search_start; 1677 max_hole_size = hole_size; 1678 } 1679 } 1680 1681 /* See above. */ 1682 if (max_hole_size < num_bytes) 1683 ret = -ENOSPC; 1684 else 1685 ret = 0; 1686 1687 out: 1688 btrfs_free_path(path); 1689 *start = max_hole_start; 1690 if (len) 1691 *len = max_hole_size; 1692 return ret; 1693 } 1694 1695 int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes, 1696 u64 *start, u64 *len) 1697 { 1698 /* FIXME use last free of some kind */ 1699 return find_free_dev_extent_start(device, num_bytes, 0, start, len); 1700 } 1701 1702 static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans, 1703 struct btrfs_device *device, 1704 u64 start, u64 *dev_extent_len) 1705 { 1706 struct btrfs_fs_info *fs_info = device->fs_info; 1707 struct btrfs_root *root = fs_info->dev_root; 1708 int ret; 1709 struct btrfs_path *path; 1710 struct btrfs_key key; 1711 struct btrfs_key found_key; 1712 struct extent_buffer *leaf = NULL; 1713 struct btrfs_dev_extent *extent = NULL; 1714 1715 path = btrfs_alloc_path(); 1716 if (!path) 1717 return -ENOMEM; 1718 1719 key.objectid = device->devid; 1720 key.offset = start; 1721 key.type = BTRFS_DEV_EXTENT_KEY; 1722 again: 1723 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 1724 if (ret > 0) { 1725 ret = btrfs_previous_item(root, path, key.objectid, 1726 BTRFS_DEV_EXTENT_KEY); 1727 if (ret) 1728 goto out; 1729 leaf = path->nodes[0]; 1730 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 1731 extent = btrfs_item_ptr(leaf, path->slots[0], 1732 struct btrfs_dev_extent); 1733 BUG_ON(found_key.offset > start || found_key.offset + 1734 btrfs_dev_extent_length(leaf, extent) < start); 1735 key = found_key; 1736 btrfs_release_path(path); 1737 goto again; 1738 } else if (ret == 0) { 1739 leaf = path->nodes[0]; 1740 extent = btrfs_item_ptr(leaf, path->slots[0], 1741 struct btrfs_dev_extent); 1742 } else { 1743 goto out; 1744 } 1745 1746 *dev_extent_len = btrfs_dev_extent_length(leaf, extent); 1747 1748 ret = btrfs_del_item(trans, root, path); 1749 if (ret == 0) 1750 set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags); 1751 out: 1752 btrfs_free_path(path); 1753 return ret; 1754 } 1755 1756 static u64 find_next_chunk(struct btrfs_fs_info *fs_info) 1757 { 1758 struct extent_map_tree *em_tree; 1759 struct extent_map *em; 1760 struct rb_node *n; 1761 u64 ret = 0; 1762 1763 em_tree = &fs_info->mapping_tree; 1764 read_lock(&em_tree->lock); 1765 n = rb_last(&em_tree->map.rb_root); 1766 if (n) { 1767 em = rb_entry(n, struct extent_map, rb_node); 1768 ret = em->start + em->len; 1769 } 1770 read_unlock(&em_tree->lock); 1771 1772 return ret; 1773 } 1774 1775 static noinline int find_next_devid(struct btrfs_fs_info *fs_info, 1776 u64 *devid_ret) 1777 { 1778 int ret; 1779 struct btrfs_key key; 1780 struct btrfs_key found_key; 1781 struct btrfs_path *path; 1782 1783 path = btrfs_alloc_path(); 1784 if (!path) 1785 return -ENOMEM; 1786 1787 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 1788 key.type = BTRFS_DEV_ITEM_KEY; 1789 key.offset = (u64)-1; 1790 1791 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0); 1792 if (ret < 0) 1793 goto error; 1794 1795 if (ret == 0) { 1796 /* Corruption */ 1797 btrfs_err(fs_info, "corrupted chunk tree devid -1 matched"); 1798 ret = -EUCLEAN; 1799 goto error; 1800 } 1801 1802 ret = btrfs_previous_item(fs_info->chunk_root, path, 1803 BTRFS_DEV_ITEMS_OBJECTID, 1804 BTRFS_DEV_ITEM_KEY); 1805 if (ret) { 1806 *devid_ret = 1; 1807 } else { 1808 btrfs_item_key_to_cpu(path->nodes[0], &found_key, 1809 path->slots[0]); 1810 *devid_ret = found_key.offset + 1; 1811 } 1812 ret = 0; 1813 error: 1814 btrfs_free_path(path); 1815 return ret; 1816 } 1817 1818 /* 1819 * the device information is stored in the chunk root 1820 * the btrfs_device struct should be fully filled in 1821 */ 1822 static int btrfs_add_dev_item(struct btrfs_trans_handle *trans, 1823 struct btrfs_device *device) 1824 { 1825 int ret; 1826 struct btrfs_path *path; 1827 struct btrfs_dev_item *dev_item; 1828 struct extent_buffer *leaf; 1829 struct btrfs_key key; 1830 unsigned long ptr; 1831 1832 path = btrfs_alloc_path(); 1833 if (!path) 1834 return -ENOMEM; 1835 1836 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 1837 key.type = BTRFS_DEV_ITEM_KEY; 1838 key.offset = device->devid; 1839 1840 btrfs_reserve_chunk_metadata(trans, true); 1841 ret = btrfs_insert_empty_item(trans, trans->fs_info->chunk_root, path, 1842 &key, sizeof(*dev_item)); 1843 btrfs_trans_release_chunk_metadata(trans); 1844 if (ret) 1845 goto out; 1846 1847 leaf = path->nodes[0]; 1848 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); 1849 1850 btrfs_set_device_id(leaf, dev_item, device->devid); 1851 btrfs_set_device_generation(leaf, dev_item, 0); 1852 btrfs_set_device_type(leaf, dev_item, device->type); 1853 btrfs_set_device_io_align(leaf, dev_item, device->io_align); 1854 btrfs_set_device_io_width(leaf, dev_item, device->io_width); 1855 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); 1856 btrfs_set_device_total_bytes(leaf, dev_item, 1857 btrfs_device_get_disk_total_bytes(device)); 1858 btrfs_set_device_bytes_used(leaf, dev_item, 1859 btrfs_device_get_bytes_used(device)); 1860 btrfs_set_device_group(leaf, dev_item, 0); 1861 btrfs_set_device_seek_speed(leaf, dev_item, 0); 1862 btrfs_set_device_bandwidth(leaf, dev_item, 0); 1863 btrfs_set_device_start_offset(leaf, dev_item, 0); 1864 1865 ptr = btrfs_device_uuid(dev_item); 1866 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); 1867 ptr = btrfs_device_fsid(dev_item); 1868 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid, 1869 ptr, BTRFS_FSID_SIZE); 1870 btrfs_mark_buffer_dirty(leaf); 1871 1872 ret = 0; 1873 out: 1874 btrfs_free_path(path); 1875 return ret; 1876 } 1877 1878 /* 1879 * Function to update ctime/mtime for a given device path. 1880 * Mainly used for ctime/mtime based probe like libblkid. 1881 * 1882 * We don't care about errors here, this is just to be kind to userspace. 1883 */ 1884 static void update_dev_time(const char *device_path) 1885 { 1886 struct path path; 1887 struct timespec64 now; 1888 int ret; 1889 1890 ret = kern_path(device_path, LOOKUP_FOLLOW, &path); 1891 if (ret) 1892 return; 1893 1894 now = current_time(d_inode(path.dentry)); 1895 inode_update_time(d_inode(path.dentry), &now, S_MTIME | S_CTIME); 1896 path_put(&path); 1897 } 1898 1899 static int btrfs_rm_dev_item(struct btrfs_trans_handle *trans, 1900 struct btrfs_device *device) 1901 { 1902 struct btrfs_root *root = device->fs_info->chunk_root; 1903 int ret; 1904 struct btrfs_path *path; 1905 struct btrfs_key key; 1906 1907 path = btrfs_alloc_path(); 1908 if (!path) 1909 return -ENOMEM; 1910 1911 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 1912 key.type = BTRFS_DEV_ITEM_KEY; 1913 key.offset = device->devid; 1914 1915 btrfs_reserve_chunk_metadata(trans, false); 1916 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 1917 btrfs_trans_release_chunk_metadata(trans); 1918 if (ret) { 1919 if (ret > 0) 1920 ret = -ENOENT; 1921 goto out; 1922 } 1923 1924 ret = btrfs_del_item(trans, root, path); 1925 out: 1926 btrfs_free_path(path); 1927 return ret; 1928 } 1929 1930 /* 1931 * Verify that @num_devices satisfies the RAID profile constraints in the whole 1932 * filesystem. It's up to the caller to adjust that number regarding eg. device 1933 * replace. 1934 */ 1935 static int btrfs_check_raid_min_devices(struct btrfs_fs_info *fs_info, 1936 u64 num_devices) 1937 { 1938 u64 all_avail; 1939 unsigned seq; 1940 int i; 1941 1942 do { 1943 seq = read_seqbegin(&fs_info->profiles_lock); 1944 1945 all_avail = fs_info->avail_data_alloc_bits | 1946 fs_info->avail_system_alloc_bits | 1947 fs_info->avail_metadata_alloc_bits; 1948 } while (read_seqretry(&fs_info->profiles_lock, seq)); 1949 1950 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 1951 if (!(all_avail & btrfs_raid_array[i].bg_flag)) 1952 continue; 1953 1954 if (num_devices < btrfs_raid_array[i].devs_min) 1955 return btrfs_raid_array[i].mindev_error; 1956 } 1957 1958 return 0; 1959 } 1960 1961 static struct btrfs_device * btrfs_find_next_active_device( 1962 struct btrfs_fs_devices *fs_devs, struct btrfs_device *device) 1963 { 1964 struct btrfs_device *next_device; 1965 1966 list_for_each_entry(next_device, &fs_devs->devices, dev_list) { 1967 if (next_device != device && 1968 !test_bit(BTRFS_DEV_STATE_MISSING, &next_device->dev_state) 1969 && next_device->bdev) 1970 return next_device; 1971 } 1972 1973 return NULL; 1974 } 1975 1976 /* 1977 * Helper function to check if the given device is part of s_bdev / latest_dev 1978 * and replace it with the provided or the next active device, in the context 1979 * where this function called, there should be always be another device (or 1980 * this_dev) which is active. 1981 */ 1982 void __cold btrfs_assign_next_active_device(struct btrfs_device *device, 1983 struct btrfs_device *next_device) 1984 { 1985 struct btrfs_fs_info *fs_info = device->fs_info; 1986 1987 if (!next_device) 1988 next_device = btrfs_find_next_active_device(fs_info->fs_devices, 1989 device); 1990 ASSERT(next_device); 1991 1992 if (fs_info->sb->s_bdev && 1993 (fs_info->sb->s_bdev == device->bdev)) 1994 fs_info->sb->s_bdev = next_device->bdev; 1995 1996 if (fs_info->fs_devices->latest_dev->bdev == device->bdev) 1997 fs_info->fs_devices->latest_dev = next_device; 1998 } 1999 2000 /* 2001 * Return btrfs_fs_devices::num_devices excluding the device that's being 2002 * currently replaced. 2003 */ 2004 static u64 btrfs_num_devices(struct btrfs_fs_info *fs_info) 2005 { 2006 u64 num_devices = fs_info->fs_devices->num_devices; 2007 2008 down_read(&fs_info->dev_replace.rwsem); 2009 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) { 2010 ASSERT(num_devices > 1); 2011 num_devices--; 2012 } 2013 up_read(&fs_info->dev_replace.rwsem); 2014 2015 return num_devices; 2016 } 2017 2018 void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, 2019 struct block_device *bdev, 2020 const char *device_path) 2021 { 2022 struct btrfs_super_block *disk_super; 2023 int copy_num; 2024 2025 if (!bdev) 2026 return; 2027 2028 for (copy_num = 0; copy_num < BTRFS_SUPER_MIRROR_MAX; copy_num++) { 2029 struct page *page; 2030 int ret; 2031 2032 disk_super = btrfs_read_dev_one_super(bdev, copy_num); 2033 if (IS_ERR(disk_super)) 2034 continue; 2035 2036 if (bdev_is_zoned(bdev)) { 2037 btrfs_reset_sb_log_zones(bdev, copy_num); 2038 continue; 2039 } 2040 2041 memset(&disk_super->magic, 0, sizeof(disk_super->magic)); 2042 2043 page = virt_to_page(disk_super); 2044 set_page_dirty(page); 2045 lock_page(page); 2046 /* write_on_page() unlocks the page */ 2047 ret = write_one_page(page); 2048 if (ret) 2049 btrfs_warn(fs_info, 2050 "error clearing superblock number %d (%d)", 2051 copy_num, ret); 2052 btrfs_release_disk_super(disk_super); 2053 2054 } 2055 2056 /* Notify udev that device has changed */ 2057 btrfs_kobject_uevent(bdev, KOBJ_CHANGE); 2058 2059 /* Update ctime/mtime for device path for libblkid */ 2060 update_dev_time(device_path); 2061 } 2062 2063 int btrfs_rm_device(struct btrfs_fs_info *fs_info, 2064 struct btrfs_dev_lookup_args *args, 2065 struct block_device **bdev, fmode_t *mode) 2066 { 2067 struct btrfs_trans_handle *trans; 2068 struct btrfs_device *device; 2069 struct btrfs_fs_devices *cur_devices; 2070 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 2071 u64 num_devices; 2072 int ret = 0; 2073 2074 if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) { 2075 btrfs_err(fs_info, "device remove not supported on extent tree v2 yet"); 2076 return -EINVAL; 2077 } 2078 2079 /* 2080 * The device list in fs_devices is accessed without locks (neither 2081 * uuid_mutex nor device_list_mutex) as it won't change on a mounted 2082 * filesystem and another device rm cannot run. 2083 */ 2084 num_devices = btrfs_num_devices(fs_info); 2085 2086 ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1); 2087 if (ret) 2088 return ret; 2089 2090 device = btrfs_find_device(fs_info->fs_devices, args); 2091 if (!device) { 2092 if (args->missing) 2093 ret = BTRFS_ERROR_DEV_MISSING_NOT_FOUND; 2094 else 2095 ret = -ENOENT; 2096 return ret; 2097 } 2098 2099 if (btrfs_pinned_by_swapfile(fs_info, device)) { 2100 btrfs_warn_in_rcu(fs_info, 2101 "cannot remove device %s (devid %llu) due to active swapfile", 2102 rcu_str_deref(device->name), device->devid); 2103 return -ETXTBSY; 2104 } 2105 2106 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) 2107 return BTRFS_ERROR_DEV_TGT_REPLACE; 2108 2109 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && 2110 fs_info->fs_devices->rw_devices == 1) 2111 return BTRFS_ERROR_DEV_ONLY_WRITABLE; 2112 2113 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 2114 mutex_lock(&fs_info->chunk_mutex); 2115 list_del_init(&device->dev_alloc_list); 2116 device->fs_devices->rw_devices--; 2117 mutex_unlock(&fs_info->chunk_mutex); 2118 } 2119 2120 ret = btrfs_shrink_device(device, 0); 2121 if (ret) 2122 goto error_undo; 2123 2124 trans = btrfs_start_transaction(fs_info->chunk_root, 0); 2125 if (IS_ERR(trans)) { 2126 ret = PTR_ERR(trans); 2127 goto error_undo; 2128 } 2129 2130 ret = btrfs_rm_dev_item(trans, device); 2131 if (ret) { 2132 /* Any error in dev item removal is critical */ 2133 btrfs_crit(fs_info, 2134 "failed to remove device item for devid %llu: %d", 2135 device->devid, ret); 2136 btrfs_abort_transaction(trans, ret); 2137 btrfs_end_transaction(trans); 2138 return ret; 2139 } 2140 2141 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 2142 btrfs_scrub_cancel_dev(device); 2143 2144 /* 2145 * the device list mutex makes sure that we don't change 2146 * the device list while someone else is writing out all 2147 * the device supers. Whoever is writing all supers, should 2148 * lock the device list mutex before getting the number of 2149 * devices in the super block (super_copy). Conversely, 2150 * whoever updates the number of devices in the super block 2151 * (super_copy) should hold the device list mutex. 2152 */ 2153 2154 /* 2155 * In normal cases the cur_devices == fs_devices. But in case 2156 * of deleting a seed device, the cur_devices should point to 2157 * its own fs_devices listed under the fs_devices->seed_list. 2158 */ 2159 cur_devices = device->fs_devices; 2160 mutex_lock(&fs_devices->device_list_mutex); 2161 list_del_rcu(&device->dev_list); 2162 2163 cur_devices->num_devices--; 2164 cur_devices->total_devices--; 2165 /* Update total_devices of the parent fs_devices if it's seed */ 2166 if (cur_devices != fs_devices) 2167 fs_devices->total_devices--; 2168 2169 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) 2170 cur_devices->missing_devices--; 2171 2172 btrfs_assign_next_active_device(device, NULL); 2173 2174 if (device->bdev) { 2175 cur_devices->open_devices--; 2176 /* remove sysfs entry */ 2177 btrfs_sysfs_remove_device(device); 2178 } 2179 2180 num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1; 2181 btrfs_set_super_num_devices(fs_info->super_copy, num_devices); 2182 mutex_unlock(&fs_devices->device_list_mutex); 2183 2184 /* 2185 * At this point, the device is zero sized and detached from the 2186 * devices list. All that's left is to zero out the old supers and 2187 * free the device. 2188 * 2189 * We cannot call btrfs_close_bdev() here because we're holding the sb 2190 * write lock, and blkdev_put() will pull in the ->open_mutex on the 2191 * block device and it's dependencies. Instead just flush the device 2192 * and let the caller do the final blkdev_put. 2193 */ 2194 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 2195 btrfs_scratch_superblocks(fs_info, device->bdev, 2196 device->name->str); 2197 if (device->bdev) { 2198 sync_blockdev(device->bdev); 2199 invalidate_bdev(device->bdev); 2200 } 2201 } 2202 2203 *bdev = device->bdev; 2204 *mode = device->mode; 2205 synchronize_rcu(); 2206 btrfs_free_device(device); 2207 2208 /* 2209 * This can happen if cur_devices is the private seed devices list. We 2210 * cannot call close_fs_devices() here because it expects the uuid_mutex 2211 * to be held, but in fact we don't need that for the private 2212 * seed_devices, we can simply decrement cur_devices->opened and then 2213 * remove it from our list and free the fs_devices. 2214 */ 2215 if (cur_devices->num_devices == 0) { 2216 list_del_init(&cur_devices->seed_list); 2217 ASSERT(cur_devices->opened == 1); 2218 cur_devices->opened--; 2219 free_fs_devices(cur_devices); 2220 } 2221 2222 ret = btrfs_commit_transaction(trans); 2223 2224 return ret; 2225 2226 error_undo: 2227 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 2228 mutex_lock(&fs_info->chunk_mutex); 2229 list_add(&device->dev_alloc_list, 2230 &fs_devices->alloc_list); 2231 device->fs_devices->rw_devices++; 2232 mutex_unlock(&fs_info->chunk_mutex); 2233 } 2234 return ret; 2235 } 2236 2237 void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_device *srcdev) 2238 { 2239 struct btrfs_fs_devices *fs_devices; 2240 2241 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex); 2242 2243 /* 2244 * in case of fs with no seed, srcdev->fs_devices will point 2245 * to fs_devices of fs_info. However when the dev being replaced is 2246 * a seed dev it will point to the seed's local fs_devices. In short 2247 * srcdev will have its correct fs_devices in both the cases. 2248 */ 2249 fs_devices = srcdev->fs_devices; 2250 2251 list_del_rcu(&srcdev->dev_list); 2252 list_del(&srcdev->dev_alloc_list); 2253 fs_devices->num_devices--; 2254 if (test_bit(BTRFS_DEV_STATE_MISSING, &srcdev->dev_state)) 2255 fs_devices->missing_devices--; 2256 2257 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &srcdev->dev_state)) 2258 fs_devices->rw_devices--; 2259 2260 if (srcdev->bdev) 2261 fs_devices->open_devices--; 2262 } 2263 2264 void btrfs_rm_dev_replace_free_srcdev(struct btrfs_device *srcdev) 2265 { 2266 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices; 2267 2268 mutex_lock(&uuid_mutex); 2269 2270 btrfs_close_bdev(srcdev); 2271 synchronize_rcu(); 2272 btrfs_free_device(srcdev); 2273 2274 /* if this is no devs we rather delete the fs_devices */ 2275 if (!fs_devices->num_devices) { 2276 /* 2277 * On a mounted FS, num_devices can't be zero unless it's a 2278 * seed. In case of a seed device being replaced, the replace 2279 * target added to the sprout FS, so there will be no more 2280 * device left under the seed FS. 2281 */ 2282 ASSERT(fs_devices->seeding); 2283 2284 list_del_init(&fs_devices->seed_list); 2285 close_fs_devices(fs_devices); 2286 free_fs_devices(fs_devices); 2287 } 2288 mutex_unlock(&uuid_mutex); 2289 } 2290 2291 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_device *tgtdev) 2292 { 2293 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices; 2294 2295 mutex_lock(&fs_devices->device_list_mutex); 2296 2297 btrfs_sysfs_remove_device(tgtdev); 2298 2299 if (tgtdev->bdev) 2300 fs_devices->open_devices--; 2301 2302 fs_devices->num_devices--; 2303 2304 btrfs_assign_next_active_device(tgtdev, NULL); 2305 2306 list_del_rcu(&tgtdev->dev_list); 2307 2308 mutex_unlock(&fs_devices->device_list_mutex); 2309 2310 btrfs_scratch_superblocks(tgtdev->fs_info, tgtdev->bdev, 2311 tgtdev->name->str); 2312 2313 btrfs_close_bdev(tgtdev); 2314 synchronize_rcu(); 2315 btrfs_free_device(tgtdev); 2316 } 2317 2318 /** 2319 * Populate args from device at path 2320 * 2321 * @fs_info: the filesystem 2322 * @args: the args to populate 2323 * @path: the path to the device 2324 * 2325 * This will read the super block of the device at @path and populate @args with 2326 * the devid, fsid, and uuid. This is meant to be used for ioctls that need to 2327 * lookup a device to operate on, but need to do it before we take any locks. 2328 * This properly handles the special case of "missing" that a user may pass in, 2329 * and does some basic sanity checks. The caller must make sure that @path is 2330 * properly NUL terminated before calling in, and must call 2331 * btrfs_put_dev_args_from_path() in order to free up the temporary fsid and 2332 * uuid buffers. 2333 * 2334 * Return: 0 for success, -errno for failure 2335 */ 2336 int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info, 2337 struct btrfs_dev_lookup_args *args, 2338 const char *path) 2339 { 2340 struct btrfs_super_block *disk_super; 2341 struct block_device *bdev; 2342 int ret; 2343 2344 if (!path || !path[0]) 2345 return -EINVAL; 2346 if (!strcmp(path, "missing")) { 2347 args->missing = true; 2348 return 0; 2349 } 2350 2351 args->uuid = kzalloc(BTRFS_UUID_SIZE, GFP_KERNEL); 2352 args->fsid = kzalloc(BTRFS_FSID_SIZE, GFP_KERNEL); 2353 if (!args->uuid || !args->fsid) { 2354 btrfs_put_dev_args_from_path(args); 2355 return -ENOMEM; 2356 } 2357 2358 ret = btrfs_get_bdev_and_sb(path, FMODE_READ, fs_info->bdev_holder, 0, 2359 &bdev, &disk_super); 2360 if (ret) 2361 return ret; 2362 args->devid = btrfs_stack_device_id(&disk_super->dev_item); 2363 memcpy(args->uuid, disk_super->dev_item.uuid, BTRFS_UUID_SIZE); 2364 if (btrfs_fs_incompat(fs_info, METADATA_UUID)) 2365 memcpy(args->fsid, disk_super->metadata_uuid, BTRFS_FSID_SIZE); 2366 else 2367 memcpy(args->fsid, disk_super->fsid, BTRFS_FSID_SIZE); 2368 btrfs_release_disk_super(disk_super); 2369 blkdev_put(bdev, FMODE_READ); 2370 return 0; 2371 } 2372 2373 /* 2374 * Only use this jointly with btrfs_get_dev_args_from_path() because we will 2375 * allocate our ->uuid and ->fsid pointers, everybody else uses local variables 2376 * that don't need to be freed. 2377 */ 2378 void btrfs_put_dev_args_from_path(struct btrfs_dev_lookup_args *args) 2379 { 2380 kfree(args->uuid); 2381 kfree(args->fsid); 2382 args->uuid = NULL; 2383 args->fsid = NULL; 2384 } 2385 2386 struct btrfs_device *btrfs_find_device_by_devspec( 2387 struct btrfs_fs_info *fs_info, u64 devid, 2388 const char *device_path) 2389 { 2390 BTRFS_DEV_LOOKUP_ARGS(args); 2391 struct btrfs_device *device; 2392 int ret; 2393 2394 if (devid) { 2395 args.devid = devid; 2396 device = btrfs_find_device(fs_info->fs_devices, &args); 2397 if (!device) 2398 return ERR_PTR(-ENOENT); 2399 return device; 2400 } 2401 2402 ret = btrfs_get_dev_args_from_path(fs_info, &args, device_path); 2403 if (ret) 2404 return ERR_PTR(ret); 2405 device = btrfs_find_device(fs_info->fs_devices, &args); 2406 btrfs_put_dev_args_from_path(&args); 2407 if (!device) 2408 return ERR_PTR(-ENOENT); 2409 return device; 2410 } 2411 2412 static struct btrfs_fs_devices *btrfs_init_sprout(struct btrfs_fs_info *fs_info) 2413 { 2414 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 2415 struct btrfs_fs_devices *old_devices; 2416 struct btrfs_fs_devices *seed_devices; 2417 2418 lockdep_assert_held(&uuid_mutex); 2419 if (!fs_devices->seeding) 2420 return ERR_PTR(-EINVAL); 2421 2422 /* 2423 * Private copy of the seed devices, anchored at 2424 * fs_info->fs_devices->seed_list 2425 */ 2426 seed_devices = alloc_fs_devices(NULL, NULL); 2427 if (IS_ERR(seed_devices)) 2428 return seed_devices; 2429 2430 /* 2431 * It's necessary to retain a copy of the original seed fs_devices in 2432 * fs_uuids so that filesystems which have been seeded can successfully 2433 * reference the seed device from open_seed_devices. This also supports 2434 * multiple fs seed. 2435 */ 2436 old_devices = clone_fs_devices(fs_devices); 2437 if (IS_ERR(old_devices)) { 2438 kfree(seed_devices); 2439 return old_devices; 2440 } 2441 2442 list_add(&old_devices->fs_list, &fs_uuids); 2443 2444 memcpy(seed_devices, fs_devices, sizeof(*seed_devices)); 2445 seed_devices->opened = 1; 2446 INIT_LIST_HEAD(&seed_devices->devices); 2447 INIT_LIST_HEAD(&seed_devices->alloc_list); 2448 mutex_init(&seed_devices->device_list_mutex); 2449 2450 return seed_devices; 2451 } 2452 2453 /* 2454 * Splice seed devices into the sprout fs_devices. 2455 * Generate a new fsid for the sprouted read-write filesystem. 2456 */ 2457 static void btrfs_setup_sprout(struct btrfs_fs_info *fs_info, 2458 struct btrfs_fs_devices *seed_devices) 2459 { 2460 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 2461 struct btrfs_super_block *disk_super = fs_info->super_copy; 2462 struct btrfs_device *device; 2463 u64 super_flags; 2464 2465 /* 2466 * We are updating the fsid, the thread leading to device_list_add() 2467 * could race, so uuid_mutex is needed. 2468 */ 2469 lockdep_assert_held(&uuid_mutex); 2470 2471 /* 2472 * The threads listed below may traverse dev_list but can do that without 2473 * device_list_mutex: 2474 * - All device ops and balance - as we are in btrfs_exclop_start. 2475 * - Various dev_list readers - are using RCU. 2476 * - btrfs_ioctl_fitrim() - is using RCU. 2477 * 2478 * For-read threads as below are using device_list_mutex: 2479 * - Readonly scrub btrfs_scrub_dev() 2480 * - Readonly scrub btrfs_scrub_progress() 2481 * - btrfs_get_dev_stats() 2482 */ 2483 lockdep_assert_held(&fs_devices->device_list_mutex); 2484 2485 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices, 2486 synchronize_rcu); 2487 list_for_each_entry(device, &seed_devices->devices, dev_list) 2488 device->fs_devices = seed_devices; 2489 2490 fs_devices->seeding = false; 2491 fs_devices->num_devices = 0; 2492 fs_devices->open_devices = 0; 2493 fs_devices->missing_devices = 0; 2494 fs_devices->rotating = false; 2495 list_add(&seed_devices->seed_list, &fs_devices->seed_list); 2496 2497 generate_random_uuid(fs_devices->fsid); 2498 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE); 2499 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE); 2500 2501 super_flags = btrfs_super_flags(disk_super) & 2502 ~BTRFS_SUPER_FLAG_SEEDING; 2503 btrfs_set_super_flags(disk_super, super_flags); 2504 } 2505 2506 /* 2507 * Store the expected generation for seed devices in device items. 2508 */ 2509 static int btrfs_finish_sprout(struct btrfs_trans_handle *trans) 2510 { 2511 BTRFS_DEV_LOOKUP_ARGS(args); 2512 struct btrfs_fs_info *fs_info = trans->fs_info; 2513 struct btrfs_root *root = fs_info->chunk_root; 2514 struct btrfs_path *path; 2515 struct extent_buffer *leaf; 2516 struct btrfs_dev_item *dev_item; 2517 struct btrfs_device *device; 2518 struct btrfs_key key; 2519 u8 fs_uuid[BTRFS_FSID_SIZE]; 2520 u8 dev_uuid[BTRFS_UUID_SIZE]; 2521 int ret; 2522 2523 path = btrfs_alloc_path(); 2524 if (!path) 2525 return -ENOMEM; 2526 2527 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 2528 key.offset = 0; 2529 key.type = BTRFS_DEV_ITEM_KEY; 2530 2531 while (1) { 2532 btrfs_reserve_chunk_metadata(trans, false); 2533 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 2534 btrfs_trans_release_chunk_metadata(trans); 2535 if (ret < 0) 2536 goto error; 2537 2538 leaf = path->nodes[0]; 2539 next_slot: 2540 if (path->slots[0] >= btrfs_header_nritems(leaf)) { 2541 ret = btrfs_next_leaf(root, path); 2542 if (ret > 0) 2543 break; 2544 if (ret < 0) 2545 goto error; 2546 leaf = path->nodes[0]; 2547 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 2548 btrfs_release_path(path); 2549 continue; 2550 } 2551 2552 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 2553 if (key.objectid != BTRFS_DEV_ITEMS_OBJECTID || 2554 key.type != BTRFS_DEV_ITEM_KEY) 2555 break; 2556 2557 dev_item = btrfs_item_ptr(leaf, path->slots[0], 2558 struct btrfs_dev_item); 2559 args.devid = btrfs_device_id(leaf, dev_item); 2560 read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item), 2561 BTRFS_UUID_SIZE); 2562 read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item), 2563 BTRFS_FSID_SIZE); 2564 args.uuid = dev_uuid; 2565 args.fsid = fs_uuid; 2566 device = btrfs_find_device(fs_info->fs_devices, &args); 2567 BUG_ON(!device); /* Logic error */ 2568 2569 if (device->fs_devices->seeding) { 2570 btrfs_set_device_generation(leaf, dev_item, 2571 device->generation); 2572 btrfs_mark_buffer_dirty(leaf); 2573 } 2574 2575 path->slots[0]++; 2576 goto next_slot; 2577 } 2578 ret = 0; 2579 error: 2580 btrfs_free_path(path); 2581 return ret; 2582 } 2583 2584 int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path) 2585 { 2586 struct btrfs_root *root = fs_info->dev_root; 2587 struct btrfs_trans_handle *trans; 2588 struct btrfs_device *device; 2589 struct block_device *bdev; 2590 struct super_block *sb = fs_info->sb; 2591 struct rcu_string *name; 2592 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 2593 struct btrfs_fs_devices *seed_devices; 2594 u64 orig_super_total_bytes; 2595 u64 orig_super_num_devices; 2596 int ret = 0; 2597 bool seeding_dev = false; 2598 bool locked = false; 2599 2600 if (sb_rdonly(sb) && !fs_devices->seeding) 2601 return -EROFS; 2602 2603 bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL, 2604 fs_info->bdev_holder); 2605 if (IS_ERR(bdev)) 2606 return PTR_ERR(bdev); 2607 2608 if (!btrfs_check_device_zone_type(fs_info, bdev)) { 2609 ret = -EINVAL; 2610 goto error; 2611 } 2612 2613 if (fs_devices->seeding) { 2614 seeding_dev = true; 2615 down_write(&sb->s_umount); 2616 mutex_lock(&uuid_mutex); 2617 locked = true; 2618 } 2619 2620 sync_blockdev(bdev); 2621 2622 rcu_read_lock(); 2623 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { 2624 if (device->bdev == bdev) { 2625 ret = -EEXIST; 2626 rcu_read_unlock(); 2627 goto error; 2628 } 2629 } 2630 rcu_read_unlock(); 2631 2632 device = btrfs_alloc_device(fs_info, NULL, NULL); 2633 if (IS_ERR(device)) { 2634 /* we can safely leave the fs_devices entry around */ 2635 ret = PTR_ERR(device); 2636 goto error; 2637 } 2638 2639 name = rcu_string_strdup(device_path, GFP_KERNEL); 2640 if (!name) { 2641 ret = -ENOMEM; 2642 goto error_free_device; 2643 } 2644 rcu_assign_pointer(device->name, name); 2645 2646 device->fs_info = fs_info; 2647 device->bdev = bdev; 2648 ret = lookup_bdev(device_path, &device->devt); 2649 if (ret) 2650 goto error_free_device; 2651 2652 ret = btrfs_get_dev_zone_info(device, false); 2653 if (ret) 2654 goto error_free_device; 2655 2656 trans = btrfs_start_transaction(root, 0); 2657 if (IS_ERR(trans)) { 2658 ret = PTR_ERR(trans); 2659 goto error_free_zone; 2660 } 2661 2662 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 2663 device->generation = trans->transid; 2664 device->io_width = fs_info->sectorsize; 2665 device->io_align = fs_info->sectorsize; 2666 device->sector_size = fs_info->sectorsize; 2667 device->total_bytes = 2668 round_down(bdev_nr_bytes(bdev), fs_info->sectorsize); 2669 device->disk_total_bytes = device->total_bytes; 2670 device->commit_total_bytes = device->total_bytes; 2671 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 2672 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); 2673 device->mode = FMODE_EXCL; 2674 device->dev_stats_valid = 1; 2675 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); 2676 2677 if (seeding_dev) { 2678 btrfs_clear_sb_rdonly(sb); 2679 2680 /* GFP_KERNEL allocation must not be under device_list_mutex */ 2681 seed_devices = btrfs_init_sprout(fs_info); 2682 if (IS_ERR(seed_devices)) { 2683 ret = PTR_ERR(seed_devices); 2684 btrfs_abort_transaction(trans, ret); 2685 goto error_trans; 2686 } 2687 } 2688 2689 mutex_lock(&fs_devices->device_list_mutex); 2690 if (seeding_dev) { 2691 btrfs_setup_sprout(fs_info, seed_devices); 2692 btrfs_assign_next_active_device(fs_info->fs_devices->latest_dev, 2693 device); 2694 } 2695 2696 device->fs_devices = fs_devices; 2697 2698 mutex_lock(&fs_info->chunk_mutex); 2699 list_add_rcu(&device->dev_list, &fs_devices->devices); 2700 list_add(&device->dev_alloc_list, &fs_devices->alloc_list); 2701 fs_devices->num_devices++; 2702 fs_devices->open_devices++; 2703 fs_devices->rw_devices++; 2704 fs_devices->total_devices++; 2705 fs_devices->total_rw_bytes += device->total_bytes; 2706 2707 atomic64_add(device->total_bytes, &fs_info->free_chunk_space); 2708 2709 if (!blk_queue_nonrot(bdev_get_queue(bdev))) 2710 fs_devices->rotating = true; 2711 2712 orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy); 2713 btrfs_set_super_total_bytes(fs_info->super_copy, 2714 round_down(orig_super_total_bytes + device->total_bytes, 2715 fs_info->sectorsize)); 2716 2717 orig_super_num_devices = btrfs_super_num_devices(fs_info->super_copy); 2718 btrfs_set_super_num_devices(fs_info->super_copy, 2719 orig_super_num_devices + 1); 2720 2721 /* 2722 * we've got more storage, clear any full flags on the space 2723 * infos 2724 */ 2725 btrfs_clear_space_info_full(fs_info); 2726 2727 mutex_unlock(&fs_info->chunk_mutex); 2728 2729 /* Add sysfs device entry */ 2730 btrfs_sysfs_add_device(device); 2731 2732 mutex_unlock(&fs_devices->device_list_mutex); 2733 2734 if (seeding_dev) { 2735 mutex_lock(&fs_info->chunk_mutex); 2736 ret = init_first_rw_device(trans); 2737 mutex_unlock(&fs_info->chunk_mutex); 2738 if (ret) { 2739 btrfs_abort_transaction(trans, ret); 2740 goto error_sysfs; 2741 } 2742 } 2743 2744 ret = btrfs_add_dev_item(trans, device); 2745 if (ret) { 2746 btrfs_abort_transaction(trans, ret); 2747 goto error_sysfs; 2748 } 2749 2750 if (seeding_dev) { 2751 ret = btrfs_finish_sprout(trans); 2752 if (ret) { 2753 btrfs_abort_transaction(trans, ret); 2754 goto error_sysfs; 2755 } 2756 2757 /* 2758 * fs_devices now represents the newly sprouted filesystem and 2759 * its fsid has been changed by btrfs_sprout_splice(). 2760 */ 2761 btrfs_sysfs_update_sprout_fsid(fs_devices); 2762 } 2763 2764 ret = btrfs_commit_transaction(trans); 2765 2766 if (seeding_dev) { 2767 mutex_unlock(&uuid_mutex); 2768 up_write(&sb->s_umount); 2769 locked = false; 2770 2771 if (ret) /* transaction commit */ 2772 return ret; 2773 2774 ret = btrfs_relocate_sys_chunks(fs_info); 2775 if (ret < 0) 2776 btrfs_handle_fs_error(fs_info, ret, 2777 "Failed to relocate sys chunks after device initialization. This can be fixed using the \"btrfs balance\" command."); 2778 trans = btrfs_attach_transaction(root); 2779 if (IS_ERR(trans)) { 2780 if (PTR_ERR(trans) == -ENOENT) 2781 return 0; 2782 ret = PTR_ERR(trans); 2783 trans = NULL; 2784 goto error_sysfs; 2785 } 2786 ret = btrfs_commit_transaction(trans); 2787 } 2788 2789 /* 2790 * Now that we have written a new super block to this device, check all 2791 * other fs_devices list if device_path alienates any other scanned 2792 * device. 2793 * We can ignore the return value as it typically returns -EINVAL and 2794 * only succeeds if the device was an alien. 2795 */ 2796 btrfs_forget_devices(device->devt); 2797 2798 /* Update ctime/mtime for blkid or udev */ 2799 update_dev_time(device_path); 2800 2801 return ret; 2802 2803 error_sysfs: 2804 btrfs_sysfs_remove_device(device); 2805 mutex_lock(&fs_info->fs_devices->device_list_mutex); 2806 mutex_lock(&fs_info->chunk_mutex); 2807 list_del_rcu(&device->dev_list); 2808 list_del(&device->dev_alloc_list); 2809 fs_info->fs_devices->num_devices--; 2810 fs_info->fs_devices->open_devices--; 2811 fs_info->fs_devices->rw_devices--; 2812 fs_info->fs_devices->total_devices--; 2813 fs_info->fs_devices->total_rw_bytes -= device->total_bytes; 2814 atomic64_sub(device->total_bytes, &fs_info->free_chunk_space); 2815 btrfs_set_super_total_bytes(fs_info->super_copy, 2816 orig_super_total_bytes); 2817 btrfs_set_super_num_devices(fs_info->super_copy, 2818 orig_super_num_devices); 2819 mutex_unlock(&fs_info->chunk_mutex); 2820 mutex_unlock(&fs_info->fs_devices->device_list_mutex); 2821 error_trans: 2822 if (seeding_dev) 2823 btrfs_set_sb_rdonly(sb); 2824 if (trans) 2825 btrfs_end_transaction(trans); 2826 error_free_zone: 2827 btrfs_destroy_dev_zone_info(device); 2828 error_free_device: 2829 btrfs_free_device(device); 2830 error: 2831 blkdev_put(bdev, FMODE_EXCL); 2832 if (locked) { 2833 mutex_unlock(&uuid_mutex); 2834 up_write(&sb->s_umount); 2835 } 2836 return ret; 2837 } 2838 2839 static noinline int btrfs_update_device(struct btrfs_trans_handle *trans, 2840 struct btrfs_device *device) 2841 { 2842 int ret; 2843 struct btrfs_path *path; 2844 struct btrfs_root *root = device->fs_info->chunk_root; 2845 struct btrfs_dev_item *dev_item; 2846 struct extent_buffer *leaf; 2847 struct btrfs_key key; 2848 2849 path = btrfs_alloc_path(); 2850 if (!path) 2851 return -ENOMEM; 2852 2853 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 2854 key.type = BTRFS_DEV_ITEM_KEY; 2855 key.offset = device->devid; 2856 2857 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 2858 if (ret < 0) 2859 goto out; 2860 2861 if (ret > 0) { 2862 ret = -ENOENT; 2863 goto out; 2864 } 2865 2866 leaf = path->nodes[0]; 2867 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); 2868 2869 btrfs_set_device_id(leaf, dev_item, device->devid); 2870 btrfs_set_device_type(leaf, dev_item, device->type); 2871 btrfs_set_device_io_align(leaf, dev_item, device->io_align); 2872 btrfs_set_device_io_width(leaf, dev_item, device->io_width); 2873 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); 2874 btrfs_set_device_total_bytes(leaf, dev_item, 2875 btrfs_device_get_disk_total_bytes(device)); 2876 btrfs_set_device_bytes_used(leaf, dev_item, 2877 btrfs_device_get_bytes_used(device)); 2878 btrfs_mark_buffer_dirty(leaf); 2879 2880 out: 2881 btrfs_free_path(path); 2882 return ret; 2883 } 2884 2885 int btrfs_grow_device(struct btrfs_trans_handle *trans, 2886 struct btrfs_device *device, u64 new_size) 2887 { 2888 struct btrfs_fs_info *fs_info = device->fs_info; 2889 struct btrfs_super_block *super_copy = fs_info->super_copy; 2890 u64 old_total; 2891 u64 diff; 2892 int ret; 2893 2894 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) 2895 return -EACCES; 2896 2897 new_size = round_down(new_size, fs_info->sectorsize); 2898 2899 mutex_lock(&fs_info->chunk_mutex); 2900 old_total = btrfs_super_total_bytes(super_copy); 2901 diff = round_down(new_size - device->total_bytes, fs_info->sectorsize); 2902 2903 if (new_size <= device->total_bytes || 2904 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { 2905 mutex_unlock(&fs_info->chunk_mutex); 2906 return -EINVAL; 2907 } 2908 2909 btrfs_set_super_total_bytes(super_copy, 2910 round_down(old_total + diff, fs_info->sectorsize)); 2911 device->fs_devices->total_rw_bytes += diff; 2912 2913 btrfs_device_set_total_bytes(device, new_size); 2914 btrfs_device_set_disk_total_bytes(device, new_size); 2915 btrfs_clear_space_info_full(device->fs_info); 2916 if (list_empty(&device->post_commit_list)) 2917 list_add_tail(&device->post_commit_list, 2918 &trans->transaction->dev_update_list); 2919 mutex_unlock(&fs_info->chunk_mutex); 2920 2921 btrfs_reserve_chunk_metadata(trans, false); 2922 ret = btrfs_update_device(trans, device); 2923 btrfs_trans_release_chunk_metadata(trans); 2924 2925 return ret; 2926 } 2927 2928 static int btrfs_free_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) 2929 { 2930 struct btrfs_fs_info *fs_info = trans->fs_info; 2931 struct btrfs_root *root = fs_info->chunk_root; 2932 int ret; 2933 struct btrfs_path *path; 2934 struct btrfs_key key; 2935 2936 path = btrfs_alloc_path(); 2937 if (!path) 2938 return -ENOMEM; 2939 2940 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; 2941 key.offset = chunk_offset; 2942 key.type = BTRFS_CHUNK_ITEM_KEY; 2943 2944 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 2945 if (ret < 0) 2946 goto out; 2947 else if (ret > 0) { /* Logic error or corruption */ 2948 btrfs_handle_fs_error(fs_info, -ENOENT, 2949 "Failed lookup while freeing chunk."); 2950 ret = -ENOENT; 2951 goto out; 2952 } 2953 2954 ret = btrfs_del_item(trans, root, path); 2955 if (ret < 0) 2956 btrfs_handle_fs_error(fs_info, ret, 2957 "Failed to delete chunk item."); 2958 out: 2959 btrfs_free_path(path); 2960 return ret; 2961 } 2962 2963 static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset) 2964 { 2965 struct btrfs_super_block *super_copy = fs_info->super_copy; 2966 struct btrfs_disk_key *disk_key; 2967 struct btrfs_chunk *chunk; 2968 u8 *ptr; 2969 int ret = 0; 2970 u32 num_stripes; 2971 u32 array_size; 2972 u32 len = 0; 2973 u32 cur; 2974 struct btrfs_key key; 2975 2976 lockdep_assert_held(&fs_info->chunk_mutex); 2977 array_size = btrfs_super_sys_array_size(super_copy); 2978 2979 ptr = super_copy->sys_chunk_array; 2980 cur = 0; 2981 2982 while (cur < array_size) { 2983 disk_key = (struct btrfs_disk_key *)ptr; 2984 btrfs_disk_key_to_cpu(&key, disk_key); 2985 2986 len = sizeof(*disk_key); 2987 2988 if (key.type == BTRFS_CHUNK_ITEM_KEY) { 2989 chunk = (struct btrfs_chunk *)(ptr + len); 2990 num_stripes = btrfs_stack_chunk_num_stripes(chunk); 2991 len += btrfs_chunk_item_size(num_stripes); 2992 } else { 2993 ret = -EIO; 2994 break; 2995 } 2996 if (key.objectid == BTRFS_FIRST_CHUNK_TREE_OBJECTID && 2997 key.offset == chunk_offset) { 2998 memmove(ptr, ptr + len, array_size - (cur + len)); 2999 array_size -= len; 3000 btrfs_set_super_sys_array_size(super_copy, array_size); 3001 } else { 3002 ptr += len; 3003 cur += len; 3004 } 3005 } 3006 return ret; 3007 } 3008 3009 /* 3010 * btrfs_get_chunk_map() - Find the mapping containing the given logical extent. 3011 * @logical: Logical block offset in bytes. 3012 * @length: Length of extent in bytes. 3013 * 3014 * Return: Chunk mapping or ERR_PTR. 3015 */ 3016 struct extent_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info, 3017 u64 logical, u64 length) 3018 { 3019 struct extent_map_tree *em_tree; 3020 struct extent_map *em; 3021 3022 em_tree = &fs_info->mapping_tree; 3023 read_lock(&em_tree->lock); 3024 em = lookup_extent_mapping(em_tree, logical, length); 3025 read_unlock(&em_tree->lock); 3026 3027 if (!em) { 3028 btrfs_crit(fs_info, "unable to find logical %llu length %llu", 3029 logical, length); 3030 return ERR_PTR(-EINVAL); 3031 } 3032 3033 if (em->start > logical || em->start + em->len < logical) { 3034 btrfs_crit(fs_info, 3035 "found a bad mapping, wanted %llu-%llu, found %llu-%llu", 3036 logical, length, em->start, em->start + em->len); 3037 free_extent_map(em); 3038 return ERR_PTR(-EINVAL); 3039 } 3040 3041 /* callers are responsible for dropping em's ref. */ 3042 return em; 3043 } 3044 3045 static int remove_chunk_item(struct btrfs_trans_handle *trans, 3046 struct map_lookup *map, u64 chunk_offset) 3047 { 3048 int i; 3049 3050 /* 3051 * Removing chunk items and updating the device items in the chunks btree 3052 * requires holding the chunk_mutex. 3053 * See the comment at btrfs_chunk_alloc() for the details. 3054 */ 3055 lockdep_assert_held(&trans->fs_info->chunk_mutex); 3056 3057 for (i = 0; i < map->num_stripes; i++) { 3058 int ret; 3059 3060 ret = btrfs_update_device(trans, map->stripes[i].dev); 3061 if (ret) 3062 return ret; 3063 } 3064 3065 return btrfs_free_chunk(trans, chunk_offset); 3066 } 3067 3068 int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) 3069 { 3070 struct btrfs_fs_info *fs_info = trans->fs_info; 3071 struct extent_map *em; 3072 struct map_lookup *map; 3073 u64 dev_extent_len = 0; 3074 int i, ret = 0; 3075 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 3076 3077 em = btrfs_get_chunk_map(fs_info, chunk_offset, 1); 3078 if (IS_ERR(em)) { 3079 /* 3080 * This is a logic error, but we don't want to just rely on the 3081 * user having built with ASSERT enabled, so if ASSERT doesn't 3082 * do anything we still error out. 3083 */ 3084 ASSERT(0); 3085 return PTR_ERR(em); 3086 } 3087 map = em->map_lookup; 3088 3089 /* 3090 * First delete the device extent items from the devices btree. 3091 * We take the device_list_mutex to avoid racing with the finishing phase 3092 * of a device replace operation. See the comment below before acquiring 3093 * fs_info->chunk_mutex. Note that here we do not acquire the chunk_mutex 3094 * because that can result in a deadlock when deleting the device extent 3095 * items from the devices btree - COWing an extent buffer from the btree 3096 * may result in allocating a new metadata chunk, which would attempt to 3097 * lock again fs_info->chunk_mutex. 3098 */ 3099 mutex_lock(&fs_devices->device_list_mutex); 3100 for (i = 0; i < map->num_stripes; i++) { 3101 struct btrfs_device *device = map->stripes[i].dev; 3102 ret = btrfs_free_dev_extent(trans, device, 3103 map->stripes[i].physical, 3104 &dev_extent_len); 3105 if (ret) { 3106 mutex_unlock(&fs_devices->device_list_mutex); 3107 btrfs_abort_transaction(trans, ret); 3108 goto out; 3109 } 3110 3111 if (device->bytes_used > 0) { 3112 mutex_lock(&fs_info->chunk_mutex); 3113 btrfs_device_set_bytes_used(device, 3114 device->bytes_used - dev_extent_len); 3115 atomic64_add(dev_extent_len, &fs_info->free_chunk_space); 3116 btrfs_clear_space_info_full(fs_info); 3117 mutex_unlock(&fs_info->chunk_mutex); 3118 } 3119 } 3120 mutex_unlock(&fs_devices->device_list_mutex); 3121 3122 /* 3123 * We acquire fs_info->chunk_mutex for 2 reasons: 3124 * 3125 * 1) Just like with the first phase of the chunk allocation, we must 3126 * reserve system space, do all chunk btree updates and deletions, and 3127 * update the system chunk array in the superblock while holding this 3128 * mutex. This is for similar reasons as explained on the comment at 3129 * the top of btrfs_chunk_alloc(); 3130 * 3131 * 2) Prevent races with the final phase of a device replace operation 3132 * that replaces the device object associated with the map's stripes, 3133 * because the device object's id can change at any time during that 3134 * final phase of the device replace operation 3135 * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the 3136 * replaced device and then see it with an ID of 3137 * BTRFS_DEV_REPLACE_DEVID, which would cause a failure when updating 3138 * the device item, which does not exists on the chunk btree. 3139 * The finishing phase of device replace acquires both the 3140 * device_list_mutex and the chunk_mutex, in that order, so we are 3141 * safe by just acquiring the chunk_mutex. 3142 */ 3143 trans->removing_chunk = true; 3144 mutex_lock(&fs_info->chunk_mutex); 3145 3146 check_system_chunk(trans, map->type); 3147 3148 ret = remove_chunk_item(trans, map, chunk_offset); 3149 /* 3150 * Normally we should not get -ENOSPC since we reserved space before 3151 * through the call to check_system_chunk(). 3152 * 3153 * Despite our system space_info having enough free space, we may not 3154 * be able to allocate extents from its block groups, because all have 3155 * an incompatible profile, which will force us to allocate a new system 3156 * block group with the right profile, or right after we called 3157 * check_system_space() above, a scrub turned the only system block group 3158 * with enough free space into RO mode. 3159 * This is explained with more detail at do_chunk_alloc(). 3160 * 3161 * So if we get -ENOSPC, allocate a new system chunk and retry once. 3162 */ 3163 if (ret == -ENOSPC) { 3164 const u64 sys_flags = btrfs_system_alloc_profile(fs_info); 3165 struct btrfs_block_group *sys_bg; 3166 3167 sys_bg = btrfs_create_chunk(trans, sys_flags); 3168 if (IS_ERR(sys_bg)) { 3169 ret = PTR_ERR(sys_bg); 3170 btrfs_abort_transaction(trans, ret); 3171 goto out; 3172 } 3173 3174 ret = btrfs_chunk_alloc_add_chunk_item(trans, sys_bg); 3175 if (ret) { 3176 btrfs_abort_transaction(trans, ret); 3177 goto out; 3178 } 3179 3180 ret = remove_chunk_item(trans, map, chunk_offset); 3181 if (ret) { 3182 btrfs_abort_transaction(trans, ret); 3183 goto out; 3184 } 3185 } else if (ret) { 3186 btrfs_abort_transaction(trans, ret); 3187 goto out; 3188 } 3189 3190 trace_btrfs_chunk_free(fs_info, map, chunk_offset, em->len); 3191 3192 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { 3193 ret = btrfs_del_sys_chunk(fs_info, chunk_offset); 3194 if (ret) { 3195 btrfs_abort_transaction(trans, ret); 3196 goto out; 3197 } 3198 } 3199 3200 mutex_unlock(&fs_info->chunk_mutex); 3201 trans->removing_chunk = false; 3202 3203 /* 3204 * We are done with chunk btree updates and deletions, so release the 3205 * system space we previously reserved (with check_system_chunk()). 3206 */ 3207 btrfs_trans_release_chunk_metadata(trans); 3208 3209 ret = btrfs_remove_block_group(trans, chunk_offset, em); 3210 if (ret) { 3211 btrfs_abort_transaction(trans, ret); 3212 goto out; 3213 } 3214 3215 out: 3216 if (trans->removing_chunk) { 3217 mutex_unlock(&fs_info->chunk_mutex); 3218 trans->removing_chunk = false; 3219 } 3220 /* once for us */ 3221 free_extent_map(em); 3222 return ret; 3223 } 3224 3225 int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset) 3226 { 3227 struct btrfs_root *root = fs_info->chunk_root; 3228 struct btrfs_trans_handle *trans; 3229 struct btrfs_block_group *block_group; 3230 u64 length; 3231 int ret; 3232 3233 if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) { 3234 btrfs_err(fs_info, 3235 "relocate: not supported on extent tree v2 yet"); 3236 return -EINVAL; 3237 } 3238 3239 /* 3240 * Prevent races with automatic removal of unused block groups. 3241 * After we relocate and before we remove the chunk with offset 3242 * chunk_offset, automatic removal of the block group can kick in, 3243 * resulting in a failure when calling btrfs_remove_chunk() below. 3244 * 3245 * Make sure to acquire this mutex before doing a tree search (dev 3246 * or chunk trees) to find chunks. Otherwise the cleaner kthread might 3247 * call btrfs_remove_chunk() (through btrfs_delete_unused_bgs()) after 3248 * we release the path used to search the chunk/dev tree and before 3249 * the current task acquires this mutex and calls us. 3250 */ 3251 lockdep_assert_held(&fs_info->reclaim_bgs_lock); 3252 3253 /* step one, relocate all the extents inside this chunk */ 3254 btrfs_scrub_pause(fs_info); 3255 ret = btrfs_relocate_block_group(fs_info, chunk_offset); 3256 btrfs_scrub_continue(fs_info); 3257 if (ret) 3258 return ret; 3259 3260 block_group = btrfs_lookup_block_group(fs_info, chunk_offset); 3261 if (!block_group) 3262 return -ENOENT; 3263 btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group); 3264 length = block_group->length; 3265 btrfs_put_block_group(block_group); 3266 3267 /* 3268 * On a zoned file system, discard the whole block group, this will 3269 * trigger a REQ_OP_ZONE_RESET operation on the device zone. If 3270 * resetting the zone fails, don't treat it as a fatal problem from the 3271 * filesystem's point of view. 3272 */ 3273 if (btrfs_is_zoned(fs_info)) { 3274 ret = btrfs_discard_extent(fs_info, chunk_offset, length, NULL); 3275 if (ret) 3276 btrfs_info(fs_info, 3277 "failed to reset zone %llu after relocation", 3278 chunk_offset); 3279 } 3280 3281 trans = btrfs_start_trans_remove_block_group(root->fs_info, 3282 chunk_offset); 3283 if (IS_ERR(trans)) { 3284 ret = PTR_ERR(trans); 3285 btrfs_handle_fs_error(root->fs_info, ret, NULL); 3286 return ret; 3287 } 3288 3289 /* 3290 * step two, delete the device extents and the 3291 * chunk tree entries 3292 */ 3293 ret = btrfs_remove_chunk(trans, chunk_offset); 3294 btrfs_end_transaction(trans); 3295 return ret; 3296 } 3297 3298 static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info) 3299 { 3300 struct btrfs_root *chunk_root = fs_info->chunk_root; 3301 struct btrfs_path *path; 3302 struct extent_buffer *leaf; 3303 struct btrfs_chunk *chunk; 3304 struct btrfs_key key; 3305 struct btrfs_key found_key; 3306 u64 chunk_type; 3307 bool retried = false; 3308 int failed = 0; 3309 int ret; 3310 3311 path = btrfs_alloc_path(); 3312 if (!path) 3313 return -ENOMEM; 3314 3315 again: 3316 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; 3317 key.offset = (u64)-1; 3318 key.type = BTRFS_CHUNK_ITEM_KEY; 3319 3320 while (1) { 3321 mutex_lock(&fs_info->reclaim_bgs_lock); 3322 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); 3323 if (ret < 0) { 3324 mutex_unlock(&fs_info->reclaim_bgs_lock); 3325 goto error; 3326 } 3327 BUG_ON(ret == 0); /* Corruption */ 3328 3329 ret = btrfs_previous_item(chunk_root, path, key.objectid, 3330 key.type); 3331 if (ret) 3332 mutex_unlock(&fs_info->reclaim_bgs_lock); 3333 if (ret < 0) 3334 goto error; 3335 if (ret > 0) 3336 break; 3337 3338 leaf = path->nodes[0]; 3339 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 3340 3341 chunk = btrfs_item_ptr(leaf, path->slots[0], 3342 struct btrfs_chunk); 3343 chunk_type = btrfs_chunk_type(leaf, chunk); 3344 btrfs_release_path(path); 3345 3346 if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) { 3347 ret = btrfs_relocate_chunk(fs_info, found_key.offset); 3348 if (ret == -ENOSPC) 3349 failed++; 3350 else 3351 BUG_ON(ret); 3352 } 3353 mutex_unlock(&fs_info->reclaim_bgs_lock); 3354 3355 if (found_key.offset == 0) 3356 break; 3357 key.offset = found_key.offset - 1; 3358 } 3359 ret = 0; 3360 if (failed && !retried) { 3361 failed = 0; 3362 retried = true; 3363 goto again; 3364 } else if (WARN_ON(failed && retried)) { 3365 ret = -ENOSPC; 3366 } 3367 error: 3368 btrfs_free_path(path); 3369 return ret; 3370 } 3371 3372 /* 3373 * return 1 : allocate a data chunk successfully, 3374 * return <0: errors during allocating a data chunk, 3375 * return 0 : no need to allocate a data chunk. 3376 */ 3377 static int btrfs_may_alloc_data_chunk(struct btrfs_fs_info *fs_info, 3378 u64 chunk_offset) 3379 { 3380 struct btrfs_block_group *cache; 3381 u64 bytes_used; 3382 u64 chunk_type; 3383 3384 cache = btrfs_lookup_block_group(fs_info, chunk_offset); 3385 ASSERT(cache); 3386 chunk_type = cache->flags; 3387 btrfs_put_block_group(cache); 3388 3389 if (!(chunk_type & BTRFS_BLOCK_GROUP_DATA)) 3390 return 0; 3391 3392 spin_lock(&fs_info->data_sinfo->lock); 3393 bytes_used = fs_info->data_sinfo->bytes_used; 3394 spin_unlock(&fs_info->data_sinfo->lock); 3395 3396 if (!bytes_used) { 3397 struct btrfs_trans_handle *trans; 3398 int ret; 3399 3400 trans = btrfs_join_transaction(fs_info->tree_root); 3401 if (IS_ERR(trans)) 3402 return PTR_ERR(trans); 3403 3404 ret = btrfs_force_chunk_alloc(trans, BTRFS_BLOCK_GROUP_DATA); 3405 btrfs_end_transaction(trans); 3406 if (ret < 0) 3407 return ret; 3408 return 1; 3409 } 3410 3411 return 0; 3412 } 3413 3414 static int insert_balance_item(struct btrfs_fs_info *fs_info, 3415 struct btrfs_balance_control *bctl) 3416 { 3417 struct btrfs_root *root = fs_info->tree_root; 3418 struct btrfs_trans_handle *trans; 3419 struct btrfs_balance_item *item; 3420 struct btrfs_disk_balance_args disk_bargs; 3421 struct btrfs_path *path; 3422 struct extent_buffer *leaf; 3423 struct btrfs_key key; 3424 int ret, err; 3425 3426 path = btrfs_alloc_path(); 3427 if (!path) 3428 return -ENOMEM; 3429 3430 trans = btrfs_start_transaction(root, 0); 3431 if (IS_ERR(trans)) { 3432 btrfs_free_path(path); 3433 return PTR_ERR(trans); 3434 } 3435 3436 key.objectid = BTRFS_BALANCE_OBJECTID; 3437 key.type = BTRFS_TEMPORARY_ITEM_KEY; 3438 key.offset = 0; 3439 3440 ret = btrfs_insert_empty_item(trans, root, path, &key, 3441 sizeof(*item)); 3442 if (ret) 3443 goto out; 3444 3445 leaf = path->nodes[0]; 3446 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); 3447 3448 memzero_extent_buffer(leaf, (unsigned long)item, sizeof(*item)); 3449 3450 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data); 3451 btrfs_set_balance_data(leaf, item, &disk_bargs); 3452 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta); 3453 btrfs_set_balance_meta(leaf, item, &disk_bargs); 3454 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys); 3455 btrfs_set_balance_sys(leaf, item, &disk_bargs); 3456 3457 btrfs_set_balance_flags(leaf, item, bctl->flags); 3458 3459 btrfs_mark_buffer_dirty(leaf); 3460 out: 3461 btrfs_free_path(path); 3462 err = btrfs_commit_transaction(trans); 3463 if (err && !ret) 3464 ret = err; 3465 return ret; 3466 } 3467 3468 static int del_balance_item(struct btrfs_fs_info *fs_info) 3469 { 3470 struct btrfs_root *root = fs_info->tree_root; 3471 struct btrfs_trans_handle *trans; 3472 struct btrfs_path *path; 3473 struct btrfs_key key; 3474 int ret, err; 3475 3476 path = btrfs_alloc_path(); 3477 if (!path) 3478 return -ENOMEM; 3479 3480 trans = btrfs_start_transaction_fallback_global_rsv(root, 0); 3481 if (IS_ERR(trans)) { 3482 btrfs_free_path(path); 3483 return PTR_ERR(trans); 3484 } 3485 3486 key.objectid = BTRFS_BALANCE_OBJECTID; 3487 key.type = BTRFS_TEMPORARY_ITEM_KEY; 3488 key.offset = 0; 3489 3490 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 3491 if (ret < 0) 3492 goto out; 3493 if (ret > 0) { 3494 ret = -ENOENT; 3495 goto out; 3496 } 3497 3498 ret = btrfs_del_item(trans, root, path); 3499 out: 3500 btrfs_free_path(path); 3501 err = btrfs_commit_transaction(trans); 3502 if (err && !ret) 3503 ret = err; 3504 return ret; 3505 } 3506 3507 /* 3508 * This is a heuristic used to reduce the number of chunks balanced on 3509 * resume after balance was interrupted. 3510 */ 3511 static void update_balance_args(struct btrfs_balance_control *bctl) 3512 { 3513 /* 3514 * Turn on soft mode for chunk types that were being converted. 3515 */ 3516 if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) 3517 bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT; 3518 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) 3519 bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT; 3520 if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) 3521 bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT; 3522 3523 /* 3524 * Turn on usage filter if is not already used. The idea is 3525 * that chunks that we have already balanced should be 3526 * reasonably full. Don't do it for chunks that are being 3527 * converted - that will keep us from relocating unconverted 3528 * (albeit full) chunks. 3529 */ 3530 if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) && 3531 !(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && 3532 !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) { 3533 bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE; 3534 bctl->data.usage = 90; 3535 } 3536 if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) && 3537 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && 3538 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) { 3539 bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE; 3540 bctl->sys.usage = 90; 3541 } 3542 if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) && 3543 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && 3544 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) { 3545 bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE; 3546 bctl->meta.usage = 90; 3547 } 3548 } 3549 3550 /* 3551 * Clear the balance status in fs_info and delete the balance item from disk. 3552 */ 3553 static void reset_balance_state(struct btrfs_fs_info *fs_info) 3554 { 3555 struct btrfs_balance_control *bctl = fs_info->balance_ctl; 3556 int ret; 3557 3558 BUG_ON(!fs_info->balance_ctl); 3559 3560 spin_lock(&fs_info->balance_lock); 3561 fs_info->balance_ctl = NULL; 3562 spin_unlock(&fs_info->balance_lock); 3563 3564 kfree(bctl); 3565 ret = del_balance_item(fs_info); 3566 if (ret) 3567 btrfs_handle_fs_error(fs_info, ret, NULL); 3568 } 3569 3570 /* 3571 * Balance filters. Return 1 if chunk should be filtered out 3572 * (should not be balanced). 3573 */ 3574 static int chunk_profiles_filter(u64 chunk_type, 3575 struct btrfs_balance_args *bargs) 3576 { 3577 chunk_type = chunk_to_extended(chunk_type) & 3578 BTRFS_EXTENDED_PROFILE_MASK; 3579 3580 if (bargs->profiles & chunk_type) 3581 return 0; 3582 3583 return 1; 3584 } 3585 3586 static int chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset, 3587 struct btrfs_balance_args *bargs) 3588 { 3589 struct btrfs_block_group *cache; 3590 u64 chunk_used; 3591 u64 user_thresh_min; 3592 u64 user_thresh_max; 3593 int ret = 1; 3594 3595 cache = btrfs_lookup_block_group(fs_info, chunk_offset); 3596 chunk_used = cache->used; 3597 3598 if (bargs->usage_min == 0) 3599 user_thresh_min = 0; 3600 else 3601 user_thresh_min = div_factor_fine(cache->length, 3602 bargs->usage_min); 3603 3604 if (bargs->usage_max == 0) 3605 user_thresh_max = 1; 3606 else if (bargs->usage_max > 100) 3607 user_thresh_max = cache->length; 3608 else 3609 user_thresh_max = div_factor_fine(cache->length, 3610 bargs->usage_max); 3611 3612 if (user_thresh_min <= chunk_used && chunk_used < user_thresh_max) 3613 ret = 0; 3614 3615 btrfs_put_block_group(cache); 3616 return ret; 3617 } 3618 3619 static int chunk_usage_filter(struct btrfs_fs_info *fs_info, 3620 u64 chunk_offset, struct btrfs_balance_args *bargs) 3621 { 3622 struct btrfs_block_group *cache; 3623 u64 chunk_used, user_thresh; 3624 int ret = 1; 3625 3626 cache = btrfs_lookup_block_group(fs_info, chunk_offset); 3627 chunk_used = cache->used; 3628 3629 if (bargs->usage_min == 0) 3630 user_thresh = 1; 3631 else if (bargs->usage > 100) 3632 user_thresh = cache->length; 3633 else 3634 user_thresh = div_factor_fine(cache->length, bargs->usage); 3635 3636 if (chunk_used < user_thresh) 3637 ret = 0; 3638 3639 btrfs_put_block_group(cache); 3640 return ret; 3641 } 3642 3643 static int chunk_devid_filter(struct extent_buffer *leaf, 3644 struct btrfs_chunk *chunk, 3645 struct btrfs_balance_args *bargs) 3646 { 3647 struct btrfs_stripe *stripe; 3648 int num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 3649 int i; 3650 3651 for (i = 0; i < num_stripes; i++) { 3652 stripe = btrfs_stripe_nr(chunk, i); 3653 if (btrfs_stripe_devid(leaf, stripe) == bargs->devid) 3654 return 0; 3655 } 3656 3657 return 1; 3658 } 3659 3660 static u64 calc_data_stripes(u64 type, int num_stripes) 3661 { 3662 const int index = btrfs_bg_flags_to_raid_index(type); 3663 const int ncopies = btrfs_raid_array[index].ncopies; 3664 const int nparity = btrfs_raid_array[index].nparity; 3665 3666 return (num_stripes - nparity) / ncopies; 3667 } 3668 3669 /* [pstart, pend) */ 3670 static int chunk_drange_filter(struct extent_buffer *leaf, 3671 struct btrfs_chunk *chunk, 3672 struct btrfs_balance_args *bargs) 3673 { 3674 struct btrfs_stripe *stripe; 3675 int num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 3676 u64 stripe_offset; 3677 u64 stripe_length; 3678 u64 type; 3679 int factor; 3680 int i; 3681 3682 if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID)) 3683 return 0; 3684 3685 type = btrfs_chunk_type(leaf, chunk); 3686 factor = calc_data_stripes(type, num_stripes); 3687 3688 for (i = 0; i < num_stripes; i++) { 3689 stripe = btrfs_stripe_nr(chunk, i); 3690 if (btrfs_stripe_devid(leaf, stripe) != bargs->devid) 3691 continue; 3692 3693 stripe_offset = btrfs_stripe_offset(leaf, stripe); 3694 stripe_length = btrfs_chunk_length(leaf, chunk); 3695 stripe_length = div_u64(stripe_length, factor); 3696 3697 if (stripe_offset < bargs->pend && 3698 stripe_offset + stripe_length > bargs->pstart) 3699 return 0; 3700 } 3701 3702 return 1; 3703 } 3704 3705 /* [vstart, vend) */ 3706 static int chunk_vrange_filter(struct extent_buffer *leaf, 3707 struct btrfs_chunk *chunk, 3708 u64 chunk_offset, 3709 struct btrfs_balance_args *bargs) 3710 { 3711 if (chunk_offset < bargs->vend && 3712 chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart) 3713 /* at least part of the chunk is inside this vrange */ 3714 return 0; 3715 3716 return 1; 3717 } 3718 3719 static int chunk_stripes_range_filter(struct extent_buffer *leaf, 3720 struct btrfs_chunk *chunk, 3721 struct btrfs_balance_args *bargs) 3722 { 3723 int num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 3724 3725 if (bargs->stripes_min <= num_stripes 3726 && num_stripes <= bargs->stripes_max) 3727 return 0; 3728 3729 return 1; 3730 } 3731 3732 static int chunk_soft_convert_filter(u64 chunk_type, 3733 struct btrfs_balance_args *bargs) 3734 { 3735 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) 3736 return 0; 3737 3738 chunk_type = chunk_to_extended(chunk_type) & 3739 BTRFS_EXTENDED_PROFILE_MASK; 3740 3741 if (bargs->target == chunk_type) 3742 return 1; 3743 3744 return 0; 3745 } 3746 3747 static int should_balance_chunk(struct extent_buffer *leaf, 3748 struct btrfs_chunk *chunk, u64 chunk_offset) 3749 { 3750 struct btrfs_fs_info *fs_info = leaf->fs_info; 3751 struct btrfs_balance_control *bctl = fs_info->balance_ctl; 3752 struct btrfs_balance_args *bargs = NULL; 3753 u64 chunk_type = btrfs_chunk_type(leaf, chunk); 3754 3755 /* type filter */ 3756 if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) & 3757 (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) { 3758 return 0; 3759 } 3760 3761 if (chunk_type & BTRFS_BLOCK_GROUP_DATA) 3762 bargs = &bctl->data; 3763 else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) 3764 bargs = &bctl->sys; 3765 else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA) 3766 bargs = &bctl->meta; 3767 3768 /* profiles filter */ 3769 if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) && 3770 chunk_profiles_filter(chunk_type, bargs)) { 3771 return 0; 3772 } 3773 3774 /* usage filter */ 3775 if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) && 3776 chunk_usage_filter(fs_info, chunk_offset, bargs)) { 3777 return 0; 3778 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && 3779 chunk_usage_range_filter(fs_info, chunk_offset, bargs)) { 3780 return 0; 3781 } 3782 3783 /* devid filter */ 3784 if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) && 3785 chunk_devid_filter(leaf, chunk, bargs)) { 3786 return 0; 3787 } 3788 3789 /* drange filter, makes sense only with devid filter */ 3790 if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) && 3791 chunk_drange_filter(leaf, chunk, bargs)) { 3792 return 0; 3793 } 3794 3795 /* vrange filter */ 3796 if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) && 3797 chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) { 3798 return 0; 3799 } 3800 3801 /* stripes filter */ 3802 if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) && 3803 chunk_stripes_range_filter(leaf, chunk, bargs)) { 3804 return 0; 3805 } 3806 3807 /* soft profile changing mode */ 3808 if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) && 3809 chunk_soft_convert_filter(chunk_type, bargs)) { 3810 return 0; 3811 } 3812 3813 /* 3814 * limited by count, must be the last filter 3815 */ 3816 if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) { 3817 if (bargs->limit == 0) 3818 return 0; 3819 else 3820 bargs->limit--; 3821 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) { 3822 /* 3823 * Same logic as the 'limit' filter; the minimum cannot be 3824 * determined here because we do not have the global information 3825 * about the count of all chunks that satisfy the filters. 3826 */ 3827 if (bargs->limit_max == 0) 3828 return 0; 3829 else 3830 bargs->limit_max--; 3831 } 3832 3833 return 1; 3834 } 3835 3836 static int __btrfs_balance(struct btrfs_fs_info *fs_info) 3837 { 3838 struct btrfs_balance_control *bctl = fs_info->balance_ctl; 3839 struct btrfs_root *chunk_root = fs_info->chunk_root; 3840 u64 chunk_type; 3841 struct btrfs_chunk *chunk; 3842 struct btrfs_path *path = NULL; 3843 struct btrfs_key key; 3844 struct btrfs_key found_key; 3845 struct extent_buffer *leaf; 3846 int slot; 3847 int ret; 3848 int enospc_errors = 0; 3849 bool counting = true; 3850 /* The single value limit and min/max limits use the same bytes in the */ 3851 u64 limit_data = bctl->data.limit; 3852 u64 limit_meta = bctl->meta.limit; 3853 u64 limit_sys = bctl->sys.limit; 3854 u32 count_data = 0; 3855 u32 count_meta = 0; 3856 u32 count_sys = 0; 3857 int chunk_reserved = 0; 3858 3859 path = btrfs_alloc_path(); 3860 if (!path) { 3861 ret = -ENOMEM; 3862 goto error; 3863 } 3864 3865 /* zero out stat counters */ 3866 spin_lock(&fs_info->balance_lock); 3867 memset(&bctl->stat, 0, sizeof(bctl->stat)); 3868 spin_unlock(&fs_info->balance_lock); 3869 again: 3870 if (!counting) { 3871 /* 3872 * The single value limit and min/max limits use the same bytes 3873 * in the 3874 */ 3875 bctl->data.limit = limit_data; 3876 bctl->meta.limit = limit_meta; 3877 bctl->sys.limit = limit_sys; 3878 } 3879 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; 3880 key.offset = (u64)-1; 3881 key.type = BTRFS_CHUNK_ITEM_KEY; 3882 3883 while (1) { 3884 if ((!counting && atomic_read(&fs_info->balance_pause_req)) || 3885 atomic_read(&fs_info->balance_cancel_req)) { 3886 ret = -ECANCELED; 3887 goto error; 3888 } 3889 3890 mutex_lock(&fs_info->reclaim_bgs_lock); 3891 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); 3892 if (ret < 0) { 3893 mutex_unlock(&fs_info->reclaim_bgs_lock); 3894 goto error; 3895 } 3896 3897 /* 3898 * this shouldn't happen, it means the last relocate 3899 * failed 3900 */ 3901 if (ret == 0) 3902 BUG(); /* FIXME break ? */ 3903 3904 ret = btrfs_previous_item(chunk_root, path, 0, 3905 BTRFS_CHUNK_ITEM_KEY); 3906 if (ret) { 3907 mutex_unlock(&fs_info->reclaim_bgs_lock); 3908 ret = 0; 3909 break; 3910 } 3911 3912 leaf = path->nodes[0]; 3913 slot = path->slots[0]; 3914 btrfs_item_key_to_cpu(leaf, &found_key, slot); 3915 3916 if (found_key.objectid != key.objectid) { 3917 mutex_unlock(&fs_info->reclaim_bgs_lock); 3918 break; 3919 } 3920 3921 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); 3922 chunk_type = btrfs_chunk_type(leaf, chunk); 3923 3924 if (!counting) { 3925 spin_lock(&fs_info->balance_lock); 3926 bctl->stat.considered++; 3927 spin_unlock(&fs_info->balance_lock); 3928 } 3929 3930 ret = should_balance_chunk(leaf, chunk, found_key.offset); 3931 3932 btrfs_release_path(path); 3933 if (!ret) { 3934 mutex_unlock(&fs_info->reclaim_bgs_lock); 3935 goto loop; 3936 } 3937 3938 if (counting) { 3939 mutex_unlock(&fs_info->reclaim_bgs_lock); 3940 spin_lock(&fs_info->balance_lock); 3941 bctl->stat.expected++; 3942 spin_unlock(&fs_info->balance_lock); 3943 3944 if (chunk_type & BTRFS_BLOCK_GROUP_DATA) 3945 count_data++; 3946 else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) 3947 count_sys++; 3948 else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA) 3949 count_meta++; 3950 3951 goto loop; 3952 } 3953 3954 /* 3955 * Apply limit_min filter, no need to check if the LIMITS 3956 * filter is used, limit_min is 0 by default 3957 */ 3958 if (((chunk_type & BTRFS_BLOCK_GROUP_DATA) && 3959 count_data < bctl->data.limit_min) 3960 || ((chunk_type & BTRFS_BLOCK_GROUP_METADATA) && 3961 count_meta < bctl->meta.limit_min) 3962 || ((chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) && 3963 count_sys < bctl->sys.limit_min)) { 3964 mutex_unlock(&fs_info->reclaim_bgs_lock); 3965 goto loop; 3966 } 3967 3968 if (!chunk_reserved) { 3969 /* 3970 * We may be relocating the only data chunk we have, 3971 * which could potentially end up with losing data's 3972 * raid profile, so lets allocate an empty one in 3973 * advance. 3974 */ 3975 ret = btrfs_may_alloc_data_chunk(fs_info, 3976 found_key.offset); 3977 if (ret < 0) { 3978 mutex_unlock(&fs_info->reclaim_bgs_lock); 3979 goto error; 3980 } else if (ret == 1) { 3981 chunk_reserved = 1; 3982 } 3983 } 3984 3985 ret = btrfs_relocate_chunk(fs_info, found_key.offset); 3986 mutex_unlock(&fs_info->reclaim_bgs_lock); 3987 if (ret == -ENOSPC) { 3988 enospc_errors++; 3989 } else if (ret == -ETXTBSY) { 3990 btrfs_info(fs_info, 3991 "skipping relocation of block group %llu due to active swapfile", 3992 found_key.offset); 3993 ret = 0; 3994 } else if (ret) { 3995 goto error; 3996 } else { 3997 spin_lock(&fs_info->balance_lock); 3998 bctl->stat.completed++; 3999 spin_unlock(&fs_info->balance_lock); 4000 } 4001 loop: 4002 if (found_key.offset == 0) 4003 break; 4004 key.offset = found_key.offset - 1; 4005 } 4006 4007 if (counting) { 4008 btrfs_release_path(path); 4009 counting = false; 4010 goto again; 4011 } 4012 error: 4013 btrfs_free_path(path); 4014 if (enospc_errors) { 4015 btrfs_info(fs_info, "%d enospc errors during balance", 4016 enospc_errors); 4017 if (!ret) 4018 ret = -ENOSPC; 4019 } 4020 4021 return ret; 4022 } 4023 4024 /** 4025 * alloc_profile_is_valid - see if a given profile is valid and reduced 4026 * @flags: profile to validate 4027 * @extended: if true @flags is treated as an extended profile 4028 */ 4029 static int alloc_profile_is_valid(u64 flags, int extended) 4030 { 4031 u64 mask = (extended ? BTRFS_EXTENDED_PROFILE_MASK : 4032 BTRFS_BLOCK_GROUP_PROFILE_MASK); 4033 4034 flags &= ~BTRFS_BLOCK_GROUP_TYPE_MASK; 4035 4036 /* 1) check that all other bits are zeroed */ 4037 if (flags & ~mask) 4038 return 0; 4039 4040 /* 2) see if profile is reduced */ 4041 if (flags == 0) 4042 return !extended; /* "0" is valid for usual profiles */ 4043 4044 return has_single_bit_set(flags); 4045 } 4046 4047 static inline int balance_need_close(struct btrfs_fs_info *fs_info) 4048 { 4049 /* cancel requested || normal exit path */ 4050 return atomic_read(&fs_info->balance_cancel_req) || 4051 (atomic_read(&fs_info->balance_pause_req) == 0 && 4052 atomic_read(&fs_info->balance_cancel_req) == 0); 4053 } 4054 4055 /* 4056 * Validate target profile against allowed profiles and return true if it's OK. 4057 * Otherwise print the error message and return false. 4058 */ 4059 static inline int validate_convert_profile(struct btrfs_fs_info *fs_info, 4060 const struct btrfs_balance_args *bargs, 4061 u64 allowed, const char *type) 4062 { 4063 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) 4064 return true; 4065 4066 /* Profile is valid and does not have bits outside of the allowed set */ 4067 if (alloc_profile_is_valid(bargs->target, 1) && 4068 (bargs->target & ~allowed) == 0) 4069 return true; 4070 4071 btrfs_err(fs_info, "balance: invalid convert %s profile %s", 4072 type, btrfs_bg_type_to_raid_name(bargs->target)); 4073 return false; 4074 } 4075 4076 /* 4077 * Fill @buf with textual description of balance filter flags @bargs, up to 4078 * @size_buf including the terminating null. The output may be trimmed if it 4079 * does not fit into the provided buffer. 4080 */ 4081 static void describe_balance_args(struct btrfs_balance_args *bargs, char *buf, 4082 u32 size_buf) 4083 { 4084 int ret; 4085 u32 size_bp = size_buf; 4086 char *bp = buf; 4087 u64 flags = bargs->flags; 4088 char tmp_buf[128] = {'\0'}; 4089 4090 if (!flags) 4091 return; 4092 4093 #define CHECK_APPEND_NOARG(a) \ 4094 do { \ 4095 ret = snprintf(bp, size_bp, (a)); \ 4096 if (ret < 0 || ret >= size_bp) \ 4097 goto out_overflow; \ 4098 size_bp -= ret; \ 4099 bp += ret; \ 4100 } while (0) 4101 4102 #define CHECK_APPEND_1ARG(a, v1) \ 4103 do { \ 4104 ret = snprintf(bp, size_bp, (a), (v1)); \ 4105 if (ret < 0 || ret >= size_bp) \ 4106 goto out_overflow; \ 4107 size_bp -= ret; \ 4108 bp += ret; \ 4109 } while (0) 4110 4111 #define CHECK_APPEND_2ARG(a, v1, v2) \ 4112 do { \ 4113 ret = snprintf(bp, size_bp, (a), (v1), (v2)); \ 4114 if (ret < 0 || ret >= size_bp) \ 4115 goto out_overflow; \ 4116 size_bp -= ret; \ 4117 bp += ret; \ 4118 } while (0) 4119 4120 if (flags & BTRFS_BALANCE_ARGS_CONVERT) 4121 CHECK_APPEND_1ARG("convert=%s,", 4122 btrfs_bg_type_to_raid_name(bargs->target)); 4123 4124 if (flags & BTRFS_BALANCE_ARGS_SOFT) 4125 CHECK_APPEND_NOARG("soft,"); 4126 4127 if (flags & BTRFS_BALANCE_ARGS_PROFILES) { 4128 btrfs_describe_block_groups(bargs->profiles, tmp_buf, 4129 sizeof(tmp_buf)); 4130 CHECK_APPEND_1ARG("profiles=%s,", tmp_buf); 4131 } 4132 4133 if (flags & BTRFS_BALANCE_ARGS_USAGE) 4134 CHECK_APPEND_1ARG("usage=%llu,", bargs->usage); 4135 4136 if (flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) 4137 CHECK_APPEND_2ARG("usage=%u..%u,", 4138 bargs->usage_min, bargs->usage_max); 4139 4140 if (flags & BTRFS_BALANCE_ARGS_DEVID) 4141 CHECK_APPEND_1ARG("devid=%llu,", bargs->devid); 4142 4143 if (flags & BTRFS_BALANCE_ARGS_DRANGE) 4144 CHECK_APPEND_2ARG("drange=%llu..%llu,", 4145 bargs->pstart, bargs->pend); 4146 4147 if (flags & BTRFS_BALANCE_ARGS_VRANGE) 4148 CHECK_APPEND_2ARG("vrange=%llu..%llu,", 4149 bargs->vstart, bargs->vend); 4150 4151 if (flags & BTRFS_BALANCE_ARGS_LIMIT) 4152 CHECK_APPEND_1ARG("limit=%llu,", bargs->limit); 4153 4154 if (flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE) 4155 CHECK_APPEND_2ARG("limit=%u..%u,", 4156 bargs->limit_min, bargs->limit_max); 4157 4158 if (flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) 4159 CHECK_APPEND_2ARG("stripes=%u..%u,", 4160 bargs->stripes_min, bargs->stripes_max); 4161 4162 #undef CHECK_APPEND_2ARG 4163 #undef CHECK_APPEND_1ARG 4164 #undef CHECK_APPEND_NOARG 4165 4166 out_overflow: 4167 4168 if (size_bp < size_buf) 4169 buf[size_buf - size_bp - 1] = '\0'; /* remove last , */ 4170 else 4171 buf[0] = '\0'; 4172 } 4173 4174 static void describe_balance_start_or_resume(struct btrfs_fs_info *fs_info) 4175 { 4176 u32 size_buf = 1024; 4177 char tmp_buf[192] = {'\0'}; 4178 char *buf; 4179 char *bp; 4180 u32 size_bp = size_buf; 4181 int ret; 4182 struct btrfs_balance_control *bctl = fs_info->balance_ctl; 4183 4184 buf = kzalloc(size_buf, GFP_KERNEL); 4185 if (!buf) 4186 return; 4187 4188 bp = buf; 4189 4190 #define CHECK_APPEND_1ARG(a, v1) \ 4191 do { \ 4192 ret = snprintf(bp, size_bp, (a), (v1)); \ 4193 if (ret < 0 || ret >= size_bp) \ 4194 goto out_overflow; \ 4195 size_bp -= ret; \ 4196 bp += ret; \ 4197 } while (0) 4198 4199 if (bctl->flags & BTRFS_BALANCE_FORCE) 4200 CHECK_APPEND_1ARG("%s", "-f "); 4201 4202 if (bctl->flags & BTRFS_BALANCE_DATA) { 4203 describe_balance_args(&bctl->data, tmp_buf, sizeof(tmp_buf)); 4204 CHECK_APPEND_1ARG("-d%s ", tmp_buf); 4205 } 4206 4207 if (bctl->flags & BTRFS_BALANCE_METADATA) { 4208 describe_balance_args(&bctl->meta, tmp_buf, sizeof(tmp_buf)); 4209 CHECK_APPEND_1ARG("-m%s ", tmp_buf); 4210 } 4211 4212 if (bctl->flags & BTRFS_BALANCE_SYSTEM) { 4213 describe_balance_args(&bctl->sys, tmp_buf, sizeof(tmp_buf)); 4214 CHECK_APPEND_1ARG("-s%s ", tmp_buf); 4215 } 4216 4217 #undef CHECK_APPEND_1ARG 4218 4219 out_overflow: 4220 4221 if (size_bp < size_buf) 4222 buf[size_buf - size_bp - 1] = '\0'; /* remove last " " */ 4223 btrfs_info(fs_info, "balance: %s %s", 4224 (bctl->flags & BTRFS_BALANCE_RESUME) ? 4225 "resume" : "start", buf); 4226 4227 kfree(buf); 4228 } 4229 4230 /* 4231 * Should be called with balance mutexe held 4232 */ 4233 int btrfs_balance(struct btrfs_fs_info *fs_info, 4234 struct btrfs_balance_control *bctl, 4235 struct btrfs_ioctl_balance_args *bargs) 4236 { 4237 u64 meta_target, data_target; 4238 u64 allowed; 4239 int mixed = 0; 4240 int ret; 4241 u64 num_devices; 4242 unsigned seq; 4243 bool reducing_redundancy; 4244 int i; 4245 4246 if (btrfs_fs_closing(fs_info) || 4247 atomic_read(&fs_info->balance_pause_req) || 4248 btrfs_should_cancel_balance(fs_info)) { 4249 ret = -EINVAL; 4250 goto out; 4251 } 4252 4253 allowed = btrfs_super_incompat_flags(fs_info->super_copy); 4254 if (allowed & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) 4255 mixed = 1; 4256 4257 /* 4258 * In case of mixed groups both data and meta should be picked, 4259 * and identical options should be given for both of them. 4260 */ 4261 allowed = BTRFS_BALANCE_DATA | BTRFS_BALANCE_METADATA; 4262 if (mixed && (bctl->flags & allowed)) { 4263 if (!(bctl->flags & BTRFS_BALANCE_DATA) || 4264 !(bctl->flags & BTRFS_BALANCE_METADATA) || 4265 memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) { 4266 btrfs_err(fs_info, 4267 "balance: mixed groups data and metadata options must be the same"); 4268 ret = -EINVAL; 4269 goto out; 4270 } 4271 } 4272 4273 /* 4274 * rw_devices will not change at the moment, device add/delete/replace 4275 * are exclusive 4276 */ 4277 num_devices = fs_info->fs_devices->rw_devices; 4278 4279 /* 4280 * SINGLE profile on-disk has no profile bit, but in-memory we have a 4281 * special bit for it, to make it easier to distinguish. Thus we need 4282 * to set it manually, or balance would refuse the profile. 4283 */ 4284 allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE; 4285 for (i = 0; i < ARRAY_SIZE(btrfs_raid_array); i++) 4286 if (num_devices >= btrfs_raid_array[i].devs_min) 4287 allowed |= btrfs_raid_array[i].bg_flag; 4288 4289 if (!validate_convert_profile(fs_info, &bctl->data, allowed, "data") || 4290 !validate_convert_profile(fs_info, &bctl->meta, allowed, "metadata") || 4291 !validate_convert_profile(fs_info, &bctl->sys, allowed, "system")) { 4292 ret = -EINVAL; 4293 goto out; 4294 } 4295 4296 /* 4297 * Allow to reduce metadata or system integrity only if force set for 4298 * profiles with redundancy (copies, parity) 4299 */ 4300 allowed = 0; 4301 for (i = 0; i < ARRAY_SIZE(btrfs_raid_array); i++) { 4302 if (btrfs_raid_array[i].ncopies >= 2 || 4303 btrfs_raid_array[i].tolerated_failures >= 1) 4304 allowed |= btrfs_raid_array[i].bg_flag; 4305 } 4306 do { 4307 seq = read_seqbegin(&fs_info->profiles_lock); 4308 4309 if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) && 4310 (fs_info->avail_system_alloc_bits & allowed) && 4311 !(bctl->sys.target & allowed)) || 4312 ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) && 4313 (fs_info->avail_metadata_alloc_bits & allowed) && 4314 !(bctl->meta.target & allowed))) 4315 reducing_redundancy = true; 4316 else 4317 reducing_redundancy = false; 4318 4319 /* if we're not converting, the target field is uninitialized */ 4320 meta_target = (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) ? 4321 bctl->meta.target : fs_info->avail_metadata_alloc_bits; 4322 data_target = (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) ? 4323 bctl->data.target : fs_info->avail_data_alloc_bits; 4324 } while (read_seqretry(&fs_info->profiles_lock, seq)); 4325 4326 if (reducing_redundancy) { 4327 if (bctl->flags & BTRFS_BALANCE_FORCE) { 4328 btrfs_info(fs_info, 4329 "balance: force reducing metadata redundancy"); 4330 } else { 4331 btrfs_err(fs_info, 4332 "balance: reduces metadata redundancy, use --force if you want this"); 4333 ret = -EINVAL; 4334 goto out; 4335 } 4336 } 4337 4338 if (btrfs_get_num_tolerated_disk_barrier_failures(meta_target) < 4339 btrfs_get_num_tolerated_disk_barrier_failures(data_target)) { 4340 btrfs_warn(fs_info, 4341 "balance: metadata profile %s has lower redundancy than data profile %s", 4342 btrfs_bg_type_to_raid_name(meta_target), 4343 btrfs_bg_type_to_raid_name(data_target)); 4344 } 4345 4346 ret = insert_balance_item(fs_info, bctl); 4347 if (ret && ret != -EEXIST) 4348 goto out; 4349 4350 if (!(bctl->flags & BTRFS_BALANCE_RESUME)) { 4351 BUG_ON(ret == -EEXIST); 4352 BUG_ON(fs_info->balance_ctl); 4353 spin_lock(&fs_info->balance_lock); 4354 fs_info->balance_ctl = bctl; 4355 spin_unlock(&fs_info->balance_lock); 4356 } else { 4357 BUG_ON(ret != -EEXIST); 4358 spin_lock(&fs_info->balance_lock); 4359 update_balance_args(bctl); 4360 spin_unlock(&fs_info->balance_lock); 4361 } 4362 4363 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); 4364 set_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); 4365 describe_balance_start_or_resume(fs_info); 4366 mutex_unlock(&fs_info->balance_mutex); 4367 4368 ret = __btrfs_balance(fs_info); 4369 4370 mutex_lock(&fs_info->balance_mutex); 4371 if (ret == -ECANCELED && atomic_read(&fs_info->balance_pause_req)) { 4372 btrfs_info(fs_info, "balance: paused"); 4373 btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED); 4374 } 4375 /* 4376 * Balance can be canceled by: 4377 * 4378 * - Regular cancel request 4379 * Then ret == -ECANCELED and balance_cancel_req > 0 4380 * 4381 * - Fatal signal to "btrfs" process 4382 * Either the signal caught by wait_reserve_ticket() and callers 4383 * got -EINTR, or caught by btrfs_should_cancel_balance() and 4384 * got -ECANCELED. 4385 * Either way, in this case balance_cancel_req = 0, and 4386 * ret == -EINTR or ret == -ECANCELED. 4387 * 4388 * So here we only check the return value to catch canceled balance. 4389 */ 4390 else if (ret == -ECANCELED || ret == -EINTR) 4391 btrfs_info(fs_info, "balance: canceled"); 4392 else 4393 btrfs_info(fs_info, "balance: ended with status: %d", ret); 4394 4395 clear_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); 4396 4397 if (bargs) { 4398 memset(bargs, 0, sizeof(*bargs)); 4399 btrfs_update_ioctl_balance_args(fs_info, bargs); 4400 } 4401 4402 if ((ret && ret != -ECANCELED && ret != -ENOSPC) || 4403 balance_need_close(fs_info)) { 4404 reset_balance_state(fs_info); 4405 btrfs_exclop_finish(fs_info); 4406 } 4407 4408 wake_up(&fs_info->balance_wait_q); 4409 4410 return ret; 4411 out: 4412 if (bctl->flags & BTRFS_BALANCE_RESUME) 4413 reset_balance_state(fs_info); 4414 else 4415 kfree(bctl); 4416 btrfs_exclop_finish(fs_info); 4417 4418 return ret; 4419 } 4420 4421 static int balance_kthread(void *data) 4422 { 4423 struct btrfs_fs_info *fs_info = data; 4424 int ret = 0; 4425 4426 sb_start_write(fs_info->sb); 4427 mutex_lock(&fs_info->balance_mutex); 4428 if (fs_info->balance_ctl) 4429 ret = btrfs_balance(fs_info, fs_info->balance_ctl, NULL); 4430 mutex_unlock(&fs_info->balance_mutex); 4431 sb_end_write(fs_info->sb); 4432 4433 return ret; 4434 } 4435 4436 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info) 4437 { 4438 struct task_struct *tsk; 4439 4440 mutex_lock(&fs_info->balance_mutex); 4441 if (!fs_info->balance_ctl) { 4442 mutex_unlock(&fs_info->balance_mutex); 4443 return 0; 4444 } 4445 mutex_unlock(&fs_info->balance_mutex); 4446 4447 if (btrfs_test_opt(fs_info, SKIP_BALANCE)) { 4448 btrfs_info(fs_info, "balance: resume skipped"); 4449 return 0; 4450 } 4451 4452 spin_lock(&fs_info->super_lock); 4453 ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED); 4454 fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE; 4455 spin_unlock(&fs_info->super_lock); 4456 /* 4457 * A ro->rw remount sequence should continue with the paused balance 4458 * regardless of who pauses it, system or the user as of now, so set 4459 * the resume flag. 4460 */ 4461 spin_lock(&fs_info->balance_lock); 4462 fs_info->balance_ctl->flags |= BTRFS_BALANCE_RESUME; 4463 spin_unlock(&fs_info->balance_lock); 4464 4465 tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance"); 4466 return PTR_ERR_OR_ZERO(tsk); 4467 } 4468 4469 int btrfs_recover_balance(struct btrfs_fs_info *fs_info) 4470 { 4471 struct btrfs_balance_control *bctl; 4472 struct btrfs_balance_item *item; 4473 struct btrfs_disk_balance_args disk_bargs; 4474 struct btrfs_path *path; 4475 struct extent_buffer *leaf; 4476 struct btrfs_key key; 4477 int ret; 4478 4479 path = btrfs_alloc_path(); 4480 if (!path) 4481 return -ENOMEM; 4482 4483 key.objectid = BTRFS_BALANCE_OBJECTID; 4484 key.type = BTRFS_TEMPORARY_ITEM_KEY; 4485 key.offset = 0; 4486 4487 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); 4488 if (ret < 0) 4489 goto out; 4490 if (ret > 0) { /* ret = -ENOENT; */ 4491 ret = 0; 4492 goto out; 4493 } 4494 4495 bctl = kzalloc(sizeof(*bctl), GFP_NOFS); 4496 if (!bctl) { 4497 ret = -ENOMEM; 4498 goto out; 4499 } 4500 4501 leaf = path->nodes[0]; 4502 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); 4503 4504 bctl->flags = btrfs_balance_flags(leaf, item); 4505 bctl->flags |= BTRFS_BALANCE_RESUME; 4506 4507 btrfs_balance_data(leaf, item, &disk_bargs); 4508 btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs); 4509 btrfs_balance_meta(leaf, item, &disk_bargs); 4510 btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs); 4511 btrfs_balance_sys(leaf, item, &disk_bargs); 4512 btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs); 4513 4514 /* 4515 * This should never happen, as the paused balance state is recovered 4516 * during mount without any chance of other exclusive ops to collide. 4517 * 4518 * This gives the exclusive op status to balance and keeps in paused 4519 * state until user intervention (cancel or umount). If the ownership 4520 * cannot be assigned, show a message but do not fail. The balance 4521 * is in a paused state and must have fs_info::balance_ctl properly 4522 * set up. 4523 */ 4524 if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED)) 4525 btrfs_warn(fs_info, 4526 "balance: cannot set exclusive op status, resume manually"); 4527 4528 btrfs_release_path(path); 4529 4530 mutex_lock(&fs_info->balance_mutex); 4531 BUG_ON(fs_info->balance_ctl); 4532 spin_lock(&fs_info->balance_lock); 4533 fs_info->balance_ctl = bctl; 4534 spin_unlock(&fs_info->balance_lock); 4535 mutex_unlock(&fs_info->balance_mutex); 4536 out: 4537 btrfs_free_path(path); 4538 return ret; 4539 } 4540 4541 int btrfs_pause_balance(struct btrfs_fs_info *fs_info) 4542 { 4543 int ret = 0; 4544 4545 mutex_lock(&fs_info->balance_mutex); 4546 if (!fs_info->balance_ctl) { 4547 mutex_unlock(&fs_info->balance_mutex); 4548 return -ENOTCONN; 4549 } 4550 4551 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { 4552 atomic_inc(&fs_info->balance_pause_req); 4553 mutex_unlock(&fs_info->balance_mutex); 4554 4555 wait_event(fs_info->balance_wait_q, 4556 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); 4557 4558 mutex_lock(&fs_info->balance_mutex); 4559 /* we are good with balance_ctl ripped off from under us */ 4560 BUG_ON(test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); 4561 atomic_dec(&fs_info->balance_pause_req); 4562 } else { 4563 ret = -ENOTCONN; 4564 } 4565 4566 mutex_unlock(&fs_info->balance_mutex); 4567 return ret; 4568 } 4569 4570 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info) 4571 { 4572 mutex_lock(&fs_info->balance_mutex); 4573 if (!fs_info->balance_ctl) { 4574 mutex_unlock(&fs_info->balance_mutex); 4575 return -ENOTCONN; 4576 } 4577 4578 /* 4579 * A paused balance with the item stored on disk can be resumed at 4580 * mount time if the mount is read-write. Otherwise it's still paused 4581 * and we must not allow cancelling as it deletes the item. 4582 */ 4583 if (sb_rdonly(fs_info->sb)) { 4584 mutex_unlock(&fs_info->balance_mutex); 4585 return -EROFS; 4586 } 4587 4588 atomic_inc(&fs_info->balance_cancel_req); 4589 /* 4590 * if we are running just wait and return, balance item is 4591 * deleted in btrfs_balance in this case 4592 */ 4593 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { 4594 mutex_unlock(&fs_info->balance_mutex); 4595 wait_event(fs_info->balance_wait_q, 4596 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); 4597 mutex_lock(&fs_info->balance_mutex); 4598 } else { 4599 mutex_unlock(&fs_info->balance_mutex); 4600 /* 4601 * Lock released to allow other waiters to continue, we'll 4602 * reexamine the status again. 4603 */ 4604 mutex_lock(&fs_info->balance_mutex); 4605 4606 if (fs_info->balance_ctl) { 4607 reset_balance_state(fs_info); 4608 btrfs_exclop_finish(fs_info); 4609 btrfs_info(fs_info, "balance: canceled"); 4610 } 4611 } 4612 4613 BUG_ON(fs_info->balance_ctl || 4614 test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); 4615 atomic_dec(&fs_info->balance_cancel_req); 4616 mutex_unlock(&fs_info->balance_mutex); 4617 return 0; 4618 } 4619 4620 int btrfs_uuid_scan_kthread(void *data) 4621 { 4622 struct btrfs_fs_info *fs_info = data; 4623 struct btrfs_root *root = fs_info->tree_root; 4624 struct btrfs_key key; 4625 struct btrfs_path *path = NULL; 4626 int ret = 0; 4627 struct extent_buffer *eb; 4628 int slot; 4629 struct btrfs_root_item root_item; 4630 u32 item_size; 4631 struct btrfs_trans_handle *trans = NULL; 4632 bool closing = false; 4633 4634 path = btrfs_alloc_path(); 4635 if (!path) { 4636 ret = -ENOMEM; 4637 goto out; 4638 } 4639 4640 key.objectid = 0; 4641 key.type = BTRFS_ROOT_ITEM_KEY; 4642 key.offset = 0; 4643 4644 while (1) { 4645 if (btrfs_fs_closing(fs_info)) { 4646 closing = true; 4647 break; 4648 } 4649 ret = btrfs_search_forward(root, &key, path, 4650 BTRFS_OLDEST_GENERATION); 4651 if (ret) { 4652 if (ret > 0) 4653 ret = 0; 4654 break; 4655 } 4656 4657 if (key.type != BTRFS_ROOT_ITEM_KEY || 4658 (key.objectid < BTRFS_FIRST_FREE_OBJECTID && 4659 key.objectid != BTRFS_FS_TREE_OBJECTID) || 4660 key.objectid > BTRFS_LAST_FREE_OBJECTID) 4661 goto skip; 4662 4663 eb = path->nodes[0]; 4664 slot = path->slots[0]; 4665 item_size = btrfs_item_size(eb, slot); 4666 if (item_size < sizeof(root_item)) 4667 goto skip; 4668 4669 read_extent_buffer(eb, &root_item, 4670 btrfs_item_ptr_offset(eb, slot), 4671 (int)sizeof(root_item)); 4672 if (btrfs_root_refs(&root_item) == 0) 4673 goto skip; 4674 4675 if (!btrfs_is_empty_uuid(root_item.uuid) || 4676 !btrfs_is_empty_uuid(root_item.received_uuid)) { 4677 if (trans) 4678 goto update_tree; 4679 4680 btrfs_release_path(path); 4681 /* 4682 * 1 - subvol uuid item 4683 * 1 - received_subvol uuid item 4684 */ 4685 trans = btrfs_start_transaction(fs_info->uuid_root, 2); 4686 if (IS_ERR(trans)) { 4687 ret = PTR_ERR(trans); 4688 break; 4689 } 4690 continue; 4691 } else { 4692 goto skip; 4693 } 4694 update_tree: 4695 btrfs_release_path(path); 4696 if (!btrfs_is_empty_uuid(root_item.uuid)) { 4697 ret = btrfs_uuid_tree_add(trans, root_item.uuid, 4698 BTRFS_UUID_KEY_SUBVOL, 4699 key.objectid); 4700 if (ret < 0) { 4701 btrfs_warn(fs_info, "uuid_tree_add failed %d", 4702 ret); 4703 break; 4704 } 4705 } 4706 4707 if (!btrfs_is_empty_uuid(root_item.received_uuid)) { 4708 ret = btrfs_uuid_tree_add(trans, 4709 root_item.received_uuid, 4710 BTRFS_UUID_KEY_RECEIVED_SUBVOL, 4711 key.objectid); 4712 if (ret < 0) { 4713 btrfs_warn(fs_info, "uuid_tree_add failed %d", 4714 ret); 4715 break; 4716 } 4717 } 4718 4719 skip: 4720 btrfs_release_path(path); 4721 if (trans) { 4722 ret = btrfs_end_transaction(trans); 4723 trans = NULL; 4724 if (ret) 4725 break; 4726 } 4727 4728 if (key.offset < (u64)-1) { 4729 key.offset++; 4730 } else if (key.type < BTRFS_ROOT_ITEM_KEY) { 4731 key.offset = 0; 4732 key.type = BTRFS_ROOT_ITEM_KEY; 4733 } else if (key.objectid < (u64)-1) { 4734 key.offset = 0; 4735 key.type = BTRFS_ROOT_ITEM_KEY; 4736 key.objectid++; 4737 } else { 4738 break; 4739 } 4740 cond_resched(); 4741 } 4742 4743 out: 4744 btrfs_free_path(path); 4745 if (trans && !IS_ERR(trans)) 4746 btrfs_end_transaction(trans); 4747 if (ret) 4748 btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret); 4749 else if (!closing) 4750 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags); 4751 up(&fs_info->uuid_tree_rescan_sem); 4752 return 0; 4753 } 4754 4755 int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info) 4756 { 4757 struct btrfs_trans_handle *trans; 4758 struct btrfs_root *tree_root = fs_info->tree_root; 4759 struct btrfs_root *uuid_root; 4760 struct task_struct *task; 4761 int ret; 4762 4763 /* 4764 * 1 - root node 4765 * 1 - root item 4766 */ 4767 trans = btrfs_start_transaction(tree_root, 2); 4768 if (IS_ERR(trans)) 4769 return PTR_ERR(trans); 4770 4771 uuid_root = btrfs_create_tree(trans, BTRFS_UUID_TREE_OBJECTID); 4772 if (IS_ERR(uuid_root)) { 4773 ret = PTR_ERR(uuid_root); 4774 btrfs_abort_transaction(trans, ret); 4775 btrfs_end_transaction(trans); 4776 return ret; 4777 } 4778 4779 fs_info->uuid_root = uuid_root; 4780 4781 ret = btrfs_commit_transaction(trans); 4782 if (ret) 4783 return ret; 4784 4785 down(&fs_info->uuid_tree_rescan_sem); 4786 task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid"); 4787 if (IS_ERR(task)) { 4788 /* fs_info->update_uuid_tree_gen remains 0 in all error case */ 4789 btrfs_warn(fs_info, "failed to start uuid_scan task"); 4790 up(&fs_info->uuid_tree_rescan_sem); 4791 return PTR_ERR(task); 4792 } 4793 4794 return 0; 4795 } 4796 4797 /* 4798 * shrinking a device means finding all of the device extents past 4799 * the new size, and then following the back refs to the chunks. 4800 * The chunk relocation code actually frees the device extent 4801 */ 4802 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size) 4803 { 4804 struct btrfs_fs_info *fs_info = device->fs_info; 4805 struct btrfs_root *root = fs_info->dev_root; 4806 struct btrfs_trans_handle *trans; 4807 struct btrfs_dev_extent *dev_extent = NULL; 4808 struct btrfs_path *path; 4809 u64 length; 4810 u64 chunk_offset; 4811 int ret; 4812 int slot; 4813 int failed = 0; 4814 bool retried = false; 4815 struct extent_buffer *l; 4816 struct btrfs_key key; 4817 struct btrfs_super_block *super_copy = fs_info->super_copy; 4818 u64 old_total = btrfs_super_total_bytes(super_copy); 4819 u64 old_size = btrfs_device_get_total_bytes(device); 4820 u64 diff; 4821 u64 start; 4822 4823 new_size = round_down(new_size, fs_info->sectorsize); 4824 start = new_size; 4825 diff = round_down(old_size - new_size, fs_info->sectorsize); 4826 4827 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) 4828 return -EINVAL; 4829 4830 path = btrfs_alloc_path(); 4831 if (!path) 4832 return -ENOMEM; 4833 4834 path->reada = READA_BACK; 4835 4836 trans = btrfs_start_transaction(root, 0); 4837 if (IS_ERR(trans)) { 4838 btrfs_free_path(path); 4839 return PTR_ERR(trans); 4840 } 4841 4842 mutex_lock(&fs_info->chunk_mutex); 4843 4844 btrfs_device_set_total_bytes(device, new_size); 4845 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 4846 device->fs_devices->total_rw_bytes -= diff; 4847 atomic64_sub(diff, &fs_info->free_chunk_space); 4848 } 4849 4850 /* 4851 * Once the device's size has been set to the new size, ensure all 4852 * in-memory chunks are synced to disk so that the loop below sees them 4853 * and relocates them accordingly. 4854 */ 4855 if (contains_pending_extent(device, &start, diff)) { 4856 mutex_unlock(&fs_info->chunk_mutex); 4857 ret = btrfs_commit_transaction(trans); 4858 if (ret) 4859 goto done; 4860 } else { 4861 mutex_unlock(&fs_info->chunk_mutex); 4862 btrfs_end_transaction(trans); 4863 } 4864 4865 again: 4866 key.objectid = device->devid; 4867 key.offset = (u64)-1; 4868 key.type = BTRFS_DEV_EXTENT_KEY; 4869 4870 do { 4871 mutex_lock(&fs_info->reclaim_bgs_lock); 4872 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 4873 if (ret < 0) { 4874 mutex_unlock(&fs_info->reclaim_bgs_lock); 4875 goto done; 4876 } 4877 4878 ret = btrfs_previous_item(root, path, 0, key.type); 4879 if (ret) { 4880 mutex_unlock(&fs_info->reclaim_bgs_lock); 4881 if (ret < 0) 4882 goto done; 4883 ret = 0; 4884 btrfs_release_path(path); 4885 break; 4886 } 4887 4888 l = path->nodes[0]; 4889 slot = path->slots[0]; 4890 btrfs_item_key_to_cpu(l, &key, path->slots[0]); 4891 4892 if (key.objectid != device->devid) { 4893 mutex_unlock(&fs_info->reclaim_bgs_lock); 4894 btrfs_release_path(path); 4895 break; 4896 } 4897 4898 dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent); 4899 length = btrfs_dev_extent_length(l, dev_extent); 4900 4901 if (key.offset + length <= new_size) { 4902 mutex_unlock(&fs_info->reclaim_bgs_lock); 4903 btrfs_release_path(path); 4904 break; 4905 } 4906 4907 chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent); 4908 btrfs_release_path(path); 4909 4910 /* 4911 * We may be relocating the only data chunk we have, 4912 * which could potentially end up with losing data's 4913 * raid profile, so lets allocate an empty one in 4914 * advance. 4915 */ 4916 ret = btrfs_may_alloc_data_chunk(fs_info, chunk_offset); 4917 if (ret < 0) { 4918 mutex_unlock(&fs_info->reclaim_bgs_lock); 4919 goto done; 4920 } 4921 4922 ret = btrfs_relocate_chunk(fs_info, chunk_offset); 4923 mutex_unlock(&fs_info->reclaim_bgs_lock); 4924 if (ret == -ENOSPC) { 4925 failed++; 4926 } else if (ret) { 4927 if (ret == -ETXTBSY) { 4928 btrfs_warn(fs_info, 4929 "could not shrink block group %llu due to active swapfile", 4930 chunk_offset); 4931 } 4932 goto done; 4933 } 4934 } while (key.offset-- > 0); 4935 4936 if (failed && !retried) { 4937 failed = 0; 4938 retried = true; 4939 goto again; 4940 } else if (failed && retried) { 4941 ret = -ENOSPC; 4942 goto done; 4943 } 4944 4945 /* Shrinking succeeded, else we would be at "done". */ 4946 trans = btrfs_start_transaction(root, 0); 4947 if (IS_ERR(trans)) { 4948 ret = PTR_ERR(trans); 4949 goto done; 4950 } 4951 4952 mutex_lock(&fs_info->chunk_mutex); 4953 /* Clear all state bits beyond the shrunk device size */ 4954 clear_extent_bits(&device->alloc_state, new_size, (u64)-1, 4955 CHUNK_STATE_MASK); 4956 4957 btrfs_device_set_disk_total_bytes(device, new_size); 4958 if (list_empty(&device->post_commit_list)) 4959 list_add_tail(&device->post_commit_list, 4960 &trans->transaction->dev_update_list); 4961 4962 WARN_ON(diff > old_total); 4963 btrfs_set_super_total_bytes(super_copy, 4964 round_down(old_total - diff, fs_info->sectorsize)); 4965 mutex_unlock(&fs_info->chunk_mutex); 4966 4967 btrfs_reserve_chunk_metadata(trans, false); 4968 /* Now btrfs_update_device() will change the on-disk size. */ 4969 ret = btrfs_update_device(trans, device); 4970 btrfs_trans_release_chunk_metadata(trans); 4971 if (ret < 0) { 4972 btrfs_abort_transaction(trans, ret); 4973 btrfs_end_transaction(trans); 4974 } else { 4975 ret = btrfs_commit_transaction(trans); 4976 } 4977 done: 4978 btrfs_free_path(path); 4979 if (ret) { 4980 mutex_lock(&fs_info->chunk_mutex); 4981 btrfs_device_set_total_bytes(device, old_size); 4982 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) 4983 device->fs_devices->total_rw_bytes += diff; 4984 atomic64_add(diff, &fs_info->free_chunk_space); 4985 mutex_unlock(&fs_info->chunk_mutex); 4986 } 4987 return ret; 4988 } 4989 4990 static int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info, 4991 struct btrfs_key *key, 4992 struct btrfs_chunk *chunk, int item_size) 4993 { 4994 struct btrfs_super_block *super_copy = fs_info->super_copy; 4995 struct btrfs_disk_key disk_key; 4996 u32 array_size; 4997 u8 *ptr; 4998 4999 lockdep_assert_held(&fs_info->chunk_mutex); 5000 5001 array_size = btrfs_super_sys_array_size(super_copy); 5002 if (array_size + item_size + sizeof(disk_key) 5003 > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) 5004 return -EFBIG; 5005 5006 ptr = super_copy->sys_chunk_array + array_size; 5007 btrfs_cpu_key_to_disk(&disk_key, key); 5008 memcpy(ptr, &disk_key, sizeof(disk_key)); 5009 ptr += sizeof(disk_key); 5010 memcpy(ptr, chunk, item_size); 5011 item_size += sizeof(disk_key); 5012 btrfs_set_super_sys_array_size(super_copy, array_size + item_size); 5013 5014 return 0; 5015 } 5016 5017 /* 5018 * sort the devices in descending order by max_avail, total_avail 5019 */ 5020 static int btrfs_cmp_device_info(const void *a, const void *b) 5021 { 5022 const struct btrfs_device_info *di_a = a; 5023 const struct btrfs_device_info *di_b = b; 5024 5025 if (di_a->max_avail > di_b->max_avail) 5026 return -1; 5027 if (di_a->max_avail < di_b->max_avail) 5028 return 1; 5029 if (di_a->total_avail > di_b->total_avail) 5030 return -1; 5031 if (di_a->total_avail < di_b->total_avail) 5032 return 1; 5033 return 0; 5034 } 5035 5036 static void check_raid56_incompat_flag(struct btrfs_fs_info *info, u64 type) 5037 { 5038 if (!(type & BTRFS_BLOCK_GROUP_RAID56_MASK)) 5039 return; 5040 5041 btrfs_set_fs_incompat(info, RAID56); 5042 } 5043 5044 static void check_raid1c34_incompat_flag(struct btrfs_fs_info *info, u64 type) 5045 { 5046 if (!(type & (BTRFS_BLOCK_GROUP_RAID1C3 | BTRFS_BLOCK_GROUP_RAID1C4))) 5047 return; 5048 5049 btrfs_set_fs_incompat(info, RAID1C34); 5050 } 5051 5052 /* 5053 * Structure used internally for btrfs_create_chunk() function. 5054 * Wraps needed parameters. 5055 */ 5056 struct alloc_chunk_ctl { 5057 u64 start; 5058 u64 type; 5059 /* Total number of stripes to allocate */ 5060 int num_stripes; 5061 /* sub_stripes info for map */ 5062 int sub_stripes; 5063 /* Stripes per device */ 5064 int dev_stripes; 5065 /* Maximum number of devices to use */ 5066 int devs_max; 5067 /* Minimum number of devices to use */ 5068 int devs_min; 5069 /* ndevs has to be a multiple of this */ 5070 int devs_increment; 5071 /* Number of copies */ 5072 int ncopies; 5073 /* Number of stripes worth of bytes to store parity information */ 5074 int nparity; 5075 u64 max_stripe_size; 5076 u64 max_chunk_size; 5077 u64 dev_extent_min; 5078 u64 stripe_size; 5079 u64 chunk_size; 5080 int ndevs; 5081 }; 5082 5083 static void init_alloc_chunk_ctl_policy_regular( 5084 struct btrfs_fs_devices *fs_devices, 5085 struct alloc_chunk_ctl *ctl) 5086 { 5087 u64 type = ctl->type; 5088 5089 if (type & BTRFS_BLOCK_GROUP_DATA) { 5090 ctl->max_stripe_size = SZ_1G; 5091 ctl->max_chunk_size = BTRFS_MAX_DATA_CHUNK_SIZE; 5092 } else if (type & BTRFS_BLOCK_GROUP_METADATA) { 5093 /* For larger filesystems, use larger metadata chunks */ 5094 if (fs_devices->total_rw_bytes > 50ULL * SZ_1G) 5095 ctl->max_stripe_size = SZ_1G; 5096 else 5097 ctl->max_stripe_size = SZ_256M; 5098 ctl->max_chunk_size = ctl->max_stripe_size; 5099 } else if (type & BTRFS_BLOCK_GROUP_SYSTEM) { 5100 ctl->max_stripe_size = SZ_32M; 5101 ctl->max_chunk_size = 2 * ctl->max_stripe_size; 5102 ctl->devs_max = min_t(int, ctl->devs_max, 5103 BTRFS_MAX_DEVS_SYS_CHUNK); 5104 } else { 5105 BUG(); 5106 } 5107 5108 /* We don't want a chunk larger than 10% of writable space */ 5109 ctl->max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1), 5110 ctl->max_chunk_size); 5111 ctl->dev_extent_min = BTRFS_STRIPE_LEN * ctl->dev_stripes; 5112 } 5113 5114 static void init_alloc_chunk_ctl_policy_zoned( 5115 struct btrfs_fs_devices *fs_devices, 5116 struct alloc_chunk_ctl *ctl) 5117 { 5118 u64 zone_size = fs_devices->fs_info->zone_size; 5119 u64 limit; 5120 int min_num_stripes = ctl->devs_min * ctl->dev_stripes; 5121 int min_data_stripes = (min_num_stripes - ctl->nparity) / ctl->ncopies; 5122 u64 min_chunk_size = min_data_stripes * zone_size; 5123 u64 type = ctl->type; 5124 5125 ctl->max_stripe_size = zone_size; 5126 if (type & BTRFS_BLOCK_GROUP_DATA) { 5127 ctl->max_chunk_size = round_down(BTRFS_MAX_DATA_CHUNK_SIZE, 5128 zone_size); 5129 } else if (type & BTRFS_BLOCK_GROUP_METADATA) { 5130 ctl->max_chunk_size = ctl->max_stripe_size; 5131 } else if (type & BTRFS_BLOCK_GROUP_SYSTEM) { 5132 ctl->max_chunk_size = 2 * ctl->max_stripe_size; 5133 ctl->devs_max = min_t(int, ctl->devs_max, 5134 BTRFS_MAX_DEVS_SYS_CHUNK); 5135 } else { 5136 BUG(); 5137 } 5138 5139 /* We don't want a chunk larger than 10% of writable space */ 5140 limit = max(round_down(div_factor(fs_devices->total_rw_bytes, 1), 5141 zone_size), 5142 min_chunk_size); 5143 ctl->max_chunk_size = min(limit, ctl->max_chunk_size); 5144 ctl->dev_extent_min = zone_size * ctl->dev_stripes; 5145 } 5146 5147 static void init_alloc_chunk_ctl(struct btrfs_fs_devices *fs_devices, 5148 struct alloc_chunk_ctl *ctl) 5149 { 5150 int index = btrfs_bg_flags_to_raid_index(ctl->type); 5151 5152 ctl->sub_stripes = btrfs_raid_array[index].sub_stripes; 5153 ctl->dev_stripes = btrfs_raid_array[index].dev_stripes; 5154 ctl->devs_max = btrfs_raid_array[index].devs_max; 5155 if (!ctl->devs_max) 5156 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info); 5157 ctl->devs_min = btrfs_raid_array[index].devs_min; 5158 ctl->devs_increment = btrfs_raid_array[index].devs_increment; 5159 ctl->ncopies = btrfs_raid_array[index].ncopies; 5160 ctl->nparity = btrfs_raid_array[index].nparity; 5161 ctl->ndevs = 0; 5162 5163 switch (fs_devices->chunk_alloc_policy) { 5164 case BTRFS_CHUNK_ALLOC_REGULAR: 5165 init_alloc_chunk_ctl_policy_regular(fs_devices, ctl); 5166 break; 5167 case BTRFS_CHUNK_ALLOC_ZONED: 5168 init_alloc_chunk_ctl_policy_zoned(fs_devices, ctl); 5169 break; 5170 default: 5171 BUG(); 5172 } 5173 } 5174 5175 static int gather_device_info(struct btrfs_fs_devices *fs_devices, 5176 struct alloc_chunk_ctl *ctl, 5177 struct btrfs_device_info *devices_info) 5178 { 5179 struct btrfs_fs_info *info = fs_devices->fs_info; 5180 struct btrfs_device *device; 5181 u64 total_avail; 5182 u64 dev_extent_want = ctl->max_stripe_size * ctl->dev_stripes; 5183 int ret; 5184 int ndevs = 0; 5185 u64 max_avail; 5186 u64 dev_offset; 5187 5188 /* 5189 * in the first pass through the devices list, we gather information 5190 * about the available holes on each device. 5191 */ 5192 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) { 5193 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 5194 WARN(1, KERN_ERR 5195 "BTRFS: read-only device in alloc_list\n"); 5196 continue; 5197 } 5198 5199 if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, 5200 &device->dev_state) || 5201 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) 5202 continue; 5203 5204 if (device->total_bytes > device->bytes_used) 5205 total_avail = device->total_bytes - device->bytes_used; 5206 else 5207 total_avail = 0; 5208 5209 /* If there is no space on this device, skip it. */ 5210 if (total_avail < ctl->dev_extent_min) 5211 continue; 5212 5213 ret = find_free_dev_extent(device, dev_extent_want, &dev_offset, 5214 &max_avail); 5215 if (ret && ret != -ENOSPC) 5216 return ret; 5217 5218 if (ret == 0) 5219 max_avail = dev_extent_want; 5220 5221 if (max_avail < ctl->dev_extent_min) { 5222 if (btrfs_test_opt(info, ENOSPC_DEBUG)) 5223 btrfs_debug(info, 5224 "%s: devid %llu has no free space, have=%llu want=%llu", 5225 __func__, device->devid, max_avail, 5226 ctl->dev_extent_min); 5227 continue; 5228 } 5229 5230 if (ndevs == fs_devices->rw_devices) { 5231 WARN(1, "%s: found more than %llu devices\n", 5232 __func__, fs_devices->rw_devices); 5233 break; 5234 } 5235 devices_info[ndevs].dev_offset = dev_offset; 5236 devices_info[ndevs].max_avail = max_avail; 5237 devices_info[ndevs].total_avail = total_avail; 5238 devices_info[ndevs].dev = device; 5239 ++ndevs; 5240 } 5241 ctl->ndevs = ndevs; 5242 5243 /* 5244 * now sort the devices by hole size / available space 5245 */ 5246 sort(devices_info, ndevs, sizeof(struct btrfs_device_info), 5247 btrfs_cmp_device_info, NULL); 5248 5249 return 0; 5250 } 5251 5252 static int decide_stripe_size_regular(struct alloc_chunk_ctl *ctl, 5253 struct btrfs_device_info *devices_info) 5254 { 5255 /* Number of stripes that count for block group size */ 5256 int data_stripes; 5257 5258 /* 5259 * The primary goal is to maximize the number of stripes, so use as 5260 * many devices as possible, even if the stripes are not maximum sized. 5261 * 5262 * The DUP profile stores more than one stripe per device, the 5263 * max_avail is the total size so we have to adjust. 5264 */ 5265 ctl->stripe_size = div_u64(devices_info[ctl->ndevs - 1].max_avail, 5266 ctl->dev_stripes); 5267 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; 5268 5269 /* This will have to be fixed for RAID1 and RAID10 over more drives */ 5270 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; 5271 5272 /* 5273 * Use the number of data stripes to figure out how big this chunk is 5274 * really going to be in terms of logical address space, and compare 5275 * that answer with the max chunk size. If it's higher, we try to 5276 * reduce stripe_size. 5277 */ 5278 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { 5279 /* 5280 * Reduce stripe_size, round it up to a 16MB boundary again and 5281 * then use it, unless it ends up being even bigger than the 5282 * previous value we had already. 5283 */ 5284 ctl->stripe_size = min(round_up(div_u64(ctl->max_chunk_size, 5285 data_stripes), SZ_16M), 5286 ctl->stripe_size); 5287 } 5288 5289 /* Align to BTRFS_STRIPE_LEN */ 5290 ctl->stripe_size = round_down(ctl->stripe_size, BTRFS_STRIPE_LEN); 5291 ctl->chunk_size = ctl->stripe_size * data_stripes; 5292 5293 return 0; 5294 } 5295 5296 static int decide_stripe_size_zoned(struct alloc_chunk_ctl *ctl, 5297 struct btrfs_device_info *devices_info) 5298 { 5299 u64 zone_size = devices_info[0].dev->zone_info->zone_size; 5300 /* Number of stripes that count for block group size */ 5301 int data_stripes; 5302 5303 /* 5304 * It should hold because: 5305 * dev_extent_min == dev_extent_want == zone_size * dev_stripes 5306 */ 5307 ASSERT(devices_info[ctl->ndevs - 1].max_avail == ctl->dev_extent_min); 5308 5309 ctl->stripe_size = zone_size; 5310 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; 5311 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; 5312 5313 /* stripe_size is fixed in zoned filesysmte. Reduce ndevs instead. */ 5314 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { 5315 ctl->ndevs = div_u64(div_u64(ctl->max_chunk_size * ctl->ncopies, 5316 ctl->stripe_size) + ctl->nparity, 5317 ctl->dev_stripes); 5318 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; 5319 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; 5320 ASSERT(ctl->stripe_size * data_stripes <= ctl->max_chunk_size); 5321 } 5322 5323 ctl->chunk_size = ctl->stripe_size * data_stripes; 5324 5325 return 0; 5326 } 5327 5328 static int decide_stripe_size(struct btrfs_fs_devices *fs_devices, 5329 struct alloc_chunk_ctl *ctl, 5330 struct btrfs_device_info *devices_info) 5331 { 5332 struct btrfs_fs_info *info = fs_devices->fs_info; 5333 5334 /* 5335 * Round down to number of usable stripes, devs_increment can be any 5336 * number so we can't use round_down() that requires power of 2, while 5337 * rounddown is safe. 5338 */ 5339 ctl->ndevs = rounddown(ctl->ndevs, ctl->devs_increment); 5340 5341 if (ctl->ndevs < ctl->devs_min) { 5342 if (btrfs_test_opt(info, ENOSPC_DEBUG)) { 5343 btrfs_debug(info, 5344 "%s: not enough devices with free space: have=%d minimum required=%d", 5345 __func__, ctl->ndevs, ctl->devs_min); 5346 } 5347 return -ENOSPC; 5348 } 5349 5350 ctl->ndevs = min(ctl->ndevs, ctl->devs_max); 5351 5352 switch (fs_devices->chunk_alloc_policy) { 5353 case BTRFS_CHUNK_ALLOC_REGULAR: 5354 return decide_stripe_size_regular(ctl, devices_info); 5355 case BTRFS_CHUNK_ALLOC_ZONED: 5356 return decide_stripe_size_zoned(ctl, devices_info); 5357 default: 5358 BUG(); 5359 } 5360 } 5361 5362 static struct btrfs_block_group *create_chunk(struct btrfs_trans_handle *trans, 5363 struct alloc_chunk_ctl *ctl, 5364 struct btrfs_device_info *devices_info) 5365 { 5366 struct btrfs_fs_info *info = trans->fs_info; 5367 struct map_lookup *map = NULL; 5368 struct extent_map_tree *em_tree; 5369 struct btrfs_block_group *block_group; 5370 struct extent_map *em; 5371 u64 start = ctl->start; 5372 u64 type = ctl->type; 5373 int ret; 5374 int i; 5375 int j; 5376 5377 map = kmalloc(map_lookup_size(ctl->num_stripes), GFP_NOFS); 5378 if (!map) 5379 return ERR_PTR(-ENOMEM); 5380 map->num_stripes = ctl->num_stripes; 5381 5382 for (i = 0; i < ctl->ndevs; ++i) { 5383 for (j = 0; j < ctl->dev_stripes; ++j) { 5384 int s = i * ctl->dev_stripes + j; 5385 map->stripes[s].dev = devices_info[i].dev; 5386 map->stripes[s].physical = devices_info[i].dev_offset + 5387 j * ctl->stripe_size; 5388 } 5389 } 5390 map->stripe_len = BTRFS_STRIPE_LEN; 5391 map->io_align = BTRFS_STRIPE_LEN; 5392 map->io_width = BTRFS_STRIPE_LEN; 5393 map->type = type; 5394 map->sub_stripes = ctl->sub_stripes; 5395 5396 trace_btrfs_chunk_alloc(info, map, start, ctl->chunk_size); 5397 5398 em = alloc_extent_map(); 5399 if (!em) { 5400 kfree(map); 5401 return ERR_PTR(-ENOMEM); 5402 } 5403 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); 5404 em->map_lookup = map; 5405 em->start = start; 5406 em->len = ctl->chunk_size; 5407 em->block_start = 0; 5408 em->block_len = em->len; 5409 em->orig_block_len = ctl->stripe_size; 5410 5411 em_tree = &info->mapping_tree; 5412 write_lock(&em_tree->lock); 5413 ret = add_extent_mapping(em_tree, em, 0); 5414 if (ret) { 5415 write_unlock(&em_tree->lock); 5416 free_extent_map(em); 5417 return ERR_PTR(ret); 5418 } 5419 write_unlock(&em_tree->lock); 5420 5421 block_group = btrfs_make_block_group(trans, 0, type, start, ctl->chunk_size); 5422 if (IS_ERR(block_group)) 5423 goto error_del_extent; 5424 5425 for (i = 0; i < map->num_stripes; i++) { 5426 struct btrfs_device *dev = map->stripes[i].dev; 5427 5428 btrfs_device_set_bytes_used(dev, 5429 dev->bytes_used + ctl->stripe_size); 5430 if (list_empty(&dev->post_commit_list)) 5431 list_add_tail(&dev->post_commit_list, 5432 &trans->transaction->dev_update_list); 5433 } 5434 5435 atomic64_sub(ctl->stripe_size * map->num_stripes, 5436 &info->free_chunk_space); 5437 5438 free_extent_map(em); 5439 check_raid56_incompat_flag(info, type); 5440 check_raid1c34_incompat_flag(info, type); 5441 5442 return block_group; 5443 5444 error_del_extent: 5445 write_lock(&em_tree->lock); 5446 remove_extent_mapping(em_tree, em); 5447 write_unlock(&em_tree->lock); 5448 5449 /* One for our allocation */ 5450 free_extent_map(em); 5451 /* One for the tree reference */ 5452 free_extent_map(em); 5453 5454 return block_group; 5455 } 5456 5457 struct btrfs_block_group *btrfs_create_chunk(struct btrfs_trans_handle *trans, 5458 u64 type) 5459 { 5460 struct btrfs_fs_info *info = trans->fs_info; 5461 struct btrfs_fs_devices *fs_devices = info->fs_devices; 5462 struct btrfs_device_info *devices_info = NULL; 5463 struct alloc_chunk_ctl ctl; 5464 struct btrfs_block_group *block_group; 5465 int ret; 5466 5467 lockdep_assert_held(&info->chunk_mutex); 5468 5469 if (!alloc_profile_is_valid(type, 0)) { 5470 ASSERT(0); 5471 return ERR_PTR(-EINVAL); 5472 } 5473 5474 if (list_empty(&fs_devices->alloc_list)) { 5475 if (btrfs_test_opt(info, ENOSPC_DEBUG)) 5476 btrfs_debug(info, "%s: no writable device", __func__); 5477 return ERR_PTR(-ENOSPC); 5478 } 5479 5480 if (!(type & BTRFS_BLOCK_GROUP_TYPE_MASK)) { 5481 btrfs_err(info, "invalid chunk type 0x%llx requested", type); 5482 ASSERT(0); 5483 return ERR_PTR(-EINVAL); 5484 } 5485 5486 ctl.start = find_next_chunk(info); 5487 ctl.type = type; 5488 init_alloc_chunk_ctl(fs_devices, &ctl); 5489 5490 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info), 5491 GFP_NOFS); 5492 if (!devices_info) 5493 return ERR_PTR(-ENOMEM); 5494 5495 ret = gather_device_info(fs_devices, &ctl, devices_info); 5496 if (ret < 0) { 5497 block_group = ERR_PTR(ret); 5498 goto out; 5499 } 5500 5501 ret = decide_stripe_size(fs_devices, &ctl, devices_info); 5502 if (ret < 0) { 5503 block_group = ERR_PTR(ret); 5504 goto out; 5505 } 5506 5507 block_group = create_chunk(trans, &ctl, devices_info); 5508 5509 out: 5510 kfree(devices_info); 5511 return block_group; 5512 } 5513 5514 /* 5515 * This function, btrfs_chunk_alloc_add_chunk_item(), typically belongs to the 5516 * phase 1 of chunk allocation. It belongs to phase 2 only when allocating system 5517 * chunks. 5518 * 5519 * See the comment at btrfs_chunk_alloc() for details about the chunk allocation 5520 * phases. 5521 */ 5522 int btrfs_chunk_alloc_add_chunk_item(struct btrfs_trans_handle *trans, 5523 struct btrfs_block_group *bg) 5524 { 5525 struct btrfs_fs_info *fs_info = trans->fs_info; 5526 struct btrfs_root *chunk_root = fs_info->chunk_root; 5527 struct btrfs_key key; 5528 struct btrfs_chunk *chunk; 5529 struct btrfs_stripe *stripe; 5530 struct extent_map *em; 5531 struct map_lookup *map; 5532 size_t item_size; 5533 int i; 5534 int ret; 5535 5536 /* 5537 * We take the chunk_mutex for 2 reasons: 5538 * 5539 * 1) Updates and insertions in the chunk btree must be done while holding 5540 * the chunk_mutex, as well as updating the system chunk array in the 5541 * superblock. See the comment on top of btrfs_chunk_alloc() for the 5542 * details; 5543 * 5544 * 2) To prevent races with the final phase of a device replace operation 5545 * that replaces the device object associated with the map's stripes, 5546 * because the device object's id can change at any time during that 5547 * final phase of the device replace operation 5548 * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the 5549 * replaced device and then see it with an ID of BTRFS_DEV_REPLACE_DEVID, 5550 * which would cause a failure when updating the device item, which does 5551 * not exists, or persisting a stripe of the chunk item with such ID. 5552 * Here we can't use the device_list_mutex because our caller already 5553 * has locked the chunk_mutex, and the final phase of device replace 5554 * acquires both mutexes - first the device_list_mutex and then the 5555 * chunk_mutex. Using any of those two mutexes protects us from a 5556 * concurrent device replace. 5557 */ 5558 lockdep_assert_held(&fs_info->chunk_mutex); 5559 5560 em = btrfs_get_chunk_map(fs_info, bg->start, bg->length); 5561 if (IS_ERR(em)) { 5562 ret = PTR_ERR(em); 5563 btrfs_abort_transaction(trans, ret); 5564 return ret; 5565 } 5566 5567 map = em->map_lookup; 5568 item_size = btrfs_chunk_item_size(map->num_stripes); 5569 5570 chunk = kzalloc(item_size, GFP_NOFS); 5571 if (!chunk) { 5572 ret = -ENOMEM; 5573 btrfs_abort_transaction(trans, ret); 5574 goto out; 5575 } 5576 5577 for (i = 0; i < map->num_stripes; i++) { 5578 struct btrfs_device *device = map->stripes[i].dev; 5579 5580 ret = btrfs_update_device(trans, device); 5581 if (ret) 5582 goto out; 5583 } 5584 5585 stripe = &chunk->stripe; 5586 for (i = 0; i < map->num_stripes; i++) { 5587 struct btrfs_device *device = map->stripes[i].dev; 5588 const u64 dev_offset = map->stripes[i].physical; 5589 5590 btrfs_set_stack_stripe_devid(stripe, device->devid); 5591 btrfs_set_stack_stripe_offset(stripe, dev_offset); 5592 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE); 5593 stripe++; 5594 } 5595 5596 btrfs_set_stack_chunk_length(chunk, bg->length); 5597 btrfs_set_stack_chunk_owner(chunk, BTRFS_EXTENT_TREE_OBJECTID); 5598 btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len); 5599 btrfs_set_stack_chunk_type(chunk, map->type); 5600 btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes); 5601 btrfs_set_stack_chunk_io_align(chunk, map->stripe_len); 5602 btrfs_set_stack_chunk_io_width(chunk, map->stripe_len); 5603 btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize); 5604 btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes); 5605 5606 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; 5607 key.type = BTRFS_CHUNK_ITEM_KEY; 5608 key.offset = bg->start; 5609 5610 ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size); 5611 if (ret) 5612 goto out; 5613 5614 bg->chunk_item_inserted = 1; 5615 5616 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { 5617 ret = btrfs_add_system_chunk(fs_info, &key, chunk, item_size); 5618 if (ret) 5619 goto out; 5620 } 5621 5622 out: 5623 kfree(chunk); 5624 free_extent_map(em); 5625 return ret; 5626 } 5627 5628 static noinline int init_first_rw_device(struct btrfs_trans_handle *trans) 5629 { 5630 struct btrfs_fs_info *fs_info = trans->fs_info; 5631 u64 alloc_profile; 5632 struct btrfs_block_group *meta_bg; 5633 struct btrfs_block_group *sys_bg; 5634 5635 /* 5636 * When adding a new device for sprouting, the seed device is read-only 5637 * so we must first allocate a metadata and a system chunk. But before 5638 * adding the block group items to the extent, device and chunk btrees, 5639 * we must first: 5640 * 5641 * 1) Create both chunks without doing any changes to the btrees, as 5642 * otherwise we would get -ENOSPC since the block groups from the 5643 * seed device are read-only; 5644 * 5645 * 2) Add the device item for the new sprout device - finishing the setup 5646 * of a new block group requires updating the device item in the chunk 5647 * btree, so it must exist when we attempt to do it. The previous step 5648 * ensures this does not fail with -ENOSPC. 5649 * 5650 * After that we can add the block group items to their btrees: 5651 * update existing device item in the chunk btree, add a new block group 5652 * item to the extent btree, add a new chunk item to the chunk btree and 5653 * finally add the new device extent items to the devices btree. 5654 */ 5655 5656 alloc_profile = btrfs_metadata_alloc_profile(fs_info); 5657 meta_bg = btrfs_create_chunk(trans, alloc_profile); 5658 if (IS_ERR(meta_bg)) 5659 return PTR_ERR(meta_bg); 5660 5661 alloc_profile = btrfs_system_alloc_profile(fs_info); 5662 sys_bg = btrfs_create_chunk(trans, alloc_profile); 5663 if (IS_ERR(sys_bg)) 5664 return PTR_ERR(sys_bg); 5665 5666 return 0; 5667 } 5668 5669 static inline int btrfs_chunk_max_errors(struct map_lookup *map) 5670 { 5671 const int index = btrfs_bg_flags_to_raid_index(map->type); 5672 5673 return btrfs_raid_array[index].tolerated_failures; 5674 } 5675 5676 bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset) 5677 { 5678 struct extent_map *em; 5679 struct map_lookup *map; 5680 int miss_ndevs = 0; 5681 int i; 5682 bool ret = true; 5683 5684 em = btrfs_get_chunk_map(fs_info, chunk_offset, 1); 5685 if (IS_ERR(em)) 5686 return false; 5687 5688 map = em->map_lookup; 5689 for (i = 0; i < map->num_stripes; i++) { 5690 if (test_bit(BTRFS_DEV_STATE_MISSING, 5691 &map->stripes[i].dev->dev_state)) { 5692 miss_ndevs++; 5693 continue; 5694 } 5695 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, 5696 &map->stripes[i].dev->dev_state)) { 5697 ret = false; 5698 goto end; 5699 } 5700 } 5701 5702 /* 5703 * If the number of missing devices is larger than max errors, we can 5704 * not write the data into that chunk successfully. 5705 */ 5706 if (miss_ndevs > btrfs_chunk_max_errors(map)) 5707 ret = false; 5708 end: 5709 free_extent_map(em); 5710 return ret; 5711 } 5712 5713 void btrfs_mapping_tree_free(struct extent_map_tree *tree) 5714 { 5715 struct extent_map *em; 5716 5717 while (1) { 5718 write_lock(&tree->lock); 5719 em = lookup_extent_mapping(tree, 0, (u64)-1); 5720 if (em) 5721 remove_extent_mapping(tree, em); 5722 write_unlock(&tree->lock); 5723 if (!em) 5724 break; 5725 /* once for us */ 5726 free_extent_map(em); 5727 /* once for the tree */ 5728 free_extent_map(em); 5729 } 5730 } 5731 5732 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len) 5733 { 5734 struct extent_map *em; 5735 struct map_lookup *map; 5736 int ret; 5737 5738 em = btrfs_get_chunk_map(fs_info, logical, len); 5739 if (IS_ERR(em)) 5740 /* 5741 * We could return errors for these cases, but that could get 5742 * ugly and we'd probably do the same thing which is just not do 5743 * anything else and exit, so return 1 so the callers don't try 5744 * to use other copies. 5745 */ 5746 return 1; 5747 5748 map = em->map_lookup; 5749 if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1_MASK)) 5750 ret = map->num_stripes; 5751 else if (map->type & BTRFS_BLOCK_GROUP_RAID10) 5752 ret = map->sub_stripes; 5753 else if (map->type & BTRFS_BLOCK_GROUP_RAID5) 5754 ret = 2; 5755 else if (map->type & BTRFS_BLOCK_GROUP_RAID6) 5756 /* 5757 * There could be two corrupted data stripes, we need 5758 * to loop retry in order to rebuild the correct data. 5759 * 5760 * Fail a stripe at a time on every retry except the 5761 * stripe under reconstruction. 5762 */ 5763 ret = map->num_stripes; 5764 else 5765 ret = 1; 5766 free_extent_map(em); 5767 5768 down_read(&fs_info->dev_replace.rwsem); 5769 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace) && 5770 fs_info->dev_replace.tgtdev) 5771 ret++; 5772 up_read(&fs_info->dev_replace.rwsem); 5773 5774 return ret; 5775 } 5776 5777 unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info, 5778 u64 logical) 5779 { 5780 struct extent_map *em; 5781 struct map_lookup *map; 5782 unsigned long len = fs_info->sectorsize; 5783 5784 em = btrfs_get_chunk_map(fs_info, logical, len); 5785 5786 if (!WARN_ON(IS_ERR(em))) { 5787 map = em->map_lookup; 5788 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) 5789 len = map->stripe_len * nr_data_stripes(map); 5790 free_extent_map(em); 5791 } 5792 return len; 5793 } 5794 5795 int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info, u64 logical, u64 len) 5796 { 5797 struct extent_map *em; 5798 struct map_lookup *map; 5799 int ret = 0; 5800 5801 em = btrfs_get_chunk_map(fs_info, logical, len); 5802 5803 if(!WARN_ON(IS_ERR(em))) { 5804 map = em->map_lookup; 5805 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) 5806 ret = 1; 5807 free_extent_map(em); 5808 } 5809 return ret; 5810 } 5811 5812 static int find_live_mirror(struct btrfs_fs_info *fs_info, 5813 struct map_lookup *map, int first, 5814 int dev_replace_is_ongoing) 5815 { 5816 int i; 5817 int num_stripes; 5818 int preferred_mirror; 5819 int tolerance; 5820 struct btrfs_device *srcdev; 5821 5822 ASSERT((map->type & 5823 (BTRFS_BLOCK_GROUP_RAID1_MASK | BTRFS_BLOCK_GROUP_RAID10))); 5824 5825 if (map->type & BTRFS_BLOCK_GROUP_RAID10) 5826 num_stripes = map->sub_stripes; 5827 else 5828 num_stripes = map->num_stripes; 5829 5830 switch (fs_info->fs_devices->read_policy) { 5831 default: 5832 /* Shouldn't happen, just warn and use pid instead of failing */ 5833 btrfs_warn_rl(fs_info, 5834 "unknown read_policy type %u, reset to pid", 5835 fs_info->fs_devices->read_policy); 5836 fs_info->fs_devices->read_policy = BTRFS_READ_POLICY_PID; 5837 fallthrough; 5838 case BTRFS_READ_POLICY_PID: 5839 preferred_mirror = first + (current->pid % num_stripes); 5840 break; 5841 } 5842 5843 if (dev_replace_is_ongoing && 5844 fs_info->dev_replace.cont_reading_from_srcdev_mode == 5845 BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID) 5846 srcdev = fs_info->dev_replace.srcdev; 5847 else 5848 srcdev = NULL; 5849 5850 /* 5851 * try to avoid the drive that is the source drive for a 5852 * dev-replace procedure, only choose it if no other non-missing 5853 * mirror is available 5854 */ 5855 for (tolerance = 0; tolerance < 2; tolerance++) { 5856 if (map->stripes[preferred_mirror].dev->bdev && 5857 (tolerance || map->stripes[preferred_mirror].dev != srcdev)) 5858 return preferred_mirror; 5859 for (i = first; i < first + num_stripes; i++) { 5860 if (map->stripes[i].dev->bdev && 5861 (tolerance || map->stripes[i].dev != srcdev)) 5862 return i; 5863 } 5864 } 5865 5866 /* we couldn't find one that doesn't fail. Just return something 5867 * and the io error handling code will clean up eventually 5868 */ 5869 return preferred_mirror; 5870 } 5871 5872 /* Bubble-sort the stripe set to put the parity/syndrome stripes last */ 5873 static void sort_parity_stripes(struct btrfs_io_context *bioc, int num_stripes) 5874 { 5875 int i; 5876 int again = 1; 5877 5878 while (again) { 5879 again = 0; 5880 for (i = 0; i < num_stripes - 1; i++) { 5881 /* Swap if parity is on a smaller index */ 5882 if (bioc->raid_map[i] > bioc->raid_map[i + 1]) { 5883 swap(bioc->stripes[i], bioc->stripes[i + 1]); 5884 swap(bioc->raid_map[i], bioc->raid_map[i + 1]); 5885 again = 1; 5886 } 5887 } 5888 } 5889 } 5890 5891 static struct btrfs_io_context *alloc_btrfs_io_context(struct btrfs_fs_info *fs_info, 5892 int total_stripes, 5893 int real_stripes) 5894 { 5895 struct btrfs_io_context *bioc = kzalloc( 5896 /* The size of btrfs_io_context */ 5897 sizeof(struct btrfs_io_context) + 5898 /* Plus the variable array for the stripes */ 5899 sizeof(struct btrfs_io_stripe) * (total_stripes) + 5900 /* Plus the variable array for the tgt dev */ 5901 sizeof(int) * (real_stripes) + 5902 /* 5903 * Plus the raid_map, which includes both the tgt dev 5904 * and the stripes. 5905 */ 5906 sizeof(u64) * (total_stripes), 5907 GFP_NOFS|__GFP_NOFAIL); 5908 5909 atomic_set(&bioc->error, 0); 5910 refcount_set(&bioc->refs, 1); 5911 5912 bioc->fs_info = fs_info; 5913 bioc->tgtdev_map = (int *)(bioc->stripes + total_stripes); 5914 bioc->raid_map = (u64 *)(bioc->tgtdev_map + real_stripes); 5915 5916 return bioc; 5917 } 5918 5919 void btrfs_get_bioc(struct btrfs_io_context *bioc) 5920 { 5921 WARN_ON(!refcount_read(&bioc->refs)); 5922 refcount_inc(&bioc->refs); 5923 } 5924 5925 void btrfs_put_bioc(struct btrfs_io_context *bioc) 5926 { 5927 if (!bioc) 5928 return; 5929 if (refcount_dec_and_test(&bioc->refs)) 5930 kfree(bioc); 5931 } 5932 5933 /* can REQ_OP_DISCARD be sent with other REQ like REQ_OP_WRITE? */ 5934 /* 5935 * Please note that, discard won't be sent to target device of device 5936 * replace. 5937 */ 5938 static int __btrfs_map_block_for_discard(struct btrfs_fs_info *fs_info, 5939 u64 logical, u64 *length_ret, 5940 struct btrfs_io_context **bioc_ret) 5941 { 5942 struct extent_map *em; 5943 struct map_lookup *map; 5944 struct btrfs_io_context *bioc; 5945 u64 length = *length_ret; 5946 u64 offset; 5947 u64 stripe_nr; 5948 u64 stripe_nr_end; 5949 u64 stripe_end_offset; 5950 u64 stripe_cnt; 5951 u64 stripe_len; 5952 u64 stripe_offset; 5953 u64 num_stripes; 5954 u32 stripe_index; 5955 u32 factor = 0; 5956 u32 sub_stripes = 0; 5957 u64 stripes_per_dev = 0; 5958 u32 remaining_stripes = 0; 5959 u32 last_stripe = 0; 5960 int ret = 0; 5961 int i; 5962 5963 /* Discard always returns a bioc. */ 5964 ASSERT(bioc_ret); 5965 5966 em = btrfs_get_chunk_map(fs_info, logical, length); 5967 if (IS_ERR(em)) 5968 return PTR_ERR(em); 5969 5970 map = em->map_lookup; 5971 /* we don't discard raid56 yet */ 5972 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { 5973 ret = -EOPNOTSUPP; 5974 goto out; 5975 } 5976 5977 offset = logical - em->start; 5978 length = min_t(u64, em->start + em->len - logical, length); 5979 *length_ret = length; 5980 5981 stripe_len = map->stripe_len; 5982 /* 5983 * stripe_nr counts the total number of stripes we have to stride 5984 * to get to this block 5985 */ 5986 stripe_nr = div64_u64(offset, stripe_len); 5987 5988 /* stripe_offset is the offset of this block in its stripe */ 5989 stripe_offset = offset - stripe_nr * stripe_len; 5990 5991 stripe_nr_end = round_up(offset + length, map->stripe_len); 5992 stripe_nr_end = div64_u64(stripe_nr_end, map->stripe_len); 5993 stripe_cnt = stripe_nr_end - stripe_nr; 5994 stripe_end_offset = stripe_nr_end * map->stripe_len - 5995 (offset + length); 5996 /* 5997 * after this, stripe_nr is the number of stripes on this 5998 * device we have to walk to find the data, and stripe_index is 5999 * the number of our device in the stripe array 6000 */ 6001 num_stripes = 1; 6002 stripe_index = 0; 6003 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | 6004 BTRFS_BLOCK_GROUP_RAID10)) { 6005 if (map->type & BTRFS_BLOCK_GROUP_RAID0) 6006 sub_stripes = 1; 6007 else 6008 sub_stripes = map->sub_stripes; 6009 6010 factor = map->num_stripes / sub_stripes; 6011 num_stripes = min_t(u64, map->num_stripes, 6012 sub_stripes * stripe_cnt); 6013 stripe_nr = div_u64_rem(stripe_nr, factor, &stripe_index); 6014 stripe_index *= sub_stripes; 6015 stripes_per_dev = div_u64_rem(stripe_cnt, factor, 6016 &remaining_stripes); 6017 div_u64_rem(stripe_nr_end - 1, factor, &last_stripe); 6018 last_stripe *= sub_stripes; 6019 } else if (map->type & (BTRFS_BLOCK_GROUP_RAID1_MASK | 6020 BTRFS_BLOCK_GROUP_DUP)) { 6021 num_stripes = map->num_stripes; 6022 } else { 6023 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, 6024 &stripe_index); 6025 } 6026 6027 bioc = alloc_btrfs_io_context(fs_info, num_stripes, 0); 6028 if (!bioc) { 6029 ret = -ENOMEM; 6030 goto out; 6031 } 6032 6033 for (i = 0; i < num_stripes; i++) { 6034 bioc->stripes[i].physical = 6035 map->stripes[stripe_index].physical + 6036 stripe_offset + stripe_nr * map->stripe_len; 6037 bioc->stripes[i].dev = map->stripes[stripe_index].dev; 6038 6039 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | 6040 BTRFS_BLOCK_GROUP_RAID10)) { 6041 bioc->stripes[i].length = stripes_per_dev * 6042 map->stripe_len; 6043 6044 if (i / sub_stripes < remaining_stripes) 6045 bioc->stripes[i].length += map->stripe_len; 6046 6047 /* 6048 * Special for the first stripe and 6049 * the last stripe: 6050 * 6051 * |-------|...|-------| 6052 * |----------| 6053 * off end_off 6054 */ 6055 if (i < sub_stripes) 6056 bioc->stripes[i].length -= stripe_offset; 6057 6058 if (stripe_index >= last_stripe && 6059 stripe_index <= (last_stripe + 6060 sub_stripes - 1)) 6061 bioc->stripes[i].length -= stripe_end_offset; 6062 6063 if (i == sub_stripes - 1) 6064 stripe_offset = 0; 6065 } else { 6066 bioc->stripes[i].length = length; 6067 } 6068 6069 stripe_index++; 6070 if (stripe_index == map->num_stripes) { 6071 stripe_index = 0; 6072 stripe_nr++; 6073 } 6074 } 6075 6076 *bioc_ret = bioc; 6077 bioc->map_type = map->type; 6078 bioc->num_stripes = num_stripes; 6079 out: 6080 free_extent_map(em); 6081 return ret; 6082 } 6083 6084 /* 6085 * In dev-replace case, for repair case (that's the only case where the mirror 6086 * is selected explicitly when calling btrfs_map_block), blocks left of the 6087 * left cursor can also be read from the target drive. 6088 * 6089 * For REQ_GET_READ_MIRRORS, the target drive is added as the last one to the 6090 * array of stripes. 6091 * For READ, it also needs to be supported using the same mirror number. 6092 * 6093 * If the requested block is not left of the left cursor, EIO is returned. This 6094 * can happen because btrfs_num_copies() returns one more in the dev-replace 6095 * case. 6096 */ 6097 static int get_extra_mirror_from_replace(struct btrfs_fs_info *fs_info, 6098 u64 logical, u64 length, 6099 u64 srcdev_devid, int *mirror_num, 6100 u64 *physical) 6101 { 6102 struct btrfs_io_context *bioc = NULL; 6103 int num_stripes; 6104 int index_srcdev = 0; 6105 int found = 0; 6106 u64 physical_of_found = 0; 6107 int i; 6108 int ret = 0; 6109 6110 ret = __btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS, 6111 logical, &length, &bioc, 0, 0); 6112 if (ret) { 6113 ASSERT(bioc == NULL); 6114 return ret; 6115 } 6116 6117 num_stripes = bioc->num_stripes; 6118 if (*mirror_num > num_stripes) { 6119 /* 6120 * BTRFS_MAP_GET_READ_MIRRORS does not contain this mirror, 6121 * that means that the requested area is not left of the left 6122 * cursor 6123 */ 6124 btrfs_put_bioc(bioc); 6125 return -EIO; 6126 } 6127 6128 /* 6129 * process the rest of the function using the mirror_num of the source 6130 * drive. Therefore look it up first. At the end, patch the device 6131 * pointer to the one of the target drive. 6132 */ 6133 for (i = 0; i < num_stripes; i++) { 6134 if (bioc->stripes[i].dev->devid != srcdev_devid) 6135 continue; 6136 6137 /* 6138 * In case of DUP, in order to keep it simple, only add the 6139 * mirror with the lowest physical address 6140 */ 6141 if (found && 6142 physical_of_found <= bioc->stripes[i].physical) 6143 continue; 6144 6145 index_srcdev = i; 6146 found = 1; 6147 physical_of_found = bioc->stripes[i].physical; 6148 } 6149 6150 btrfs_put_bioc(bioc); 6151 6152 ASSERT(found); 6153 if (!found) 6154 return -EIO; 6155 6156 *mirror_num = index_srcdev + 1; 6157 *physical = physical_of_found; 6158 return ret; 6159 } 6160 6161 static bool is_block_group_to_copy(struct btrfs_fs_info *fs_info, u64 logical) 6162 { 6163 struct btrfs_block_group *cache; 6164 bool ret; 6165 6166 /* Non zoned filesystem does not use "to_copy" flag */ 6167 if (!btrfs_is_zoned(fs_info)) 6168 return false; 6169 6170 cache = btrfs_lookup_block_group(fs_info, logical); 6171 6172 spin_lock(&cache->lock); 6173 ret = cache->to_copy; 6174 spin_unlock(&cache->lock); 6175 6176 btrfs_put_block_group(cache); 6177 return ret; 6178 } 6179 6180 static void handle_ops_on_dev_replace(enum btrfs_map_op op, 6181 struct btrfs_io_context **bioc_ret, 6182 struct btrfs_dev_replace *dev_replace, 6183 u64 logical, 6184 int *num_stripes_ret, int *max_errors_ret) 6185 { 6186 struct btrfs_io_context *bioc = *bioc_ret; 6187 u64 srcdev_devid = dev_replace->srcdev->devid; 6188 int tgtdev_indexes = 0; 6189 int num_stripes = *num_stripes_ret; 6190 int max_errors = *max_errors_ret; 6191 int i; 6192 6193 if (op == BTRFS_MAP_WRITE) { 6194 int index_where_to_add; 6195 6196 /* 6197 * A block group which have "to_copy" set will eventually 6198 * copied by dev-replace process. We can avoid cloning IO here. 6199 */ 6200 if (is_block_group_to_copy(dev_replace->srcdev->fs_info, logical)) 6201 return; 6202 6203 /* 6204 * duplicate the write operations while the dev replace 6205 * procedure is running. Since the copying of the old disk to 6206 * the new disk takes place at run time while the filesystem is 6207 * mounted writable, the regular write operations to the old 6208 * disk have to be duplicated to go to the new disk as well. 6209 * 6210 * Note that device->missing is handled by the caller, and that 6211 * the write to the old disk is already set up in the stripes 6212 * array. 6213 */ 6214 index_where_to_add = num_stripes; 6215 for (i = 0; i < num_stripes; i++) { 6216 if (bioc->stripes[i].dev->devid == srcdev_devid) { 6217 /* write to new disk, too */ 6218 struct btrfs_io_stripe *new = 6219 bioc->stripes + index_where_to_add; 6220 struct btrfs_io_stripe *old = 6221 bioc->stripes + i; 6222 6223 new->physical = old->physical; 6224 new->length = old->length; 6225 new->dev = dev_replace->tgtdev; 6226 bioc->tgtdev_map[i] = index_where_to_add; 6227 index_where_to_add++; 6228 max_errors++; 6229 tgtdev_indexes++; 6230 } 6231 } 6232 num_stripes = index_where_to_add; 6233 } else if (op == BTRFS_MAP_GET_READ_MIRRORS) { 6234 int index_srcdev = 0; 6235 int found = 0; 6236 u64 physical_of_found = 0; 6237 6238 /* 6239 * During the dev-replace procedure, the target drive can also 6240 * be used to read data in case it is needed to repair a corrupt 6241 * block elsewhere. This is possible if the requested area is 6242 * left of the left cursor. In this area, the target drive is a 6243 * full copy of the source drive. 6244 */ 6245 for (i = 0; i < num_stripes; i++) { 6246 if (bioc->stripes[i].dev->devid == srcdev_devid) { 6247 /* 6248 * In case of DUP, in order to keep it simple, 6249 * only add the mirror with the lowest physical 6250 * address 6251 */ 6252 if (found && 6253 physical_of_found <= bioc->stripes[i].physical) 6254 continue; 6255 index_srcdev = i; 6256 found = 1; 6257 physical_of_found = bioc->stripes[i].physical; 6258 } 6259 } 6260 if (found) { 6261 struct btrfs_io_stripe *tgtdev_stripe = 6262 bioc->stripes + num_stripes; 6263 6264 tgtdev_stripe->physical = physical_of_found; 6265 tgtdev_stripe->length = 6266 bioc->stripes[index_srcdev].length; 6267 tgtdev_stripe->dev = dev_replace->tgtdev; 6268 bioc->tgtdev_map[index_srcdev] = num_stripes; 6269 6270 tgtdev_indexes++; 6271 num_stripes++; 6272 } 6273 } 6274 6275 *num_stripes_ret = num_stripes; 6276 *max_errors_ret = max_errors; 6277 bioc->num_tgtdevs = tgtdev_indexes; 6278 *bioc_ret = bioc; 6279 } 6280 6281 static bool need_full_stripe(enum btrfs_map_op op) 6282 { 6283 return (op == BTRFS_MAP_WRITE || op == BTRFS_MAP_GET_READ_MIRRORS); 6284 } 6285 6286 /* 6287 * Calculate the geometry of a particular (address, len) tuple. This 6288 * information is used to calculate how big a particular bio can get before it 6289 * straddles a stripe. 6290 * 6291 * @fs_info: the filesystem 6292 * @em: mapping containing the logical extent 6293 * @op: type of operation - write or read 6294 * @logical: address that we want to figure out the geometry of 6295 * @io_geom: pointer used to return values 6296 * 6297 * Returns < 0 in case a chunk for the given logical address cannot be found, 6298 * usually shouldn't happen unless @logical is corrupted, 0 otherwise. 6299 */ 6300 int btrfs_get_io_geometry(struct btrfs_fs_info *fs_info, struct extent_map *em, 6301 enum btrfs_map_op op, u64 logical, 6302 struct btrfs_io_geometry *io_geom) 6303 { 6304 struct map_lookup *map; 6305 u64 len; 6306 u64 offset; 6307 u64 stripe_offset; 6308 u64 stripe_nr; 6309 u32 stripe_len; 6310 u64 raid56_full_stripe_start = (u64)-1; 6311 int data_stripes; 6312 6313 ASSERT(op != BTRFS_MAP_DISCARD); 6314 6315 map = em->map_lookup; 6316 /* Offset of this logical address in the chunk */ 6317 offset = logical - em->start; 6318 /* Len of a stripe in a chunk */ 6319 stripe_len = map->stripe_len; 6320 /* 6321 * Stripe_nr is where this block falls in 6322 * stripe_offset is the offset of this block in its stripe. 6323 */ 6324 stripe_nr = div64_u64_rem(offset, stripe_len, &stripe_offset); 6325 ASSERT(stripe_offset < U32_MAX); 6326 6327 data_stripes = nr_data_stripes(map); 6328 6329 /* Only stripe based profiles needs to check against stripe length. */ 6330 if (map->type & BTRFS_BLOCK_GROUP_STRIPE_MASK) { 6331 u64 max_len = stripe_len - stripe_offset; 6332 6333 /* 6334 * In case of raid56, we need to know the stripe aligned start 6335 */ 6336 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { 6337 unsigned long full_stripe_len = stripe_len * data_stripes; 6338 raid56_full_stripe_start = offset; 6339 6340 /* 6341 * Allow a write of a full stripe, but make sure we 6342 * don't allow straddling of stripes 6343 */ 6344 raid56_full_stripe_start = div64_u64(raid56_full_stripe_start, 6345 full_stripe_len); 6346 raid56_full_stripe_start *= full_stripe_len; 6347 6348 /* 6349 * For writes to RAID[56], allow a full stripeset across 6350 * all disks. For other RAID types and for RAID[56] 6351 * reads, just allow a single stripe (on a single disk). 6352 */ 6353 if (op == BTRFS_MAP_WRITE) { 6354 max_len = stripe_len * data_stripes - 6355 (offset - raid56_full_stripe_start); 6356 } 6357 } 6358 len = min_t(u64, em->len - offset, max_len); 6359 } else { 6360 len = em->len - offset; 6361 } 6362 6363 io_geom->len = len; 6364 io_geom->offset = offset; 6365 io_geom->stripe_len = stripe_len; 6366 io_geom->stripe_nr = stripe_nr; 6367 io_geom->stripe_offset = stripe_offset; 6368 io_geom->raid56_stripe_offset = raid56_full_stripe_start; 6369 6370 return 0; 6371 } 6372 6373 static int __btrfs_map_block(struct btrfs_fs_info *fs_info, 6374 enum btrfs_map_op op, 6375 u64 logical, u64 *length, 6376 struct btrfs_io_context **bioc_ret, 6377 int mirror_num, int need_raid_map) 6378 { 6379 struct extent_map *em; 6380 struct map_lookup *map; 6381 u64 stripe_offset; 6382 u64 stripe_nr; 6383 u64 stripe_len; 6384 u32 stripe_index; 6385 int data_stripes; 6386 int i; 6387 int ret = 0; 6388 int num_stripes; 6389 int max_errors = 0; 6390 int tgtdev_indexes = 0; 6391 struct btrfs_io_context *bioc = NULL; 6392 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; 6393 int dev_replace_is_ongoing = 0; 6394 int num_alloc_stripes; 6395 int patch_the_first_stripe_for_dev_replace = 0; 6396 u64 physical_to_patch_in_first_stripe = 0; 6397 u64 raid56_full_stripe_start = (u64)-1; 6398 struct btrfs_io_geometry geom; 6399 6400 ASSERT(bioc_ret); 6401 ASSERT(op != BTRFS_MAP_DISCARD); 6402 6403 em = btrfs_get_chunk_map(fs_info, logical, *length); 6404 ASSERT(!IS_ERR(em)); 6405 6406 ret = btrfs_get_io_geometry(fs_info, em, op, logical, &geom); 6407 if (ret < 0) 6408 return ret; 6409 6410 map = em->map_lookup; 6411 6412 *length = geom.len; 6413 stripe_len = geom.stripe_len; 6414 stripe_nr = geom.stripe_nr; 6415 stripe_offset = geom.stripe_offset; 6416 raid56_full_stripe_start = geom.raid56_stripe_offset; 6417 data_stripes = nr_data_stripes(map); 6418 6419 down_read(&dev_replace->rwsem); 6420 dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace); 6421 /* 6422 * Hold the semaphore for read during the whole operation, write is 6423 * requested at commit time but must wait. 6424 */ 6425 if (!dev_replace_is_ongoing) 6426 up_read(&dev_replace->rwsem); 6427 6428 if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 && 6429 !need_full_stripe(op) && dev_replace->tgtdev != NULL) { 6430 ret = get_extra_mirror_from_replace(fs_info, logical, *length, 6431 dev_replace->srcdev->devid, 6432 &mirror_num, 6433 &physical_to_patch_in_first_stripe); 6434 if (ret) 6435 goto out; 6436 else 6437 patch_the_first_stripe_for_dev_replace = 1; 6438 } else if (mirror_num > map->num_stripes) { 6439 mirror_num = 0; 6440 } 6441 6442 num_stripes = 1; 6443 stripe_index = 0; 6444 if (map->type & BTRFS_BLOCK_GROUP_RAID0) { 6445 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, 6446 &stripe_index); 6447 if (!need_full_stripe(op)) 6448 mirror_num = 1; 6449 } else if (map->type & BTRFS_BLOCK_GROUP_RAID1_MASK) { 6450 if (need_full_stripe(op)) 6451 num_stripes = map->num_stripes; 6452 else if (mirror_num) 6453 stripe_index = mirror_num - 1; 6454 else { 6455 stripe_index = find_live_mirror(fs_info, map, 0, 6456 dev_replace_is_ongoing); 6457 mirror_num = stripe_index + 1; 6458 } 6459 6460 } else if (map->type & BTRFS_BLOCK_GROUP_DUP) { 6461 if (need_full_stripe(op)) { 6462 num_stripes = map->num_stripes; 6463 } else if (mirror_num) { 6464 stripe_index = mirror_num - 1; 6465 } else { 6466 mirror_num = 1; 6467 } 6468 6469 } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) { 6470 u32 factor = map->num_stripes / map->sub_stripes; 6471 6472 stripe_nr = div_u64_rem(stripe_nr, factor, &stripe_index); 6473 stripe_index *= map->sub_stripes; 6474 6475 if (need_full_stripe(op)) 6476 num_stripes = map->sub_stripes; 6477 else if (mirror_num) 6478 stripe_index += mirror_num - 1; 6479 else { 6480 int old_stripe_index = stripe_index; 6481 stripe_index = find_live_mirror(fs_info, map, 6482 stripe_index, 6483 dev_replace_is_ongoing); 6484 mirror_num = stripe_index - old_stripe_index + 1; 6485 } 6486 6487 } else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { 6488 if (need_raid_map && (need_full_stripe(op) || mirror_num > 1)) { 6489 /* push stripe_nr back to the start of the full stripe */ 6490 stripe_nr = div64_u64(raid56_full_stripe_start, 6491 stripe_len * data_stripes); 6492 6493 /* RAID[56] write or recovery. Return all stripes */ 6494 num_stripes = map->num_stripes; 6495 max_errors = nr_parity_stripes(map); 6496 6497 *length = map->stripe_len; 6498 stripe_index = 0; 6499 stripe_offset = 0; 6500 } else { 6501 /* 6502 * Mirror #0 or #1 means the original data block. 6503 * Mirror #2 is RAID5 parity block. 6504 * Mirror #3 is RAID6 Q block. 6505 */ 6506 stripe_nr = div_u64_rem(stripe_nr, 6507 data_stripes, &stripe_index); 6508 if (mirror_num > 1) 6509 stripe_index = data_stripes + mirror_num - 2; 6510 6511 /* We distribute the parity blocks across stripes */ 6512 div_u64_rem(stripe_nr + stripe_index, map->num_stripes, 6513 &stripe_index); 6514 if (!need_full_stripe(op) && mirror_num <= 1) 6515 mirror_num = 1; 6516 } 6517 } else { 6518 /* 6519 * after this, stripe_nr is the number of stripes on this 6520 * device we have to walk to find the data, and stripe_index is 6521 * the number of our device in the stripe array 6522 */ 6523 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, 6524 &stripe_index); 6525 mirror_num = stripe_index + 1; 6526 } 6527 if (stripe_index >= map->num_stripes) { 6528 btrfs_crit(fs_info, 6529 "stripe index math went horribly wrong, got stripe_index=%u, num_stripes=%u", 6530 stripe_index, map->num_stripes); 6531 ret = -EINVAL; 6532 goto out; 6533 } 6534 6535 num_alloc_stripes = num_stripes; 6536 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL) { 6537 if (op == BTRFS_MAP_WRITE) 6538 num_alloc_stripes <<= 1; 6539 if (op == BTRFS_MAP_GET_READ_MIRRORS) 6540 num_alloc_stripes++; 6541 tgtdev_indexes = num_stripes; 6542 } 6543 6544 bioc = alloc_btrfs_io_context(fs_info, num_alloc_stripes, tgtdev_indexes); 6545 if (!bioc) { 6546 ret = -ENOMEM; 6547 goto out; 6548 } 6549 6550 for (i = 0; i < num_stripes; i++) { 6551 bioc->stripes[i].physical = map->stripes[stripe_index].physical + 6552 stripe_offset + stripe_nr * map->stripe_len; 6553 bioc->stripes[i].dev = map->stripes[stripe_index].dev; 6554 stripe_index++; 6555 } 6556 6557 /* Build raid_map */ 6558 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK && need_raid_map && 6559 (need_full_stripe(op) || mirror_num > 1)) { 6560 u64 tmp; 6561 unsigned rot; 6562 6563 /* Work out the disk rotation on this stripe-set */ 6564 div_u64_rem(stripe_nr, num_stripes, &rot); 6565 6566 /* Fill in the logical address of each stripe */ 6567 tmp = stripe_nr * data_stripes; 6568 for (i = 0; i < data_stripes; i++) 6569 bioc->raid_map[(i + rot) % num_stripes] = 6570 em->start + (tmp + i) * map->stripe_len; 6571 6572 bioc->raid_map[(i + rot) % map->num_stripes] = RAID5_P_STRIPE; 6573 if (map->type & BTRFS_BLOCK_GROUP_RAID6) 6574 bioc->raid_map[(i + rot + 1) % num_stripes] = 6575 RAID6_Q_STRIPE; 6576 6577 sort_parity_stripes(bioc, num_stripes); 6578 } 6579 6580 if (need_full_stripe(op)) 6581 max_errors = btrfs_chunk_max_errors(map); 6582 6583 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL && 6584 need_full_stripe(op)) { 6585 handle_ops_on_dev_replace(op, &bioc, dev_replace, logical, 6586 &num_stripes, &max_errors); 6587 } 6588 6589 *bioc_ret = bioc; 6590 bioc->map_type = map->type; 6591 bioc->num_stripes = num_stripes; 6592 bioc->max_errors = max_errors; 6593 bioc->mirror_num = mirror_num; 6594 6595 /* 6596 * this is the case that REQ_READ && dev_replace_is_ongoing && 6597 * mirror_num == num_stripes + 1 && dev_replace target drive is 6598 * available as a mirror 6599 */ 6600 if (patch_the_first_stripe_for_dev_replace && num_stripes > 0) { 6601 WARN_ON(num_stripes > 1); 6602 bioc->stripes[0].dev = dev_replace->tgtdev; 6603 bioc->stripes[0].physical = physical_to_patch_in_first_stripe; 6604 bioc->mirror_num = map->num_stripes + 1; 6605 } 6606 out: 6607 if (dev_replace_is_ongoing) { 6608 lockdep_assert_held(&dev_replace->rwsem); 6609 /* Unlock and let waiting writers proceed */ 6610 up_read(&dev_replace->rwsem); 6611 } 6612 free_extent_map(em); 6613 return ret; 6614 } 6615 6616 int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, 6617 u64 logical, u64 *length, 6618 struct btrfs_io_context **bioc_ret, int mirror_num) 6619 { 6620 if (op == BTRFS_MAP_DISCARD) 6621 return __btrfs_map_block_for_discard(fs_info, logical, 6622 length, bioc_ret); 6623 6624 return __btrfs_map_block(fs_info, op, logical, length, bioc_ret, 6625 mirror_num, 0); 6626 } 6627 6628 /* For Scrub/replace */ 6629 int btrfs_map_sblock(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, 6630 u64 logical, u64 *length, 6631 struct btrfs_io_context **bioc_ret) 6632 { 6633 return __btrfs_map_block(fs_info, op, logical, length, bioc_ret, 0, 1); 6634 } 6635 6636 static inline void btrfs_end_bioc(struct btrfs_io_context *bioc, struct bio *bio) 6637 { 6638 bio->bi_private = bioc->private; 6639 bio->bi_end_io = bioc->end_io; 6640 bio_endio(bio); 6641 6642 btrfs_put_bioc(bioc); 6643 } 6644 6645 static void btrfs_end_bio(struct bio *bio) 6646 { 6647 struct btrfs_io_context *bioc = bio->bi_private; 6648 int is_orig_bio = 0; 6649 6650 if (bio->bi_status) { 6651 atomic_inc(&bioc->error); 6652 if (bio->bi_status == BLK_STS_IOERR || 6653 bio->bi_status == BLK_STS_TARGET) { 6654 struct btrfs_device *dev = btrfs_bio(bio)->device; 6655 6656 ASSERT(dev->bdev); 6657 if (btrfs_op(bio) == BTRFS_MAP_WRITE) 6658 btrfs_dev_stat_inc_and_print(dev, 6659 BTRFS_DEV_STAT_WRITE_ERRS); 6660 else if (!(bio->bi_opf & REQ_RAHEAD)) 6661 btrfs_dev_stat_inc_and_print(dev, 6662 BTRFS_DEV_STAT_READ_ERRS); 6663 if (bio->bi_opf & REQ_PREFLUSH) 6664 btrfs_dev_stat_inc_and_print(dev, 6665 BTRFS_DEV_STAT_FLUSH_ERRS); 6666 } 6667 } 6668 6669 if (bio == bioc->orig_bio) 6670 is_orig_bio = 1; 6671 6672 btrfs_bio_counter_dec(bioc->fs_info); 6673 6674 if (atomic_dec_and_test(&bioc->stripes_pending)) { 6675 if (!is_orig_bio) { 6676 bio_put(bio); 6677 bio = bioc->orig_bio; 6678 } 6679 6680 btrfs_bio(bio)->mirror_num = bioc->mirror_num; 6681 /* only send an error to the higher layers if it is 6682 * beyond the tolerance of the btrfs bio 6683 */ 6684 if (atomic_read(&bioc->error) > bioc->max_errors) { 6685 bio->bi_status = BLK_STS_IOERR; 6686 } else { 6687 /* 6688 * this bio is actually up to date, we didn't 6689 * go over the max number of errors 6690 */ 6691 bio->bi_status = BLK_STS_OK; 6692 } 6693 6694 btrfs_end_bioc(bioc, bio); 6695 } else if (!is_orig_bio) { 6696 bio_put(bio); 6697 } 6698 } 6699 6700 static void submit_stripe_bio(struct btrfs_io_context *bioc, struct bio *bio, 6701 u64 physical, struct btrfs_device *dev) 6702 { 6703 struct btrfs_fs_info *fs_info = bioc->fs_info; 6704 6705 bio->bi_private = bioc; 6706 btrfs_bio(bio)->device = dev; 6707 bio->bi_end_io = btrfs_end_bio; 6708 bio->bi_iter.bi_sector = physical >> 9; 6709 /* 6710 * For zone append writing, bi_sector must point the beginning of the 6711 * zone 6712 */ 6713 if (bio_op(bio) == REQ_OP_ZONE_APPEND) { 6714 if (btrfs_dev_is_sequential(dev, physical)) { 6715 u64 zone_start = round_down(physical, fs_info->zone_size); 6716 6717 bio->bi_iter.bi_sector = zone_start >> SECTOR_SHIFT; 6718 } else { 6719 bio->bi_opf &= ~REQ_OP_ZONE_APPEND; 6720 bio->bi_opf |= REQ_OP_WRITE; 6721 } 6722 } 6723 btrfs_debug_in_rcu(fs_info, 6724 "btrfs_map_bio: rw %d 0x%x, sector=%llu, dev=%lu (%s id %llu), size=%u", 6725 bio_op(bio), bio->bi_opf, bio->bi_iter.bi_sector, 6726 (unsigned long)dev->bdev->bd_dev, rcu_str_deref(dev->name), 6727 dev->devid, bio->bi_iter.bi_size); 6728 6729 btrfs_bio_counter_inc_noblocked(fs_info); 6730 6731 btrfsic_check_bio(bio); 6732 submit_bio(bio); 6733 } 6734 6735 static void bioc_error(struct btrfs_io_context *bioc, struct bio *bio, u64 logical) 6736 { 6737 atomic_inc(&bioc->error); 6738 if (atomic_dec_and_test(&bioc->stripes_pending)) { 6739 /* Should be the original bio. */ 6740 WARN_ON(bio != bioc->orig_bio); 6741 6742 btrfs_bio(bio)->mirror_num = bioc->mirror_num; 6743 bio->bi_iter.bi_sector = logical >> 9; 6744 if (atomic_read(&bioc->error) > bioc->max_errors) 6745 bio->bi_status = BLK_STS_IOERR; 6746 else 6747 bio->bi_status = BLK_STS_OK; 6748 btrfs_end_bioc(bioc, bio); 6749 } 6750 } 6751 6752 blk_status_t btrfs_map_bio(struct btrfs_fs_info *fs_info, struct bio *bio, 6753 int mirror_num) 6754 { 6755 struct btrfs_device *dev; 6756 struct bio *first_bio = bio; 6757 u64 logical = bio->bi_iter.bi_sector << 9; 6758 u64 length = 0; 6759 u64 map_length; 6760 int ret; 6761 int dev_nr; 6762 int total_devs; 6763 struct btrfs_io_context *bioc = NULL; 6764 6765 length = bio->bi_iter.bi_size; 6766 map_length = length; 6767 6768 btrfs_bio_counter_inc_blocked(fs_info); 6769 ret = __btrfs_map_block(fs_info, btrfs_op(bio), logical, 6770 &map_length, &bioc, mirror_num, 1); 6771 if (ret) { 6772 btrfs_bio_counter_dec(fs_info); 6773 return errno_to_blk_status(ret); 6774 } 6775 6776 total_devs = bioc->num_stripes; 6777 bioc->orig_bio = first_bio; 6778 bioc->private = first_bio->bi_private; 6779 bioc->end_io = first_bio->bi_end_io; 6780 atomic_set(&bioc->stripes_pending, bioc->num_stripes); 6781 6782 if ((bioc->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) && 6783 ((btrfs_op(bio) == BTRFS_MAP_WRITE) || (mirror_num > 1))) { 6784 /* In this case, map_length has been set to the length of 6785 a single stripe; not the whole write */ 6786 if (btrfs_op(bio) == BTRFS_MAP_WRITE) { 6787 ret = raid56_parity_write(bio, bioc, map_length); 6788 } else { 6789 ret = raid56_parity_recover(bio, bioc, map_length, 6790 mirror_num, 1); 6791 } 6792 6793 btrfs_bio_counter_dec(fs_info); 6794 return errno_to_blk_status(ret); 6795 } 6796 6797 if (map_length < length) { 6798 btrfs_crit(fs_info, 6799 "mapping failed logical %llu bio len %llu len %llu", 6800 logical, length, map_length); 6801 BUG(); 6802 } 6803 6804 for (dev_nr = 0; dev_nr < total_devs; dev_nr++) { 6805 dev = bioc->stripes[dev_nr].dev; 6806 if (!dev || !dev->bdev || test_bit(BTRFS_DEV_STATE_MISSING, 6807 &dev->dev_state) || 6808 (btrfs_op(first_bio) == BTRFS_MAP_WRITE && 6809 !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))) { 6810 bioc_error(bioc, first_bio, logical); 6811 continue; 6812 } 6813 6814 if (dev_nr < total_devs - 1) { 6815 bio = btrfs_bio_clone(dev->bdev, first_bio); 6816 } else { 6817 bio = first_bio; 6818 bio_set_dev(bio, dev->bdev); 6819 } 6820 6821 submit_stripe_bio(bioc, bio, bioc->stripes[dev_nr].physical, dev); 6822 } 6823 btrfs_bio_counter_dec(fs_info); 6824 return BLK_STS_OK; 6825 } 6826 6827 static bool dev_args_match_fs_devices(const struct btrfs_dev_lookup_args *args, 6828 const struct btrfs_fs_devices *fs_devices) 6829 { 6830 if (args->fsid == NULL) 6831 return true; 6832 if (memcmp(fs_devices->metadata_uuid, args->fsid, BTRFS_FSID_SIZE) == 0) 6833 return true; 6834 return false; 6835 } 6836 6837 static bool dev_args_match_device(const struct btrfs_dev_lookup_args *args, 6838 const struct btrfs_device *device) 6839 { 6840 ASSERT((args->devid != (u64)-1) || args->missing); 6841 6842 if ((args->devid != (u64)-1) && device->devid != args->devid) 6843 return false; 6844 if (args->uuid && memcmp(device->uuid, args->uuid, BTRFS_UUID_SIZE) != 0) 6845 return false; 6846 if (!args->missing) 6847 return true; 6848 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state) && 6849 !device->bdev) 6850 return true; 6851 return false; 6852 } 6853 6854 /* 6855 * Find a device specified by @devid or @uuid in the list of @fs_devices, or 6856 * return NULL. 6857 * 6858 * If devid and uuid are both specified, the match must be exact, otherwise 6859 * only devid is used. 6860 */ 6861 struct btrfs_device *btrfs_find_device(const struct btrfs_fs_devices *fs_devices, 6862 const struct btrfs_dev_lookup_args *args) 6863 { 6864 struct btrfs_device *device; 6865 struct btrfs_fs_devices *seed_devs; 6866 6867 if (dev_args_match_fs_devices(args, fs_devices)) { 6868 list_for_each_entry(device, &fs_devices->devices, dev_list) { 6869 if (dev_args_match_device(args, device)) 6870 return device; 6871 } 6872 } 6873 6874 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { 6875 if (!dev_args_match_fs_devices(args, seed_devs)) 6876 continue; 6877 list_for_each_entry(device, &seed_devs->devices, dev_list) { 6878 if (dev_args_match_device(args, device)) 6879 return device; 6880 } 6881 } 6882 6883 return NULL; 6884 } 6885 6886 static struct btrfs_device *add_missing_dev(struct btrfs_fs_devices *fs_devices, 6887 u64 devid, u8 *dev_uuid) 6888 { 6889 struct btrfs_device *device; 6890 unsigned int nofs_flag; 6891 6892 /* 6893 * We call this under the chunk_mutex, so we want to use NOFS for this 6894 * allocation, however we don't want to change btrfs_alloc_device() to 6895 * always do NOFS because we use it in a lot of other GFP_KERNEL safe 6896 * places. 6897 */ 6898 nofs_flag = memalloc_nofs_save(); 6899 device = btrfs_alloc_device(NULL, &devid, dev_uuid); 6900 memalloc_nofs_restore(nofs_flag); 6901 if (IS_ERR(device)) 6902 return device; 6903 6904 list_add(&device->dev_list, &fs_devices->devices); 6905 device->fs_devices = fs_devices; 6906 fs_devices->num_devices++; 6907 6908 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 6909 fs_devices->missing_devices++; 6910 6911 return device; 6912 } 6913 6914 /** 6915 * btrfs_alloc_device - allocate struct btrfs_device 6916 * @fs_info: used only for generating a new devid, can be NULL if 6917 * devid is provided (i.e. @devid != NULL). 6918 * @devid: a pointer to devid for this device. If NULL a new devid 6919 * is generated. 6920 * @uuid: a pointer to UUID for this device. If NULL a new UUID 6921 * is generated. 6922 * 6923 * Return: a pointer to a new &struct btrfs_device on success; ERR_PTR() 6924 * on error. Returned struct is not linked onto any lists and must be 6925 * destroyed with btrfs_free_device. 6926 */ 6927 struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info, 6928 const u64 *devid, 6929 const u8 *uuid) 6930 { 6931 struct btrfs_device *dev; 6932 u64 tmp; 6933 6934 if (WARN_ON(!devid && !fs_info)) 6935 return ERR_PTR(-EINVAL); 6936 6937 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 6938 if (!dev) 6939 return ERR_PTR(-ENOMEM); 6940 6941 /* 6942 * Preallocate a bio that's always going to be used for flushing device 6943 * barriers and matches the device lifespan 6944 */ 6945 dev->flush_bio = bio_kmalloc(GFP_KERNEL, 0); 6946 if (!dev->flush_bio) { 6947 kfree(dev); 6948 return ERR_PTR(-ENOMEM); 6949 } 6950 6951 INIT_LIST_HEAD(&dev->dev_list); 6952 INIT_LIST_HEAD(&dev->dev_alloc_list); 6953 INIT_LIST_HEAD(&dev->post_commit_list); 6954 6955 atomic_set(&dev->dev_stats_ccnt, 0); 6956 btrfs_device_data_ordered_init(dev); 6957 extent_io_tree_init(fs_info, &dev->alloc_state, 6958 IO_TREE_DEVICE_ALLOC_STATE, NULL); 6959 6960 if (devid) 6961 tmp = *devid; 6962 else { 6963 int ret; 6964 6965 ret = find_next_devid(fs_info, &tmp); 6966 if (ret) { 6967 btrfs_free_device(dev); 6968 return ERR_PTR(ret); 6969 } 6970 } 6971 dev->devid = tmp; 6972 6973 if (uuid) 6974 memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE); 6975 else 6976 generate_random_uuid(dev->uuid); 6977 6978 return dev; 6979 } 6980 6981 static void btrfs_report_missing_device(struct btrfs_fs_info *fs_info, 6982 u64 devid, u8 *uuid, bool error) 6983 { 6984 if (error) 6985 btrfs_err_rl(fs_info, "devid %llu uuid %pU is missing", 6986 devid, uuid); 6987 else 6988 btrfs_warn_rl(fs_info, "devid %llu uuid %pU is missing", 6989 devid, uuid); 6990 } 6991 6992 static u64 calc_stripe_length(u64 type, u64 chunk_len, int num_stripes) 6993 { 6994 const int data_stripes = calc_data_stripes(type, num_stripes); 6995 6996 return div_u64(chunk_len, data_stripes); 6997 } 6998 6999 #if BITS_PER_LONG == 32 7000 /* 7001 * Due to page cache limit, metadata beyond BTRFS_32BIT_MAX_FILE_SIZE 7002 * can't be accessed on 32bit systems. 7003 * 7004 * This function do mount time check to reject the fs if it already has 7005 * metadata chunk beyond that limit. 7006 */ 7007 static int check_32bit_meta_chunk(struct btrfs_fs_info *fs_info, 7008 u64 logical, u64 length, u64 type) 7009 { 7010 if (!(type & BTRFS_BLOCK_GROUP_METADATA)) 7011 return 0; 7012 7013 if (logical + length < MAX_LFS_FILESIZE) 7014 return 0; 7015 7016 btrfs_err_32bit_limit(fs_info); 7017 return -EOVERFLOW; 7018 } 7019 7020 /* 7021 * This is to give early warning for any metadata chunk reaching 7022 * BTRFS_32BIT_EARLY_WARN_THRESHOLD. 7023 * Although we can still access the metadata, it's not going to be possible 7024 * once the limit is reached. 7025 */ 7026 static void warn_32bit_meta_chunk(struct btrfs_fs_info *fs_info, 7027 u64 logical, u64 length, u64 type) 7028 { 7029 if (!(type & BTRFS_BLOCK_GROUP_METADATA)) 7030 return; 7031 7032 if (logical + length < BTRFS_32BIT_EARLY_WARN_THRESHOLD) 7033 return; 7034 7035 btrfs_warn_32bit_limit(fs_info); 7036 } 7037 #endif 7038 7039 static struct btrfs_device *handle_missing_device(struct btrfs_fs_info *fs_info, 7040 u64 devid, u8 *uuid) 7041 { 7042 struct btrfs_device *dev; 7043 7044 if (!btrfs_test_opt(fs_info, DEGRADED)) { 7045 btrfs_report_missing_device(fs_info, devid, uuid, true); 7046 return ERR_PTR(-ENOENT); 7047 } 7048 7049 dev = add_missing_dev(fs_info->fs_devices, devid, uuid); 7050 if (IS_ERR(dev)) { 7051 btrfs_err(fs_info, "failed to init missing device %llu: %ld", 7052 devid, PTR_ERR(dev)); 7053 return dev; 7054 } 7055 btrfs_report_missing_device(fs_info, devid, uuid, false); 7056 7057 return dev; 7058 } 7059 7060 static int read_one_chunk(struct btrfs_key *key, struct extent_buffer *leaf, 7061 struct btrfs_chunk *chunk) 7062 { 7063 BTRFS_DEV_LOOKUP_ARGS(args); 7064 struct btrfs_fs_info *fs_info = leaf->fs_info; 7065 struct extent_map_tree *map_tree = &fs_info->mapping_tree; 7066 struct map_lookup *map; 7067 struct extent_map *em; 7068 u64 logical; 7069 u64 length; 7070 u64 devid; 7071 u64 type; 7072 u8 uuid[BTRFS_UUID_SIZE]; 7073 int num_stripes; 7074 int ret; 7075 int i; 7076 7077 logical = key->offset; 7078 length = btrfs_chunk_length(leaf, chunk); 7079 type = btrfs_chunk_type(leaf, chunk); 7080 num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 7081 7082 #if BITS_PER_LONG == 32 7083 ret = check_32bit_meta_chunk(fs_info, logical, length, type); 7084 if (ret < 0) 7085 return ret; 7086 warn_32bit_meta_chunk(fs_info, logical, length, type); 7087 #endif 7088 7089 /* 7090 * Only need to verify chunk item if we're reading from sys chunk array, 7091 * as chunk item in tree block is already verified by tree-checker. 7092 */ 7093 if (leaf->start == BTRFS_SUPER_INFO_OFFSET) { 7094 ret = btrfs_check_chunk_valid(leaf, chunk, logical); 7095 if (ret) 7096 return ret; 7097 } 7098 7099 read_lock(&map_tree->lock); 7100 em = lookup_extent_mapping(map_tree, logical, 1); 7101 read_unlock(&map_tree->lock); 7102 7103 /* already mapped? */ 7104 if (em && em->start <= logical && em->start + em->len > logical) { 7105 free_extent_map(em); 7106 return 0; 7107 } else if (em) { 7108 free_extent_map(em); 7109 } 7110 7111 em = alloc_extent_map(); 7112 if (!em) 7113 return -ENOMEM; 7114 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS); 7115 if (!map) { 7116 free_extent_map(em); 7117 return -ENOMEM; 7118 } 7119 7120 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); 7121 em->map_lookup = map; 7122 em->start = logical; 7123 em->len = length; 7124 em->orig_start = 0; 7125 em->block_start = 0; 7126 em->block_len = em->len; 7127 7128 map->num_stripes = num_stripes; 7129 map->io_width = btrfs_chunk_io_width(leaf, chunk); 7130 map->io_align = btrfs_chunk_io_align(leaf, chunk); 7131 map->stripe_len = btrfs_chunk_stripe_len(leaf, chunk); 7132 map->type = type; 7133 map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk); 7134 map->verified_stripes = 0; 7135 em->orig_block_len = calc_stripe_length(type, em->len, 7136 map->num_stripes); 7137 for (i = 0; i < num_stripes; i++) { 7138 map->stripes[i].physical = 7139 btrfs_stripe_offset_nr(leaf, chunk, i); 7140 devid = btrfs_stripe_devid_nr(leaf, chunk, i); 7141 args.devid = devid; 7142 read_extent_buffer(leaf, uuid, (unsigned long) 7143 btrfs_stripe_dev_uuid_nr(chunk, i), 7144 BTRFS_UUID_SIZE); 7145 args.uuid = uuid; 7146 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, &args); 7147 if (!map->stripes[i].dev) { 7148 map->stripes[i].dev = handle_missing_device(fs_info, 7149 devid, uuid); 7150 if (IS_ERR(map->stripes[i].dev)) { 7151 free_extent_map(em); 7152 return PTR_ERR(map->stripes[i].dev); 7153 } 7154 } 7155 7156 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, 7157 &(map->stripes[i].dev->dev_state)); 7158 } 7159 7160 write_lock(&map_tree->lock); 7161 ret = add_extent_mapping(map_tree, em, 0); 7162 write_unlock(&map_tree->lock); 7163 if (ret < 0) { 7164 btrfs_err(fs_info, 7165 "failed to add chunk map, start=%llu len=%llu: %d", 7166 em->start, em->len, ret); 7167 } 7168 free_extent_map(em); 7169 7170 return ret; 7171 } 7172 7173 static void fill_device_from_item(struct extent_buffer *leaf, 7174 struct btrfs_dev_item *dev_item, 7175 struct btrfs_device *device) 7176 { 7177 unsigned long ptr; 7178 7179 device->devid = btrfs_device_id(leaf, dev_item); 7180 device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item); 7181 device->total_bytes = device->disk_total_bytes; 7182 device->commit_total_bytes = device->disk_total_bytes; 7183 device->bytes_used = btrfs_device_bytes_used(leaf, dev_item); 7184 device->commit_bytes_used = device->bytes_used; 7185 device->type = btrfs_device_type(leaf, dev_item); 7186 device->io_align = btrfs_device_io_align(leaf, dev_item); 7187 device->io_width = btrfs_device_io_width(leaf, dev_item); 7188 device->sector_size = btrfs_device_sector_size(leaf, dev_item); 7189 WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID); 7190 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); 7191 7192 ptr = btrfs_device_uuid(dev_item); 7193 read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); 7194 } 7195 7196 static struct btrfs_fs_devices *open_seed_devices(struct btrfs_fs_info *fs_info, 7197 u8 *fsid) 7198 { 7199 struct btrfs_fs_devices *fs_devices; 7200 int ret; 7201 7202 lockdep_assert_held(&uuid_mutex); 7203 ASSERT(fsid); 7204 7205 /* This will match only for multi-device seed fs */ 7206 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list) 7207 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE)) 7208 return fs_devices; 7209 7210 7211 fs_devices = find_fsid(fsid, NULL); 7212 if (!fs_devices) { 7213 if (!btrfs_test_opt(fs_info, DEGRADED)) 7214 return ERR_PTR(-ENOENT); 7215 7216 fs_devices = alloc_fs_devices(fsid, NULL); 7217 if (IS_ERR(fs_devices)) 7218 return fs_devices; 7219 7220 fs_devices->seeding = true; 7221 fs_devices->opened = 1; 7222 return fs_devices; 7223 } 7224 7225 /* 7226 * Upon first call for a seed fs fsid, just create a private copy of the 7227 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list 7228 */ 7229 fs_devices = clone_fs_devices(fs_devices); 7230 if (IS_ERR(fs_devices)) 7231 return fs_devices; 7232 7233 ret = open_fs_devices(fs_devices, FMODE_READ, fs_info->bdev_holder); 7234 if (ret) { 7235 free_fs_devices(fs_devices); 7236 return ERR_PTR(ret); 7237 } 7238 7239 if (!fs_devices->seeding) { 7240 close_fs_devices(fs_devices); 7241 free_fs_devices(fs_devices); 7242 return ERR_PTR(-EINVAL); 7243 } 7244 7245 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list); 7246 7247 return fs_devices; 7248 } 7249 7250 static int read_one_dev(struct extent_buffer *leaf, 7251 struct btrfs_dev_item *dev_item) 7252 { 7253 BTRFS_DEV_LOOKUP_ARGS(args); 7254 struct btrfs_fs_info *fs_info = leaf->fs_info; 7255 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 7256 struct btrfs_device *device; 7257 u64 devid; 7258 int ret; 7259 u8 fs_uuid[BTRFS_FSID_SIZE]; 7260 u8 dev_uuid[BTRFS_UUID_SIZE]; 7261 7262 devid = args.devid = btrfs_device_id(leaf, dev_item); 7263 read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item), 7264 BTRFS_UUID_SIZE); 7265 read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item), 7266 BTRFS_FSID_SIZE); 7267 args.uuid = dev_uuid; 7268 args.fsid = fs_uuid; 7269 7270 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) { 7271 fs_devices = open_seed_devices(fs_info, fs_uuid); 7272 if (IS_ERR(fs_devices)) 7273 return PTR_ERR(fs_devices); 7274 } 7275 7276 device = btrfs_find_device(fs_info->fs_devices, &args); 7277 if (!device) { 7278 if (!btrfs_test_opt(fs_info, DEGRADED)) { 7279 btrfs_report_missing_device(fs_info, devid, 7280 dev_uuid, true); 7281 return -ENOENT; 7282 } 7283 7284 device = add_missing_dev(fs_devices, devid, dev_uuid); 7285 if (IS_ERR(device)) { 7286 btrfs_err(fs_info, 7287 "failed to add missing dev %llu: %ld", 7288 devid, PTR_ERR(device)); 7289 return PTR_ERR(device); 7290 } 7291 btrfs_report_missing_device(fs_info, devid, dev_uuid, false); 7292 } else { 7293 if (!device->bdev) { 7294 if (!btrfs_test_opt(fs_info, DEGRADED)) { 7295 btrfs_report_missing_device(fs_info, 7296 devid, dev_uuid, true); 7297 return -ENOENT; 7298 } 7299 btrfs_report_missing_device(fs_info, devid, 7300 dev_uuid, false); 7301 } 7302 7303 if (!device->bdev && 7304 !test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { 7305 /* 7306 * this happens when a device that was properly setup 7307 * in the device info lists suddenly goes bad. 7308 * device->bdev is NULL, and so we have to set 7309 * device->missing to one here 7310 */ 7311 device->fs_devices->missing_devices++; 7312 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 7313 } 7314 7315 /* Move the device to its own fs_devices */ 7316 if (device->fs_devices != fs_devices) { 7317 ASSERT(test_bit(BTRFS_DEV_STATE_MISSING, 7318 &device->dev_state)); 7319 7320 list_move(&device->dev_list, &fs_devices->devices); 7321 device->fs_devices->num_devices--; 7322 fs_devices->num_devices++; 7323 7324 device->fs_devices->missing_devices--; 7325 fs_devices->missing_devices++; 7326 7327 device->fs_devices = fs_devices; 7328 } 7329 } 7330 7331 if (device->fs_devices != fs_info->fs_devices) { 7332 BUG_ON(test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)); 7333 if (device->generation != 7334 btrfs_device_generation(leaf, dev_item)) 7335 return -EINVAL; 7336 } 7337 7338 fill_device_from_item(leaf, dev_item, device); 7339 if (device->bdev) { 7340 u64 max_total_bytes = bdev_nr_bytes(device->bdev); 7341 7342 if (device->total_bytes > max_total_bytes) { 7343 btrfs_err(fs_info, 7344 "device total_bytes should be at most %llu but found %llu", 7345 max_total_bytes, device->total_bytes); 7346 return -EINVAL; 7347 } 7348 } 7349 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 7350 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && 7351 !test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { 7352 device->fs_devices->total_rw_bytes += device->total_bytes; 7353 atomic64_add(device->total_bytes - device->bytes_used, 7354 &fs_info->free_chunk_space); 7355 } 7356 ret = 0; 7357 return ret; 7358 } 7359 7360 int btrfs_read_sys_array(struct btrfs_fs_info *fs_info) 7361 { 7362 struct btrfs_super_block *super_copy = fs_info->super_copy; 7363 struct extent_buffer *sb; 7364 struct btrfs_disk_key *disk_key; 7365 struct btrfs_chunk *chunk; 7366 u8 *array_ptr; 7367 unsigned long sb_array_offset; 7368 int ret = 0; 7369 u32 num_stripes; 7370 u32 array_size; 7371 u32 len = 0; 7372 u32 cur_offset; 7373 u64 type; 7374 struct btrfs_key key; 7375 7376 ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize); 7377 7378 /* 7379 * We allocated a dummy extent, just to use extent buffer accessors. 7380 * There will be unused space after BTRFS_SUPER_INFO_SIZE, but 7381 * that's fine, we will not go beyond system chunk array anyway. 7382 */ 7383 sb = alloc_dummy_extent_buffer(fs_info, BTRFS_SUPER_INFO_OFFSET); 7384 if (!sb) 7385 return -ENOMEM; 7386 set_extent_buffer_uptodate(sb); 7387 7388 write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE); 7389 array_size = btrfs_super_sys_array_size(super_copy); 7390 7391 array_ptr = super_copy->sys_chunk_array; 7392 sb_array_offset = offsetof(struct btrfs_super_block, sys_chunk_array); 7393 cur_offset = 0; 7394 7395 while (cur_offset < array_size) { 7396 disk_key = (struct btrfs_disk_key *)array_ptr; 7397 len = sizeof(*disk_key); 7398 if (cur_offset + len > array_size) 7399 goto out_short_read; 7400 7401 btrfs_disk_key_to_cpu(&key, disk_key); 7402 7403 array_ptr += len; 7404 sb_array_offset += len; 7405 cur_offset += len; 7406 7407 if (key.type != BTRFS_CHUNK_ITEM_KEY) { 7408 btrfs_err(fs_info, 7409 "unexpected item type %u in sys_array at offset %u", 7410 (u32)key.type, cur_offset); 7411 ret = -EIO; 7412 break; 7413 } 7414 7415 chunk = (struct btrfs_chunk *)sb_array_offset; 7416 /* 7417 * At least one btrfs_chunk with one stripe must be present, 7418 * exact stripe count check comes afterwards 7419 */ 7420 len = btrfs_chunk_item_size(1); 7421 if (cur_offset + len > array_size) 7422 goto out_short_read; 7423 7424 num_stripes = btrfs_chunk_num_stripes(sb, chunk); 7425 if (!num_stripes) { 7426 btrfs_err(fs_info, 7427 "invalid number of stripes %u in sys_array at offset %u", 7428 num_stripes, cur_offset); 7429 ret = -EIO; 7430 break; 7431 } 7432 7433 type = btrfs_chunk_type(sb, chunk); 7434 if ((type & BTRFS_BLOCK_GROUP_SYSTEM) == 0) { 7435 btrfs_err(fs_info, 7436 "invalid chunk type %llu in sys_array at offset %u", 7437 type, cur_offset); 7438 ret = -EIO; 7439 break; 7440 } 7441 7442 len = btrfs_chunk_item_size(num_stripes); 7443 if (cur_offset + len > array_size) 7444 goto out_short_read; 7445 7446 ret = read_one_chunk(&key, sb, chunk); 7447 if (ret) 7448 break; 7449 7450 array_ptr += len; 7451 sb_array_offset += len; 7452 cur_offset += len; 7453 } 7454 clear_extent_buffer_uptodate(sb); 7455 free_extent_buffer_stale(sb); 7456 return ret; 7457 7458 out_short_read: 7459 btrfs_err(fs_info, "sys_array too short to read %u bytes at offset %u", 7460 len, cur_offset); 7461 clear_extent_buffer_uptodate(sb); 7462 free_extent_buffer_stale(sb); 7463 return -EIO; 7464 } 7465 7466 /* 7467 * Check if all chunks in the fs are OK for read-write degraded mount 7468 * 7469 * If the @failing_dev is specified, it's accounted as missing. 7470 * 7471 * Return true if all chunks meet the minimal RW mount requirements. 7472 * Return false if any chunk doesn't meet the minimal RW mount requirements. 7473 */ 7474 bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info, 7475 struct btrfs_device *failing_dev) 7476 { 7477 struct extent_map_tree *map_tree = &fs_info->mapping_tree; 7478 struct extent_map *em; 7479 u64 next_start = 0; 7480 bool ret = true; 7481 7482 read_lock(&map_tree->lock); 7483 em = lookup_extent_mapping(map_tree, 0, (u64)-1); 7484 read_unlock(&map_tree->lock); 7485 /* No chunk at all? Return false anyway */ 7486 if (!em) { 7487 ret = false; 7488 goto out; 7489 } 7490 while (em) { 7491 struct map_lookup *map; 7492 int missing = 0; 7493 int max_tolerated; 7494 int i; 7495 7496 map = em->map_lookup; 7497 max_tolerated = 7498 btrfs_get_num_tolerated_disk_barrier_failures( 7499 map->type); 7500 for (i = 0; i < map->num_stripes; i++) { 7501 struct btrfs_device *dev = map->stripes[i].dev; 7502 7503 if (!dev || !dev->bdev || 7504 test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state) || 7505 dev->last_flush_error) 7506 missing++; 7507 else if (failing_dev && failing_dev == dev) 7508 missing++; 7509 } 7510 if (missing > max_tolerated) { 7511 if (!failing_dev) 7512 btrfs_warn(fs_info, 7513 "chunk %llu missing %d devices, max tolerance is %d for writable mount", 7514 em->start, missing, max_tolerated); 7515 free_extent_map(em); 7516 ret = false; 7517 goto out; 7518 } 7519 next_start = extent_map_end(em); 7520 free_extent_map(em); 7521 7522 read_lock(&map_tree->lock); 7523 em = lookup_extent_mapping(map_tree, next_start, 7524 (u64)(-1) - next_start); 7525 read_unlock(&map_tree->lock); 7526 } 7527 out: 7528 return ret; 7529 } 7530 7531 static void readahead_tree_node_children(struct extent_buffer *node) 7532 { 7533 int i; 7534 const int nr_items = btrfs_header_nritems(node); 7535 7536 for (i = 0; i < nr_items; i++) 7537 btrfs_readahead_node_child(node, i); 7538 } 7539 7540 int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info) 7541 { 7542 struct btrfs_root *root = fs_info->chunk_root; 7543 struct btrfs_path *path; 7544 struct extent_buffer *leaf; 7545 struct btrfs_key key; 7546 struct btrfs_key found_key; 7547 int ret; 7548 int slot; 7549 int iter_ret = 0; 7550 u64 total_dev = 0; 7551 u64 last_ra_node = 0; 7552 7553 path = btrfs_alloc_path(); 7554 if (!path) 7555 return -ENOMEM; 7556 7557 /* 7558 * uuid_mutex is needed only if we are mounting a sprout FS 7559 * otherwise we don't need it. 7560 */ 7561 mutex_lock(&uuid_mutex); 7562 7563 /* 7564 * It is possible for mount and umount to race in such a way that 7565 * we execute this code path, but open_fs_devices failed to clear 7566 * total_rw_bytes. We certainly want it cleared before reading the 7567 * device items, so clear it here. 7568 */ 7569 fs_info->fs_devices->total_rw_bytes = 0; 7570 7571 /* 7572 * Lockdep complains about possible circular locking dependency between 7573 * a disk's open_mutex (struct gendisk.open_mutex), the rw semaphores 7574 * used for freeze procection of a fs (struct super_block.s_writers), 7575 * which we take when starting a transaction, and extent buffers of the 7576 * chunk tree if we call read_one_dev() while holding a lock on an 7577 * extent buffer of the chunk tree. Since we are mounting the filesystem 7578 * and at this point there can't be any concurrent task modifying the 7579 * chunk tree, to keep it simple, just skip locking on the chunk tree. 7580 */ 7581 ASSERT(!test_bit(BTRFS_FS_OPEN, &fs_info->flags)); 7582 path->skip_locking = 1; 7583 7584 /* 7585 * Read all device items, and then all the chunk items. All 7586 * device items are found before any chunk item (their object id 7587 * is smaller than the lowest possible object id for a chunk 7588 * item - BTRFS_FIRST_CHUNK_TREE_OBJECTID). 7589 */ 7590 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 7591 key.offset = 0; 7592 key.type = 0; 7593 btrfs_for_each_slot(root, &key, &found_key, path, iter_ret) { 7594 struct extent_buffer *node = path->nodes[1]; 7595 7596 leaf = path->nodes[0]; 7597 slot = path->slots[0]; 7598 7599 if (node) { 7600 if (last_ra_node != node->start) { 7601 readahead_tree_node_children(node); 7602 last_ra_node = node->start; 7603 } 7604 } 7605 if (found_key.type == BTRFS_DEV_ITEM_KEY) { 7606 struct btrfs_dev_item *dev_item; 7607 dev_item = btrfs_item_ptr(leaf, slot, 7608 struct btrfs_dev_item); 7609 ret = read_one_dev(leaf, dev_item); 7610 if (ret) 7611 goto error; 7612 total_dev++; 7613 } else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) { 7614 struct btrfs_chunk *chunk; 7615 7616 /* 7617 * We are only called at mount time, so no need to take 7618 * fs_info->chunk_mutex. Plus, to avoid lockdep warnings, 7619 * we always lock first fs_info->chunk_mutex before 7620 * acquiring any locks on the chunk tree. This is a 7621 * requirement for chunk allocation, see the comment on 7622 * top of btrfs_chunk_alloc() for details. 7623 */ 7624 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); 7625 ret = read_one_chunk(&found_key, leaf, chunk); 7626 if (ret) 7627 goto error; 7628 } 7629 } 7630 /* Catch error found during iteration */ 7631 if (iter_ret < 0) { 7632 ret = iter_ret; 7633 goto error; 7634 } 7635 7636 /* 7637 * After loading chunk tree, we've got all device information, 7638 * do another round of validation checks. 7639 */ 7640 if (total_dev != fs_info->fs_devices->total_devices) { 7641 btrfs_warn(fs_info, 7642 "super block num_devices %llu mismatch with DEV_ITEM count %llu, will be repaired on next transaction commit", 7643 btrfs_super_num_devices(fs_info->super_copy), 7644 total_dev); 7645 fs_info->fs_devices->total_devices = total_dev; 7646 btrfs_set_super_num_devices(fs_info->super_copy, total_dev); 7647 } 7648 if (btrfs_super_total_bytes(fs_info->super_copy) < 7649 fs_info->fs_devices->total_rw_bytes) { 7650 btrfs_err(fs_info, 7651 "super_total_bytes %llu mismatch with fs_devices total_rw_bytes %llu", 7652 btrfs_super_total_bytes(fs_info->super_copy), 7653 fs_info->fs_devices->total_rw_bytes); 7654 ret = -EINVAL; 7655 goto error; 7656 } 7657 ret = 0; 7658 error: 7659 mutex_unlock(&uuid_mutex); 7660 7661 btrfs_free_path(path); 7662 return ret; 7663 } 7664 7665 void btrfs_init_devices_late(struct btrfs_fs_info *fs_info) 7666 { 7667 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; 7668 struct btrfs_device *device; 7669 7670 fs_devices->fs_info = fs_info; 7671 7672 mutex_lock(&fs_devices->device_list_mutex); 7673 list_for_each_entry(device, &fs_devices->devices, dev_list) 7674 device->fs_info = fs_info; 7675 7676 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { 7677 list_for_each_entry(device, &seed_devs->devices, dev_list) 7678 device->fs_info = fs_info; 7679 7680 seed_devs->fs_info = fs_info; 7681 } 7682 mutex_unlock(&fs_devices->device_list_mutex); 7683 } 7684 7685 static u64 btrfs_dev_stats_value(const struct extent_buffer *eb, 7686 const struct btrfs_dev_stats_item *ptr, 7687 int index) 7688 { 7689 u64 val; 7690 7691 read_extent_buffer(eb, &val, 7692 offsetof(struct btrfs_dev_stats_item, values) + 7693 ((unsigned long)ptr) + (index * sizeof(u64)), 7694 sizeof(val)); 7695 return val; 7696 } 7697 7698 static void btrfs_set_dev_stats_value(struct extent_buffer *eb, 7699 struct btrfs_dev_stats_item *ptr, 7700 int index, u64 val) 7701 { 7702 write_extent_buffer(eb, &val, 7703 offsetof(struct btrfs_dev_stats_item, values) + 7704 ((unsigned long)ptr) + (index * sizeof(u64)), 7705 sizeof(val)); 7706 } 7707 7708 static int btrfs_device_init_dev_stats(struct btrfs_device *device, 7709 struct btrfs_path *path) 7710 { 7711 struct btrfs_dev_stats_item *ptr; 7712 struct extent_buffer *eb; 7713 struct btrfs_key key; 7714 int item_size; 7715 int i, ret, slot; 7716 7717 if (!device->fs_info->dev_root) 7718 return 0; 7719 7720 key.objectid = BTRFS_DEV_STATS_OBJECTID; 7721 key.type = BTRFS_PERSISTENT_ITEM_KEY; 7722 key.offset = device->devid; 7723 ret = btrfs_search_slot(NULL, device->fs_info->dev_root, &key, path, 0, 0); 7724 if (ret) { 7725 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) 7726 btrfs_dev_stat_set(device, i, 0); 7727 device->dev_stats_valid = 1; 7728 btrfs_release_path(path); 7729 return ret < 0 ? ret : 0; 7730 } 7731 slot = path->slots[0]; 7732 eb = path->nodes[0]; 7733 item_size = btrfs_item_size(eb, slot); 7734 7735 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_stats_item); 7736 7737 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) { 7738 if (item_size >= (1 + i) * sizeof(__le64)) 7739 btrfs_dev_stat_set(device, i, 7740 btrfs_dev_stats_value(eb, ptr, i)); 7741 else 7742 btrfs_dev_stat_set(device, i, 0); 7743 } 7744 7745 device->dev_stats_valid = 1; 7746 btrfs_dev_stat_print_on_load(device); 7747 btrfs_release_path(path); 7748 7749 return 0; 7750 } 7751 7752 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info) 7753 { 7754 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; 7755 struct btrfs_device *device; 7756 struct btrfs_path *path = NULL; 7757 int ret = 0; 7758 7759 path = btrfs_alloc_path(); 7760 if (!path) 7761 return -ENOMEM; 7762 7763 mutex_lock(&fs_devices->device_list_mutex); 7764 list_for_each_entry(device, &fs_devices->devices, dev_list) { 7765 ret = btrfs_device_init_dev_stats(device, path); 7766 if (ret) 7767 goto out; 7768 } 7769 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { 7770 list_for_each_entry(device, &seed_devs->devices, dev_list) { 7771 ret = btrfs_device_init_dev_stats(device, path); 7772 if (ret) 7773 goto out; 7774 } 7775 } 7776 out: 7777 mutex_unlock(&fs_devices->device_list_mutex); 7778 7779 btrfs_free_path(path); 7780 return ret; 7781 } 7782 7783 static int update_dev_stat_item(struct btrfs_trans_handle *trans, 7784 struct btrfs_device *device) 7785 { 7786 struct btrfs_fs_info *fs_info = trans->fs_info; 7787 struct btrfs_root *dev_root = fs_info->dev_root; 7788 struct btrfs_path *path; 7789 struct btrfs_key key; 7790 struct extent_buffer *eb; 7791 struct btrfs_dev_stats_item *ptr; 7792 int ret; 7793 int i; 7794 7795 key.objectid = BTRFS_DEV_STATS_OBJECTID; 7796 key.type = BTRFS_PERSISTENT_ITEM_KEY; 7797 key.offset = device->devid; 7798 7799 path = btrfs_alloc_path(); 7800 if (!path) 7801 return -ENOMEM; 7802 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1); 7803 if (ret < 0) { 7804 btrfs_warn_in_rcu(fs_info, 7805 "error %d while searching for dev_stats item for device %s", 7806 ret, rcu_str_deref(device->name)); 7807 goto out; 7808 } 7809 7810 if (ret == 0 && 7811 btrfs_item_size(path->nodes[0], path->slots[0]) < sizeof(*ptr)) { 7812 /* need to delete old one and insert a new one */ 7813 ret = btrfs_del_item(trans, dev_root, path); 7814 if (ret != 0) { 7815 btrfs_warn_in_rcu(fs_info, 7816 "delete too small dev_stats item for device %s failed %d", 7817 rcu_str_deref(device->name), ret); 7818 goto out; 7819 } 7820 ret = 1; 7821 } 7822 7823 if (ret == 1) { 7824 /* need to insert a new item */ 7825 btrfs_release_path(path); 7826 ret = btrfs_insert_empty_item(trans, dev_root, path, 7827 &key, sizeof(*ptr)); 7828 if (ret < 0) { 7829 btrfs_warn_in_rcu(fs_info, 7830 "insert dev_stats item for device %s failed %d", 7831 rcu_str_deref(device->name), ret); 7832 goto out; 7833 } 7834 } 7835 7836 eb = path->nodes[0]; 7837 ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item); 7838 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) 7839 btrfs_set_dev_stats_value(eb, ptr, i, 7840 btrfs_dev_stat_read(device, i)); 7841 btrfs_mark_buffer_dirty(eb); 7842 7843 out: 7844 btrfs_free_path(path); 7845 return ret; 7846 } 7847 7848 /* 7849 * called from commit_transaction. Writes all changed device stats to disk. 7850 */ 7851 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans) 7852 { 7853 struct btrfs_fs_info *fs_info = trans->fs_info; 7854 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 7855 struct btrfs_device *device; 7856 int stats_cnt; 7857 int ret = 0; 7858 7859 mutex_lock(&fs_devices->device_list_mutex); 7860 list_for_each_entry(device, &fs_devices->devices, dev_list) { 7861 stats_cnt = atomic_read(&device->dev_stats_ccnt); 7862 if (!device->dev_stats_valid || stats_cnt == 0) 7863 continue; 7864 7865 7866 /* 7867 * There is a LOAD-LOAD control dependency between the value of 7868 * dev_stats_ccnt and updating the on-disk values which requires 7869 * reading the in-memory counters. Such control dependencies 7870 * require explicit read memory barriers. 7871 * 7872 * This memory barriers pairs with smp_mb__before_atomic in 7873 * btrfs_dev_stat_inc/btrfs_dev_stat_set and with the full 7874 * barrier implied by atomic_xchg in 7875 * btrfs_dev_stats_read_and_reset 7876 */ 7877 smp_rmb(); 7878 7879 ret = update_dev_stat_item(trans, device); 7880 if (!ret) 7881 atomic_sub(stats_cnt, &device->dev_stats_ccnt); 7882 } 7883 mutex_unlock(&fs_devices->device_list_mutex); 7884 7885 return ret; 7886 } 7887 7888 void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index) 7889 { 7890 btrfs_dev_stat_inc(dev, index); 7891 btrfs_dev_stat_print_on_error(dev); 7892 } 7893 7894 static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev) 7895 { 7896 if (!dev->dev_stats_valid) 7897 return; 7898 btrfs_err_rl_in_rcu(dev->fs_info, 7899 "bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u", 7900 rcu_str_deref(dev->name), 7901 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS), 7902 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS), 7903 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS), 7904 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS), 7905 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS)); 7906 } 7907 7908 static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev) 7909 { 7910 int i; 7911 7912 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) 7913 if (btrfs_dev_stat_read(dev, i) != 0) 7914 break; 7915 if (i == BTRFS_DEV_STAT_VALUES_MAX) 7916 return; /* all values == 0, suppress message */ 7917 7918 btrfs_info_in_rcu(dev->fs_info, 7919 "bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u", 7920 rcu_str_deref(dev->name), 7921 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS), 7922 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS), 7923 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS), 7924 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS), 7925 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS)); 7926 } 7927 7928 int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info, 7929 struct btrfs_ioctl_get_dev_stats *stats) 7930 { 7931 BTRFS_DEV_LOOKUP_ARGS(args); 7932 struct btrfs_device *dev; 7933 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 7934 int i; 7935 7936 mutex_lock(&fs_devices->device_list_mutex); 7937 args.devid = stats->devid; 7938 dev = btrfs_find_device(fs_info->fs_devices, &args); 7939 mutex_unlock(&fs_devices->device_list_mutex); 7940 7941 if (!dev) { 7942 btrfs_warn(fs_info, "get dev_stats failed, device not found"); 7943 return -ENODEV; 7944 } else if (!dev->dev_stats_valid) { 7945 btrfs_warn(fs_info, "get dev_stats failed, not yet valid"); 7946 return -ENODEV; 7947 } else if (stats->flags & BTRFS_DEV_STATS_RESET) { 7948 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) { 7949 if (stats->nr_items > i) 7950 stats->values[i] = 7951 btrfs_dev_stat_read_and_reset(dev, i); 7952 else 7953 btrfs_dev_stat_set(dev, i, 0); 7954 } 7955 btrfs_info(fs_info, "device stats zeroed by %s (%d)", 7956 current->comm, task_pid_nr(current)); 7957 } else { 7958 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) 7959 if (stats->nr_items > i) 7960 stats->values[i] = btrfs_dev_stat_read(dev, i); 7961 } 7962 if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX) 7963 stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX; 7964 return 0; 7965 } 7966 7967 /* 7968 * Update the size and bytes used for each device where it changed. This is 7969 * delayed since we would otherwise get errors while writing out the 7970 * superblocks. 7971 * 7972 * Must be invoked during transaction commit. 7973 */ 7974 void btrfs_commit_device_sizes(struct btrfs_transaction *trans) 7975 { 7976 struct btrfs_device *curr, *next; 7977 7978 ASSERT(trans->state == TRANS_STATE_COMMIT_DOING); 7979 7980 if (list_empty(&trans->dev_update_list)) 7981 return; 7982 7983 /* 7984 * We don't need the device_list_mutex here. This list is owned by the 7985 * transaction and the transaction must complete before the device is 7986 * released. 7987 */ 7988 mutex_lock(&trans->fs_info->chunk_mutex); 7989 list_for_each_entry_safe(curr, next, &trans->dev_update_list, 7990 post_commit_list) { 7991 list_del_init(&curr->post_commit_list); 7992 curr->commit_total_bytes = curr->disk_total_bytes; 7993 curr->commit_bytes_used = curr->bytes_used; 7994 } 7995 mutex_unlock(&trans->fs_info->chunk_mutex); 7996 } 7997 7998 /* 7999 * Multiplicity factor for simple profiles: DUP, RAID1-like and RAID10. 8000 */ 8001 int btrfs_bg_type_to_factor(u64 flags) 8002 { 8003 const int index = btrfs_bg_flags_to_raid_index(flags); 8004 8005 return btrfs_raid_array[index].ncopies; 8006 } 8007 8008 8009 8010 static int verify_one_dev_extent(struct btrfs_fs_info *fs_info, 8011 u64 chunk_offset, u64 devid, 8012 u64 physical_offset, u64 physical_len) 8013 { 8014 struct btrfs_dev_lookup_args args = { .devid = devid }; 8015 struct extent_map_tree *em_tree = &fs_info->mapping_tree; 8016 struct extent_map *em; 8017 struct map_lookup *map; 8018 struct btrfs_device *dev; 8019 u64 stripe_len; 8020 bool found = false; 8021 int ret = 0; 8022 int i; 8023 8024 read_lock(&em_tree->lock); 8025 em = lookup_extent_mapping(em_tree, chunk_offset, 1); 8026 read_unlock(&em_tree->lock); 8027 8028 if (!em) { 8029 btrfs_err(fs_info, 8030 "dev extent physical offset %llu on devid %llu doesn't have corresponding chunk", 8031 physical_offset, devid); 8032 ret = -EUCLEAN; 8033 goto out; 8034 } 8035 8036 map = em->map_lookup; 8037 stripe_len = calc_stripe_length(map->type, em->len, map->num_stripes); 8038 if (physical_len != stripe_len) { 8039 btrfs_err(fs_info, 8040 "dev extent physical offset %llu on devid %llu length doesn't match chunk %llu, have %llu expect %llu", 8041 physical_offset, devid, em->start, physical_len, 8042 stripe_len); 8043 ret = -EUCLEAN; 8044 goto out; 8045 } 8046 8047 for (i = 0; i < map->num_stripes; i++) { 8048 if (map->stripes[i].dev->devid == devid && 8049 map->stripes[i].physical == physical_offset) { 8050 found = true; 8051 if (map->verified_stripes >= map->num_stripes) { 8052 btrfs_err(fs_info, 8053 "too many dev extents for chunk %llu found", 8054 em->start); 8055 ret = -EUCLEAN; 8056 goto out; 8057 } 8058 map->verified_stripes++; 8059 break; 8060 } 8061 } 8062 if (!found) { 8063 btrfs_err(fs_info, 8064 "dev extent physical offset %llu devid %llu has no corresponding chunk", 8065 physical_offset, devid); 8066 ret = -EUCLEAN; 8067 } 8068 8069 /* Make sure no dev extent is beyond device boundary */ 8070 dev = btrfs_find_device(fs_info->fs_devices, &args); 8071 if (!dev) { 8072 btrfs_err(fs_info, "failed to find devid %llu", devid); 8073 ret = -EUCLEAN; 8074 goto out; 8075 } 8076 8077 if (physical_offset + physical_len > dev->disk_total_bytes) { 8078 btrfs_err(fs_info, 8079 "dev extent devid %llu physical offset %llu len %llu is beyond device boundary %llu", 8080 devid, physical_offset, physical_len, 8081 dev->disk_total_bytes); 8082 ret = -EUCLEAN; 8083 goto out; 8084 } 8085 8086 if (dev->zone_info) { 8087 u64 zone_size = dev->zone_info->zone_size; 8088 8089 if (!IS_ALIGNED(physical_offset, zone_size) || 8090 !IS_ALIGNED(physical_len, zone_size)) { 8091 btrfs_err(fs_info, 8092 "zoned: dev extent devid %llu physical offset %llu len %llu is not aligned to device zone", 8093 devid, physical_offset, physical_len); 8094 ret = -EUCLEAN; 8095 goto out; 8096 } 8097 } 8098 8099 out: 8100 free_extent_map(em); 8101 return ret; 8102 } 8103 8104 static int verify_chunk_dev_extent_mapping(struct btrfs_fs_info *fs_info) 8105 { 8106 struct extent_map_tree *em_tree = &fs_info->mapping_tree; 8107 struct extent_map *em; 8108 struct rb_node *node; 8109 int ret = 0; 8110 8111 read_lock(&em_tree->lock); 8112 for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) { 8113 em = rb_entry(node, struct extent_map, rb_node); 8114 if (em->map_lookup->num_stripes != 8115 em->map_lookup->verified_stripes) { 8116 btrfs_err(fs_info, 8117 "chunk %llu has missing dev extent, have %d expect %d", 8118 em->start, em->map_lookup->verified_stripes, 8119 em->map_lookup->num_stripes); 8120 ret = -EUCLEAN; 8121 goto out; 8122 } 8123 } 8124 out: 8125 read_unlock(&em_tree->lock); 8126 return ret; 8127 } 8128 8129 /* 8130 * Ensure that all dev extents are mapped to correct chunk, otherwise 8131 * later chunk allocation/free would cause unexpected behavior. 8132 * 8133 * NOTE: This will iterate through the whole device tree, which should be of 8134 * the same size level as the chunk tree. This slightly increases mount time. 8135 */ 8136 int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info) 8137 { 8138 struct btrfs_path *path; 8139 struct btrfs_root *root = fs_info->dev_root; 8140 struct btrfs_key key; 8141 u64 prev_devid = 0; 8142 u64 prev_dev_ext_end = 0; 8143 int ret = 0; 8144 8145 /* 8146 * We don't have a dev_root because we mounted with ignorebadroots and 8147 * failed to load the root, so we want to skip the verification in this 8148 * case for sure. 8149 * 8150 * However if the dev root is fine, but the tree itself is corrupted 8151 * we'd still fail to mount. This verification is only to make sure 8152 * writes can happen safely, so instead just bypass this check 8153 * completely in the case of IGNOREBADROOTS. 8154 */ 8155 if (btrfs_test_opt(fs_info, IGNOREBADROOTS)) 8156 return 0; 8157 8158 key.objectid = 1; 8159 key.type = BTRFS_DEV_EXTENT_KEY; 8160 key.offset = 0; 8161 8162 path = btrfs_alloc_path(); 8163 if (!path) 8164 return -ENOMEM; 8165 8166 path->reada = READA_FORWARD; 8167 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 8168 if (ret < 0) 8169 goto out; 8170 8171 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) { 8172 ret = btrfs_next_leaf(root, path); 8173 if (ret < 0) 8174 goto out; 8175 /* No dev extents at all? Not good */ 8176 if (ret > 0) { 8177 ret = -EUCLEAN; 8178 goto out; 8179 } 8180 } 8181 while (1) { 8182 struct extent_buffer *leaf = path->nodes[0]; 8183 struct btrfs_dev_extent *dext; 8184 int slot = path->slots[0]; 8185 u64 chunk_offset; 8186 u64 physical_offset; 8187 u64 physical_len; 8188 u64 devid; 8189 8190 btrfs_item_key_to_cpu(leaf, &key, slot); 8191 if (key.type != BTRFS_DEV_EXTENT_KEY) 8192 break; 8193 devid = key.objectid; 8194 physical_offset = key.offset; 8195 8196 dext = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent); 8197 chunk_offset = btrfs_dev_extent_chunk_offset(leaf, dext); 8198 physical_len = btrfs_dev_extent_length(leaf, dext); 8199 8200 /* Check if this dev extent overlaps with the previous one */ 8201 if (devid == prev_devid && physical_offset < prev_dev_ext_end) { 8202 btrfs_err(fs_info, 8203 "dev extent devid %llu physical offset %llu overlap with previous dev extent end %llu", 8204 devid, physical_offset, prev_dev_ext_end); 8205 ret = -EUCLEAN; 8206 goto out; 8207 } 8208 8209 ret = verify_one_dev_extent(fs_info, chunk_offset, devid, 8210 physical_offset, physical_len); 8211 if (ret < 0) 8212 goto out; 8213 prev_devid = devid; 8214 prev_dev_ext_end = physical_offset + physical_len; 8215 8216 ret = btrfs_next_item(root, path); 8217 if (ret < 0) 8218 goto out; 8219 if (ret > 0) { 8220 ret = 0; 8221 break; 8222 } 8223 } 8224 8225 /* Ensure all chunks have corresponding dev extents */ 8226 ret = verify_chunk_dev_extent_mapping(fs_info); 8227 out: 8228 btrfs_free_path(path); 8229 return ret; 8230 } 8231 8232 /* 8233 * Check whether the given block group or device is pinned by any inode being 8234 * used as a swapfile. 8235 */ 8236 bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr) 8237 { 8238 struct btrfs_swapfile_pin *sp; 8239 struct rb_node *node; 8240 8241 spin_lock(&fs_info->swapfile_pins_lock); 8242 node = fs_info->swapfile_pins.rb_node; 8243 while (node) { 8244 sp = rb_entry(node, struct btrfs_swapfile_pin, node); 8245 if (ptr < sp->ptr) 8246 node = node->rb_left; 8247 else if (ptr > sp->ptr) 8248 node = node->rb_right; 8249 else 8250 break; 8251 } 8252 spin_unlock(&fs_info->swapfile_pins_lock); 8253 return node != NULL; 8254 } 8255 8256 static int relocating_repair_kthread(void *data) 8257 { 8258 struct btrfs_block_group *cache = data; 8259 struct btrfs_fs_info *fs_info = cache->fs_info; 8260 u64 target; 8261 int ret = 0; 8262 8263 target = cache->start; 8264 btrfs_put_block_group(cache); 8265 8266 sb_start_write(fs_info->sb); 8267 if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) { 8268 btrfs_info(fs_info, 8269 "zoned: skip relocating block group %llu to repair: EBUSY", 8270 target); 8271 sb_end_write(fs_info->sb); 8272 return -EBUSY; 8273 } 8274 8275 mutex_lock(&fs_info->reclaim_bgs_lock); 8276 8277 /* Ensure block group still exists */ 8278 cache = btrfs_lookup_block_group(fs_info, target); 8279 if (!cache) 8280 goto out; 8281 8282 if (!cache->relocating_repair) 8283 goto out; 8284 8285 ret = btrfs_may_alloc_data_chunk(fs_info, target); 8286 if (ret < 0) 8287 goto out; 8288 8289 btrfs_info(fs_info, 8290 "zoned: relocating block group %llu to repair IO failure", 8291 target); 8292 ret = btrfs_relocate_chunk(fs_info, target); 8293 8294 out: 8295 if (cache) 8296 btrfs_put_block_group(cache); 8297 mutex_unlock(&fs_info->reclaim_bgs_lock); 8298 btrfs_exclop_finish(fs_info); 8299 sb_end_write(fs_info->sb); 8300 8301 return ret; 8302 } 8303 8304 bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical) 8305 { 8306 struct btrfs_block_group *cache; 8307 8308 if (!btrfs_is_zoned(fs_info)) 8309 return false; 8310 8311 /* Do not attempt to repair in degraded state */ 8312 if (btrfs_test_opt(fs_info, DEGRADED)) 8313 return true; 8314 8315 cache = btrfs_lookup_block_group(fs_info, logical); 8316 if (!cache) 8317 return true; 8318 8319 spin_lock(&cache->lock); 8320 if (cache->relocating_repair) { 8321 spin_unlock(&cache->lock); 8322 btrfs_put_block_group(cache); 8323 return true; 8324 } 8325 cache->relocating_repair = 1; 8326 spin_unlock(&cache->lock); 8327 8328 kthread_run(relocating_repair_kthread, cache, 8329 "btrfs-relocating-repair"); 8330 8331 return true; 8332 } 8333