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 (64 * 1024)
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
57 struct btrfs_root *dev_root;
58
59 struct rcu_string *name;
60
61 u64 generation;
62
63 spinlock_t io_lock ____cacheline_aligned;
64 int running_pending;
65 /* When true means this device has pending chunk alloc in
66 * current transaction. Protected by chunk_mutex.
67 */
68 bool has_pending_chunks;
69
70 /* regular prio bios */
71 struct btrfs_pending_bios pending_bios;
72 /* WRITE_SYNC bios */
73 struct btrfs_pending_bios pending_sync_bios;
74
75 struct block_device *bdev;
76
77 /* the mode sent to blkdev_get */
78 fmode_t mode;
79
80 int writeable;
81 int in_fs_metadata;
82 int missing;
83 int can_discard;
84 int is_tgtdev_for_dev_replace;
85
86 #ifdef __BTRFS_NEED_DEVICE_DATA_ORDERED
87 seqcount_t data_seqcount;
88 #endif
89
90 /* the internal btrfs device id */
91 u64 devid;
92
93 /* size of the device in memory */
94 u64 total_bytes;
95
96 /* size of the device on disk */
97 u64 disk_total_bytes;
98
99 /* bytes used */
100 u64 bytes_used;
101
102 /* optimal io alignment for this device */
103 u32 io_align;
104
105 /* optimal io width for this device */
106 u32 io_width;
107 /* type and info about this device */
108 u64 type;
109
110 /* minimal io size for this device */
111 u32 sector_size;
112
113 /* physical drive uuid (or lvm uuid) */
114 u8 uuid[BTRFS_UUID_SIZE];
115
116 /*
117 * size of the device on the current transaction
118 *
119 * This variant is update when committing the transaction,
120 * and protected by device_list_mutex
121 */
122 u64 commit_total_bytes;
123
124 /* bytes used on the current transaction */
125 u64 commit_bytes_used;
126 /*
127 * used to manage the device which is resized
128 *
129 * It is protected by chunk_lock.
130 */
131 struct list_head resized_list;
132
133 /* for sending down flush barriers */
134 int nobarriers;
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 bio bio;
292 };
293
btrfs_io_bio(struct bio * bio)294 static inline struct btrfs_io_bio *btrfs_io_bio(struct bio *bio)
295 {
296 return container_of(bio, struct btrfs_io_bio, bio);
297 }
298
299 struct btrfs_bio_stripe {
300 struct btrfs_device *dev;
301 u64 physical;
302 u64 length; /* only used for discard mappings */
303 };
304
305 struct btrfs_bio;
306 typedef void (btrfs_bio_end_io_t) (struct btrfs_bio *bio, int err);
307
308 struct btrfs_bio {
309 atomic_t refs;
310 atomic_t stripes_pending;
311 struct btrfs_fs_info *fs_info;
312 u64 map_type; /* get from map_lookup->type */
313 bio_end_io_t *end_io;
314 struct bio *orig_bio;
315 void *private;
316 atomic_t error;
317 int max_errors;
318 int num_stripes;
319 int mirror_num;
320 int num_tgtdevs;
321 int *tgtdev_map;
322 /*
323 * logical block numbers for the start of each stripe
324 * The last one or two are p/q. These are sorted,
325 * so raid_map[0] is the start of our full stripe
326 */
327 u64 *raid_map;
328 struct btrfs_bio_stripe stripes[];
329 };
330
331 struct btrfs_device_info {
332 struct btrfs_device *dev;
333 u64 dev_offset;
334 u64 max_avail;
335 u64 total_avail;
336 };
337
338 struct btrfs_raid_attr {
339 int sub_stripes; /* sub_stripes info for map */
340 int dev_stripes; /* stripes per dev */
341 int devs_max; /* max devs to use */
342 int devs_min; /* min devs needed */
343 int tolerated_failures; /* max tolerated fail devs */
344 int devs_increment; /* ndevs has to be a multiple of this */
345 int ncopies; /* how many copies to data has */
346 };
347
348 extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
349
350 extern const u64 btrfs_raid_group[BTRFS_NR_RAID_TYPES];
351
352 struct map_lookup {
353 u64 type;
354 int io_align;
355 int io_width;
356 int stripe_len;
357 int sector_size;
358 int num_stripes;
359 int sub_stripes;
360 struct btrfs_bio_stripe stripes[];
361 };
362
363 #define map_lookup_size(n) (sizeof(struct map_lookup) + \
364 (sizeof(struct btrfs_bio_stripe) * (n)))
365
366 /*
367 * Restriper's general type filter
368 */
369 #define BTRFS_BALANCE_DATA (1ULL << 0)
370 #define BTRFS_BALANCE_SYSTEM (1ULL << 1)
371 #define BTRFS_BALANCE_METADATA (1ULL << 2)
372
373 #define BTRFS_BALANCE_TYPE_MASK (BTRFS_BALANCE_DATA | \
374 BTRFS_BALANCE_SYSTEM | \
375 BTRFS_BALANCE_METADATA)
376
377 #define BTRFS_BALANCE_FORCE (1ULL << 3)
378 #define BTRFS_BALANCE_RESUME (1ULL << 4)
379
380 /*
381 * Balance filters
382 */
383 #define BTRFS_BALANCE_ARGS_PROFILES (1ULL << 0)
384 #define BTRFS_BALANCE_ARGS_USAGE (1ULL << 1)
385 #define BTRFS_BALANCE_ARGS_DEVID (1ULL << 2)
386 #define BTRFS_BALANCE_ARGS_DRANGE (1ULL << 3)
387 #define BTRFS_BALANCE_ARGS_VRANGE (1ULL << 4)
388 #define BTRFS_BALANCE_ARGS_LIMIT (1ULL << 5)
389 #define BTRFS_BALANCE_ARGS_LIMIT_RANGE (1ULL << 6)
390 #define BTRFS_BALANCE_ARGS_STRIPES_RANGE (1ULL << 7)
391 #define BTRFS_BALANCE_ARGS_USAGE_RANGE (1ULL << 10)
392
393 #define BTRFS_BALANCE_ARGS_MASK \
394 (BTRFS_BALANCE_ARGS_PROFILES | \
395 BTRFS_BALANCE_ARGS_USAGE | \
396 BTRFS_BALANCE_ARGS_DEVID | \
397 BTRFS_BALANCE_ARGS_DRANGE | \
398 BTRFS_BALANCE_ARGS_VRANGE | \
399 BTRFS_BALANCE_ARGS_LIMIT | \
400 BTRFS_BALANCE_ARGS_LIMIT_RANGE | \
401 BTRFS_BALANCE_ARGS_STRIPES_RANGE | \
402 BTRFS_BALANCE_ARGS_USAGE_RANGE)
403
404 /*
405 * Profile changing flags. When SOFT is set we won't relocate chunk if
406 * it already has the target profile (even though it may be
407 * half-filled).
408 */
409 #define BTRFS_BALANCE_ARGS_CONVERT (1ULL << 8)
410 #define BTRFS_BALANCE_ARGS_SOFT (1ULL << 9)
411
412 struct btrfs_balance_args;
413 struct btrfs_balance_progress;
414 struct btrfs_balance_control {
415 struct btrfs_fs_info *fs_info;
416
417 struct btrfs_balance_args data;
418 struct btrfs_balance_args meta;
419 struct btrfs_balance_args sys;
420
421 u64 flags;
422
423 struct btrfs_balance_progress stat;
424 };
425
426 int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
427 u64 end, u64 *length);
428 void btrfs_get_bbio(struct btrfs_bio *bbio);
429 void btrfs_put_bbio(struct btrfs_bio *bbio);
430 int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
431 u64 logical, u64 *length,
432 struct btrfs_bio **bbio_ret, int mirror_num);
433 int btrfs_map_sblock(struct btrfs_fs_info *fs_info, int rw,
434 u64 logical, u64 *length,
435 struct btrfs_bio **bbio_ret, int mirror_num,
436 int need_raid_map);
437 int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
438 u64 chunk_start, u64 physical, u64 devid,
439 u64 **logical, int *naddrs, int *stripe_len);
440 int btrfs_read_sys_array(struct btrfs_root *root);
441 int btrfs_read_chunk_tree(struct btrfs_root *root);
442 int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
443 struct btrfs_root *extent_root, u64 type);
444 void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
445 void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
446 int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
447 int mirror_num, int async_submit);
448 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
449 fmode_t flags, void *holder);
450 int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
451 struct btrfs_fs_devices **fs_devices_ret);
452 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
453 void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step);
454 int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
455 char *device_path,
456 struct btrfs_device **device);
457 struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
458 const u64 *devid,
459 const u8 *uuid);
460 int btrfs_rm_device(struct btrfs_root *root, char *device_path);
461 void btrfs_cleanup_fs_uuids(void);
462 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
463 int btrfs_grow_device(struct btrfs_trans_handle *trans,
464 struct btrfs_device *device, u64 new_size);
465 struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
466 u8 *uuid, u8 *fsid);
467 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
468 int btrfs_init_new_device(struct btrfs_root *root, char *path);
469 int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
470 struct btrfs_device *srcdev,
471 struct btrfs_device **device_out);
472 int btrfs_balance(struct btrfs_balance_control *bctl,
473 struct btrfs_ioctl_balance_args *bargs);
474 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
475 int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
476 int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
477 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
478 int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info);
479 int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info);
480 int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
481 int find_free_dev_extent_start(struct btrfs_transaction *transaction,
482 struct btrfs_device *device, u64 num_bytes,
483 u64 search_start, u64 *start, u64 *max_avail);
484 int find_free_dev_extent(struct btrfs_trans_handle *trans,
485 struct btrfs_device *device, u64 num_bytes,
486 u64 *start, u64 *max_avail);
487 void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
488 int btrfs_get_dev_stats(struct btrfs_root *root,
489 struct btrfs_ioctl_get_dev_stats *stats);
490 void btrfs_init_devices_late(struct btrfs_fs_info *fs_info);
491 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);
492 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
493 struct btrfs_fs_info *fs_info);
494 void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info *fs_info,
495 struct btrfs_device *srcdev);
496 void btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info *fs_info,
497 struct btrfs_device *srcdev);
498 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
499 struct btrfs_device *tgtdev);
500 void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
501 struct btrfs_device *tgtdev);
502 void btrfs_scratch_superblocks(struct block_device *bdev, char *device_path);
503 int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree,
504 u64 logical, u64 len, int mirror_num);
505 unsigned long btrfs_full_stripe_len(struct btrfs_root *root,
506 struct btrfs_mapping_tree *map_tree,
507 u64 logical);
508 int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
509 struct btrfs_root *extent_root,
510 u64 chunk_offset, u64 chunk_size);
511 int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
512 struct btrfs_root *root, u64 chunk_offset);
513
btrfs_dev_stats_dirty(struct btrfs_device * dev)514 static inline int btrfs_dev_stats_dirty(struct btrfs_device *dev)
515 {
516 return atomic_read(&dev->dev_stats_ccnt);
517 }
518
btrfs_dev_stat_inc(struct btrfs_device * dev,int index)519 static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
520 int index)
521 {
522 atomic_inc(dev->dev_stat_values + index);
523 smp_mb__before_atomic();
524 atomic_inc(&dev->dev_stats_ccnt);
525 }
526
btrfs_dev_stat_read(struct btrfs_device * dev,int index)527 static inline int btrfs_dev_stat_read(struct btrfs_device *dev,
528 int index)
529 {
530 return atomic_read(dev->dev_stat_values + index);
531 }
532
btrfs_dev_stat_read_and_reset(struct btrfs_device * dev,int index)533 static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev,
534 int index)
535 {
536 int ret;
537
538 ret = atomic_xchg(dev->dev_stat_values + index, 0);
539 smp_mb__before_atomic();
540 atomic_inc(&dev->dev_stats_ccnt);
541 return ret;
542 }
543
btrfs_dev_stat_set(struct btrfs_device * dev,int index,unsigned long val)544 static inline void btrfs_dev_stat_set(struct btrfs_device *dev,
545 int index, unsigned long val)
546 {
547 atomic_set(dev->dev_stat_values + index, val);
548 smp_mb__before_atomic();
549 atomic_inc(&dev->dev_stats_ccnt);
550 }
551
btrfs_dev_stat_reset(struct btrfs_device * dev,int index)552 static inline void btrfs_dev_stat_reset(struct btrfs_device *dev,
553 int index)
554 {
555 btrfs_dev_stat_set(dev, index, 0);
556 }
557
558 void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info);
559 void btrfs_update_commit_device_bytes_used(struct btrfs_root *root,
560 struct btrfs_transaction *transaction);
561
lock_chunks(struct btrfs_root * root)562 static inline void lock_chunks(struct btrfs_root *root)
563 {
564 mutex_lock(&root->fs_info->chunk_mutex);
565 }
566
unlock_chunks(struct btrfs_root * root)567 static inline void unlock_chunks(struct btrfs_root *root)
568 {
569 mutex_unlock(&root->fs_info->chunk_mutex);
570 }
571
572 struct list_head *btrfs_get_fs_uuids(void);
573 void btrfs_set_fs_info_ptr(struct btrfs_fs_info *fs_info);
574 void btrfs_reset_fs_info_ptr(struct btrfs_fs_info *fs_info);
575 void btrfs_close_one_device(struct btrfs_device *device);
576
577 #endif
578