19888c340SDavid Sterba /* SPDX-License-Identifier: GPL-2.0 */ 20b86a832SChris Mason /* 30b86a832SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 40b86a832SChris Mason */ 50b86a832SChris Mason 69888c340SDavid Sterba #ifndef BTRFS_VOLUMES_H 79888c340SDavid Sterba #define BTRFS_VOLUMES_H 88790d502SChris Mason 9cea9e445SChris Mason #include <linux/bio.h> 10b2117a39SMiao Xie #include <linux/sort.h> 1155e301fdSFilipe Brandenburger #include <linux/btrfs.h> 128b712842SChris Mason #include "async-thread.h" 13b31bed17SJosef Bacik #include "messages.h" 14cea9e445SChris Mason 15fce466eaSQu Wenruo #define BTRFS_MAX_DATA_CHUNK_SIZE (10ULL * SZ_1G) 16fce466eaSQu Wenruo 1767a2c45eSMiao Xie extern struct mutex uuid_mutex; 1867a2c45eSMiao Xie 19ee22184bSByongho Lee #define BTRFS_STRIPE_LEN SZ_64K 20b2117a39SMiao Xie 21719fae89SQu Wenruo /* Used by sanity check for btrfs_raid_types. */ 22719fae89SQu Wenruo #define const_ffs(n) (__builtin_ctzll(n) + 1) 23719fae89SQu Wenruo 24719fae89SQu Wenruo /* 25719fae89SQu Wenruo * The conversion from BTRFS_BLOCK_GROUP_* bits to btrfs_raid_type requires 26719fae89SQu Wenruo * RAID0 always to be the lowest profile bit. 27719fae89SQu Wenruo * Although it's part of on-disk format and should never change, do extra 28719fae89SQu Wenruo * compile-time sanity checks. 29719fae89SQu Wenruo */ 30719fae89SQu Wenruo static_assert(const_ffs(BTRFS_BLOCK_GROUP_RAID0) < 31719fae89SQu Wenruo const_ffs(BTRFS_BLOCK_GROUP_PROFILE_MASK & ~BTRFS_BLOCK_GROUP_RAID0)); 32719fae89SQu Wenruo static_assert(const_ilog2(BTRFS_BLOCK_GROUP_RAID0) > 33719fae89SQu Wenruo ilog2(BTRFS_BLOCK_GROUP_TYPE_MASK)); 34719fae89SQu Wenruo 35719fae89SQu Wenruo /* ilog2() can handle both constants and variables */ 36719fae89SQu Wenruo #define BTRFS_BG_FLAG_TO_INDEX(profile) \ 37719fae89SQu Wenruo ilog2((profile) >> (ilog2(BTRFS_BLOCK_GROUP_RAID0) - 1)) 38719fae89SQu Wenruo 39f04fbcc6SQu Wenruo enum btrfs_raid_types { 40719fae89SQu Wenruo /* SINGLE is the special one as it doesn't have on-disk bit. */ 41719fae89SQu Wenruo BTRFS_RAID_SINGLE = 0, 42719fae89SQu Wenruo 43719fae89SQu Wenruo BTRFS_RAID_RAID0 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID0), 44719fae89SQu Wenruo BTRFS_RAID_RAID1 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1), 45719fae89SQu Wenruo BTRFS_RAID_DUP = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_DUP), 46719fae89SQu Wenruo BTRFS_RAID_RAID10 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID10), 47719fae89SQu Wenruo BTRFS_RAID_RAID5 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID5), 48719fae89SQu Wenruo BTRFS_RAID_RAID6 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID6), 49719fae89SQu Wenruo BTRFS_RAID_RAID1C3 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1C3), 50719fae89SQu Wenruo BTRFS_RAID_RAID1C4 = BTRFS_BG_FLAG_TO_INDEX(BTRFS_BLOCK_GROUP_RAID1C4), 51719fae89SQu Wenruo 52f04fbcc6SQu Wenruo BTRFS_NR_RAID_TYPES 53f04fbcc6SQu Wenruo }; 54f04fbcc6SQu Wenruo 555f141126SNikolay Borisov struct btrfs_io_geometry { 565f141126SNikolay Borisov /* remaining bytes before crossing a stripe */ 575f141126SNikolay Borisov u64 len; 585f141126SNikolay Borisov /* offset of logical address in chunk */ 595f141126SNikolay Borisov u64 offset; 605f141126SNikolay Borisov /* length of single IO stripe */ 61cc353a8bSQu Wenruo u32 stripe_len; 62cc353a8bSQu Wenruo /* offset of address in stripe */ 63cc353a8bSQu Wenruo u32 stripe_offset; 645f141126SNikolay Borisov /* number of stripe where address falls */ 655f141126SNikolay Borisov u64 stripe_nr; 665f141126SNikolay Borisov /* offset of raid56 stripe into the chunk */ 675f141126SNikolay Borisov u64 raid56_stripe_offset; 685f141126SNikolay Borisov }; 695f141126SNikolay Borisov 707cc8e58dSMiao Xie /* 717cc8e58dSMiao Xie * Use sequence counter to get consistent device stat data on 727cc8e58dSMiao Xie * 32-bit processors. 737cc8e58dSMiao Xie */ 747cc8e58dSMiao Xie #if BITS_PER_LONG==32 && defined(CONFIG_SMP) 757cc8e58dSMiao Xie #include <linux/seqlock.h> 767cc8e58dSMiao Xie #define __BTRFS_NEED_DEVICE_DATA_ORDERED 77c41ec452SSu Yue #define btrfs_device_data_ordered_init(device) \ 78c41ec452SSu Yue seqcount_init(&device->data_seqcount) 797cc8e58dSMiao Xie #else 80c41ec452SSu Yue #define btrfs_device_data_ordered_init(device) do { } while (0) 817cc8e58dSMiao Xie #endif 827cc8e58dSMiao Xie 83ebbede42SAnand Jain #define BTRFS_DEV_STATE_WRITEABLE (0) 84e12c9621SAnand Jain #define BTRFS_DEV_STATE_IN_FS_METADATA (1) 85e6e674bdSAnand Jain #define BTRFS_DEV_STATE_MISSING (2) 86401e29c1SAnand Jain #define BTRFS_DEV_STATE_REPLACE_TGT (3) 871c3063b6SAnand Jain #define BTRFS_DEV_STATE_FLUSH_SENT (4) 8866d204a1SFilipe Manana #define BTRFS_DEV_STATE_NO_READA (5) 89ebbede42SAnand Jain 905b316468SNaohiro Aota struct btrfs_zoned_device_info; 915b316468SNaohiro Aota 920b86a832SChris Mason struct btrfs_device { 930b6f5d40SNikolay Borisov struct list_head dev_list; /* device_list_mutex */ 940b6f5d40SNikolay Borisov struct list_head dev_alloc_list; /* chunk mutex */ 95bbbf7243SNikolay Borisov struct list_head post_commit_list; /* chunk mutex */ 962b82032cSYan Zheng struct btrfs_fs_devices *fs_devices; 97fb456252SJeff Mahoney struct btrfs_fs_info *fs_info; 98ffbd517dSChris Mason 998d1a7aaeSMadhuparna Bhowmik struct rcu_string __rcu *name; 100d5ee37bcSMiao Xie 101d5ee37bcSMiao Xie u64 generation; 102d5ee37bcSMiao Xie 103d5ee37bcSMiao Xie struct block_device *bdev; 104d5ee37bcSMiao Xie 1055b316468SNaohiro Aota struct btrfs_zoned_device_info *zone_info; 1065b316468SNaohiro Aota 107d5ee37bcSMiao Xie /* the mode sent to blkdev_get */ 108d5ee37bcSMiao Xie fmode_t mode; 109d5ee37bcSMiao Xie 1104889bc05SAnand Jain /* 1114889bc05SAnand Jain * Device's major-minor number. Must be set even if the device is not 1124889bc05SAnand Jain * opened (bdev == NULL), unless the device is missing. 1134889bc05SAnand Jain */ 1144889bc05SAnand Jain dev_t devt; 115ebbede42SAnand Jain unsigned long dev_state; 11658efbc9fSOmar Sandoval blk_status_t last_flush_error; 117b3075717SChris Mason 1187cc8e58dSMiao Xie #ifdef __BTRFS_NEED_DEVICE_DATA_ORDERED 119c41ec452SSu Yue seqcount_t data_seqcount; 1207cc8e58dSMiao Xie #endif 1217cc8e58dSMiao Xie 1220b86a832SChris Mason /* the internal btrfs device id */ 1230b86a832SChris Mason u64 devid; 1240b86a832SChris Mason 1256ba40b61SMiao Xie /* size of the device in memory */ 1260b86a832SChris Mason u64 total_bytes; 1270b86a832SChris Mason 1286ba40b61SMiao Xie /* size of the device on disk */ 129d6397baeSChris Ball u64 disk_total_bytes; 130d6397baeSChris Ball 1310b86a832SChris Mason /* bytes used */ 1320b86a832SChris Mason u64 bytes_used; 1330b86a832SChris Mason 1340b86a832SChris Mason /* optimal io alignment for this device */ 1350b86a832SChris Mason u32 io_align; 1360b86a832SChris Mason 1370b86a832SChris Mason /* optimal io width for this device */ 1380b86a832SChris Mason u32 io_width; 1393c45bfc1SDulshani Gunawardhana /* type and info about this device */ 1403c45bfc1SDulshani Gunawardhana u64 type; 1410b86a832SChris Mason 1420b86a832SChris Mason /* minimal io size for this device */ 1430b86a832SChris Mason u32 sector_size; 1440b86a832SChris Mason 1450b86a832SChris Mason /* physical drive uuid (or lvm uuid) */ 146e17cade2SChris Mason u8 uuid[BTRFS_UUID_SIZE]; 1478b712842SChris Mason 148935e5cc9SMiao Xie /* 149935e5cc9SMiao Xie * size of the device on the current transaction 150935e5cc9SMiao Xie * 151935e5cc9SMiao Xie * This variant is update when committing the transaction, 152bbbf7243SNikolay Borisov * and protected by chunk mutex 153935e5cc9SMiao Xie */ 154935e5cc9SMiao Xie u64 commit_total_bytes; 155935e5cc9SMiao Xie 156ce7213c7SMiao Xie /* bytes used on the current transaction */ 157ce7213c7SMiao Xie u64 commit_bytes_used; 158935e5cc9SMiao Xie 159f9e69aa9SChristoph Hellwig /* Bio used for flushing device barriers */ 160f9e69aa9SChristoph Hellwig struct bio flush_bio; 1613c45bfc1SDulshani Gunawardhana struct completion flush_wait; 1623c45bfc1SDulshani Gunawardhana 163a2de733cSArne Jansen /* per-device scrub information */ 164cadbc0a0SAnand Jain struct scrub_ctx *scrub_ctx; 165a2de733cSArne Jansen 166442a4f63SStefan Behrens /* disk I/O failure stats. For detailed description refer to 167442a4f63SStefan Behrens * enum btrfs_dev_stat_values in ioctl.h */ 168733f4fbbSStefan Behrens int dev_stats_valid; 169addc3fa7SMiao Xie 170addc3fa7SMiao Xie /* Counter to record the change of device stats */ 171addc3fa7SMiao Xie atomic_t dev_stats_ccnt; 172442a4f63SStefan Behrens atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX]; 1731c11b63eSJeff Mahoney 1741c11b63eSJeff Mahoney struct extent_io_tree alloc_state; 175668e48afSAnand Jain 176668e48afSAnand Jain struct completion kobj_unregister; 177668e48afSAnand Jain /* For sysfs/FSID/devinfo/devid/ */ 178668e48afSAnand Jain struct kobject devid_kobj; 179eb3b5053SDavid Sterba 180eb3b5053SDavid Sterba /* Bandwidth limit for scrub, in bytes */ 181eb3b5053SDavid Sterba u64 scrub_speed_max; 1820b86a832SChris Mason }; 1830b86a832SChris Mason 1847cc8e58dSMiao Xie /* 1852103da3bSJosef Bacik * Block group or device which contains an active swapfile. Used for preventing 1862103da3bSJosef Bacik * unsafe operations while a swapfile is active. 1872103da3bSJosef Bacik * 1882103da3bSJosef Bacik * These are sorted on (ptr, inode) (note that a block group or device can 1892103da3bSJosef Bacik * contain more than one swapfile). We compare the pointer values because we 1902103da3bSJosef Bacik * don't actually care what the object is, we just need a quick check whether 1912103da3bSJosef Bacik * the object exists in the rbtree. 1922103da3bSJosef Bacik */ 1932103da3bSJosef Bacik struct btrfs_swapfile_pin { 1942103da3bSJosef Bacik struct rb_node node; 1952103da3bSJosef Bacik void *ptr; 1962103da3bSJosef Bacik struct inode *inode; 1972103da3bSJosef Bacik /* 1982103da3bSJosef Bacik * If true, ptr points to a struct btrfs_block_group. Otherwise, ptr 1992103da3bSJosef Bacik * points to a struct btrfs_device. 2002103da3bSJosef Bacik */ 2012103da3bSJosef Bacik bool is_block_group; 2022103da3bSJosef Bacik /* 2032103da3bSJosef Bacik * Only used when 'is_block_group' is true and it is the number of 2042103da3bSJosef Bacik * extents used by a swapfile for this block group ('ptr' field). 2052103da3bSJosef Bacik */ 2062103da3bSJosef Bacik int bg_extent_count; 2072103da3bSJosef Bacik }; 2082103da3bSJosef Bacik 2092103da3bSJosef Bacik /* 2107cc8e58dSMiao Xie * If we read those variants at the context of their own lock, we needn't 2117cc8e58dSMiao Xie * use the following helpers, reading them directly is safe. 2127cc8e58dSMiao Xie */ 2137cc8e58dSMiao Xie #if BITS_PER_LONG==32 && defined(CONFIG_SMP) 2147cc8e58dSMiao Xie #define BTRFS_DEVICE_GETSET_FUNCS(name) \ 2157cc8e58dSMiao Xie static inline u64 \ 2167cc8e58dSMiao Xie btrfs_device_get_##name(const struct btrfs_device *dev) \ 2177cc8e58dSMiao Xie { \ 2187cc8e58dSMiao Xie u64 size; \ 2197cc8e58dSMiao Xie unsigned int seq; \ 2207cc8e58dSMiao Xie \ 2217cc8e58dSMiao Xie do { \ 2227cc8e58dSMiao Xie seq = read_seqcount_begin(&dev->data_seqcount); \ 2237cc8e58dSMiao Xie size = dev->name; \ 2247cc8e58dSMiao Xie } while (read_seqcount_retry(&dev->data_seqcount, seq)); \ 2257cc8e58dSMiao Xie return size; \ 2267cc8e58dSMiao Xie } \ 2277cc8e58dSMiao Xie \ 2287cc8e58dSMiao Xie static inline void \ 2297cc8e58dSMiao Xie btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \ 2307cc8e58dSMiao Xie { \ 231c41ec452SSu Yue preempt_disable(); \ 2327cc8e58dSMiao Xie write_seqcount_begin(&dev->data_seqcount); \ 2337cc8e58dSMiao Xie dev->name = size; \ 2347cc8e58dSMiao Xie write_seqcount_end(&dev->data_seqcount); \ 235c41ec452SSu Yue preempt_enable(); \ 2367cc8e58dSMiao Xie } 23794545870SThomas Gleixner #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPTION) 2387cc8e58dSMiao Xie #define BTRFS_DEVICE_GETSET_FUNCS(name) \ 2397cc8e58dSMiao Xie static inline u64 \ 2407cc8e58dSMiao Xie btrfs_device_get_##name(const struct btrfs_device *dev) \ 2417cc8e58dSMiao Xie { \ 2427cc8e58dSMiao Xie u64 size; \ 2437cc8e58dSMiao Xie \ 2447cc8e58dSMiao Xie preempt_disable(); \ 2457cc8e58dSMiao Xie size = dev->name; \ 2467cc8e58dSMiao Xie preempt_enable(); \ 2477cc8e58dSMiao Xie return size; \ 2487cc8e58dSMiao Xie } \ 2497cc8e58dSMiao Xie \ 2507cc8e58dSMiao Xie static inline void \ 2517cc8e58dSMiao Xie btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \ 2527cc8e58dSMiao Xie { \ 2537cc8e58dSMiao Xie preempt_disable(); \ 2547cc8e58dSMiao Xie dev->name = size; \ 2557cc8e58dSMiao Xie preempt_enable(); \ 2567cc8e58dSMiao Xie } 2577cc8e58dSMiao Xie #else 2587cc8e58dSMiao Xie #define BTRFS_DEVICE_GETSET_FUNCS(name) \ 2597cc8e58dSMiao Xie static inline u64 \ 2607cc8e58dSMiao Xie btrfs_device_get_##name(const struct btrfs_device *dev) \ 2617cc8e58dSMiao Xie { \ 2627cc8e58dSMiao Xie return dev->name; \ 2637cc8e58dSMiao Xie } \ 2647cc8e58dSMiao Xie \ 2657cc8e58dSMiao Xie static inline void \ 2667cc8e58dSMiao Xie btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \ 2677cc8e58dSMiao Xie { \ 2687cc8e58dSMiao Xie dev->name = size; \ 2697cc8e58dSMiao Xie } 2707cc8e58dSMiao Xie #endif 2717cc8e58dSMiao Xie 2727cc8e58dSMiao Xie BTRFS_DEVICE_GETSET_FUNCS(total_bytes); 2737cc8e58dSMiao Xie BTRFS_DEVICE_GETSET_FUNCS(disk_total_bytes); 2747cc8e58dSMiao Xie BTRFS_DEVICE_GETSET_FUNCS(bytes_used); 2757cc8e58dSMiao Xie 276c4a816c6SNaohiro Aota enum btrfs_chunk_allocation_policy { 277c4a816c6SNaohiro Aota BTRFS_CHUNK_ALLOC_REGULAR, 2781cd6121fSNaohiro Aota BTRFS_CHUNK_ALLOC_ZONED, 279c4a816c6SNaohiro Aota }; 280c4a816c6SNaohiro Aota 28133fd2f71SAnand Jain /* 28233fd2f71SAnand Jain * Read policies for mirrored block group profiles, read picks the stripe based 28333fd2f71SAnand Jain * on these policies. 28433fd2f71SAnand Jain */ 28533fd2f71SAnand Jain enum btrfs_read_policy { 28633fd2f71SAnand Jain /* Use process PID to choose the stripe */ 28733fd2f71SAnand Jain BTRFS_READ_POLICY_PID, 28833fd2f71SAnand Jain BTRFS_NR_READ_POLICY, 28933fd2f71SAnand Jain }; 29033fd2f71SAnand Jain 2918a4b83ccSChris Mason struct btrfs_fs_devices { 2928a4b83ccSChris Mason u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ 2937239ff4bSNikolay Borisov u8 metadata_uuid[BTRFS_FSID_SIZE]; 294d1a63002SNikolay Borisov bool fsid_change; 295c4babc5eSAnand Jain struct list_head fs_list; 2968a4b83ccSChris Mason 297add9745aSAnand Jain /* 298add9745aSAnand Jain * Number of devices under this fsid including missing and 299add9745aSAnand Jain * replace-target device and excludes seed devices. 300add9745aSAnand Jain */ 3018a4b83ccSChris Mason u64 num_devices; 302add9745aSAnand Jain 303add9745aSAnand Jain /* 304add9745aSAnand Jain * The number of devices that successfully opened, including 305add9745aSAnand Jain * replace-target, excludes seed devices. 306add9745aSAnand Jain */ 307a0af469bSChris Mason u64 open_devices; 308add9745aSAnand Jain 309add9745aSAnand Jain /* The number of devices that are under the chunk allocation list. */ 3102b82032cSYan Zheng u64 rw_devices; 311add9745aSAnand Jain 312add9745aSAnand Jain /* Count of missing devices under this fsid excluding seed device. */ 313cd02dca5SChris Mason u64 missing_devices; 3142b82032cSYan Zheng u64 total_rw_bytes; 315add9745aSAnand Jain 316add9745aSAnand Jain /* 317add9745aSAnand Jain * Count of devices from btrfs_super_block::num_devices for this fsid, 318add9745aSAnand Jain * which includes the seed device, excludes the transient replace-target 319add9745aSAnand Jain * device. 320add9745aSAnand Jain */ 32102db0844SJosef Bacik u64 total_devices; 322d1a63002SNikolay Borisov 323d1a63002SNikolay Borisov /* Highest generation number of seen devices */ 324d1a63002SNikolay Borisov u64 latest_generation; 325d1a63002SNikolay Borisov 326d24fa5c1SAnand Jain /* 327d24fa5c1SAnand Jain * The mount device or a device with highest generation after removal 328d24fa5c1SAnand Jain * or replace. 329d24fa5c1SAnand Jain */ 330d24fa5c1SAnand Jain struct btrfs_device *latest_dev; 331e5e9a520SChris Mason 332e5e9a520SChris Mason /* all of the devices in the FS, protected by a mutex 333e5e9a520SChris Mason * so we can safely walk it to write out the supers without 3349b011adfSWang Shilong * worrying about add/remove by the multi-device code. 3359b011adfSWang Shilong * Scrubbing super can kick off supers writing by holding 3369b011adfSWang Shilong * this mutex lock. 337e5e9a520SChris Mason */ 338e5e9a520SChris Mason struct mutex device_list_mutex; 3390b6f5d40SNikolay Borisov 3400b6f5d40SNikolay Borisov /* List of all devices, protected by device_list_mutex */ 3418a4b83ccSChris Mason struct list_head devices; 342b3075717SChris Mason 3430b6f5d40SNikolay Borisov /* 3440b6f5d40SNikolay Borisov * Devices which can satisfy space allocation. Protected by 3450b6f5d40SNikolay Borisov * chunk_mutex 3460b6f5d40SNikolay Borisov */ 347b3075717SChris Mason struct list_head alloc_list; 3482b82032cSYan Zheng 349944d3f9fSNikolay Borisov struct list_head seed_list; 3500395d84fSJohannes Thumshirn bool seeding; 3512b82032cSYan Zheng 3522b82032cSYan Zheng int opened; 353c289811cSChris Mason 354c289811cSChris Mason /* set when we find or add a device that doesn't have the 355c289811cSChris Mason * nonrot flag set 356c289811cSChris Mason */ 3577f0432d0SJohannes Thumshirn bool rotating; 35863a7cb13SDavid Sterba /* Devices support TRIM/discard commands */ 35963a7cb13SDavid Sterba bool discardable; 3602e7910d6SAnand Jain 3615a13f430SAnand Jain struct btrfs_fs_info *fs_info; 3622e7910d6SAnand Jain /* sysfs kobjects */ 363c1b7e474SAnand Jain struct kobject fsid_kobj; 364b5501504SAnand Jain struct kobject *devices_kobj; 365a013d141SAnand Jain struct kobject *devinfo_kobj; 3662e7910d6SAnand Jain struct completion kobj_unregister; 367c4a816c6SNaohiro Aota 368c4a816c6SNaohiro Aota enum btrfs_chunk_allocation_policy chunk_alloc_policy; 36933fd2f71SAnand Jain 37033fd2f71SAnand Jain /* Policy used to read the mirrored stripes */ 37133fd2f71SAnand Jain enum btrfs_read_policy read_policy; 3728a4b83ccSChris Mason }; 3738a4b83ccSChris Mason 374facc8a22SMiao Xie #define BTRFS_BIO_INLINE_CSUM_SIZE 64 375facc8a22SMiao Xie 376ab4ba2e1SQu Wenruo #define BTRFS_MAX_DEVS(info) ((BTRFS_MAX_ITEM_SIZE(info) \ 377ab4ba2e1SQu Wenruo - sizeof(struct btrfs_chunk)) \ 378ab4ba2e1SQu Wenruo / sizeof(struct btrfs_stripe) + 1) 379ab4ba2e1SQu Wenruo 380ab4ba2e1SQu Wenruo #define BTRFS_MAX_DEVS_SYS_CHUNK ((BTRFS_SYSTEM_CHUNK_ARRAY_SIZE \ 381ab4ba2e1SQu Wenruo - 2 * sizeof(struct btrfs_disk_key) \ 382ab4ba2e1SQu Wenruo - 2 * sizeof(struct btrfs_chunk)) \ 383ab4ba2e1SQu Wenruo / sizeof(struct btrfs_stripe) + 1) 384ab4ba2e1SQu Wenruo 3859be3395bSChris Mason /* 386ee5b46a3SChristoph Hellwig * Maximum number of sectors for a single bio to limit the size of the 387ee5b46a3SChristoph Hellwig * checksum array. This matches the number of bio_vecs per bio and thus the 388ee5b46a3SChristoph Hellwig * I/O size for buffered I/O. 389ee5b46a3SChristoph Hellwig */ 390ee5b46a3SChristoph Hellwig #define BTRFS_MAX_BIO_SECTORS (256) 391ee5b46a3SChristoph Hellwig 392917f32a2SChristoph Hellwig typedef void (*btrfs_bio_end_io_t)(struct btrfs_bio *bbio); 393917f32a2SChristoph Hellwig 394ee5b46a3SChristoph Hellwig /* 395c3a3b19bSQu Wenruo * Additional info to pass along bio. 396c3a3b19bSQu Wenruo * 397c3a3b19bSQu Wenruo * Mostly for btrfs specific features like csum and mirror_num. 3989be3395bSChris Mason */ 399c3a3b19bSQu Wenruo struct btrfs_bio { 400c1dc0896SMiao Xie unsigned int mirror_num; 401ae0e5df4SDavid Sterba struct bvec_iter iter; 402c3a3b19bSQu Wenruo 40300d82525SChristoph Hellwig /* for direct I/O */ 40400d82525SChristoph Hellwig u64 file_offset; 40500d82525SChristoph Hellwig 406c3a3b19bSQu Wenruo /* @device is for stripe IO submission. */ 407c31efbdfSNikolay Borisov struct btrfs_device *device; 408facc8a22SMiao Xie u8 *csum; 409facc8a22SMiao Xie u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE]; 410c3a3b19bSQu Wenruo 411917f32a2SChristoph Hellwig /* End I/O information supplied to btrfs_bio_alloc */ 412917f32a2SChristoph Hellwig btrfs_bio_end_io_t end_io; 413917f32a2SChristoph Hellwig void *private; 414917f32a2SChristoph Hellwig 415d7b9416fSChristoph Hellwig /* For read end I/O handling */ 416d7b9416fSChristoph Hellwig struct work_struct end_io_work; 417d7b9416fSChristoph Hellwig 418fa1bcbe0SDavid Sterba /* 419fa1bcbe0SDavid Sterba * This member must come last, bio_alloc_bioset will allocate enough 420c3a3b19bSQu Wenruo * bytes for entire btrfs_bio but relies on bio being last. 421fa1bcbe0SDavid Sterba */ 4229be3395bSChris Mason struct bio bio; 4239be3395bSChris Mason }; 4249be3395bSChris Mason 425c3a3b19bSQu Wenruo static inline struct btrfs_bio *btrfs_bio(struct bio *bio) 4269be3395bSChris Mason { 427c3a3b19bSQu Wenruo return container_of(bio, struct btrfs_bio, bio); 4289be3395bSChris Mason } 4299be3395bSChris Mason 430d45cfb88SChristoph Hellwig int __init btrfs_bioset_init(void); 431d45cfb88SChristoph Hellwig void __cold btrfs_bioset_exit(void); 432d45cfb88SChristoph Hellwig 433917f32a2SChristoph Hellwig struct bio *btrfs_bio_alloc(unsigned int nr_vecs, blk_opf_t opf, 434917f32a2SChristoph Hellwig btrfs_bio_end_io_t end_io, void *private); 435917f32a2SChristoph Hellwig struct bio *btrfs_bio_clone_partial(struct bio *orig, u64 offset, u64 size, 436917f32a2SChristoph Hellwig btrfs_bio_end_io_t end_io, void *private); 437917f32a2SChristoph Hellwig 438917f32a2SChristoph Hellwig static inline void btrfs_bio_end_io(struct btrfs_bio *bbio, blk_status_t status) 439917f32a2SChristoph Hellwig { 440917f32a2SChristoph Hellwig bbio->bio.bi_status = status; 441917f32a2SChristoph Hellwig bbio->end_io(bbio); 442917f32a2SChristoph Hellwig } 443d45cfb88SChristoph Hellwig 444c3a3b19bSQu Wenruo static inline void btrfs_bio_free_csum(struct btrfs_bio *bbio) 445b3a0dd50SDavid Sterba { 446c3a3b19bSQu Wenruo if (bbio->csum != bbio->csum_inline) { 447c3a3b19bSQu Wenruo kfree(bbio->csum); 448c3a3b19bSQu Wenruo bbio->csum = NULL; 449b3a0dd50SDavid Sterba } 450b3a0dd50SDavid Sterba } 451b3a0dd50SDavid Sterba 452261d812bSQu Wenruo /* 453261d812bSQu Wenruo * Iterate through a btrfs_bio (@bbio) on a per-sector basis. 454261d812bSQu Wenruo * 455261d812bSQu Wenruo * bvl - struct bio_vec 456261d812bSQu Wenruo * bbio - struct btrfs_bio 457261d812bSQu Wenruo * iters - struct bvec_iter 458261d812bSQu Wenruo * bio_offset - unsigned int 459261d812bSQu Wenruo */ 460261d812bSQu Wenruo #define btrfs_bio_for_each_sector(fs_info, bvl, bbio, iter, bio_offset) \ 461261d812bSQu Wenruo for ((iter) = (bbio)->iter, (bio_offset) = 0; \ 462261d812bSQu Wenruo (iter).bi_size && \ 463261d812bSQu Wenruo (((bvl) = bio_iter_iovec((&(bbio)->bio), (iter))), 1); \ 464261d812bSQu Wenruo (bio_offset) += fs_info->sectorsize, \ 465261d812bSQu Wenruo bio_advance_iter_single(&(bbio)->bio, &(iter), \ 466261d812bSQu Wenruo (fs_info)->sectorsize)) 467261d812bSQu Wenruo 4684c664611SQu Wenruo struct btrfs_io_stripe { 469cea9e445SChris Mason struct btrfs_device *dev; 4709ff7ddd3SChristoph Hellwig union { 4719ff7ddd3SChristoph Hellwig /* Block mapping */ 472cea9e445SChris Mason u64 physical; 4739ff7ddd3SChristoph Hellwig /* For the endio handler */ 4749ff7ddd3SChristoph Hellwig struct btrfs_io_context *bioc; 4759ff7ddd3SChristoph Hellwig }; 476a4012f06SChristoph Hellwig }; 477a4012f06SChristoph Hellwig 478a4012f06SChristoph Hellwig struct btrfs_discard_stripe { 479a4012f06SChristoph Hellwig struct btrfs_device *dev; 480a4012f06SChristoph Hellwig u64 physical; 481a4012f06SChristoph Hellwig u64 length; 482cea9e445SChris Mason }; 483cea9e445SChris Mason 4844c664611SQu Wenruo /* 4854c664611SQu Wenruo * Context for IO subsmission for device stripe. 4864c664611SQu Wenruo * 4874c664611SQu Wenruo * - Track the unfinished mirrors for mirror based profiles 4884c664611SQu Wenruo * Mirror based profiles are SINGLE/DUP/RAID1/RAID10. 4894c664611SQu Wenruo * 4904c664611SQu Wenruo * - Contain the logical -> physical mapping info 4914c664611SQu Wenruo * Used by submit_stripe_bio() for mapping logical bio 4924c664611SQu Wenruo * into physical device address. 4934c664611SQu Wenruo * 4944c664611SQu Wenruo * - Contain device replace info 4954c664611SQu Wenruo * Used by handle_ops_on_dev_replace() to copy logical bios 4964c664611SQu Wenruo * into the new device. 4974c664611SQu Wenruo * 4984c664611SQu Wenruo * - Contain RAID56 full stripe logical bytenrs 4994c664611SQu Wenruo */ 5004c664611SQu Wenruo struct btrfs_io_context { 501140475aeSElena Reshetova refcount_t refs; 502c404e0dcSMiao Xie struct btrfs_fs_info *fs_info; 50310f11900SZhao Lei u64 map_type; /* get from map_lookup->type */ 5047d2b4daaSChris Mason struct bio *orig_bio; 505a236aed1SChris Mason atomic_t error; 506a236aed1SChris Mason int max_errors; 507cea9e445SChris Mason int num_stripes; 508a1d3c478SJan Schmidt int mirror_num; 5092c8cdd6eSMiao Xie int num_tgtdevs; 5102c8cdd6eSMiao Xie int *tgtdev_map; 5118e5cfb55SZhao Lei /* 5128e5cfb55SZhao Lei * logical block numbers for the start of each stripe 5138e5cfb55SZhao Lei * The last one or two are p/q. These are sorted, 5148e5cfb55SZhao Lei * so raid_map[0] is the start of our full stripe 5158e5cfb55SZhao Lei */ 5168e5cfb55SZhao Lei u64 *raid_map; 5174c664611SQu Wenruo struct btrfs_io_stripe stripes[]; 518cea9e445SChris Mason }; 519cea9e445SChris Mason 520b2117a39SMiao Xie struct btrfs_device_info { 521b2117a39SMiao Xie struct btrfs_device *dev; 522b2117a39SMiao Xie u64 dev_offset; 523b2117a39SMiao Xie u64 max_avail; 52473c5de00SArne Jansen u64 total_avail; 525b2117a39SMiao Xie }; 526b2117a39SMiao Xie 52731e50229SLiu Bo struct btrfs_raid_attr { 5288c3e3582SDavid Sterba u8 sub_stripes; /* sub_stripes info for map */ 5298c3e3582SDavid Sterba u8 dev_stripes; /* stripes per dev */ 5308c3e3582SDavid Sterba u8 devs_max; /* max devs to use */ 5318c3e3582SDavid Sterba u8 devs_min; /* min devs needed */ 5328c3e3582SDavid Sterba u8 tolerated_failures; /* max tolerated fail devs */ 5338c3e3582SDavid Sterba u8 devs_increment; /* ndevs has to be a multiple of this */ 5348c3e3582SDavid Sterba u8 ncopies; /* how many copies to data has */ 5358c3e3582SDavid Sterba u8 nparity; /* number of stripes worth of bytes to store 536b50836edSHans van Kranenburg * parity information */ 5378c3e3582SDavid Sterba u8 mindev_error; /* error code if min devs requisite is unmet */ 538ed23467bSAnand Jain const char raid_name[8]; /* name of the raid */ 53941a6e891SAnand Jain u64 bg_flag; /* block group flag of the raid */ 54031e50229SLiu Bo }; 54131e50229SLiu Bo 542af902047SZhao Lei extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES]; 543af902047SZhao Lei 5441abe9b8aSliubo struct map_lookup { 5451abe9b8aSliubo u64 type; 5461abe9b8aSliubo int io_align; 5471abe9b8aSliubo int io_width; 548cc353a8bSQu Wenruo u32 stripe_len; 5491abe9b8aSliubo int num_stripes; 5501abe9b8aSliubo int sub_stripes; 551cf90d884SQu Wenruo int verified_stripes; /* For mount time dev extent verification */ 5524c664611SQu Wenruo struct btrfs_io_stripe stripes[]; 5531abe9b8aSliubo }; 5541abe9b8aSliubo 555a2de733cSArne Jansen #define map_lookup_size(n) (sizeof(struct map_lookup) + \ 5564c664611SQu Wenruo (sizeof(struct btrfs_io_stripe) * (n))) 557a2de733cSArne Jansen 558c9e9f97bSIlya Dryomov struct btrfs_balance_args; 55919a39dceSIlya Dryomov struct btrfs_balance_progress; 560c9e9f97bSIlya Dryomov struct btrfs_balance_control { 561c9e9f97bSIlya Dryomov struct btrfs_balance_args data; 562c9e9f97bSIlya Dryomov struct btrfs_balance_args meta; 563c9e9f97bSIlya Dryomov struct btrfs_balance_args sys; 564c9e9f97bSIlya Dryomov 565c9e9f97bSIlya Dryomov u64 flags; 56619a39dceSIlya Dryomov 56719a39dceSIlya Dryomov struct btrfs_balance_progress stat; 568c9e9f97bSIlya Dryomov }; 569c9e9f97bSIlya Dryomov 570562d7b15SJosef Bacik /* 571562d7b15SJosef Bacik * Search for a given device by the set parameters 572562d7b15SJosef Bacik */ 573562d7b15SJosef Bacik struct btrfs_dev_lookup_args { 574562d7b15SJosef Bacik u64 devid; 575562d7b15SJosef Bacik u8 *uuid; 576562d7b15SJosef Bacik u8 *fsid; 577562d7b15SJosef Bacik bool missing; 578562d7b15SJosef Bacik }; 579562d7b15SJosef Bacik 580562d7b15SJosef Bacik /* We have to initialize to -1 because BTRFS_DEV_REPLACE_DEVID is 0 */ 581562d7b15SJosef Bacik #define BTRFS_DEV_LOOKUP_ARGS_INIT { .devid = (u64)-1 } 582562d7b15SJosef Bacik 583562d7b15SJosef Bacik #define BTRFS_DEV_LOOKUP_ARGS(name) \ 584562d7b15SJosef Bacik struct btrfs_dev_lookup_args name = BTRFS_DEV_LOOKUP_ARGS_INIT 585562d7b15SJosef Bacik 586cf8cddd3SChristoph Hellwig enum btrfs_map_op { 587cf8cddd3SChristoph Hellwig BTRFS_MAP_READ, 588cf8cddd3SChristoph Hellwig BTRFS_MAP_WRITE, 589cf8cddd3SChristoph Hellwig BTRFS_MAP_DISCARD, 590cf8cddd3SChristoph Hellwig BTRFS_MAP_GET_READ_MIRRORS, 591cf8cddd3SChristoph Hellwig }; 592cf8cddd3SChristoph Hellwig 593cf8cddd3SChristoph Hellwig static inline enum btrfs_map_op btrfs_op(struct bio *bio) 594cf8cddd3SChristoph Hellwig { 595cf8cddd3SChristoph Hellwig switch (bio_op(bio)) { 596cf8cddd3SChristoph Hellwig case REQ_OP_DISCARD: 597cf8cddd3SChristoph Hellwig return BTRFS_MAP_DISCARD; 598cf8cddd3SChristoph Hellwig case REQ_OP_WRITE: 599cfe94440SNaohiro Aota case REQ_OP_ZONE_APPEND: 600cf8cddd3SChristoph Hellwig return BTRFS_MAP_WRITE; 601cf8cddd3SChristoph Hellwig default: 602cf8cddd3SChristoph Hellwig WARN_ON_ONCE(1); 603c730ae0cSMarcos Paulo de Souza fallthrough; 604cf8cddd3SChristoph Hellwig case REQ_OP_READ: 605cf8cddd3SChristoph Hellwig return BTRFS_MAP_READ; 606cf8cddd3SChristoph Hellwig } 607cf8cddd3SChristoph Hellwig } 608cf8cddd3SChristoph Hellwig 609b31bed17SJosef Bacik static inline unsigned long btrfs_chunk_item_size(int num_stripes) 610b31bed17SJosef Bacik { 611b31bed17SJosef Bacik ASSERT(num_stripes); 612b31bed17SJosef Bacik return sizeof(struct btrfs_chunk) + 613b31bed17SJosef Bacik sizeof(struct btrfs_stripe) * (num_stripes - 1); 614b31bed17SJosef Bacik } 615b31bed17SJosef Bacik 6164c664611SQu Wenruo void btrfs_get_bioc(struct btrfs_io_context *bioc); 6174c664611SQu Wenruo void btrfs_put_bioc(struct btrfs_io_context *bioc); 618cf8cddd3SChristoph Hellwig int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, 619cea9e445SChris Mason u64 logical, u64 *length, 6204c664611SQu Wenruo struct btrfs_io_context **bioc_ret, int mirror_num); 621cf8cddd3SChristoph Hellwig int btrfs_map_sblock(struct btrfs_fs_info *fs_info, enum btrfs_map_op op, 622af8e2d1dSMiao Xie u64 logical, u64 *length, 6234c664611SQu Wenruo struct btrfs_io_context **bioc_ret); 624a4012f06SChristoph Hellwig struct btrfs_discard_stripe *btrfs_map_discard(struct btrfs_fs_info *fs_info, 625a4012f06SChristoph Hellwig u64 logical, u64 *length_ret, 626a4012f06SChristoph Hellwig u32 *num_stripes); 62742034313SMichal Rostecki int btrfs_get_io_geometry(struct btrfs_fs_info *fs_info, struct extent_map *map, 62843c0d1a5SQu Wenruo enum btrfs_map_op op, u64 logical, 62942034313SMichal Rostecki struct btrfs_io_geometry *io_geom); 6306bccf3abSJeff Mahoney int btrfs_read_sys_array(struct btrfs_fs_info *fs_info); 6315b4aacefSJeff Mahoney int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info); 632f6f39f7aSNikolay Borisov struct btrfs_block_group *btrfs_create_chunk(struct btrfs_trans_handle *trans, 63379bd3712SFilipe Manana u64 type); 634c8bf1b67SDavid Sterba void btrfs_mapping_tree_free(struct extent_map_tree *tree); 6351a722d8fSChristoph Hellwig void btrfs_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio, int mirror_num); 6368a4b83ccSChris Mason int btrfs_open_devices(struct btrfs_fs_devices *fs_devices, 63797288f2cSChristoph Hellwig fmode_t flags, void *holder); 63836350e95SGu Jinxiang struct btrfs_device *btrfs_scan_one_device(const char *path, 63936350e95SGu Jinxiang fmode_t flags, void *holder); 64016cab91aSAnand Jain int btrfs_forget_devices(dev_t devt); 64154eed6aeSNikolay Borisov void btrfs_close_devices(struct btrfs_fs_devices *fs_devices); 642bacce86aSAnand Jain void btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices); 643d6507cf1SNikolay Borisov void btrfs_assign_next_active_device(struct btrfs_device *device, 644d6507cf1SNikolay Borisov struct btrfs_device *this_dev); 645a27a94c2SNikolay Borisov struct btrfs_device *btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, 646a27a94c2SNikolay Borisov u64 devid, 647a27a94c2SNikolay Borisov const char *devpath); 648faa775c4SJosef Bacik int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info, 649faa775c4SJosef Bacik struct btrfs_dev_lookup_args *args, 650faa775c4SJosef Bacik const char *path); 65112bd2fc0SIlya Dryomov struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info, 652*bb21e302SAnand Jain const u64 *devid, const u8 *uuid, 653*bb21e302SAnand Jain const char *path); 654faa775c4SJosef Bacik void btrfs_put_dev_args_from_path(struct btrfs_dev_lookup_args *args); 655a425f9d4SDavid Sterba void btrfs_free_device(struct btrfs_device *device); 6562ff7e61eSJeff Mahoney int btrfs_rm_device(struct btrfs_fs_info *fs_info, 6571a15eb72SJosef Bacik struct btrfs_dev_lookup_args *args, 6583fa421deSJosef Bacik struct block_device **bdev, fmode_t *mode); 659ffc5a379SDavid Sterba void __exit btrfs_cleanup_fs_uuids(void); 6605d964051SStefan Behrens int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len); 6618f18cf13SChris Mason int btrfs_grow_device(struct btrfs_trans_handle *trans, 6628f18cf13SChris Mason struct btrfs_device *device, u64 new_size); 663562d7b15SJosef Bacik struct btrfs_device *btrfs_find_device(const struct btrfs_fs_devices *fs_devices, 664562d7b15SJosef Bacik const struct btrfs_dev_lookup_args *args); 6658f18cf13SChris Mason int btrfs_shrink_device(struct btrfs_device *device, u64 new_size); 666da353f6bSDavid Sterba int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path); 6676fcf6e2bSDavid Sterba int btrfs_balance(struct btrfs_fs_info *fs_info, 6686fcf6e2bSDavid Sterba struct btrfs_balance_control *bctl, 669c9e9f97bSIlya Dryomov struct btrfs_ioctl_balance_args *bargs); 670f89e09cfSAnand Jain void btrfs_describe_block_groups(u64 flags, char *buf, u32 size_buf); 6712b6ba629SIlya Dryomov int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info); 67268310a5eSIlya Dryomov int btrfs_recover_balance(struct btrfs_fs_info *fs_info); 673837d5b6eSIlya Dryomov int btrfs_pause_balance(struct btrfs_fs_info *fs_info); 67418bb8bbfSJohannes Thumshirn int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset); 675a7e99c69SIlya Dryomov int btrfs_cancel_balance(struct btrfs_fs_info *fs_info); 676f7a81ea4SStefan Behrens int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info); 67797f4dd09SNikolay Borisov int btrfs_uuid_scan_kthread(void *data); 678a09f23c3SAnand Jain bool btrfs_chunk_writeable(struct btrfs_fs_info *fs_info, u64 chunk_offset); 67960dfdf25SNikolay Borisov int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes, 680ba1bf481SJosef Bacik u64 *start, u64 *max_avail); 681442a4f63SStefan Behrens void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index); 6822ff7e61eSJeff Mahoney int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info, 683b27f7c0cSDavid Sterba struct btrfs_ioctl_get_dev_stats *stats); 684a8d1b164SJohannes Thumshirn int btrfs_init_devices_late(struct btrfs_fs_info *fs_info); 685733f4fbbSStefan Behrens int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info); 686196c9d8dSDavid Sterba int btrfs_run_dev_stats(struct btrfs_trans_handle *trans); 68768a9db5fSNikolay Borisov void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_device *srcdev); 68865237ee3SDavid Sterba void btrfs_rm_dev_replace_free_srcdev(struct btrfs_device *srcdev); 6894f5ad7bdSNikolay Borisov void btrfs_destroy_dev_replace_tgtdev(struct btrfs_device *tgtdev); 690592d92eeSLiu Bo int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info, 691e4ff5fb5SNikolay Borisov u64 logical, u64 len); 6922ff7e61eSJeff Mahoney unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info, 69353b381b3SDavid Woodhouse u64 logical); 694bc88b486SQu Wenruo u64 btrfs_calc_stripe_length(const struct extent_map *em); 6950b30f719SQu Wenruo int btrfs_nr_parity_stripes(u64 type); 69679bd3712SFilipe Manana int btrfs_chunk_alloc_add_chunk_item(struct btrfs_trans_handle *trans, 69779bd3712SFilipe Manana struct btrfs_block_group *bg); 69897aff912SNikolay Borisov int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset); 69960ca842eSOmar Sandoval struct extent_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info, 70060ca842eSOmar Sandoval u64 logical, u64 length); 7018f32380dSJohannes Thumshirn void btrfs_release_disk_super(struct btrfs_super_block *super); 702addc3fa7SMiao Xie 703442a4f63SStefan Behrens static inline void btrfs_dev_stat_inc(struct btrfs_device *dev, 704442a4f63SStefan Behrens int index) 705442a4f63SStefan Behrens { 706442a4f63SStefan Behrens atomic_inc(dev->dev_stat_values + index); 7079deae968SNikolay Borisov /* 7089deae968SNikolay Borisov * This memory barrier orders stores updating statistics before stores 7099deae968SNikolay Borisov * updating dev_stats_ccnt. 7109deae968SNikolay Borisov * 7119deae968SNikolay Borisov * It pairs with smp_rmb() in btrfs_run_dev_stats(). 7129deae968SNikolay Borisov */ 713addc3fa7SMiao Xie smp_mb__before_atomic(); 714addc3fa7SMiao Xie atomic_inc(&dev->dev_stats_ccnt); 715442a4f63SStefan Behrens } 716442a4f63SStefan Behrens 717442a4f63SStefan Behrens static inline int btrfs_dev_stat_read(struct btrfs_device *dev, 718442a4f63SStefan Behrens int index) 719442a4f63SStefan Behrens { 720442a4f63SStefan Behrens return atomic_read(dev->dev_stat_values + index); 721442a4f63SStefan Behrens } 722442a4f63SStefan Behrens 723442a4f63SStefan Behrens static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev, 724442a4f63SStefan Behrens int index) 725442a4f63SStefan Behrens { 726442a4f63SStefan Behrens int ret; 727442a4f63SStefan Behrens 728442a4f63SStefan Behrens ret = atomic_xchg(dev->dev_stat_values + index, 0); 7294660c49fSNikolay Borisov /* 7304660c49fSNikolay Borisov * atomic_xchg implies a full memory barriers as per atomic_t.txt: 7314660c49fSNikolay Borisov * - RMW operations that have a return value are fully ordered; 7324660c49fSNikolay Borisov * 7334660c49fSNikolay Borisov * This implicit memory barriers is paired with the smp_rmb in 7344660c49fSNikolay Borisov * btrfs_run_dev_stats 7354660c49fSNikolay Borisov */ 736addc3fa7SMiao Xie atomic_inc(&dev->dev_stats_ccnt); 737442a4f63SStefan Behrens return ret; 738442a4f63SStefan Behrens } 739442a4f63SStefan Behrens 740442a4f63SStefan Behrens static inline void btrfs_dev_stat_set(struct btrfs_device *dev, 741442a4f63SStefan Behrens int index, unsigned long val) 742442a4f63SStefan Behrens { 743442a4f63SStefan Behrens atomic_set(dev->dev_stat_values + index, val); 7449deae968SNikolay Borisov /* 7459deae968SNikolay Borisov * This memory barrier orders stores updating statistics before stores 7469deae968SNikolay Borisov * updating dev_stats_ccnt. 7479deae968SNikolay Borisov * 7489deae968SNikolay Borisov * It pairs with smp_rmb() in btrfs_run_dev_stats(). 7499deae968SNikolay Borisov */ 750addc3fa7SMiao Xie smp_mb__before_atomic(); 751addc3fa7SMiao Xie atomic_inc(&dev->dev_stats_ccnt); 752442a4f63SStefan Behrens } 753442a4f63SStefan Behrens 754bbbf7243SNikolay Borisov void btrfs_commit_device_sizes(struct btrfs_transaction *trans); 75504216820SFilipe Manana 7564143cb8bSDavid Sterba struct list_head * __attribute_const__ btrfs_get_fs_uuids(void); 7576528b99dSAnand Jain bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info, 7586528b99dSAnand Jain struct btrfs_device *failing_dev); 759313b0858SJosef Bacik void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info, 760313b0858SJosef Bacik struct block_device *bdev, 761313b0858SJosef Bacik const char *device_path); 76221634a19SQu Wenruo 763500a44c9SDavid Sterba enum btrfs_raid_types __attribute_const__ btrfs_bg_flags_to_raid_index(u64 flags); 76446df06b8SDavid Sterba int btrfs_bg_type_to_factor(u64 flags); 765158da513SDavid Sterba const char *btrfs_bg_type_to_raid_name(u64 flags); 766cf90d884SQu Wenruo int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info); 767554aed7dSJohannes Thumshirn bool btrfs_repair_one_zone(struct btrfs_fs_info *fs_info, u64 logical); 76846df06b8SDavid Sterba 769c2e79e86SJosef Bacik bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr); 770c2e79e86SJosef Bacik 7710b86a832SChris Mason #endif 772