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