2008-03-25 03:03:18 +08:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2015-01-22 00:49:26 +08:00
|
|
|
#ifndef __BTRFS_VOLUMES_H__
|
|
|
|
#define __BTRFS_VOLUMES_H__
|
2012-02-22 10:20:54 +08:00
|
|
|
|
2015-06-10 08:21:42 +08:00
|
|
|
#include "kerncompat.h"
|
2020-08-18 21:56:04 +08:00
|
|
|
#include "kernel-shared/ctree.h"
|
2015-06-10 08:21:42 +08:00
|
|
|
|
2017-01-24 11:03:05 +08:00
|
|
|
#define BTRFS_STRIPE_LEN SZ_64K
|
2013-12-16 20:33:57 +08:00
|
|
|
|
2008-03-25 03:03:18 +08:00
|
|
|
struct btrfs_device {
|
|
|
|
struct list_head dev_list;
|
|
|
|
struct btrfs_root *dev_root;
|
2008-11-18 23:40:06 +08:00
|
|
|
struct btrfs_fs_devices *fs_devices;
|
2008-03-25 03:03:18 +08:00
|
|
|
|
2008-04-04 04:35:48 +08:00
|
|
|
u64 total_ios;
|
|
|
|
|
2008-03-25 03:03:18 +08:00
|
|
|
int fd;
|
|
|
|
|
2008-11-18 23:40:06 +08:00
|
|
|
int writeable;
|
|
|
|
|
2008-03-25 03:05:44 +08:00
|
|
|
char *name;
|
|
|
|
|
2008-04-23 02:06:31 +08:00
|
|
|
/* these are read off the super block, only in the progs */
|
|
|
|
char *label;
|
|
|
|
u64 total_devs;
|
|
|
|
u64 super_bytes_used;
|
|
|
|
|
2014-10-06 18:16:46 +08:00
|
|
|
u64 generation;
|
|
|
|
|
2008-03-25 03:03:18 +08:00
|
|
|
/* the internal btrfs device id */
|
|
|
|
u64 devid;
|
|
|
|
|
|
|
|
/* size of the device */
|
|
|
|
u64 total_bytes;
|
|
|
|
|
|
|
|
/* 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) */
|
2008-04-16 03:42:08 +08:00
|
|
|
u8 uuid[BTRFS_UUID_SIZE];
|
2008-03-25 03:03:18 +08:00
|
|
|
};
|
|
|
|
|
2008-03-25 03:05:44 +08:00
|
|
|
struct btrfs_fs_devices {
|
|
|
|
u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
|
2018-10-11 23:03:59 +08:00
|
|
|
u8 metadata_uuid[BTRFS_FSID_SIZE]; /* FS specific uuid */
|
2008-03-25 03:05:44 +08:00
|
|
|
|
2014-06-14 07:43:56 +08:00
|
|
|
/* the device with this id has the most recent copy of the super */
|
2008-03-25 03:05:44 +08:00
|
|
|
u64 latest_devid;
|
|
|
|
u64 latest_trans;
|
|
|
|
u64 lowest_devid;
|
2019-02-05 14:53:11 +08:00
|
|
|
|
|
|
|
u64 total_rw_bytes;
|
|
|
|
|
2008-03-25 03:05:44 +08:00
|
|
|
int latest_bdev;
|
|
|
|
int lowest_bdev;
|
|
|
|
struct list_head devices;
|
|
|
|
struct list_head list;
|
2008-11-18 23:40:06 +08:00
|
|
|
|
|
|
|
int seeding;
|
|
|
|
struct btrfs_fs_devices *seed;
|
2008-03-25 03:05:44 +08:00
|
|
|
};
|
|
|
|
|
2008-04-10 04:28:12 +08:00
|
|
|
struct btrfs_bio_stripe {
|
|
|
|
struct btrfs_device *dev;
|
|
|
|
u64 physical;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct btrfs_multi_bio {
|
|
|
|
int error;
|
|
|
|
int num_stripes;
|
|
|
|
struct btrfs_bio_stripe stripes[];
|
|
|
|
};
|
|
|
|
|
2012-02-22 10:20:54 +08:00
|
|
|
struct map_lookup {
|
|
|
|
struct cache_extent ce;
|
|
|
|
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[];
|
|
|
|
};
|
|
|
|
|
2018-02-09 15:44:22 +08:00
|
|
|
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 */
|
|
|
|
int tolerated_failures; /* max tolerated fail devs */
|
|
|
|
int devs_increment; /* ndevs has to be a multiple of this */
|
|
|
|
int ncopies; /* how many copies to data has */
|
2019-06-20 04:15:15 +08:00
|
|
|
int nparity; /* number of stripes worth of bytes to store
|
|
|
|
* parity information */
|
|
|
|
int mindev_error; /* error code if min devs requisite is unmet */
|
|
|
|
const char raid_name[8]; /* name of the raid */
|
|
|
|
u64 bg_flag; /* block group flag of the raid */
|
2018-02-09 15:44:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
|
|
|
|
|
|
|
|
static inline enum btrfs_raid_types btrfs_bg_flags_to_raid_index(u64 flags)
|
|
|
|
{
|
|
|
|
if (flags & BTRFS_BLOCK_GROUP_RAID10)
|
|
|
|
return BTRFS_RAID_RAID10;
|
|
|
|
else if (flags & BTRFS_BLOCK_GROUP_RAID1)
|
|
|
|
return BTRFS_RAID_RAID1;
|
2019-11-01 02:43:17 +08:00
|
|
|
else if (flags & BTRFS_BLOCK_GROUP_RAID1C3)
|
|
|
|
return BTRFS_RAID_RAID1C3;
|
|
|
|
else if (flags & BTRFS_BLOCK_GROUP_RAID1C4)
|
|
|
|
return BTRFS_RAID_RAID1C4;
|
2018-02-09 15:44:22 +08:00
|
|
|
else if (flags & BTRFS_BLOCK_GROUP_DUP)
|
|
|
|
return BTRFS_RAID_DUP;
|
|
|
|
else if (flags & BTRFS_BLOCK_GROUP_RAID0)
|
|
|
|
return BTRFS_RAID_RAID0;
|
|
|
|
else if (flags & BTRFS_BLOCK_GROUP_RAID5)
|
|
|
|
return BTRFS_RAID_RAID5;
|
|
|
|
else if (flags & BTRFS_BLOCK_GROUP_RAID6)
|
|
|
|
return BTRFS_RAID_RAID6;
|
|
|
|
|
|
|
|
return BTRFS_RAID_SINGLE; /* BTRFS_BLOCK_GROUP_SINGLE */
|
|
|
|
}
|
|
|
|
|
2008-04-10 04:28:12 +08:00
|
|
|
#define btrfs_multi_bio_size(n) (sizeof(struct btrfs_multi_bio) + \
|
|
|
|
(sizeof(struct btrfs_bio_stripe) * (n)))
|
2013-07-03 21:25:17 +08:00
|
|
|
#define btrfs_map_lookup_size(n) (sizeof(struct map_lookup) + \
|
|
|
|
(sizeof(struct btrfs_bio_stripe) * (n)))
|
2008-04-10 04:28:12 +08:00
|
|
|
|
2012-02-04 03:02:29 +08:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
|
|
|
|
#define BTRFS_BALANCE_FORCE (1ULL << 3)
|
|
|
|
#define BTRFS_BALANCE_RESUME (1ULL << 4)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Balance filters
|
|
|
|
*/
|
|
|
|
#define BTRFS_BALANCE_ARGS_PROFILES (1ULL << 0)
|
|
|
|
#define BTRFS_BALANCE_ARGS_USAGE (1ULL << 1)
|
|
|
|
#define BTRFS_BALANCE_ARGS_DEVID (1ULL << 2)
|
|
|
|
#define BTRFS_BALANCE_ARGS_DRANGE (1ULL << 3)
|
|
|
|
#define BTRFS_BALANCE_ARGS_VRANGE (1ULL << 4)
|
2014-05-07 23:38:00 +08:00
|
|
|
#define BTRFS_BALANCE_ARGS_LIMIT (1ULL << 5)
|
2015-10-12 06:34:58 +08:00
|
|
|
#define BTRFS_BALANCE_ARGS_LIMIT_RANGE (1ULL << 6)
|
2015-09-29 06:33:04 +08:00
|
|
|
#define BTRFS_BALANCE_ARGS_STRIPES_RANGE (1ULL << 7)
|
2015-10-22 16:19:38 +08:00
|
|
|
#define BTRFS_BALANCE_ARGS_USAGE_RANGE (1ULL << 10)
|
2012-02-04 03:02:29 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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).
|
|
|
|
*/
|
|
|
|
#define BTRFS_BALANCE_ARGS_CONVERT (1ULL << 8)
|
|
|
|
#define BTRFS_BALANCE_ARGS_SOFT (1ULL << 9)
|
|
|
|
|
2009-07-12 01:12:37 +08:00
|
|
|
#define BTRFS_RAID5_P_STRIPE ((u64)-2)
|
|
|
|
#define BTRFS_RAID6_Q_STRIPE ((u64)-1)
|
|
|
|
|
2015-07-23 17:18:08 +08:00
|
|
|
/*
|
|
|
|
* Check if the given range cross stripes.
|
|
|
|
* To ensure kernel scrub won't causing bug on with METADATA in mixed
|
|
|
|
* block group
|
2016-10-24 15:22:33 +08:00
|
|
|
*
|
|
|
|
* Return 1 if the range crosses STRIPE boundary
|
|
|
|
* Return 0 if the range doesn't cross STRIPE boundary or it
|
|
|
|
* doesn't belong to any block group (no boundary to cross)
|
2015-07-23 17:18:08 +08:00
|
|
|
*/
|
2016-10-24 15:22:33 +08:00
|
|
|
static inline int check_crossing_stripes(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 start, u64 len)
|
2015-07-23 17:18:08 +08:00
|
|
|
{
|
2020-05-01 14:52:19 +08:00
|
|
|
struct btrfs_block_group *bg_cache;
|
2016-10-24 15:22:33 +08:00
|
|
|
u64 bg_offset;
|
|
|
|
|
|
|
|
bg_cache = btrfs_lookup_block_group(fs_info, start);
|
|
|
|
/*
|
|
|
|
* Does not belong to block group, no boundary to cross
|
|
|
|
* although it's a bigger problem, but here we don't care.
|
|
|
|
*/
|
|
|
|
if (!bg_cache)
|
|
|
|
return 0;
|
2020-05-01 14:52:17 +08:00
|
|
|
bg_offset = start - bg_cache->start;
|
2016-10-24 15:22:33 +08:00
|
|
|
|
|
|
|
return (bg_offset / BTRFS_STRIPE_LEN !=
|
|
|
|
(bg_offset + len - 1) / BTRFS_STRIPE_LEN);
|
2015-07-23 17:18:08 +08:00
|
|
|
}
|
2009-07-12 01:12:37 +08:00
|
|
|
|
2018-02-09 15:44:26 +08:00
|
|
|
static inline u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
|
|
|
|
{
|
|
|
|
u64 stripe_size;
|
|
|
|
|
|
|
|
if (type & BTRFS_BLOCK_GROUP_RAID0) {
|
|
|
|
stripe_size = length;
|
|
|
|
stripe_size /= num_stripes;
|
|
|
|
} else if (type & BTRFS_BLOCK_GROUP_RAID10) {
|
|
|
|
stripe_size = length * 2;
|
|
|
|
stripe_size /= num_stripes;
|
|
|
|
} else if (type & BTRFS_BLOCK_GROUP_RAID5) {
|
|
|
|
stripe_size = length;
|
|
|
|
stripe_size /= (num_stripes - 1);
|
|
|
|
} else if (type & BTRFS_BLOCK_GROUP_RAID6) {
|
|
|
|
stripe_size = length;
|
|
|
|
stripe_size /= (num_stripes - 2);
|
|
|
|
} else {
|
|
|
|
stripe_size = length;
|
|
|
|
}
|
|
|
|
return stripe_size;
|
|
|
|
}
|
|
|
|
|
2017-06-13 17:19:17 +08:00
|
|
|
int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
|
2011-08-26 21:51:36 +08:00
|
|
|
u64 logical, u64 *length, u64 *type,
|
2009-07-12 01:12:37 +08:00
|
|
|
struct btrfs_multi_bio **multi_ret, int mirror_num,
|
|
|
|
u64 **raid_map);
|
2017-06-13 17:19:17 +08:00
|
|
|
int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
|
2008-04-10 04:28:12 +08:00
|
|
|
u64 logical, u64 *length,
|
2009-07-12 01:12:37 +08:00
|
|
|
struct btrfs_multi_bio **multi_ret, int mirror_num,
|
|
|
|
u64 **raid_map_ret);
|
2017-06-13 17:19:19 +08:00
|
|
|
int btrfs_next_bg(struct btrfs_fs_info *map_tree, u64 *logical,
|
2015-11-13 10:53:41 +08:00
|
|
|
u64 *size, u64 type);
|
2017-06-13 17:19:19 +08:00
|
|
|
static inline int btrfs_next_bg_metadata(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 *logical, u64 *size)
|
2015-11-13 10:53:41 +08:00
|
|
|
{
|
2017-06-13 17:19:19 +08:00
|
|
|
return btrfs_next_bg(fs_info, logical, size,
|
2015-11-13 10:53:41 +08:00
|
|
|
BTRFS_BLOCK_GROUP_METADATA);
|
|
|
|
}
|
2017-06-13 17:19:19 +08:00
|
|
|
static inline int btrfs_next_bg_system(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 *logical, u64 *size)
|
2015-11-13 10:53:41 +08:00
|
|
|
{
|
2017-06-13 17:19:19 +08:00
|
|
|
return btrfs_next_bg(fs_info, logical, size,
|
2015-11-13 10:53:41 +08:00
|
|
|
BTRFS_BLOCK_GROUP_SYSTEM);
|
|
|
|
}
|
2017-06-13 17:19:17 +08:00
|
|
|
int btrfs_rmap_block(struct btrfs_fs_info *fs_info,
|
2018-05-04 15:47:25 +08:00
|
|
|
u64 chunk_start, u64 physical, u64 **logical,
|
|
|
|
int *naddrs, int *stripe_len);
|
2017-06-13 17:19:30 +08:00
|
|
|
int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);
|
|
|
|
int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);
|
2008-03-25 03:03:18 +08:00
|
|
|
int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
|
2017-06-13 17:19:35 +08:00
|
|
|
struct btrfs_fs_info *fs_info, u64 *start,
|
2008-03-25 03:03:58 +08:00
|
|
|
u64 *num_bytes, u64 type);
|
2010-07-08 17:17:59 +08:00
|
|
|
int btrfs_alloc_data_chunk(struct btrfs_trans_handle *trans,
|
2019-10-30 20:22:27 +08:00
|
|
|
struct btrfs_fs_info *fs_info, u64 *start, u64 num_bytes);
|
2008-03-25 03:05:44 +08:00
|
|
|
int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
|
|
|
|
int flags);
|
|
|
|
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
|
2015-08-24 16:45:02 +08:00
|
|
|
void btrfs_close_all_devices(void);
|
2018-11-27 16:38:26 +08:00
|
|
|
int btrfs_insert_dev_extent(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_device *device,
|
|
|
|
u64 chunk_offset, u64 num_bytes, u64 start);
|
2008-03-25 03:05:44 +08:00
|
|
|
int btrfs_add_device(struct btrfs_trans_handle *trans,
|
2017-06-13 17:19:33 +08:00
|
|
|
struct btrfs_fs_info *fs_info,
|
2008-03-25 03:05:44 +08:00
|
|
|
struct btrfs_device *device);
|
2008-04-23 02:06:56 +08:00
|
|
|
int btrfs_update_device(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_device *device);
|
2008-03-25 03:05:44 +08:00
|
|
|
int btrfs_scan_one_device(int fd, const char *path,
|
|
|
|
struct btrfs_fs_devices **fs_devices_ret,
|
2016-08-19 22:36:40 +08:00
|
|
|
u64 *total_devs, u64 super_offset, unsigned sbflags);
|
2017-06-13 17:19:18 +08:00
|
|
|
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
|
2008-04-23 02:06:31 +08:00
|
|
|
struct list_head *btrfs_scanned_uuids(void);
|
2017-06-13 17:19:31 +08:00
|
|
|
int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info, struct btrfs_key *key,
|
2008-04-23 02:06:56 +08:00
|
|
|
struct btrfs_chunk *chunk, int item_size);
|
2017-06-13 17:19:32 +08:00
|
|
|
int btrfs_chunk_readonly(struct btrfs_fs_info *fs_info, u64 chunk_offset);
|
2013-07-03 21:25:19 +08:00
|
|
|
struct btrfs_device *
|
|
|
|
btrfs_find_device_by_devid(struct btrfs_fs_devices *fs_devices,
|
|
|
|
u64 devid, int instance);
|
2017-06-13 17:19:29 +08:00
|
|
|
struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
|
2013-07-03 21:25:17 +08:00
|
|
|
u8 *uuid, u8 *fsid);
|
Btrfs-progs: enhance btrfs-image to restore image onto multiple disks
This adds a 'btrfs-image -m' option, which let us restore an image that
is built from a btrfs of multiple disks onto several disks altogether.
This aims to address the following case,
$ mkfs.btrfs -m raid0 sda sdb
$ btrfs-image sda image.file
$ btrfs-image -r image.file sdc
---------
so we can only restore metadata onto sdc, and another thing is we can
only mount sdc with degraded mode as we don't provide informations of
another disk. And, it's built as RAID0 and we have only one disk,
so after mount sdc we'll get into readonly mode.
This is just annoying for people(like me) who're trying to restore image
but turn to find they cannot make it work.
So this'll make your life easier, just tap
$ btrfs-image -m image.file sdc sdd
---------
then you get everything about metadata done, the same offset with that of
the originals(of course, you need offer enough disk size, at least the disk
size of the original disks).
Besides, this also works with raid5 and raid6 metadata image.
Signed-off-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2013-06-22 13:32:45 +08:00
|
|
|
int write_raid56_with_parity(struct btrfs_fs_info *info,
|
|
|
|
struct extent_buffer *eb,
|
|
|
|
struct btrfs_multi_bio *multi,
|
|
|
|
u64 stripe_len, u64 *raid_map);
|
2017-06-13 17:19:28 +08:00
|
|
|
int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
|
2016-08-29 16:09:02 +08:00
|
|
|
struct extent_buffer *leaf,
|
|
|
|
struct btrfs_chunk *chunk,
|
|
|
|
int slot, u64 logical);
|
2017-05-31 13:56:08 +08:00
|
|
|
u64 btrfs_stripe_length(struct btrfs_fs_info *fs_info,
|
|
|
|
struct extent_buffer *leaf,
|
|
|
|
struct btrfs_chunk *chunk);
|
2017-10-17 13:00:41 +08:00
|
|
|
int btrfs_fix_device_size(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_device *device);
|
2017-10-17 15:12:39 +08:00
|
|
|
int btrfs_fix_super_size(struct btrfs_fs_info *fs_info);
|
2017-10-17 15:45:50 +08:00
|
|
|
int btrfs_fix_device_and_super_size(struct btrfs_fs_info *fs_info);
|
2008-03-25 03:03:18 +08:00
|
|
|
#endif
|