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