844 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2/*3 * Copyright (C) 2007 Oracle. All rights reserved.4 */5 6#ifndef BTRFS_VOLUMES_H7#define BTRFS_VOLUMES_H8 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 24struct block_device;25struct bdev_handle;26struct btrfs_fs_info;27struct btrfs_block_group;28struct btrfs_trans_handle;29struct 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 time35 * spent in blkdev_issue_discard().36 */37#define BTRFS_MAX_DISCARD_CHUNK_SIZE (SZ_1G)38 39extern struct mutex uuid_mutex;40 41#define BTRFS_STRIPE_LEN SZ_64K42#define BTRFS_STRIPE_LEN_SHIFT (16)43#define BTRFS_STRIPE_LEN_MASK (BTRFS_STRIPE_LEN - 1)44 45static_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 requires52 * RAID0 always to be the lowest profile bit.53 * Although it's part of on-disk format and should never change, do extra54 * compile-time sanity checks.55 */56static_assert(const_ffs(BTRFS_BLOCK_GROUP_RAID0) <57 const_ffs(BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0));58static_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 65enum 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_TYPES79};80 81/*82 * Use sequence counter to get consistent device stat data on83 * 32-bit processors.84 */85#if BITS_PER_LONG==32 && defined(CONFIG_SMP)86#include <linux/seqlock.h>87#define __BTRFS_NEED_DEVICE_DATA_ORDERED88#define btrfs_device_data_ordered_init(device) \89 seqcount_init(&device->data_seqcount)90#else91#define btrfs_device_data_ordered_init(device) do { } while (0)92#endif93 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 104struct btrfs_fs_devices;105 106struct 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 not124 * 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_ORDERED131 seqcount_t data_seqcount;132#endif133 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 than156 * 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 transaction168 *169 * This variant is update when committing the transaction,170 * and protected by chunk mutex171 */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 to185 * 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 preventing204 * unsafe operations while a swapfile is active.205 *206 * These are sorted on (ptr, inode) (note that a block group or device can207 * contain more than one swapfile). We compare the pointer values because we208 * don't actually care what the object is, we just need a quick check whether209 * the object exists in the rbtree.210 */211struct 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, ptr217 * 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 of222 * 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't229 * 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) \233static inline u64 \234btrfs_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 \246static inline void \247btrfs_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) \257static inline u64 \258btrfs_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 \268static inline void \269btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \270{ \271 preempt_disable(); \272 dev->name = size; \273 preempt_enable(); \274}275#else276#define BTRFS_DEVICE_GETSET_FUNCS(name) \277static inline u64 \278btrfs_device_get_##name(const struct btrfs_device *dev) \279{ \280 return dev->name; \281} \282 \283static inline void \284btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \285{ \286 dev->name = size; \287}288#endif289 290BTRFS_DEVICE_GETSET_FUNCS(total_bytes);291BTRFS_DEVICE_GETSET_FUNCS(disk_total_bytes);292BTRFS_DEVICE_GETSET_FUNCS(bytes_used);293 294enum 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 based301 * on these policies.302 */303enum 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_DEBUG310/*311 * Checksum mode - offload it to workqueues or do it synchronously in312 * btrfs_submit_chunk().313 */314enum 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 workqueues318 * 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#endif327 328struct 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 have335 * BTRFS_FEATURE_INCOMPAT_METADATA_UUID flag set.336 *337 * - Following shall be true at all times:338 * - metadata_uuid == btrfs_header::fsid339 * - metadata_uuid == btrfs_dev_item::fsid340 *341 * - Relations between fsid and metadata_uuid in sb and fs_devices:342 * - Normal:343 * fs_devices->fsid == fs_devices->metadata_uuid == sb->fsid344 * sb->metadata_uuid == 0345 *346 * - When the BTRFS_FEATURE_INCOMPAT_METADATA_UUID flag is set:347 * fs_devices->fsid == sb->fsid348 * fs_devices->metadata_uuid == sb->metadata_uuid349 *350 * - When in-memory fs_devices->temp_fsid is true351 * fs_devices->fsid = random352 * fs_devices->metadata_uuid == sb->fsid353 */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 and360 * replace-target device and excludes seed devices.361 */362 u64 num_devices;363 364 /*365 * The number of devices that successfully opened, including366 * 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-target380 * 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 removal389 * 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 can395 * safely walk it to write out the super blocks without worrying about396 * adding/removing by the multi-device code. Scrubbing super block can397 * 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_DEBUG434 /* Checksum mode - offload it or do it synchronously. */435 enum btrfs_offload_csum_mode offload_csum_mode;436#endif437};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 448struct 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 458struct 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 profiles468 * Mirror based profiles are SINGLE/DUP/RAID1/RAID10.469 *470 * - Contain the logical -> physical mapping info471 * Used by submit_stripe_bio() for mapping logical bio472 * into physical device address.473 *474 * - Contain device replace info475 * Used by handle_ops_on_dev_replace() to copy logical bios476 * into the new device.477 *478 * - Contain RAID56 full stripe logical bytenrs479 */480struct 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 duplicated496 * 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 a504 * 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 be512 * written to replace target.513 * Should be <= 2 (2 for DUP, otherwise <= 1).514 * @replace_stripe_src: The array indicates where the duplicated stripes515 * 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, thus522 * 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 = X528 * stripes[1]: dev = devid 2, physical = Y529 * stripes[2]: dev = devid 3, physical = Z530 * stripes[3]: dev = devid 0, physical = Y531 *532 * replace_nr_stripes = 1533 * replace_stripe_src = 1 <- Means stripes[1] is involved in replace.534 * The duplicated stripe index would be535 * (@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't539 * 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[] should547 * 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 stripe553 * stripes[1]: The second data stripe554 * ...555 * stripes[data_stripes - 1]: The last data stripe556 * stripes[data_stripes]: The P stripe557 * stripes[data_stripes + 1]: The Q stripe (only for RAID6).558 */559 u64 full_stripe_logical;560 struct btrfs_io_stripe stripes[];561};562 563struct btrfs_device_info {564 struct btrfs_device *dev;565 u64 dev_offset;566 u64 max_avail;567 u64 total_avail;568};569 570struct 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 store579 * 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 585extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];586 587struct 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 606static 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 614struct 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 parameters626 */627struct 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_INIT639 640enum btrfs_map_op {641 BTRFS_MAP_READ,642 BTRFS_MAP_WRITE,643 BTRFS_MAP_GET_READ_MIRRORS,644};645 646static 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 660static 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 larger671 * than 4G. This does the proper type cast to avoid overflow.672 */673static inline u64 btrfs_stripe_nr_to_offset(u32 stripe_nr)674{675 return (u64)stripe_nr << BTRFS_STRIPE_LEN_SHIFT;676}677 678void btrfs_get_bioc(struct btrfs_io_context *bioc);679void btrfs_put_bioc(struct btrfs_io_context *bioc);680int 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);684int btrfs_map_repair_block(struct btrfs_fs_info *fs_info,685 struct btrfs_io_stripe *smap, u64 logical,686 u32 length, int mirror_num);687struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info,688 u64 logical, u64 *length_ret,689 u32 *num_stripes);690int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);691int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);692struct btrfs_block_group *btrfs_create_chunk(struct btrfs_trans_handle *trans,693 u64 type);694void btrfs_mapping_tree_free(struct btrfs_fs_info *fs_info);695int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,696 blk_mode_t flags, void *holder);697struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags,698 bool mount_arg_dev);699int btrfs_forget_devices(dev_t devt);700void btrfs_close_devices(struct btrfs_fs_devices *fs_devices);701void btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices);702void btrfs_assign_next_active_device(struct btrfs_device *device,703 struct btrfs_device *this_dev);704struct btrfs_device *btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info,705 u64 devid,706 const char *devpath);707int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,708 struct btrfs_dev_lookup_args *args,709 const char *path);710struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,711 const u64 *devid, const u8 *uuid,712 const char *path);713void btrfs_put_dev_args_from_path(struct btrfs_dev_lookup_args *args);714int btrfs_rm_device(struct btrfs_fs_info *fs_info,715 struct btrfs_dev_lookup_args *args,716 struct file **bdev_file);717void __exit btrfs_cleanup_fs_uuids(void);718int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);719int btrfs_grow_device(struct btrfs_trans_handle *trans,720 struct btrfs_device *device, u64 new_size);721struct btrfs_device *btrfs_find_device(const struct btrfs_fs_devices *fs_devices,722 const struct btrfs_dev_lookup_args *args);723int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);724int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path);725int btrfs_balance(struct btrfs_fs_info *fs_info,726 struct btrfs_balance_control *bctl,727 struct btrfs_ioctl_balance_args *bargs);728void btrfs_describe_block_groups(u64 flags, char *buf, u32 size_buf);729int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);730int btrfs_recover_balance(struct btrfs_fs_info *fs_info);731int btrfs_pause_balance(struct btrfs_fs_info *fs_info);732int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset);733int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);734bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset);735void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);736int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,737 struct btrfs_ioctl_get_dev_stats *stats);738int btrfs_init_devices_late(struct btrfs_fs_info *fs_info);739int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);740int btrfs_run_dev_stats(struct btrfs_trans_handle *trans);741void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_device *srcdev);742void btrfs_rm_dev_replace_free_srcdev(struct btrfs_device *srcdev);743void btrfs_destroy_dev_replace_tgtdev(struct btrfs_device *tgtdev);744int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info,745 u64 logical, u64 len);746unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,747 u64 logical);748u64 btrfs_calc_stripe_length(const struct btrfs_chunk_map *map);749int btrfs_nr_parity_stripes(u64 type);750int btrfs_chunk_alloc_add_chunk_item(struct btrfs_trans_handle *trans,751 struct btrfs_block_group *bg);752int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset);753 754#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS755struct btrfs_chunk_map *btrfs_alloc_chunk_map(int num_stripes, gfp_t gfp);756int btrfs_add_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);757#endif758 759struct btrfs_chunk_map *btrfs_find_chunk_map(struct btrfs_fs_info *fs_info,760 u64 logical, u64 length);761struct btrfs_chunk_map *btrfs_find_chunk_map_nolock(struct btrfs_fs_info *fs_info,762 u64 logical, u64 length);763struct btrfs_chunk_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info,764 u64 logical, u64 length);765void btrfs_remove_chunk_map(struct btrfs_fs_info *fs_info, struct btrfs_chunk_map *map);766void btrfs_release_disk_super(struct btrfs_super_block *super);767 768static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,769 int index)770{771 atomic_inc(dev->dev_stat_values + index);772 /*773 * This memory barrier orders stores updating statistics before stores774 * updating dev_stats_ccnt.775 *776 * It pairs with smp_rmb() in btrfs_run_dev_stats().777 */778 smp_mb__before_atomic();779 atomic_inc(&dev->dev_stats_ccnt);780}781 782static inline int btrfs_dev_stat_read(struct btrfs_device *dev,783 int index)784{785 return atomic_read(dev->dev_stat_values + index);786}787 788static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev,789 int index)790{791 int ret;792 793 ret = atomic_xchg(dev->dev_stat_values + index, 0);794 /*795 * atomic_xchg implies a full memory barriers as per atomic_t.txt:796 * - RMW operations that have a return value are fully ordered;797 *798 * This implicit memory barriers is paired with the smp_rmb in799 * btrfs_run_dev_stats800 */801 atomic_inc(&dev->dev_stats_ccnt);802 return ret;803}804 805static inline void btrfs_dev_stat_set(struct btrfs_device *dev,806 int index, unsigned long val)807{808 atomic_set(dev->dev_stat_values + index, val);809 /*810 * This memory barrier orders stores updating statistics before stores811 * updating dev_stats_ccnt.812 *813 * It pairs with smp_rmb() in btrfs_run_dev_stats().814 */815 smp_mb__before_atomic();816 atomic_inc(&dev->dev_stats_ccnt);817}818 819static inline const char *btrfs_dev_name(const struct btrfs_device *device)820{821 if (!device || test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))822 return "<missing disk>";823 else824 return rcu_str_deref(device->name);825}826 827void btrfs_commit_device_sizes(struct btrfs_transaction *trans);828 829struct list_head * __attribute_const__ btrfs_get_fs_uuids(void);830bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info,831 struct btrfs_device *failing_dev);832void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, struct btrfs_device *device);833 834enum btrfs_raid_types __attribute_const__ btrfs_bg_flags_to_raid_index(u64 flags);835int btrfs_bg_type_to_factor(u64 flags);836const char *btrfs_bg_type_to_raid_name(u64 flags);837int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info);838bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical);839 840bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);841const u8 *btrfs_sb_fsid_ptr(const struct btrfs_super_block *sb);842 843#endif844