Replace free_vg with release_vg

Move the free_vg() to  vg.c  and replace free_vg  with release_vg
and make the _free_vg internal.

Patch is needed for sharing VG in vginfo cache so the release_vg function name
is a better fit here.

diff --git a/WHATS_NEW b/WHATS_NEW
index c73fe24f3c87b0b37e7a72c9fad2d3d17fb83af3..2571fc97928851699e1be42c99040df4bfc51156 100644 (file)
--- a/WHATS_NEW
+++ b/WHATS_NEW
@@ -1,5 +1,6 @@
 Version 2.02.87 - 
 ===============================
+  Replace free_vg with release_vg and move it to vg.c.
   Remove INCONSISTENT_VG flag from the code.
   Remove lock from cache even if unlock fails.
   Initialise clvmd locks before lvm context to avoid open descriptor leaks.

diff --git a/daemons/clvmd/lvm-functions.c b/daemons/clvmd/lvm-functions.c
index eb1a42ad2793d495da2e44d578dd432fc1483984..b988b1555ce6c9ca7d17f77958e7ca77aee9268b 100644 (file)
--- a/daemons/clvmd/lvm-functions.c
+++ b/daemons/clvmd/lvm-functions.c
@@ -840,7 +840,7 @@ void lvm_do_backup(const char *vgname)
        else
                log_error("Error backing up metadata, can't find VG for group %s", vgname);
 
-       free_vg(vg);
+       release_vg(vg);
        dm_pool_empty(cmd->mem);
 
        pthread_mutex_unlock(&lvm_lock);

diff --git a/lib/activate/activate.c b/lib/activate/activate.c
index de662281c180d433cfb9d61e6ee319a89769389b..d368f38c5bd0d40006bd86d4aca2a9c709d83b77 100644 (file)
--- a/lib/activate/activate.c
+++ b/lib/activate/activate.c
@@ -521,7 +521,7 @@ int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
                origin_only = 0;
 
        r = lv_info(cmd, lv, origin_only, info, with_open_count, with_read_ahead);
-       free_vg(lv->vg);
+       release_vg(lv->vg);
 
        return r;
 }
@@ -1267,10 +1267,10 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
        r = 1;
 out:
        if (lv_pre)
-               free_vg(lv_pre->vg);
+               release_vg(lv_pre->vg);
        if (lv) {
                lv_release_replicator_vgs(lv);
-               free_vg(lv->vg);
+               release_vg(lv->vg);
        }
 
        return r;
@@ -1351,7 +1351,7 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
        r = 1;
 out:
        if (lv)
-               free_vg(lv->vg);
+               release_vg(lv->vg);
 
        return r;
 }
@@ -1458,7 +1458,7 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
 out:
        if (lv) {
                lv_release_replicator_vgs(lv);
-               free_vg(lv->vg);
+               release_vg(lv->vg);
        }
 
        return r;
@@ -1488,7 +1488,7 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
        r = 1;
 out:
        if (lv)
-               free_vg(lv->vg);
+               release_vg(lv->vg);
 
        return r;
 }
@@ -1557,7 +1557,7 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
 out:
        if (lv) {
                lv_release_replicator_vgs(lv);
-               free_vg(lv->vg);
+               release_vg(lv->vg);
        }
 
        return r;

diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c
index 527d79b42cd60584c76c5ee70ff85989a16c35bf..43ed1f46973008eebe65f5051e629a75813185cd 100644 (file)
--- a/lib/cache/lvmcache.c
+++ b/lib/cache/lvmcache.c
@@ -683,7 +683,7 @@ struct volume_group *lvmcache_get_vg(const char *vgid, unsigned precommitted)
        return vg;
 
 bad:
-       free_vg(vg);
+       release_vg(vg);
        _free_cached_vgmetadata(vginfo);
        return NULL;
 }

diff --git a/lib/format_pool/format_pool.c b/lib/format_pool/format_pool.c
index a9eba248821329417631bad26f3db285e3d94682..6caa76ac87bd9cdbbc121ade7c35966c12ee92aa 100644 (file)
--- a/lib/format_pool/format_pool.c
+++ b/lib/format_pool/format_pool.c
@@ -156,7 +156,7 @@ static struct volume_group *_pool_vg_read(struct format_instance *fid,
        return vg;
 
 bad:
-       free_vg(vg);
+       release_vg(vg);
 
        return NULL;
 }

diff --git a/lib/format_text/archive.c b/lib/format_text/archive.c
index 4e7c8f182abd8f3633fcea186b037ad47dba84b5..c9fd0e902067e3f170d4882ea91c0038698c7eb4 100644 (file)
--- a/lib/format_text/archive.c
+++ b/lib/format_text/archive.c
@@ -332,7 +332,7 @@ static void _display_archive(struct cmd_context *cmd, struct archive_file *af)
        log_print("Description:\t%s", desc ? : "<No description>");
        log_print("Backup Time:\t%s", ctime(&when));
 
-       free_vg(vg);
+       release_vg(vg);
 }
 
 int archive_list(struct cmd_context *cmd, const char *dir, const char *vgname)

diff --git a/lib/format_text/archiver.c b/lib/format_text/archiver.c
index e3e9fe051e2e49eee7164609a4e294dabb5bdf17..498b6f28861e3c6a92c6ece49c65bd01d5eb932f 100644 (file)
--- a/lib/format_text/archiver.c
+++ b/lib/format_text/archiver.c
@@ -362,7 +362,7 @@ int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name,
                log_error("Cannot restore Volume Group %s with %i PVs "
                          "marked as missing.", vg->name, missing_pvs);
 
-       free_vg(vg);
+       release_vg(vg);
        return r;
 }
 
@@ -447,7 +447,7 @@ void check_current_backup(struct volume_group *vg)
            (vg->seqno == vg_backup->seqno) &&
            (id_equal(&vg->id, &vg_backup->id))) {
                log_suppress(old_suppress);
-               free_vg(vg_backup);
+               release_vg(vg_backup);
                return;
        }
        log_suppress(old_suppress);
@@ -455,7 +455,7 @@ void check_current_backup(struct volume_group *vg)
        if (vg_backup) {
                if (!archive(vg_backup))
                        stack;
-               free_vg(vg_backup);
+               release_vg(vg_backup);
        }
        if (!archive(vg))
                stack;

diff --git a/lib/format_text/format-text.c b/lib/format_text/format-text.c
index d53313c078e535eeb6783b065409837045581be2..4a025b2279219f55352bcd5b6597455c195029f5 100644 (file)
--- a/lib/format_text/format-text.c
+++ b/lib/format_text/format-text.c
@@ -855,7 +855,7 @@ static struct volume_group *_vg_read_file_name(struct format_instance *fid,
         * check that it contains the correct volume group.
         */
        if (vgname && strcmp(vgname, vg->name)) {
-               free_vg(vg);
+               release_vg(vg);
                log_error("'%s' does not contain volume group '%s'.",
                          read_path, vgname);
                return NULL;
@@ -1091,7 +1091,7 @@ static int _scan_file(const struct format_type *fmt, const char *vgname)
                                                             path))) {
                                        /* FIXME Store creation host in vg */
                                        lvmcache_update_vg(vg, 0);
-                                       free_vg(vg);
+                                       release_vg(vg);
                                }
                        }
 

diff --git a/lib/format_text/import_vsn1.c b/lib/format_text/import_vsn1.c
index 5b1c4a42707970cb74df78a4e2d783c99f846eb7..3232cc05c24fe9d55e3b2e1aad262bd47c31e0b0 100644 (file)
--- a/lib/format_text/import_vsn1.c
+++ b/lib/format_text/import_vsn1.c
@@ -814,7 +814,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
        if (lv_hash)
                dm_hash_destroy(lv_hash);
 
-       free_vg(vg);
+       release_vg(vg);
        return NULL;
 }
 

diff --git a/lib/locking/locking.h b/lib/locking/locking.h
index 6a184573dc3ed6548c3c96b02164c45164ae6a3e..f8a2c25151e435a24744e0bd38d50b33a5e6e2f1 100644 (file)
--- a/lib/locking/locking.h
+++ b/lib/locking/locking.h
@@ -156,10 +156,10 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
                        sync_dev_names(cmd); \
                lock_vol(cmd, vol, LCK_VG_UNLOCK); \
        } while (0)
-#define unlock_and_free_vg(cmd, vg, vol) \
+#define unlock_and_release_vg(cmd, vg, vol) \
        do { \
                unlock_vg(cmd, vol); \
-               free_vg(vg); \
+               release_vg(vg); \
        } while (0)
 
 #define resume_lv(cmd, lv)     lock_lv_vol(cmd, lv, LCK_LV_RESUME)

diff --git a/lib/metadata/metadata-exported.h b/lib/metadata/metadata-exported.h
index 8b1c0fe321e32c2f585232ec30b2cf1473291a75..070037172c8dec19026f190d44b458a31be9fd07 100644 (file)
--- a/lib/metadata/metadata-exported.h
+++ b/lib/metadata/metadata-exported.h
@@ -479,12 +479,6 @@ int remove_lvs_in_vg(struct cmd_context *cmd,
  */
 void free_pv_fid(struct physical_volume *pv);
 
-/*
- * free_vg() must be called on every struct volume_group allocated
- * by vg_create() or vg_read_internal() to free it when no longer required.
- */
-void free_vg(struct volume_group *vg);
-
 /* Manipulate LVs */
 struct logical_volume *lv_create_empty(const char *name,
                                       union lvid *lvid,

diff --git a/lib/metadata/metadata.c b/lib/metadata/metadata.c
index 215d1f49394d8029226949709bfc35f9eb1983ce..ab8aa61378e8da0bb4497bcc56cc3baf62b383dd 100644 (file)
--- a/lib/metadata/metadata.c
+++ b/lib/metadata/metadata.c
@@ -374,7 +374,7 @@ int get_pv_from_vg_by_id(const struct format_type *fmt, const char *vg_name,
                }
        }
 out:
-       free_vg(vg);
+       release_vg(vg);
        return r;
 }
 
@@ -928,7 +928,7 @@ struct volume_group *vg_create(struct cmd_context *cmd, const char *vg_name)
        /* is this vg name already in use ? */
        if ((vg = vg_read_internal(cmd, vg_name, NULL, 1, &consistent))) {
                log_error("A volume group called '%s' already exists.", vg_name);
-               unlock_and_free_vg(cmd, vg, vg_name);
+               unlock_and_release_vg(cmd, vg, vg_name);
                return _vg_make_handle(cmd, NULL, FAILED_EXIST);
        }
 
@@ -980,7 +980,7 @@ struct volume_group *vg_create(struct cmd_context *cmd, const char *vg_name)
        return _vg_make_handle(cmd, vg, SUCCESS);
 
 bad:
-       unlock_and_free_vg(cmd, vg, vg_name);
+       unlock_and_release_vg(cmd, vg, vg_name);
        /* FIXME: use _vg_make_handle() w/proper error code */
        return NULL;
 }
@@ -2730,7 +2730,7 @@ static struct volume_group *_vg_read_orphans(struct cmd_context *cmd,
        return vg;
 bad:
        free_pv_fid(pv);
-       free_vg(vg);
+       release_vg(vg);
        return NULL;
 }
 
@@ -2865,7 +2865,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                *consistent = 1;
                return correct_vg;
        } else {
-               free_vg(correct_vg);
+               release_vg(correct_vg);
                correct_vg = NULL;
        }
 
@@ -2911,7 +2911,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                    (!use_precommitted &&
                     !(vg = mda->ops->vg_read(fid, vgname, mda)))) {
                        inconsistent = 1;
-                       free_vg(vg);
+                       release_vg(vg);
                        continue;
                }
 
@@ -2930,7 +2930,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                                inconsistent = 1;
 
                        if (vg->seqno > correct_vg->seqno) {
-                               free_vg(correct_vg);
+                               release_vg(correct_vg);
                                correct_vg = vg;
                        } else {
                                mda->status |= MDA_INCONSISTENT;
@@ -2939,7 +2939,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                }
 
                if (vg != correct_vg)
-                       free_vg(vg);
+                       release_vg(vg);
        }
 
        /* Ensure every PV in the VG was in the cache */
@@ -3015,7 +3015,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                        if (critical_section())
                                inconsistent = 1;
                        else {
-                               free_vg(correct_vg);
+                               release_vg(correct_vg);
                                correct_vg = NULL;
                        }
                } else dm_list_iterate_items(pvl, &correct_vg->pvs) {
@@ -3024,14 +3024,14 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                        if (!str_list_match_item(pvids, pvl->pv->dev->pvid)) {
                                log_debug("Cached VG %s had incorrect PV list",
                                          vgname);
-                               free_vg(correct_vg);
+                               release_vg(correct_vg);
                                correct_vg = NULL;
                                break;
                        }
                }
 
                if (correct_vg && inconsistent_mdas) {
-                       free_vg(correct_vg);
+                       release_vg(correct_vg);
                        correct_vg = NULL;
                }
        }
@@ -3076,7 +3076,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                                correct_vg = vg;
                                if (!_update_pv_list(cmd->mem, &all_pvs, correct_vg)) {
                                        _free_pv_list(&all_pvs);
-                                       free_vg(vg);
+                                       release_vg(vg);
                                        return_NULL;
                                }
                                continue;
@@ -3099,12 +3099,12 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
 
                                if (!_update_pv_list(cmd->mem, &all_pvs, vg)) {
                                        _free_pv_list(&all_pvs);
-                                       free_vg(vg);
-                                       free_vg(correct_vg);
+                                       release_vg(vg);
+                                       release_vg(correct_vg);
                                        return_NULL;
                                }
                                if (vg->seqno > correct_vg->seqno) {
-                                       free_vg(correct_vg);
+                                       release_vg(correct_vg);
                                        correct_vg = vg;
                                } else {
                                        mda->status |= MDA_INCONSISTENT;
@@ -3113,7 +3113,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                        }
 
                        if (vg != correct_vg)
-                               free_vg(vg);
+                               release_vg(vg);
                }
 
                /* Give up looking */
@@ -3159,7 +3159,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                                return correct_vg;
                        }
                        _free_pv_list(&all_pvs);
-                       free_vg(correct_vg);
+                       release_vg(correct_vg);
                        return NULL;
                }
 
@@ -3191,7 +3191,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                if (!vg_write(correct_vg)) {
                        log_error("Automatic metadata correction failed");
                        _free_pv_list(&all_pvs);
-                       free_vg(correct_vg);
+                       release_vg(correct_vg);
                        cmd->handles_missing_pvs = saved_handles_missing_pvs;
                        return NULL;
                }
@@ -3200,7 +3200,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                if (!vg_commit(correct_vg)) {
                        log_error("Automatic metadata correction commit "
                                  "failed");
-                       free_vg(correct_vg);
+                       release_vg(correct_vg);
                        return NULL;
                }
 
@@ -3211,14 +3211,14 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                        }
                        if (!id_write_format(&pvl->pv->id, uuid, sizeof(uuid))) {
                                _free_pv_list(&all_pvs);
-                               free_vg(correct_vg);
+                               release_vg(correct_vg);
                                return_NULL;
                        }
                        log_error("Removing PV %s (%s) that no longer belongs to VG %s",
                                  pv_dev_name(pvl->pv), uuid, correct_vg->name);
                        if (!pv_write_orphan(cmd, pvl->pv)) {
                                _free_pv_list(&all_pvs);
-                               free_vg(correct_vg);
+                               release_vg(correct_vg);
                                return_NULL;
                        }
 
@@ -3242,7 +3242,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
                          "volume group %s", correct_vg->name);
                log_error("Please restore the metadata by running "
                          "vgcfgrestore.");
-               free_vg(correct_vg);
+               release_vg(correct_vg);
                return NULL;
        }
 
@@ -3262,7 +3262,7 @@ struct volume_group *vg_read_internal(struct cmd_context *cmd, const char *vgnam
        if (!check_pv_segments(vg)) {
                log_error(INTERNAL_ERROR "PV segments corrupted in %s.",
                          vg->name);
-               free_vg(vg);
+               release_vg(vg);
                return NULL;
        }
 
@@ -3270,7 +3270,7 @@ struct volume_group *vg_read_internal(struct cmd_context *cmd, const char *vgnam
                if (!check_lv_segments(lvl->lv, 0)) {
                        log_error(INTERNAL_ERROR "LV segments corrupted in %s.",
                                  lvl->lv->name);
-                       free_vg(vg);
+                       release_vg(vg);
                        return NULL;
                }
        }
@@ -3282,7 +3282,7 @@ struct volume_group *vg_read_internal(struct cmd_context *cmd, const char *vgnam
                if (!check_lv_segments(lvl->lv, 1)) {
                        log_error(INTERNAL_ERROR "LV segments corrupted in %s.",
                                  lvl->lv->name);
-                       free_vg(vg);
+                       release_vg(vg);
                        return NULL;
                }
        }
@@ -3299,22 +3299,6 @@ void free_pv_fid(struct physical_volume *pv)
                pv->fid->fmt->ops->destroy_instance(pv->fid);
 }
 
-void free_vg(struct volume_group *vg)
-{
-       if (!vg)
-               return;
-
-       vg_set_fid(vg, NULL);
-
-       if (vg->cmd && vg->vgmem == vg->cmd->mem) {
-               log_error(INTERNAL_ERROR "global memory pool used for VG %s",
-                         vg->name);
-               return;
-       }
-
-       dm_pool_destroy(vg->vgmem);
-}
-
 /* This is only called by lv_from_lvid, which is only called from
  * activate.c so we know the appropriate VG lock is already held and
  * the vg_read_internal is therefore safe.
@@ -3341,7 +3325,7 @@ static struct volume_group *_vg_read_by_vgid(struct cmd_context *cmd,
                                          "inconsistent", vg->name);
                        return vg;
                }
-               free_vg(vg);
+               release_vg(vg);
        }
 
        /* Mustn't scan if memory locked: ensure cache gets pre-populated! */
@@ -3370,12 +3354,12 @@ static struct volume_group *_vg_read_by_vgid(struct cmd_context *cmd,
                        if (!consistent) {
                                log_error("Volume group %s metadata is "
                                          "inconsistent", vgname);
-                               free_vg(vg);
+                               release_vg(vg);
                                return NULL;
                        }
                        return vg;
                }
-               free_vg(vg);
+               release_vg(vg);
        }
 
        return NULL;
@@ -3409,7 +3393,7 @@ struct logical_volume *lv_from_lvid(struct cmd_context *cmd, const char *lvid_s,
 
        return lvl->lv;
 out:
-       free_vg(vg);
+       release_vg(vg);
        return NULL;
 }
 
@@ -3616,12 +3600,12 @@ static int _get_pvs(struct cmd_context *cmd, int warnings, struct dm_list **pvsl
                        dm_list_iterate_items(pvl, &vg->pvs) {
                                if (!(pvl_copy = _copy_pvl(cmd->mem, pvl))) {
                                        log_error("PV list allocation failed");
-                                       free_vg(vg);
+                                       release_vg(vg);
                                        return 0;
                                }
                                dm_list_add(results, &pvl_copy->list);
                        }
-               free_vg(vg);
+               release_vg(vg);
        }
        init_pvmove(old_pvmove);
 
@@ -3838,7 +3822,7 @@ static struct volume_group *_recover_vg(struct cmd_context *cmd,
                return_NULL;
 
        if (!consistent) {
-               free_vg(vg);
+               release_vg(vg);
                return_NULL;
        }
 
@@ -3910,7 +3894,7 @@ static struct volume_group *_vg_lock_and_read(struct cmd_context *cmd, const cha
 
        /* consistent == 0 when VG is not found, but failed == FAILED_NOTFOUND */
        if (!consistent && !failure) {
-               free_vg(vg);
+               release_vg(vg);
                if (!(vg = _recover_vg(cmd, vg_name, vgid))) {
                        log_error("Recovery of volume group \"%s\" failed.",
                                  vg_name);

diff --git a/lib/metadata/replicator_manip.c b/lib/metadata/replicator_manip.c
index 79abca04f2911b5e779125d65dc3cd6e47154fe5..9f9dc97ddb0673a9ab426ac3ac6ab1c063902e8c 100644 (file)
--- a/lib/metadata/replicator_manip.c
+++ b/lib/metadata/replicator_manip.c
@@ -597,9 +597,9 @@ void free_cmd_vgs(struct dm_list *cmd_vgs)
        /* Backward iterate cmd_vg list */
        dm_list_iterate_back_items(cvl, cmd_vgs) {
                if (vg_read_error(cvl->vg))
-                       free_vg(cvl->vg);
+                       release_vg(cvl->vg);
                else
-                       unlock_and_free_vg(cvl->vg->cmd, cvl->vg, cvl->vg_name);
+                       unlock_and_release_vg(cvl->vg->cmd, cvl->vg, cvl->vg_name);
                cvl->vg = NULL;
        }
 }
@@ -687,7 +687,7 @@ void lv_release_replicator_vgs(struct logical_volume *lv)
 
        dm_list_iterate_back_items(rsite, &first_seg(lv)->replicator->rsites)
                if (rsite->vg_name && rsite->vg) {
-                       free_vg(rsite->vg);
+                       release_vg(rsite->vg);
                        rsite->vg = NULL;
                }
 }

diff --git a/lib/metadata/vg.c b/lib/metadata/vg.c
index af286fc4c65caff63de9116eb0fd9530ede6333a..ef88a4d3a4c1c14234b002f8aeb9a6ebee5ece1e 100644 (file)
--- a/lib/metadata/vg.c
+++ b/lib/metadata/vg.c
@@ -17,6 +17,7 @@
 #include "metadata.h"
 #include "display.h"
 #include "activate.h"
+#include "toolcontext.h"
 
 struct volume_group *alloc_vg(const char *pool_name, struct cmd_context *cmd,
                              const char *vg_name)
@@ -51,6 +52,27 @@ struct volume_group *alloc_vg(const char *pool_name, struct cmd_context *cmd,
        return vg;
 }
 
+static void _free_vg(struct volume_group *vg)
+{
+       vg_set_fid(vg, NULL);
+
+       if (vg->cmd && vg->vgmem == vg->cmd->mem) {
+               log_error(INTERNAL_ERROR "global memory pool used for VG %s",
+                         vg->name);
+               return;
+       }
+
+       dm_pool_destroy(vg->vgmem);
+}
+
+void release_vg(struct volume_group *vg)
+{
+       if (!vg)
+               return;
+
+       _free_vg(vg);
+}
+
 char *vg_fmt_dup(const struct volume_group *vg)
 {
        if (!vg->fid || !vg->fid->fmt)

diff --git a/lib/metadata/vg.h b/lib/metadata/vg.h
index bebe6cffab3ea42972d632a2d2e0bc6a7d23393f..a3dc2183e2ee81918c570ca5faf40b205bd10718 100644 (file)
--- a/lib/metadata/vg.h
+++ b/lib/metadata/vg.h
@@ -111,6 +111,12 @@ struct volume_group {
 struct volume_group *alloc_vg(const char *pool_name, struct cmd_context *cmd,
                              const char *vg_name);
 
+/*
+ * release_vg() must be called on every struct volume_group allocated
+ * by vg_create() or vg_read_internal() to free it when no longer required.
+ */
+void release_vg(struct volume_group *vg);
+
 char *vg_fmt_dup(const struct volume_group *vg);
 char *vg_name_dup(const struct volume_group *vg);
 char *vg_system_id_dup(const struct volume_group *vg);

diff --git a/liblvm/lvm_vg.c b/liblvm/lvm_vg.c
index 08b421286027c748dc7fec38e500eb00bff8a29e..405a91a1044e7316aa2fccdc121cf0ae75b93c44 100644 (file)
--- a/liblvm/lvm_vg.c
+++ b/liblvm/lvm_vg.c
@@ -56,7 +56,7 @@ vg_t lvm_vg_create(lvm_t libh, const char *vg_name)
        vg = vg_create((struct cmd_context *)libh, vg_name);
        /* FIXME: error handling is still TBD */
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                return NULL;
        }
        vg->open_mode = 'w';
@@ -160,9 +160,9 @@ int lvm_vg_write(vg_t vg)
 int lvm_vg_close(vg_t vg)
 {
        if (vg_read_error(vg) == FAILED_LOCKING)
-               free_vg(vg);
+               release_vg(vg);
        else
-               unlock_and_free_vg(vg->cmd, vg, vg->name);
+               unlock_and_release_vg(vg->cmd, vg, vg->name);
        return 0;
 }
 
@@ -197,7 +197,7 @@ vg_t lvm_vg_open(lvm_t libh, const char *vgname, const char *mode,
        vg = vg_read((struct cmd_context *)libh, vgname, NULL, internal_flags);
        if (vg_read_error(vg)) {
                /* FIXME: use log_errno either here in inside vg_read */
-               free_vg(vg);
+               release_vg(vg);
                return NULL;
        }
        /* FIXME: combine this with locking ? */

diff --git a/tools/lvconvert.c b/tools/lvconvert.c
index 73b9788f4b9ce4ace762e4f3f53765a9b9c6c69f..20ec617bc2a3e3aa4034450f2831cdca398249f6 100644 (file)
--- a/tools/lvconvert.c
+++ b/tools/lvconvert.c
@@ -1615,7 +1615,7 @@ static struct logical_volume *get_vg_lock_and_logical_volume(struct cmd_context
 {
        /*
         * Returns NULL if the requested LV doesn't exist;
-        * otherwise the caller must free_vg(lv->vg)
+        * otherwise the caller must release_vg(lv->vg)
         * - it is also up to the caller to unlock_vg() as needed
         */
        struct volume_group *vg;
@@ -1623,13 +1623,13 @@ static struct logical_volume *get_vg_lock_and_logical_volume(struct cmd_context
 
        vg = _get_lvconvert_vg(cmd, vg_name, NULL);
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                return_NULL;
        }
 
        if (!(lv = _get_lvconvert_lv(cmd, vg, lv_name, NULL, 0))) {
                log_error("Can't find LV %s in VG %s", lv_name, vg_name);
-               unlock_and_free_vg(cmd, vg, vg_name);
+               unlock_and_release_vg(cmd, vg, vg_name);
                return NULL;
        }
 
@@ -1682,7 +1682,7 @@ bad:
                ret = poll_logical_volume(cmd, lp->lv_to_poll,
                                          lp->wait_completion);
 
-       free_vg(lv->vg);
+       release_vg(lv->vg);
 out:
        init_ignore_suspended_devices(saved_ignore_suspended_devices);
        return ret;
@@ -1732,7 +1732,7 @@ static int lvconvert_merge_single(struct cmd_context *cmd, struct logical_volume
                }
        }
 
-       free_vg(refreshed_lv->vg);
+       release_vg(refreshed_lv->vg);
 
        return ret;
 }

diff --git a/tools/lvcreate.c b/tools/lvcreate.c
index f68c0f6af0d24caa9a173e5ec63764dbda137226..de7805e391e57b70c96f4604bdc7e347593c352a 100644 (file)
--- a/tools/lvcreate.c
+++ b/tools/lvcreate.c
@@ -600,7 +600,7 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv)
        log_verbose("Finding volume group \"%s\"", lp.vg_name);
        vg = vg_read_for_update(cmd, lp.vg_name, NULL, 0);
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                stack;
                return ECMD_FAILED;
        }
@@ -615,6 +615,6 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv)
                r = ECMD_FAILED;
        }
 out:
-       unlock_and_free_vg(cmd, vg, lp.vg_name);
+       unlock_and_release_vg(cmd, vg, lp.vg_name);
        return r;
 }

diff --git a/tools/lvrename.c b/tools/lvrename.c
index db47a8bc64f994c093bca0cf797c1eeda0a0896d..782f32b4f4b1fdd1b0036f71dc509b94e610d781 100644 (file)
--- a/tools/lvrename.c
+++ b/tools/lvrename.c
@@ -104,7 +104,7 @@ int lvrename(struct cmd_context *cmd, int argc, char **argv)
        log_verbose("Checking for existing volume group \"%s\"", vg_name);
        vg = vg_read_for_update(cmd, vg_name, NULL, 0);
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                stack;
                return ECMD_FAILED;
        }
@@ -123,6 +123,6 @@ int lvrename(struct cmd_context *cmd, int argc, char **argv)
 
        r = ECMD_PROCESSED;
 error:
-       unlock_and_free_vg(cmd, vg, vg_name);
+       unlock_and_release_vg(cmd, vg, vg_name);
        return r;
 }

diff --git a/tools/lvresize.c b/tools/lvresize.c
index 8c23a5e35fa184641affcb3ad9d6550885044dbb..6fbc11592f026180edb11d614b51d8425e92af70 100644 (file)
--- a/tools/lvresize.c
+++ b/tools/lvresize.c
@@ -773,7 +773,7 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv)
        log_verbose("Finding volume group %s", lp.vg_name);
        vg = vg_read_for_update(cmd, lp.vg_name, NULL, 0);
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                stack;
                return ECMD_FAILED;
        }
@@ -781,7 +781,7 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv)
        if (!(r = _lvresize(cmd, vg, &lp)))
                stack;
 
-       unlock_and_free_vg(cmd, vg, lp.vg_name);
+       unlock_and_release_vg(cmd, vg, lp.vg_name);
 
        return r;
 }

diff --git a/tools/polldaemon.c b/tools/polldaemon.c
index 0555b94ab6f6ccc315a8885cddae8cc90bac3045..90392400c929260c5a375ba972962a6563fd6d85 100644 (file)
--- a/tools/polldaemon.c
+++ b/tools/polldaemon.c
@@ -187,7 +187,7 @@ static int _wait_for_single_lv(struct cmd_context *cmd, const char *name, const
                /* Locks the (possibly renamed) VG again */
                vg = parms->poll_fns->get_copy_vg(cmd, name, uuid);
                if (vg_read_error(vg)) {
-                       free_vg(vg);
+                       release_vg(vg);
                        log_error("ABORTING: Can't reread VG for %s", name);
                        /* What more could we do here? */
                        return 0;
@@ -198,23 +198,23 @@ static int _wait_for_single_lv(struct cmd_context *cmd, const char *name, const
                if (!lv && parms->lv_type == PVMOVE) {
                        log_print("%s: no pvmove in progress - already finished or aborted.",
                                  name);
-                       unlock_and_free_vg(cmd, vg, vg->name);
+                       unlock_and_release_vg(cmd, vg, vg->name);
                        return 1;
                }
 
                if (!lv) {
                        log_error("ABORTING: Can't find LV in %s for %s",
                                  vg->name, name);
-                       unlock_and_free_vg(cmd, vg, vg->name);
+                       unlock_and_release_vg(cmd, vg, vg->name);
                        return 0;
                }
 
                if (!_check_lv_status(cmd, vg, lv, name, parms, &finished)) {
-                       unlock_and_free_vg(cmd, vg, vg->name);
+                       unlock_and_release_vg(cmd, vg, vg->name);
                        return_0;
                }
 
-               unlock_and_free_vg(cmd, vg, vg->name);
+               unlock_and_release_vg(cmd, vg, vg->name);
 
                /*
                 * FIXME Sleeping after testing, while preferred, also works around

diff --git a/tools/pvchange.c b/tools/pvchange.c
index 58dd64947a91b3087c450879974d1483d4cd09cc..990d0f21f57ff59777c1d992eed51efa5aeba05c 100644 (file)
--- a/tools/pvchange.c
+++ b/tools/pvchange.c
@@ -218,7 +218,7 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
                        }
                        vg = vg_read_for_update(cmd, vg_name, NULL, 0);
                        if (vg_read_error(vg)) {
-                               free_vg(vg);
+                               release_vg(vg);
                                stack;
                                continue;
                        }
@@ -232,7 +232,7 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
                        total++;
                        done += _pvchange_single(cmd, vg,
                                                 pvl->pv, NULL);
-                       unlock_and_free_vg(cmd, vg, vg_name);
+                       unlock_and_release_vg(cmd, vg, vg_name);
                }
        } else {
                log_verbose("Scanning for physical volume names");
@@ -253,7 +253,7 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
                        dm_list_iterate_items(sll, vgnames) {
                                vg = vg_read_for_update(cmd, sll->str, NULL, 0);
                                if (vg_read_error(vg)) {
-                                       free_vg(vg);
+                                       release_vg(vg);
                                        stack;
                                        continue;
                                }
@@ -263,7 +263,7 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
                                                                 pvl->pv,
                                                                 NULL);
                                }
-                               unlock_and_free_vg(cmd, vg, sll->str);
+                               unlock_and_release_vg(cmd, vg, sll->str);
                        }
                }
                unlock_vg(cmd, VG_GLOBAL);

diff --git a/tools/pvcreate.c b/tools/pvcreate.c
index 0108d775ef42d847b0c4f64230e37e7b7b57d226..7b50f70c6482d9456c33c04b2833a55fcd6a630f 100644 (file)
--- a/tools/pvcreate.c
+++ b/tools/pvcreate.c
@@ -74,7 +74,7 @@ static int pvcreate_restore_params_validate(struct cmd_context *cmd,
                pp->pe_start = pv_pe_start(existing_pvl->pv);
                pp->extent_size = pv_pe_size(existing_pvl->pv);
                pp->extent_count = pv_pe_count(existing_pvl->pv);
-               free_vg(vg);
+               release_vg(vg);
        }
 
        if (arg_sign_value(cmd, physicalvolumesize_ARG, 0) == SIGN_MINUS) {

diff --git a/tools/pvdisplay.c b/tools/pvdisplay.c
index 1ae0339ab60fafe5d65778c99e0d92c9b7241cf3..2136721284cfd0e2ffce1bdd60a2f7c201b44dda 100644 (file)
--- a/tools/pvdisplay.c
+++ b/tools/pvdisplay.c
@@ -32,7 +32,7 @@ static int _pvdisplay_single(struct cmd_context *cmd,
                vg = vg_read(cmd, vg_name, (char *)&pv->vgid, 0);
                if (vg_read_error(vg)) {
                        log_error("Skipping volume group %s", vg_name);
-                       free_vg(vg);
+                       release_vg(vg);
                        /* FIXME If CLUSTERED should return ECMD_PROCESSED here */
                        return ECMD_FAILED;
                }
@@ -85,7 +85,7 @@ out:
        if (vg_name)
                unlock_vg(cmd, vg_name);
        if (!old_vg)
-               free_vg(vg);
+               release_vg(vg);
 
        return ret;
 }

diff --git a/tools/pvmove.c b/tools/pvmove.c
index 79b17df8e277f6f9ab2bc95133fe8308e9f00457..7a2fd14a373e28dd622a4d8a953e430cefdd8b96 100644 (file)
--- a/tools/pvmove.c
+++ b/tools/pvmove.c
@@ -460,7 +460,7 @@ static int _set_up_pvmove(struct cmd_context *cmd, const char *pv_name,
 
        vg = _get_vg(cmd, pv_vg_name(pv));
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                stack;
                return ECMD_FAILED;
        }
@@ -526,7 +526,7 @@ static int _set_up_pvmove(struct cmd_context *cmd, const char *pv_name,
        r = ECMD_PROCESSED;
 out:
        free_pv_fid(pv);
-       unlock_and_free_vg(cmd, vg, pv_vg_name(pv));
+       unlock_and_release_vg(cmd, vg, pv_vg_name(pv));
        return r;
 }
 

diff --git a/tools/pvresize.c b/tools/pvresize.c
index 1c80c942f9bc7ecc1bfc1756cae6b3065363ba30..549661a566c63a015620e1aa05a59361e6aae84f 100644 (file)
--- a/tools/pvresize.c
+++ b/tools/pvresize.c
@@ -52,7 +52,7 @@ static int _pv_resize_single(struct cmd_context *cmd,
                vg = vg_read_for_update(cmd, vg_name, NULL, 0);
 
                if (vg_read_error(vg)) {
-                       free_vg(vg);
+                       release_vg(vg);
                        log_error("Unable to read volume group \"%s\".",
                                  vg_name);
                        return 0;
@@ -129,7 +129,7 @@ out:
        if (is_orphan_vg(vg_name))
                free_pv_fid(pv);
        if (!old_vg)
-               free_vg(vg);
+               release_vg(vg);
        return r;
 }
 

diff --git a/tools/reporter.c b/tools/reporter.c
index c8a6bb41b0571df0aa63f451d5de70bff7ebff30..a52725383e641e2253a167b61490901e0b7417e9 100644 (file)
--- a/tools/reporter.c
+++ b/tools/reporter.c
@@ -142,7 +142,7 @@ static int _pvs_single(struct cmd_context *cmd, struct volume_group *vg,
                vg = vg_read(cmd, vg_name, (char *)&pv->vgid, 0);
                if (vg_read_error(vg)) {
                        log_error("Skipping volume group %s", vg_name);
-                       free_vg(vg);
+                       release_vg(vg);
                        return ECMD_FAILED;
                }
 
@@ -182,7 +182,7 @@ out:
                unlock_vg(cmd, vg_name);
 
        if (!old_vg)
-               free_vg(vg);
+               release_vg(vg);
 
        return ret;
 }

diff --git a/tools/toollib.c b/tools/toollib.c
index 2aa5506ebaae37b4025c2958da5fdd5d33d2dcd2..b606df842689701bae21d70d554cdfce60f4d9f1 100644 (file)
--- a/tools/toollib.c
+++ b/tools/toollib.c
@@ -403,7 +403,7 @@ int process_each_segment_in_pv(struct cmd_context *cmd,
 
                vg = vg_read(cmd, vg_name, NULL, 0);
                if (vg_read_error(vg)) {
-                       free_vg(vg);
+                       release_vg(vg);
                        log_error("Skipping volume group %s", vg_name);
                        return ECMD_FAILED;
                }
@@ -415,7 +415,7 @@ int process_each_segment_in_pv(struct cmd_context *cmd,
                if (!(pvl = find_pv_in_vg(vg, pv_dev_name(pv)))) {
                         log_error("Unable to find %s in volume group %s",
                                   pv_dev_name(pv), vg_name);
-                        unlock_and_free_vg(cmd, vg, vg_name);
+                        unlock_and_release_vg(cmd, vg, vg_name);
                         return ECMD_FAILED;
                }
 
@@ -438,7 +438,7 @@ int process_each_segment_in_pv(struct cmd_context *cmd,
        if (vg_name)
                unlock_vg(cmd, vg_name);
        if (!old_vg)
-               free_vg(vg);
+               release_vg(vg);
 
        return ret_max;
 }
@@ -795,7 +795,7 @@ int process_each_pv(struct cmd_context *cmd, int argc, char **argv,
                                vg = vg_read(cmd, sll->str, NULL, flags);
                                if (vg_read_error(vg)) {
                                        ret_max = ECMD_FAILED;
-                                       free_vg(vg);
+                                       release_vg(vg);
                                        stack;
                                        continue;
                                }
@@ -804,7 +804,7 @@ int process_each_pv(struct cmd_context *cmd, int argc, char **argv,
                                                            handle,
                                                            process_single_pv);
 
-                               unlock_and_free_vg(cmd, vg, sll->str);
+                               unlock_and_release_vg(cmd, vg, sll->str);
 
                                if (ret > ret_max)
                                        ret_max = ret;

diff --git a/tools/vgcreate.c b/tools/vgcreate.c
index 62b5ac7bdd9432b60957c3f239e03b0de10ec7af..053b089acc85e711da3de750c643d51439a03c2b 100644 (file)
--- a/tools/vgcreate.c
+++ b/tools/vgcreate.c
@@ -56,7 +56,7 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
                        log_error("A volume group called %s already exists.", vp_new.vg_name);
                else
                        log_error("Can't get lock for %s.", vp_new.vg_name);
-               free_vg(vg);
+               release_vg(vg);
                return ECMD_FAILED;
        }
 
@@ -120,13 +120,13 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
        log_print("%s%colume group \"%s\" successfully created",
                  clustered_message, *clustered_message ? 'v' : 'V', vg->name);
 
-       free_vg(vg);
+       release_vg(vg);
        return ECMD_PROCESSED;
 
 bad:
        unlock_vg(cmd, VG_ORPHANS);
 bad_orphan:
-       free_vg(vg);
+       release_vg(vg);
        unlock_vg(cmd, vp_new.vg_name);
        return ECMD_FAILED;
 }

diff --git a/tools/vgextend.c b/tools/vgextend.c
index 5d2b54d7ecb6046749be336317269fe2583c7e7e..d1adf210494295d816d3d531983feccb756ca465 100644 (file)
--- a/tools/vgextend.c
+++ b/tools/vgextend.c
@@ -72,7 +72,7 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv)
        log_verbose("Checking for volume group \"%s\"", vg_name);
        vg = vg_read_for_update(cmd, vg_name, NULL, 0);
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                stack;
                return ECMD_FAILED;
        }
@@ -92,7 +92,7 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv)
        } else { /* no --restore, normal vgextend */
                if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE)) {
                        log_error("Can't get lock for orphan PVs");
-                       unlock_and_free_vg(cmd, vg, vg_name);
+                       unlock_and_release_vg(cmd, vg, vg_name);
                        return ECMD_FAILED;
                }
 
@@ -135,6 +135,6 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv)
 bad:
        if (!arg_count(cmd, restoremissing_ARG))
                unlock_vg(cmd, VG_ORPHANS);
-       unlock_and_free_vg(cmd, vg, vg_name);
+       unlock_and_release_vg(cmd, vg, vg_name);
        return r;
 }

diff --git a/tools/vgmerge.c b/tools/vgmerge.c
index 6b403bf422d9b6c76b0ac0c39d25225ca7f2370f..48aa127ad9e4ae244a9fb537c356384d1d6e7331 100644 (file)
--- a/tools/vgmerge.c
+++ b/tools/vgmerge.c
@@ -22,7 +22,7 @@ static struct volume_group *_vgmerge_vg_read(struct cmd_context *cmd,
        log_verbose("Checking for volume group \"%s\"", vg_name);
        vg = vg_read_for_update(cmd, vg_name, NULL, 0);
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                return NULL;
        }
        return vg;
@@ -54,7 +54,7 @@ static int _vgmerge_single(struct cmd_context *cmd, const char *vg_name_to,
                vg_to = _vgmerge_vg_read(cmd, vg_name_to);
                if (!vg_to) {
                        stack;
-                       unlock_and_free_vg(cmd, vg_from, vg_name_from);
+                       unlock_and_release_vg(cmd, vg_from, vg_name_from);
                        return ECMD_FAILED;
                }
        } else {
@@ -67,7 +67,7 @@ static int _vgmerge_single(struct cmd_context *cmd, const char *vg_name_to,
                vg_from = _vgmerge_vg_read(cmd, vg_name_from);
                if (!vg_from) {
                        stack;
-                       unlock_and_free_vg(cmd, vg_to, vg_name_to);
+                       unlock_and_release_vg(cmd, vg_to, vg_name_to);
                        return ECMD_FAILED;
                }
        }
@@ -153,10 +153,10 @@ static int _vgmerge_single(struct cmd_context *cmd, const char *vg_name_to,
 bad:
        /*
         * Note: as vg_to is referencing moved elements from vg_from
-        * the order of free_vg calls is mandatory.
+        * the order of release_vg calls is mandatory.
         */
-       unlock_and_free_vg(cmd, vg_to, vg_name_to);
-       unlock_and_free_vg(cmd, vg_from, vg_name_from);
+       unlock_and_release_vg(cmd, vg_to, vg_name_to);
+       unlock_and_release_vg(cmd, vg_from, vg_name_from);
 
        return r;
 }

diff --git a/tools/vgreduce.c b/tools/vgreduce.c
index bcf3fb030fbfb69a6d2d68fe5019709a895c5f80..4d5220bc1ac130b198f812f99ae33b106850699c 100644 (file)
--- a/tools/vgreduce.c
+++ b/tools/vgreduce.c
@@ -194,7 +194,7 @@ static int _vgreduce_single(struct cmd_context *cmd, struct volume_group *vg,
 bad:
        if (pvl)
                free_pv_fid(pvl->pv);
-       unlock_and_free_vg(cmd, orphan_vg, VG_ORPHANS);
+       unlock_and_release_vg(cmd, orphan_vg, VG_ORPHANS);
        return r;
 }
 
@@ -268,7 +268,7 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
                        goto out;
                }
 
-               free_vg(vg);
+               release_vg(vg);
                log_verbose("Trying to open VG %s for recovery...", vg_name);
 
                vg = vg_read_for_update(cmd, vg_name, NULL,
@@ -314,7 +314,7 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
        }
 out:
        init_ignore_suspended_devices(saved_ignore_suspended_devices);
-       unlock_and_free_vg(cmd, vg, vg_name);
+       unlock_and_release_vg(cmd, vg, vg_name);
 
        return ret;
 

diff --git a/tools/vgrename.c b/tools/vgrename.c
index 2f83fc63dcd420932df14acd63096a6895925586..1f1f943474d1c943e909fe323d52beb032ebef4a 100644 (file)
--- a/tools/vgrename.c
+++ b/tools/vgrename.c
@@ -25,7 +25,7 @@ static struct volume_group *_get_old_vg_for_rename(struct cmd_context *cmd,
           nevertheless. */
        vg = vg_read_for_update(cmd, vg_name_old, vgid, READ_ALLOW_EXPORTED);
        if (vg_read_error(vg)) {
-               free_vg(vg);
+               release_vg(vg);
                return_NULL;
        }
 
@@ -117,7 +117,7 @@ static int vg_rename_path(struct cmd_context *cmd, const char *old_vg_path,
                        return_0;
 
                if (!_lock_new_vg_for_rename(cmd, vg_name_new)) {
-                       unlock_and_free_vg(cmd, vg, vg_name_old);
+                       unlock_and_release_vg(cmd, vg, vg_name_old);
                        return_0;
                }
        } else {
@@ -170,7 +170,7 @@ static int vg_rename_path(struct cmd_context *cmd, const char *old_vg_path,
                stack;
 
        unlock_vg(cmd, vg_name_new);
-       unlock_and_free_vg(cmd, vg, vg_name_old);
+       unlock_and_release_vg(cmd, vg, vg_name_old);
 
        log_print("Volume group \"%s\" successfully renamed to \"%s\"",
                  vg_name_old, vg_name_new);
@@ -184,9 +184,9 @@ static int vg_rename_path(struct cmd_context *cmd, const char *old_vg_path,
       error:
        if (lock_vg_old_first) {
                unlock_vg(cmd, vg_name_new);
-               unlock_and_free_vg(cmd, vg, vg_name_old);
+               unlock_and_release_vg(cmd, vg, vg_name_old);
        } else {
-               unlock_and_free_vg(cmd, vg, vg_name_old);
+               unlock_and_release_vg(cmd, vg, vg_name_old);
                unlock_vg(cmd, vg_name_new);
        }
        return 0;

diff --git a/tools/vgsplit.c b/tools/vgsplit.c
index f8660e1d028ec6bc0eaf82172977f6cd42597994..0538459e96015b2d0648a91d89dec23113196d39 100644 (file)
--- a/tools/vgsplit.c
+++ b/tools/vgsplit.c
@@ -224,16 +224,16 @@ static struct volume_group *_vgsplit_to(struct cmd_context *cmd,
        vg_to = vg_create(cmd, vg_name_to);
        if (vg_read_error(vg_to) == FAILED_LOCKING) {
                log_error("Can't get lock for %s", vg_name_to);
-               free_vg(vg_to);
+               release_vg(vg_to);
                return NULL;
        }
        if (vg_read_error(vg_to) == FAILED_EXIST) {
                *existing_vg = 1;
-               free_vg(vg_to);
+               release_vg(vg_to);
                vg_to = vg_read_for_update(cmd, vg_name_to, NULL, 0);
 
                if (vg_read_error(vg_to)) {
-                       free_vg(vg_to);
+                       release_vg(vg_to);
                        stack;
                        return NULL;
                }
@@ -259,7 +259,7 @@ static struct volume_group *_vgsplit_from(struct cmd_context *cmd,
 
        vg_from = vg_read_for_update(cmd, vg_name_from, NULL, 0);
        if (vg_read_error(vg_from)) {
-               free_vg(vg_from);
+               release_vg(vg_from);
                return NULL;
        }
        return vg_from;
@@ -334,7 +334,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv)
 
                vg_to = _vgsplit_to(cmd, vg_name_to, &existing_vg);
                if (!vg_to) {
-                       unlock_and_free_vg(cmd, vg_from, vg_name_from);
+                       unlock_and_release_vg(cmd, vg_from, vg_name_from);
                        stack;
                        return ECMD_FAILED;
                }
@@ -346,7 +346,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv)
                }
                vg_from = _vgsplit_from(cmd, vg_name_from);
                if (!vg_from) {
-                       unlock_and_free_vg(cmd, vg_to, vg_name_to);
+                       unlock_and_release_vg(cmd, vg_to, vg_name_to);
                        stack;
                        return ECMD_FAILED;
                }
@@ -463,7 +463,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv)
         * Finally, remove the EXPORTED flag from the new VG and write it out.
         */
        if (!test_mode()) {
-               free_vg(vg_to);
+               release_vg(vg_to);
                vg_to = vg_read_for_update(cmd, vg_name_to, NULL,
                                           READ_ALLOW_EXPORTED);
                if (vg_read_error(vg_to)) {
@@ -491,8 +491,8 @@ bad:
         * vg_to references elements moved from vg_from
         * so vg_to has to be freed first.
         */
-       unlock_and_free_vg(cmd, vg_to, vg_name_to);
-       unlock_and_free_vg(cmd, vg_from, vg_name_from);
+       unlock_and_release_vg(cmd, vg_to, vg_name_to);
+       unlock_and_release_vg(cmd, vg_from, vg_name_from);
 
        return r;
 }