fs/btrfs/volumes.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) 2007 Oracle.  All rights reserved.
   4  */
   5
   6 #ifndef BTRFS_VOLUMES_H
   7 #define BTRFS_VOLUMES_H
   8
   9 #include <linux/blk_types.h>
  10 #include <linux/sizes.h>
  11 #include <linux/atomic.h>
  12 #include <linux/sort.h>
  13 #include <linux/list.h>
  14 #include <linux/mutex.h>
  15 #include <linux/log2.h>
  16 #include <linux/kobject.h>
  17 #include <linux/refcount.h>
  18 #include <linux/completion.h>
  19 #include <linux/rbtree.h>
  20 #include <uapi/linux/btrfs.h>
  21 #include "messages.h"
  22 #include "rcu-string.h"
  23
  24 struct block_device;
  25 struct bdev_handle;
  26 struct btrfs_fs_info;
  27 struct btrfs_block_group;
  28 struct btrfs_trans_handle;
  29 struct btrfs_zoned_device_info;
  30
  31 #define BTRFS_MAX_DATA_CHUNK_SIZE       (10ULL * SZ_1G)
  32
  33 /*
  34  * Arbitratry maximum size of one discard request to limit potentially long time
  35  * spent in blkdev_issue_discard().
  36  */
  37 #define BTRFS_MAX_DISCARD_CHUNK_SIZE    (SZ_1G)
  38
  39 extern struct mutex uuid_mutex;
  40
  41 #define BTRFS_STRIPE_LEN                SZ_64K
  42 #define BTRFS_STRIPE_LEN_SHIFT          (16)
  43 #define BTRFS_STRIPE_LEN_MASK           (BTRFS_STRIPE_LEN - 1)
  44
  45 static_assert(const_ilog2(BTRFS_STRIPE_LEN) == BTRFS_STRIPE_LEN_SHIFT);
  46
  47 /* Used by sanity check for btrfs_raid_types. */
  48 #define const_ffs(n) (__builtin_ctzll(n) + 1)
  49
  50 /*
  51  * The conversion from BTRFS_BLOCK_GROUP_* bits to btrfs_raid_type requires
  52  * RAID0 always to be the lowest profile bit.
  53  * Although it's part of on-disk format and should never change, do extra
  54  * compile-time sanity checks.
  55  */
  56 static_assert(const_ffs(BTRFS_BLOCK_GROUP_RAID0) <
  57               const_ffs(BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0));
  58 static_assert(const_ilog2(BTRFS_BLOCK_GROUP_RAID0) >
  59               ilog2(BTRFS_BLOCK_GROUP_TYPE_MASK));
  60
  61 /* ilog2() can handle both constants and variables */
  62 #define BTRFS_BG_FLAG_TO_INDEX(profile)                                 \
  63         ilog2((profile) >> (ilog2(BTRFS_BLOCK_GROUP_RAID0) - 1))
  64
  65 enum btrfs_raid_types {
  66         /* SINGLE is the special one as it doesn't have on-disk bit. */
  67         BTRFS_RAID_SINGLE  = 0,
  68
  69         BTRFS_RAID_RAID0   = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID0),
  70         BTRFS_RAID_RAID1   = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1),
  71         BTRFS_RAID_DUP     = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_DUP),
  72         BTRFS_RAID_RAID10  = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID10),
  73         BTRFS_RAID_RAID5   = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID5),
  74         BTRFS_RAID_RAID6   = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID6),
  75         BTRFS_RAID_RAID1C3 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1C3),
  76         BTRFS_RAID_RAID1C4 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1C4),
  77
  78         BTRFS_NR_RAID_TYPES
  79 };
  80
  81 /*
  82  * Use sequence counter to get consistent device stat data on
  83  * 32-bit processors.
  84  */
  85 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
  86 #include <linux/seqlock.h>
  87 #define __BTRFS_NEED_DEVICE_DATA_ORDERED
  88 #define btrfs_device_data_ordered_init(device)  \
  89         seqcount_init(&device->data_seqcount)
  90 #else
  91 #define btrfs_device_data_ordered_init(device) do { } while (0)
  92 #endif
  93
  94 #define BTRFS_DEV_STATE_WRITEABLE       (0)
  95 #define BTRFS_DEV_STATE_IN_FS_METADATA  (1)
  96 #define BTRFS_DEV_STATE_MISSING         (2)
  97 #define BTRFS_DEV_STATE_REPLACE_TGT     (3)
  98 #define BTRFS_DEV_STATE_FLUSH_SENT      (4)
  99 #define BTRFS_DEV_STATE_NO_READA        (5)
 100
 101 /* Special value encoding failure to write primary super block. */
 102 #define BTRFS_SUPER_PRIMARY_WRITE_ERROR         (INT_MAX / 2)
 103
 104 struct btrfs_fs_devices;
 105
 106 struct btrfs_device {
 107         struct list_head dev_list; /* device_list_mutex */
 108         struct list_head dev_alloc_list; /* chunk mutex */
 109         struct list_head post_commit_list; /* chunk mutex */
 110         struct btrfs_fs_devices *fs_devices;
 111         struct btrfs_fs_info *fs_info;
 112
 113         struct rcu_string __rcu *name;
 114
 115         u64 generation;
 116
 117         struct file *bdev_file;
 118         struct block_device *bdev;
 119
 120         struct btrfs_zoned_device_info *zone_info;
 121
 122         /*
 123          * Device's major-minor number. Must be set even if the device is not
 124          * opened (bdev == NULL), unless the device is missing.
 125          */
 126         dev_t devt;
 127         unsigned long dev_state;
 128         blk_status_t last_flush_error;
 129
 130 #ifdef __BTRFS_NEED_DEVICE_DATA_ORDERED
 131         seqcount_t data_seqcount;
 132 #endif
 133
 134         /* the internal btrfs device id */
 135         u64 devid;
 136
 137         /* size of the device in memory */
 138         u64 total_bytes;
 139
 140         /* size of the device on disk */
 141         u64 disk_total_bytes;
 142
 143         /* bytes used */
 144         u64 bytes_used;
 145
 146         /* optimal io alignment for this device */
 147         u32 io_align;
 148
 149         /* optimal io width for this device */
 150         u32 io_width;
 151         /* type and info about this device */
 152         u64 type;
 153
 154         /*
 155          * Counter of super block write errors, values larger than
 156          * BTRFS_SUPER_PRIMARY_WRITE_ERROR encode primary super block write failure.
 157          */
 158         atomic_t sb_write_errors;
 159
 160         /* minimal io size for this device */
 161         u32 sector_size;
 162
 163         /* physical drive uuid (or lvm uuid) */
 164         u8 uuid[BTRFS_UUID_SIZE];
 165
 166         /*
 167          * size of the device on the current transaction
 168          *
 169          * This variant is update when committing the transaction,
 170          * and protected by chunk mutex
 171          */
 172         u64 commit_total_bytes;
 173
 174         /* bytes used on the current transaction */
 175         u64 commit_bytes_used;
 176
 177         /* Bio used for flushing device barriers */
 178         struct bio flush_bio;
 179         struct completion flush_wait;
 180
 181         /* per-device scrub information */
 182         struct scrub_ctx *scrub_ctx;
 183
 184         /* disk I/O failure stats. For detailed description refer to
 185          * enum btrfs_dev_stat_values in ioctl.h */
 186         int dev_stats_valid;
 187
 188         /* Counter to record the change of device stats */
 189         atomic_t dev_stats_ccnt;
 190         atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX];
 191
 192         struct extent_io_tree alloc_state;
 193
 194         struct completion kobj_unregister;
 195         /* For sysfs/FSID/devinfo/devid/ */
 196         struct kobject devid_kobj;
 197
 198         /* Bandwidth limit for scrub, in bytes */
 199         u64 scrub_speed_max;
 200 };
 201
 202 /*
 203  * Block group or device which contains an active swapfile. Used for preventing
 204  * unsafe operations while a swapfile is active.
 205  *
 206  * These are sorted on (ptr, inode) (note that a block group or device can
 207  * contain more than one swapfile). We compare the pointer values because we
 208  * don't actually care what the object is, we just need a quick check whether
 209  * the object exists in the rbtree.
 210  */
 211 struct btrfs_swapfile_pin {
 212         struct rb_node node;
 213         void *ptr;
 214         struct inode *inode;
 215         /*
 216          * If true, ptr points to a struct btrfs_block_group. Otherwise, ptr
 217          * points to a struct btrfs_device.
 218          */
 219         bool is_block_group;
 220         /*
 221          * Only used when 'is_block_group' is true and it is the number of
 222          * extents used by a swapfile for this block group ('ptr' field).
 223          */
 224         int bg_extent_count;
 225 };
 226
 227 /*
 228  * If we read those variants at the context of their own lock, we needn't
 229  * use the following helpers, reading them directly is safe.
 230  */
 231 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 232 #define BTRFS_DEVICE_GETSET_FUNCS(name)                                 \
 233 static inline u64                                                       \
 234 btrfs_device_get_##name(const struct btrfs_device *dev)                 \
 235 {                                                                       \
 236         u64 size;                                                       \
 237         unsigned int seq;                                               \
 238                                                                         \
 239         do {                                                            \
 240                 seq = read_seqcount_begin(&dev->data_seqcount);         \
 241                 size = dev->name;                                       \
 242         } while (read_seqcount_retry(&dev->data_seqcount, seq));        \
 243         return size;                                                    \
 244 }                                                                       \
 245                                                                         \
 246 static inline void                                                      \
 247 btrfs_device_set_##name(struct btrfs_device *dev, u64 size)             \
 248 {                                                                       \
 249         preempt_disable();                                              \
 250         write_seqcount_begin(&dev->data_seqcount);                      \
 251         dev->name = size;                                               \
 252         write_seqcount_end(&dev->data_seqcount);                        \
 253         preempt_enable();                                               \
 254 }
 255 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION)
 256 #define BTRFS_DEVICE_GETSET_FUNCS(name)                                 \
 257 static inline u64                                                       \
 258 btrfs_device_get_##name(const struct btrfs_device *dev)                 \
 259 {                                                                       \
 260         u64 size;                                                       \
 261                                                                         \
 262         preempt_disable();                                              \
 263         size = dev->name;                                               \
 264         preempt_enable();                                               \
 265         return size;                                                    \
 266 }                                                                       \
 267                                                                         \
 268 static inline void                                                      \
 269 btrfs_device_set_##name(struct btrfs_device *dev, u64 size)             \
 270 {                                                                       \
 271         preempt_disable();                                              \
 272         dev->name = size;                                               \
 273         preempt_enable();                                               \
 274 }
 275 #else
 276 #define BTRFS_DEVICE_GETSET_FUNCS(name)                                 \
 277 static inline u64                                                       \
 278 btrfs_device_get_##name(const struct btrfs_device *dev)                 \
 279 {                                                                       \
 280         return dev->name;                                               \
 281 }                                                                       \
 282                                                                         \
 283 static inline void                                                      \
 284 btrfs_device_set_##name(struct btrfs_device *dev, u64 size)             \
 285 {                                                                       \
 286         dev->name = size;                                               \
 287 }
 288 #endif
 289
 290 BTRFS_DEVICE_GETSET_FUNCS(total_bytes);
 291 BTRFS_DEVICE_GETSET_FUNCS(disk_total_bytes);
 292 BTRFS_DEVICE_GETSET_FUNCS(bytes_used);
 293
 294 enum btrfs_chunk_allocation_policy {
 295         BTRFS_CHUNK_ALLOC_REGULAR,
 296         BTRFS_CHUNK_ALLOC_ZONED,
 297 };
 298
 299 /*
 300  * Read policies for mirrored block group profiles, read picks the stripe based
 301  * on these policies.
 302  */
 303 enum btrfs_read_policy {
 304         /* Use process PID to choose the stripe */
 305         BTRFS_READ_POLICY_PID,
 306         BTRFS_NR_READ_POLICY,
 307 };
 308
 309 #ifdef CONFIG_BTRFS_EXPERIMENTAL
 310 /*
 311  * Checksum mode - offload it to workqueues or do it synchronously in
 312  * btrfs_submit_chunk().
 313  */
 314 enum btrfs_offload_csum_mode {
 315         /*
 316          * Choose offloading checksum or do it synchronously automatically.
 317          * Do it synchronously if the checksum is fast, or offload to workqueues
 318          * otherwise.
 319          */
 320         BTRFS_OFFLOAD_CSUM_AUTO,
 321         /* Always offload checksum to workqueues. */
 322         BTRFS_OFFLOAD_CSUM_FORCE_ON,
 323         /* Never offload checksum to workqueues. */
 324         BTRFS_OFFLOAD_CSUM_FORCE_OFF,
 325 };
 326 #endif
 327
 328 struct btrfs_fs_devices {
 329         u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
 330
 331         /*
 332          * UUID written into the btree blocks:
 333          *
 334          * - If metadata_uuid != fsid then super block must have
 335          *   BTRFS_FEATURE_INCOMPAT_METADATA_UUID flag set.
 336          *
 337          * - Following shall be true at all times:
 338          *   - metadata_uuid == btrfs_header::fsid
 339          *   - metadata_uuid == btrfs_dev_item::fsid
 340          *
 341          * - Relations between fsid and metadata_uuid in sb and fs_devices:
 342          *   - Normal:
 343          *       fs_devices->fsid == fs_devices->metadata_uuid == sb->fsid
 344          *       sb->metadata_uuid == 0
 345          *
 346          *   - When the BTRFS_FEATURE_INCOMPAT_METADATA_UUID flag is set:
 347          *       fs_devices->fsid == sb->fsid
 348          *       fs_devices->metadata_uuid == sb->metadata_uuid
 349          *
 350          *   - When in-memory fs_devices->temp_fsid is true
 351          *       fs_devices->fsid = random
 352          *       fs_devices->metadata_uuid == sb->fsid
 353          */
 354         u8 metadata_uuid[BTRFS_FSID_SIZE];
 355
 356         struct list_head fs_list;
 357
 358         /*
 359          * Number of devices under this fsid including missing and
 360          * replace-target device and excludes seed devices.
 361          */
 362         u64 num_devices;
 363
 364         /*
 365          * The number of devices that successfully opened, including
 366          * replace-target, excludes seed devices.
 367          */
 368         u64 open_devices;
 369
 370         /* The number of devices that are under the chunk allocation list. */
 371         u64 rw_devices;
 372
 373         /* Count of missing devices under this fsid excluding seed device. */
 374         u64 missing_devices;
 375         u64 total_rw_bytes;
 376
 377         /*
 378          * Count of devices from btrfs_super_block::num_devices for this fsid,
 379          * which includes the seed device, excludes the transient replace-target
 380          * device.
 381          */
 382         u64 total_devices;
 383
 384         /* Highest generation number of seen devices */
 385         u64 latest_generation;
 386
 387         /*
 388          * The mount device or a device with highest generation after removal
 389          * or replace.
 390          */
 391         struct btrfs_device *latest_dev;
 392
 393         /*
 394          * All of the devices in the filesystem, protected by a mutex so we can
 395          * safely walk it to write out the super blocks without worrying about
 396          * adding/removing by the multi-device code. Scrubbing super block can
 397          * kick off supers writing by holding this mutex lock.
 398          */
 399         struct mutex device_list_mutex;
 400
 401         /* List of all devices, protected by device_list_mutex */
 402         struct list_head devices;
 403
 404         /* Devices which can satisfy space allocation. Protected by * chunk_mutex. */
 405         struct list_head alloc_list;
 406
 407         struct list_head seed_list;
 408
 409         /* Count fs-devices opened. */
 410         int opened;
 411
 412         /* Set when we find or add a device that doesn't have the nonrot flag set. */
 413         bool rotating;
 414         /* Devices support TRIM/discard commands. */
 415         bool discardable;
 416         /* The filesystem is a seed filesystem. */
 417         bool seeding;
 418         /* The mount needs to use a randomly generated fsid. */
 419         bool temp_fsid;
 420
 421         struct btrfs_fs_info *fs_info;
 422         /* sysfs kobjects */
 423         struct kobject fsid_kobj;
 424         struct kobject *devices_kobj;
 425         struct kobject *devinfo_kobj;
 426         struct completion kobj_unregister;
 427
 428         enum btrfs_chunk_allocation_policy chunk_alloc_policy;
 429
 430         /* Policy used to read the mirrored stripes. */
 431         enum btrfs_read_policy read_policy;
 432
 433 #ifdef CONFIG_BTRFS_EXPERIMENTAL
 434         /* Checksum mode - offload it or do it synchronously. */
 435         enum btrfs_offload_csum_mode offload_csum_mode;
 436 #endif
 437 };
 438
 439 #define BTRFS_MAX_DEVS(info) ((BTRFS_MAX_ITEM_SIZE(info)        \
 440                         - sizeof(struct btrfs_chunk))           \
 441                         / sizeof(struct btrfs_stripe) + 1)
 442
 443 #define BTRFS_MAX_DEVS_SYS_CHUNK ((BTRFS_SYSTEM_CHUNK_ARRAY_SIZE        \
 444                                 - 2 * sizeof(struct btrfs_disk_key)     \
 445                                 - 2 * sizeof(struct btrfs_chunk))       \
 446                                 / sizeof(struct btrfs_stripe) + 1)
 447
 448 struct btrfs_io_stripe {
 449         struct btrfs_device *dev;
 450         /* Block mapping. */
 451         u64 physical;
 452         u64 length;
 453         bool rst_search_commit_root;
 454         /* For the endio handler. */
 455         struct btrfs_io_context *bioc;
 456 };
 457
 458 struct btrfs_discard_stripe {
 459         struct btrfs_device *dev;
 460         u64 physical;
 461         u64 length;
 462 };
 463
 464 /*
 465  * Context for IO subsmission for device stripe.
 466  *
 467  * - Track the unfinished mirrors for mirror based profiles
 468  *   Mirror based profiles are SINGLE/DUP/RAID1/RAID10.
 469  *
 470  * - Contain the logical -> physical mapping info
 471  *   Used by submit_stripe_bio() for mapping logical bio
 472  *   into physical device address.
 473  *
 474  * - Contain device replace info
 475  *   Used by handle_ops_on_dev_replace() to copy logical bios
 476  *   into the new device.
 477  *
 478  * - Contain RAID56 full stripe logical bytenrs
 479  */
 480 struct btrfs_io_context {
 481         refcount_t refs;
 482         struct btrfs_fs_info *fs_info;
 483         /* Taken from struct btrfs_chunk_map::type. */
 484         u64 map_type;
 485         struct bio *orig_bio;
 486         atomic_t error;
 487         u16 max_errors;
 488
 489         u64 logical;
 490         u64 size;
 491         /* Raid stripe tree ordered entry. */
 492         struct list_head rst_ordered_entry;
 493
 494         /*
 495          * The total number of stripes, including the extra duplicated
 496          * stripe for replace.
 497          */
 498         u16 num_stripes;
 499
 500         /*
 501          * The mirror_num of this bioc.
 502          *
 503          * This is for reads which use 0 as mirror_num, thus we should return a
 504          * valid mirror_num (>0) for the reader.
 505          */
 506         u16 mirror_num;
 507
 508         /*
 509          * The following two members are for dev-replace case only.
 510          *
 511          * @replace_nr_stripes: Number of duplicated stripes which need to be
 512          *                      written to replace target.
 513          *                      Should be <= 2 (2 for DUP, otherwise <= 1).
 514          * @replace_stripe_src: The array indicates where the duplicated stripes
 515          *                      are from.
 516          *
 517          * The @replace_stripe_src[] array is mostly for RAID56 cases.
 518          * As non-RAID56 stripes share the same contents of the mapped range,
 519          * thus no need to bother where the duplicated ones are from.
 520          *
 521          * But for RAID56 case, all stripes contain different contents, thus
 522          * we need a way to know the mapping.
 523          *
 524          * There is an example for the two members, using a RAID5 write:
 525          *
 526          *   num_stripes:       4 (3 + 1 duplicated write)
 527          *   stripes[0]:        dev = devid 1, physical = X
 528          *   stripes[1]:        dev = devid 2, physical = Y
 529          *   stripes[2]:        dev = devid 3, physical = Z
 530          *   stripes[3]:        dev = devid 0, physical = Y
 531          *
 532          * replace_nr_stripes = 1
 533          * replace_stripe_src = 1       <- Means stripes[1] is involved in replace.
 534          *                                 The duplicated stripe index would be
 535          *                                 (@num_stripes - 1).
 536          *
 537          * Note, that we can still have cases replace_nr_stripes = 2 for DUP.
 538          * In that case, all stripes share the same content, thus we don't
 539          * need to bother @replace_stripe_src value at all.
 540          */
 541         u16 replace_nr_stripes;
 542         s16 replace_stripe_src;
 543         /*
 544          * Logical bytenr of the full stripe start, only for RAID56 cases.
 545          *
 546          * When this value is set to other than (u64)-1, the stripes[] should
 547          * follow this pattern:
 548          *
 549          * (real_stripes = num_stripes - replace_nr_stripes)
 550          * (data_stripes = (is_raid6) ? (real_stripes - 2) : (real_stripes - 1))
 551          *
 552          * stripes[0]:                  The first data stripe
 553          * stripes[1]:                  The second data stripe
 554          * ...
 555          * stripes[data_stripes - 1]:   The last data stripe
 556          * stripes[data_stripes]:       The P stripe
 557          * stripes[data_stripes + 1]:   The Q stripe (only for RAID6).
 558          */
 559         u64 full_stripe_logical;
 560         struct btrfs_io_stripe stripes[];
 561 };
 562
 563 struct btrfs_device_info {
 564         struct btrfs_device *dev;
 565         u64 dev_offset;
 566         u64 max_avail;
 567         u64 total_avail;
 568 };
 569
 570 struct btrfs_raid_attr {
 571         u8 sub_stripes;         /* sub_stripes info for map */
 572         u8 dev_stripes;         /* stripes per dev */
 573         u8 devs_max;            /* max devs to use */
 574         u8 devs_min;            /* min devs needed */
 575         u8 tolerated_failures;  /* max tolerated fail devs */
 576         u8 devs_increment;      /* ndevs has to be a multiple of this */
 577         u8 ncopies;             /* how many copies to data has */
 578         u8 nparity;             /* number of stripes worth of bytes to store
 579                                  * parity information */
 580         u8 mindev_error;        /* error code if min devs requisite is unmet */
 581         const char raid_name[8]; /* name of the raid */
 582         u64 bg_flag;            /* block group flag of the raid */
 583 };
 584
 585 extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
 586
 587 struct btrfs_chunk_map {
 588         struct rb_node rb_node;
 589         /* For mount time dev extent verification. */
 590         int verified_stripes;
 591         refcount_t refs;
 592         u64 start;
 593         u64 chunk_len;
 594         u64 stripe_size;
 595         u64 type;
 596         int io_align;
 597         int io_width;
 598         int num_stripes;
 599         int sub_stripes;
 600         struct btrfs_io_stripe stripes[];
 601 };
 602
 603 #define btrfs_chunk_map_size(n) (sizeof(struct btrfs_chunk_map) + \
 604                                  (sizeof(struct btrfs_io_stripe) * (n)))
 605
 606 static inline void btrfs_free_chunk_map(struct btrfs_chunk_map *map)
 607 {
 608         if (map && refcount_dec_and_test(&map->refs)) {
 609                 ASSERT(RB_EMPTY_NODE(&map->rb_node));
 610                 kfree(map);
 611         }
 612 }
 613
 614 struct btrfs_balance_control {
 615         struct btrfs_balance_args data;
 616         struct btrfs_balance_args meta;
 617         struct btrfs_balance_args sys;
 618
 619         u64 flags;
 620
 621         struct btrfs_balance_progress stat;
 622 };
 623
 624 /*
 625  * Search for a given device by the set parameters
 626  */
 627 struct btrfs_dev_lookup_args {
 628         u64 devid;
 629         u8 *uuid;
 630         u8 *fsid;
 631         bool missing;
 632 };
 633
 634 /* We have to initialize to -1 because BTRFS_DEV_REPLACE_DEVID is 0 */
 635 #define BTRFS_DEV_LOOKUP_ARGS_INIT { .devid = (u64)-1 }
 636
 637 #define BTRFS_DEV_LOOKUP_ARGS(name) \
 638         struct btrfs_dev_lookup_args name = BTRFS_DEV_LOOKUP_ARGS_INIT
 639
 640 enum btrfs_map_op {
 641         BTRFS_MAP_READ,
 642         BTRFS_MAP_WRITE,
 643         BTRFS_MAP_GET_READ_MIRRORS,
 644 };
 645
 646 static inline enum btrfs_map_op btrfs_op(struct bio *bio)
 647 {
 648         switch (bio_op(bio)) {
 649         case REQ_OP_WRITE:
 650         case REQ_OP_ZONE_APPEND:
 651                 return BTRFS_MAP_WRITE;
 652         default:
 653                 WARN_ON_ONCE(1);
 654                 fallthrough;
 655         case REQ_OP_READ:
 656                 return BTRFS_MAP_READ;
 657         }
 658 }
 659
 660 static inline unsigned long btrfs_chunk_item_size(int num_stripes)
 661 {
 662         ASSERT(num_stripes);
 663         return sizeof(struct btrfs_chunk) +
 664                 sizeof(struct btrfs_stripe) * (num_stripes - 1);
 665 }
 666
 667 /*
 668  * Do the type safe conversion from stripe_nr to offset inside the chunk.
 669  *
 670  * @stripe_nr is u32, with left shift it can overflow u32 for chunks larger
 671  * than 4G.  This does the proper type cast to avoid overflow.
 672  */
 673 static inline u64 btrfs_stripe_nr_to_offset(u32 stripe_nr)
 674 {
 675         return (u64)stripe_nr << BTRFS_STRIPE_LEN_SHIFT;
 676 }
 677
 678 void btrfs_get_bioc(struct btrfs_io_context *bioc);
 679 void btrfs_put_bioc(struct btrfs_io_context *bioc);
 680 int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
 681                     u64 logical, u64 *length,
 682                     struct btrfs_io_context **bioc_ret,
 683                     struct btrfs_io_stripe *smap, int *mirror_num_ret);
 684 int btrfs_map_repair_block(struct btrfs_fs_info *fs_info,
 685                            struct btrfs_io_stripe *smap, u64 logical,
 686                            u32 length, int mirror_num);
 687 struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,
 688                                                u64 logical, u64 *length_ret,
 689                                                u32 *num_stripes);
 690 int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);
 691 int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);
 692 struct btrfs_block_group *btrfs_create_chunk(struct btrfs_trans_handle *trans,
 693                                             u64 type);
 694 void btrfs_mapping_tree_free(struct btrfs_fs_info *fs_info);
 695 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
 696                        blk_mode_t flags, void *holder);
 697 struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags,
 698                                            bool mount_arg_dev);
 699 int btrfs_forget_devices(dev_t devt);
 700 void btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
 701 void btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices);
 702 void btrfs_assign_next_active_device(struct btrfs_device *device,
 703                                      struct btrfs_device *this_dev);
 704 struct btrfs_device *btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info,
 705                                                   u64 devid,
 706                                                   const char *devpath);
 707 int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,
 708                                  struct btrfs_dev_lookup_args *args,
 709                                  const char *path);
 710 struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
 711                                         const u64 *devid, const u8 *uuid,
 712                                         const char *path);
 713 void btrfs_put_dev_args_from_path(struct btrfs_dev_lookup_args *args);
 714 int btrfs_rm_device(struct btrfs_fs_info *fs_info,
 715                     struct btrfs_dev_lookup_args *args,
 716                     struct file **bdev_file);
 717 void __exit btrfs_cleanup_fs_uuids(void);
 718 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
 719 int btrfs_grow_device(struct btrfs_trans_handle *trans,
 720                       struct btrfs_device *device, u64 new_size);
 721 struct btrfs_device *btrfs_find_device(const struct btrfs_fs_devices *fs_devices,
 722                                        const struct btrfs_dev_lookup_args *args);
 723 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
 724 int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path);
 725 int btrfs_balance(struct btrfs_fs_info *fs_info,
 726                   struct btrfs_balance_control *bctl,
 727                   struct btrfs_ioctl_balance_args *bargs);
 728 void btrfs_describe_block_groups(u64 flags, char *buf, u32 size_buf);
 729 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
 730 int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
 731 int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
 732 int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset);
 733 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
 734 bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset);
 735 void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
 736 int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,
 737                         struct btrfs_ioctl_get_dev_stats *stats);
 738 int btrfs_init_devices_late(struct btrfs_fs_info *fs_info);
 739 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);
 740 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans);
 741 void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_device *srcdev);
 742 void btrfs_rm_dev_replace_free_srcdev(struct btrfs_device *srcdev);
 743 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_device *tgtdev);
 744 unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,
 745                                     u64 logical);
 746 u64 btrfs_calc_stripe_length(const struct btrfs_chunk_map *map);
 747 int btrfs_nr_parity_stripes(u64 type);
 748 int btrfs_chunk_alloc_add_chunk_item(struct btrfs_trans_handle *trans,
 749                                      struct btrfs_block_group *bg);
 750 int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset);
 751
 752 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
 753 struct btrfs_chunk_map *btrfs_alloc_chunk_map(int num_stripes, gfp_t gfp);
 754 int btrfs_add_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);
 755 #endif
 756
 757 struct btrfs_chunk_map *btrfs_find_chunk_map(struct btrfs_fs_info *fs_info,
 758                                              u64 logical, u64 length);
 759 struct btrfs_chunk_map *btrfs_find_chunk_map_nolock(struct btrfs_fs_info *fs_info,
 760                                                     u64 logical, u64 length);
 761 struct btrfs_chunk_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info,
 762                                             u64 logical, u64 length);
 763 void btrfs_remove_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);
 764 void btrfs_release_disk_super(struct btrfs_super_block *super);
 765
 766 static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
 767                                       int index)
 768 {
 769         atomic_inc(dev->dev_stat_values + index);
 770         /*
 771          * This memory barrier orders stores updating statistics before stores
 772          * updating dev_stats_ccnt.
 773          *
 774          * It pairs with smp_rmb() in btrfs_run_dev_stats().
 775          */
 776         smp_mb__before_atomic();
 777         atomic_inc(&dev->dev_stats_ccnt);
 778 }
 779
 780 static inline int btrfs_dev_stat_read(struct btrfs_device *dev,
 781                                       int index)
 782 {
 783         return atomic_read(dev->dev_stat_values + index);
 784 }
 785
 786 static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev,
 787                                                 int index)
 788 {
 789         int ret;
 790
 791         ret = atomic_xchg(dev->dev_stat_values + index, 0);
 792         /*
 793          * atomic_xchg implies a full memory barriers as per atomic_t.txt:
 794          * - RMW operations that have a return value are fully ordered;
 795          *
 796          * This implicit memory barriers is paired with the smp_rmb in
 797          * btrfs_run_dev_stats
 798          */
 799         atomic_inc(&dev->dev_stats_ccnt);
 800         return ret;
 801 }
 802
 803 static inline void btrfs_dev_stat_set(struct btrfs_device *dev,
 804                                       int index, unsigned long val)
 805 {
 806         atomic_set(dev->dev_stat_values + index, val);
 807         /*
 808          * This memory barrier orders stores updating statistics before stores
 809          * updating dev_stats_ccnt.
 810          *
 811          * It pairs with smp_rmb() in btrfs_run_dev_stats().
 812          */
 813         smp_mb__before_atomic();
 814         atomic_inc(&dev->dev_stats_ccnt);
 815 }
 816
 817 static inline const char *btrfs_dev_name(const struct btrfs_device *device)
 818 {
 819         if (!device || test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))
 820                 return "<missing disk>";
 821         else
 822                 return rcu_str_deref(device->name);
 823 }
 824
 825 void btrfs_commit_device_sizes(struct btrfs_transaction *trans);
 826
 827 struct list_head * __attribute_const__ btrfs_get_fs_uuids(void);
 828 bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info,
 829                                         struct btrfs_device *failing_dev);
 830 void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, struct btrfs_device *device);
 831
 832 enum btrfs_raid_types __attribute_const__ btrfs_bg_flags_to_raid_index(u64 flags);
 833 int btrfs_bg_type_to_factor(u64 flags);
 834 const char *btrfs_bg_type_to_raid_name(u64 flags);
 835 int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info);
 836 bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical);
 837
 838 bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);
 839 const u8 *btrfs_sb_fsid_ptr(const struct btrfs_super_block *sb);
 840
 841 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
 842 struct btrfs_io_context *alloc_btrfs_io_context(struct btrfs_fs_info *fs_info,
 843                                                 u64 logical, u16 total_stripes);
 844 #endif
 845
 846 #endif