2 * Copyright (C) 2007 Oracle. All rights reserved.
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.
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.
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.
19 #ifndef __BTRFS_VOLUMES_
20 #define __BTRFS_VOLUMES_
22 #include <linux/bio.h>
23 #include <linux/sort.h>
24 #include <linux/btrfs.h>
25 #include "async-thread.h"
27 #define BTRFS_MAX_DATA_CHUNK_SIZE (10ULL * SZ_1G)
29 extern struct mutex uuid_mutex
;
31 #define BTRFS_STRIPE_LEN SZ_64K
34 struct btrfs_pending_bios
{
40 * Use sequence counter to get consistent device stat data on
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)
49 #define btrfs_device_data_ordered_init(device) do { } while (0)
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
;
58 struct rcu_string
*name
;
62 spinlock_t io_lock ____cacheline_aligned
;
64 /* When true means this device has pending chunk alloc in
65 * current transaction. Protected by chunk_mutex.
67 bool has_pending_chunks
;
69 /* regular prio bios */
70 struct btrfs_pending_bios pending_bios
;
72 struct btrfs_pending_bios pending_sync_bios
;
74 struct block_device
*bdev
;
76 /* the mode sent to blkdev_get */
83 int is_tgtdev_for_dev_replace
;
84 blk_status_t last_flush_error
;
87 #ifdef __BTRFS_NEED_DEVICE_DATA_ORDERED
88 seqcount_t data_seqcount
;
91 /* the internal btrfs device id */
94 /* size of the device in memory */
97 /* size of the device on disk */
103 /* optimal io alignment for this device */
106 /* optimal io width for this device */
108 /* type and info about this device */
111 /* minimal io size for this device */
114 /* physical drive uuid (or lvm uuid) */
115 u8 uuid
[BTRFS_UUID_SIZE
];
118 * size of the device on the current transaction
120 * This variant is update when committing the transaction,
121 * and protected by device_list_mutex
123 u64 commit_total_bytes
;
125 /* bytes used on the current transaction */
126 u64 commit_bytes_used
;
128 * used to manage the device which is resized
130 * It is protected by chunk_lock.
132 struct list_head resized_list
;
134 /* for sending down flush barriers */
135 struct bio
*flush_bio
;
136 struct completion flush_wait
;
138 /* per-device scrub information */
139 struct scrub_ctx
*scrub_device
;
141 struct btrfs_work work
;
143 struct work_struct rcu_work
;
145 /* readahead state */
146 spinlock_t reada_lock
;
147 atomic_t reada_in_flight
;
149 struct reada_zone
*reada_curr_zone
;
150 struct radix_tree_root reada_zones
;
151 struct radix_tree_root reada_extents
;
153 /* disk I/O failure stats. For detailed description refer to
154 * enum btrfs_dev_stat_values in ioctl.h */
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
];
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.
166 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
167 #define BTRFS_DEVICE_GETSET_FUNCS(name) \
169 btrfs_device_get_##name(const struct btrfs_device *dev) \
175 seq = read_seqcount_begin(&dev->data_seqcount); \
177 } while (read_seqcount_retry(&dev->data_seqcount, seq)); \
182 btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \
185 write_seqcount_begin(&dev->data_seqcount); \
187 write_seqcount_end(&dev->data_seqcount); \
190 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
191 #define BTRFS_DEVICE_GETSET_FUNCS(name) \
193 btrfs_device_get_##name(const struct btrfs_device *dev) \
204 btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \
211 #define BTRFS_DEVICE_GETSET_FUNCS(name) \
213 btrfs_device_get_##name(const struct btrfs_device *dev) \
219 btrfs_device_set_##name(struct btrfs_device *dev, u64 size) \
225 BTRFS_DEVICE_GETSET_FUNCS(total_bytes
);
226 BTRFS_DEVICE_GETSET_FUNCS(disk_total_bytes
);
227 BTRFS_DEVICE_GETSET_FUNCS(bytes_used
);
229 struct btrfs_fs_devices
{
230 u8 fsid
[BTRFS_FSID_SIZE
]; /* FS specific uuid */
238 struct block_device
*latest_bdev
;
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
246 struct mutex device_list_mutex
;
247 struct list_head devices
;
249 struct list_head resized_devices
;
250 /* devices not currently being allocated */
251 struct list_head alloc_list
;
252 struct list_head list
;
254 struct btrfs_fs_devices
*seed
;
259 /* set when we find or add a device that doesn't have the
264 struct btrfs_fs_info
*fs_info
;
266 struct kobject fsid_kobj
;
267 struct kobject
*device_dir_kobj
;
268 struct completion kobj_unregister
;
271 #define BTRFS_BIO_INLINE_CSUM_SIZE 64
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.
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
;
288 u8 csum_inline
[BTRFS_BIO_INLINE_CSUM_SIZE
];
290 btrfs_io_bio_end_io_t
*end_io
;
291 struct bvec_iter iter
;
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.
299 static inline struct btrfs_io_bio
*btrfs_io_bio(struct bio
*bio
)
301 return container_of(bio
, struct btrfs_io_bio
, bio
);
304 struct btrfs_bio_stripe
{
305 struct btrfs_device
*dev
;
307 u64 length
; /* only used for discard mappings */
311 typedef void (btrfs_bio_end_io_t
) (struct btrfs_bio
*bio
, int err
);
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
;
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
333 struct btrfs_bio_stripe stripes
[];
336 struct btrfs_device_info
{
337 struct btrfs_device
*dev
;
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 */
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
];
364 struct btrfs_bio_stripe stripes
[];
367 #define map_lookup_size(n) (sizeof(struct map_lookup) + \
368 (sizeof(struct btrfs_bio_stripe) * (n)))
370 struct btrfs_balance_args
;
371 struct btrfs_balance_progress
;
372 struct btrfs_balance_control
{
373 struct btrfs_fs_info
*fs_info
;
375 struct btrfs_balance_args data
;
376 struct btrfs_balance_args meta
;
377 struct btrfs_balance_args sys
;
381 struct btrfs_balance_progress stat
;
388 BTRFS_MAP_GET_READ_MIRRORS
,
391 static inline enum btrfs_map_op
btrfs_op(struct bio
*bio
)
393 switch (bio_op(bio
)) {
395 return BTRFS_MAP_DISCARD
;
397 return BTRFS_MAP_WRITE
;
401 return BTRFS_MAP_READ
;
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
,
439 struct btrfs_device
**device
);
440 struct btrfs_device
*btrfs_alloc_device(struct btrfs_fs_info
*fs_info
,
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_devices
*fs_devices
,
450 u64 devid
, u8
*uuid
, u8
*fsid
, bool seed
);
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
,
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
);
498 static inline int btrfs_dev_stats_dirty(struct btrfs_device
*dev
)
500 return atomic_read(&dev
->dev_stats_ccnt
);
503 static inline void btrfs_dev_stat_inc(struct btrfs_device
*dev
,
506 atomic_inc(dev
->dev_stat_values
+ index
);
508 * This memory barrier orders stores updating statistics before stores
509 * updating dev_stats_ccnt.
511 * It pairs with smp_rmb() in btrfs_run_dev_stats().
513 smp_mb__before_atomic();
514 atomic_inc(&dev
->dev_stats_ccnt
);
517 static inline int btrfs_dev_stat_read(struct btrfs_device
*dev
,
520 return atomic_read(dev
->dev_stat_values
+ index
);
523 static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device
*dev
,
528 ret
= atomic_xchg(dev
->dev_stat_values
+ index
, 0);
529 smp_mb__before_atomic();
530 atomic_inc(&dev
->dev_stats_ccnt
);
534 static inline void btrfs_dev_stat_set(struct btrfs_device
*dev
,
535 int index
, unsigned long val
)
537 atomic_set(dev
->dev_stat_values
+ index
, val
);
539 * This memory barrier orders stores updating statistics before stores
540 * updating dev_stats_ccnt.
542 * It pairs with smp_rmb() in btrfs_run_dev_stats().
544 smp_mb__before_atomic();
545 atomic_inc(&dev
->dev_stats_ccnt
);
548 static inline void btrfs_dev_stat_reset(struct btrfs_device
*dev
,
551 btrfs_dev_stat_set(dev
, index
, 0);
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
);
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
);
562 bool btrfs_check_rw_degradable(struct btrfs_fs_info
*fs_info
);