volumes.h 9.9 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 "async-thread.h"
25
#include "ioctl.h"
26

27 28
#define BTRFS_STRIPE_LEN	(64 * 1024)

29
struct buffer_head;
30 31 32 33 34
struct btrfs_pending_bios {
	struct bio *head;
	struct bio *tail;
};

35 36
struct btrfs_device {
	struct list_head dev_list;
37
	struct list_head dev_alloc_list;
Y
Yan Zheng 已提交
38
	struct btrfs_fs_devices *fs_devices;
39
	struct btrfs_root *dev_root;
40 41 42 43 44 45

	/* regular prio bios */
	struct btrfs_pending_bios pending_bios;
	/* WRITE_SYNC bios */
	struct btrfs_pending_bios pending_sync_bios;

46
	int running_pending;
47
	u64 generation;
48

Y
Yan Zheng 已提交
49
	int writeable;
50
	int in_fs_metadata;
51
	int missing;
52
	int can_discard;
53
	int is_tgtdev_for_dev_replace;
54

55
	spinlock_t io_lock;
56 57 58

	struct block_device *bdev;

59
	/* the mode sent to blkdev_get */
60 61
	fmode_t mode;

62
	struct rcu_string *name;
63

64 65 66 67 68 69
	/* the internal btrfs device id */
	u64 devid;

	/* size of the device */
	u64 total_bytes;

70 71 72
	/* size of the disk */
	u64 disk_total_bytes;

73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	/* bytes used */
	u64 bytes_used;

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

	/* optimal io width for this device */
	u32 io_width;

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

	/* type and info about this device */
	u64 type;

	/* physical drive uuid (or lvm uuid) */
89
	u8 uuid[BTRFS_UUID_SIZE];
90

A
Arne Jansen 已提交
91
	/* per-device scrub information */
92
	struct scrub_ctx *scrub_device;
A
Arne Jansen 已提交
93

94
	struct btrfs_work work;
95 96
	struct rcu_head rcu;
	struct work_struct rcu_work;
97 98 99 100 101 102 103 104

	/* 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 已提交
105 106 107 108 109 110

	/* for sending down flush barriers */
	struct bio *flush_bio;
	struct completion flush_wait;
	int nobarriers;

111 112
	/* disk I/O failure stats. For detailed description refer to
	 * enum btrfs_dev_stat_values in ioctl.h */
113
	int dev_stats_valid;
114 115
	int dev_stats_dirty; /* counters need to be written to disk */
	atomic_t dev_stat_values[BTRFS_DEV_STAT_VALUES_MAX];
116 117
};

118 119 120
struct btrfs_fs_devices {
	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */

W
Wu Fengguang 已提交
121
	/* the device with this id has the most recent copy of the super */
122 123 124
	u64 latest_devid;
	u64 latest_trans;
	u64 num_devices;
125
	u64 open_devices;
Y
Yan Zheng 已提交
126
	u64 rw_devices;
127
	u64 missing_devices;
Y
Yan Zheng 已提交
128
	u64 total_rw_bytes;
129
	u64 num_can_discard;
J
Josef Bacik 已提交
130
	u64 total_devices;
131
	struct block_device *latest_bdev;
132 133 134 135 136 137

	/* all of the devices in the FS, protected by a mutex
	 * so we can safely walk it to write out the supers without
	 * worrying about add/remove by the multi-device code
	 */
	struct mutex device_list_mutex;
138
	struct list_head devices;
139 140 141

	/* devices not currently being allocated */
	struct list_head alloc_list;
142
	struct list_head list;
Y
Yan Zheng 已提交
143 144 145 146 147

	struct btrfs_fs_devices *seed;
	int seeding;

	int opened;
C
Chris Mason 已提交
148 149 150 151 152

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

155 156 157
struct btrfs_bio_stripe {
	struct btrfs_device *dev;
	u64 physical;
158
	u64 length; /* only used for discard mappings */
159 160
};

161 162 163 164
struct btrfs_bio;
typedef void (btrfs_bio_end_io_t) (struct btrfs_bio *bio, int err);

struct btrfs_bio {
165 166
	atomic_t stripes_pending;
	bio_end_io_t *end_io;
167
	struct bio *orig_bio;
168
	void *private;
169 170
	atomic_t error;
	int max_errors;
171
	int num_stripes;
172
	int mirror_num;
173 174 175
	struct btrfs_bio_stripe stripes[];
};

176 177 178 179
struct btrfs_device_info {
	struct btrfs_device *dev;
	u64 dev_offset;
	u64 max_avail;
180
	u64 total_avail;
181 182
};

183 184 185 186 187 188 189 190 191 192 193
struct map_lookup {
	u64 type;
	int io_align;
	int io_width;
	int stripe_len;
	int sector_size;
	int num_stripes;
	int sub_stripes;
	struct btrfs_bio_stripe stripes[];
};

A
Arne Jansen 已提交
194 195 196
#define map_lookup_size(n) (sizeof(struct map_lookup) + \
			    (sizeof(struct btrfs_bio_stripe) * (n)))

197 198 199 200 201 202 203 204 205 206
/*
 * Restriper's general type filter
 */
#define BTRFS_BALANCE_DATA		(1ULL << 0)
#define BTRFS_BALANCE_SYSTEM		(1ULL << 1)
#define BTRFS_BALANCE_METADATA		(1ULL << 2)

#define BTRFS_BALANCE_TYPE_MASK		(BTRFS_BALANCE_DATA |	    \
					 BTRFS_BALANCE_SYSTEM |	    \
					 BTRFS_BALANCE_METADATA)
207 208

#define BTRFS_BALANCE_FORCE		(1ULL << 3)
I
Ilya Dryomov 已提交
209
#define BTRFS_BALANCE_RESUME		(1ULL << 4)
210

I
Ilya Dryomov 已提交
211 212 213 214
/*
 * Balance filters
 */
#define BTRFS_BALANCE_ARGS_PROFILES	(1ULL << 0)
I
Ilya Dryomov 已提交
215
#define BTRFS_BALANCE_ARGS_USAGE	(1ULL << 1)
I
Ilya Dryomov 已提交
216
#define BTRFS_BALANCE_ARGS_DEVID	(1ULL << 2)
I
Ilya Dryomov 已提交
217
#define BTRFS_BALANCE_ARGS_DRANGE	(1ULL << 3)
218
#define BTRFS_BALANCE_ARGS_VRANGE	(1ULL << 4)
219

220 221 222 223 224
/*
 * Profile changing flags.  When SOFT is set we won't relocate chunk if
 * it already has the target profile (even though it may be
 * half-filled).
 */
225
#define BTRFS_BALANCE_ARGS_CONVERT	(1ULL << 8)
226
#define BTRFS_BALANCE_ARGS_SOFT		(1ULL << 9)
227

228
struct btrfs_balance_args;
229
struct btrfs_balance_progress;
230 231 232 233 234 235 236 237
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;
238 239

	struct btrfs_balance_progress stat;
240 241
};

242 243 244
int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
				   u64 end, u64 *length);

245
#define btrfs_bio_size(n) (sizeof(struct btrfs_bio) + \
246 247
			    (sizeof(struct btrfs_bio_stripe) * (n)))

248 249
int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
			   struct btrfs_device *device,
250
			   u64 chunk_tree, u64 chunk_objectid,
Y
Yan Zheng 已提交
251
			   u64 chunk_offset, u64 start, u64 num_bytes);
252
int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
253
		    u64 logical, u64 *length,
254
		    struct btrfs_bio **bbio_ret, int mirror_num);
Y
Yan Zheng 已提交
255 256 257
int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
		     u64 chunk_start, u64 physical, u64 devid,
		     u64 **logical, int *naddrs, int *stripe_len);
Y
Yan Zheng 已提交
258
int btrfs_read_sys_array(struct btrfs_root *root);
259 260
int btrfs_read_chunk_tree(struct btrfs_root *root);
int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
Y
Yan Zheng 已提交
261
		      struct btrfs_root *extent_root, u64 type);
262 263
void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
264
int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
265
		  int mirror_num, int async_submit);
266
int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
267 268
		       fmode_t flags, void *holder);
int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
269 270
			  struct btrfs_fs_devices **fs_devices_ret);
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
271
void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices);
272 273 274 275 276
int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
					 char *device_path,
					 struct btrfs_device **device);
int btrfs_find_device_by_path(struct btrfs_root *root, char *device_path,
			      struct btrfs_device **device);
277 278 279
int btrfs_add_device(struct btrfs_trans_handle *trans,
		     struct btrfs_root *root,
		     struct btrfs_device *device);
280
int btrfs_rm_device(struct btrfs_root *root, char *device_path);
281
void btrfs_cleanup_fs_uuids(void);
282
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
283 284
int btrfs_grow_device(struct btrfs_trans_handle *trans,
		      struct btrfs_device *device, u64 new_size);
285
struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
Y
Yan Zheng 已提交
286
				       u8 *uuid, u8 *fsid);
287
int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
288
int btrfs_init_new_device(struct btrfs_root *root, char *path);
289 290
int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
				  struct btrfs_device **device_out);
291 292
int btrfs_balance(struct btrfs_balance_control *bctl,
		  struct btrfs_ioctl_balance_args *bargs);
293
int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
294
int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
295
int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
296
int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
Y
Yan Zheng 已提交
297
int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
298
int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes,
299
			 u64 *start, u64 *max_avail);
300 301
void btrfs_dev_stat_print_on_error(struct btrfs_device *device);
void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
302
int btrfs_get_dev_stats(struct btrfs_root *root,
303
			struct btrfs_ioctl_get_dev_stats *stats);
304 305 306
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);
307 308 309 310 311 312
void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
				 struct btrfs_device *srcdev);
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);
313
int btrfs_scratch_superblock(struct btrfs_device *device);
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349

static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
				      int index)
{
	atomic_inc(dev->dev_stat_values + index);
	dev->dev_stats_dirty = 1;
}

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);
	dev->dev_stats_dirty = 1;
	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);
	dev->dev_stats_dirty = 1;
}

static inline void btrfs_dev_stat_reset(struct btrfs_device *dev,
					int index)
{
	btrfs_dev_stat_set(dev, index, 0);
}
350
#endif