fs/btrfs/volumes.c

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