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