volumes.h 15.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

#ifndef __BTRFS_VOLUMES_
#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 28
extern struct mutex uuid_mutex;

29
#define BTRFS_STRIPE_LEN	SZ_64K
30

31
struct buffer_head;
32 33 34 35 36
struct btrfs_pending_bios {
	struct bio *head;
	struct bio *tail;
};

37 38 39 40 41 42 43 44 45 46 47 48 49
/*
 * Use sequence counter to get consistent device stat data on
 * 32-bit processors.
 */
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
#include <linux/seqlock.h>
#define __BTRFS_NEED_DEVICE_DATA_ORDERED
#define btrfs_device_data_ordered_init(device)	\
	seqcount_init(&device->data_seqcount)
#else
#define btrfs_device_data_ordered_init(device) do { } while (0)
#endif

50 51
struct btrfs_device {
	struct list_head dev_list;
52
	struct list_head dev_alloc_list;
Y
Yan Zheng 已提交
53
	struct btrfs_fs_devices *fs_devices;
54
	struct btrfs_fs_info *fs_info;
55

56 57 58 59 60 61
	struct rcu_string *name;

	u64 generation;

	spinlock_t io_lock ____cacheline_aligned;
	int running_pending;
62 63
	/* regular prio bios */
	struct btrfs_pending_bios pending_bios;
64
	/* sync bios */
65 66
	struct btrfs_pending_bios pending_sync_bios;

67 68 69 70 71
	struct block_device *bdev;

	/* the mode sent to blkdev_get */
	fmode_t mode;

Y
Yan Zheng 已提交
72
	int writeable;
73
	int in_fs_metadata;
74
	int missing;
75
	int can_discard;
76
	int is_tgtdev_for_dev_replace;
77
	int last_flush_error;
78

79 80 81 82
#ifdef __BTRFS_NEED_DEVICE_DATA_ORDERED
	seqcount_t data_seqcount;
#endif

83 84 85
	/* the internal btrfs device id */
	u64 devid;

86
	/* size of the device in memory */
87 88
	u64 total_bytes;

89
	/* size of the device on disk */
90 91
	u64 disk_total_bytes;

92 93 94 95 96 97 98 99
	/* bytes used */
	u64 bytes_used;

	/* optimal io alignment for this device */
	u32 io_align;

	/* optimal io width for this device */
	u32 io_width;
100 101
	/* type and info about this device */
	u64 type;
102 103 104 105 106

	/* minimal io size for this device */
	u32 sector_size;

	/* physical drive uuid (or lvm uuid) */
107
	u8 uuid[BTRFS_UUID_SIZE];
108

109 110 111 112 113 114 115 116
	/*
	 * size of the device on the current transaction
	 *
	 * This variant is update when committing the transaction,
	 * and protected by device_list_mutex
	 */
	u64 commit_total_bytes;

117 118
	/* bytes used on the current transaction */
	u64 commit_bytes_used;
119 120 121 122 123 124 125
	/*
	 * used to manage the device which is resized
	 *
	 * It is protected by chunk_lock.
	 */
	struct list_head resized_list;

126 127 128 129
	/* for sending down flush barriers */
	struct bio *flush_bio;
	struct completion flush_wait;

A
Arne Jansen 已提交
130
	/* per-device scrub information */
131
	struct scrub_ctx *scrub_device;
A
Arne Jansen 已提交
132

133
	struct btrfs_work work;
134 135
	struct rcu_head rcu;
	struct work_struct rcu_work;
136 137 138 139 140 141 142 143

	/* readahead state */
	spinlock_t reada_lock;
	atomic_t reada_in_flight;
	u64 reada_next;
	struct reada_zone *reada_curr_zone;
	struct radix_tree_root reada_zones;
	struct radix_tree_root reada_extents;
C
Chris Mason 已提交
144

145 146
	/* disk I/O failure stats. For detailed description refer to
	 * enum btrfs_dev_stat_values in ioctl.h */
147
	int dev_stats_valid;
148 149 150

	/* Counter to record the change of device stats */
	atomic_t dev_stats_ccnt;
151
	atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX];
152 153
};

154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
/*
 * If we read those variants at the context of their own lock, we needn't
 * use the following helpers, reading them directly is safe.
 */
#if BITS_PER_LONG==32 && defined(CONFIG_SMP)
#define BTRFS_DEVICE_GETSET_FUNCS(name)					\
static inline u64							\
btrfs_device_get_##name(const struct btrfs_device *dev)			\
{									\
	u64 size;							\
	unsigned int seq;						\
									\
	do {								\
		seq = read_seqcount_begin(&dev->data_seqcount);		\
		size = dev->name;					\
	} while (read_seqcount_retry(&dev->data_seqcount, seq));	\
	return size;							\
}									\
									\
static inline void							\
btrfs_device_set_##name(struct btrfs_device *dev, u64 size)		\
{									\
	preempt_disable();						\
	write_seqcount_begin(&dev->data_seqcount);			\
	dev->name = size;						\
	write_seqcount_end(&dev->data_seqcount);			\
	preempt_enable();						\
}
#elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
#define BTRFS_DEVICE_GETSET_FUNCS(name)					\
static inline u64							\
btrfs_device_get_##name(const struct btrfs_device *dev)			\
{									\
	u64 size;							\
									\
	preempt_disable();						\
	size = dev->name;						\
	preempt_enable();						\
	return size;							\
}									\
									\
static inline void							\
btrfs_device_set_##name(struct btrfs_device *dev, u64 size)		\
{									\
	preempt_disable();						\
	dev->name = size;						\
	preempt_enable();						\
}
#else
#define BTRFS_DEVICE_GETSET_FUNCS(name)					\
static inline u64							\
btrfs_device_get_##name(const struct btrfs_device *dev)			\
{									\
	return dev->name;						\
}									\
									\
static inline void							\
btrfs_device_set_##name(struct btrfs_device *dev, u64 size)		\
{									\
	dev->name = size;						\
}
#endif

BTRFS_DEVICE_GETSET_FUNCS(total_bytes);
BTRFS_DEVICE_GETSET_FUNCS(disk_total_bytes);
BTRFS_DEVICE_GETSET_FUNCS(bytes_used);

221 222 223 224
struct btrfs_fs_devices {
	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */

	u64 num_devices;
225
	u64 open_devices;
Y
Yan Zheng 已提交
226
	u64 rw_devices;
227
	u64 missing_devices;
Y
Yan Zheng 已提交
228
	u64 total_rw_bytes;
J
Josef Bacik 已提交
229
	u64 total_devices;
230
	struct block_device *latest_bdev;
231 232 233

	/* all of the devices in the FS, protected by a mutex
	 * so we can safely walk it to write out the supers without
234 235 236
	 * worrying about add/remove by the multi-device code.
	 * Scrubbing super can kick off supers writing by holding
	 * this mutex lock.
237 238
	 */
	struct mutex device_list_mutex;
239
	struct list_head devices;
240

241
	struct list_head resized_devices;
242 243
	/* devices not currently being allocated */
	struct list_head alloc_list;
244
	struct list_head list;
Y
Yan Zheng 已提交
245 246 247 248 249

	struct btrfs_fs_devices *seed;
	int seeding;

	int opened;
C
Chris Mason 已提交
250 251 252 253 254

	/* set when we find or add a device that doesn't have the
	 * nonrot flag set
	 */
	int rotating;
255

256
	struct btrfs_fs_info *fs_info;
257
	/* sysfs kobjects */
258
	struct kobject fsid_kobj;
259 260
	struct kobject *device_dir_kobj;
	struct completion kobj_unregister;
261 262
};

263 264
#define BTRFS_BIO_INLINE_CSUM_SIZE	64

265 266 267 268 269 270 271 272 273
/*
 * we need the mirror number and stripe index to be passed around
 * the call chain while we are processing end_io (especially errors).
 * Really, what we need is a btrfs_bio structure that has this info
 * and is properly sized with its stripe array, but we're not there
 * quite yet.  We have our own btrfs bioset, and all of the bios
 * we allocate are actually btrfs_io_bios.  We'll cram as much of
 * struct btrfs_bio as we can into this over time.
 */
274
typedef void (btrfs_io_bio_end_io_t) (struct btrfs_io_bio *bio, int err);
275
struct btrfs_io_bio {
276 277 278
	unsigned int mirror_num;
	unsigned int stripe_index;
	u64 logical;
279 280 281 282
	u8 *csum;
	u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE];
	u8 *csum_allocated;
	btrfs_io_bio_end_io_t *end_io;
283
	struct bvec_iter iter;
284 285 286 287 288 289 290 291
	struct bio bio;
};

static inline struct btrfs_io_bio *btrfs_io_bio(struct bio *bio)
{
	return container_of(bio, struct btrfs_io_bio, bio);
}

292 293 294
struct btrfs_bio_stripe {
	struct btrfs_device *dev;
	u64 physical;
295
	u64 length; /* only used for discard mappings */
296 297
};

298 299 300 301
struct btrfs_bio;
typedef void (btrfs_bio_end_io_t) (struct btrfs_bio *bio, int err);

struct btrfs_bio {
302
	refcount_t refs;
303
	atomic_t stripes_pending;
304
	struct btrfs_fs_info *fs_info;
Z
Zhao Lei 已提交
305
	u64 map_type; /* get from map_lookup->type */
306
	bio_end_io_t *end_io;
307
	struct bio *orig_bio;
308
	unsigned long flags;
309
	void *private;
310 311
	atomic_t error;
	int max_errors;
312
	int num_stripes;
313
	int mirror_num;
314 315
	int num_tgtdevs;
	int *tgtdev_map;
316 317 318 319 320 321
	/*
	 * logical block numbers for the start of each stripe
	 * The last one or two are p/q.  These are sorted,
	 * so raid_map[0] is the start of our full stripe
	 */
	u64 *raid_map;
322 323 324
	struct btrfs_bio_stripe stripes[];
};

325 326 327 328
struct btrfs_device_info {
	struct btrfs_device *dev;
	u64 dev_offset;
	u64 max_avail;
329
	u64 total_avail;
330 331
};

332 333 334 335 336
struct btrfs_raid_attr {
	int sub_stripes;	/* sub_stripes info for map */
	int dev_stripes;	/* stripes per dev */
	int devs_max;		/* max devs to use */
	int devs_min;		/* min devs needed */
337
	int tolerated_failures; /* max tolerated fail devs */
338 339 340 341
	int devs_increment;	/* ndevs has to be a multiple of this */
	int ncopies;		/* how many copies to data has */
};

Z
Zhao Lei 已提交
342
extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
343
extern const int btrfs_raid_mindev_error[BTRFS_NR_RAID_TYPES];
Z
Zhao Lei 已提交
344 345
extern const u64 btrfs_raid_group[BTRFS_NR_RAID_TYPES];

346 347 348 349
struct map_lookup {
	u64 type;
	int io_align;
	int io_width;
350
	u64 stripe_len;
351 352 353 354 355 356
	int sector_size;
	int num_stripes;
	int sub_stripes;
	struct btrfs_bio_stripe stripes[];
};

A
Arne Jansen 已提交
357 358 359
#define map_lookup_size(n) (sizeof(struct map_lookup) + \
			    (sizeof(struct btrfs_bio_stripe) * (n)))

360
struct btrfs_balance_args;
361
struct btrfs_balance_progress;
362 363 364 365 366 367 368 369
struct btrfs_balance_control {
	struct btrfs_fs_info *fs_info;

	struct btrfs_balance_args data;
	struct btrfs_balance_args meta;
	struct btrfs_balance_args sys;

	u64 flags;
370 371

	struct btrfs_balance_progress stat;
372 373
};

374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
enum btrfs_map_op {
	BTRFS_MAP_READ,
	BTRFS_MAP_WRITE,
	BTRFS_MAP_DISCARD,
	BTRFS_MAP_GET_READ_MIRRORS,
};

static inline enum btrfs_map_op btrfs_op(struct bio *bio)
{
	switch (bio_op(bio)) {
	case REQ_OP_DISCARD:
		return BTRFS_MAP_DISCARD;
	case REQ_OP_WRITE:
		return BTRFS_MAP_WRITE;
	default:
		WARN_ON_ONCE(1);
	case REQ_OP_READ:
		return BTRFS_MAP_READ;
	}
}

395 396
int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
				   u64 end, u64 *length);
397 398
void btrfs_get_bbio(struct btrfs_bio *bbio);
void btrfs_put_bbio(struct btrfs_bio *bbio);
399
int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
400
		    u64 logical, u64 *length,
401
		    struct btrfs_bio **bbio_ret, int mirror_num);
402
int btrfs_map_sblock(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
403
		     u64 logical, u64 *length,
404
		     struct btrfs_bio **bbio_ret);
405
int btrfs_rmap_block(struct btrfs_fs_info *fs_info,
Y
Yan Zheng 已提交
406 407
		     u64 chunk_start, u64 physical, u64 devid,
		     u64 **logical, int *naddrs, int *stripe_len);
408
int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);
409
int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);
410
int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
411
		      struct btrfs_fs_info *fs_info, u64 type);
412 413
void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
414
int btrfs_map_bio(struct btrfs_fs_info *fs_info, struct bio *bio,
415
		  int mirror_num, int async_submit);
416
int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
417 418
		       fmode_t flags, void *holder);
int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
419 420
			  struct btrfs_fs_devices **fs_devices_ret);
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
421
void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step);
422 423
void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info,
		struct btrfs_device *device, struct btrfs_device *this_dev);
424
int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info,
425
					 const char *device_path,
426
					 struct btrfs_device **device);
427
int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid,
428
					 const char *devpath,
429
					 struct btrfs_device **device);
430 431 432
struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
					const u64 *devid,
					const u8 *uuid);
433
int btrfs_rm_device(struct btrfs_fs_info *fs_info,
434
		    const char *device_path, u64 devid);
435
void btrfs_cleanup_fs_uuids(void);
436
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
437 438
int btrfs_grow_device(struct btrfs_trans_handle *trans,
		      struct btrfs_device *device, u64 new_size);
439
struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
Y
Yan Zheng 已提交
440
				       u8 *uuid, u8 *fsid);
441
int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
442
int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *path);
443
int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
444
				  const char *device_path,
445
				  struct btrfs_device *srcdev,
446
				  struct btrfs_device **device_out);
447 448
int btrfs_balance(struct btrfs_balance_control *bctl,
		  struct btrfs_ioctl_balance_args *bargs);
449
int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
450
int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
451
int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
452
int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
453
int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info);
454
int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info);
455
int btrfs_chunk_readonly(struct btrfs_fs_info *fs_info, u64 chunk_offset);
456 457 458
int find_free_dev_extent_start(struct btrfs_transaction *transaction,
			 struct btrfs_device *device, u64 num_bytes,
			 u64 search_start, u64 *start, u64 *max_avail);
459 460
int find_free_dev_extent(struct btrfs_trans_handle *trans,
			 struct btrfs_device *device, u64 num_bytes,
461
			 u64 *start, u64 *max_avail);
462
void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
463
int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,
464
			struct btrfs_ioctl_get_dev_stats *stats);
465
void btrfs_init_devices_late(struct btrfs_fs_info *fs_info);
466 467 468
int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);
int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
			struct btrfs_fs_info *fs_info);
469 470 471 472
void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info *fs_info,
					struct btrfs_device *srcdev);
void btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info *fs_info,
				      struct btrfs_device *srcdev);
473 474 475 476
void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
				      struct btrfs_device *tgtdev);
void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
					      struct btrfs_device *tgtdev);
477
void btrfs_scratch_superblocks(struct block_device *bdev, const char *device_path);
478
int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info,
D
David Woodhouse 已提交
479
			   u64 logical, u64 len, int mirror_num);
480
unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,
D
David Woodhouse 已提交
481 482
				    struct btrfs_mapping_tree *map_tree,
				    u64 logical);
483
int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
484
				struct btrfs_fs_info *fs_info,
485
				u64 chunk_offset, u64 chunk_size);
486
int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
487
		       struct btrfs_fs_info *fs_info, u64 chunk_offset);
488 489 490 491 492 493

static inline int btrfs_dev_stats_dirty(struct btrfs_device *dev)
{
	return atomic_read(&dev->dev_stats_ccnt);
}

494 495 496 497
static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
				      int index)
{
	atomic_inc(dev->dev_stat_values + index);
498 499
	smp_mb__before_atomic();
	atomic_inc(&dev->dev_stats_ccnt);
500 501 502 503 504 505 506 507 508 509 510 511 512 513
}

static inline int btrfs_dev_stat_read(struct btrfs_device *dev,
				      int index)
{
	return atomic_read(dev->dev_stat_values + index);
}

static inline int btrfs_dev_stat_read_and_reset(struct btrfs_device *dev,
						int index)
{
	int ret;

	ret = atomic_xchg(dev->dev_stat_values + index, 0);
514 515
	smp_mb__before_atomic();
	atomic_inc(&dev->dev_stats_ccnt);
516 517 518 519 520 521 522
	return ret;
}

static inline void btrfs_dev_stat_set(struct btrfs_device *dev,
				      int index, unsigned long val)
{
	atomic_set(dev->dev_stat_values + index, val);
523 524
	smp_mb__before_atomic();
	atomic_inc(&dev->dev_stats_ccnt);
525 526 527 528 529 530 531
}

static inline void btrfs_dev_stat_reset(struct btrfs_device *dev,
					int index)
{
	btrfs_dev_stat_set(dev, index, 0);
}
532 533

void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info);
534
void btrfs_update_commit_device_bytes_used(struct btrfs_fs_info *fs_info,
535
					struct btrfs_transaction *transaction);
536

537
struct list_head *btrfs_get_fs_uuids(void);
538 539
void btrfs_set_fs_info_ptr(struct btrfs_fs_info *fs_info);
void btrfs_reset_fs_info_ptr(struct btrfs_fs_info *fs_info);
540

541
#endif