/* * Copyright (C) 2001 Sistina Software (UK) Limited. * * This file is released under the LGPL. * * This is the in core representation of a volume group and its * associated physical and logical volumes. */ #ifndef _LVM_METADATA_H #define _LVM_METADATA_H #include #include #include "dev-cache.h" #include "list.h" #include "uuid.h" #define NAME_LEN 128 #define MAX_STRIPES 128 #define SECTOR_SIZE 512 #define STRIPE_SIZE_DEFAULT 16 /* 16KB */ #define STRIPE_SIZE_MIN ( PAGE_SIZE/SECTOR_SIZE) /* PAGESIZE in sectors */ #define STRIPE_SIZE_MAX ( 512L * 1024 / SECTOR_SIZE) /* 512 KB in sectors */ #define PV_MIN_SIZE ( 512L * 1024 / SECTOR_SIZE) /* 512 KB in sectors */ #define PE_ALIGN (65536UL / SECTOR_SIZE) /* PE alignment */ /* Various flags */ /* Note that the bits no longer necessarily correspond to LVM1 disk format */ #define BIT(x) (1 << x) #define EXPORTED_VG BIT(0) /* VG PV */ #define RESIZEABLE_VG BIT(1) /* VG */ #define PARTIAL_VG BIT(2) /* VG */ /* * May any free extents on this PV be used or must they be left * free? */ #define ALLOCATABLE_PV BIT(3) /* PV */ #define SPINDOWN_LV BIT(4) /* LV */ #define BADBLOCK_ON BIT(5) /* LV */ #define FIXED_MINOR BIT(6) /* LV */ #define VISIBLE_LV BIT(7) /* LV */ /* * FIXME: do we really set read/write for a whole vg ? */ #define LVM_READ BIT(8) /* LV VG */ #define LVM_WRITE BIT(9) /* LV VG */ #define CLUSTERED BIT(10) /* VG */ #define SHARED BIT(11) /* VG */ #define FMT_SEGMENTS 0x00000001 /* Arbitrary segment parameters? */ #define FMT_TEXT_NAME "text" #define FMT_LVM1_NAME "lvm1" typedef enum { ALLOC_NEXT_FREE, ALLOC_STRICT, ALLOC_CONTIGUOUS } alloc_policy_t; struct physical_volume { struct id id; struct device *dev; struct format_instance *fid; char *vg_name; uint32_t status; uint64_t size; /* physical extents */ uint64_t pe_size; uint64_t pe_start; uint32_t pe_count; uint32_t pe_alloc_count; }; struct cmd_context; struct format_type { struct cmd_context *cmd; struct format_handler *ops; const char *name; uint32_t features; void *private; }; struct metadata_area { struct list list; void *metadata_locn; }; struct format_instance { struct format_type *fmt; struct list metadata_areas; /* e.g. metadata locations */ }; struct volume_group { struct cmd_context *cmd; struct format_instance *fid; uint32_t seqno; /* Metadata sequence number */ struct id id; char *name; char *system_id; uint32_t status; uint32_t extent_size; uint32_t extent_count; uint32_t free_count; uint32_t max_lv; uint32_t max_pv; /* physical volumes */ uint32_t pv_count; struct list pvs; /* logical volumes */ uint32_t lv_count; struct list lvs; /* snapshots */ uint32_t snapshot_count; struct list snapshots; }; struct stripe_segment { struct list list; struct logical_volume *lv; uint32_t le; uint32_t len; uint32_t stripe_size; uint32_t stripes; /* There will be one area for each stripe */ struct { struct physical_volume *pv; uint32_t pe; } area[0]; }; struct logical_volume { union lvid lvid; char *name; struct volume_group *vg; uint32_t status; alloc_policy_t alloc; uint32_t read_ahead; int32_t minor; uint64_t size; uint32_t le_count; struct list segments; }; struct snapshot { int persistent; /* boolean */ uint32_t chunk_size; /* in 512 byte sectors */ struct logical_volume *origin; struct logical_volume *cow; }; struct name_list { struct list list; char *name; }; struct pv_list { struct list list; struct physical_volume *pv; }; struct lv_list { struct list list; struct logical_volume *lv; }; struct snapshot_list { struct list list; struct snapshot *snapshot; }; /* * Ownership of objects passes to caller. */ struct format_handler { /* * Returns a name_list of vg's. */ struct list *(*get_vgs)(struct format_type *fmt, struct list *names); /* * Returns pv_list of fully-populated pv structures. */ struct list *(*get_pvs)(struct format_type *fmt, struct list *results); /* * Return PV with given path. */ int (*pv_read)(struct format_type *fmt, const char *pv_name, struct physical_volume *pv); /* * Tweak an already filled out a pv ready for importing into a * vg. eg. pe_count is format specific. */ int (*pv_setup)(struct format_instance *fi, struct physical_volume *pv, struct volume_group *vg); /* * Write a PV structure to disk. Fails if the PV is in a VG ie * pv->vg_name must be null. */ int (*pv_write)(struct format_instance *fi, struct physical_volume *pv, void *mdl); int (*pv_commit)(struct format_instance *fid, struct physical_volume *pv, void *mdl); /* * Tweak an already filled out a lv eg, check there * aren't too many extents. */ int (*lv_setup)(struct format_instance *fi, struct logical_volume *lv); /* * Tweak an already filled out vg. eg, max_pv is format * specific. */ int (*vg_setup)(struct format_instance *fi, struct volume_group *vg); int (*vg_remove)(struct format_instance *fi, struct volume_group *vg, void *mdl); /* * The name may be prefixed with the dev_dir from the * job_context. * mdl is the metadata location to use */ struct volume_group *(*vg_read)(struct format_instance *fi, const char *vg_name, void *mdl); /* * Write out complete VG metadata. You must ensure internal * consistency before calling. eg. PEs can't refer to PVs not * part of the VG. * * It is also the responsibility of the caller to ensure external * consistency, eg by calling pv_write() if removing PVs from * a VG or calling vg_write() a second time if splitting a VG * into two. * * vg_write() must not read or write from any PVs not included * in the volume_group structure it is handed. Note: format1 * does read all pv's currently. */ int (*vg_write)(struct format_instance *fid, struct volume_group *vg, void *mdl); int (*vg_commit)(struct format_instance *fid, struct volume_group *vg, void *mdl); /* * Create format instance with a particular metadata area */ struct format_instance *(*create_instance)(struct format_type *fmt, const char *vgname, void *context); /* * Destructor for format instance */ void (*destroy_instance)(struct format_instance *fid); /* * Destructor for format type */ void (*destroy)(struct format_type *fmt); }; /* * Utility functions */ int vg_write(struct volume_group *vg); struct volume_group *vg_read(struct cmd_context *cmd, const char *vg_name); struct volume_group *vg_read_by_vgid(struct cmd_context *cmd, const char *vgid); struct physical_volume *pv_read(struct cmd_context *cmd, const char *pv_name); struct list *get_pvs(struct cmd_context *cmd); struct list *get_vgs(struct cmd_context *cmd); int pv_write(struct cmd_context *cmd, struct physical_volume *pv); struct physical_volume *pv_create(struct format_instance *fi, const char *name, struct id *id, uint64_t size); struct volume_group *vg_create(struct cmd_context *cmd, const char *name, uint32_t extent_size, int max_pv, int max_lv, int pv_count, char **pv_names); int vg_remove(struct volume_group *vg); /* * This needs the format instance to check the * pv's are orphaned. */ int vg_extend(struct format_instance *fi, struct volume_group *vg, int pv_count, char **pv_names); /* * Create a new LV within a given volume group. * */ struct logical_volume *lv_create(struct format_instance *fi, const char *name, uint32_t status, alloc_policy_t alloc, uint32_t stripes, uint32_t stripe_size, uint32_t extents, struct volume_group *vg, struct list *acceptable_pvs); int lv_reduce(struct format_instance *fi, struct logical_volume *lv, uint32_t extents); int lv_extend(struct format_instance *fi, struct logical_volume *lv, uint32_t stripes, uint32_t stripe_size, uint32_t extents, struct list *allocatable_pvs); /* lv must be part of vg->lvs */ int lv_remove(struct volume_group *vg, struct logical_volume *lv); /* FIXME: Move to other files */ int id_eq(struct id *op1, struct id *op2); /* Manipulate PV structures */ int pv_add(struct volume_group *vg, struct physical_volume *pv); int pv_remove(struct volume_group *vg, struct physical_volume *pv); struct physical_volume *pv_find(struct volume_group *vg, const char *pv_name); /* Find a PV within a given VG */ struct pv_list *find_pv_in_vg(struct volume_group *vg, const char *pv_name); /* Find an LV within a given VG */ struct lv_list *find_lv_in_vg(struct volume_group *vg, const char *lv_name); struct lv_list *find_lv_in_vg_by_lvid(struct volume_group *vg, union lvid *lvid); /* Return the VG that contains a given LV (based on path given in lv_name) */ /* or environment var */ struct volume_group *find_vg_with_lv(const char *lv_name); /* FIXME Merge these functions with ones above */ struct physical_volume *find_pv(struct volume_group *vg, struct device *dev); struct logical_volume *find_lv(struct volume_group *vg, const char *lv_name); /* * Remove a dev_dir if present. */ const char *strip_dir(const char *vg_name, const char *dir); /* * Checks that an lv has no gaps or overlapping segments. */ int lv_check_segments(struct logical_volume *lv); /* * Sometimes (eg, after an lvextend), it is possible to merge two * adjacent segments into a single segment. This function trys * to merge as many segments as possible. */ int lv_merge_segments(struct logical_volume *lv); /* * Useful functions for managing snapshots. */ int lv_is_origin(struct logical_volume *lv); int lv_is_cow(struct logical_volume *lv); struct snapshot *find_cow(struct logical_volume *lv); struct snapshot *find_origin(struct logical_volume *lv); struct list *find_snapshots(struct logical_volume *lv); int vg_add_snapshot(struct logical_volume *origin, struct logical_volume *cow, int persistent, uint32_t chunk_size); int vg_remove_snapshot(struct volume_group *vg, struct logical_volume *cow); #endif