mirror of
https://github.com/kdave/btrfs-progs
synced 2024-12-16 19:35:38 +00:00
979bda6fb5
To drop sizes.h from exported headers, replace the few SZ_ constants from the existing exported headers (ctree.h, send.h). It would be nice to use them in the long run but right now it would prevent unexporting the sizes.h file. Signed-off-by: David Sterba <dsterba@suse.com>
315 lines
9.4 KiB
C
315 lines
9.4 KiB
C
/*
|
|
* 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_H__
|
|
#define __BTRFS_VOLUMES_H__
|
|
|
|
#include "kerncompat.h"
|
|
#include "kernel-shared/ctree.h"
|
|
#include "kernel-lib/sizes.h"
|
|
|
|
#define BTRFS_STRIPE_LEN SZ_64K
|
|
|
|
struct btrfs_device {
|
|
struct list_head dev_list;
|
|
struct btrfs_root *dev_root;
|
|
struct btrfs_fs_devices *fs_devices;
|
|
struct btrfs_fs_info *fs_info;
|
|
|
|
u64 total_ios;
|
|
|
|
int fd;
|
|
|
|
int writeable;
|
|
|
|
char *name;
|
|
|
|
/* these are read off the super block, only in the progs */
|
|
char *label;
|
|
u64 total_devs;
|
|
u64 super_bytes_used;
|
|
|
|
u64 generation;
|
|
|
|
struct btrfs_zoned_device_info *zone_info;
|
|
|
|
/* 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) */
|
|
u8 uuid[BTRFS_UUID_SIZE];
|
|
};
|
|
|
|
enum btrfs_chunk_allocation_policy {
|
|
BTRFS_CHUNK_ALLOC_REGULAR,
|
|
BTRFS_CHUNK_ALLOC_ZONED,
|
|
};
|
|
|
|
struct btrfs_fs_devices {
|
|
u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
|
|
u8 metadata_uuid[BTRFS_FSID_SIZE]; /* FS specific uuid */
|
|
|
|
/* the device with this id has the most recent copy of the super */
|
|
u64 latest_devid;
|
|
u64 latest_trans;
|
|
u64 lowest_devid;
|
|
|
|
u64 total_rw_bytes;
|
|
|
|
int latest_bdev;
|
|
int lowest_bdev;
|
|
struct list_head devices;
|
|
struct list_head list;
|
|
|
|
int seeding;
|
|
struct btrfs_fs_devices *seed;
|
|
|
|
enum btrfs_chunk_allocation_policy chunk_alloc_policy;
|
|
};
|
|
|
|
struct btrfs_bio_stripe {
|
|
struct btrfs_device *dev;
|
|
u64 physical;
|
|
};
|
|
|
|
struct btrfs_multi_bio {
|
|
int error;
|
|
int num_stripes;
|
|
struct btrfs_bio_stripe stripes[];
|
|
};
|
|
|
|
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[];
|
|
};
|
|
|
|
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 */
|
|
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 */
|
|
};
|
|
|
|
extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
|
|
|
|
#define btrfs_multi_bio_size(n) (sizeof(struct btrfs_multi_bio) + \
|
|
(sizeof(struct btrfs_bio_stripe) * (n)))
|
|
#define btrfs_map_lookup_size(n) (sizeof(struct map_lookup) + \
|
|
(sizeof(struct btrfs_bio_stripe) * (n)))
|
|
|
|
/*
|
|
* 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)
|
|
#define BTRFS_BALANCE_ARGS_LIMIT (1ULL << 5)
|
|
#define BTRFS_BALANCE_ARGS_LIMIT_RANGE (1ULL << 6)
|
|
#define BTRFS_BALANCE_ARGS_STRIPES_RANGE (1ULL << 7)
|
|
#define BTRFS_BALANCE_ARGS_USAGE_RANGE (1ULL << 10)
|
|
|
|
/*
|
|
* 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)
|
|
|
|
#define BTRFS_RAID5_P_STRIPE ((u64)-2)
|
|
#define BTRFS_RAID6_Q_STRIPE ((u64)-1)
|
|
|
|
/*
|
|
* Check if the given range cross stripes.
|
|
* To ensure kernel scrub won't causing bug on with METADATA in mixed
|
|
* block group
|
|
*
|
|
* 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)
|
|
*/
|
|
static inline int check_crossing_stripes(struct btrfs_fs_info *fs_info,
|
|
u64 start, u64 len)
|
|
{
|
|
struct btrfs_block_group *bg_cache;
|
|
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;
|
|
bg_offset = start - bg_cache->start;
|
|
|
|
return (bg_offset / BTRFS_STRIPE_LEN !=
|
|
(bg_offset + len - 1) / BTRFS_STRIPE_LEN);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
|
|
u64 logical, u64 *length, u64 *type,
|
|
struct btrfs_multi_bio **multi_ret, int mirror_num,
|
|
u64 **raid_map);
|
|
int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
|
|
u64 logical, u64 *length,
|
|
struct btrfs_multi_bio **multi_ret, int mirror_num,
|
|
u64 **raid_map_ret);
|
|
int btrfs_next_bg(struct btrfs_fs_info *map_tree, u64 *logical,
|
|
u64 *size, u64 type);
|
|
static inline int btrfs_next_bg_metadata(struct btrfs_fs_info *fs_info,
|
|
u64 *logical, u64 *size)
|
|
{
|
|
return btrfs_next_bg(fs_info, logical, size,
|
|
BTRFS_BLOCK_GROUP_METADATA);
|
|
}
|
|
static inline int btrfs_next_bg_system(struct btrfs_fs_info *fs_info,
|
|
u64 *logical, u64 *size)
|
|
{
|
|
return btrfs_next_bg(fs_info, logical, size,
|
|
BTRFS_BLOCK_GROUP_SYSTEM);
|
|
}
|
|
int btrfs_rmap_block(struct btrfs_fs_info *fs_info,
|
|
u64 chunk_start, u64 physical, u64 **logical,
|
|
int *naddrs, int *stripe_len);
|
|
int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);
|
|
int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);
|
|
int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info, u64 *start,
|
|
u64 *num_bytes, u64 type);
|
|
int btrfs_alloc_data_chunk(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info, u64 *start, u64 num_bytes);
|
|
int btrfs_open_devices(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_fs_devices *fs_devices, int flags);
|
|
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
|
|
void btrfs_close_all_devices(void);
|
|
int btrfs_insert_dev_extent(struct btrfs_trans_handle *trans,
|
|
struct btrfs_device *device,
|
|
u64 chunk_offset, u64 num_bytes, u64 start);
|
|
int btrfs_add_device(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *device);
|
|
int btrfs_update_device(struct btrfs_trans_handle *trans,
|
|
struct btrfs_device *device);
|
|
int btrfs_scan_one_device(int fd, const char *path,
|
|
struct btrfs_fs_devices **fs_devices_ret,
|
|
u64 *total_devs, u64 super_offset, unsigned sbflags);
|
|
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
|
|
struct list_head *btrfs_scanned_uuids(void);
|
|
int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info, struct btrfs_key *key,
|
|
struct btrfs_chunk *chunk, int item_size);
|
|
int btrfs_chunk_readonly(struct btrfs_fs_info *fs_info, u64 chunk_offset);
|
|
struct btrfs_device *
|
|
btrfs_find_device_by_devid(struct btrfs_fs_devices *fs_devices,
|
|
u64 devid, int instance);
|
|
struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
|
|
u8 *uuid, u8 *fsid);
|
|
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);
|
|
int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
|
|
struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk,
|
|
int slot, u64 logical);
|
|
u64 btrfs_stripe_length(struct btrfs_fs_info *fs_info,
|
|
struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk);
|
|
int btrfs_fix_device_size(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *device);
|
|
int btrfs_fix_super_size(struct btrfs_fs_info *fs_info);
|
|
int btrfs_fix_device_and_super_size(struct btrfs_fs_info *fs_info);
|
|
|
|
enum btrfs_raid_types btrfs_bg_flags_to_raid_index(u64 flags);
|
|
int btrfs_bg_type_to_factor(u64 flags);
|
|
const char *btrfs_bg_type_to_raid_name(u64 flags);
|
|
int btrfs_bg_type_to_tolerated_failures(u64 flags);
|
|
|
|
#endif
|