GNU Linux-libre 4.9.308-gnu1
[releases.git] / fs / btrfs / volumes.h
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
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
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 extern const int btrfs_raid_mindev_error[BTRFS_NR_RAID_TYPES];
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         u64 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 struct btrfs_balance_args;
367 struct btrfs_balance_progress;
368 struct btrfs_balance_control {
369         struct btrfs_fs_info *fs_info;
370
371         struct btrfs_balance_args data;
372         struct btrfs_balance_args meta;
373         struct btrfs_balance_args sys;
374
375         u64 flags;
376
377         struct btrfs_balance_progress stat;
378 };
379
380 int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
381                                    u64 end, u64 *length);
382 void btrfs_get_bbio(struct btrfs_bio *bbio);
383 void btrfs_put_bbio(struct btrfs_bio *bbio);
384 int btrfs_map_block(struct btrfs_fs_info *fs_info, int op,
385                     u64 logical, u64 *length,
386                     struct btrfs_bio **bbio_ret, int mirror_num);
387 int btrfs_map_sblock(struct btrfs_fs_info *fs_info, int op,
388                      u64 logical, u64 *length,
389                      struct btrfs_bio **bbio_ret, int mirror_num,
390                      int need_raid_map);
391 int btrfs_rmap_block(struct btrfs_fs_info *fs_info,
392                      u64 chunk_start, u64 physical, u64 devid,
393                      u64 **logical, int *naddrs, int *stripe_len);
394 int btrfs_read_sys_array(struct btrfs_root *root);
395 int btrfs_read_chunk_tree(struct btrfs_root *root);
396 int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
397                       struct btrfs_root *extent_root, u64 type);
398 void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
399 void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
400 int btrfs_map_bio(struct btrfs_root *root, struct bio *bio,
401                   int mirror_num, int async_submit);
402 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
403                        fmode_t flags, void *holder);
404 int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
405                           struct btrfs_fs_devices **fs_devices_ret);
406 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
407 void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step);
408 void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info,
409                 struct btrfs_device *device, struct btrfs_device *this_dev);
410 int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
411                                          char *device_path,
412                                          struct btrfs_device **device);
413 int btrfs_find_device_by_devspec(struct btrfs_root *root, u64 devid,
414                                          char *devpath,
415                                          struct btrfs_device **device);
416 struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
417                                         const u64 *devid,
418                                         const u8 *uuid);
419 int btrfs_rm_device(struct btrfs_root *root, char *device_path, u64 devid);
420 void btrfs_cleanup_fs_uuids(void);
421 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
422 int btrfs_grow_device(struct btrfs_trans_handle *trans,
423                       struct btrfs_device *device, u64 new_size);
424 struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
425                                        u8 *uuid, u8 *fsid);
426 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
427 int btrfs_init_new_device(struct btrfs_root *root, char *path);
428 int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
429                                   struct btrfs_device *srcdev,
430                                   struct btrfs_device **device_out);
431 int btrfs_balance(struct btrfs_balance_control *bctl,
432                   struct btrfs_ioctl_balance_args *bargs);
433 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
434 int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
435 int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
436 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
437 int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info);
438 int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info);
439 int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
440 int find_free_dev_extent_start(struct btrfs_transaction *transaction,
441                          struct btrfs_device *device, u64 num_bytes,
442                          u64 search_start, u64 *start, u64 *max_avail);
443 int find_free_dev_extent(struct btrfs_trans_handle *trans,
444                          struct btrfs_device *device, u64 num_bytes,
445                          u64 *start, u64 *max_avail);
446 void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
447 int btrfs_get_dev_stats(struct btrfs_root *root,
448                         struct btrfs_ioctl_get_dev_stats *stats);
449 void btrfs_init_devices_late(struct btrfs_fs_info *fs_info);
450 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);
451 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
452                         struct btrfs_fs_info *fs_info);
453 void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info *fs_info,
454                                         struct btrfs_device *srcdev);
455 void btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info *fs_info,
456                                       struct btrfs_device *srcdev);
457 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
458                                       struct btrfs_device *tgtdev);
459 void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
460                                               struct btrfs_device *tgtdev);
461 void btrfs_scratch_superblocks(struct block_device *bdev, char *device_path);
462 int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree,
463                            u64 logical, u64 len, int mirror_num);
464 unsigned long btrfs_full_stripe_len(struct btrfs_root *root,
465                                     struct btrfs_mapping_tree *map_tree,
466                                     u64 logical);
467 int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
468                                 struct btrfs_root *extent_root,
469                                 u64 chunk_offset, u64 chunk_size);
470 int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
471                        struct btrfs_root *root, u64 chunk_offset);
472
473 static inline int btrfs_dev_stats_dirty(struct btrfs_device *dev)
474 {
475         return atomic_read(&dev->dev_stats_ccnt);
476 }
477
478 static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
479                                       int index)
480 {
481         atomic_inc(dev->dev_stat_values + index);
482         smp_mb__before_atomic();
483         atomic_inc(&dev->dev_stats_ccnt);
484 }
485
486 static inline int btrfs_dev_stat_read(struct btrfs_device *dev,
487                                       int index)
488 {
489         return atomic_read(dev->dev_stat_values + index);
490 }
491
492 static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev,
493                                                 int index)
494 {
495         int ret;
496
497         ret = atomic_xchg(dev->dev_stat_values + index, 0);
498         smp_mb__before_atomic();
499         atomic_inc(&dev->dev_stats_ccnt);
500         return ret;
501 }
502
503 static inline void btrfs_dev_stat_set(struct btrfs_device *dev,
504                                       int index, unsigned long val)
505 {
506         atomic_set(dev->dev_stat_values + index, val);
507         smp_mb__before_atomic();
508         atomic_inc(&dev->dev_stats_ccnt);
509 }
510
511 static inline void btrfs_dev_stat_reset(struct btrfs_device *dev,
512                                         int index)
513 {
514         btrfs_dev_stat_set(dev, index, 0);
515 }
516
517 void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info);
518 void btrfs_update_commit_device_bytes_used(struct btrfs_root *root,
519                                         struct btrfs_transaction *transaction);
520
521 static inline void lock_chunks(struct btrfs_root *root)
522 {
523         mutex_lock(&root->fs_info->chunk_mutex);
524 }
525
526 static inline void unlock_chunks(struct btrfs_root *root)
527 {
528         mutex_unlock(&root->fs_info->chunk_mutex);
529 }
530
531 struct list_head *btrfs_get_fs_uuids(void);
532 void btrfs_set_fs_info_ptr(struct btrfs_fs_info *fs_info);
533 void btrfs_reset_fs_info_ptr(struct btrfs_fs_info *fs_info);
534
535 #endif