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