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