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