Remove pv_t, vg_t & lv_t handles from lib. Only liblvm uses them.

Rename lvm.h to lvm2app.h for now.

diff --git a/WHATS_NEW b/WHATS_NEW
index 9ce9509fabc1b4b0961ce94a1c0043724418e60e..d4e276cad0588fef4a1a2b17a3446fee7b5b34ce 100644 (file)
--- a/WHATS_NEW
+++ b/WHATS_NEW
@@ -1,5 +1,7 @@
 Version 2.02.51 - 
 ================================
+  Remove pv_t, vg_t & lv_t handles from lib.  Only liblvm uses them.
+  Rename lvm.h to lvm2app.h for now.
 
 Version 2.02.50 - 28th July 2009
 ================================

diff --git a/include/.symlinks b/include/.symlinks
index 28da67f625c2867bd33bc4a641f5ad831477b141..8b191965327cd422dddd04efe2def56f37cad106 100644 (file)
--- a/include/.symlinks
+++ b/include/.symlinks
@@ -1,6 +1,6 @@
 ../daemons/clvmd/clvm.h
 ../daemons/dmeventd/libdevmapper-event.h
-../liblvm/lvm.h
+../liblvm/lvm2app.h
 ../lib/activate/activate.h
 ../lib/activate/targets.h
 ../lib/cache/lvmcache.h

diff --git a/lib/metadata/metadata-exported.h b/lib/metadata/metadata-exported.h
index bd207da3ff49c900f197a9ab8349433f68fdeb95..74786ed240f76561ae67dfe04f536a1f02181559 100644 (file)
--- a/lib/metadata/metadata-exported.h
+++ b/lib/metadata/metadata-exported.h
@@ -22,7 +22,6 @@
 #define _LVM_METADATA_EXPORTED_H
 
 #include "uuid.h"
-#include "lvm.h"
 
 #define MAX_STRIPES 128U
 #define SECTOR_SHIFT 9L
@@ -238,8 +237,7 @@ struct volume_group {
        struct dm_list tags;
 
        /*
-        * vg_t handle fields.
-        * FIXME: Split these out.
+        * FIXME: Move the next fields into a different struct?
         */
 
        /*
@@ -361,8 +359,9 @@ struct pvcreate_params {
        unsigned yes;
 };
 
-pv_t * pvcreate_single(struct cmd_context *cmd, const char *pv_name,
-                      struct pvcreate_params *pp);
+struct physical_volume *pvcreate_single(struct cmd_context *cmd,
+                                       const char *pv_name,
+                                       struct pvcreate_params *pp);
 
 /*
 * Utility functions
@@ -392,14 +391,14 @@ int scan_vgs_for_pvs(struct cmd_context *cmd);
 
 int pv_write(struct cmd_context *cmd, struct physical_volume *pv,
             struct dm_list *mdas, int64_t label_sector);
-int is_pv(pv_t *pv);
+int is_pv(struct physical_volume *pv);
 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_orphan_vg(const char *vg_name);
-int is_orphan(const pv_t *pv);
+int is_orphan(const struct physical_volume *pv);
 int vgs_are_compatible(struct cmd_context *cmd,
                       struct volume_group *vg_from,
                       struct volume_group *vg_to);
@@ -408,19 +407,19 @@ uint32_t vg_lock_newname(struct cmd_context *cmd, const char *vgname);
 /*
  * Return a handle to VG metadata.
  */
-vg_t *vg_read(struct cmd_context *cmd, const char *vg_name,
+struct volume_group *vg_read(struct cmd_context *cmd, const char *vg_name,
               const char *vgid, uint32_t flags);
-vg_t *vg_read_for_update(struct cmd_context *cmd, const char *vg_name,
+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(vg_t *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 */
-pv_t *pv_create(const struct cmd_context *cmd,
+struct physical_volume *pv_create(const struct cmd_context *cmd,
                      struct device *dev,
                      struct id *id,
                      uint64_t size,
@@ -438,17 +437,17 @@ int pv_analyze(struct cmd_context *cmd, const char *pv_name,
 /* FIXME: move internal to library */
 uint32_t pv_list_extents_free(const struct dm_list *pvh);
 
-vg_t *vg_create(struct cmd_context *cmd, const char *vg_name);
+struct volume_group *vg_create(struct cmd_context *cmd, const char *vg_name);
 int vg_remove(struct volume_group *vg);
-int vg_remove_single(vg_t *vg);
+int vg_remove_single(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, char **pv_names);
 int vg_reduce(struct volume_group *vg, char *pv_name);
-int vg_set_extent_size(vg_t *vg, uint32_t new_extent_size);
-int vg_set_max_lv(vg_t *vg, uint32_t max_lv);
-int vg_set_max_pv(vg_t *vg, uint32_t max_pv);
-int vg_set_alloc_policy(vg_t *vg, alloc_policy_t alloc);
+int vg_set_extent_size(struct volume_group *vg, uint32_t new_extent_size);
+int vg_set_max_lv(struct volume_group *vg, uint32_t max_lv);
+int vg_set_max_pv(struct volume_group *vg, uint32_t max_pv);
+int vg_set_alloc_policy(struct volume_group *vg, alloc_policy_t alloc);
 int vg_split_mdas(struct cmd_context *cmd, struct volume_group *vg_from,
                  struct volume_group *vg_to);
 
@@ -574,7 +573,7 @@ struct logical_volume *insert_layer_for_lv(struct cmd_context *cmd,
 /* Find a PV within a given VG */
 struct pv_list *find_pv_in_vg(const struct volume_group *vg,
                              const char *pv_name);
-pv_t *find_pv_in_vg_by_uuid(const struct volume_group *vg,
+struct physical_volume *find_pv_in_vg_by_uuid(const struct volume_group *vg,
                            const struct id *id);
 
 /* Find an LV within a given VG */
@@ -692,29 +691,29 @@ char *generate_lv_name(struct volume_group *vg, const char *format,
 /*
 * Begin skeleton for external LVM library
 */
-struct device *pv_dev(const pv_t *pv);
-const char *pv_vg_name(const pv_t *pv);
-const char *pv_dev_name(const pv_t *pv);
-uint64_t pv_size(const pv_t *pv);
-uint32_t pv_status(const pv_t *pv);
-uint32_t pv_pe_size(const pv_t *pv);
-uint64_t pv_pe_start(const pv_t *pv);
-uint32_t pv_pe_count(const pv_t *pv);
-uint32_t pv_pe_alloc_count(const pv_t *pv);
-uint32_t pv_mda_count(const pv_t *pv);
-
-uint64_t lv_size(const lv_t *lv);
-
-int vg_missing_pv_count(const vg_t *vg);
-uint32_t vg_seqno(const vg_t *vg);
-uint32_t vg_status(const vg_t *vg);
-uint64_t vg_size(const vg_t *vg);
-uint64_t vg_free(const vg_t *vg);
-uint64_t vg_extent_size(const vg_t *vg);
-uint64_t vg_extent_count(const vg_t *vg);
-uint64_t vg_free_count(const vg_t *vg);
-uint64_t vg_pv_count(const vg_t *vg);
-int vg_check_write_mode(vg_t *vg);
+struct device *pv_dev(const struct physical_volume *pv);
+const char *pv_vg_name(const struct physical_volume *pv);
+const char *pv_dev_name(const struct physical_volume *pv);
+uint64_t pv_size(const struct physical_volume *pv);
+uint32_t pv_status(const struct physical_volume *pv);
+uint32_t pv_pe_size(const struct physical_volume *pv);
+uint64_t pv_pe_start(const struct physical_volume *pv);
+uint32_t pv_pe_count(const struct physical_volume *pv);
+uint32_t pv_pe_alloc_count(const struct physical_volume *pv);
+uint32_t pv_mda_count(const struct physical_volume *pv);
+
+uint64_t lv_size(const struct logical_volume *lv);
+
+int vg_missing_pv_count(const struct volume_group *vg);
+uint32_t vg_seqno(const struct volume_group *vg);
+uint32_t vg_status(const struct volume_group *vg);
+uint64_t vg_size(const struct volume_group *vg);
+uint64_t vg_free(const struct volume_group *vg);
+uint64_t vg_extent_size(const struct volume_group *vg);
+uint64_t vg_extent_count(const struct volume_group *vg);
+uint64_t vg_free_count(const struct volume_group *vg);
+uint64_t vg_pv_count(const struct volume_group *vg);
+int vg_check_write_mode(struct volume_group *vg);
 #define vg_is_clustered(vg) (vg_status((vg)) & CLUSTERED)
 
 struct vgcreate_params {

diff --git a/lib/metadata/metadata.c b/lib/metadata/metadata.c
index 68f645f5f22b99090e95cf09a4d0c8a0b586dc27..76af7668096d77c99726fd1fc2d82dbf0b5c6dc7 100644 (file)
--- a/lib/metadata/metadata.c
+++ b/lib/metadata/metadata.c
@@ -58,9 +58,6 @@ static struct pv_list *_find_pv_in_vg(const struct volume_group *vg,
 static struct physical_volume *_find_pv_in_vg_by_uuid(const struct volume_group *vg,
                                                      const struct id *id);
 
-static vg_t *_vg_make_handle(struct cmd_context *cmd,
-                            struct volume_group *vg,
-                            uint32_t failure);
 static uint32_t _vg_bad_status_bits(const struct volume_group *vg,
                                    uint32_t status);
 
@@ -429,7 +426,7 @@ int remove_lvs_in_vg(struct cmd_context *cmd,
        return 1;
 }
 
-int vg_remove_single(vg_t *vg)
+int vg_remove_single(struct volume_group *vg)
 {
        struct physical_volume *pv;
        struct pv_list *pvl;
@@ -628,17 +625,43 @@ int validate_vg_create_params(struct cmd_context *cmd,
        return 0;
 }
 
+/*
+ * Create a (struct volume_group) volume group handle from a struct volume_group pointer and a
+ * possible failure code or zero for success.
+ */
+static struct volume_group *_vg_make_handle(struct cmd_context *cmd,
+                            struct volume_group *vg,
+                            uint32_t failure)
+{
+       struct dm_pool *vgmem;
+
+       if (!vg) {
+               if (!(vgmem = dm_pool_create("lvm2 vg_handle", VG_MEMPOOL_CHUNK)) ||
+                   !(vg = dm_pool_zalloc(vgmem, sizeof(*vg)))) {
+                       log_error("Error allocating vg handle.");
+                       if (vgmem)
+                               dm_pool_destroy(vgmem);
+                       return_NULL;
+               }
+               vg->vgmem = vgmem;
+       }
+
+       vg->read_status = failure;
+
+       return (struct volume_group *)vg;
+}
+
 /*
  * Create a VG with default parameters.
  * Returns:
- * - vg_t* with SUCCESS code: VG structure created
- * - NULL or vg_t* with FAILED_* code: error creating VG structure
+ * - struct volume_group* with SUCCESS code: VG structure created
+ * - NULL or struct volume_group* with FAILED_* code: error creating VG structure
  * Use vg_read_error() to determine success or failure.
  * FIXME: cleanup usage of _vg_make_handle()
  */
-vg_t *vg_create(struct cmd_context *cmd, const char *vg_name)
+struct volume_group *vg_create(struct cmd_context *cmd, const char *vg_name)
 {
-       vg_t *vg;
+       struct volume_group *vg;
        int consistent = 0;
        struct dm_pool *mem;
        uint32_t rc;
@@ -778,7 +801,7 @@ static int _recalc_extents(uint32_t *extents, const char *desc1,
        return 1;
 }
 
-int vg_set_extent_size(vg_t *vg, uint32_t new_size)
+int vg_set_extent_size(struct volume_group *vg, uint32_t new_size)
 {
        uint32_t old_size = vg->extent_size;
        struct pv_list *pvl;
@@ -925,7 +948,7 @@ int vg_set_extent_size(vg_t *vg, uint32_t new_size)
        return 1;
 }
 
-int vg_set_max_lv(vg_t *vg, uint32_t max_lv)
+int vg_set_max_lv(struct volume_group *vg, uint32_t max_lv)
 {
        if (!(vg_status(vg) & RESIZEABLE_VG)) {
                log_error("Volume group \"%s\" must be resizeable "
@@ -953,7 +976,7 @@ int vg_set_max_lv(vg_t *vg, uint32_t max_lv)
        return 1;
 }
 
-int vg_set_max_pv(vg_t *vg, uint32_t max_pv)
+int vg_set_max_pv(struct volume_group *vg, uint32_t max_pv)
 {
        if (!(vg_status(vg) & RESIZEABLE_VG)) {
                log_error("Volume group \"%s\" must be resizeable "
@@ -980,7 +1003,7 @@ int vg_set_max_pv(vg_t *vg, uint32_t max_pv)
        return 1;
 }
 
-int vg_set_alloc_policy(vg_t *vg, alloc_policy_t alloc)
+int vg_set_alloc_policy(struct volume_group *vg, alloc_policy_t alloc)
 {
        if (alloc == ALLOC_INHERIT) {
                log_error("Volume Group allocation policy cannot inherit "
@@ -1189,9 +1212,9 @@ static void fill_default_pvcreate_params(struct pvcreate_params *pp)
  *
  * Returns:
  * NULL: error
- * pv_t * (non-NULL): handle to physical volume created
+ * struct physical_volume * (non-NULL): handle to physical volume created
  */
-pv_t * pvcreate_single(struct cmd_context *cmd, const char *pv_name,
+struct physical_volume * pvcreate_single(struct cmd_context *cmd, const char *pv_name,
                       struct pvcreate_params *pp)
 {
        void *pv;
@@ -1452,7 +1475,7 @@ int pv_is_in_vg(struct volume_group *vg, struct physical_volume *pv)
  * Note
  *   FIXME - liblvm todo - make into function that takes VG handle
  */
-pv_t *find_pv_in_vg_by_uuid(const struct volume_group *vg,
+struct physical_volume *find_pv_in_vg_by_uuid(const struct volume_group *vg,
                            const struct id *id)
 {
        return _find_pv_in_vg_by_uuid(vg, id);
@@ -2277,7 +2300,7 @@ static int _update_pv_list(struct dm_pool *pvmem, struct dm_list *all_pvs, struc
        return 1;
 }
 
-int vg_missing_pv_count(const vg_t *vg)
+int vg_missing_pv_count(const struct volume_group *vg)
 {
        int ret = 0;
        struct pv_list *pvl;
@@ -2986,7 +3009,7 @@ int is_orphan_vg(const char *vg_name)
  * is_orphan - Determine whether a pv is an orphan based on its vg_name
  * @pv: handle to the physical volume
  */
-int is_orphan(const pv_t *pv)
+int is_orphan(const struct physical_volume *pv)
 {
        return is_orphan_vg(pv_field(pv, vg_name));
 }
@@ -2995,7 +3018,7 @@ int is_orphan(const pv_t *pv)
  * is_pv - Determine whether a pv is a real pv or dummy one
  * @pv: handle to device
  */
-int is_pv(pv_t *pv)
+int is_pv(struct physical_volume *pv)
 {
        return (pv_field(pv, vg_name) ? 1 : 0);
 }
@@ -3043,7 +3066,7 @@ int pv_analyze(struct cmd_context *cmd, const char *pv_name,
 }
 
 /* FIXME: remove / combine this with locking? */
-int vg_check_write_mode(vg_t *vg)
+int vg_check_write_mode(struct volume_group *vg)
 {
        if (vg->open_mode != 'w') {
                log_errno(EPERM, "Attempt to modify a read-only VG");
@@ -3101,33 +3124,7 @@ int vg_check_status(const struct volume_group *vg, uint32_t status)
        return !_vg_bad_status_bits(vg, status);
 }
 
-/*
- * Create a (vg_t) volume group handle from a struct volume_group pointer and a
- * possible failure code or zero for success.
- */
-static vg_t *_vg_make_handle(struct cmd_context *cmd,
-                            struct volume_group *vg,
-                            uint32_t failure)
-{
-       struct dm_pool *vgmem;
-
-       if (!vg) {
-               if (!(vgmem = dm_pool_create("lvm2 vg_handle", VG_MEMPOOL_CHUNK)) ||
-                   !(vg = dm_pool_zalloc(vgmem, sizeof(*vg)))) {
-                       log_error("Error allocating vg handle.");
-                       if (vgmem)
-                               dm_pool_destroy(vgmem);
-                       return_NULL;
-               }
-               vg->vgmem = vgmem;
-       }
-
-       vg->read_status = failure;
-
-       return (vg_t *)vg;
-}
-
-static vg_t *_recover_vg(struct cmd_context *cmd, const char *lock_name,
+static struct volume_group *_recover_vg(struct cmd_context *cmd, const char *lock_name,
                         const char *vg_name, const char *vgid,
                         uint32_t lock_flags)
 {
@@ -3152,7 +3149,7 @@ static vg_t *_recover_vg(struct cmd_context *cmd, const char *lock_name,
                return_NULL;
        }
 
-       return (vg_t *)vg;
+       return (struct volume_group *)vg;
 }
 
 /*
@@ -3166,7 +3163,7 @@ static vg_t *_recover_vg(struct cmd_context *cmd, const char *lock_name,
  * problems reading the volume group.
  * Zero value means that the VG is open and appropriate locks are held.
  */
-static vg_t *_vg_lock_and_read(struct cmd_context *cmd, const char *vg_name,
+static struct volume_group *_vg_lock_and_read(struct cmd_context *cmd, const char *vg_name,
                               const char *vgid, uint32_t lock_flags,
                               uint32_t status_flags, uint32_t misc_flags)
 {
@@ -3279,7 +3276,7 @@ bad:
  * toollib just set lock_flags to LCK_VG_WRITE and called vg_read_internal with
  * *consistent = 1.
  */
-vg_t *vg_read(struct cmd_context *cmd, const char *vg_name,
+struct volume_group *vg_read(struct cmd_context *cmd, const char *vg_name,
              const char *vgid, uint32_t flags)
 {
        uint32_t status = 0;
@@ -3301,7 +3298,7 @@ vg_t *vg_read(struct cmd_context *cmd, const char *vg_name,
  * later update (this means the user code can change the metadata and later
  * request the new metadata to be written and committed).
  */
-vg_t *vg_read_for_update(struct cmd_context *cmd, const char *vg_name,
+struct volume_group *vg_read_for_update(struct cmd_context *cmd, const char *vg_name,
                         const char *vgid, uint32_t flags)
 {
        return vg_read(cmd, vg_name, vgid, flags | READ_FOR_UPDATE);
@@ -3310,7 +3307,7 @@ vg_t *vg_read_for_update(struct cmd_context *cmd, const char *vg_name,
 /*
  * Test the validity of a VG handle returned by vg_read() or vg_read_for_update().
  */
-uint32_t vg_read_error(vg_t *vg_handle)
+uint32_t vg_read_error(struct volume_group *vg_handle)
 {
        if (!vg_handle)
                return FAILED_ALLOCATION;
@@ -3366,67 +3363,67 @@ uint32_t vg_lock_newname(struct cmd_context *cmd, const char *vgname)
 /*
  * Gets/Sets for external LVM library
  */
-struct id pv_id(const pv_t *pv)
+struct id pv_id(const struct physical_volume *pv)
 {
        return pv_field(pv, id);
 }
 
-const struct format_type *pv_format_type(const pv_t *pv)
+const struct format_type *pv_format_type(const struct physical_volume *pv)
 {
        return pv_field(pv, fmt);
 }
 
-struct id pv_vgid(const pv_t *pv)
+struct id pv_vgid(const struct physical_volume *pv)
 {
        return pv_field(pv, vgid);
 }
 
-struct device *pv_dev(const pv_t *pv)
+struct device *pv_dev(const struct physical_volume *pv)
 {
        return pv_field(pv, dev);
 }
 
-const char *pv_vg_name(const pv_t *pv)
+const char *pv_vg_name(const struct physical_volume *pv)
 {
        return pv_field(pv, vg_name);
 }
 
-const char *pv_dev_name(const pv_t *pv)
+const char *pv_dev_name(const struct physical_volume *pv)
 {
        return dev_name(pv_dev(pv));
 }
 
-uint64_t pv_size(const pv_t *pv)
+uint64_t pv_size(const struct physical_volume *pv)
 {
        return pv_field(pv, size);
 }
 
-uint32_t pv_status(const pv_t *pv)
+uint32_t pv_status(const struct physical_volume *pv)
 {
        return pv_field(pv, status);
 }
 
-uint32_t pv_pe_size(const pv_t *pv)
+uint32_t pv_pe_size(const struct physical_volume *pv)
 {
        return pv_field(pv, pe_size);
 }
 
-uint64_t pv_pe_start(const pv_t *pv)
+uint64_t pv_pe_start(const struct physical_volume *pv)
 {
        return pv_field(pv, pe_start);
 }
 
-uint32_t pv_pe_count(const pv_t *pv)
+uint32_t pv_pe_count(const struct physical_volume *pv)
 {
        return pv_field(pv, pe_count);
 }
 
-uint32_t pv_pe_alloc_count(const pv_t *pv)
+uint32_t pv_pe_alloc_count(const struct physical_volume *pv)
 {
        return pv_field(pv, pe_alloc_count);
 }
 
-uint32_t pv_mda_count(const pv_t *pv)
+uint32_t pv_mda_count(const struct physical_volume *pv)
 {
        struct lvmcache_info *info;
 
@@ -3434,47 +3431,47 @@ uint32_t pv_mda_count(const pv_t *pv)
        return info ? dm_list_size(&info->mdas) : UINT64_C(0);
 }
 
-uint32_t vg_seqno(const vg_t *vg)
+uint32_t vg_seqno(const struct volume_group *vg)
 {
        return vg->seqno;
 }
 
-uint32_t vg_status(const vg_t *vg)
+uint32_t vg_status(const struct volume_group *vg)
 {
        return vg->status;
 }
 
-uint64_t vg_size(const vg_t *vg)
+uint64_t vg_size(const struct volume_group *vg)
 {
        return (uint64_t) vg->extent_count * vg->extent_size;
 }
 
-uint64_t vg_free(const vg_t *vg)
+uint64_t vg_free(const struct volume_group *vg)
 {
        return (uint64_t) vg->free_count * vg->extent_size;
 }
 
-uint64_t vg_extent_size(const vg_t *vg)
+uint64_t vg_extent_size(const struct volume_group *vg)
 {
        return (uint64_t) vg->extent_size;
 }
 
-uint64_t vg_extent_count(const vg_t *vg)
+uint64_t vg_extent_count(const struct volume_group *vg)
 {
        return (uint64_t) vg->extent_count;
 }
 
-uint64_t vg_free_count(const vg_t *vg)
+uint64_t vg_free_count(const struct volume_group *vg)
 {
        return (uint64_t) vg->free_count;
 }
 
-uint64_t vg_pv_count(const vg_t *vg)
+uint64_t vg_pv_count(const struct volume_group *vg)
 {
        return (uint64_t) vg->pv_count;
 }
 
-uint64_t lv_size(const lv_t *lv)
+uint64_t lv_size(const struct logical_volume *lv)
 {
        return lv->size;
 }
@@ -3490,7 +3487,7 @@ uint64_t lv_size(const lv_t *lv)
  *
  * FIXME: merge with find_pv_by_name ?
  */
-pv_t *pv_by_path(struct cmd_context *cmd, const char *pv_name)
+struct physical_volume *pv_by_path(struct cmd_context *cmd, const char *pv_name)
 {
        struct dm_list mdas;
 

diff --git a/lib/metadata/metadata.h b/lib/metadata/metadata.h
index ceb089ccf6b3553fbaec28b52c9944a734bead4d..b9cdfeba25f8126a24e23561b4cf13805466e001 100644 (file)
--- a/lib/metadata/metadata.h
+++ b/lib/metadata/metadata.h
@@ -368,11 +368,11 @@ int fixup_imported_mirrors(struct volume_group *vg);
 /*
  * Begin skeleton for external LVM library
  */
-struct id pv_id(const pv_t *pv);
-const struct format_type *pv_format_type(const pv_t *pv);
-struct id pv_vgid(const pv_t *pv);
+struct id pv_id(const struct physical_volume *pv);
+const struct format_type *pv_format_type(const struct physical_volume *pv);
+struct id pv_vgid(const struct physical_volume *pv);
 
-pv_t *pv_by_path(struct cmd_context *cmd, const char *pv_name);
+struct physical_volume *pv_by_path(struct cmd_context *cmd, const char *pv_name);
 int add_pv_to_vg(struct volume_group *vg, const char *pv_name,
                 struct physical_volume *pv);
 

diff --git a/liblvm/Makefile.in b/liblvm/Makefile.in
index f356131927e9b1df2e24105e3defe70f0d5a76c6..e7d713be352d280340161e8671d5c8d8a42c4ac5 100644 (file)
--- a/liblvm/Makefile.in
+++ b/liblvm/Makefile.in
@@ -62,7 +62,7 @@ endif
 install: $(INSTALL_TYPE) install_include
 
 install_include:
-       $(INSTALL) -D $(OWNER) $(GROUP) -m 444 lvm.h $(includedir)/lvm.h
+       $(INSTALL) -D $(OWNER) $(GROUP) -m 444 lvm2app.h $(includedir)/lvm2app.h
 
 install_dynamic: $(LIB_SHARED)
        $(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \

diff --git a/liblvm/lvm.h b/liblvm/lvm2app.h
similarity index 99%
rename from liblvm/lvm.h
rename to liblvm/lvm2app.h
index 8db6ad300935041c4d900099da609a7b24a2252d..0a46ae43a10211d47c4bf69fe0987579ff13c64a 100644 (file)
--- a/liblvm/lvm.h
+++ b/liblvm/lvm2app.h
@@ -11,8 +11,8 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-#ifndef _LIB_LVM_H
-#define _LIB_LVM_H
+#ifndef _LIB_LVM2APP_H
+#define _LIB_LVM2APP_H
 
 #include "lvm-version.h"
 #include "libdevmapper.h"
@@ -826,4 +826,4 @@ uint64_t lvm_pv_get_mda_count(const pv_t *pv);
  */
 int lvm_pv_resize(const pv_t *pv, uint64_t new_size);
 
-#endif /* _LIB_LVM_H */
+#endif /* _LIB_LVM2APP_H */

diff --git a/liblvm/lvm_base.c b/liblvm/lvm_base.c
index 5a6fa75dcb474abf8a0b2255db9009c4d35beef5..e910a9f55380a3516d0f348c1410091ff31e1d5e 100644 (file)
--- a/liblvm/lvm_base.c
+++ b/liblvm/lvm_base.c
@@ -13,7 +13,7 @@
  */
 
 #include "lib.h"
-#include "lvm.h"
+#include "lvm2app.h"
 #include "toolcontext.h"
 #include "locking.h"
 

diff --git a/liblvm/lvm_lv.c b/liblvm/lvm_lv.c
index 46b0360fc082eb3eea89245df3816a681c74b02d..059d639cfb948ba30c88424e6ad1fa7613a3412c 100644 (file)
--- a/liblvm/lvm_lv.c
+++ b/liblvm/lvm_lv.c
@@ -13,7 +13,7 @@
  */
 
 #include "lib.h"
-#include "lvm.h"
+#include "lvm2app.h"
 #include "metadata-exported.h"
 #include "lvm-string.h"
 #include "defaults.h"
@@ -120,7 +120,7 @@ lv_t *lvm_vg_create_lv_linear(vg_t *vg, const char *name, uint64_t size)
        lvl = find_lv_in_vg(vg, name);
        if (!lvl)
                return NULL;
-       return lvl->lv;
+       return (struct lv_t *) lvl->lv;
 }
 
 /*

diff --git a/liblvm/lvm_pv.c b/liblvm/lvm_pv.c
index 6ee1c03f2996056a19e29f8411848aa3d7ba11dc..3d67769466f89e818e8768078ce8e483f124d43d 100644 (file)
--- a/liblvm/lvm_pv.c
+++ b/liblvm/lvm_pv.c
@@ -13,7 +13,7 @@
  */
 
 #include "lib.h"
-#include "lvm.h"
+#include "lvm2app.h"
 #include "metadata-exported.h"
 #include "lvm-string.h"
 

diff --git a/liblvm/lvm_vg.c b/liblvm/lvm_vg.c
index 048cae94efa267bd97909cf47bdcc5dd49658821..b8c3ff46a305c9db8a3c3751ebe0c646904be828 100644 (file)
--- a/liblvm/lvm_vg.c
+++ b/liblvm/lvm_vg.c
@@ -13,7 +13,7 @@
  */
 
 #include "lib.h"
-#include "lvm.h"
+#include "lvm2app.h"
 #include "toolcontext.h"
 #include "metadata-exported.h"
 #include "archiver.h"
@@ -36,7 +36,7 @@ vg_t *lvm_vg_create(lvm_t libh, const char *vg_name)
                return NULL;
        }
        vg->open_mode = 'w';
-       return vg;
+       return (vg_t *) vg;
 }
 
 int lvm_vg_extend(vg_t *vg, const char *device)
@@ -180,7 +180,7 @@ vg_t *lvm_vg_open(lvm_t libh, const char *vgname, const char *mode,
        /* FIXME: combine this with locking ? */
        vg->open_mode = mode[0];
 
-       return vg;
+       return (vg_t *) vg;
 }
 
 struct dm_list *lvm_vg_list_pvs(vg_t *vg)