Accept orphan VG names as parameters to lock_vol() and related functions.

diff --git a/WHATS_NEW b/WHATS_NEW
index 25324b94b24fe7150d52913d48fdcd7cd5f4aa38..ae23b31a114a554e36ad400c0f4f59a48f02e8c7 100644 (file)
--- a/WHATS_NEW
+++ b/WHATS_NEW
@@ -1,5 +1,6 @@
 Version 2.02.66 - 
 ===============================
+  Accept orphan VG names as parameters to lock_vol() and related functions.
   Use is_orphan_vg in place of hard-coded prefix tests.
 
 Version 2.02.65 - 17th May 2010

diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c
index 22e4517b271ed97593a56fd3c2a906e2d1ea9f1d..34c54ad6ee67d20cf88b7d6ed6483946b1a9e8f8 100644 (file)
--- a/lib/cache/lvmcache.c
+++ b/lib/cache/lvmcache.c
@@ -290,7 +290,7 @@ int vgname_is_locked(const char *vgname)
        if (!_lock_hash)
                return 0;
 
-       return dm_hash_lookup(_lock_hash, vgname) ? 1 : 0;
+       return dm_hash_lookup(_lock_hash, is_orphan_vg(vgname) ? VG_ORPHANS : vgname) ? 1 : 0;
 }
 
 void lvmcache_unlock_vgname(const char *vgname)

diff --git a/lib/locking/locking.c b/lib/locking/locking.c
index 3abf8f288e1c9e7c4e4fdfe4e049c9f22c0d5abc..032d97dab6ad4dab94bf780d49d0232bfbdc691f 100644 (file)
--- a/lib/locking/locking.c
+++ b/lib/locking/locking.c
@@ -417,16 +417,16 @@ int lock_vol(struct cmd_context *cmd, const char *vol, uint32_t flags)
 
        switch (flags & LCK_SCOPE_MASK) {
        case LCK_VG:
-               /*
-                * VG locks alphabetical, ORPHAN lock last
-                */
                if (!_blocking_supported)
                        flags |= LCK_NONBLOCK;
 
-               if (!is_orphan_vg(vol) && 
-                   ((flags & LCK_TYPE_MASK) != LCK_UNLOCK) &&
-                   (!(flags & LCK_CACHE)) &&
-                   !lvmcache_verify_lock_order(vol))
+               /* Global VG_ORPHANS lock covers all orphan formats. */
+               if (is_orphan_vg(vol))
+                       vol = VG_ORPHANS;
+               /* VG locks alphabetical, ORPHAN lock last */
+               else if (((flags & LCK_TYPE_MASK) != LCK_UNLOCK) &&
+                        !(flags & LCK_CACHE) &&
+                        !lvmcache_verify_lock_order(vol))
                        return 0;
 
                /* Lock VG to change on-disk metadata. */

diff --git a/lib/metadata/metadata.c b/lib/metadata/metadata.c
index 12cb5e41f24156e85274fb3bff40e03f4597d484..0bd7455fc7fe752378dae21d72c33cff69028f50 100644 (file)
--- a/lib/metadata/metadata.c
+++ b/lib/metadata/metadata.c
@@ -3459,7 +3459,7 @@ int vg_check_status(const struct volume_group *vg, uint64_t status)
        return !_vg_bad_status_bits(vg, status);
 }
 
-static struct volume_group *_recover_vg(struct cmd_context *cmd, const char *lock_name,
+static struct volume_group *_recover_vg(struct cmd_context *cmd,
                         const char *vg_name, const char *vgid,
                         uint32_t lock_flags)
 {
@@ -3469,11 +3469,11 @@ static struct volume_group *_recover_vg(struct cmd_context *cmd, const char *loc
        lock_flags &= ~LCK_TYPE_MASK;
        lock_flags |= LCK_WRITE;
 
-       unlock_vg(cmd, lock_name);
+       unlock_vg(cmd, vg_name);
 
        dev_close_all();
 
-       if (!lock_vol(cmd, lock_name, lock_flags))
+       if (!lock_vol(cmd, vg_name, lock_flags))
                return_NULL;
 
        if (!(vg = vg_read_internal(cmd, vg_name, vgid, &consistent)))
@@ -3503,7 +3503,6 @@ static struct volume_group *_vg_lock_and_read(struct cmd_context *cmd, const cha
                               uint64_t status_flags, uint32_t misc_flags)
 {
        struct volume_group *vg = NULL;
-       const char *lock_name;
        int consistent = 1;
        int consistent_in;
        uint32_t failure = 0;
@@ -3518,11 +3517,10 @@ static struct volume_group *_vg_lock_and_read(struct cmd_context *cmd, const cha
                return NULL;
        }
 
-       lock_name = is_orphan_vg(vg_name) ? VG_ORPHANS : vg_name;
-       already_locked = vgname_is_locked(lock_name);
+       already_locked = vgname_is_locked(vg_name);
 
        if (!already_locked && !(misc_flags & READ_WITHOUT_LOCK) &&
-           !lock_vol(cmd, lock_name, lock_flags)) {
+           !lock_vol(cmd, vg_name, lock_flags)) {
                log_error("Can't get lock for %s", vg_name);
                return _vg_make_handle(cmd, vg, FAILED_LOCKING);
        }
@@ -3555,7 +3553,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) {
                vg_release(vg);
-               if (!(vg = _recover_vg(cmd, lock_name, vg_name, vgid, lock_flags))) {
+               if (!(vg = _recover_vg(cmd, vg_name, vgid, lock_flags))) {
                        log_error("Recovery of volume group \"%s\" failed.",
                                  vg_name);
                        failure |= FAILED_INCONSISTENT;
@@ -3592,7 +3590,7 @@ static struct volume_group *_vg_lock_and_read(struct cmd_context *cmd, const cha
 
 bad:
        if (!already_locked && !(misc_flags & READ_WITHOUT_LOCK))
-               unlock_vg(cmd, lock_name);
+               unlock_vg(cmd, vg_name);
 
        return _vg_make_handle(cmd, vg, failure);
 }

diff --git a/tools/pvresize.c b/tools/pvresize.c
index 292e3cc1cdb58c38c1d0b583ab54b79ddc4ecd39..ccd025a3db80cd99a4a205d637d12e0a397486e6 100644 (file)
--- a/tools/pvresize.c
+++ b/tools/pvresize.c
@@ -34,15 +34,14 @@ static int _pv_resize_single(struct cmd_context *cmd,
        int r = 0;
        struct dm_list mdas;
        const char *pv_name = pv_dev_name(pv);
-       const char *vg_name;
+       const char *vg_name = pv_vg_name(pv);
        struct lvmcache_info *info;
        int mda_count = 0;
        struct volume_group *old_vg = vg;
 
        dm_list_init(&mdas);
 
-       if (is_orphan_vg(pv_vg_name(pv))) {
-               vg_name = VG_ORPHANS;
+       if (is_orphan_vg(vg_name)) {
                if (!lock_vol(cmd, vg_name, LCK_VG_WRITE)) {
                        log_error("Can't get lock for orphans");
                        return 0;
@@ -56,8 +55,6 @@ static int _pv_resize_single(struct cmd_context *cmd,
 
                mda_count = dm_list_size(&mdas);
        } else {
-               vg_name = pv_vg_name(pv);
-
                vg = vg_read_for_update(cmd, vg_name, NULL, 0);
 
                if (vg_read_error(vg)) {
@@ -70,7 +67,7 @@ static int _pv_resize_single(struct cmd_context *cmd,
                if (!(pvl = find_pv_in_vg(vg, pv_name))) {
                        log_error("Unable to find \"%s\" in volume group \"%s\"",
                                  pv_name, vg->name);
-                       goto bad;
+                       goto out;
                }
 
                pv = pvl->pv;
@@ -78,31 +75,31 @@ static int _pv_resize_single(struct cmd_context *cmd,
                if (!(info = info_from_pvid(pv->dev->pvid, 0))) {
                        log_error("Can't get info for PV %s in volume group %s",
                                  pv_name, vg->name);
-                       goto bad;
+                       goto out;
                }
 
                mda_count = dm_list_size(&info->mdas);
 
                if (!archive(vg))
-                       goto bad;
+                       goto out;
        }
 
        /* FIXME Create function to test compatibility properly */
        if (mda_count > 1) {
                log_error("%s: too many metadata areas for pvresize", pv_name);
-               goto bad;
+               goto out;
        }
 
        if (!(pv->fmt->features & FMT_RESIZE_PV)) {
                log_error("Physical volume %s format does not support resizing.",
                          pv_name);
-               goto bad;
+               goto out;
        }
 
        /* Get new size */
        if (!dev_get_size(pv_dev(pv), &size)) {
                log_error("%s: Couldn't get size.", pv_name);
-               goto bad;
+               goto out;
        }
 
        if (new_size) {
@@ -117,13 +114,13 @@ static int _pv_resize_single(struct cmd_context *cmd,
        if (size < PV_MIN_SIZE) {
                log_error("%s: Size must exceed minimum of %ld sectors.",
                          pv_name, PV_MIN_SIZE);
-               goto bad;
+               goto out;
        }
 
        if (size < pv_pe_start(pv)) {
                log_error("%s: Size must exceed physical extent start of "
                          "%" PRIu64 " sectors.", pv_name, pv_pe_start(pv));
-               goto bad;
+               goto out;
        }
 
        pv->size = size;
@@ -137,34 +134,34 @@ static int _pv_resize_single(struct cmd_context *cmd,
                                  "least one physical extent of "
                                  "%" PRIu32 " sectors.", pv_name,
                                  pv_pe_size(pv));
-                       goto bad;
+                       goto out;
                }
 
                if (!pv_resize(pv, vg, new_pe_count))
-                       goto_bad;
+                       goto_out;
        }
 
        log_verbose("Resizing volume \"%s\" to %" PRIu64 " sectors.",
                    pv_name, pv_size(pv));
 
        log_verbose("Updating physical volume \"%s\"", pv_name);
-       if (!is_orphan_vg(pv_vg_name(pv))) {
+       if (!is_orphan_vg(vg_name)) {
                if (!vg_write(vg) || !vg_commit(vg)) {
                        log_error("Failed to store physical volume \"%s\" in "
                                  "volume group \"%s\"", pv_name, vg->name);
-                       goto bad;
+                       goto out;
                }
                backup(vg);
        } else if (!(pv_write(cmd, pv, NULL, INT64_C(-1)))) {
                log_error("Failed to store physical volume \"%s\"",
                          pv_name);
-               goto bad;;
+               goto out;
        }
 
        log_print("Physical volume \"%s\" changed", pv_name);
        r = 1;
 
-bad:
+out:
        unlock_vg(cmd, vg_name);
        if (!old_vg)
                vg_release(vg);