external/gpl2/lvm2/dist/include/metadata-exported.h

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   5  * Copyright (C) 2004-2009 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 representation of LVM metadata that is being adapted
  20  * for library export.
  21  */
  22
  23 #ifndef _LVM_METADATA_EXPORTED_H
  24 #define _LVM_METADATA_EXPORTED_H
  25
  26 #include "uuid.h"
  27
  28 #define MAX_STRIPES 128U
  29 #define SECTOR_SHIFT 9L
  30 #define STRIPE_SIZE_MIN ( (unsigned) lvm_getpagesize() >> SECTOR_SHIFT) /* PAGESIZE in sectors */
  31 #define STRIPE_SIZE_MAX ( 512L * 1024L >> SECTOR_SHIFT) /* 512 KB in sectors */
  32 #define STRIPE_SIZE_LIMIT ((UINT_MAX >> 2) + 1)
  33 #define PV_MIN_SIZE ( 512L * 1024L >> SECTOR_SHIFT)     /* 512 KB in sectors */
  34 #define MAX_RESTRICTED_LVS 255  /* Used by FMT_RESTRICTED_LVIDS */
  35
  36 /* Layer suffix */
  37 #define MIRROR_SYNC_LAYER "_mimagetmp"
  38
  39 /* Various flags */
  40 /* Note that the bits no longer necessarily correspond to LVM1 disk format */
  41
  42 #define PARTIAL_VG              0x00000001U     /* VG */
  43 #define EXPORTED_VG             0x00000002U     /* VG PV */
  44 #define RESIZEABLE_VG           0x00000004U     /* VG */
  45
  46 /* May any free extents on this PV be used or must they be left free? */
  47 #define ALLOCATABLE_PV          0x00000008U     /* PV */
  48
  49 //#define SPINDOWN_LV           0x00000010U     /* LV */
  50 //#define BADBLOCK_ON           0x00000020U     /* LV */
  51 #define VISIBLE_LV              0x00000040U     /* LV */
  52 #define FIXED_MINOR             0x00000080U     /* LV */
  53 /* FIXME Remove when metadata restructuring is completed */
  54 #define SNAPSHOT                0x00001000U     /* LV - internal use only */
  55 #define PVMOVE                  0x00002000U     /* VG LV SEG */
  56 #define LOCKED                  0x00004000U     /* LV */
  57 #define MIRRORED                0x00008000U     /* LV - internal use only */
  58 //#define VIRTUAL                       0x00010000U     /* LV - internal use only */
  59 #define MIRROR_LOG              0x00020000U     /* LV */
  60 #define MIRROR_IMAGE            0x00040000U     /* LV */
  61 #define MIRROR_NOTSYNCED        0x00080000U     /* LV */
  62 //#define ACTIVATE_EXCL         0x00100000U     /* LV - internal use only */
  63 //#define PRECOMMITTED          0x00200000U     /* VG - internal use only */
  64 #define CONVERTING              0x00400000U     /* LV */
  65
  66 #define MISSING_PV              0x00800000U     /* PV */
  67 #define PARTIAL_LV              0x01000000U     /* LV - derived flag, not
  68                                                    written out in metadata*/
  69
  70 //#define POSTORDER_FLAG        0x02000000U /* Not real flags, reserved for
  71 //#define POSTORDER_OPEN_FLAG   0x04000000U    temporary use inside vg_read_internal. */
  72 //#define VIRTUAL_ORIGIN        0x08000000U     /* LV - internal use only */
  73
  74 #define LVM_READ                0x00000100U     /* LV VG */
  75 #define LVM_WRITE               0x00000200U     /* LV VG */
  76 #define CLUSTERED               0x00000400U     /* VG */
  77 //#define SHARED                0x00000800U     /* VG */
  78
  79 /* Format features flags */
  80 #define FMT_SEGMENTS            0x00000001U     /* Arbitrary segment params? */
  81 #define FMT_MDAS                0x00000002U     /* Proper metadata areas? */
  82 #define FMT_TAGS                0x00000004U     /* Tagging? */
  83 #define FMT_UNLIMITED_VOLS      0x00000008U     /* Unlimited PVs/LVs? */
  84 #define FMT_RESTRICTED_LVIDS    0x00000010U     /* LVID <= 255 */
  85 #define FMT_ORPHAN_ALLOCATABLE  0x00000020U     /* Orphan PV allocatable? */
  86 //#define FMT_PRECOMMIT         0x00000040U     /* Supports pre-commit? */
  87 #define FMT_RESIZE_PV           0x00000080U     /* Supports pvresize? */
  88 #define FMT_UNLIMITED_STRIPESIZE 0x00000100U    /* Unlimited stripe size? */
  89 #define FMT_RESTRICTED_READAHEAD 0x00000200U    /* Readahead restricted to 2-120? */
  90
  91 /* Mirror conversion type flags */
  92 #define MIRROR_BY_SEG           0x00000001U     /* segment-by-segment mirror */
  93 #define MIRROR_BY_LV            0x00000002U     /* mirror using whole mimage LVs */
  94 #define MIRROR_SKIP_INIT_SYNC   0x00000010U     /* skip initial sync */
  95
  96 /* vg_read and vg_read_for_update flags */
  97 #define READ_ALLOW_INCONSISTENT 0x00010000U
  98 #define READ_ALLOW_EXPORTED     0x00020000U
  99 #define READ_WITHOUT_LOCK       0x00040000U
 100
 101 /* A meta-flag, useful with toollib for_each_* functions. */
 102 #define READ_FOR_UPDATE         0x00100000U
 103
 104 /* vg's "read_status" field */
 105 #define FAILED_INCONSISTENT     0x00000001U
 106 #define FAILED_LOCKING          0x00000002U
 107 #define FAILED_NOTFOUND         0x00000004U
 108 #define FAILED_READ_ONLY        0x00000008U
 109 #define FAILED_EXPORTED         0x00000010U
 110 #define FAILED_RESIZEABLE       0x00000020U
 111 #define FAILED_CLUSTERED        0x00000040U
 112 #define FAILED_ALLOCATION       0x00000080U
 113 #define FAILED_EXIST            0x00000100U
 114 #define SUCCESS                 0x00000000U
 115
 116 /* Ordered list - see lv_manip.c */
 117 typedef enum {
 118         ALLOC_INVALID,
 119         ALLOC_CONTIGUOUS,
 120         ALLOC_CLING,
 121         ALLOC_NORMAL,
 122         ALLOC_ANYWHERE,
 123         ALLOC_INHERIT
 124 } alloc_policy_t;
 125
 126 typedef enum {
 127         AREA_UNASSIGNED,
 128         AREA_PV,
 129         AREA_LV
 130 } area_type_t;
 131
 132 /*
 133  * Whether or not to force an operation.
 134  */
 135 typedef enum {
 136         PROMPT = 0, /* Issue yes/no prompt to confirm operation */
 137         DONT_PROMPT = 1, /* Skip yes/no prompt */
 138         DONT_PROMPT_OVERRIDE = 2 /* Skip prompt + override a second condition */
 139 } force_t;
 140
 141 typedef enum {
 142         PERCENT_0 = 0,
 143         PERCENT_0_TO_100 = 1,
 144         PERCENT_100 = 2,
 145         PERCENT_INVALID = 3
 146 } percent_range_t;
 147
 148 struct cmd_context;
 149 struct format_handler;
 150 struct labeller;
 151
 152 struct format_type {
 153         struct dm_list list;
 154         struct cmd_context *cmd;
 155         struct format_handler *ops;
 156         struct labeller *labeller;
 157         const char *name;
 158         const char *alias;
 159         const char *orphan_vg_name;
 160         uint32_t features;
 161         void *library;
 162         void *private;
 163 };
 164
 165 struct pv_segment {
 166         struct dm_list list;    /* Member of pv->segments: ordered list
 167                                  * covering entire data area on this PV */
 168
 169         struct physical_volume *pv;
 170         uint32_t pe;
 171         uint32_t len;
 172
 173         struct lv_segment *lvseg;       /* NULL if free space */
 174         uint32_t lv_area;       /* Index to area in LV segment */
 175 };
 176
 177 #define pvseg_is_allocated(pvseg) ((pvseg)->lvseg)
 178
 179 struct physical_volume {
 180         struct id id;
 181         struct device *dev;
 182         const struct format_type *fmt;
 183         const char *vg_name;
 184         struct id vgid;
 185
 186         uint32_t status;
 187         uint64_t size;
 188
 189         /* physical extents */
 190         uint32_t pe_size;
 191         uint64_t pe_start;
 192         uint32_t pe_count;
 193         uint32_t pe_alloc_count;
 194         unsigned long pe_align;
 195         unsigned long pe_align_offset;
 196
 197         struct dm_list segments;        /* Ordered pv_segments covering complete PV */
 198         struct dm_list tags;
 199 };
 200
 201 struct format_instance {
 202         const struct format_type *fmt;
 203         struct dm_list metadata_areas;  /* e.g. metadata locations */
 204         void *private;
 205 };
 206
 207 struct volume_group {
 208         struct cmd_context *cmd;
 209         struct dm_pool *vgmem;
 210         struct format_instance *fid;
 211         uint32_t seqno;         /* Metadata sequence number */
 212
 213         struct id id;
 214         char *name;
 215         char *system_id;
 216
 217         uint32_t status;
 218         alloc_policy_t alloc;
 219
 220         uint32_t extent_size;
 221         uint32_t extent_count;
 222         uint32_t free_count;
 223
 224         uint32_t max_lv;
 225         uint32_t max_pv;
 226
 227         /* physical volumes */
 228         uint32_t pv_count;
 229         struct dm_list pvs;
 230
 231         /*
 232          * logical volumes
 233          * The following relationship should always hold:
 234          * dm_list_size(lvs) = user visible lv_count + snapshot_count + other invisible LVs
 235          *
 236          * Snapshots consist of 2 instances of "struct logical_volume":
 237          * - cow (lv_name is visible to the user)
 238          * - snapshot (lv_name is 'snapshotN')
 239          *
 240          * Mirrors consist of multiple instances of "struct logical_volume":
 241          * - one for the mirror log
 242          * - one for each mirror leg
 243          * - one for the user-visible mirror LV
 244          */
 245         struct dm_list lvs;
 246
 247         struct dm_list tags;
 248
 249         /*
 250          * FIXME: Move the next fields into a different struct?
 251          */
 252
 253         /*
 254          * List of removed physical volumes by pvreduce.
 255          * They have to get cleared on vg_commit.
 256          */
 257         struct dm_list removed_pvs;
 258         uint32_t open_mode; /* FIXME: read or write - check lock type? */
 259
 260         /*
 261          * Store result of the last vg_read().
 262          * 0 for success else appropriate FAILURE_* bits set.
 263          */
 264         uint32_t read_status;
 265 };
 266
 267 /* There will be one area for each stripe */
 268 struct lv_segment_area {
 269         area_type_t type;
 270         union {
 271                 struct {
 272                         struct pv_segment *pvseg;
 273                 } pv;
 274                 struct {
 275                         struct logical_volume *lv;
 276                         uint32_t le;
 277                 } lv;
 278         } u;
 279 };
 280
 281 struct segment_type;
 282 struct lv_segment {
 283         struct dm_list list;
 284         struct logical_volume *lv;
 285
 286         const struct segment_type *segtype;
 287         uint32_t le;
 288         uint32_t len;
 289
 290         uint32_t status;
 291
 292         /* FIXME Fields depend on segment type */
 293         uint32_t stripe_size;
 294         uint32_t area_count;
 295         uint32_t area_len;
 296         struct logical_volume *origin;
 297         struct logical_volume *cow;
 298         struct dm_list origin_list;
 299         uint32_t chunk_size;    /* For snapshots - in sectors */
 300         uint32_t region_size;   /* For mirrors - in sectors */
 301         uint32_t extents_copied;
 302         struct logical_volume *log_lv;
 303         void *segtype_private;
 304
 305         struct dm_list tags;
 306
 307         struct lv_segment_area *areas;
 308 };
 309
 310 #define seg_type(seg, s)        (seg)->areas[(s)].type
 311 #define seg_pv(seg, s)          (seg)->areas[(s)].u.pv.pvseg->pv
 312 #define seg_lv(seg, s)          (seg)->areas[(s)].u.lv.lv
 313
 314 struct logical_volume {
 315         union lvid lvid;
 316         char *name;
 317
 318         struct volume_group *vg;
 319
 320         uint32_t status;
 321         alloc_policy_t alloc;
 322         uint32_t read_ahead;
 323         int32_t major;
 324         int32_t minor;
 325
 326         uint64_t size;          /* Sectors */
 327         uint32_t le_count;
 328
 329         uint32_t origin_count;
 330         struct dm_list snapshot_segs;
 331         struct lv_segment *snapshot;
 332
 333         struct dm_list segments;
 334         struct dm_list tags;
 335         struct dm_list segs_using_this_lv;
 336 };
 337
 338 struct pe_range {
 339         struct dm_list list;
 340         uint32_t start;         /* PEs */
 341         uint32_t count;         /* PEs */
 342 };
 343
 344 struct pv_list {
 345         struct dm_list list;
 346         struct physical_volume *pv;
 347         struct dm_list *mdas;   /* Metadata areas */
 348         struct dm_list *pe_ranges;      /* Ranges of PEs e.g. for allocation */
 349 };
 350
 351 struct lv_list {
 352         struct dm_list list;
 353         struct logical_volume *lv;
 354 };
 355
 356 struct pvcreate_params {
 357         int zero;
 358         uint64_t size;
 359         uint64_t data_alignment;
 360         uint64_t data_alignment_offset;
 361         int pvmetadatacopies;
 362         uint64_t pvmetadatasize;
 363         int64_t labelsector;
 364         struct id id; /* FIXME: redundant */
 365         struct id *idp; /* 0 if no --uuid option */
 366         uint64_t pe_start;
 367         uint32_t extent_count;
 368         uint32_t extent_size;
 369         const char *restorefile; /* 0 if no --restorefile option */
 370         force_t force;
 371         unsigned yes;
 372 };
 373
 374 struct physical_volume *pvcreate_single(struct cmd_context *cmd,
 375                                         const char *pv_name,
 376                                         struct pvcreate_params *pp);
 377 void pvcreate_params_set_defaults(struct pvcreate_params *pp);
 378
 379 /*
 380 * Utility functions
 381 */
 382 int vg_write(struct volume_group *vg);
 383 int vg_commit(struct volume_group *vg);
 384 int vg_revert(struct volume_group *vg);
 385 struct volume_group *vg_read_internal(struct cmd_context *cmd, const char *vg_name,
 386                              const char *vgid, int *consistent);
 387 struct physical_volume *pv_read(struct cmd_context *cmd, const char *pv_name,
 388                                 struct dm_list *mdas, uint64_t *label_sector,
 389                                 int warnings, int scan_label_only);
 390 struct dm_list *get_pvs(struct cmd_context *cmd);
 391
 392 /*
 393  * Add/remove LV to/from volume group
 394  */
 395 int link_lv_to_vg(struct volume_group *vg, struct logical_volume *lv);
 396 int unlink_lv_from_vg(struct logical_volume *lv);
 397 void lv_set_visible(struct logical_volume *lv);
 398 void lv_set_hidden(struct logical_volume *lv);
 399
 400 /* Set full_scan to 1 to re-read every (filtered) device label */
 401 struct dm_list *get_vgnames(struct cmd_context *cmd, int full_scan);
 402 struct dm_list *get_vgids(struct cmd_context *cmd, int full_scan);
 403 int scan_vgs_for_pvs(struct cmd_context *cmd);
 404
 405 int pv_write(struct cmd_context *cmd, struct physical_volume *pv,
 406              struct dm_list *mdas, int64_t label_sector);
 407 int is_pv(struct physical_volume *pv);
 408 int move_pv(struct volume_group *vg_from, struct volume_group *vg_to,
 409             const char *pv_name);
 410 int move_pvs_used_by_lv(struct volume_group *vg_from,
 411                         struct volume_group *vg_to,
 412                         const char *lv_name);
 413 int is_orphan_vg(const char *vg_name);
 414 int is_orphan(const struct physical_volume *pv);
 415 int vgs_are_compatible(struct cmd_context *cmd,
 416                        struct volume_group *vg_from,
 417                        struct volume_group *vg_to);
 418 uint32_t vg_lock_newname(struct cmd_context *cmd, const char *vgname);
 419
 420 /*
 421  * Return a handle to VG metadata.
 422  */
 423 struct volume_group *vg_read(struct cmd_context *cmd, const char *vg_name,
 424               const char *vgid, uint32_t flags);
 425 struct volume_group *vg_read_for_update(struct cmd_context *cmd, const char *vg_name,
 426                          const char *vgid, uint32_t flags);
 427
 428 /*
 429  * Test validity of a VG handle.
 430  */
 431 uint32_t vg_read_error(struct volume_group *vg_handle);
 432
 433 /* pe_start and pe_end relate to any existing data so that new metadata
 434 * areas can avoid overlap */
 435 struct physical_volume *pv_create(const struct cmd_context *cmd,
 436                       struct device *dev,
 437                       struct id *id,
 438                       uint64_t size,
 439                       unsigned long data_alignment,
 440                       unsigned long data_alignment_offset,
 441                       uint64_t pe_start,
 442                       uint32_t existing_extent_count,
 443                       uint32_t existing_extent_size,
 444                       int pvmetadatacopies,
 445                       uint64_t pvmetadatasize, struct dm_list *mdas);
 446 int pv_resize(struct physical_volume *pv, struct volume_group *vg,
 447              uint32_t new_pe_count);
 448 int pv_analyze(struct cmd_context *cmd, const char *pv_name,
 449                uint64_t label_sector);
 450
 451 /* FIXME: move internal to library */
 452 uint32_t pv_list_extents_free(const struct dm_list *pvh);
 453
 454 struct volume_group *vg_create(struct cmd_context *cmd, const char *vg_name);
 455 int vg_remove_mdas(struct volume_group *vg);
 456 int vg_remove_check(struct volume_group *vg);
 457 int vg_remove(struct volume_group *vg);
 458 int vg_rename(struct cmd_context *cmd, struct volume_group *vg,
 459               const char *new_name);
 460 int vg_extend(struct volume_group *vg, int pv_count, char **pv_names,
 461               struct pvcreate_params *pp);
 462 int vg_reduce(struct volume_group *vg, char *pv_name);
 463 int vg_set_extent_size(struct volume_group *vg, uint32_t new_extent_size);
 464 int vg_set_max_lv(struct volume_group *vg, uint32_t max_lv);
 465 int vg_set_max_pv(struct volume_group *vg, uint32_t max_pv);
 466 int vg_set_alloc_policy(struct volume_group *vg, alloc_policy_t alloc);
 467 int vg_set_clustered(struct volume_group *vg, int clustered);
 468 int vg_split_mdas(struct cmd_context *cmd, struct volume_group *vg_from,
 469                   struct volume_group *vg_to);
 470
 471 /* FIXME: refactor / unexport when lvremove liblvm refactoring dones */
 472 int remove_lvs_in_vg(struct cmd_context *cmd,
 473                      struct volume_group *vg,
 474                      force_t force);
 475 /*
 476  * vg_release() must be called on every struct volume_group allocated
 477  * by vg_create() or vg_read_internal() to free it when no longer required.
 478  */
 479 void vg_release(struct volume_group *vg);
 480
 481 /* Manipulate LVs */
 482 struct logical_volume *lv_create_empty(const char *name,
 483                                        union lvid *lvid,
 484                                        uint32_t status,
 485                                        alloc_policy_t alloc,
 486                                        struct volume_group *vg);
 487
 488 /* Write out LV contents */
 489 int set_lv(struct cmd_context *cmd, struct logical_volume *lv,
 490            uint64_t sectors, int value);
 491
 492 /* Reduce the size of an LV by extents */
 493 int lv_reduce(struct logical_volume *lv, uint32_t extents);
 494
 495 /* Empty an LV prior to deleting it */
 496 int lv_empty(struct logical_volume *lv);
 497
 498 /* Empty an LV and add error segment */
 499 int replace_lv_with_error_segment(struct logical_volume *lv);
 500
 501 /* Entry point for all LV extent allocations */
 502 int lv_extend(struct logical_volume *lv,
 503               const struct segment_type *segtype,
 504               uint32_t stripes, uint32_t stripe_size,
 505               uint32_t mirrors, uint32_t extents,
 506               struct physical_volume *mirrored_pv, uint32_t mirrored_pe,
 507               uint32_t status, struct dm_list *allocatable_pvs,
 508               alloc_policy_t alloc);
 509
 510 /* lv must be part of lv->vg->lvs */
 511 int lv_remove(struct logical_volume *lv);
 512
 513 int lv_remove_single(struct cmd_context *cmd, struct logical_volume *lv,
 514                      force_t force);
 515
 516 int lv_remove_with_dependencies(struct cmd_context *cmd, struct logical_volume *lv,
 517                                 force_t force);
 518
 519 int lv_rename(struct cmd_context *cmd, struct logical_volume *lv,
 520               const char *new_name);
 521
 522 uint64_t extents_from_size(struct cmd_context *cmd, uint64_t size,
 523                            uint32_t extent_size);
 524
 525 /* FIXME: refactor and reduce the size of this struct! */
 526 struct lvcreate_params {
 527         /* flags */
 528         int snapshot; /* snap */
 529         int zero; /* all */
 530         int major; /* all */
 531         int minor; /* all */
 532         int corelog; /* mirror */
 533         int nosync; /* mirror */
 534
 535         char *origin; /* snap */
 536         const char *vg_name; /* all */
 537         const char *lv_name; /* all */
 538
 539         uint32_t stripes; /* striped */
 540         uint32_t stripe_size; /* striped */
 541         uint32_t chunk_size; /* snapshot */
 542         uint32_t region_size; /* mirror */
 543
 544         uint32_t mirrors; /* mirror */
 545
 546         const struct segment_type *segtype; /* all */
 547
 548         /* size */
 549         uint32_t extents; /* all */
 550         uint32_t voriginextents; /* snapshot */
 551         uint64_t voriginsize; /* snapshot */
 552         struct dm_list *pvh; /* all */
 553
 554         uint32_t permission; /* all */
 555         uint32_t read_ahead; /* all */
 556         alloc_policy_t alloc; /* all */
 557
 558         const char *tag; /* all */
 559 };
 560
 561 int lv_create_single(struct volume_group *vg,
 562                      struct lvcreate_params *lp);
 563
 564 /*
 565  * Functions for layer manipulation
 566  */
 567 int insert_layer_for_segments_on_pv(struct cmd_context *cmd,
 568                                     struct logical_volume *lv_where,
 569                                     struct logical_volume *layer_lv,
 570                                     uint32_t status,
 571                                     struct pv_list *pv,
 572                                     struct dm_list *lvs_changed);
 573 int remove_layers_for_segments(struct cmd_context *cmd,
 574                                struct logical_volume *lv,
 575                                struct logical_volume *layer_lv,
 576                                uint32_t status_mask, struct dm_list *lvs_changed);
 577 int remove_layers_for_segments_all(struct cmd_context *cmd,
 578                                    struct logical_volume *layer_lv,
 579                                    uint32_t status_mask,
 580                                    struct dm_list *lvs_changed);
 581 int split_parent_segments_for_layer(struct cmd_context *cmd,
 582                                     struct logical_volume *layer_lv);
 583 int remove_layer_from_lv(struct logical_volume *lv,
 584                          struct logical_volume *layer_lv);
 585 struct logical_volume *insert_layer_for_lv(struct cmd_context *cmd,
 586                                            struct logical_volume *lv_where,
 587                                            uint32_t status,
 588                                            const char *layer_suffix);
 589
 590 /* Find a PV within a given VG */
 591 struct pv_list *find_pv_in_vg(const struct volume_group *vg,
 592                               const char *pv_name);
 593 struct physical_volume *find_pv_in_vg_by_uuid(const struct volume_group *vg,
 594                             const struct id *id);
 595
 596 /* Find an LV within a given VG */
 597 struct lv_list *find_lv_in_vg(const struct volume_group *vg,
 598                               const char *lv_name);
 599
 600 /* FIXME Merge these functions with ones above */
 601 struct logical_volume *find_lv(const struct volume_group *vg,
 602                                const char *lv_name);
 603 struct physical_volume *find_pv_by_name(struct cmd_context *cmd,
 604                                         const char *pv_name);
 605
 606 /* Find LV segment containing given LE */
 607 struct lv_segment *first_seg(const struct logical_volume *lv);
 608
 609
 610 /*
 611 * Useful functions for managing snapshots.
 612 */
 613 int lv_is_origin(const struct logical_volume *lv);
 614 int lv_is_virtual_origin(const struct logical_volume *lv);
 615 int lv_is_cow(const struct logical_volume *lv);
 616
 617 /* Test if given LV is visible from user's perspective */
 618 int lv_is_visible(const struct logical_volume *lv);
 619
 620 int pv_is_in_vg(struct volume_group *vg, struct physical_volume *pv);
 621
 622 /* Given a cow LV, return return the snapshot lv_segment that uses it */
 623 struct lv_segment *find_cow(const struct logical_volume *lv);
 624
 625 /* Given a cow LV, return its origin */
 626 struct logical_volume *origin_from_cow(const struct logical_volume *lv);
 627
 628 void init_snapshot_seg(struct lv_segment *seg, struct logical_volume *origin,
 629                        struct logical_volume *cow, uint32_t chunk_size);
 630
 631 int vg_add_snapshot(struct logical_volume *origin, struct logical_volume *cow,
 632                     union lvid *lvid, uint32_t extent_count,
 633                     uint32_t chunk_size);
 634
 635 int vg_remove_snapshot(struct logical_volume *cow);
 636
 637 int vg_check_status(const struct volume_group *vg, uint32_t status);
 638
 639 /*
 640  * Returns visible LV count - number of LVs from user perspective
 641  */
 642 unsigned vg_visible_lvs(const struct volume_group *vg);
 643
 644 /*
 645  * Check if the VG reached maximal LVs count (if set)
 646  */
 647 int vg_max_lv_reached(struct volume_group *vg);
 648
 649 /*
 650 * Mirroring functions
 651 */
 652 struct lv_segment *find_mirror_seg(struct lv_segment *seg);
 653 int lv_add_mirrors(struct cmd_context *cmd, struct logical_volume *lv,
 654                    uint32_t mirrors, uint32_t stripes,
 655                    uint32_t region_size, uint32_t log_count,
 656                    struct dm_list *pvs, alloc_policy_t alloc, uint32_t flags);
 657 int lv_remove_mirrors(struct cmd_context *cmd, struct logical_volume *lv,
 658                       uint32_t mirrors, uint32_t log_count,
 659                       struct dm_list *pvs, uint32_t status_mask);
 660
 661 int is_temporary_mirror_layer(const struct logical_volume *lv);
 662 struct logical_volume * find_temporary_mirror(const struct logical_volume *lv);
 663 uint32_t lv_mirror_count(const struct logical_volume *lv);
 664 uint32_t adjusted_mirror_region_size(uint32_t extent_size, uint32_t extents,
 665                                     uint32_t region_size);
 666 int remove_mirrors_from_segments(struct logical_volume *lv,
 667                                  uint32_t new_mirrors, uint32_t status_mask);
 668 int add_mirrors_to_segments(struct cmd_context *cmd, struct logical_volume *lv,
 669                             uint32_t mirrors, uint32_t region_size,
 670                             struct dm_list *allocatable_pvs, alloc_policy_t alloc);
 671
 672 int remove_mirror_images(struct logical_volume *lv, uint32_t num_mirrors,
 673                          struct dm_list *removable_pvs, unsigned remove_log);
 674 int add_mirror_images(struct cmd_context *cmd, struct logical_volume *lv,
 675                       uint32_t mirrors, uint32_t stripes, uint32_t region_size,
 676                       struct dm_list *allocatable_pvs, alloc_policy_t alloc,
 677                       uint32_t log_count);
 678 struct logical_volume *detach_mirror_log(struct lv_segment *seg);
 679 int attach_mirror_log(struct lv_segment *seg, struct logical_volume *lv);
 680 int remove_mirror_log(struct cmd_context *cmd, struct logical_volume *lv,
 681                       struct dm_list *removable_pvs);
 682 int add_mirror_log(struct cmd_context *cmd, struct logical_volume *lv,
 683                    uint32_t log_count, uint32_t region_size,
 684                    struct dm_list *allocatable_pvs, alloc_policy_t alloc);
 685
 686 int reconfigure_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors,
 687                               struct dm_list *removable_pvs, unsigned remove_log);
 688 int collapse_mirrored_lv(struct logical_volume *lv);
 689 int shift_mirror_images(struct lv_segment *mirrored_seg, unsigned mimage);
 690
 691 struct logical_volume *find_pvmove_lv(struct volume_group *vg,
 692                                       struct device *dev, uint32_t lv_type);
 693 struct logical_volume *find_pvmove_lv_from_pvname(struct cmd_context *cmd,
 694                                                   struct volume_group *vg,
 695                                                   const char *name,
 696                                                   const char *uuid,
 697                                                   uint32_t lv_type);
 698 const char *get_pvmove_pvname_from_lv(struct logical_volume *lv);
 699 const char *get_pvmove_pvname_from_lv_mirr(struct logical_volume *lv_mirr);
 700 float copy_percent(struct logical_volume *lv_mirr,
 701                    percent_range_t *percent_range);
 702 struct dm_list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
 703                           struct logical_volume *lv);
 704
 705 uint32_t find_free_lvnum(struct logical_volume *lv);
 706 char *generate_lv_name(struct volume_group *vg, const char *format,
 707                        char *buffer, size_t len);
 708
 709 /*
 710 * Begin skeleton for external LVM library
 711 */
 712 struct device *pv_dev(const struct physical_volume *pv);
 713 const char *pv_vg_name(const struct physical_volume *pv);
 714 const char *pv_dev_name(const struct physical_volume *pv);
 715 uint64_t pv_size(const struct physical_volume *pv);
 716 uint32_t pv_status(const struct physical_volume *pv);
 717 uint32_t pv_pe_size(const struct physical_volume *pv);
 718 uint64_t pv_pe_start(const struct physical_volume *pv);
 719 uint32_t pv_pe_count(const struct physical_volume *pv);
 720 uint32_t pv_pe_alloc_count(const struct physical_volume *pv);
 721 uint32_t pv_mda_count(const struct physical_volume *pv);
 722
 723 uint64_t lv_size(const struct logical_volume *lv);
 724
 725 int vg_missing_pv_count(const struct volume_group *vg);
 726 uint32_t vg_seqno(const struct volume_group *vg);
 727 uint32_t vg_status(const struct volume_group *vg);
 728 uint64_t vg_size(const struct volume_group *vg);
 729 uint64_t vg_free(const struct volume_group *vg);
 730 uint64_t vg_extent_size(const struct volume_group *vg);
 731 uint64_t vg_extent_count(const struct volume_group *vg);
 732 uint64_t vg_free_count(const struct volume_group *vg);
 733 uint64_t vg_pv_count(const struct volume_group *vg);
 734 uint64_t vg_max_pv(const struct volume_group *vg);
 735 uint64_t vg_max_lv(const struct volume_group *vg);
 736 uint32_t vg_mda_count(const struct volume_group *vg);
 737 int vg_check_write_mode(struct volume_group *vg);
 738 #define vg_is_clustered(vg) (vg_status((vg)) & CLUSTERED)
 739 #define vg_is_exported(vg) (vg_status((vg)) & EXPORTED_VG)
 740 #define vg_is_resizeable(vg) (vg_status((vg)) & RESIZEABLE_VG)
 741
 742 int lv_has_unknown_segments(const struct logical_volume *lv);
 743 int vg_has_unknown_segments(const struct volume_group *vg);
 744
 745 struct vgcreate_params {
 746         char *vg_name;
 747         uint32_t extent_size;
 748         size_t max_pv;
 749         size_t max_lv;
 750         alloc_policy_t alloc;
 751         int clustered; /* FIXME: put this into a 'status' variable instead? */
 752 };
 753
 754 int vgcreate_params_validate(struct cmd_context *cmd,
 755                              struct vgcreate_params *vp);
 756
 757 int validate_vg_rename_params(struct cmd_context *cmd,
 758                               const char *vg_name_old,
 759                               const char *vg_name_new);
 760 #endif