blob: b30d018fa3594c28ba2ff4dbbf8ac47b4e050f77 [file] [log] [blame]
Chris Mason0b86a832008-03-24 15:01:56 -04001/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19#ifndef __BTRFS_VOLUMES_
20#define __BTRFS_VOLUMES_
Chris Mason8790d502008-04-03 16:29:03 -040021
Chris Masoncea9e442008-04-09 16:28:12 -040022#include <linux/bio.h>
Miao Xieb2117a32011-01-05 10:07:28 +000023#include <linux/sort.h>
Filipe Brandenburger55e301f2013-01-29 06:04:50 +000024#include <linux/btrfs.h>
Chris Mason8b712842008-06-11 16:50:36 -040025#include "async-thread.h"
Chris Masoncea9e442008-04-09 16:28:12 -040026
Miao Xieb2117a32011-01-05 10:07:28 +000027#define BTRFS_STRIPE_LEN (64 * 1024)
28
Chris Masonf2984462008-04-10 16:19:33 -040029struct buffer_head;
Chris Masonffbd5172009-04-20 15:50:09 -040030struct btrfs_pending_bios {
31 struct bio *head;
32 struct bio *tail;
33};
34
Chris Mason0b86a832008-03-24 15:01:56 -040035struct btrfs_device {
36 struct list_head dev_list;
Chris Masonb3075712008-04-22 09:22:07 -040037 struct list_head dev_alloc_list;
Yan Zheng2b820322008-11-17 21:11:30 -050038 struct btrfs_fs_devices *fs_devices;
Miao Xied5ee37b2014-07-24 11:37:10 +080039
Chris Mason0b86a832008-03-24 15:01:56 -040040 struct btrfs_root *dev_root;
Chris Masonffbd5172009-04-20 15:50:09 -040041
Miao Xied5ee37b2014-07-24 11:37:10 +080042 struct rcu_string *name;
43
44 u64 generation;
45
46 spinlock_t io_lock ____cacheline_aligned;
47 int running_pending;
Chris Masonffbd5172009-04-20 15:50:09 -040048 /* regular prio bios */
49 struct btrfs_pending_bios pending_bios;
50 /* WRITE_SYNC bios */
51 struct btrfs_pending_bios pending_sync_bios;
52
Miao Xied5ee37b2014-07-24 11:37:10 +080053 struct block_device *bdev;
54
55 /* the mode sent to blkdev_get */
56 fmode_t mode;
57
Yan Zheng2b820322008-11-17 21:11:30 -050058 int writeable;
Chris Masondfe25022008-05-13 13:46:40 -040059 int in_fs_metadata;
Chris Masoncd02dca2010-12-13 14:56:23 -050060 int missing;
Josef Bacikd5e20032011-08-04 14:52:27 +000061 int can_discard;
Stefan Behrens63a212a2012-11-05 18:29:28 +010062 int is_tgtdev_for_dev_replace;
Chris Masonb3075712008-04-22 09:22:07 -040063
Chris Mason0b86a832008-03-24 15:01:56 -040064 /* the internal btrfs device id */
65 u64 devid;
66
Miao Xie6ba40b62014-07-24 11:37:12 +080067 /* size of the device in memory */
Chris Mason0b86a832008-03-24 15:01:56 -040068 u64 total_bytes;
69
Miao Xie6ba40b62014-07-24 11:37:12 +080070 /* size of the device on disk */
Chris Balld6397ba2009-04-27 07:29:03 -040071 u64 disk_total_bytes;
72
Chris Mason0b86a832008-03-24 15:01:56 -040073 /* bytes used */
74 u64 bytes_used;
75
76 /* optimal io alignment for this device */
77 u32 io_align;
78
79 /* optimal io width for this device */
80 u32 io_width;
Dulshani Gunawardhana3c45bfc2013-10-31 09:57:33 +053081 /* type and info about this device */
82 u64 type;
Chris Mason0b86a832008-03-24 15:01:56 -040083
84 /* minimal io size for this device */
85 u32 sector_size;
86
Chris Mason0b86a832008-03-24 15:01:56 -040087 /* physical drive uuid (or lvm uuid) */
Chris Masone17cade2008-04-15 15:41:47 -040088 u8 uuid[BTRFS_UUID_SIZE];
Chris Mason8b712842008-06-11 16:50:36 -040089
Miao Xie935e5cc2014-09-03 21:35:33 +080090 /*
91 * size of the device on the current transaction
92 *
93 * This variant is update when committing the transaction,
94 * and protected by device_list_mutex
95 */
96 u64 commit_total_bytes;
97
98 /*
99 * used to manage the device which is resized
100 *
101 * It is protected by chunk_lock.
102 */
103 struct list_head resized_list;
104
Dulshani Gunawardhana3c45bfc2013-10-31 09:57:33 +0530105 /* for sending down flush barriers */
106 int nobarriers;
107 struct bio *flush_bio;
108 struct completion flush_wait;
109
Arne Jansena2de7332011-03-08 14:14:00 +0100110 /* per-device scrub information */
Stefan Behrensd9d181c2012-11-02 09:58:09 +0100111 struct scrub_ctx *scrub_device;
Arne Jansena2de7332011-03-08 14:14:00 +0100112
Qu Wenruod458b052014-02-28 10:46:19 +0800113 struct btrfs_work work;
Xiao Guangrong1f781602011-04-20 10:09:16 +0000114 struct rcu_head rcu;
115 struct work_struct rcu_work;
Arne Jansen90519d62011-05-23 14:30:00 +0200116
117 /* readahead state */
118 spinlock_t reada_lock;
119 atomic_t reada_in_flight;
120 u64 reada_next;
121 struct reada_zone *reada_curr_zone;
122 struct radix_tree_root reada_zones;
123 struct radix_tree_root reada_extents;
Chris Mason387125f2011-11-18 15:07:51 -0500124
Stefan Behrens442a4f62012-05-25 16:06:08 +0200125 /* disk I/O failure stats. For detailed description refer to
126 * enum btrfs_dev_stat_values in ioctl.h */
Stefan Behrens733f4fb2012-05-25 16:06:10 +0200127 int dev_stats_valid;
Miao Xieaddc3fa2014-07-24 11:37:11 +0800128
129 /* Counter to record the change of device stats */
130 atomic_t dev_stats_ccnt;
Stefan Behrens442a4f62012-05-25 16:06:08 +0200131 atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX];
Chris Mason0b86a832008-03-24 15:01:56 -0400132};
133
Chris Mason8a4b83c2008-03-24 15:02:07 -0400134struct btrfs_fs_devices {
135 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
136
Chris Mason8a4b83c2008-03-24 15:02:07 -0400137 u64 num_devices;
Chris Masona0af4692008-05-13 16:03:06 -0400138 u64 open_devices;
Yan Zheng2b820322008-11-17 21:11:30 -0500139 u64 rw_devices;
Chris Masoncd02dca2010-12-13 14:56:23 -0500140 u64 missing_devices;
Yan Zheng2b820322008-11-17 21:11:30 -0500141 u64 total_rw_bytes;
Josef Bacik02db0842012-06-21 16:03:58 -0400142 u64 total_devices;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400143 struct block_device *latest_bdev;
Chris Masone5e9a522009-06-10 15:17:02 -0400144
145 /* all of the devices in the FS, protected by a mutex
146 * so we can safely walk it to write out the supers without
Wang Shilong9b011ad2013-10-25 19:12:02 +0800147 * worrying about add/remove by the multi-device code.
148 * Scrubbing super can kick off supers writing by holding
149 * this mutex lock.
Chris Masone5e9a522009-06-10 15:17:02 -0400150 */
151 struct mutex device_list_mutex;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400152 struct list_head devices;
Chris Masonb3075712008-04-22 09:22:07 -0400153
Miao Xie935e5cc2014-09-03 21:35:33 +0800154 struct list_head resized_devices;
Chris Masonb3075712008-04-22 09:22:07 -0400155 /* devices not currently being allocated */
156 struct list_head alloc_list;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400157 struct list_head list;
Yan Zheng2b820322008-11-17 21:11:30 -0500158
159 struct btrfs_fs_devices *seed;
160 int seeding;
Yan Zheng2b820322008-11-17 21:11:30 -0500161
162 int opened;
Chris Masonc2898112009-06-10 09:51:32 -0400163
164 /* set when we find or add a device that doesn't have the
165 * nonrot flag set
166 */
167 int rotating;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400168};
169
Miao Xiefacc8a222013-07-25 19:22:34 +0800170#define BTRFS_BIO_INLINE_CSUM_SIZE 64
171
Chris Mason9be33952013-05-17 18:30:14 -0400172/*
173 * we need the mirror number and stripe index to be passed around
174 * the call chain while we are processing end_io (especially errors).
175 * Really, what we need is a btrfs_bio structure that has this info
176 * and is properly sized with its stripe array, but we're not there
177 * quite yet. We have our own btrfs bioset, and all of the bios
178 * we allocate are actually btrfs_io_bios. We'll cram as much of
179 * struct btrfs_bio as we can into this over time.
180 */
Miao Xiefacc8a222013-07-25 19:22:34 +0800181typedef void (btrfs_io_bio_end_io_t) (struct btrfs_io_bio *bio, int err);
Chris Mason9be33952013-05-17 18:30:14 -0400182struct btrfs_io_bio {
183 unsigned long mirror_num;
184 unsigned long stripe_index;
Miao Xiefacc8a222013-07-25 19:22:34 +0800185 u8 *csum;
186 u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE];
187 u8 *csum_allocated;
188 btrfs_io_bio_end_io_t *end_io;
Chris Mason9be33952013-05-17 18:30:14 -0400189 struct bio bio;
190};
191
192static inline struct btrfs_io_bio *btrfs_io_bio(struct bio *bio)
193{
194 return container_of(bio, struct btrfs_io_bio, bio);
195}
196
Chris Masoncea9e442008-04-09 16:28:12 -0400197struct btrfs_bio_stripe {
198 struct btrfs_device *dev;
199 u64 physical;
Li Dongyangfce3bb92011-03-24 10:24:26 +0000200 u64 length; /* only used for discard mappings */
Chris Masoncea9e442008-04-09 16:28:12 -0400201};
202
Jan Schmidta1d3c472011-08-04 17:15:33 +0200203struct btrfs_bio;
204typedef void (btrfs_bio_end_io_t) (struct btrfs_bio *bio, int err);
205
Miao Xiec55f1392014-06-19 10:42:54 +0800206#define BTRFS_BIO_ORIG_BIO_SUBMITTED 0x1
207
Jan Schmidta1d3c472011-08-04 17:15:33 +0200208struct btrfs_bio {
Chris Masoncea9e442008-04-09 16:28:12 -0400209 atomic_t stripes_pending;
Miao Xiec404e0d2014-01-30 16:46:55 +0800210 struct btrfs_fs_info *fs_info;
Chris Masoncea9e442008-04-09 16:28:12 -0400211 bio_end_io_t *end_io;
Chris Mason7d2b4da2008-08-05 10:13:57 -0400212 struct bio *orig_bio;
Miao Xiec55f1392014-06-19 10:42:54 +0800213 unsigned long flags;
Chris Masoncea9e442008-04-09 16:28:12 -0400214 void *private;
Chris Masona236aed2008-04-29 09:38:00 -0400215 atomic_t error;
216 int max_errors;
Chris Masoncea9e442008-04-09 16:28:12 -0400217 int num_stripes;
Jan Schmidta1d3c472011-08-04 17:15:33 +0200218 int mirror_num;
Chris Masoncea9e442008-04-09 16:28:12 -0400219 struct btrfs_bio_stripe stripes[];
220};
221
Miao Xieb2117a32011-01-05 10:07:28 +0000222struct btrfs_device_info {
223 struct btrfs_device *dev;
224 u64 dev_offset;
225 u64 max_avail;
Arne Jansen73c5de02011-04-12 12:07:57 +0200226 u64 total_avail;
Miao Xieb2117a32011-01-05 10:07:28 +0000227};
228
Liu Bo31e50222012-11-21 14:18:10 +0000229struct btrfs_raid_attr {
230 int sub_stripes; /* sub_stripes info for map */
231 int dev_stripes; /* stripes per dev */
232 int devs_max; /* max devs to use */
233 int devs_min; /* min devs needed */
234 int devs_increment; /* ndevs has to be a multiple of this */
235 int ncopies; /* how many copies to data has */
236};
237
liubo1abe9b82011-03-24 11:18:59 +0000238struct map_lookup {
239 u64 type;
240 int io_align;
241 int io_width;
242 int stripe_len;
243 int sector_size;
244 int num_stripes;
245 int sub_stripes;
246 struct btrfs_bio_stripe stripes[];
247};
248
Arne Jansena2de7332011-03-08 14:14:00 +0100249#define map_lookup_size(n) (sizeof(struct map_lookup) + \
250 (sizeof(struct btrfs_bio_stripe) * (n)))
251
Ilya Dryomovf43ffb62012-01-16 22:04:47 +0200252/*
253 * Restriper's general type filter
254 */
255#define BTRFS_BALANCE_DATA (1ULL << 0)
256#define BTRFS_BALANCE_SYSTEM (1ULL << 1)
257#define BTRFS_BALANCE_METADATA (1ULL << 2)
258
259#define BTRFS_BALANCE_TYPE_MASK (BTRFS_BALANCE_DATA | \
260 BTRFS_BALANCE_SYSTEM | \
261 BTRFS_BALANCE_METADATA)
Ilya Dryomove4d8ec02012-01-16 22:04:48 +0200262
263#define BTRFS_BALANCE_FORCE (1ULL << 3)
Ilya Dryomov59641012012-01-16 22:04:48 +0200264#define BTRFS_BALANCE_RESUME (1ULL << 4)
Ilya Dryomove4d8ec02012-01-16 22:04:48 +0200265
Ilya Dryomoved25e9b2012-01-16 22:04:47 +0200266/*
267 * Balance filters
268 */
269#define BTRFS_BALANCE_ARGS_PROFILES (1ULL << 0)
Ilya Dryomov5ce5b3c2012-01-16 22:04:47 +0200270#define BTRFS_BALANCE_ARGS_USAGE (1ULL << 1)
Ilya Dryomov409d4042012-01-16 22:04:47 +0200271#define BTRFS_BALANCE_ARGS_DEVID (1ULL << 2)
Ilya Dryomov94e60d52012-01-16 22:04:48 +0200272#define BTRFS_BALANCE_ARGS_DRANGE (1ULL << 3)
Ilya Dryomovea671762012-01-16 22:04:48 +0200273#define BTRFS_BALANCE_ARGS_VRANGE (1ULL << 4)
David Sterba7d824b62014-05-07 17:37:51 +0200274#define BTRFS_BALANCE_ARGS_LIMIT (1ULL << 5)
Ilya Dryomovf43ffb62012-01-16 22:04:47 +0200275
Ilya Dryomovcfa4c962012-01-16 22:04:48 +0200276/*
277 * Profile changing flags. When SOFT is set we won't relocate chunk if
278 * it already has the target profile (even though it may be
279 * half-filled).
280 */
Ilya Dryomove4d8ec02012-01-16 22:04:48 +0200281#define BTRFS_BALANCE_ARGS_CONVERT (1ULL << 8)
Ilya Dryomovcfa4c962012-01-16 22:04:48 +0200282#define BTRFS_BALANCE_ARGS_SOFT (1ULL << 9)
Ilya Dryomove4d8ec02012-01-16 22:04:48 +0200283
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200284struct btrfs_balance_args;
Ilya Dryomov19a39dc2012-01-16 22:04:49 +0200285struct btrfs_balance_progress;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200286struct btrfs_balance_control {
287 struct btrfs_fs_info *fs_info;
288
289 struct btrfs_balance_args data;
290 struct btrfs_balance_args meta;
291 struct btrfs_balance_args sys;
292
293 u64 flags;
Ilya Dryomov19a39dc2012-01-16 22:04:49 +0200294
295 struct btrfs_balance_progress stat;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200296};
297
Miao Xie6d07bce2011-01-05 10:07:31 +0000298int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
299 u64 end, u64 *length);
300
Jan Schmidta1d3c472011-08-04 17:15:33 +0200301#define btrfs_bio_size(n) (sizeof(struct btrfs_bio) + \
Chris Masoncea9e442008-04-09 16:28:12 -0400302 (sizeof(struct btrfs_bio_stripe) * (n)))
303
Stefan Behrens3ec706c2012-11-05 15:46:42 +0100304int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
Chris Masoncea9e442008-04-09 16:28:12 -0400305 u64 logical, u64 *length,
Jan Schmidta1d3c472011-08-04 17:15:33 +0200306 struct btrfs_bio **bbio_ret, int mirror_num);
Yan Zhenga512bbf2008-12-08 16:46:26 -0500307int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
308 u64 chunk_start, u64 physical, u64 devid,
309 u64 **logical, int *naddrs, int *stripe_len);
Yan Zhenge4404d62008-12-12 10:03:26 -0500310int btrfs_read_sys_array(struct btrfs_root *root);
Chris Mason0b86a832008-03-24 15:01:56 -0400311int btrfs_read_chunk_tree(struct btrfs_root *root);
312int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
Yan Zheng2b820322008-11-17 21:11:30 -0500313 struct btrfs_root *extent_root, u64 type);
Chris Mason0b86a832008-03-24 15:01:56 -0400314void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
315void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
Chris Masonf1885912008-04-09 16:28:12 -0400316int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
Chris Mason8b712842008-06-11 16:50:36 -0400317 int mirror_num, int async_submit);
Chris Mason8a4b83c2008-03-24 15:02:07 -0400318int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
Christoph Hellwig97288f22008-12-02 06:36:09 -0500319 fmode_t flags, void *holder);
320int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
Chris Mason8a4b83c2008-03-24 15:02:07 -0400321 struct btrfs_fs_devices **fs_devices_ret);
322int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
Stefan Behrens8dabb742012-11-06 13:15:27 +0100323void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info,
324 struct btrfs_fs_devices *fs_devices, int step);
Stefan Behrens7ba15b72012-11-05 14:42:30 +0100325int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
326 char *device_path,
327 struct btrfs_device **device);
Ilya Dryomov12bd2fc2013-08-23 13:20:17 +0300328struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
329 const u64 *devid,
330 const u8 *uuid);
Chris Masona061fc82008-05-07 11:43:44 -0400331int btrfs_rm_device(struct btrfs_root *root, char *device_path);
Jeff Mahoney143bede2012-03-01 14:56:26 +0100332void btrfs_cleanup_fs_uuids(void);
Stefan Behrens5d964052012-11-05 14:59:07 +0100333int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
Chris Mason8f18cf12008-04-25 16:53:30 -0400334int btrfs_grow_device(struct btrfs_trans_handle *trans,
335 struct btrfs_device *device, u64 new_size);
Stefan Behrensaa1b8cd2012-11-05 17:03:39 +0100336struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
Yan Zheng2b820322008-11-17 21:11:30 -0500337 u8 *uuid, u8 *fsid);
Chris Mason8f18cf12008-04-25 16:53:30 -0400338int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
Chris Mason788f20e2008-04-28 15:29:42 -0400339int btrfs_init_new_device(struct btrfs_root *root, char *path);
Stefan Behrense93c89c2012-11-05 17:33:06 +0100340int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
Miao Xie1c433662014-09-03 21:35:32 +0800341 struct btrfs_device *srcdev,
Stefan Behrense93c89c2012-11-05 17:33:06 +0100342 struct btrfs_device **device_out);
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200343int btrfs_balance(struct btrfs_balance_control *bctl,
344 struct btrfs_ioctl_balance_args *bargs);
Ilya Dryomov2b6ba622012-06-22 12:24:13 -0600345int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
Ilya Dryomov68310a52012-06-22 12:24:12 -0600346int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
Ilya Dryomov837d5b62012-01-16 22:04:49 +0200347int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
Ilya Dryomova7e99c62012-01-16 22:04:49 +0200348int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
Stefan Behrensf7a81ea2013-08-15 17:11:19 +0200349int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info);
Stefan Behrens70f80172013-08-15 17:11:23 +0200350int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info);
Yan Zheng2b820322008-11-17 21:11:30 -0500351int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
Josef Bacik6df9a952013-06-27 13:22:46 -0400352int find_free_dev_extent(struct btrfs_trans_handle *trans,
353 struct btrfs_device *device, u64 num_bytes,
Josef Bacikba1bf482009-09-11 16:11:19 -0400354 u64 *start, u64 *max_avail);
Stefan Behrens442a4f62012-05-25 16:06:08 +0200355void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
Stefan Behrensc11d2c22012-05-25 16:06:09 +0200356int btrfs_get_dev_stats(struct btrfs_root *root,
David Sterbab27f7c02012-06-22 06:30:39 -0600357 struct btrfs_ioctl_get_dev_stats *stats);
Miao Xiecb517ea2013-05-15 07:48:19 +0000358void btrfs_init_devices_late(struct btrfs_fs_info *fs_info);
Stefan Behrens733f4fb2012-05-25 16:06:10 +0200359int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);
360int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
361 struct btrfs_fs_info *fs_info);
Stefan Behrense93c89c2012-11-05 17:33:06 +0100362void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
363 struct btrfs_device *srcdev);
364void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
365 struct btrfs_device *tgtdev);
366void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
367 struct btrfs_device *tgtdev);
Stefan Behrensa8a6dab2012-11-05 15:50:14 +0100368int btrfs_scratch_superblock(struct btrfs_device *device);
David Woodhouse53b381b2013-01-29 18:40:14 -0500369int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree,
370 u64 logical, u64 len, int mirror_num);
371unsigned long btrfs_full_stripe_len(struct btrfs_root *root,
372 struct btrfs_mapping_tree *map_tree,
373 u64 logical);
Josef Bacik6df9a952013-06-27 13:22:46 -0400374int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
375 struct btrfs_root *extent_root,
376 u64 chunk_offset, u64 chunk_size);
Miao Xieaddc3fa2014-07-24 11:37:11 +0800377
378static inline int btrfs_dev_stats_dirty(struct btrfs_device *dev)
379{
380 return atomic_read(&dev->dev_stats_ccnt);
381}
382
Stefan Behrens442a4f62012-05-25 16:06:08 +0200383static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
384 int index)
385{
386 atomic_inc(dev->dev_stat_values + index);
Miao Xieaddc3fa2014-07-24 11:37:11 +0800387 smp_mb__before_atomic();
388 atomic_inc(&dev->dev_stats_ccnt);
Stefan Behrens442a4f62012-05-25 16:06:08 +0200389}
390
391static inline int btrfs_dev_stat_read(struct btrfs_device *dev,
392 int index)
393{
394 return atomic_read(dev->dev_stat_values + index);
395}
396
397static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev,
398 int index)
399{
400 int ret;
401
402 ret = atomic_xchg(dev->dev_stat_values + index, 0);
Miao Xieaddc3fa2014-07-24 11:37:11 +0800403 smp_mb__before_atomic();
404 atomic_inc(&dev->dev_stats_ccnt);
Stefan Behrens442a4f62012-05-25 16:06:08 +0200405 return ret;
406}
407
408static inline void btrfs_dev_stat_set(struct btrfs_device *dev,
409 int index, unsigned long val)
410{
411 atomic_set(dev->dev_stat_values + index, val);
Miao Xieaddc3fa2014-07-24 11:37:11 +0800412 smp_mb__before_atomic();
413 atomic_inc(&dev->dev_stats_ccnt);
Stefan Behrens442a4f62012-05-25 16:06:08 +0200414}
415
416static inline void btrfs_dev_stat_reset(struct btrfs_device *dev,
417 int index)
418{
419 btrfs_dev_stat_set(dev, index, 0);
420}
Miao Xie935e5cc2014-09-03 21:35:33 +0800421
422void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info);
Chris Mason0b86a832008-03-24 15:01:56 -0400423#endif