Decode cluster locking state in log message. (untested)

Change file locking state messages from debug to very verbose.

diff --git a/WHATS_NEW b/WHATS_NEW
index e3f1799294eb53d36f5bff065aece614ffdae5cf..278dd923f7af258807ef9ecbcd4de0b0ae0f9bed 100644 (file)
--- a/WHATS_NEW
+++ b/WHATS_NEW
@@ -1,5 +1,7 @@
 Version 2.02.29 -
 ==================================
+  Decode cluster locking state in log message.
+  Change file locking state messages from debug to very verbose.
   Fix --addtag to drop @ prefix from name.
   Stop clvmd going haywire if a pre_function fails.
   Convert some vg_reads into vg_lock_and_reads.

diff --git a/lib/locking/cluster_locking.c b/lib/locking/cluster_locking.c
index b0aa6c6a9472f922e4243f7cc621cc8f549de14d..6c3f96b6d3444ef8d53a1c3fbc6c7ed56cb19bc3 100644 (file)
--- a/lib/locking/cluster_locking.c
+++ b/lib/locking/cluster_locking.c
@@ -378,6 +378,8 @@ int lock_resource(struct cmd_context *cmd, const char *resource, uint32_t flags)
 {
        char lockname[PATH_MAX];
        int cluster_cmd = 0;
+       const char *lock_scope;
+       const char *lock_type = "";
 
        assert(strlen(resource) < sizeof(lockname));
        assert(resource);
@@ -393,6 +395,7 @@ int lock_resource(struct cmd_context *cmd, const char *resource, uint32_t flags)
                        dm_snprintf(lockname, sizeof(lockname), "V_%s",
                                     resource);
 
+               lock_scope = "VG";
                cluster_cmd = CLVMD_CMD_LOCK_VG;
                flags &= LCK_TYPE_MASK;
                break;
@@ -400,6 +403,7 @@ int lock_resource(struct cmd_context *cmd, const char *resource, uint32_t flags)
        case LCK_LV:
                cluster_cmd = CLVMD_CMD_LOCK_LV;
                strcpy(lockname, resource);
+               lock_scope = "LV";
                flags &= 0xffdf;        /* Mask off HOLD flag */
                break;
 
@@ -409,9 +413,40 @@ int lock_resource(struct cmd_context *cmd, const char *resource, uint32_t flags)
                return 0;
        }
 
-       /* Send a message to the cluster manager */
-       log_very_verbose("Locking %s at 0x%x", lockname, flags);
+       switch(flags & LCK_TYPE_MASK) {
+       case LCK_UNLOCK:
+               lock_type = "UN";
+               break;
+       case LCK_NULL:
+               lock_type = "NL";
+               break;
+       case LCK_READ:
+               lock_type = "CR";
+               break;
+       case LCK_PREAD:
+               lock_type = "PR";
+               break;
+       case LCK_WRITE:
+               lock_type = "PW";
+               break;
+       case LCK_EXCL:
+               lock_type = "EX";
+               break;
+       default:
+               log_error("Unrecognised lock type: %u",
+                         flags & LCK_TYPE_MASK);
+               return 0;
+       }
+
+       log_very_verbose("Locking %s %s %s %s%s%s%s (0x%x)", lock_scope, lockname,
+                        lock_type,
+                        flags & LCK_NONBLOCK ? "" : "B", 
+                        flags & LCK_HOLD ? "H" : "", 
+                        flags & LCK_LOCAL ? "L" : "", 
+                        flags & LCK_CLUSTER_VG ? "C" : "", 
+                        flags);
 
+       /* Send a message to the cluster manager */
        return _lock_for_cluster(cluster_cmd, flags, lockname);
 }
 

diff --git a/lib/locking/file_locking.c b/lib/locking/file_locking.c
index 4d83f6294ee501455dab803eb815032c41aa6871..65c9fbf93b8c50df7715c08028ce3c1de2502935 100644 (file)
--- a/lib/locking/file_locking.c
+++ b/lib/locking/file_locking.c
@@ -208,8 +208,6 @@ static int _file_lock_resource(struct cmd_context *cmd, const char *resource,
 {
        char lockfile[PATH_MAX];
 
-       assert(resource);
-
        switch (flags & LCK_SCOPE_MASK) {
        case LCK_VG:
                if (!*resource) /* FIXME Deprecated */
@@ -238,27 +236,30 @@ static int _file_lock_resource(struct cmd_context *cmd, const char *resource,
        case LCK_LV:
                switch (flags & LCK_TYPE_MASK) {
                case LCK_UNLOCK:
-                       log_debug("Unlocking LV %s", resource);
+                       log_very_verbose("Unlocking LV %s", resource);
                        if (!lv_resume_if_active(cmd, resource))
                                return 0;
                        break;
                case LCK_NULL:
-                       log_debug("Locking LV %s (NL)", resource);
+                       log_very_verbose("Locking LV %s (NL)", resource);
                        if (!lv_deactivate(cmd, resource))
                                return 0;
                        break;
                case LCK_READ:
-                       log_debug("Locking LV %s (R)", resource);
+                       log_very_verbose("Locking LV %s (R)", resource);
                        if (!lv_activate_with_filter(cmd, resource, 0))
                                return 0;
                        break;
+               case LCK_PREAD:
+                       log_very_verbose("Locking LV %s (PR) - ignored", resource);
+                       break;
                case LCK_WRITE:
-                       log_debug("Locking LV %s (W)", resource);
+                       log_very_verbose("Locking LV %s (W)", resource);
                        if (!lv_suspend_if_active(cmd, resource))
                                return 0;
                        break;
                case LCK_EXCL:
-                       log_debug("Locking LV %s (EX)", resource);
+                       log_very_verbose("Locking LV %s (EX)", resource);
                        if (!lv_activate_with_filter(cmd, resource, 1))
                                return 0;
                        break;

diff --git a/lib/locking/locking.c b/lib/locking/locking.c
index 6ca1a10d455fcf577d985e76a9fb4296e7c68f68..b45d56c9726193637f1f5186c7719f1773e89e70 100644 (file)
--- a/lib/locking/locking.c
+++ b/lib/locking/locking.c
@@ -318,6 +318,8 @@ static int _lock_vol(struct cmd_context *cmd, const char *resource, uint32_t fla
        _block_signals(flags);
        _lock_memory(flags);
 
+       assert(resource);
+
        if (!(_locking.lock_resource(cmd, resource, flags))) {
                _unlock_memory(flags);
                _unblock_signals();

diff --git a/tools/pvresize.c b/tools/pvresize.c
index 223828795076310faad066687866b9326cbdd34f..e4ef249f4638183669a1fa3eb5174d5fc44e5a2c 100644 (file)
--- a/tools/pvresize.c
+++ b/tools/pvresize.c
@@ -23,10 +23,10 @@ struct pvresize_params {
        unsigned total;
 };
 
-int pv_resize_single(struct cmd_context *cmd,
-                    struct volume_group *vg,
-                    struct physical_volume *pv,
-                    const uint64_t new_size)
+static int _pv_resize_single(struct cmd_context *cmd,
+                            struct volume_group *vg,
+                            struct physical_volume *pv,
+                            const uint64_t new_size)
 {
        struct pv_list *pvl;
        int consistent = 1;
@@ -186,7 +186,7 @@ static int _pvresize_single(struct cmd_context *cmd,
 
        params->total++;
 
-       if (!pv_resize_single(cmd, vg, pv, params->new_size))
+       if (!_pv_resize_single(cmd, vg, pv, params->new_size))
                return ECMD_FAILED;
        
        params->done++;

diff --git a/tools/toollib.c b/tools/toollib.c
index 12c2f7408a6a1c6e1410bf150ba880b3e5c86b22..161851da4720123d88d89e35bc65ad9c72b5aea8 100644 (file)
--- a/tools/toollib.c
+++ b/tools/toollib.c
@@ -428,7 +428,7 @@ int process_each_segment_in_pv(struct cmd_context *cmd,
        int ret_max = 0;
        int ret;
 
-       if (!vg) {
+       if (!vg && !is_orphan(pv)) {
                vg_name = pv_vg_name(pv);
 
                if (!(vg = vg_lock_and_read(cmd, vg_name, NULL, LCK_VG_READ,