external/gpl2/lvm2/dist/lib/metadata/metadata.h

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   5  * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
   6  *
   7  * This file is part of LVM2.
   8  *
   9  * This copyrighted material is made available to anyone wishing to use,
  10  * modify, copy, or redistribute it subject to the terms and conditions
  11  * of the GNU Lesser General Public License v.2.1.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this program; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 /*
  19  * This is the in core representation of a volume group and its
  20  * associated physical and logical volumes.
  21  */
  22
  23 #ifndef _LVM_METADATA_H
  24 #define _LVM_METADATA_H
  25
  26 #include "ctype.h"
  27 #include "dev-cache.h"
  28 #include "lvm-string.h"
  29 #include "metadata-exported.h"
  30
  31 //#define MAX_STRIPES 128U
  32 //#define SECTOR_SHIFT 9L
  33 #define SECTOR_SIZE ( 1L << SECTOR_SHIFT )
  34 //#define STRIPE_SIZE_MIN ( (unsigned) lvm_getpagesize() >> SECTOR_SHIFT)       /* PAGESIZE in sectors */
  35 //#define STRIPE_SIZE_MAX ( 512L * 1024L >> SECTOR_SHIFT)       /* 512 KB in sectors */
  36 //#define STRIPE_SIZE_LIMIT ((UINT_MAX >> 2) + 1)
  37 //#define PV_MIN_SIZE ( 512L * 1024L >> SECTOR_SHIFT)   /* 512 KB in sectors */
  38 //#define MAX_RESTRICTED_LVS 255        /* Used by FMT_RESTRICTED_LVIDS */
  39 #define MIRROR_LOG_OFFSET       2       /* sectors */
  40 #define VG_MEMPOOL_CHUNK        10240   /* in bytes, hint only */
  41
  42 /*
  43  * Ceiling(n / sz)
  44  */
  45 #define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
  46
  47 /*
  48  * Ceiling(n / size) * size
  49  */
  50 #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
  51
  52
  53 /* Various flags */
  54 /* Note that the bits no longer necessarily correspond to LVM1 disk format */
  55
  56 //#define PARTIAL_VG            0x00000001U     /* VG */
  57 //#define EXPORTED_VG           0x00000002U     /* VG PV */
  58 //#define RESIZEABLE_VG         0x00000004U     /* VG */
  59
  60 /* May any free extents on this PV be used or must they be left free? */
  61 //#define ALLOCATABLE_PV                0x00000008U     /* PV */
  62
  63 #define SPINDOWN_LV             0x00000010U     /* LV */
  64 #define BADBLOCK_ON             0x00000020U     /* LV */
  65 //#define VISIBLE_LV            0x00000040U     /* LV */
  66 //#define FIXED_MINOR           0x00000080U     /* LV */
  67 /* FIXME Remove when metadata restructuring is completed */
  68 //#define SNAPSHOT              0x00001000U     /* LV - internal use only */
  69 //#define PVMOVE                        0x00002000U     /* VG LV SEG */
  70 //#define LOCKED                        0x00004000U     /* LV */
  71 //#define MIRRORED              0x00008000U     /* LV - internal use only */
  72 #define VIRTUAL                 0x00010000U     /* LV - internal use only */
  73 //#define MIRROR_LOG            0x00020000U     /* LV */
  74 //#define MIRROR_IMAGE          0x00040000U     /* LV */
  75 //#define MIRROR_NOTSYNCED      0x00080000U     /* LV */
  76 #define ACTIVATE_EXCL           0x00100000U     /* LV - internal use only */
  77 #define PRECOMMITTED            0x00200000U     /* VG - internal use only */
  78 //#define CONVERTING            0x00400000U     /* LV */
  79
  80 //#define MISSING_PV            0x00800000U     /* PV */
  81 //#define PARTIAL_LV            0x01000000U     /* LV - derived flag, not
  82 //                                                 written out in metadata*/
  83
  84 #define POSTORDER_FLAG          0x02000000U /* Not real flags, reserved for  */
  85 #define POSTORDER_OPEN_FLAG     0x04000000U /* temporary use inside vg_read_internal. */
  86 #define VIRTUAL_ORIGIN          0x08000000U     /* LV - internal use only */
  87
  88 //#define LVM_READ                      0x00000100U     /* LV VG */
  89 //#define LVM_WRITE                     0x00000200U     /* LV VG */
  90 //#define CLUSTERED             0x00000400U     /* VG */
  91 #define SHARED                  0x00000800U     /* VG */
  92
  93 /* Format features flags */
  94 //#define FMT_SEGMENTS          0x00000001U     /* Arbitrary segment params? */
  95 //#define FMT_MDAS              0x00000002U     /* Proper metadata areas? */
  96 //#define FMT_TAGS              0x00000004U     /* Tagging? */
  97 //#define FMT_UNLIMITED_VOLS    0x00000008U     /* Unlimited PVs/LVs? */
  98 //#define FMT_RESTRICTED_LVIDS  0x00000010U     /* LVID <= 255 */
  99 //#define FMT_ORPHAN_ALLOCATABLE        0x00000020U     /* Orphan PV allocatable? */
 100 #define FMT_PRECOMMIT           0x00000040U     /* Supports pre-commit? */
 101 //#define FMT_RESIZE_PV         0x00000080U     /* Supports pvresize? */
 102 //#define FMT_UNLIMITED_STRIPESIZE 0x00000100U  /* Unlimited stripe size? */
 103
 104 struct metadata_area;
 105
 106 /* Per-format per-metadata area operations */
 107 struct metadata_area_ops {
 108         struct volume_group *(*vg_read) (struct format_instance * fi,
 109                                          const char *vg_name,
 110                                          struct metadata_area * mda);
 111         struct volume_group *(*vg_read_precommit) (struct format_instance * fi,
 112                                          const char *vg_name,
 113                                          struct metadata_area * mda);
 114         /*
 115          * Write out complete VG metadata.  You must ensure internal
 116          * consistency before calling. eg. PEs can't refer to PVs not
 117          * part of the VG.
 118          *
 119          * It is also the responsibility of the caller to ensure external
 120          * consistency, eg by calling pv_write() if removing PVs from
 121          * a VG or calling vg_write() a second time if splitting a VG
 122          * into two.
 123          *
 124          * vg_write() should not read or write from any PVs not included
 125          * in the volume_group structure it is handed.
 126          * (format1 currently breaks this rule.)
 127          */
 128         int (*vg_write) (struct format_instance * fid, struct volume_group * vg,
 129                          struct metadata_area * mda);
 130         int (*vg_precommit) (struct format_instance * fid,
 131                              struct volume_group * vg,
 132                              struct metadata_area * mda);
 133         int (*vg_commit) (struct format_instance * fid,
 134                           struct volume_group * vg, struct metadata_area * mda);
 135         int (*vg_revert) (struct format_instance * fid,
 136                           struct volume_group * vg, struct metadata_area * mda);
 137         int (*vg_remove) (struct format_instance * fi, struct volume_group * vg,
 138                           struct metadata_area * mda);
 139
 140         /*
 141          * Returns number of free sectors in given metadata area.
 142          */
 143         uint64_t (*mda_free_sectors) (struct metadata_area *mda);
 144
 145         /*
 146          * Returns number of total sectors in given metadata area.
 147          */
 148         uint64_t (*mda_total_sectors) (struct metadata_area *mda);
 149
 150         /*
 151          * Check if metadata area belongs to vg
 152          */
 153         int (*mda_in_vg) (struct format_instance * fi,
 154                             struct volume_group * vg, struct metadata_area *mda);
 155         /*
 156          * Analyze a metadata area on a PV.
 157          */
 158         int (*pv_analyze_mda) (const struct format_type * fmt,
 159                                struct metadata_area *mda);
 160
 161 };
 162
 163 struct metadata_area {
 164         struct dm_list list;
 165         struct metadata_area_ops *ops;
 166         void *metadata_locn;
 167 };
 168
 169 #define seg_pvseg(seg, s)       (seg)->areas[(s)].u.pv.pvseg
 170 #define seg_dev(seg, s)         (seg)->areas[(s)].u.pv.pvseg->pv->dev
 171 #define seg_pe(seg, s)          (seg)->areas[(s)].u.pv.pvseg->pe
 172 #define seg_le(seg, s)          (seg)->areas[(s)].u.lv.le
 173
 174 struct name_list {
 175         struct dm_list list;
 176         char *name;
 177 };
 178
 179 struct mda_list {
 180         struct dm_list list;
 181         struct device_area mda;
 182 };
 183
 184 struct peg_list {
 185         struct dm_list list;
 186         struct pv_segment *peg;
 187 };
 188
 189 struct seg_list {
 190         struct dm_list list;
 191         unsigned count;
 192         struct lv_segment *seg;
 193 };
 194
 195 /*
 196  * Ownership of objects passes to caller.
 197  */
 198 struct format_handler {
 199         /*
 200          * Scan any metadata areas that aren't referenced in PV labels
 201          */
 202         int (*scan) (const struct format_type * fmt);
 203
 204         /*
 205          * Return PV with given path.
 206          */
 207         int (*pv_read) (const struct format_type * fmt, const char *pv_name,
 208                         struct physical_volume * pv, struct dm_list *mdas,
 209                         int scan_label_only);
 210
 211         /*
 212          * Tweak an already filled out a pv ready for importing into a
 213          * vg.  eg. pe_count is format specific.
 214          */
 215         int (*pv_setup) (const struct format_type * fmt,
 216                          uint64_t pe_start, uint32_t extent_count,
 217                          uint32_t extent_size, unsigned long data_alignment,
 218                          unsigned long data_alignment_offset,
 219                          int pvmetadatacopies,
 220                          uint64_t pvmetadatasize, struct dm_list * mdas,
 221                          struct physical_volume * pv, struct volume_group * vg);
 222
 223         /*
 224          * Write a PV structure to disk. Fails if the PV is in a VG ie
 225          * pv->vg_name must be a valid orphan VG name
 226          */
 227         int (*pv_write) (const struct format_type * fmt,
 228                          struct physical_volume * pv, struct dm_list * mdas,
 229                          int64_t label_sector);
 230
 231         /*
 232          * Tweak an already filled out a lv eg, check there
 233          * aren't too many extents.
 234          */
 235         int (*lv_setup) (struct format_instance * fi,
 236                          struct logical_volume * lv);
 237
 238         /*
 239          * Tweak an already filled out vg.  eg, max_pv is format
 240          * specific.
 241          */
 242         int (*vg_setup) (struct format_instance * fi, struct volume_group * vg);
 243
 244         /*
 245          * Check whether particular segment type is supported.
 246          */
 247         int (*segtype_supported) (struct format_instance *fid,
 248                                   const struct segment_type *segtype);
 249
 250         /*
 251          * Create format instance with a particular metadata area
 252          */
 253         struct format_instance *(*create_instance) (const struct format_type *
 254                                                     fmt, const char *vgname,
 255                                                     const char *vgid,
 256                                                     void *context);
 257
 258         /*
 259          * Destructor for format instance
 260          */
 261         void (*destroy_instance) (struct format_instance * fid);
 262
 263         /*
 264          * Destructor for format type
 265          */
 266         void (*destroy) (const struct format_type * fmt);
 267 };
 268
 269 /*
 270  * Utility functions
 271  */
 272 unsigned long set_pe_align(struct physical_volume *pv, unsigned long data_alignment);
 273 unsigned long set_pe_align_offset(struct physical_volume *pv,
 274                                   unsigned long data_alignment_offset);
 275 int vg_validate(struct volume_group *vg);
 276
 277 int pv_write_orphan(struct cmd_context *cmd, struct physical_volume *pv);
 278
 279 /* Manipulate PV structures */
 280 int pv_add(struct volume_group *vg, struct physical_volume *pv);
 281 int pv_remove(struct volume_group *vg, struct physical_volume *pv);
 282 struct physical_volume *pv_find(struct volume_group *vg, const char *pv_name);
 283
 284 /* Find a PV within a given VG */
 285 int get_pv_from_vg_by_id(const struct format_type *fmt, const char *vg_name,
 286                          const char *vgid, const char *pvid,
 287                          struct physical_volume *pv);
 288
 289 struct lv_list *find_lv_in_vg_by_lvid(struct volume_group *vg,
 290                                       const union lvid *lvid);
 291
 292 struct lv_list *find_lv_in_lv_list(const struct dm_list *ll,
 293                                    const struct logical_volume *lv);
 294
 295 /* Return the VG that contains a given LV (based on path given in lv_name) */
 296 /* or environment var */
 297 struct volume_group *find_vg_with_lv(const char *lv_name);
 298
 299 /* Find LV with given lvid (used during activation) */
 300 struct logical_volume *lv_from_lvid(struct cmd_context *cmd,
 301                                     const char *lvid_s,
 302                                     unsigned precommitted);
 303
 304 /* FIXME Merge these functions with ones above */
 305 struct physical_volume *find_pv(struct volume_group *vg, struct device *dev);
 306
 307 struct pv_list *find_pv_in_pv_list(const struct dm_list *pl,
 308                                    const struct physical_volume *pv);
 309
 310 /* Find LV segment containing given LE */
 311 struct lv_segment *find_seg_by_le(const struct logical_volume *lv, uint32_t le);
 312
 313 /* Find PV segment containing given LE */
 314 struct pv_segment *find_peg_by_pe(const struct physical_volume *pv, uint32_t pe);
 315
 316 /*
 317  * Remove a dev_dir if present.
 318  */
 319 const char *strip_dir(const char *vg_name, const char *dir);
 320
 321 struct logical_volume *alloc_lv(struct dm_pool *mem);
 322
 323 /*
 324  * Checks that an lv has no gaps or overlapping segments.
 325  * Set complete_vg to perform additional VG level checks.
 326  */
 327 int check_lv_segments(struct logical_volume *lv, int complete_vg);
 328
 329 /*
 330  * Sometimes (eg, after an lvextend), it is possible to merge two
 331  * adjacent segments into a single segment.  This function trys
 332  * to merge as many segments as possible.
 333  */
 334 int lv_merge_segments(struct logical_volume *lv);
 335
 336 /*
 337  * Ensure there's a segment boundary at a given LE, splitting if necessary
 338  */
 339 int lv_split_segment(struct logical_volume *lv, uint32_t le);
 340
 341 /*
 342  * Add/remove upward link from underlying LV to the segment using it
 343  * FIXME: ridiculously long name
 344  */
 345 int add_seg_to_segs_using_this_lv(struct logical_volume *lv, struct lv_segment *seg);
 346 int remove_seg_from_segs_using_this_lv(struct logical_volume *lv, struct lv_segment *seg);
 347 struct lv_segment *get_only_segment_using_this_lv(struct logical_volume *lv);
 348
 349 /*
 350  * Count snapshot LVs.
 351  */
 352 unsigned snapshot_count(const struct volume_group *vg);
 353
 354 /*
 355  * Calculate readahead from underlying PV devices
 356  */
 357 void lv_calculate_readahead(const struct logical_volume *lv, uint32_t *read_ahead);
 358
 359 /*
 360  * For internal metadata caching.
 361  */
 362 int export_vg_to_buffer(struct volume_group *vg, char **buf);
 363 struct volume_group *import_vg_from_buffer(char *buf,
 364                                            struct format_instance *fid);
 365
 366 /*
 367  * Mirroring functions
 368  */
 369
 370 /*
 371  * Given mirror image or mirror log segment, find corresponding mirror segment
 372  */
 373 int fixup_imported_mirrors(struct volume_group *vg);
 374
 375 /*
 376  * Begin skeleton for external LVM library
 377  */
 378 struct id pv_id(const struct physical_volume *pv);
 379 const struct format_type *pv_format_type(const struct physical_volume *pv);
 380 struct id pv_vgid(const struct physical_volume *pv);
 381
 382 struct physical_volume *pv_by_path(struct cmd_context *cmd, const char *pv_name);
 383 int add_pv_to_vg(struct volume_group *vg, const char *pv_name,
 384                  struct physical_volume *pv);
 385
 386 #endif