volumes.h

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #ifndef __BTRFS_VOLUMES_H__
  20 #define __BTRFS_VOLUMES_H__
  21
  22 #include "kerncompat.h"
  23 #include "ctree.h"
  24
  25 #define BTRFS_STRIPE_LEN        SZ_64K
  26
  27 struct btrfs_device {
  28         struct list_head dev_list;
  29         struct btrfs_root *dev_root;
  30         struct btrfs_fs_devices *fs_devices;
  31
  32         u64 total_ios;
  33
  34         int fd;
  35
  36         int writeable;
  37
  38         char *name;
  39
  40         /* these are read off the super block, only in the progs */
  41         char *label;
  42         u64 total_devs;
  43         u64 super_bytes_used;
  44
  45         u64 generation;
  46
  47         /* the internal btrfs device id */
  48         u64 devid;
  49
  50         /* size of the device */
  51         u64 total_bytes;
  52
  53         /* bytes used */
  54         u64 bytes_used;
  55
  56         /* optimal io alignment for this device */
  57         u32 io_align;
  58
  59         /* optimal io width for this device */
  60         u32 io_width;
  61
  62         /* minimal io size for this device */
  63         u32 sector_size;
  64
  65         /* type and info about this device */
  66         u64 type;
  67
  68         /* physical drive uuid (or lvm uuid) */
  69         u8 uuid[BTRFS_UUID_SIZE];
  70 };
  71
  72 struct btrfs_fs_devices {
  73         u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
  74
  75         /* the device with this id has the most recent copy of the super */
  76         u64 latest_devid;
  77         u64 latest_trans;
  78         u64 lowest_devid;
  79         int latest_bdev;
  80         int lowest_bdev;
  81         struct list_head devices;
  82         struct list_head list;
  83
  84         int seeding;
  85         struct btrfs_fs_devices *seed;
  86 };
  87
  88 struct btrfs_bio_stripe {
  89         struct btrfs_device *dev;
  90         u64 physical;
  91 };
  92
  93 struct btrfs_multi_bio {
  94         int error;
  95         int num_stripes;
  96         struct btrfs_bio_stripe stripes[];
  97 };
  98
  99 struct map_lookup {
 100         struct cache_extent ce;
 101         u64 type;
 102         int io_align;
 103         int io_width;
 104         int stripe_len;
 105         int sector_size;
 106         int num_stripes;
 107         int sub_stripes;
 108         struct btrfs_bio_stripe stripes[];
 109 };
 110
 111 struct btrfs_raid_attr {
 112         int sub_stripes;        /* sub_stripes info for map */
 113         int dev_stripes;        /* stripes per dev */
 114         int devs_max;           /* max devs to use */
 115         int devs_min;           /* min devs needed */
 116         int tolerated_failures; /* max tolerated fail devs */
 117         int devs_increment;     /* ndevs has to be a multiple of this */
 118         int ncopies;            /* how many copies to data has */
 119 };
 120
 121 extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
 122
 123 static inline enum btrfs_raid_types btrfs_bg_flags_to_raid_index(u64 flags)
 124 {
 125         if (flags & BTRFS_BLOCK_GROUP_RAID10)
 126                 return BTRFS_RAID_RAID10;
 127         else if (flags & BTRFS_BLOCK_GROUP_RAID1)
 128                 return BTRFS_RAID_RAID1;
 129         else if (flags & BTRFS_BLOCK_GROUP_DUP)
 130                 return BTRFS_RAID_DUP;
 131         else if (flags & BTRFS_BLOCK_GROUP_RAID0)
 132                 return BTRFS_RAID_RAID0;
 133         else if (flags & BTRFS_BLOCK_GROUP_RAID5)
 134                 return BTRFS_RAID_RAID5;
 135         else if (flags & BTRFS_BLOCK_GROUP_RAID6)
 136                 return BTRFS_RAID_RAID6;
 137
 138         return BTRFS_RAID_SINGLE; /* BTRFS_BLOCK_GROUP_SINGLE */
 139 }
 140
 141 #define btrfs_multi_bio_size(n) (sizeof(struct btrfs_multi_bio) + \
 142                             (sizeof(struct btrfs_bio_stripe) * (n)))
 143 #define btrfs_map_lookup_size(n) (sizeof(struct map_lookup) + \
 144                                  (sizeof(struct btrfs_bio_stripe) * (n)))
 145
 146 /*
 147  * Restriper's general type filter
 148  */
 149 #define BTRFS_BALANCE_DATA              (1ULL << 0)
 150 #define BTRFS_BALANCE_SYSTEM            (1ULL << 1)
 151 #define BTRFS_BALANCE_METADATA          (1ULL << 2)
 152
 153 #define BTRFS_BALANCE_TYPE_MASK         (BTRFS_BALANCE_DATA |       \
 154                                          BTRFS_BALANCE_SYSTEM |     \
 155                                          BTRFS_BALANCE_METADATA)
 156
 157 #define BTRFS_BALANCE_FORCE             (1ULL << 3)
 158 #define BTRFS_BALANCE_RESUME            (1ULL << 4)
 159
 160 /*
 161  * Balance filters
 162  */
 163 #define BTRFS_BALANCE_ARGS_PROFILES     (1ULL << 0)
 164 #define BTRFS_BALANCE_ARGS_USAGE        (1ULL << 1)
 165 #define BTRFS_BALANCE_ARGS_DEVID        (1ULL << 2)
 166 #define BTRFS_BALANCE_ARGS_DRANGE       (1ULL << 3)
 167 #define BTRFS_BALANCE_ARGS_VRANGE       (1ULL << 4)
 168 #define BTRFS_BALANCE_ARGS_LIMIT        (1ULL << 5)
 169 #define BTRFS_BALANCE_ARGS_LIMIT_RANGE  (1ULL << 6)
 170 #define BTRFS_BALANCE_ARGS_STRIPES_RANGE (1ULL << 7)
 171 #define BTRFS_BALANCE_ARGS_USAGE_RANGE  (1ULL << 10)
 172
 173 /*
 174  * Profile changing flags.  When SOFT is set we won't relocate chunk if
 175  * it already has the target profile (even though it may be
 176  * half-filled).
 177  */
 178 #define BTRFS_BALANCE_ARGS_CONVERT      (1ULL << 8)
 179 #define BTRFS_BALANCE_ARGS_SOFT         (1ULL << 9)
 180
 181 #define BTRFS_RAID5_P_STRIPE ((u64)-2)
 182 #define BTRFS_RAID6_Q_STRIPE ((u64)-1)
 183
 184 /*
 185  * Check if the given range cross stripes.
 186  * To ensure kernel scrub won't causing bug on with METADATA in mixed
 187  * block group
 188  *
 189  * Return 1 if the range crosses STRIPE boundary
 190  * Return 0 if the range doesn't cross STRIPE boundary or it
 191  * doesn't belong to any block group (no boundary to cross)
 192  */
 193 static inline int check_crossing_stripes(struct btrfs_fs_info *fs_info,
 194                                          u64 start, u64 len)
 195 {
 196         struct btrfs_block_group_cache *bg_cache;
 197         u64 bg_offset;
 198
 199         bg_cache = btrfs_lookup_block_group(fs_info, start);
 200         /*
 201          * Does not belong to block group, no boundary to cross
 202          * although it's a bigger problem, but here we don't care.
 203          */
 204         if (!bg_cache)
 205                 return 0;
 206         bg_offset = start - bg_cache->key.objectid;
 207
 208         return (bg_offset / BTRFS_STRIPE_LEN !=
 209                 (bg_offset + len - 1) / BTRFS_STRIPE_LEN);
 210 }
 211
 212 static inline u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
 213 {
 214         u64 stripe_size;
 215
 216         if (type & BTRFS_BLOCK_GROUP_RAID0) {
 217                 stripe_size = length;
 218                 stripe_size /= num_stripes;
 219         } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
 220                 stripe_size = length * 2;
 221                 stripe_size /= num_stripes;
 222         } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
 223                 stripe_size = length;
 224                 stripe_size /= (num_stripes - 1);
 225         } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
 226                 stripe_size = length;
 227                 stripe_size /= (num_stripes - 2);
 228         } else {
 229                 stripe_size = length;
 230         }
 231         return stripe_size;
 232 }
 233
 234 int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
 235                       u64 logical, u64 *length, u64 *type,
 236                       struct btrfs_multi_bio **multi_ret, int mirror_num,
 237                       u64 **raid_map);
 238 int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
 239                     u64 logical, u64 *length,
 240                     struct btrfs_multi_bio **multi_ret, int mirror_num,
 241                     u64 **raid_map_ret);
 242 int btrfs_next_bg(struct btrfs_fs_info *map_tree, u64 *logical,
 243                      u64 *size, u64 type);
 244 static inline int btrfs_next_bg_metadata(struct btrfs_fs_info *fs_info,
 245                                          u64 *logical, u64 *size)
 246 {
 247         return btrfs_next_bg(fs_info, logical, size,
 248                         BTRFS_BLOCK_GROUP_METADATA);
 249 }
 250 static inline int btrfs_next_bg_system(struct btrfs_fs_info *fs_info,
 251                                        u64 *logical, u64 *size)
 252 {
 253         return btrfs_next_bg(fs_info, logical, size,
 254                         BTRFS_BLOCK_GROUP_SYSTEM);
 255 }
 256 int btrfs_rmap_block(struct btrfs_fs_info *fs_info,
 257                      u64 chunk_start, u64 physical, u64 **logical,
 258                      int *naddrs, int *stripe_len);
 259 int btrfs_read_sys_array(struct btrfs_fs_info *fs_info);
 260 int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info);
 261 int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 262                       struct btrfs_fs_info *fs_info, u64 *start,
 263                       u64 *num_bytes, u64 type);
 264 int btrfs_alloc_data_chunk(struct btrfs_trans_handle *trans,
 265                            struct btrfs_fs_info *fs_info, u64 *start,
 266                            u64 num_bytes, u64 type, int convert);
 267 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
 268                        int flags);
 269 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
 270 void btrfs_close_all_devices(void);
 271 int btrfs_add_device(struct btrfs_trans_handle *trans,
 272                      struct btrfs_fs_info *fs_info,
 273                      struct btrfs_device *device);
 274 int btrfs_update_device(struct btrfs_trans_handle *trans,
 275                         struct btrfs_device *device);
 276 int btrfs_scan_one_device(int fd, const char *path,
 277                           struct btrfs_fs_devices **fs_devices_ret,
 278                           u64 *total_devs, u64 super_offset, unsigned sbflags);
 279 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
 280 struct list_head *btrfs_scanned_uuids(void);
 281 int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info, struct btrfs_key *key,
 282                            struct btrfs_chunk *chunk, int item_size);
 283 int btrfs_chunk_readonly(struct btrfs_fs_info *fs_info, u64 chunk_offset);
 284 struct btrfs_device *
 285 btrfs_find_device_by_devid(struct btrfs_fs_devices *fs_devices,
 286                            u64 devid, int instance);
 287 struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
 288                                        u8 *uuid, u8 *fsid);
 289 int write_raid56_with_parity(struct btrfs_fs_info *info,
 290                              struct extent_buffer *eb,
 291                              struct btrfs_multi_bio *multi,
 292                              u64 stripe_len, u64 *raid_map);
 293 int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
 294                             struct extent_buffer *leaf,
 295                             struct btrfs_chunk *chunk,
 296                             int slot, u64 logical);
 297 u64 btrfs_stripe_length(struct btrfs_fs_info *fs_info,
 298                         struct extent_buffer *leaf,
 299                         struct btrfs_chunk *chunk);
 300 int btrfs_fix_device_size(struct btrfs_fs_info *fs_info,
 301                           struct btrfs_device *device);
 302 int btrfs_fix_super_size(struct btrfs_fs_info *fs_info);
 303 int btrfs_fix_device_and_super_size(struct btrfs_fs_info *fs_info);
 304 #endif