volumes.h 9.4 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

54
	spinlock_t io_lock;
55 56 57

	struct block_device *bdev;

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

61
	struct rcu_string *name;
62

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

	/* size of the device */
	u64 total_bytes;

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

72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
	/* 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) */
88
	u8 uuid[BTRFS_UUID_SIZE];
89

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

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

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

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

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

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

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

	/* 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;
137
	struct list_head devices;
138 139 140

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

	struct btrfs_fs_devices *seed;
	int seeding;

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

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

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

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

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

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

182 183 184 185 186 187 188 189 190 191 192
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 已提交
193 194 195
#define map_lookup_size(n) (sizeof(struct map_lookup) + \
			    (sizeof(struct btrfs_bio_stripe) * (n)))

196 197 198 199 200 201 202 203 204 205
/*
 * 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)
206 207

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

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

219 220 221 222 223
/*
 * 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).
 */
224
#define BTRFS_BALANCE_ARGS_CONVERT	(1ULL << 8)
225
#define BTRFS_BALANCE_ARGS_SOFT		(1ULL << 9)
226

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

	struct btrfs_balance_progress stat;
239 240
};

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

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

247 248
int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
			   struct btrfs_device *device,
249
			   u64 chunk_tree, u64 chunk_objectid,
Y
Yan Zheng 已提交
250
			   u64 chunk_offset, u64 start, u64 num_bytes);
251
int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
252
		    u64 logical, u64 *length,
253
		    struct btrfs_bio **bbio_ret, int mirror_num);
Y
Yan Zheng 已提交
254 255 256
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 已提交
257
int btrfs_read_sys_array(struct btrfs_root *root);
258 259
int btrfs_read_chunk_tree(struct btrfs_root *root);
int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
Y
Yan Zheng 已提交
260
		      struct btrfs_root *extent_root, u64 type);
261 262
void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
263
int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
264
		  int mirror_num, int async_submit);
265
int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
266 267
		       fmode_t flags, void *holder);
int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
268 269
			  struct btrfs_fs_devices **fs_devices_ret);
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
270
void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices);
271 272 273 274 275
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);
276 277 278
int btrfs_add_device(struct btrfs_trans_handle *trans,
		     struct btrfs_root *root,
		     struct btrfs_device *device);
279
int btrfs_rm_device(struct btrfs_root *root, char *device_path);
280
void btrfs_cleanup_fs_uuids(void);
281
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
282 283 284
int btrfs_grow_device(struct btrfs_trans_handle *trans,
		      struct btrfs_device *device, u64 new_size);
struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid,
Y
Yan Zheng 已提交
285
				       u8 *uuid, u8 *fsid);
286
int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
287
int btrfs_init_new_device(struct btrfs_root *root, char *path);
288 289
int btrfs_balance(struct btrfs_balance_control *bctl,
		  struct btrfs_ioctl_balance_args *bargs);
290
int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
291
int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
292
int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
293
int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
Y
Yan Zheng 已提交
294
int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
295
int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes,
296
			 u64 *start, u64 *max_avail);
297 298
void btrfs_dev_stat_print_on_error(struct btrfs_device *device);
void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index);
299
int btrfs_get_dev_stats(struct btrfs_root *root,
300
			struct btrfs_ioctl_get_dev_stats *stats);
301 302 303
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);
304 305 306 307 308 309 310 311 312 313 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

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);
}
340
#endif