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