1 /*
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_
21
22 #include <linux/bio.h>
23 #include <linux/sort.h>
24 #include <linux/btrfs.h>
25 #include "async-thread.h"
26
27 #define BTRFS_MAX_DATA_CHUNK_SIZE (10ULL * SZ_1G)
28
29 extern struct mutex uuid_mutex;
30
31 #define BTRFS_STRIPE_LEN SZ_64K
32
33 struct buffer_head;
34 struct btrfs_pending_bios {
35 struct bio *head;
36 struct bio *tail;
37 };
38
39 /*
40 * Use sequence counter to get consistent device stat data on
41 * 32-bit processors.
42 */
43 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
44 #include <linux/seqlock.h>
45 #define __BTRFS_NEED_DEVICE_DATA_ORDERED
46 #define btrfs_device_data_ordered_init(device) \
47 seqcount_init(&device->data_seqcount)
48 #else
49 #define btrfs_device_data_ordered_init(device) do { } while (0)
50 #endif
51
52 struct btrfs_device {
53 struct list_head dev_list;
54 struct list_head dev_alloc_list;
55 struct btrfs_fs_devices *fs_devices;
56 struct btrfs_fs_info *fs_info;
57
58 struct rcu_string *name;
59
60 u64 generation;
61
62 spinlock_t io_lock ____cacheline_aligned;
63 int running_pending;
64 /* When true means this device has pending chunk alloc in
65 * current transaction. Protected by chunk_mutex.
66 */
67 bool has_pending_chunks;
68
69 /* regular prio bios */
70 struct btrfs_pending_bios pending_bios;
71 /* sync bios */
72 struct btrfs_pending_bios pending_sync_bios;
73
74 struct block_device *bdev;
75
76 /* the mode sent to blkdev_get */
77 fmode_t mode;
78
79 int writeable;
80 int in_fs_metadata;
81 int missing;
82 int can_discard;
83 int is_tgtdev_for_dev_replace;
84 blk_status_t last_flush_error;
85 int flush_bio_sent;
86
87 #ifdef __BTRFS_NEED_DEVICE_DATA_ORDERED
88 seqcount_t data_seqcount;
89 #endif
90
91 /* the internal btrfs device id */
92 u64 devid;
93
94 /* size of the device in memory */
95 u64 total_bytes;
96
97 /* size of the device on disk */
98 u64 disk_total_bytes;
99
100 /* bytes used */
101 u64 bytes_used;
102
103 /* optimal io alignment for this device */
104 u32 io_align;
105
106 /* optimal io width for this device */
107 u32 io_width;
108 /* type and info about this device */
109 u64 type;
110
111 /* minimal io size for this device */
112 u32 sector_size;
113
114 /* physical drive uuid (or lvm uuid) */
115 u8 uuid[BTRFS_UUID_SIZE];
116
117 /*
118 * size of the device on the current transaction
119 *
120 * This variant is update when committing the transaction,
121 * and protected by device_list_mutex
122 */
123 u64 commit_total_bytes;
124
125 /* bytes used on the current transaction */
126 u64 commit_bytes_used;
127 /*
128 * used to manage the device which is resized
129 *
130 * It is protected by chunk_lock.
131 */
132 struct list_head resized_list;
133
134 /* for sending down flush barriers */
135 struct bio *flush_bio;
136 struct completion flush_wait;
137
138 /* per-device scrub information */
139 struct scrub_ctx *scrub_device;
140
141 struct btrfs_work work;
142 struct rcu_head rcu;
143 struct work_struct rcu_work;
144
145 /* readahead state */
146 spinlock_t reada_lock;
147 atomic_t reada_in_flight;
148 u64 reada_next;
149 struct reada_zone *reada_curr_zone;
150 struct radix_tree_root reada_zones;
151 struct radix_tree_root reada_extents;
152
153 /* disk I/O failure stats. For detailed description refer to
154 * enum btrfs_dev_stat_values in ioctl.h */
155 int dev_stats_valid;
156
157 /* Counter to record the change of device stats */
158 atomic_t dev_stats_ccnt;
159 atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX];
160 };
161
162 /*
163 * If we read those variants at the context of their own lock, we needn't
164 * use the following helpers, reading them directly is safe.
165 */
166 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
167 #define BTRFS_DEVICE_GETSET_FUNCS(name) \
168 static inline u64 \
169 btrfs_device_get_##name(const struct btrfs_device *dev) \
170 { \
171 u64 size; \
172 unsigned int seq; \
173 \
174 do { \
175 seq = read_seqcount_begin(&dev->data_seqcount); \
176 size = dev->name; \
177 } while (read_seqcount_retry(&dev->data_seqcount, seq)); \
178 return size; \
179 } \
180 \
181 static inline void \
182 btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \
183 { \
184 preempt_disable(); \
185 write_seqcount_begin(&dev->data_seqcount); \
186 dev->name = size; \
187 write_seqcount_end(&dev->data_seqcount); \
188 preempt_enable(); \
189 }
190 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
191 #define BTRFS_DEVICE_GETSET_FUNCS(name) \
192 static inline u64 \
193 btrfs_device_get_##name(const struct btrfs_device *dev) \
194 { \
195 u64 size; \
196 \
197 preempt_disable(); \
198 size = dev->name; \
199 preempt_enable(); \
200 return size; \
201 } \
202 \
203 static inline void \
204 btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \
205 { \
206 preempt_disable(); \
207 dev->name = size; \
208 preempt_enable(); \
209 }
210 #else
211 #define BTRFS_DEVICE_GETSET_FUNCS(name) \
212 static inline u64 \
213 btrfs_device_get_##name(const struct btrfs_device *dev) \
214 { \
215 return dev->name; \
216 } \
217 \
218 static inline void \
219 btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \
220 { \
221 dev->name = size; \
222 }
223 #endif
224
225 BTRFS_DEVICE_GETSET_FUNCS(total_bytes);
226 BTRFS_DEVICE_GETSET_FUNCS(disk_total_bytes);
227 BTRFS_DEVICE_GETSET_FUNCS(bytes_used);
228
229 struct btrfs_fs_devices {
230 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
231
232 u64 num_devices;
233 u64 open_devices;
234 u64 rw_devices;
235 u64 missing_devices;
236 u64 total_rw_bytes;
237 u64 total_devices;
238 struct block_device *latest_bdev;
239
240 /* all of the devices in the FS, protected by a mutex
241 * so we can safely walk it to write out the supers without
242 * worrying about add/remove by the multi-device code.
243 * Scrubbing super can kick off supers writing by holding
244 * this mutex lock.
245 */
246 struct mutex device_list_mutex;
247 struct list_head devices;
248
249 struct list_head resized_devices;
250 /* devices not currently being allocated */
251 struct list_head alloc_list;
252 struct list_head list;
253
254 struct btrfs_fs_devices *seed;
255 int seeding;
256
257 int opened;
258
259 /* set when we find or add a device that doesn't have the
260 * nonrot flag set
261 */
262 int rotating;
263
264 struct btrfs_fs_info *fs_info;
265 /* sysfs kobjects */
266 struct kobject fsid_kobj;
267 struct kobject *device_dir_kobj;
268 struct completion kobj_unregister;
269 };
270
271 #define BTRFS_BIO_INLINE_CSUM_SIZE 64
272
273 /*
274 * we need the mirror number and stripe index to be passed around
275 * the call chain while we are processing end_io (especially errors).
276 * Really, what we need is a btrfs_bio structure that has this info
277 * and is properly sized with its stripe array, but we're not there
278 * quite yet. We have our own btrfs bioset, and all of the bios
279 * we allocate are actually btrfs_io_bios. We'll cram as much of
280 * struct btrfs_bio as we can into this over time.
281 */
282 typedef void (btrfs_io_bio_end_io_t) (struct btrfs_io_bio *bio, int err);
283 struct btrfs_io_bio {
284 unsigned int mirror_num;
285 unsigned int stripe_index;
286 u64 logical;
287 u8 *csum;
288 u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE];
289 u8 *csum_allocated;
290 btrfs_io_bio_end_io_t *end_io;
291 struct bvec_iter iter;
292 /*
293 * This member must come last, bio_alloc_bioset will allocate enough
294 * bytes for entire btrfs_io_bio but relies on bio being last.
295 */
296 struct bio bio;
297 };
298
btrfs_io_bio(struct bio * bio)299 static inline struct btrfs_io_bio *btrfs_io_bio(struct bio *bio)
300 {
301 return container_of(bio, struct btrfs_io_bio, bio);
302 }
303
304 struct btrfs_bio_stripe {
305 struct btrfs_device *dev;
306 u64 physical;
307 u64 length; /* only used for discard mappings */
308 };
309
310 struct btrfs_bio;
311 typedef void (btrfs_bio_end_io_t) (struct btrfs_bio *bio, int err);
312
313 struct btrfs_bio {
314 refcount_t refs;
315 atomic_t stripes_pending;
316 struct btrfs_fs_info *fs_info;
317 u64 map_type; /* get from map_lookup->type */
318 bio_end_io_t *end_io;
319 struct bio *orig_bio;
320 void *private;
321 atomic_t error;
322 int max_errors;
323 int num_stripes;
324 int mirror_num;
325 int num_tgtdevs;
326 int *tgtdev_map;
327 /*
328 * logical block numbers for the start of each stripe
329 * The last one or two are p/q. These are sorted,
330 * so raid_map[0] is the start of our full stripe
331 */
332 u64 *raid_map;
333 struct btrfs_bio_stripe stripes[];
334 };
335
336 struct btrfs_device_info {
337 struct btrfs_device *dev;
338 u64 dev_offset;
339 u64 max_avail;
340 u64 total_avail;
341 };
342
343 struct btrfs_raid_attr {
344 int sub_stripes; /* sub_stripes info for map */
345 int dev_stripes; /* stripes per dev */
346 int devs_max; /* max devs to use */
347 int devs_min; /* min devs needed */
348 int tolerated_failures; /* max tolerated fail devs */
349 int devs_increment; /* ndevs has to be a multiple of this */
350 int ncopies; /* how many copies to data has */
351 };
352
353 extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
354 extern const int btrfs_raid_mindev_error[BTRFS_NR_RAID_TYPES];
355 extern const u64 btrfs_raid_group[BTRFS_NR_RAID_TYPES];
356
357 struct map_lookup {
358 u64 type;
359 int io_align;
360 int io_width;
361 u64 stripe_len;
362 int num_stripes;
363 int sub_stripes;
364 struct btrfs_bio_stripe stripes[];
365 };
366
367 #define map_lookup_size(n) (sizeof(struct map_lookup) + \
368 (sizeof(struct btrfs_bio_stripe) * (n)))
369
370 struct btrfs_balance_args;
371 struct btrfs_balance_progress;
372 struct btrfs_balance_control {
373 struct btrfs_fs_info *fs_info;
374
375 struct btrfs_balance_args data;
376 struct btrfs_balance_args meta;
377 struct btrfs_balance_args sys;
378
379 u64 flags;
380
381 struct btrfs_balance_progress stat;
382 };
383
384 enum btrfs_map_op {
385 BTRFS_MAP_READ,
386 BTRFS_MAP_WRITE,
387 BTRFS_MAP_DISCARD,
388 BTRFS_MAP_GET_READ_MIRRORS,
389 };
390
btrfs_op(struct bio * bio)391 static inline enum btrfs_map_op btrfs_op(struct bio *bio)
392 {
393 switch (bio_op(bio)) {
394 case REQ_OP_DISCARD:
395 return BTRFS_MAP_DISCARD;
396 case REQ_OP_WRITE:
397 return BTRFS_MAP_WRITE;
398 default:
399 WARN_ON_ONCE(1);
400 case REQ_OP_READ:
401 return BTRFS_MAP_READ;
402 }
403 }
404
405 int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
406 u64 end, u64 *length);
407 void btrfs_get_bbio(struct btrfs_bio *bbio);
408 void btrfs_put_bbio(struct btrfs_bio *bbio);
409 int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
410 u64 logical, u64 *length,
411 struct btrfs_bio **bbio_ret, int mirror_num);
412 int btrfs_map_sblock(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
413 u64 logical, u64 *length,
414 struct btrfs_bio **bbio_ret);
415 int btrfs_rmap_block(struct btrfs_fs_info *fs_info,
416 u64 chunk_start, u64 physical, u64 devid,
417 u64 **logical, int *naddrs, int *stripe_len);
418 int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);
419 int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);
420 int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
421 struct btrfs_fs_info *fs_info, u64 type);
422 void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
423 void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
424 blk_status_t btrfs_map_bio(struct btrfs_fs_info *fs_info, struct bio *bio,
425 int mirror_num, int async_submit);
426 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
427 fmode_t flags, void *holder);
428 int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
429 struct btrfs_fs_devices **fs_devices_ret);
430 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
431 void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step);
432 void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info,
433 struct btrfs_device *device, struct btrfs_device *this_dev);
434 int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info,
435 const char *device_path,
436 struct btrfs_device **device);
437 int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid,
438 const char *devpath,
439 struct btrfs_device **device);
440 struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
441 const u64 *devid,
442 const u8 *uuid);
443 int btrfs_rm_device(struct btrfs_fs_info *fs_info,
444 const char *device_path, u64 devid);
445 void btrfs_cleanup_fs_uuids(void);
446 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
447 int btrfs_grow_device(struct btrfs_trans_handle *trans,
448 struct btrfs_device *device, u64 new_size);
449 struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
450 u8 *uuid, u8 *fsid);
451 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
452 int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path);
453 int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
454 const char *device_path,
455 struct btrfs_device *srcdev,
456 struct btrfs_device **device_out);
457 int btrfs_balance(struct btrfs_balance_control *bctl,
458 struct btrfs_ioctl_balance_args *bargs);
459 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
460 int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
461 int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
462 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
463 int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info);
464 int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info);
465 int btrfs_chunk_readonly(struct btrfs_fs_info *fs_info, u64 chunk_offset);
466 int find_free_dev_extent_start(struct btrfs_transaction *transaction,
467 struct btrfs_device *device, u64 num_bytes,
468 u64 search_start, u64 *start, u64 *max_avail);
469 int find_free_dev_extent(struct btrfs_trans_handle *trans,
470 struct btrfs_device *device, u64 num_bytes,
471 u64 *start, u64 *max_avail);
472 void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
473 int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,
474 struct btrfs_ioctl_get_dev_stats *stats);
475 void btrfs_init_devices_late(struct btrfs_fs_info *fs_info);
476 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);
477 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
478 struct btrfs_fs_info *fs_info);
479 void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info *fs_info,
480 struct btrfs_device *srcdev);
481 void btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info *fs_info,
482 struct btrfs_device *srcdev);
483 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
484 struct btrfs_device *tgtdev);
485 void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
486 struct btrfs_device *tgtdev);
487 void btrfs_scratch_superblocks(struct block_device *bdev, const char *device_path);
488 int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info,
489 u64 logical, u64 len);
490 unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,
491 u64 logical);
492 int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
493 struct btrfs_fs_info *fs_info,
494 u64 chunk_offset, u64 chunk_size);
495 int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
496 struct btrfs_fs_info *fs_info, u64 chunk_offset);
497
btrfs_dev_stats_dirty(struct btrfs_device * dev)498 static inline int btrfs_dev_stats_dirty(struct btrfs_device *dev)
499 {
500 return atomic_read(&dev->dev_stats_ccnt);
501 }
502
btrfs_dev_stat_inc(struct btrfs_device * dev,int index)503 static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
504 int index)
505 {
506 atomic_inc(dev->dev_stat_values + index);
507 /*
508 * This memory barrier orders stores updating statistics before stores
509 * updating dev_stats_ccnt.
510 *
511 * It pairs with smp_rmb() in btrfs_run_dev_stats().
512 */
513 smp_mb__before_atomic();
514 atomic_inc(&dev->dev_stats_ccnt);
515 }
516
btrfs_dev_stat_read(struct btrfs_device * dev,int index)517 static inline int btrfs_dev_stat_read(struct btrfs_device *dev,
518 int index)
519 {
520 return atomic_read(dev->dev_stat_values + index);
521 }
522
btrfs_dev_stat_read_and_reset(struct btrfs_device * dev,int index)523 static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev,
524 int index)
525 {
526 int ret;
527
528 ret = atomic_xchg(dev->dev_stat_values + index, 0);
529 smp_mb__before_atomic();
530 atomic_inc(&dev->dev_stats_ccnt);
531 return ret;
532 }
533
btrfs_dev_stat_set(struct btrfs_device * dev,int index,unsigned long val)534 static inline void btrfs_dev_stat_set(struct btrfs_device *dev,
535 int index, unsigned long val)
536 {
537 atomic_set(dev->dev_stat_values + index, val);
538 /*
539 * This memory barrier orders stores updating statistics before stores
540 * updating dev_stats_ccnt.
541 *
542 * It pairs with smp_rmb() in btrfs_run_dev_stats().
543 */
544 smp_mb__before_atomic();
545 atomic_inc(&dev->dev_stats_ccnt);
546 }
547
btrfs_dev_stat_reset(struct btrfs_device * dev,int index)548 static inline void btrfs_dev_stat_reset(struct btrfs_device *dev,
549 int index)
550 {
551 btrfs_dev_stat_set(dev, index, 0);
552 }
553
554 void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info);
555 void btrfs_update_commit_device_bytes_used(struct btrfs_fs_info *fs_info,
556 struct btrfs_transaction *transaction);
557
558 struct list_head *btrfs_get_fs_uuids(void);
559 void btrfs_set_fs_info_ptr(struct btrfs_fs_info *fs_info);
560 void btrfs_reset_fs_info_ptr(struct btrfs_fs_info *fs_info);
561
562 bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info);
563 void btrfs_report_missing_device(struct btrfs_fs_info *fs_info, u64 devid,
564 u8 *uuid);
565
566 #endif
567