/* * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved. * Copyright (C) 2004-2010 Red Hat, Inc. All rights reserved. * * This file is part of LVM2. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions * of the GNU Lesser General Public License v.2.1. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* * This is the representation of LVM metadata that is being adapted * for library export. */ #ifndef _LVM_METADATA_EXPORTED_H #define _LVM_METADATA_EXPORTED_H #include "uuid.h" #include "pv.h" #include "vg.h" #include "lv.h" #include "lvm-percent.h" #define MAX_STRIPES 128U #define SECTOR_SHIFT 9L #define SECTOR_SIZE ( 1L << SECTOR_SHIFT ) #define STRIPE_SIZE_MIN ( (unsigned) lvm_getpagesize() >> SECTOR_SHIFT) /* PAGESIZE in sectors */ #define STRIPE_SIZE_MAX ( 512L * 1024L >> SECTOR_SHIFT) /* 512 KB in sectors */ #define STRIPE_SIZE_LIMIT ((UINT_MAX >> 2) + 1) #define MAX_RESTRICTED_LVS 255 /* Used by FMT_RESTRICTED_LVIDS */ #define MAX_EXTENT_SIZE ((uint32_t) -1) /* Layer suffix */ #define MIRROR_SYNC_LAYER "_mimagetmp" /* Various flags */ /* Note that the bits no longer necessarily correspond to LVM1 disk format */ #define PARTIAL_VG UINT64_C(0x00000001) /* VG */ #define EXPORTED_VG UINT64_C(0x00000002) /* VG PV */ #define RESIZEABLE_VG UINT64_C(0x00000004) /* VG */ /* May any free extents on this PV be used or must they be left free? */ #define ALLOCATABLE_PV UINT64_C(0x00000008) /* PV */ //#define SPINDOWN_LV UINT64_C(0x00000010) /* LV */ //#define BADBLOCK_ON UINT64_C(0x00000020) /* LV */ #define VISIBLE_LV UINT64_C(0x00000040) /* LV */ #define FIXED_MINOR UINT64_C(0x00000080) /* LV */ /* FIXME Remove when metadata restructuring is completed */ #define SNAPSHOT UINT64_C(0x00001000) /* LV - internal use only */ #define PVMOVE UINT64_C(0x00002000) /* VG LV SEG */ #define LOCKED UINT64_C(0x00004000) /* LV */ #define MIRRORED UINT64_C(0x00008000) /* LV - internal use only */ //#define VIRTUAL UINT64_C(0x00010000) /* LV - internal use only */ #define MIRROR_LOG UINT64_C(0x00020000) /* LV */ #define MIRROR_IMAGE UINT64_C(0x00040000) /* LV */ #define LV_NOTSYNCED UINT64_C(0x00080000) /* LV */ #define LV_REBUILD UINT64_C(0x00100000) /* LV */ //#define PRECOMMITTED UINT64_C(0x00200000) /* VG - internal use only */ #define CONVERTING UINT64_C(0x00400000) /* LV */ #define MISSING_PV UINT64_C(0x00800000) /* PV */ #define PARTIAL_LV UINT64_C(0x01000000) /* LV - derived flag, not written out in metadata*/ //#define POSTORDER_FLAG UINT64_C(0x02000000) /* Not real flags, reserved for //#define POSTORDER_OPEN_FLAG UINT64_C(0x04000000) temporary use inside vg_read_internal. */ //#define VIRTUAL_ORIGIN UINT64_C(0x08000000) /* LV - internal use only */ #define MERGING UINT64_C(0x10000000) /* LV SEG */ #define REPLICATOR UINT64_C(0x20000000) /* LV -internal use only for replicator */ #define REPLICATOR_LOG UINT64_C(0x40000000) /* LV -internal use only for replicator-dev */ #define UNLABELLED_PV UINT64_C(0x80000000) /* PV -this PV had no label written yet */ #define RAID UINT64_C(0x0000000100000000) /* LV */ #define RAID_META UINT64_C(0x0000000200000000) /* LV */ #define RAID_IMAGE UINT64_C(0x0000000400000000) /* LV */ #define THIN_VOLUME UINT64_C(0x0000001000000000) /* LV */ #define THIN_POOL UINT64_C(0x0000002000000000) /* LV */ #define THIN_POOL_DATA UINT64_C(0x0000004000000000) /* LV */ #define THIN_POOL_METADATA UINT64_C(0x0000008000000000) /* LV */ #define LVM_READ UINT64_C(0x00000100) /* LV, VG */ #define LVM_WRITE UINT64_C(0x00000200) /* LV, VG */ #define CLUSTERED UINT64_C(0x00000400) /* VG */ //#define SHARED UINT64_C(0x00000800) /* VG */ /* Format features flags */ #define FMT_SEGMENTS 0x00000001U /* Arbitrary segment params? */ #define FMT_MDAS 0x00000002U /* Proper metadata areas? */ #define FMT_TAGS 0x00000004U /* Tagging? */ #define FMT_UNLIMITED_VOLS 0x00000008U /* Unlimited PVs/LVs? */ #define FMT_RESTRICTED_LVIDS 0x00000010U /* LVID <= 255 */ #define FMT_ORPHAN_ALLOCATABLE 0x00000020U /* Orphan PV allocatable? */ //#define FMT_PRECOMMIT 0x00000040U /* Supports pre-commit? */ #define FMT_RESIZE_PV 0x00000080U /* Supports pvresize? */ #define FMT_UNLIMITED_STRIPESIZE 0x00000100U /* Unlimited stripe size? */ #define FMT_RESTRICTED_READAHEAD 0x00000200U /* Readahead restricted to 2-120? */ /* Mirror conversion type flags */ #define MIRROR_BY_SEG 0x00000001U /* segment-by-segment mirror */ #define MIRROR_BY_LV 0x00000002U /* mirror using whole mimage LVs */ #define MIRROR_SKIP_INIT_SYNC 0x00000010U /* skip initial sync */ /* vg_read and vg_read_for_update flags */ #define READ_ALLOW_INCONSISTENT 0x00010000U #define READ_ALLOW_EXPORTED 0x00020000U #define READ_WITHOUT_LOCK 0x00040000U /* A meta-flag, useful with toollib for_each_* functions. */ #define READ_FOR_UPDATE 0x00100000U /* vg's "read_status" field */ #define FAILED_INCONSISTENT 0x00000001U #define FAILED_LOCKING 0x00000002U #define FAILED_NOTFOUND 0x00000004U #define FAILED_READ_ONLY 0x00000008U #define FAILED_EXPORTED 0x00000010U #define FAILED_RESIZEABLE 0x00000020U #define FAILED_CLUSTERED 0x00000040U #define FAILED_ALLOCATION 0x00000080U #define FAILED_EXIST 0x00000100U #define SUCCESS 0x00000000U #define VGMETADATACOPIES_ALL UINT32_MAX #define VGMETADATACOPIES_UNMANAGED 0 #define lv_is_thin_volume(lv) ((lv)->status & THIN_VOLUME ? 1 : 0) #define lv_is_thin_pool(lv) ((lv)->status & THIN_POOL ? 1 : 0) #define lv_is_used_thin_pool(lv) (lv_is_thin_pool(lv) && !dm_list_empty(&(lv)->segs_using_this_lv)) #define lv_is_thin_pool_data(lv) ((lv)->status & THIN_POOL_DATA ? 1 : 0) #define lv_is_thin_pool_metadata(lv) ((lv)->status & THIN_POOL_METADATA ? 1 : 0) #define lv_is_mirrored(lv) ((lv)->status & MIRRORED ? 1 : 0) #define lv_is_rlog(lv) ((lv)->status & REPLICATOR_LOG ? 1 : 0) #define lv_is_thin_type(lv) ((lv)->status & (THIN_POOL | THIN_VOLUME | THIN_POOL_DATA | THIN_POOL_METADATA) ? 1 : 0) #define lv_is_mirror_type(lv) ((lv)->status & (MIRROR_LOG | MIRROR_IMAGE | MIRRORED | PVMOVE) ? 1 : 0) #define lv_is_raid_type(lv) ((lv)->status & (RAID | RAID_IMAGE | RAID_META)) #define lv_is_virtual(lv) ((lv)->status & VIRTUAL) /* Ordered list - see lv_manip.c */ typedef enum { AREA_UNASSIGNED, AREA_PV, AREA_LV } area_type_t; /* * Whether or not to force an operation. */ typedef enum { PROMPT = 0, /* Issue yes/no prompt to confirm operation */ DONT_PROMPT = 1, /* Skip yes/no prompt */ DONT_PROMPT_OVERRIDE = 2 /* Skip prompt + override a second condition */ } force_t; struct cmd_context; struct format_handler; struct labeller; struct format_type { struct dm_list list; struct cmd_context *cmd; struct format_handler *ops; struct labeller *labeller; const char *name; const char *alias; const char *orphan_vg_name; struct volume_group *orphan_vg; /* Only one ever exists. */ uint32_t features; void *library; void *private; }; struct pv_segment { struct dm_list list; /* Member of pv->segments: ordered list * covering entire data area on this PV */ struct physical_volume *pv; uint32_t pe; uint32_t len; struct lv_segment *lvseg; /* NULL if free space */ uint32_t lv_area; /* Index to area in LV segment */ }; #define pvseg_is_allocated(pvseg) ((pvseg)->lvseg) /* * These flags define the type of the format instance to be created. * There are two basic types: a PV-based and a VG-based format instance. * We can further control the format_instance initialisation and functionality * by using the other flags. Today, the primary role of the format_instance * is to temporarily store metadata area information we are working with. More * flags can be defined to cover even more functionality in the future... */ /* PV-based format instance */ #define FMT_INSTANCE_PV 0x00000000U /* VG-based format instance */ #define FMT_INSTANCE_VG 0x00000001U /* Include any existing PV mdas during format_instance initialisation */ #define FMT_INSTANCE_MDAS 0x00000002U /* Include any auxiliary mdas during format_instance intialisation */ #define FMT_INSTANCE_AUX_MDAS 0x00000004U /* Include any other format-specific mdas during format_instance initialisation */ #define FMT_INSTANCE_PRIVATE_MDAS 0x00000008U struct format_instance { unsigned ref_count; /* Refs to this fid from VG and PV structs */ struct dm_pool *mem; uint32_t type; const struct format_type *fmt; /* * Each mda in a vg is on exactly one of the below lists. * MDAs on the 'in_use' list will be read from / written to * disk, while MDAs on the 'ignored' list will not be read * or written to. */ /* FIXME: Try to use the index only. Remove these lists. */ struct dm_list metadata_areas_in_use; struct dm_list metadata_areas_ignored; struct dm_hash_table *metadata_areas_index; void *private; }; /* There will be one area for each stripe */ struct lv_segment_area { area_type_t type; union { struct { struct pv_segment *pvseg; } pv; struct { struct logical_volume *lv; uint32_t le; } lv; } u; }; struct lv_thin_message { struct dm_list list; /* Chained list of messages */ dm_thin_message_t type; /* Use dm thin message datatype */ union { struct logical_volume *lv; /* For: create_thin, create_snap, trim */ uint32_t delete_id; /* For delete, needs device_id */ } u; }; struct segment_type; /* List with vg_name, vgid and flags */ struct cmd_vg { struct dm_list list; const char *vg_name; const char *vgid; uint32_t flags; struct volume_group *vg; }; /* ++ Replicator datatypes */ typedef enum { REPLICATOR_STATE_PASSIVE, REPLICATOR_STATE_ACTIVE, NUM_REPLICATOR_STATE } replicator_state_t; struct replicator_site { struct dm_list list; /* Chained list of sites */ struct dm_list rdevices; /* Device list */ struct logical_volume *replicator; /* Reference to replicator */ const char *name; /* Site name */ const char *vg_name; /* VG name */ struct volume_group *vg; /* resolved vg (activate/deactive) */ unsigned site_index; replicator_state_t state; /* Active or pasive state of site */ dm_replicator_mode_t op_mode; /* Operation mode sync or async fail|warn|drop|stall */ uint64_t fall_behind_data; /* Bytes */ uint32_t fall_behind_ios; /* IO operations */ uint32_t fall_behind_timeout; /* Seconds */ }; struct replicator_device { struct dm_list list; /* Chained list of devices from same site */ struct lv_segment *replicator_dev; /* Reference to replicator-dev segment */ struct replicator_site *rsite; /* Reference to site parameters */ uint64_t device_index; const char *name; /* Device LV name */ struct logical_volume *lv; /* LV from replicator site's VG */ struct logical_volume *slog; /* Synclog lv from VG */ const char *slog_name; /* Debug - specify size of core synclog */ }; /* -- Replicator datatypes */ struct lv_segment { struct dm_list list; struct logical_volume *lv; const struct segment_type *segtype; uint32_t le; uint32_t len; uint64_t status; /* FIXME Fields depend on segment type */ uint32_t stripe_size; /* For stripe and RAID - in sectors */ uint32_t area_count; uint32_t area_len; uint32_t chunk_size; /* For snapshots/thin_pool. In sectors. */ /* For thin_pool, 128..2097152. */ struct logical_volume *origin; /* snap and thin */ struct logical_volume *cow; struct dm_list origin_list; uint32_t region_size; /* For mirrors, replicators - in sectors */ uint32_t extents_copied; struct logical_volume *log_lv; struct lv_segment *pvmove_source_seg; void *segtype_private; struct dm_list tags; struct lv_segment_area *areas; struct lv_segment_area *meta_areas; /* For RAID */ struct logical_volume *metadata_lv; /* For thin_pool */ uint64_t transaction_id; /* For thin_pool, thin */ uint64_t low_water_mark; /* For thin_pool */ unsigned zero_new_blocks; /* For thin_pool */ struct dm_list thin_messages; /* For thin_pool */ struct logical_volume *pool_lv; /* For thin */ uint32_t device_id; /* For thin, 24bit */ struct logical_volume *replicator;/* For replicator-devs - link to replicator LV */ struct logical_volume *rlog_lv; /* For replicators */ const char *rlog_type; /* For replicators */ uint64_t rdevice_index_highest; /* For replicators */ unsigned rsite_index_highest; /* For replicators */ }; #define seg_type(seg, s) (seg)->areas[(s)].type #define seg_pv(seg, s) (seg)->areas[(s)].u.pv.pvseg->pv #define seg_lv(seg, s) (seg)->areas[(s)].u.lv.lv #define seg_metalv(seg, s) (seg)->meta_areas[(s)].u.lv.lv #define seg_metatype(seg, s) (seg)->meta_areas[(s)].type struct pe_range { struct dm_list list; uint32_t start; /* PEs */ uint32_t count; /* PEs */ }; struct pv_list { struct dm_list list; struct physical_volume *pv; struct dm_list *mdas; /* Metadata areas */ struct dm_list *pe_ranges; /* Ranges of PEs e.g. for allocation */ }; struct lv_list { struct dm_list list; struct logical_volume *lv; }; struct pvcreate_params { int zero; uint64_t size; uint64_t data_alignment; uint64_t data_alignment_offset; int pvmetadatacopies; uint64_t pvmetadatasize; int64_t labelsector; struct id id; /* FIXME: redundant */ struct id *idp; /* 0 if no --uuid option */ uint64_t pe_start; uint32_t extent_count; uint32_t extent_size; const char *restorefile; /* 0 if no --restorefile option */ force_t force; unsigned yes; unsigned metadataignore; }; struct physical_volume *pvcreate_single(struct cmd_context *cmd, const char *pv_name, struct pvcreate_params *pp, int write_now); void pvcreate_params_set_defaults(struct pvcreate_params *pp); /* * Utility functions */ int vg_write(struct volume_group *vg); int vg_commit(struct volume_group *vg); void vg_revert(struct volume_group *vg); struct volume_group *vg_read_internal(struct cmd_context *cmd, const char *vg_name, const char *vgid, int warnings, int *consistent); struct physical_volume *pv_read(struct cmd_context *cmd, const char *pv_name, int warnings, int scan_label_only); struct dm_list *get_pvs(struct cmd_context *cmd); /* * Add/remove LV to/from volume group */ int link_lv_to_vg(struct volume_group *vg, struct logical_volume *lv); int unlink_lv_from_vg(struct logical_volume *lv); void lv_set_visible(struct logical_volume *lv); void lv_set_hidden(struct logical_volume *lv); struct dm_list *get_vgnames(struct cmd_context *cmd, int include_internal); struct dm_list *get_vgids(struct cmd_context *cmd, int include_internal); int scan_vgs_for_pvs(struct cmd_context *cmd, int warnings); int pv_write(struct cmd_context *cmd, struct physical_volume *pv, int allow_non_orphan); int move_pv(struct volume_group *vg_from, struct volume_group *vg_to, const char *pv_name); int move_pvs_used_by_lv(struct volume_group *vg_from, struct volume_group *vg_to, const char *lv_name); int is_global_vg(const char *vg_name); int is_orphan_vg(const char *vg_name); int is_real_vg(const char *vg_name); int vg_missing_pv_count(const struct volume_group *vg); int vgs_are_compatible(struct cmd_context *cmd, struct volume_group *vg_from, struct volume_group *vg_to); uint32_t vg_lock_newname(struct cmd_context *cmd, const char *vgname); /* * Return a handle to VG metadata. */ struct volume_group *vg_read(struct cmd_context *cmd, const char *vg_name, const char *vgid, uint32_t flags); struct volume_group *vg_read_for_update(struct cmd_context *cmd, const char *vg_name, const char *vgid, uint32_t flags); /* * Test validity of a VG handle. */ uint32_t vg_read_error(struct volume_group *vg_handle); /* pe_start and pe_end relate to any existing data so that new metadata * areas can avoid overlap */ struct physical_volume *pv_create(const struct cmd_context *cmd, struct device *dev, struct id *id, uint64_t size, unsigned long data_alignment, unsigned long data_alignment_offset, uint64_t pe_start, uint32_t existing_extent_count, uint32_t existing_extent_size, uint64_t label_sector, unsigned pvmetadatacopies, uint64_t pvmetadatasize, unsigned metadataignore); int pv_resize(struct physical_volume *pv, struct volume_group *vg, uint64_t size); int pv_analyze(struct cmd_context *cmd, const char *pv_name, uint64_t label_sector); /* FIXME: move internal to library */ uint32_t pv_list_extents_free(const struct dm_list *pvh); struct volume_group *vg_create(struct cmd_context *cmd, const char *vg_name); int vg_remove_mdas(struct volume_group *vg); int vg_remove_check(struct volume_group *vg); void vg_remove_pvs(struct volume_group *vg); int vg_remove(struct volume_group *vg); int vg_rename(struct cmd_context *cmd, struct volume_group *vg, const char *new_name); int vg_extend(struct volume_group *vg, int pv_count, const char *const *pv_names, struct pvcreate_params *pp); int vg_reduce(struct volume_group *vg, const char *pv_name); int vg_change_tag(struct volume_group *vg, const char *tag, int add_tag); int vg_split_mdas(struct cmd_context *cmd, struct volume_group *vg_from, struct volume_group *vg_to); /* FIXME: Investigate refactoring these functions to take a pv ISO pv_list */ void add_pvl_to_vgs(struct volume_group *vg, struct pv_list *pvl); void del_pvl_from_vgs(struct volume_group *vg, struct pv_list *pvl); /* FIXME: refactor / unexport when lvremove liblvm refactoring dones */ int remove_lvs_in_vg(struct cmd_context *cmd, struct volume_group *vg, force_t force); /* * free_pv_fid() must be called on every struct physical_volume allocated * by pv_create, pv_read, find_pv_by_name or pv_by_path to free it when * no longer required. */ void free_pv_fid(struct physical_volume *pv); /* Manipulate LVs */ struct logical_volume *lv_create_empty(const char *name, union lvid *lvid, uint64_t status, alloc_policy_t alloc, struct volume_group *vg); /* Write out LV contents */ int set_lv(struct cmd_context *cmd, struct logical_volume *lv, uint64_t sectors, int value); int lv_change_tag(struct logical_volume *lv, const char *tag, int add_tag); /* Reduce the size of an LV by extents */ int lv_reduce(struct logical_volume *lv, uint32_t extents); /* Empty an LV prior to deleting it */ int lv_empty(struct logical_volume *lv); /* Empty an LV and add error segment */ int replace_lv_with_error_segment(struct logical_volume *lv); /* Entry point for all LV extent allocations */ int lv_extend(struct logical_volume *lv, const struct segment_type *segtype, uint32_t stripes, uint32_t stripe_size, uint32_t mirrors, uint32_t region_size, uint32_t extents, const char *thin_pool_name, struct dm_list *allocatable_pvs, alloc_policy_t alloc); /* lv must be part of lv->vg->lvs */ int lv_remove(struct logical_volume *lv); int lv_remove_single(struct cmd_context *cmd, struct logical_volume *lv, force_t force); int lv_remove_with_dependencies(struct cmd_context *cmd, struct logical_volume *lv, force_t force, unsigned level); int lv_rename(struct cmd_context *cmd, struct logical_volume *lv, const char *new_name); uint64_t extents_from_size(struct cmd_context *cmd, uint64_t size, uint32_t extent_size); int update_pool_lv(struct logical_volume *lv, int activate); /* * Activation options */ typedef enum { CHANGE_AY = 0, CHANGE_AN = 1, CHANGE_AE = 2, CHANGE_ALY = 3, CHANGE_ALN = 4 } activation_change_t; /* FIXME: refactor and reduce the size of this struct! */ struct lvcreate_params { /* flags */ int snapshot; /* snap */ int thin; /* thin */ int create_thin_pool; /* thin */ int zero; /* all */ int major; /* all */ int minor; /* all */ int log_count; /* mirror */ int nosync; /* mirror */ int activation_monitoring; /* all */ activation_change_t activate; /* non-snapshot, non-mirror */ const char *origin; /* snap */ const char *pool; /* thin */ const char *vg_name; /* all */ const char *lv_name; /* all */ uint32_t stripes; /* striped */ uint32_t stripe_size; /* striped */ uint32_t chunk_size; /* snapshot */ uint32_t region_size; /* mirror */ uint32_t mirrors; /* mirror */ const struct segment_type *segtype; /* all */ /* size */ uint32_t extents; /* all */ uint32_t voriginextents; /* snapshot */ uint64_t voriginsize; /* snapshot */ uint32_t poolmetadataextents; /* thin pool */ uint64_t poolmetadatasize; /* thin pool */ struct dm_list *pvh; /* all */ uint32_t permission; /* all */ uint32_t read_ahead; /* all */ alloc_policy_t alloc; /* all */ struct dm_list tags; /* all */ }; int lv_create_single(struct volume_group *vg, struct lvcreate_params *lp); /* * Functions for layer manipulation */ int insert_layer_for_segments_on_pv(struct cmd_context *cmd, struct logical_volume *lv_where, struct logical_volume *layer_lv, uint64_t status, struct pv_list *pv, struct dm_list *lvs_changed); int remove_layers_for_segments(struct cmd_context *cmd, struct logical_volume *lv, struct logical_volume *layer_lv, uint64_t status_mask, struct dm_list *lvs_changed); int remove_layers_for_segments_all(struct cmd_context *cmd, struct logical_volume *layer_lv, uint64_t status_mask, struct dm_list *lvs_changed); int split_parent_segments_for_layer(struct cmd_context *cmd, struct logical_volume *layer_lv); int remove_layer_from_lv(struct logical_volume *lv, struct logical_volume *layer_lv); struct logical_volume *insert_layer_for_lv(struct cmd_context *cmd, struct logical_volume *lv_where, uint64_t status, const char *layer_suffix); /* Find a PV within a given VG */ struct pv_list *find_pv_in_vg(const struct volume_group *vg, const char *pv_name); struct pv_list *find_pv_in_vg_by_uuid(const struct volume_group *vg, const struct id *id); /* Find an LV within a given VG */ struct lv_list *find_lv_in_vg(const struct volume_group *vg, const char *lv_name); /* FIXME Merge these functions with ones above */ struct logical_volume *find_lv(const struct volume_group *vg, const char *lv_name); struct physical_volume *find_pv_by_name(struct cmd_context *cmd, const char *pv_name); const char *find_vgname_from_pvname(struct cmd_context *cmd, const char *pvname); const char *find_vgname_from_pvid(struct cmd_context *cmd, const char *pvid); /* Find LV segment containing given LE */ struct lv_segment *first_seg(const struct logical_volume *lv); struct lv_segment *last_seg(const struct logical_volume *lv); /* * Useful functions for managing snapshots. */ int lv_is_origin(const struct logical_volume *lv); int lv_is_virtual_origin(const struct logical_volume *lv); int lv_is_cow(const struct logical_volume *lv); int lv_is_merging_origin(const struct logical_volume *origin); int lv_is_merging_cow(const struct logical_volume *snapshot); /* Test if given LV is visible from user's perspective */ int lv_is_visible(const struct logical_volume *lv); int pv_is_in_vg(struct volume_group *vg, struct physical_volume *pv); struct lv_segment *find_merging_cow(const struct logical_volume *origin); /* Given a cow LV, return return the snapshot lv_segment that uses it */ struct lv_segment *find_cow(const struct logical_volume *lv); /* Given a cow LV, return its origin */ struct logical_volume *origin_from_cow(const struct logical_volume *lv); void init_snapshot_seg(struct lv_segment *seg, struct logical_volume *origin, struct logical_volume *cow, uint32_t chunk_size, int merge); void init_snapshot_merge(struct lv_segment *cow_seg, struct logical_volume *origin); void clear_snapshot_merge(struct logical_volume *origin); int vg_add_snapshot(struct logical_volume *origin, struct logical_volume *cow, union lvid *lvid, uint32_t extent_count, uint32_t chunk_size); int vg_remove_snapshot(struct logical_volume *cow); int vg_check_status(const struct volume_group *vg, uint64_t status); /* * Check if the VG reached maximal LVs count (if set) */ int vg_max_lv_reached(struct volume_group *vg); /* * Mirroring functions */ struct lv_segment *find_mirror_seg(struct lv_segment *seg); int lv_add_mirrors(struct cmd_context *cmd, struct logical_volume *lv, uint32_t mirrors, uint32_t stripes, uint32_t stripe_size, uint32_t region_size, uint32_t log_count, struct dm_list *pvs, alloc_policy_t alloc, uint32_t flags); int lv_split_mirror_images(struct logical_volume *lv, const char *split_lv_name, uint32_t split_count, struct dm_list *removable_pvs); int lv_remove_mirrors(struct cmd_context *cmd, struct logical_volume *lv, uint32_t mirrors, uint32_t log_count, int (*is_removable)(struct logical_volume *, void *), void *removable_baton, uint64_t status_mask); int is_temporary_mirror_layer(const struct logical_volume *lv); struct logical_volume * find_temporary_mirror(const struct logical_volume *lv); uint32_t lv_mirror_count(const struct logical_volume *lv); uint32_t adjusted_mirror_region_size(uint32_t extent_size, uint32_t extents, uint32_t region_size); int remove_mirrors_from_segments(struct logical_volume *lv, uint32_t new_mirrors, uint64_t status_mask); int add_mirrors_to_segments(struct cmd_context *cmd, struct logical_volume *lv, uint32_t mirrors, uint32_t region_size, struct dm_list *allocatable_pvs, alloc_policy_t alloc); int remove_mirror_images(struct logical_volume *lv, uint32_t num_mirrors, int (*is_removable)(struct logical_volume *, void *), void *removable_baton, unsigned remove_log); int add_mirror_images(struct cmd_context *cmd, struct logical_volume *lv, uint32_t mirrors, uint32_t stripes, uint32_t stripe_size, uint32_t region_size, struct dm_list *allocatable_pvs, alloc_policy_t alloc, uint32_t log_count); struct logical_volume *detach_mirror_log(struct lv_segment *seg); int attach_mirror_log(struct lv_segment *seg, struct logical_volume *lv); int remove_mirror_log(struct cmd_context *cmd, struct logical_volume *lv, struct dm_list *removable_pvs, int force); int add_mirror_log(struct cmd_context *cmd, struct logical_volume *lv, uint32_t log_count, uint32_t region_size, struct dm_list *allocatable_pvs, alloc_policy_t alloc); int reconfigure_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors, struct dm_list *removable_pvs, unsigned remove_log); int collapse_mirrored_lv(struct logical_volume *lv); int shift_mirror_images(struct lv_segment *mirrored_seg, unsigned mimage); /* ++ metadata/replicator_manip.c */ int replicator_add_replicator_dev(struct logical_volume *replicator_lv, struct lv_segment *rdev_seg); struct logical_volume *replicator_remove_replicator_dev(struct lv_segment *rdev_seg); int replicator_add_rlog(struct lv_segment *replicator_seg, struct logical_volume *rlog_lv); struct logical_volume *replicator_remove_rlog(struct lv_segment *replicator_seg); int replicator_dev_add_slog(struct replicator_device *rdev, struct logical_volume *slog_lv); struct logical_volume *replicator_dev_remove_slog(struct replicator_device *rdev); int replicator_dev_add_rimage(struct replicator_device *rdev, struct logical_volume *lv); struct logical_volume *replicator_dev_remove_rimage(struct replicator_device *rdev); int lv_is_active_replicator_dev(const struct logical_volume *lv); int lv_is_replicator(const struct logical_volume *lv); int lv_is_replicator_dev(const struct logical_volume *lv); int lv_is_rimage(const struct logical_volume *lv); int lv_is_slog(const struct logical_volume *lv); struct logical_volume *first_replicator_dev(const struct logical_volume *lv); /* -- metadata/replicator_manip.c */ /* ++ metadata/raid_manip.c */ int lv_is_raid_with_tracking(const struct logical_volume *lv); uint32_t lv_raid_image_count(const struct logical_volume *lv); int lv_raid_change_image_count(struct logical_volume *lv, uint32_t new_count, struct dm_list *pvs); int lv_raid_split(struct logical_volume *lv, const char *split_name, uint32_t new_count, struct dm_list *splittable_pvs); int lv_raid_split_and_track(struct logical_volume *lv, struct dm_list *splittable_pvs); int lv_raid_merge(struct logical_volume *lv); int lv_raid_reshape(struct logical_volume *lv, const struct segment_type *new_segtype); int lv_raid_replace(struct logical_volume *lv, struct dm_list *remove_pvs, struct dm_list *allocate_pvs); /* -- metadata/raid_manip.c */ struct cmd_vg *cmd_vg_add(struct dm_pool *mem, struct dm_list *cmd_vgs, const char *vg_name, const char *vgid, uint32_t flags); struct cmd_vg *cmd_vg_lookup(struct dm_list *cmd_vgs, const char *vg_name, const char *vgid); int cmd_vg_read(struct cmd_context *cmd, struct dm_list *cmd_vgs); void free_cmd_vgs(struct dm_list *cmd_vgs); int find_replicator_vgs(struct logical_volume *lv); int lv_read_replicator_vgs(struct logical_volume *lv); void lv_release_replicator_vgs(struct logical_volume *lv); struct logical_volume *find_pvmove_lv(struct volume_group *vg, struct device *dev, uint64_t lv_type); struct logical_volume *find_pvmove_lv_from_pvname(struct cmd_context *cmd, struct volume_group *vg, const char *name, const char *uuid, uint64_t lv_type); struct logical_volume *find_pvmove_lv_in_lv(struct logical_volume *lv); const char *get_pvmove_pvname_from_lv(struct logical_volume *lv); const char *get_pvmove_pvname_from_lv_mirr(struct logical_volume *lv_mirr); percent_t copy_percent(const struct logical_volume *lv_mirr); struct dm_list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg, struct logical_volume *lv); uint32_t find_free_lvnum(struct logical_volume *lv); char *generate_lv_name(struct volume_group *vg, const char *format, char *buffer, size_t len); /* * Begin skeleton for external LVM library */ int pv_change_metadataignore(struct physical_volume *pv, uint32_t mda_ignore); int vg_check_write_mode(struct volume_group *vg); #define vg_is_clustered(vg) (vg_status((vg)) & CLUSTERED) #define vg_is_exported(vg) (vg_status((vg)) & EXPORTED_VG) #define vg_is_resizeable(vg) (vg_status((vg)) & RESIZEABLE_VG) int lv_has_unknown_segments(const struct logical_volume *lv); int vg_has_unknown_segments(const struct volume_group *vg); int vg_mark_partial_lvs(struct volume_group *vg, int clear); struct vgcreate_params { const char *vg_name; uint32_t extent_size; size_t max_pv; size_t max_lv; alloc_policy_t alloc; int clustered; /* FIXME: put this into a 'status' variable instead? */ uint32_t vgmetadatacopies; }; int vgcreate_params_validate(struct cmd_context *cmd, struct vgcreate_params *vp); int validate_vg_rename_params(struct cmd_context *cmd, const char *vg_name_old, const char *vg_name_new); #endif