April 2016 - lvm2-commits - Fedora mailing-lists

master - lvmetad: add disabled state
by David Teigland 19 Apr '16

19 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=a4ef8fa25e4a8e14… Commit: a4ef8fa25e4a8e14bef132393070006819b30935 Parent: e41ee70accbc604e3a7daea0ab10f9405e95a531 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jan 28 16:54:36 2016 -0600 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Apr 19 09:41:18 2016 -0500 lvmetad: add disabled state A global flag in lvmetad indicates it has been disabled. Other flags indicate the reason it was disabled. These flags can be queried using get_global_info. The lvmetactl debugging utility can set and clear the disabled flag in lvmetad. Nothing else sets the disabled flag yet. Commands will check these flags after connecting to lvmetad. If the disabled flag is set, the command will not use the lvmetad cache, but revert to disk scanning. To test this feature: $ lvmetactl get_global_info response = "OK" global_invalid = 0 global_disable = 0 disable_reason = "none" token = "filter:3041577944" $ vgs (should report VGs from lvmetad) $ lvmetactl set_global_disable 1 $ lvmetactl get_global_info response = "OK" global_invalid = 0 global_disable = 1 disable_reason = "DIRECT" token = "filter:3041577944" $ vgs WARNING: Not using lvmetad because the disable flag was set directly. (should report VGs without contacting lvmetad) $ lvmetactl set_global_disable 0 $ vgs (should report VGs from lvmetad) --- daemons/lvmetad/lvmetactl.c | 23 ++++++++++-- daemons/lvmetad/lvmetad-core.c | 74 +++++++++++++++++++++++++++++++++++++++- lib/cache/lvmetad.c | 49 ++++++++++++++++++++++++++ lib/cache/lvmetad.h | 3 ++ 4 files changed, 144 insertions(+), 5 deletions(-) diff --git a/daemons/lvmetad/lvmetactl.c b/daemons/lvmetad/lvmetactl.c index de40bef..90db173 100644 --- a/daemons/lvmetad/lvmetactl.c +++ b/daemons/lvmetad/lvmetactl.c @@ -37,11 +37,12 @@ int main(int argc, char **argv) printf("lvmetactl dump\n"); printf("lvmetactl pv_list\n"); printf("lvmetactl vg_list\n"); + printf("lvmetactl get_global_info\n"); printf("lvmetactl vg_lookup_name <name>\n"); printf("lvmetactl vg_lookup_uuid <uuid>\n"); printf("lvmetactl pv_lookup_uuid <uuid>\n"); printf("lvmetactl set_global_invalid 0|1\n"); - printf("lvmetactl get_global_invalid\n"); + printf("lvmetactl set_global_disable 0|1\n"); printf("lvmetactl set_vg_version <uuid> <name> <version>\n"); printf("lvmetactl vg_lock_type <uuid>\n"); return -1; @@ -69,6 +70,12 @@ int main(int argc, char **argv) NULL); printf("%s\n", reply.buffer.mem); + } else if (!strcmp(cmd, "get_global_info")) { + reply = daemon_send_simple(h, "get_global_info", + "token = %s", "skip", + NULL); + printf("%s\n", reply.buffer.mem); + } else if (!strcmp(cmd, "set_global_invalid")) { if (argc < 3) { printf("set_global_invalid 0|1\n"); @@ -82,11 +89,19 @@ int main(int argc, char **argv) NULL); print_reply(reply); - } else if (!strcmp(cmd, "get_global_invalid")) { - reply = daemon_send_simple(h, "get_global_info", + } else if (!strcmp(cmd, "set_global_disable")) { + if (argc < 3) { + printf("set_global_disable 0|1\n"); + return -1; + } + val = atoi(argv[2]); + + reply = daemon_send_simple(h, "set_global_info", + "global_disable = " FMTd64, (int64_t) val, + "disable_reason = %s", "DIRECT", "token = %s", "skip", NULL); - printf("%s\n", reply.buffer.mem); + print_reply(reply); } else if (!strcmp(cmd, "set_vg_version")) { if (argc < 5) { diff --git a/daemons/lvmetad/lvmetad-core.c b/daemons/lvmetad/lvmetad-core.c index 090255a..1c2ac81 100644 --- a/daemons/lvmetad/lvmetad-core.c +++ b/daemons/lvmetad/lvmetad-core.c @@ -196,7 +196,14 @@ struct vg_info { uint32_t flags; /* VGFL_ */ }; -#define GLFL_INVALID 0x00000001 +#define GLFL_INVALID 0x00000001 +#define GLFL_DISABLE 0x00000002 +#define GLFL_DISABLE_REASON_DIRECT 0x00000004 +#define GLFL_DISABLE_REASON_LVM1 0x00000008 +#define GLFL_DISABLE_REASON_DUPLICATES 0x00000010 + +#define GLFL_DISABLE_REASON_ALL (GLFL_DISABLE_REASON_DIRECT | GLFL_DISABLE_REASON_LVM1 | GLFL_DISABLE_REASON_DUPLICATES) + #define VGFL_INVALID 0x00000001 typedef struct { @@ -2601,9 +2608,42 @@ static response vg_remove(lvmetad_state *s, request r) return daemon_reply_simple("OK", NULL); } +/* + * Whether lvmetad is disabled is determined only by the single + * flag GLFL_DISABLE. The REASON flags are only explanatory + * additions to GLFL_DISABLE, and do not control the disabled state. + * The REASON flags can accumulate if multiple reasons exist for + * the disabled flag. When clearing GLFL_DISABLE, all REASON flags + * are cleared. The caller clearing GLFL_DISABLE should only do so + * when all the reasons for it have gone. + */ + static response set_global_info(lvmetad_state *s, request r) { const int global_invalid = daemon_request_int(r, "global_invalid", -1); + const int global_disable = daemon_request_int(r, "global_disable", -1); + const char *reason; + uint32_t reason_flags = 0; + + if ((reason = daemon_request_str(r, "disable_reason", NULL))) { + if (strstr(reason, "DIRECT")) + reason_flags |= GLFL_DISABLE_REASON_DIRECT; + if (strstr(reason, "LVM1")) + reason_flags |= GLFL_DISABLE_REASON_LVM1; + if (strstr(reason, "DUPLICATES")) + reason_flags |= GLFL_DISABLE_REASON_DUPLICATES; + } + + if (global_invalid != -1) { + DEBUGLOG(s, "set global info invalid from %d to %d", + (s->flags & GLFL_INVALID) ? 1 : 0, global_invalid); + } + + if (global_disable != -1) { + DEBUGLOG(s, "set global info disable from %d to %d %s", + (s->flags & GLFL_DISABLE) ? 1 : 0, global_disable, + reason ? reason : ""); + } if (global_invalid == 1) s->flags |= GLFL_INVALID; @@ -2611,6 +2651,15 @@ static response set_global_info(lvmetad_state *s, request r) else if (global_invalid == 0) s->flags &= ~GLFL_INVALID; + if (global_disable == 1) { + s->flags |= GLFL_DISABLE; + s->flags |= reason_flags; + + } else if (global_disable == 0) { + s->flags &= ~GLFL_DISABLE; + s->flags &= ~GLFL_DISABLE_REASON_ALL; + } + return daemon_reply_simple("OK", NULL); } @@ -2629,8 +2678,31 @@ static response set_global_info(lvmetad_state *s, request r) static response get_global_info(lvmetad_state *s, request r) { + char reason[REASON_BUF_SIZE]; + + /* This buffer should be large enough to hold all the possible reasons. */ + + memset(reason, 0, sizeof(reason)); + + if (s->flags & GLFL_DISABLE) { + snprintf(reason, REASON_BUF_SIZE - 1, "%s%s%s", + (s->flags & GLFL_DISABLE_REASON_DIRECT) ? "DIRECT," : "", + (s->flags & GLFL_DISABLE_REASON_LVM1) ? "LVM1," : "", + (s->flags & GLFL_DISABLE_REASON_DUPLICATES) ? "DUPLICATES," : ""); + } + + if (!reason[0]) + strcpy(reason, "none"); + + DEBUGLOG(s, "global info invalid is %d disable is %d reason %s", + (s->flags & GLFL_INVALID) ? 1 : 0, + (s->flags & GLFL_DISABLE) ? 1 : 0, reason); + return daemon_reply_simple("OK", "global_invalid = " FMTd64, (int64_t)((s->flags & GLFL_INVALID) ? 1 : 0), + "global_disable = " FMTd64, + (int64_t)((s->flags & GLFL_DISABLE) ? 1 : 0), + "disable_reason = %s", reason, "token = %s", s->token[0] ? s->token : "none", NULL); diff --git a/lib/cache/lvmetad.c b/lib/cache/lvmetad.c index a680441..f2831f1 100644 --- a/lib/cache/lvmetad.c +++ b/lib/cache/lvmetad.c @@ -2249,3 +2249,52 @@ int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const cha return ret; } + +int lvmetad_is_disabled(struct cmd_context *cmd, const char **reason) +{ + daemon_reply reply; + const char *reply_reason; + int ret = 0; + + reply = daemon_send_simple(_lvmetad, "get_global_info", + "token = %s", "skip", + NULL); + + if (reply.error) { + *reason = "send error"; + ret = 1; + goto out; + } + + if (strcmp(daemon_reply_str(reply, "response", ""), "OK")) { + *reason = "response error"; + ret = 1; + goto out; + } + + if (daemon_reply_int(reply, "global_disable", 0)) { + ret = 1; + + reply_reason = daemon_reply_str(reply, "disable_reason", NULL); + + if (!reply_reason) { + *reason = "<not set>"; + + } else if (strstr(reply_reason, "DIRECT")) { + *reason = "the disable flag was set directly"; + + } else if (strstr(reply_reason, "LVM1")) { + *reason = "LVM1 metadata was found"; + + } else if (strstr(reply_reason, "DUPLICATES")) { + *reason = "duplicate PVs were found"; + + } else { + *reason = "<unknown>"; + } + } +out: + daemon_reply_destroy(reply); + return ret; +} + diff --git a/lib/cache/lvmetad.h b/lib/cache/lvmetad.h index 5820956..10283bb 100644 --- a/lib/cache/lvmetad.h +++ b/lib/cache/lvmetad.h @@ -172,6 +172,8 @@ int lvmetad_token_matches(struct cmd_context *cmd); int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const char *vgid); +int lvmetad_is_disabled(struct cmd_context *cmd, const char **reason); + # else /* LVMETAD_SUPPORT */ # define lvmetad_init(cmd) do { } while (0) @@ -202,6 +204,7 @@ int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const cha # define lvmetad_validate_global_cache(cmd, force) do { } while (0) # define lvmetad_vg_is_foreign(cmd, vgname, vgid) (0) # define lvmetad_token_matches(cmd) (1) +# define lvmetad_is_disabled(cmd, reason) (0) # endif /* LVMETAD_SUPPORT */

1 0

master - toollib: remove unneeded call in process_each_pv
by David Teigland 19 Apr '16

19 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=e41ee70accbc604e… Commit: e41ee70accbc604e3a7daea0ab10f9405e95a531 Parent: a6a32a7c0e6ed9ef9e61e82b2d1353a1c06a9dd3 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Apr 7 13:45:26 2016 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Apr 19 09:40:24 2016 -0500 toollib: remove unneeded call in process_each_pv process_each_pv was doing: 1. lvmcache_seed_infos_from_lvmetad() sends pv_list request to lvmetad. 2. get_vgnameids() sends vg_list request to lvmetad. 3. _get_all_devices() first calls lvmcache_seed_infos_from_lvmetad(), which is a no-op if it's already been called. Because get_vgnameids() does not use the information from lvmcache_seed_infos_from_lvmetad(), it does not need to be called prior to get_all_devices where it is actually needed. --- tools/toollib.c | 6 ------ 1 files changed, 0 insertions(+), 6 deletions(-) diff --git a/tools/toollib.c b/tools/toollib.c index b9db9cb..ac2a57a 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -3372,12 +3372,6 @@ int process_each_pv(struct cmd_context *cmd, dev_cache_full_scan(cmd->full_filter); } - /* - * Need pvid's set on all PVs before processing so that pvid's - * can be compared to find duplicates while processing. - */ - lvmcache_seed_infos_from_lvmetad(cmd); - if (!get_vgnameids(cmd, &all_vgnameids, only_this_vgname, 1)) { stack; return ret;

1 0

master - metadata: don't repair shared VGs
by David Teigland 19 Apr '16

19 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=a6a32a7c0e6ed9ef… Commit: a6a32a7c0e6ed9ef9e61e82b2d1353a1c06a9dd3 Parent: a400eba1740c335ed715c67b978dd0ed8228d73a Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Apr 14 16:40:26 2016 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Apr 19 09:19:32 2016 -0500 metadata: don't repair shared VGs When the in-use flag looks like it needs to be repaired. --- lib/metadata/metadata.c | 8 ++++++++ 1 files changed, 8 insertions(+), 0 deletions(-) diff --git a/lib/metadata/metadata.c b/lib/metadata/metadata.c index ecdb5af..782235e 100644 --- a/lib/metadata/metadata.c +++ b/lib/metadata/metadata.c @@ -4037,6 +4037,14 @@ static int _check_or_repair_pv_ext(struct cmd_context *cmd, "VG %s but not marked as used.", pv_dev_name(pvl->pv), vg->name); *inconsistent_pvs = 1; + } else if (is_lockd_type(vg->lock_type)) { + /* + * FIXME: decide how to handle repair for shared VGs. + */ + log_warn("Skip repair of PV %s that is in shared " + "VG %s but not marked as used.", + pv_dev_name(pvl->pv), vg->name); + *inconsistent_pvs = 1; } else { log_warn("WARNING: Repairing Physical Volume %s that is " "in Volume Group %s but not marked as used.",

1 0

master - lvmlockd: skip unnecessary lvmetad cache update
by David Teigland 19 Apr '16

19 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=a400eba1740c335e… Commit: a400eba1740c335ed715c67b978dd0ed8228d73a Parent: 50633039bfb5ef9a89e419ca7ad7ad49304d1c0d Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Apr 14 13:45:10 2016 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Apr 19 09:19:32 2016 -0500 lvmlockd: skip unnecessary lvmetad cache update In cases where a VG is reread from disk, but the seqno matches what is currently in lvmetad, the metadata in lvmetad doesn't need to be updated. --- lib/cache/lvmetad.c | 30 ++++++++++++++++++------------ 1 files changed, 18 insertions(+), 12 deletions(-) diff --git a/lib/cache/lvmetad.c b/lib/cache/lvmetad.c index 7ca5d4a..a680441 100644 --- a/lib/cache/lvmetad.c +++ b/lib/cache/lvmetad.c @@ -872,7 +872,7 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, const char *vgna } else { log_error(INTERNAL_ERROR "VG name required (VGID not available)"); - goto out; + return NULL; } if (_lvmetad_handle_reply(reply, "vg_lookup", diag_name, &found) && found) { @@ -958,16 +958,14 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, const char *vgna * invalidated the cached vg. */ if (rescan) { - log_debug_lvmetad("Update invalid lvmetad cache for VG %s", vgname); - vg2 = lvmetad_pvscan_vg(cmd, vg); - release_vg(vg); - vg = vg2; - if (!vg) { + if (!(vg2 = lvmetad_pvscan_vg(cmd, vg))) { log_debug_lvmetad("VG %s from lvmetad not found during rescan.", vgname); fid = NULL; goto out; - } else - fid = vg->fid; + } + release_vg(vg); + vg = vg2; + fid = vg2->fid; } dm_list_iterate_items(pvl, &vg->pvs) { @@ -1575,6 +1573,7 @@ static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct vo struct format_instance_ctx fic = { .type = 0 }; struct _lvmetad_pvscan_baton baton; struct device *save_dev = NULL; + uint32_t save_seqno = 0; dm_list_iterate_items(pvl, &vg->pvs) { /* missing pv */ @@ -1622,6 +1621,9 @@ static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct vo continue; } + if (!save_seqno) + save_seqno = baton.vg->seqno; + if (!(vgmeta = export_vg_to_config_tree(baton.vg))) { log_error("VG export to config tree failed"); release_vg(baton.vg); @@ -1661,10 +1663,14 @@ static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct vo * but that is the field which lvmetad_vg_update() uses * to send the metadata cft to lvmetad. */ - vg_ret->cft_precommitted = vgmeta_ret; - if (!lvmetad_vg_update(vg_ret)) - log_error("Failed to update lvmetad with new VG meta"); - vg_ret->cft_precommitted = NULL; + if (save_seqno != vg->seqno) { + log_debug_lvmetad("Update lvmetad from seqno %u to seqno %u for VG %s", + vg->seqno, save_seqno, vg->name); + vg_ret->cft_precommitted = vgmeta_ret; + if (!lvmetad_vg_update(vg_ret)) + log_error("Failed to update lvmetad with new VG meta"); + vg_ret->cft_precommitted = NULL; + } dm_config_destroy(vgmeta_ret); } out:

1 0

master - tests: use should for failing test
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=50633039bfb5ef9a… Commit: 50633039bfb5ef9a89e419ca7ad7ad49304d1c0d Parent: 59b0bd7b6445d0c09568eae4cbf75577ce190803 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Mon Apr 18 23:12:05 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 23:12:05 2016 +0200 tests: use should for failing test It's better to use 'should' for failing test before it gets fixed, when we ignore failing result. --- test/shell/lvmetad-lvm1.sh | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/shell/lvmetad-lvm1.sh b/test/shell/lvmetad-lvm1.sh index 9720833..824c1d5 100644 --- a/test/shell/lvmetad-lvm1.sh +++ b/test/shell/lvmetad-lvm1.sh @@ -19,11 +19,11 @@ SKIP_WITH_LVMPOLLD=1 aux prepare_devs 2 pvcreate --metadatatype 1 "$dev1" -vgscan --cache +should not vgscan --cache pvs | tee out not grep "$dev1" out vgcreate --metadatatype 1 $vg1 "$dev1" -vgscan --cache +should not vgscan --cache vgs | tee out not grep $vg1 out pvs | tee out

1 0

master - tests: use bigger raid size
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=59b0bd7b6445d0c0… Commit: 59b0bd7b6445d0c09568eae4cbf75577ce190803 Parent: 88c19d5d7200b4193693f88f42e05646a52b4563 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Mon Apr 18 23:09:17 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 23:09:17 2016 +0200 tests: use bigger raid size To avoid problem with report of array in-sync use for now bigger raid size 64M. --- test/shell/lvconvert-repair-raid.sh | 8 ++++++-- 1 files changed, 6 insertions(+), 2 deletions(-) diff --git a/test/shell/lvconvert-repair-raid.sh b/test/shell/lvconvert-repair-raid.sh index 41d1cb9..1ef91c4 100644 --- a/test/shell/lvconvert-repair-raid.sh +++ b/test/shell/lvconvert-repair-raid.sh @@ -22,8 +22,12 @@ aux lvmconf 'allocation/maximise_cling = 0' \ aux prepare_vg 8 +# It's possible small raid arrays do have problems with reporting in-sync. +# So try bigger size +RAID_SIZE=64 + # RAID5 single replace -lvcreate --type raid5 -i 2 -l 2 -n $lv1 $vg "$dev1" "$dev2" "$dev3" +lvcreate --type raid5 -i 2 -L $RAID_SIZE -n $lv1 $vg "$dev1" "$dev2" "$dev3" aux wait_for_sync $vg $lv1 aux disable_dev "$dev3" lvconvert -y --repair $vg/$lv1 @@ -33,7 +37,7 @@ vgextend $vg "$dev3" lvremove -ff $vg # RAID6 double replace -lvcreate --type raid6 -i 3 -l 2 -n $lv1 $vg \ +lvcreate --type raid6 -i 3 -L $RAID_SIZE -n $lv1 $vg \ "$dev1" "$dev2" "$dev3" "$dev4" "$dev5" aux wait_for_sync $vg $lv1 aux disable_dev "$dev4" "$dev5"

1 0

master - lvchange: improve refresh for merging thin volume
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=88c19d5d7200b419… Commit: 88c19d5d7200b4193693f88f42e05646a52b4563 Parent: 7e5881dd131e6f521f8f419edc3bb42e575d693a Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Mon Apr 18 22:44:30 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 23:05:51 2016 +0200 lvchange: improve refresh for merging thin volume When running lvchange --refresh on merging thin volume, try to deactivate snapshot thinLV in case it's preventing startup of merge process. --- WHATS_NEW | 1 + tools/toollib.c | 10 ++++++++++ 2 files changed, 11 insertions(+), 0 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index 863fe30..4a435bb 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ Version 2.02.151 - ================================= + lvchange --refresh for merging thin origin will retry to deactivate snapshot. Recognize in-progress snapshot merge for thin volumes from dm table. Avoid deciding to initiate a pending snapshot merge during resume. Improve retrying lvmetad requests while lvmetad is being updated. diff --git a/tools/toollib.c b/tools/toollib.c index 5e9b4d8..b9db9cb 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -1080,6 +1080,16 @@ int lv_change_activate(struct cmd_context *cmd, struct logical_volume *lv, int lv_refresh(struct cmd_context *cmd, struct logical_volume *lv) { + struct logical_volume *snapshot_lv; + + if (lv_is_merging_origin(lv)) { + snapshot_lv = find_snapshot(lv)->lv; + if (lv_is_thin_type(snapshot_lv) && !deactivate_lv(cmd, snapshot_lv)) + log_print_unless_silent("Delaying merge for origin volume %s since " + "snapshot volume %s is still active.", + display_lvname(lv), display_lvname(snapshot_lv)); + } + if (!lv_refresh_suspend_resume(cmd, lv)) return_0;

1 0

master - snapshot: improve merge
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=7e5881dd131e6f52… Commit: 7e5881dd131e6f521f8f419edc3bb42e575d693a Parent: d1c1f60047bb6973eee432ea14f93058a836faac Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Mon Apr 18 22:54:27 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 23:05:17 2016 +0200 snapshot: improve merge Improve code for snapshot merge for readabilty and also reduce number of tests needed to decide if merging can or cannot be started. (Further improving 9cccf5245a97a64f900f253fcf948edd5d7ba8c0) --- lib/activate/dev_manager.c | 77 +++++++++++++++++++++----------------------- 1 files changed, 37 insertions(+), 40 deletions(-) diff --git a/lib/activate/dev_manager.c b/lib/activate/dev_manager.c index b155039..5b1e226 100644 --- a/lib/activate/dev_manager.c +++ b/lib/activate/dev_manager.c @@ -2741,7 +2741,7 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, uint32_t read_ahead = lv->read_ahead; uint32_t read_ahead_flags = UINT32_C(0); int save_pending_delete = dm->track_pending_delete; - int snap_dev_is_open = 0; + int merge_in_progress = 0; /* LV with pending delete is never put new into a table */ if (lv_is_pending_delete(lv) && !_cached_dm_info(dm->mem, dtree, lv, NULL)) @@ -2762,57 +2762,52 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, if (!layer && lv_is_merging_origin(lv)) { seg = find_snapshot(lv); /* - * Clear merge attributes if merge isn't currently possible: + * Prevent merge if merge isn't currently possible: * either origin or merging snapshot are open * - for old snaps use "snapshot-merge" if it is already in use * - open_count is always retrieved (as of dm-ioctl 4.7.0) * so just use the tree's existing nodes' info */ - if ((dinfo = _cached_dm_info(dm->mem, dtree, + if ((dinfo = _cached_dm_info(dm->mem, dtree, lv, NULL))) { + /* Merging origin LV is present, check if mergins is already running. */ + if ((seg_is_thin_volume(seg) && _thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id)) || + (!seg_is_thin_volume(seg) && lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) { + log_debug_activation("Merging of snapshot volume %s to origin %s is in progress.", + display_lvname(seg->lv), display_lvname(seg->lv)); + merge_in_progress = 1; /* Merge is already running */ + } /* Merge is not yet running, so check if it can be started */ + else if (laopts->resuming) { + log_debug_activation("Postponing pending snapshot merge for origin %s, " + "merge was not started before suspend.", + display_lvname(lv)); + laopts->no_merging = 1; /* Cannot be reloaded in suspend */ + } /* Non-resuming merge requires origin to be unused */ + else if (dinfo->open_count) { + log_debug_activation("Postponing pending snapshot merge for origin %s, " + "origin volume is opened.", + display_lvname(lv)); + laopts->no_merging = 1; + } + } + + /* If merge would be still undecided, look as snapshot */ + if (!merge_in_progress && !laopts->no_merging && + (dinfo = _cached_dm_info(dm->mem, dtree, seg_is_thin_volume(seg) ? seg->lv : seg->cow, NULL))) { if (seg_is_thin_volume(seg)) { /* Active thin snapshot prevents merge */ - log_debug_activation("Merging thin snapshot %s is active.", - display_lvname(seg->lv)); + log_debug_activation("Postponing pending snapshot merge for origin volume %s, " + "merging thin snapshot volume %s is active.", + display_lvname(lv), display_lvname(seg->lv)); + laopts->no_merging = 1; } else if (dinfo->open_count) { - log_debug_activation("Merging snapshot LV %s is openned.", - display_lvname(seg->lv)); - snap_dev_is_open = 1; + log_debug_activation("Postponing pending snapshot merge for origin volume %s, " + "merging snapshot volume %s is opened.", + display_lvname(lv), display_lvname(seg->lv)); + laopts->no_merging = 1; } } - - if ((dinfo = _cached_dm_info(dm->mem, dtree, lv, NULL))) { - if (dinfo->open_count) { - log_debug_activation("Merging origin volume %s is openned.", display_lvname(seg->lv)); - snap_dev_is_open = 1; - } - - /* Check if decision needs to be preserved. - * Merging origin LV needs to be present in table in this case. */ - if (!laopts->resuming) { - if ((seg_is_thin_volume(seg) && _thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id)) || - (!seg_is_thin_volume(seg) && lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) { - log_debug_activation("Merging of snapshot volume %s is in progress.", - display_lvname(seg->lv)); - /* Merging is already running and cannot be switched */ - snap_dev_is_open = 0; - } - } else { - if ((seg_is_thin_volume(seg) && !_thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id)) || - (!seg_is_thin_volume(seg) && !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) { - log_debug_activation("Merging of snapshot volume %s was not started before suspend.", - display_lvname(seg->lv)); - /* Merging targe table cannot be reloaded when suspend */ - snap_dev_is_open = 1; - } - } - } - - if (snap_dev_is_open) { - log_debug_activation("Postponing pending snapshot merge for origin LV %s.", display_lvname(lv)); - laopts->no_merging = 1; - } } if (!(name = dm_build_dm_name(dm->mem, lv->vg->name, lv->name, layer))) @@ -3163,6 +3158,8 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv, if (!dm_tree_preload_children(root, dlid, DLID_SIZE)) goto_out; + //if (action == PRELOAD) { log_debug("SLEEP"); sleep(7); } + if ((dm_tree_node_size_changed(root) < 0)) dm->flush_required = 1; /* Currently keep the code require flush for any

1 0

master - debug: use display_lvname
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=d1c1f60047bb6973… Commit: d1c1f60047bb6973eee432ea14f93058a836faac Parent: e2ceb90095ab008c13a3d0db0bbf1bc2bd8557f2 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Mon Apr 18 11:04:06 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 12:32:56 2016 +0200 debug: use display_lvname --- tools/toollib.c | 10 ++++++---- 1 files changed, 6 insertions(+), 4 deletions(-) diff --git a/tools/toollib.c b/tools/toollib.c index b1225cd..5e9b4d8 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -1057,13 +1057,15 @@ int lv_change_activate(struct cmd_context *cmd, struct logical_volume *lv, snapshot_lv = find_snapshot(lv)->lv; if (lv_is_thin_type(snapshot_lv) && !deactivate_lv(cmd, snapshot_lv)) { if (is_change_activating(activate)) { - log_error("Refusing to activate merging \"%s\" while snapshot \"%s\" is still active.", - lv->name, find_snapshot(lv)->lv->name); + log_error("Refusing to activate merging volume %s while " + "snapshot volume %s is still active.", + display_lvname(lv), display_lvname(snapshot_lv)); return 0; } - log_error("Cannot fully deactivate merging origin \"%s\" while snapshot \"%s\" is still active.", - lv->name, find_snapshot(lv)->lv->name); + log_error("Cannot fully deactivate merging origin volume %s while " + "snapshot volume %s is still active.", + display_lvname(lv), display_lvname(snapshot_lv)); r = 0; /* and continue to deactivate origin... */ } }

1 0

master - debug: update message in libdm
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=e2ceb90095ab008c… Commit: e2ceb90095ab008c13a3d0db0bbf1bc2bd8557f2 Parent: f5cf6cc9ed756ec1e98d62a31aba803577443ad7 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Sun Apr 17 14:51:58 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 12:32:56 2016 +0200 debug: update message in libdm When dm_tree_find_node_by_uuid() fails to find passed uuid, report in lof_debug the complete original uuid, not the one stripped of LVM- prefix. TODO: inspect manipulation with LVM- prefix here. --- WHATS_NEW_DM | 1 + libdm/libdm-deptree.c | 2 +- 2 files changed, 2 insertions(+), 1 deletions(-) diff --git a/WHATS_NEW_DM b/WHATS_NEW_DM index 08d7d45..e2301ea 100644 --- a/WHATS_NEW_DM +++ b/WHATS_NEW_DM @@ -1,5 +1,6 @@ Version 1.02.122 - 9th April 2016 ================================= + Do not strip LVM- when debug reporting not found uuid. Change log_debug ioctl flags from single characters into words. Version 1.02.121 - 26th March 2016 diff --git a/libdm/libdm-deptree.c b/libdm/libdm-deptree.c index f8b6d89..6f18ae2 100644 --- a/libdm/libdm-deptree.c +++ b/libdm/libdm-deptree.c @@ -599,7 +599,7 @@ static struct dm_tree_node *_find_dm_tree_node_by_uuid(struct dm_tree *dtree, return node; } - log_debug("Not matched uuid %s in deptree.", uuid + default_uuid_prefix_len); + log_debug("Not matched uuid %s in deptree.", uuid); return NULL; }

1 0

master - debug: fix error message
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=f5cf6cc9ed756ec1… Commit: f5cf6cc9ed756ec1e98d62a31aba803577443ad7 Parent: 9cccf5245a97a64f900f253fcf948edd5d7ba8c0 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Sun Apr 17 14:44:13 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 12:32:56 2016 +0200 debug: fix error message log_error is replaced with warn since the result of function is not result in command error. --- lib/activate/dev_manager.c | 6 +++--- 1 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/activate/dev_manager.c b/lib/activate/dev_manager.c index 2b108c9..b155039 100644 --- a/lib/activate/dev_manager.c +++ b/lib/activate/dev_manager.c @@ -766,11 +766,11 @@ static const struct dm_info *_cached_dm_info(struct dm_pool *mem, return_NULL; if (!(dnode = dm_tree_find_node_by_uuid(dtree, dlid))) - goto_out; + goto out; if (!(dinfo = dm_tree_node_get_info(dnode))) { - log_error("Failed to get info from tree node for %s.", - display_lvname(lv)); + log_warn("WARNING: Cannot get info from tree node for %s.", + display_lvname(lv)); goto out; }

1 0

master - thin: improve recognizing of merge in progress
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=9cccf5245a97a64f… Commit: 9cccf5245a97a64f900f253fcf948edd5d7ba8c0 Parent: e2cd882f2eef93f02711c34a741bd85d6313eb6e Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Mon Apr 18 11:04:16 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 12:32:52 2016 +0200 thin: improve recognizing of merge in progress Rewrite too condensed condition in more readable form, wher decision are clearly separated and commented and also add debug messages for them. --- lib/activate/dev_manager.c | 59 ++++++++++++++++++++++++++++++++------------ 1 files changed, 43 insertions(+), 16 deletions(-) diff --git a/lib/activate/dev_manager.c b/lib/activate/dev_manager.c index 6659190..2b108c9 100644 --- a/lib/activate/dev_manager.c +++ b/lib/activate/dev_manager.c @@ -2764,25 +2764,52 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, /* * Clear merge attributes if merge isn't currently possible: * either origin or merging snapshot are open - * - but use "snapshot-merge" if it is already in use + * - for old snaps use "snapshot-merge" if it is already in use * - open_count is always retrieved (as of dm-ioctl 4.7.0) * so just use the tree's existing nodes' info */ - /* An activating merging origin won't have a node in the tree yet */ - if (((dinfo = _cached_dm_info(dm->mem, dtree, lv, NULL)) && - dinfo->open_count) || - ((dinfo = _cached_dm_info(dm->mem, dtree, - seg_is_thin_volume(seg) ? - seg->lv : seg->cow, NULL)) && - dinfo->open_count)) - snap_dev_is_open = 1; - - /* Preload considers open devices. */ - /* Resume looks at the table that will be the live one after the operation. */ - if ((!laopts->resuming && snap_dev_is_open && (seg_is_thin_volume(seg) || !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) || - (laopts->resuming && - ((!seg_is_thin_volume(seg) && !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE)) || - (seg_is_thin_volume(seg) && !_thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id))))) { + if ((dinfo = _cached_dm_info(dm->mem, dtree, + seg_is_thin_volume(seg) ? + seg->lv : seg->cow, NULL))) { + if (seg_is_thin_volume(seg)) { + /* Active thin snapshot prevents merge */ + log_debug_activation("Merging thin snapshot %s is active.", + display_lvname(seg->lv)); + } else if (dinfo->open_count) { + log_debug_activation("Merging snapshot LV %s is openned.", + display_lvname(seg->lv)); + snap_dev_is_open = 1; + } + } + + if ((dinfo = _cached_dm_info(dm->mem, dtree, lv, NULL))) { + if (dinfo->open_count) { + log_debug_activation("Merging origin volume %s is openned.", display_lvname(seg->lv)); + snap_dev_is_open = 1; + } + + /* Check if decision needs to be preserved. + * Merging origin LV needs to be present in table in this case. */ + if (!laopts->resuming) { + if ((seg_is_thin_volume(seg) && _thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id)) || + (!seg_is_thin_volume(seg) && lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) { + log_debug_activation("Merging of snapshot volume %s is in progress.", + display_lvname(seg->lv)); + /* Merging is already running and cannot be switched */ + snap_dev_is_open = 0; + } + } else { + if ((seg_is_thin_volume(seg) && !_thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id)) || + (!seg_is_thin_volume(seg) && !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) { + log_debug_activation("Merging of snapshot volume %s was not started before suspend.", + display_lvname(seg->lv)); + /* Merging targe table cannot be reloaded when suspend */ + snap_dev_is_open = 1; + } + } + } + + if (snap_dev_is_open) { log_debug_activation("Postponing pending snapshot merge for origin LV %s.", display_lvname(lv)); laopts->no_merging = 1; }

1 0

master - thin: check runtime table line for merging
by Zdenek Kabelac 18 Apr '16

18 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=e2cd882f2eef93f0… Commit: e2cd882f2eef93f02711c34a741bd85d6313eb6e Parent: 662090e3587d248f1c53bd8dc2989ba0b1960085 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Sun Apr 17 14:51:48 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Mon Apr 18 11:18:35 2016 +0200 thin: check runtime table line for merging To recognize in runtime if we are merging or not to make consistent decision between suspend and resume add function to parse thin table line when add merging thin device to the table. --- WHATS_NEW | 1 + lib/activate/dev_manager.c | 65 +++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 65 insertions(+), 1 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index 123c383..863fe30 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ Version 2.02.151 - ================================= + Recognize in-progress snapshot merge for thin volumes from dm table. Avoid deciding to initiate a pending snapshot merge during resume. Improve retrying lvmetad requests while lvmetad is being updated. Read devices instead of using the lvmetad cache if rescan fails. diff --git a/lib/activate/dev_manager.c b/lib/activate/dev_manager.c index 92f2a05..6659190 100644 --- a/lib/activate/dev_manager.c +++ b/lib/activate/dev_manager.c @@ -840,6 +840,67 @@ bad: return r; } +static int _thin_lv_has_device_id(struct dm_pool *mem, const struct logical_volume *lv, + const char *layer, unsigned device_id) +{ + char *dlid; + struct dm_task *dmt; + struct dm_info info; + void *next = NULL; + uint64_t start, length; + char *type = NULL; + char *params = NULL; + unsigned id = ~0; + + if (!(dlid = build_dm_uuid(mem, lv, layer))) + return_0; + + if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TABLE, 0, 0, 0))) + goto_bad; + + if (!dm_task_run(dmt)) + goto_out; + + if (!dm_task_get_info(dmt, &info) || !info.exists) + goto_out; + + /* If there is a preloaded table, use that in preference. */ + if (info.inactive_table) { + dm_task_destroy(dmt); + + if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TABLE, 0, 0, 0))) + goto_bad; + + if (!dm_task_query_inactive_table(dmt)) + goto_out; + + if (!dm_task_run(dmt)) + goto_out; + + if (!dm_task_get_info(dmt, &info) || !info.exists || !info.inactive_table) + goto_out; + } + + (void) dm_get_next_target(dmt, next, &start, &length, &type, &params); + + if (!type || strcmp(type, TARGET_NAME_THIN)) + goto_out; + + if (!params || sscanf(params, "%*u:%*u %u", &id) != 1) + goto_out; + + log_debug_activation("%soaded thin volume %s with id %u is %smatching id %u.", + info.inactive_table ? "Prel" : "L", + display_lvname(lv), id, + (device_id != id) ? "not " : "", device_id); +out: + dm_task_destroy(dmt); +bad: + dm_pool_free(mem, dlid); + + return (device_id == id); +} + int add_linear_area_to_dtree(struct dm_tree_node *node, uint64_t size, uint32_t extent_size, int use_linear_target, const char *vgname, const char *lvname) { uint32_t page_size; @@ -2719,7 +2780,9 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, /* Preload considers open devices. */ /* Resume looks at the table that will be the live one after the operation. */ if ((!laopts->resuming && snap_dev_is_open && (seg_is_thin_volume(seg) || !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) || - (laopts->resuming && !seg_is_thin_volume(seg) && !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) { + (laopts->resuming && + ((!seg_is_thin_volume(seg) && !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE)) || + (seg_is_thin_volume(seg) && !_thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id))))) { log_debug_activation("Postponing pending snapshot merge for origin LV %s.", display_lvname(lv)); laopts->no_merging = 1; }

1 0

master - tests: fix check_lvmlockd_test
by David Teigland 15 Apr '16

15 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=662090e3587d248f… Commit: 662090e3587d248f1c53bd8dc2989ba0b1960085 Parent: 6954de22e2281876506c0db1c98972242de977fb Author: David Teigland <teigland(a)redhat.com> AuthorDate: Fri Apr 15 12:35:20 2016 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Fri Apr 15 12:35:20 2016 -0500 tests: fix check_lvmlockd_test --- test/lib/flavour-udev-lvmlockd-test.sh | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/test/lib/flavour-udev-lvmlockd-test.sh b/test/lib/flavour-udev-lvmlockd-test.sh index 17ef516..d2a7b4a 100644 --- a/test/lib/flavour-udev-lvmlockd-test.sh +++ b/test/lib/flavour-udev-lvmlockd-test.sh @@ -6,4 +6,4 @@ export LVM_TEST_LVMLOCKD_TEST=1 export LVM_TEST_DEVDIR=/dev # FIXME:dct: add option to allow --test with sanlock -LVM_TEST_LVMLOCKD_TEST_DLM=1 +export LVM_TEST_LVMLOCKD_TEST_DLM=1

1 0

master - activate: Improve snapshot merge initiation
by Alasdair Kergon 15 Apr '16

15 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=6954de22e2281876… Commit: 6954de22e2281876506c0db1c98972242de977fb Parent: 150cff9cce019e3211d99dbdceaccf77db1e503a Author: Alasdair G Kergon <agk(a)redhat.com> AuthorDate: Fri Apr 15 02:21:27 2016 +0100 Committer: Alasdair G Kergon <agk(a)redhat.com> CommitterDate: Fri Apr 15 02:33:38 2016 +0100 activate: Improve snapshot merge initiation A snapshot merge into its origin cannot be initiated while the devices are in use. If there is outside interference (such as from udev), the suspend (preload) and resume stages can reach conflicting decisions about whether or not to proceed. Try to make the logic more robust by checking the inactive or live table during resume. (This is still not perfect.) --- WHATS_NEW | 1 + lib/activate/activate.c | 1 + lib/activate/activate.h | 1 + lib/activate/dev_manager.c | 40 +++++++++++++++++++++++++++++----------- 4 files changed, 32 insertions(+), 11 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index 8c58c8d..123c383 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ Version 2.02.151 - ================================= + Avoid deciding to initiate a pending snapshot merge during resume. Improve retrying lvmetad requests while lvmetad is being updated. Read devices instead of using the lvmetad cache if rescan fails. Move lvmetad token/filter check and device rescan to the start of commands. diff --git a/lib/activate/activate.c b/lib/activate/activate.c index 8e6ee33..ac547ce 100644 --- a/lib/activate/activate.c +++ b/lib/activate/activate.c @@ -2063,6 +2063,7 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s, } laopts->read_only = _passes_readonly_filter(cmd, lv); + laopts->resuming = 1; if (!_lv_activate_lv(lv, laopts)) goto_out; diff --git a/lib/activate/activate.h b/lib/activate/activate.h index 64c026e..880689c 100644 --- a/lib/activate/activate.h +++ b/lib/activate/activate.h @@ -81,6 +81,7 @@ struct lv_activate_opts { * set of flags to avoid any scanning in udev. These udev * flags are persistent in udev db for any spurious event * that follows. */ + unsigned resuming; /* Set when resuming after a suspend. */ }; void set_activation(int activation, int silent); diff --git a/lib/activate/dev_manager.c b/lib/activate/dev_manager.c index d25c07e..92f2a05 100644 --- a/lib/activate/dev_manager.c +++ b/lib/activate/dev_manager.c @@ -806,13 +806,28 @@ int lv_has_target_type(struct dm_pool *mem, const struct logical_volume *lv, if (!dm_task_get_info(dmt, &info) || !info.exists) goto_out; + /* If there is a preloaded table, use that in preference. */ + if (info.inactive_table) { + dm_task_destroy(dmt); + + if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0))) + goto_bad; + + if (!dm_task_query_inactive_table(dmt)) + goto_out; + + if (!dm_task_run(dmt)) + goto_out; + + if (!dm_task_get_info(dmt, &info) || !info.exists || !info.inactive_table) + goto_out; + } + do { next = dm_get_next_target(dmt, next, &start, &length, &type, &params); - if (type && strncmp(type, target_type, - strlen(target_type)) == 0) { - if (info.live_table) - r = 1; + if (type && !strncmp(type, target_type, strlen(target_type))) { + r = 1; break; } } while (next); @@ -2665,6 +2680,7 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, uint32_t read_ahead = lv->read_ahead; uint32_t read_ahead_flags = UINT32_C(0); int save_pending_delete = dm->track_pending_delete; + int snap_dev_is_open = 0; /* LV with pending delete is never put new into a table */ if (lv_is_pending_delete(lv) && !_cached_dm_info(dm->mem, dtree, lv, NULL)) @@ -2697,13 +2713,15 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, ((dinfo = _cached_dm_info(dm->mem, dtree, seg_is_thin_volume(seg) ? seg->lv : seg->cow, NULL)) && - dinfo->open_count)) { - if (seg_is_thin_volume(seg) || - /* FIXME Is there anything simpler to check for instead? */ - !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE)) { - log_debug_activation("Postponing pending snapshot merge for origin LV %s.", display_lvname(lv)); - laopts->no_merging = 1; - } + dinfo->open_count)) + snap_dev_is_open = 1; + + /* Preload considers open devices. */ + /* Resume looks at the table that will be the live one after the operation. */ + if ((!laopts->resuming && snap_dev_is_open && (seg_is_thin_volume(seg) || !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) || + (laopts->resuming && !seg_is_thin_volume(seg) && !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) { + log_debug_activation("Postponing pending snapshot merge for origin LV %s.", display_lvname(lv)); + laopts->no_merging = 1; } }

1 0

master - activation: Log when pending snap merge postponed.
by Alasdair Kergon 14 Apr '16

14 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=150cff9cce019e32… Commit: 150cff9cce019e3211d99dbdceaccf77db1e503a Parent: 7ae5f6fc5c300413e740d4fa537090f0a4be5d2c Author: Alasdair G Kergon <agk(a)redhat.com> AuthorDate: Thu Apr 14 23:42:56 2016 +0100 Committer: Alasdair G Kergon <agk(a)redhat.com> CommitterDate: Thu Apr 14 23:42:56 2016 +0100 activation: Log when pending snap merge postponed. --- lib/activate/dev_manager.c | 4 +++- 1 files changed, 3 insertions(+), 1 deletions(-) diff --git a/lib/activate/dev_manager.c b/lib/activate/dev_manager.c index a0e05ad..d25c07e 100644 --- a/lib/activate/dev_manager.c +++ b/lib/activate/dev_manager.c @@ -2700,8 +2700,10 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, dinfo->open_count)) { if (seg_is_thin_volume(seg) || /* FIXME Is there anything simpler to check for instead? */ - !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE)) + !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE)) { + log_debug_activation("Postponing pending snapshot merge for origin LV %s.", display_lvname(lv)); laopts->no_merging = 1; + } } }

1 0

master - WHATS_NEW for lvmetad scanning changes
by David Teigland 14 Apr '16

14 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=7ae5f6fc5c300413… Commit: 7ae5f6fc5c300413e740d4fa537090f0a4be5d2c Parent: ff09bda7d585bbf743048965142e5b0ec881b896 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Apr 14 16:55:34 2016 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Thu Apr 14 16:55:34 2016 -0500 WHATS_NEW for lvmetad scanning changes --- WHATS_NEW | 3 +++ 1 files changed, 3 insertions(+), 0 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index 69ced16..8c58c8d 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,8 @@ Version 2.02.151 - ================================= + Improve retrying lvmetad requests while lvmetad is being updated. + Read devices instead of using the lvmetad cache if rescan fails. + Move lvmetad token/filter check and device rescan to the start of commands. Don't try deactivating fictional internal LV before snapshot merge. (2.02.105) When not obtaining devs from udev, check they exist before caching them. Detect device mismatch also when compiling without udev support.

1 0

master - activation: Add LV name to a debug message.
by Alasdair Kergon 14 Apr '16

14 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=ff09bda7d585bbf7… Commit: ff09bda7d585bbf743048965142e5b0ec881b896 Parent: f0179fac315b630aa4c475d2441dd3b5b12f0c6d Author: Alasdair G Kergon <agk(a)redhat.com> AuthorDate: Thu Apr 14 22:41:25 2016 +0100 Committer: Alasdair G Kergon <agk(a)redhat.com> CommitterDate: Thu Apr 14 22:41:25 2016 +0100 activation: Add LV name to a debug message. --- lib/activate/activate.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/lib/activate/activate.c b/lib/activate/activate.c index ca82518..8e6ee33 100644 --- a/lib/activate/activate.c +++ b/lib/activate/activate.c @@ -2309,7 +2309,7 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, if (info.exists && !info.suspended && info.live_table && (info.read_only == read_only_lv(lv, laopts))) { r = 1; - log_debug_activation("Volume is already active."); + log_debug_activation("LV %s is already active.", display_lvname(lv)); goto out; }

1 0

master - snapshot: Don't deactivate fictional snapshot LV.
by Alasdair Kergon 14 Apr '16

14 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=f0179fac315b630a… Commit: f0179fac315b630aa4c475d2441dd3b5b12f0c6d Parent: c68fb55ac104079e4708d9b869ef8edd9d1202c4 Author: Alasdair G Kergon <agk(a)redhat.com> AuthorDate: Thu Apr 14 20:48:28 2016 +0100 Committer: Alasdair G Kergon <agk(a)redhat.com> CommitterDate: Thu Apr 14 22:32:26 2016 +0100 snapshot: Don't deactivate fictional snapshot LV. Commit 971ab733b74e0ffecc3f9f60af48628cd3fba1db ("thin: activation of merging thin snapshot") also added an incorrect deactivation attempt for non-thin LVs: find_snapshot(lv)->lv is not designed to be activated and any attempt to deactivate it is incorrect. --- WHATS_NEW | 3 ++- tools/toollib.c | 4 +++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index f4eb6ad..69ced16 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ -Version 2.02.151 +Version 2.02.151 - ================================= + Don't try deactivating fictional internal LV before snapshot merge. (2.02.105) When not obtaining devs from udev, check they exist before caching them. Detect device mismatch also when compiling without udev support. diff --git a/tools/toollib.c b/tools/toollib.c index ce49773..b1225cd 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -1022,6 +1022,7 @@ int lv_change_activate(struct cmd_context *cmd, struct logical_volume *lv, activation_change_t activate) { int r = 1; + struct logical_volume *snapshot_lv; if (lv_is_cache_pool(lv)) { if (is_change_activating(activate)) { @@ -1053,7 +1054,8 @@ int lv_change_activate(struct cmd_context *cmd, struct logical_volume *lv, * User could retry to deactivate it with another * deactivation of origin, which is the only visible LV */ - if (!deactivate_lv(cmd, find_snapshot(lv)->lv)) { + snapshot_lv = find_snapshot(lv)->lv; + if (lv_is_thin_type(snapshot_lv) && !deactivate_lv(cmd, snapshot_lv)) { if (is_change_activating(activate)) { log_error("Refusing to activate merging \"%s\" while snapshot \"%s\" is still active.", lv->name, find_snapshot(lv)->lv->name);

1 0

master - toollib: Fix misleading message when forking.
by Alasdair Kergon 14 Apr '16

14 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=c68fb55ac104079e… Commit: c68fb55ac104079e4708d9b869ef8edd9d1202c4 Parent: 3f6e7f90cac72bd248c068f2893ef851d29cf1b9 Author: Alasdair G Kergon <agk(a)redhat.com> AuthorDate: Thu Apr 14 17:21:02 2016 +0100 Committer: Alasdair G Kergon <agk(a)redhat.com> CommitterDate: Thu Apr 14 17:21:02 2016 +0100 toollib: Fix misleading message when forking. Commands like pvscan --background run entirely in the background, but others fork only for polling. --- tools/toollib.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/tools/toollib.c b/tools/toollib.c index 2ff5a3b..ce49773 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -54,7 +54,7 @@ int become_daemon(struct cmd_context *cmd, int skip_lvm) .sa_flags = SA_NOCLDSTOP, }; - log_verbose("Forking background process: %s", cmd->cmd_line); + log_verbose("Forking background process from command: %s", cmd->cmd_line); sigaction(SIGCHLD, &act, NULL);

1 0

master - refactor: factor out vg/lv/pv handling part from report_for_selection fn
by Peter Rajnoha 14 Apr '16

14 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=3f6e7f90cac72bd2… Commit: 3f6e7f90cac72bd248c068f2893ef851d29cf1b9 Parent: 9a299d2d7a04759749bd6c01a86b90fd13f27b96 Author: Peter Rajnoha <prajnoha(a)redhat.com> AuthorDate: Thu Apr 14 15:21:41 2016 +0200 Committer: Peter Rajnoha <prajnoha(a)redhat.com> CommitterDate: Thu Apr 14 15:24:36 2016 +0200 refactor: factor out vg/lv/pv handling part from report_for_selection fn Functionality will be reused by future patches. Also, it makes the code more readable. --- tools/reporter.c | 160 ++++++++++++++++++++++++++++++++---------------------- 1 files changed, 96 insertions(+), 64 deletions(-) diff --git a/tools/reporter.c b/tools/reporter.c index a4cae60..ab11be2 100644 --- a/tools/reporter.c +++ b/tools/reporter.c @@ -438,13 +438,104 @@ static int _get_final_report_type(int args_are_pvs, return 1; } +static int _report_all_in_vg(struct cmd_context *cmd, struct processing_handle *handle, + struct volume_group *vg, report_type_t type, + int do_lv_info, int do_lv_seg_status) +{ + int r = 0; + + switch (type) { + case VGS: + r = _vgs_single(cmd, vg->name, vg, handle); + break; + case LVS: + r = process_each_lv_in_vg(cmd, vg, NULL, NULL, 0, handle, + do_lv_info && !do_lv_seg_status ? &_lvs_with_info_single : + !do_lv_info && do_lv_seg_status ? &_lvs_with_status_single : + do_lv_info && do_lv_seg_status ? &_lvs_with_info_and_status_single : + &_lvs_single); + break; + case SEGS: + r = process_each_lv_in_vg(cmd, vg, NULL, NULL, 0, handle, + do_lv_info && !do_lv_seg_status ? &_lvsegs_with_info_single : + !do_lv_info && do_lv_seg_status ? &_lvsegs_with_status_single : + do_lv_info && do_lv_seg_status ? &_lvsegs_with_info_and_status_single : + &_lvsegs_single); + break; + case PVS: + r = process_each_pv_in_vg(cmd, vg, handle, &_pvs_single); + break; + case PVSEGS: + r = process_each_pv_in_vg(cmd, vg, handle, + do_lv_info && !do_lv_seg_status ? &_pvsegs_with_lv_info_single : + !do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_status_single : + do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_info_and_status_single : + &_pvsegs_single); + break; + default: + log_error(INTERNAL_ERROR "_report_all_in_vg: incorrect report type"); + break; + } + + return r; +} + +static int _report_all_in_lv(struct cmd_context *cmd, struct processing_handle *handle, + struct logical_volume *lv, report_type_t type, + int do_lv_info, int do_lv_seg_status) +{ + int r = 0; + + switch (type) { + case LVS: + r = _do_lvs_with_info_and_status_single(cmd, lv, do_lv_info, do_lv_seg_status, handle); + break; + case SEGS: + r = process_each_segment_in_lv(cmd, lv, handle, + do_lv_info && !do_lv_seg_status ? &_segs_with_info_single : + !do_lv_info && do_lv_seg_status ? &_segs_with_status_single : + do_lv_info && do_lv_seg_status ? &_segs_with_info_and_status_single : + &_segs_single); + break; + default: + log_error(INTERNAL_ERROR "_report_all_in_lv: incorrect report type"); + break; + } + + return r; +} + +static int _report_all_in_pv(struct cmd_context *cmd, struct processing_handle *handle, + struct physical_volume *pv, report_type_t type, + int do_lv_info, int do_lv_seg_status) +{ + int r = 0; + + switch (type) { + case PVS: + r = _pvs_single(cmd, pv->vg, pv, handle); + break; + case PVSEGS: + r = process_each_segment_in_pv(cmd, pv->vg, pv, handle, + do_lv_info && !do_lv_seg_status ? &_pvsegs_with_lv_info_sub_single : + !do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_status_sub_single : + do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_info_and_status_sub_single : + &_pvsegs_sub_single); + break; + default: + log_error(INTERNAL_ERROR "_report_all_in_pv: incorrect report type"); + break; + } + + return r; +} + int report_for_selection(struct cmd_context *cmd, struct selection_handle *sh, struct physical_volume *pv, struct volume_group *vg, struct logical_volume *lv) { - static const char *incorrect_report_type_msg = "report_for_selection: incorrect report type"; int args_are_pvs = sh->orig_report_type == PVS; int do_lv_info, do_lv_seg_status; struct processing_handle *handle; @@ -491,75 +582,16 @@ int report_for_selection(struct cmd_context *cmd, */ switch (sh->orig_report_type) { case LVS: - switch (sh->report_type) { - case LVS: - r = _do_lvs_with_info_and_status_single(vg->cmd, lv, do_lv_info, do_lv_seg_status, handle); - break; - case SEGS: - r = process_each_segment_in_lv(vg->cmd, lv, handle, - do_lv_info && !do_lv_seg_status ? &_segs_with_info_single : - !do_lv_info && do_lv_seg_status ? &_segs_with_status_single : - do_lv_info && do_lv_seg_status ? &_segs_with_info_and_status_single : - &_segs_single); - break; - default: - log_error(INTERNAL_ERROR "%s for LVS", incorrect_report_type_msg); - break; - } + r = _report_all_in_lv(cmd, handle, lv, sh->report_type, do_lv_info, do_lv_seg_status); break; case VGS: - switch (sh->report_type) { - case VGS: - r = _vgs_single(vg->cmd, vg->name, vg, handle); - break; - case LVS: - r = process_each_lv_in_vg(vg->cmd, vg, NULL, NULL, 0, handle, - do_lv_info && !do_lv_seg_status ? &_lvs_with_info_single : - !do_lv_info && do_lv_seg_status ? &_lvs_with_status_single : - do_lv_info && do_lv_seg_status ? &_lvs_with_info_and_status_single : - &_lvs_single); - break; - case SEGS: - r = process_each_lv_in_vg(vg->cmd, vg, NULL, NULL, 0, handle, - do_lv_info && !do_lv_seg_status ? &_lvsegs_with_info_single : - !do_lv_info && do_lv_seg_status ? &_lvsegs_with_status_single : - do_lv_info && do_lv_seg_status ? &_lvsegs_with_info_and_status_single : - &_lvsegs_single); - break; - case PVS: - r = process_each_pv_in_vg(vg->cmd, vg, handle, &_pvs_single); - break; - case PVSEGS: - r = process_each_pv_in_vg(vg->cmd, vg, handle, - do_lv_info && !do_lv_seg_status ? &_pvsegs_with_lv_info_single : - !do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_status_single : - do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_info_and_status_single : - &_pvsegs_single); - break; - default: - log_error(INTERNAL_ERROR "%s for VGS", incorrect_report_type_msg); - break; - } + r = _report_all_in_vg(cmd, handle, vg, sh->report_type, do_lv_info, do_lv_seg_status); break; case PVS: - switch (sh->report_type) { - case PVS: - r = _pvs_single(vg->cmd, vg, pv, handle); - break; - case PVSEGS: - r = process_each_segment_in_pv(vg->cmd, vg, pv, handle, - do_lv_info && !do_lv_seg_status ? &_pvsegs_with_lv_info_sub_single : - !do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_status_sub_single : - do_lv_info && do_lv_seg_status ? &_pvsegs_with_lv_info_and_status_sub_single : - &_pvsegs_sub_single); - break; - default: - log_error(INTERNAL_ERROR "%s for PVS", incorrect_report_type_msg); - break; - } + r = _report_all_in_pv(cmd, handle, pv, sh->report_type, do_lv_info, do_lv_seg_status); break; default: - log_error(INTERNAL_ERROR "%s", incorrect_report_type_msg); + log_error(INTERNAL_ERROR "report_for_selection: incorrect report type"); break; }

1 0

master - tests: lvmetad-lvm1 fix
by David Teigland 13 Apr '16

13 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=9a299d2d7a047597… Commit: 9a299d2d7a04759749bd6c01a86b90fd13f27b96 Parent: 579bd9200950a438af9d842f5d0cbaf049bd87c9 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Apr 13 15:07:53 2016 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Apr 13 15:07:53 2016 -0500 tests: lvmetad-lvm1 fix workaround this test failure until the proper lvmetad/lvm1 fixes arrive shortly. --- test/shell/lvmetad-lvm1.sh | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/shell/lvmetad-lvm1.sh b/test/shell/lvmetad-lvm1.sh index 7a93f74..9720833 100644 --- a/test/shell/lvmetad-lvm1.sh +++ b/test/shell/lvmetad-lvm1.sh @@ -19,11 +19,11 @@ SKIP_WITH_LVMPOLLD=1 aux prepare_devs 2 pvcreate --metadatatype 1 "$dev1" -not vgscan --cache +vgscan --cache pvs | tee out not grep "$dev1" out vgcreate --metadatatype 1 $vg1 "$dev1" -not vgscan --cache +vgscan --cache vgs | tee out not grep $vg1 out pvs | tee out

1 0

master - lvmetad: add FIXME to comment
by David Teigland 13 Apr '16

13 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=579bd9200950a438… Commit: 579bd9200950a438af9d842f5d0cbaf049bd87c9 Parent: 56c68b3476f52a07c877496a07ebef619724e224 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Apr 13 14:08:29 2016 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Apr 13 14:08:29 2016 -0500 lvmetad: add FIXME to comment --- lib/cache/lvmetad.c | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/cache/lvmetad.c b/lib/cache/lvmetad.c index 8cc804a..7ca5d4a 100644 --- a/lib/cache/lvmetad.c +++ b/lib/cache/lvmetad.c @@ -296,9 +296,9 @@ retry: * If lvmetad is still being updated after the timeout period, * then disable this command's use of lvmetad. * - * (lvmetad could return the number of objects in its cache along with + * FIXME: lvmetad could return the number of objects in its cache along with * the update message so that callers could detect when a rescan has - * stalled while updating lvmetad.) + * stalled while updating lvmetad. */ if (!strcmp(daemon_token, "update in progress")) { if (!(now = _monotonic_seconds()))

1 0

master - lvmetad: preemptively check and rescan in commands
by David Teigland 13 Apr '16

13 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=56c68b3476f52a07… Commit: 56c68b3476f52a07c877496a07ebef619724e224 Parent: a28c81cbae308e371ece31679615d673b29fccec Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jan 28 16:40:26 2016 -0600 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Apr 13 14:05:42 2016 -0500 lvmetad: preemptively check and rescan in commands Move checking the lvmetad state, and the possible rescan, out of lvmetad_send() to the start of the command. Previously, the token mismatch and rescan would occur within lvmetad_send() for some other request. Now, the token mismatch is detected earlier, so the rescan can be done before the main command is in progress. Rescanning deep within the processing of another command will disturb the lvmcache state of that other command. A rescan already exists at the start of the command for the case where foreign VGs are going to be read. This same rescan is now also performed when there is an lvmetad token mismatch (from a changed global_filter). The commands pvscan/vgscan/lvscan/vgimport are excluded from this preemptive checking/rescanning for lvmetad because they want to do rescanning themselves explicitly. If rescanning devices fails, then lvmetad has not been correctly repopulated and should not be used, so make the command revert to not using lvmetad. --- daemons/lvmetad/lvmetad-core.c | 21 ++- lib/cache/lvmetad.c | 571 +++++++++++++++++++++++++++++++++------- lib/cache/lvmetad.h | 6 +- lib/config/config_settings.h | 5 + lib/config/defaults.h | 1 + tools/commands.h | 8 +- tools/lvmcmdline.c | 25 ++- tools/lvscan.c | 20 ++- tools/pvscan.c | 30 ++- tools/tools.h | 2 + tools/vgimport.c | 8 +- tools/vgscan.c | 21 +- 12 files changed, 593 insertions(+), 125 deletions(-) diff --git a/daemons/lvmetad/lvmetad-core.c b/daemons/lvmetad/lvmetad-core.c index 5374c0a..090255a 100644 --- a/daemons/lvmetad/lvmetad-core.c +++ b/daemons/lvmetad/lvmetad-core.c @@ -2614,10 +2614,25 @@ static response set_global_info(lvmetad_state *s, request r) return daemon_reply_simple("OK", NULL); } +#define REASON_BUF_SIZE 64 + +/* + * FIXME: save the time when "updating" begins, and add a config setting for + * how long we'll allow an update to take. Before returning "updating" as the + * token value in get_global_info, check if the update has exceeded the max + * allowed time. If so, then clear the current cache state and return "none" + * as the current token value, so that the command will repopulate our cache. + * + * This will resolve the problem of a command starting to update the cache and + * then failing, leaving the token set to "update in progress". + */ + static response get_global_info(lvmetad_state *s, request r) { return daemon_reply_simple("OK", "global_invalid = " FMTd64, (int64_t)((s->flags & GLFL_INVALID) ? 1 : 0), + "token = %s", + s->token[0] ? s->token : "none", NULL); } @@ -2815,13 +2830,17 @@ static response handler(daemon_state s, client_handle h, request r) lvmetad_state *state = s.private; const char *rq = daemon_request_str(r, "request", "NONE"); const char *token = daemon_request_str(r, "token", "NONE"); + char prev_token[128] = { 0 }; pthread_mutex_lock(&state->token_lock); if (!strcmp(rq, "token_update")) { + memcpy(prev_token, state->token, 128); strncpy(state->token, token, 128); state->token[127] = 0; pthread_mutex_unlock(&state->token_lock); - return daemon_reply_simple("OK", NULL); + return daemon_reply_simple("OK", + "prev_token = %s", prev_token, + NULL); } if (strcmp(token, state->token) && strcmp(rq, "dump") && strcmp(token, "skip")) { diff --git a/lib/cache/lvmetad.c b/lib/cache/lvmetad.c index a483e04..8cc804a 100644 --- a/lib/cache/lvmetad.c +++ b/lib/cache/lvmetad.c @@ -24,6 +24,8 @@ #include "lvm-signal.h" #include "lvmlockd.h" +#include <time.h> + #define SCAN_TIMEOUT_SECONDS 80 #define MAX_RESCANS 10 /* Maximum number of times to scan all PVs and retry if the daemon returns a token mismatch error */ @@ -37,6 +39,15 @@ static struct cmd_context *_lvmetad_cmd = NULL; static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct volume_group *vg); +static uint64_t _monotonic_seconds(void) +{ + struct timespec ts; + + if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) + return 0; + return ts.tv_sec; +} + static int _log_debug_inequality(const char *name, struct dm_config_node *a, struct dm_config_node *b) { int result = 0; @@ -132,6 +143,9 @@ static void _lvmetad_connect(void) _lvmetad.socket_fd); _lvmetad_connected = 1; } + + if (!_lvmetad_connected) + _lvmetad_use = 0; } void lvmetad_connect_or_warn(void) @@ -145,6 +159,9 @@ void lvmetad_connect_or_warn(void) if ((_lvmetad.socket_fd < 0 || _lvmetad.error)) log_warn("WARNING: Failed to connect to lvmetad. Falling back to internal scanning."); } + + if (!_lvmetad_connected) + _lvmetad_use = 0; } int lvmetad_used(void) @@ -210,82 +227,314 @@ void lvmetad_set_socket(const char *sock) _lvmetad_socket = sock; } +/* + * Check if lvmetad's token matches our token. The token is a hash of the + * global filter used to populate lvmetad. The lvmetad token was set by the + * last command to populate lvmetad, and it was set to the hash of the global + * filter that command used when scanning to populate lvmetad. + * + * Our token is a hash of the global filter this command is using. + * + * If the lvmetad token is not set (or "none"), then lvmetad has not been + * populated. If the lvmetad token is "update in progress", then lvmetad is + * currently being populated -- this should be temporary, so wait for a while + * for the current update to finish and then compare our token with the new one + * (hopefully it will match). If the lvmetad token otherwise differs from + * ours, then lvmetad was populated using a different global filter that we are + * using. + * + * Return 1 if the lvmetad token matches ours. We can use it as is. + * + * Return 0 if the lvmetad token does not match ours (lvmetad is empty or + * populated using a different global filter). The caller will repopulate + * lvmetad (via lvmetad_pvscan_all_devs) before using lvmetad. + * + * If we time out waiting for an lvmetad update to finish, then disable this + * command's use of lvmetad and return 0. + */ + +int lvmetad_token_matches(struct cmd_context *cmd) +{ + daemon_reply reply; + const char *daemon_token; + unsigned int delay_usec = 0; + unsigned int wait_sec = 0; + uint64_t now = 0, wait_start = 0; + int ret = 1; + + wait_sec = (unsigned int)find_config_tree_int(cmd, global_lvmetad_update_wait_time_CFG, NULL); + +retry: + log_debug_lvmetad("lvmetad send get_global_info"); + + reply = daemon_send_simple(_lvmetad, "get_global_info", + "token = %s", "skip", + NULL); + if (reply.error) { + log_warn("WARNING: Not using lvmetad after send error (%d).", reply.error); + goto fail; + } + + if (strcmp(daemon_reply_str(reply, "response", ""), "OK")) { + log_warn("WARNING: Not using lvmetad after response error."); + goto fail; + } + + if (!(daemon_token = daemon_reply_str(reply, "token", NULL))) { + log_warn("WARNING: Not using lvmetad with older version."); + goto fail; + } + + /* + * If lvmetad is being updated by another command, then sleep and retry + * until the token shows the update is done, and go on to the token + * comparison. + * + * Between retries, sleep for a random period between 1 and 2 seconds. + * Retry in this way for up to a configurable period of time. + * + * If lvmetad is still being updated after the timeout period, + * then disable this command's use of lvmetad. + * + * (lvmetad could return the number of objects in its cache along with + * the update message so that callers could detect when a rescan has + * stalled while updating lvmetad.) + */ + if (!strcmp(daemon_token, "update in progress")) { + if (!(now = _monotonic_seconds())) + goto fail; + + if (!wait_start) + wait_start = now; + + if (now - wait_start >= wait_sec) { + log_warn("WARNING: Not using lvmetad after %u sec lvmetad_update_wait_time.", wait_sec); + goto fail; + } + + log_warn("WARNING: lvmetad is being updated, retrying (setup) for %u more seconds.", + wait_sec - (unsigned int)(now - wait_start)); + + /* Delay a random period between 1 and 2 seconds. */ + delay_usec = 1000000 + lvm_even_rand(&_lvmetad_cmd->rand_seed, 1000000); + usleep(delay_usec); + daemon_reply_destroy(reply); + goto retry; + } + + /* + * lvmetad is empty, not yet populated. + * The caller should do a disk scan to populate lvmetad. + */ + if (!strcmp(daemon_token, "none")) { + ret = 0; + goto out; + } + + /* + * lvmetad has an unmatching token; it was last populated using + * a different global filter. + * The caller should do a disk scan to populate lvmetad with + * our global filter. + */ + if (strcmp(daemon_token, _lvmetad_token)) { + ret = 0; + goto out; + } + +out: + daemon_reply_destroy(reply); + return ret; + +fail: + daemon_reply_destroy(reply); + /* The command will not use lvmetad and will revert to scanning. */ + lvmetad_set_active(cmd, 0); + return 0; +} + +/* + * Wait up to lvmetad_update_wait_time for the lvmetad updating state to be + * finished. + * + * Return 0 if lvmetad is not updating or there's an error and we can't tell. + * Return 1 if lvmetad is updating. + */ +static int _lvmetad_is_updating(struct cmd_context *cmd, int do_wait) +{ + daemon_reply reply; + const char *daemon_token; + unsigned int wait_sec = 0; + uint64_t now = 0, wait_start = 0; + int ret = 0; + + wait_sec = (unsigned int)find_config_tree_int(cmd, global_lvmetad_update_wait_time_CFG, NULL); +retry: + log_debug_lvmetad("lvmetad send get_global_info"); + + reply = daemon_send_simple(_lvmetad, "get_global_info", + "token = %s", "skip", + NULL); + if (reply.error) + goto out; + + if (strcmp(daemon_reply_str(reply, "response", ""), "OK")) + goto out; + + if (!(daemon_token = daemon_reply_str(reply, "token", NULL))) + goto out; + + if (!strcmp(daemon_token, "update in progress")) { + ret = 1; + + if (!do_wait) + goto out; + + if (!(now = _monotonic_seconds())) + goto out; + + if (!wait_start) + wait_start = now; + + if (now - wait_start >= wait_sec) + goto out; + + log_warn("WARNING: lvmetad is being updated, waiting for %u more seconds.", + wait_sec - (unsigned int)(now - wait_start)); + + usleep(1000000); + daemon_reply_destroy(reply); + goto retry; + } else { + ret = 0; + } + +out: + daemon_reply_destroy(reply); + return ret; +} + static int _lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler, - int ignore_obsolete); + int ignore_obsolete, int do_wait); -static daemon_reply _lvmetad_send(const char *id, ...) +static daemon_reply _lvmetad_send(struct cmd_context *cmd, const char *id, ...) { va_list ap; - daemon_reply repl = { 0 }; + daemon_reply reply = { 0 }; daemon_request req; - unsigned num_rescans = 0; - unsigned total_usecs_waited = 0; - unsigned max_remaining_sleep_times = 1; - unsigned wait_usecs; + unsigned int delay_usec; + unsigned int wait_sec = 0; + uint64_t now = 0, wait_start = 0; + if (cmd) + wait_sec = (unsigned int)find_config_tree_int(cmd, global_lvmetad_update_wait_time_CFG, NULL); retry: + log_debug_lvmetad("lvmetad_send %s", id); + req = daemon_request_make(id); if (_lvmetad_token && !daemon_request_extend(req, "token = %s", _lvmetad_token, NULL)) { - repl.error = ENOMEM; - return repl; + reply.error = ENOMEM; + return reply; } va_start(ap, id); daemon_request_extend_v(req, ap); va_end(ap); - repl = daemon_send(_lvmetad, req); + reply = daemon_send(_lvmetad, req); daemon_request_destroy(req); - /* - * If another process is trying to scan, it might have the - * same future token id and it's better to wait and avoid doing - * the work multiple times. For the case where the future token is - * different, the wait is randomized so that multiple waiting - * processes do not start scanning all at once. - * - * If the token is mismatched because of global_filter changes, - * we re-scan immediately, but if we lose the potential race for - * the update, we back off for a short while (0.05-0.5 seconds) and - * try again. - */ - if (!repl.error && !strcmp(daemon_reply_str(repl, "response", ""), "token_mismatch") && - num_rescans < MAX_RESCANS && total_usecs_waited < (SCAN_TIMEOUT_SECONDS * 1000000) && !test_mode()) { - if (!strcmp(daemon_reply_str(repl, "expected", ""), "update in progress") || - max_remaining_sleep_times) { - wait_usecs = 50000 + lvm_even_rand(&_lvmetad_cmd->rand_seed, 450000); /* between 0.05s and 0.5s */ - (void) usleep(wait_usecs); - total_usecs_waited += wait_usecs; - if (max_remaining_sleep_times) - max_remaining_sleep_times--; /* Sleep once before rescanning the first time, then 5 times each time after that. */ + if (reply.error) + goto out; + + if (!strcmp(daemon_reply_str(reply, "response", ""), "token_mismatch")) { + if (!strcmp(daemon_reply_str(reply, "expected", ""), "update in progress")) { + /* + * Another command is updating the lvmetad cache, and + * we cannot use lvmetad until the update is finished. + * Retry our request for a while; the update should + * finish shortly. This should not usually happen + * because this command already checked that the token + * is usable in lvmetad_token_matches(), but it's + * possible for another command's rescan to slip in + * between the time we call lvmetad_token_matches() + * and the time we get here to lvmetad_send(). + */ + if (!(now = _monotonic_seconds())) + goto out; + + if (!wait_start) + wait_start = now; + + if (!wait_sec || (now - wait_start >= wait_sec)) { + log_warn("WARNING: Cannot use lvmetad after %u sec lvmetad_update_wait_time.", wait_sec); + goto out; + } + + log_warn("WARNING: lvmetad is being updated, retrying (%s) for %u more seconds.", + id, wait_sec - (unsigned int)(now - wait_start)); + + /* Delay a random period between 1 and 2 seconds. */ + delay_usec = 1000000 + lvm_even_rand(&_lvmetad_cmd->rand_seed, 1000000); + usleep(delay_usec); + daemon_reply_destroy(reply); + goto retry; } else { - /* If the re-scan fails here, we try again later. */ - (void) _lvmetad_pvscan_all_devs(_lvmetad_cmd, NULL, 0); - num_rescans++; - max_remaining_sleep_times = 5; + /* + * Another command has updated the lvmetad cache, and + * has done so using a different device filter from our + * own, which has made the lvmetad token and our token + * not match. This should not usually happen because + * this command has already checked for a matching token + * in lvmetad_token_matches(), but it's possible for + * another command's rescan to slip in between the time + * we call lvmetad_token_matches() and the time we get + * here to lvmetad_send(). With a mismatched token + * (different set of devices), we cannot use the lvmetad + * cache. + * + * FIXME: it would be nice to have this command ignore + * lvmetad at this point and revert to disk scanning, + * but the layers above lvmetad_send are not yet able + * to switch modes in the middle of processing. + * + * (The advantage of lvmetad_check_token is that it + * can rescan to get the token in sync, or if that + * fails it can make the command revert to scanning + * from the start.) + */ + log_warn("WARNING: Cannot use lvmetad while it caches different devices."); } - daemon_reply_destroy(repl); - goto retry; } - - return repl; +out: + return reply; } -static int _token_update(void) +static int _token_update(int *replaced_update) { - daemon_reply repl; + daemon_reply reply; + const char *prev_token; log_debug_lvmetad("Sending updated token to lvmetad: %s", _lvmetad_token ? : "<NONE>"); - repl = _lvmetad_send("token_update", NULL); + reply = _lvmetad_send(NULL, "token_update", NULL); + + if (replaced_update) + *replaced_update = 0; - if (repl.error || strcmp(daemon_reply_str(repl, "response", ""), "OK")) { - daemon_reply_destroy(repl); + if (reply.error || strcmp(daemon_reply_str(reply, "response", ""), "OK")) { + daemon_reply_destroy(reply); return 0; } - daemon_reply_destroy(repl); + if ((prev_token = daemon_reply_str(reply, "prev_token", NULL))) { + if (!strcmp(prev_token, "update in progress")) + if (replaced_update) + *replaced_update = 1; + } + + daemon_reply_destroy(reply); return 1; } @@ -297,13 +546,68 @@ static int _token_update(void) * If found is set, *found indicates whether or not device exists, * and missing device is not treated as an error. */ -static int _lvmetad_handle_reply(daemon_reply reply, const char *action, const char *object, - int *found) +static int _lvmetad_handle_reply(daemon_reply reply, const char *id, const char *object, int *found) { + int action_modifies = 0; + const char *action; + + if (!id) + action = "<none>"; + else if (!strcmp(id, "pv_list")) + action = "list PVs"; + else if (!strcmp(id, "vg_list")) + action = "list VGs"; + else if (!strcmp(id, "vg_lookup")) + action = "lookup VG"; + else if (!strcmp(id, "pv_lookup")) + action = "lookup PV"; + else if (!strcmp(id, "pv_clear_all")) + action = "clear info about all PVs"; + else if (!strcmp(id, "vg_clear_outdated_pvs")) + action = "clear the list of outdated PVs"; + else if (!strcmp(id, "vg_update")) { + action = "update VG"; + action_modifies = 1; + } else if (!strcmp(id, "vg_remove")) { + action = "remove VG"; + action_modifies = 1; + } else if (!strcmp(id, "pv_found")) { + action = "update PV"; + action_modifies = 1; + } else if (!strcmp(id, "pv_gone")) { + action = "drop PV"; + action_modifies = 1; + } else { + log_error(INTERNAL_ERROR "Unchecked lvmetad message %s.", id); + action = "action unknown"; + } + if (reply.error) { log_error("Request to %s %s%sin lvmetad gave response %s.", action, object, *object ? " " : "", strerror(reply.error)); - return 0; + goto fail; + } + + /* + * See the description of the token mismatch errors in lvmetad_send. + */ + if (!strcmp(daemon_reply_str(reply, "response", ""), "token_mismatch")) { + if (!strcmp(daemon_reply_str(reply, "expected", ""), "update in progress")) { + /* + * lvmetad_send retried up to the limit and eventually + * printed a warning and gave up. + */ + log_error("Request to %s %s%sin lvmetad failed after lvmetad_update_wait_time expired.", + action, object, *object ? " " : ""); + } else { + /* + * lvmetad is caching different devices based on a different + * device filter which causes a token mismatch. + */ + log_error("Request to %s %s%sin lvmetad failed after device filter mismatch.", + action, object, *object ? " " : ""); + } + goto fail; } /* All OK? */ @@ -330,10 +634,23 @@ static int _lvmetad_handle_reply(daemon_reply reply, const char *action, const c return 1; } + /* + * Generic error message for error cases not specifically checked above. + */ log_error("Request to %s %s%sin lvmetad gave response %s. Reason: %s", action, object, *object ? " " : "", daemon_reply_str(reply, "response", "<missing>"), daemon_reply_str(reply, "reason", "<missing>")); +fail: + /* + * If the failed lvmetad message was updating lvmetad, it is important + * to restart lvmetad (or at least rescan.) + * + * FIXME: attempt to set the disabled state in lvmetad here so that + * commands will not use it until it's been properly repopulated. + */ + if (action_modifies) + log_error("lvmetad update failed. Restart lvmetad immediately."); return 0; } @@ -537,7 +854,7 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, const char *vgna if (vgid && vgname) { log_debug_lvmetad("Asking lvmetad for VG %s %s", uuid, vgname); - reply = _lvmetad_send("vg_lookup", + reply = _lvmetad_send(cmd, "vg_lookup", "uuid = %s", uuid, "name = %s", vgname, NULL); @@ -545,12 +862,12 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, const char *vgna } else if (vgid) { log_debug_lvmetad("Asking lvmetad for VG vgid %s", uuid); - reply = _lvmetad_send("vg_lookup", "uuid = %s", uuid, NULL); + reply = _lvmetad_send(cmd, "vg_lookup", "uuid = %s", uuid, NULL); diag_name = uuid; } else if (vgname) { log_debug_lvmetad("Asking lvmetad for VG %s", vgname); - reply = _lvmetad_send("vg_lookup", "name = %s", vgname, NULL); + reply = _lvmetad_send(cmd, "vg_lookup", "name = %s", vgname, NULL); diag_name = vgname; } else { @@ -558,7 +875,7 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, const char *vgna goto out; } - if (_lvmetad_handle_reply(reply, "lookup VG", diag_name, &found) && found) { + if (_lvmetad_handle_reply(reply, "vg_lookup", diag_name, &found) && found) { if ((found == 2) && vgname) { log_error("Multiple VGs found with the same name: %s.", vgname); @@ -718,10 +1035,10 @@ int lvmetad_vg_update(struct volume_group *vg) } log_debug_lvmetad("Sending lvmetad updated metadata for VG %s (seqno %" PRIu32 ")", vg->name, vg->seqno); - reply = _lvmetad_send("vg_update", "vgname = %s", vg->name, + reply = _lvmetad_send(vg->cmd, "vg_update", "vgname = %s", vg->name, "metadata = %t", vg->cft_precommitted, NULL); - if (!_lvmetad_handle_reply(reply, "update VG", vg->name, NULL)) { + if (!_lvmetad_handle_reply(reply, "vg_update", vg->name, NULL)) { daemon_reply_destroy(reply); return 0; } @@ -770,8 +1087,8 @@ int lvmetad_vg_remove(struct volume_group *vg) return_0; log_debug_lvmetad("Telling lvmetad to remove VGID %s (%s)", uuid, vg->name); - reply = _lvmetad_send("vg_remove", "uuid = %s", uuid, NULL); - result = _lvmetad_handle_reply(reply, "remove VG", vg->name, NULL); + reply = _lvmetad_send(vg->cmd, "vg_remove", "uuid = %s", uuid, NULL); + result = _lvmetad_handle_reply(reply, "vg_remove", vg->name, NULL); daemon_reply_destroy(reply); @@ -792,8 +1109,8 @@ int lvmetad_pv_lookup(struct cmd_context *cmd, struct id pvid, int *found) return_0; log_debug_lvmetad("Asking lvmetad for PV %s", uuid); - reply = _lvmetad_send("pv_lookup", "uuid = %s", uuid, NULL); - if (!_lvmetad_handle_reply(reply, "lookup PV", "", found)) + reply = _lvmetad_send(cmd, "pv_lookup", "uuid = %s", uuid, NULL); + if (!_lvmetad_handle_reply(reply, "pv_lookup", "", found)) goto_out; if (found && !*found) @@ -823,8 +1140,8 @@ int lvmetad_pv_lookup_by_dev(struct cmd_context *cmd, struct device *dev, int *f return_0; log_debug_lvmetad("Asking lvmetad for PV on %s", dev_name(dev)); - reply = _lvmetad_send("pv_lookup", "device = %" PRId64, (int64_t) dev->dev, NULL); - if (!_lvmetad_handle_reply(reply, "lookup PV", dev_name(dev), found)) + reply = _lvmetad_send(cmd, "pv_lookup", "device = %" PRId64, (int64_t) dev->dev, NULL); + if (!_lvmetad_handle_reply(reply, "pv_lookup", dev_name(dev), found)) goto_out; if (found && !*found) @@ -852,8 +1169,8 @@ int lvmetad_pv_list_to_lvmcache(struct cmd_context *cmd) return 1; log_debug_lvmetad("Asking lvmetad for complete list of known PVs"); - reply = _lvmetad_send("pv_list", NULL); - if (!_lvmetad_handle_reply(reply, "list PVs", "", NULL)) { + reply = _lvmetad_send(cmd, "pv_list", NULL); + if (!_lvmetad_handle_reply(reply, "pv_list", "", NULL)) { daemon_reply_destroy(reply); return_0; } @@ -877,8 +1194,8 @@ int lvmetad_get_vgnameids(struct cmd_context *cmd, struct dm_list *vgnameids) struct dm_config_node *cn; log_debug_lvmetad("Asking lvmetad for complete list of known VG ids/names"); - reply = _lvmetad_send("vg_list", NULL); - if (!_lvmetad_handle_reply(reply, "list VGs", "", NULL)) { + reply = _lvmetad_send(cmd, "vg_list", NULL); + if (!_lvmetad_handle_reply(reply, "vg_list", "", NULL)) { daemon_reply_destroy(reply); return_0; } @@ -930,8 +1247,8 @@ int lvmetad_vg_list_to_lvmcache(struct cmd_context *cmd) return 1; log_debug_lvmetad("Asking lvmetad for complete list of known VGs"); - reply = _lvmetad_send("vg_list", NULL); - if (!_lvmetad_handle_reply(reply, "list VGs", "", NULL)) { + reply = _lvmetad_send(cmd, "vg_list", NULL); + if (!_lvmetad_handle_reply(reply, "vg_list", "", NULL)) { daemon_reply_destroy(reply); return_0; } @@ -1089,7 +1406,7 @@ int lvmetad_pv_found(const struct id *pvid, struct device *dev, const struct for } log_debug_lvmetad("Telling lvmetad to store PV %s (%s) in VG %s", dev_name(dev), uuid, vg->name); - reply = _lvmetad_send("pv_found", + reply = _lvmetad_send(vg->cmd, "pv_found", "pvmeta = %t", pvmeta, "vgname = %s", vg->name, "metadata = %t", vgmeta, @@ -1101,12 +1418,12 @@ int lvmetad_pv_found(const struct id *pvid, struct device *dev, const struct for * It might or might not be an orphan. */ log_debug_lvmetad("Telling lvmetad to store PV %s (%s)", dev_name(dev), uuid); - reply = _lvmetad_send("pv_found", "pvmeta = %t", pvmeta, NULL); + reply = _lvmetad_send(NULL, "pv_found", "pvmeta = %t", pvmeta, NULL); } dm_config_destroy(pvmeta); - result = _lvmetad_handle_reply(reply, "update PV", uuid, NULL); + result = _lvmetad_handle_reply(reply, "pv_found", uuid, NULL); if (vg && result && (daemon_reply_int(reply, "seqno_after", -1) != vg->seqno || @@ -1196,9 +1513,9 @@ int lvmetad_pv_gone(dev_t devno, const char *pv_name, activation_handler handler */ log_debug_lvmetad("Telling lvmetad to forget any PV on %s", pv_name); - reply = _lvmetad_send("pv_gone", "device = %" PRId64, (int64_t) devno, NULL); + reply = _lvmetad_send(NULL, "pv_gone", "device = %" PRId64, (int64_t) devno, NULL); - result = _lvmetad_handle_reply(reply, "drop PV", pv_name, &found); + result = _lvmetad_handle_reply(reply, "pv_gone", pv_name, &found); /* We don't care whether or not the daemon had the PV cached. */ daemon_reply_destroy(reply); @@ -1431,15 +1748,36 @@ int lvmetad_pvscan_single(struct cmd_context *cmd, struct device *dev, return 1; bad: - /* FIXME kill lvmetad automatically if we can */ - log_error("Update of lvmetad failed. This is a serious problem.\n" - "It is strongly recommended that you restart lvmetad immediately."); - return 0; } +/* + * Update the lvmetad cache: clear the current lvmetad cache, and scan all + * devs, sending all info from the devs to lvmetad. + * + * We want only one command to be doing this at a time. When do_wait is set, + * this will first check if lvmetad is currently being updated by another + * command, and if so it will delay until that update is finished, or until a + * timeout, at which point it will go ahead and do the lvmetad update. + * + * Callers that have already checked and waited for the updating state, e.g. by + * using lvmetad_token_matches(), will generaly set do_wait to 0. Callers that + * have not checked for the updating state yet will generally set do_wait to 1. + * + * If another command doing an update failed, it left lvmetad in the "update in + * progess" state, so we can't just wait until that state has cleared, but have + * to go ahead after a timeout. + * + * The _lvmetad_is_updating check avoids most races to update lvmetad from + * multiple commands (which shouldn't generally happen anway) but does not + * eliminate them. If an update race happens, the second will see that the + * previous token was "update in progress" when it calls _token_update(). It + * will then fail, and the command calling lvmetad_pvscan_all_devs() will + * generally revert disk scanning and not use lvmetad. + */ + static int _lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler, - int ignore_obsolete) + int ignore_obsolete, int do_wait) { struct dev_iter *iter; struct device *dev; @@ -1447,12 +1785,27 @@ static int _lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler int r = 1; char *future_token; int was_silent; + int replacing_other_update = 0; + int replaced_update = 0; + int retries = 0; if (!lvmetad_active()) { log_error("Cannot proceed since lvmetad is not active."); return 0; } + retry: + /* + * If another update is in progress, delay to allow it to finish, + * rather than interrupting it with our own update. + */ + if (do_wait && _lvmetad_is_updating(cmd, 1)) { + log_warn("WARNING: lvmetad update is interrupting another update in progress."); + replacing_other_update = 1; + } + + log_verbose("Scanning all devices to update lvmetad."); + if (!(iter = dev_iter_create(cmd->lvmetad_filter, 1))) { log_error("dev_iter creation failed"); return 0; @@ -1460,15 +1813,38 @@ static int _lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler future_token = _lvmetad_token; _lvmetad_token = (char *) "update in progress"; - if (!_token_update()) { + + if (!_token_update(&replaced_update)) { + log_error("Failed to update lvmetad which had an update in progress."); + dev_iter_destroy(iter); + _lvmetad_token = future_token; + return 0; + } + + /* + * if _token_update() sets replaced_update to 1, it means that we set + * "update in progress" when the lvmetad was already set to "udpate in + * progress". This detects a race between two commands doing updates + * at once. The attempt above to avoid this race using + * _lvmetad_is_updating isn't perfect. + */ + if (!replacing_other_update && replaced_update) { + if (do_wait && !retries) { + retries = 1; + log_warn("WARNING: lvmetad update in progress, retry update."); + dev_iter_destroy(iter); + _lvmetad_token = future_token; + goto retry; + } + log_error("Concurrent lvmetad updates failed."); dev_iter_destroy(iter); _lvmetad_token = future_token; return 0; } log_debug_lvmetad("Telling lvmetad to clear its cache"); - reply = _lvmetad_send("pv_clear_all", NULL); - if (!_lvmetad_handle_reply(reply, "clear info about all PVs", "", NULL)) + reply = _lvmetad_send(cmd, "pv_clear_all", NULL); + if (!_lvmetad_handle_reply(reply, "pv_clear_all", "", NULL)) r = 0; daemon_reply_destroy(reply); @@ -1490,15 +1866,15 @@ static int _lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler dev_iter_destroy(iter); _lvmetad_token = future_token; - if (!_token_update()) + if (!_token_update(NULL)) return 0; return r; } -int lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler) +int lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler, int do_wait) { - return _lvmetad_pvscan_all_devs(cmd, handler, 0); + return _lvmetad_pvscan_all_devs(cmd, handler, 0, do_wait); } /* @@ -1507,7 +1883,7 @@ int lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler) */ int lvmetad_pvscan_foreign_vgs(struct cmd_context *cmd, activation_handler handler) { - return _lvmetad_pvscan_all_devs(cmd, handler, 1); + return _lvmetad_pvscan_all_devs(cmd, handler, 1, 1); } int lvmetad_vg_clear_outdated_pvs(struct volume_group *vg) @@ -1519,8 +1895,8 @@ int lvmetad_vg_clear_outdated_pvs(struct volume_group *vg) if (!id_write_format(&vg->id, uuid, sizeof(uuid))) return_0; - reply = _lvmetad_send("vg_clear_outdated_pvs", "vgid = %s", uuid, NULL); - result = _lvmetad_handle_reply(reply, "clear the list of outdated PVs", vg->name, NULL); + reply = _lvmetad_send(vg->cmd, "vg_clear_outdated_pvs", "vgid = %s", uuid, NULL); + result = _lvmetad_handle_reply(reply, "vg_clear_outdated_pvs", vg->name, NULL); daemon_reply_destroy(reply); return result; @@ -1555,9 +1931,8 @@ static int _lvmetad_get_pv_cache_list(struct cmd_context *cmd, struct dm_list *p log_debug_lvmetad("Asking lvmetad for complete list of known PVs"); - reply = _lvmetad_send("pv_list", NULL); - if (!_lvmetad_handle_reply(reply, "list PVs", "", NULL)) { - log_error("lvmetad message failed."); + reply = _lvmetad_send(cmd, "pv_list", NULL); + if (!_lvmetad_handle_reply(reply, "pv_list", "", NULL)) { daemon_reply_destroy(reply); return_0; } @@ -1752,6 +2127,8 @@ void lvmetad_validate_global_cache(struct cmd_context *cmd, int force) if (force) goto do_scan; + log_debug_lvmetad("lvmetad validate send get_global_info"); + reply = daemon_send_simple(_lvmetad, "get_global_info", "token = %s", "skip", NULL); @@ -1782,10 +2159,18 @@ void lvmetad_validate_global_cache(struct cmd_context *cmd, int force) /* * Update the local lvmetad cache so it correctly reflects any - * changes made on remote hosts. + * changes made on remote hosts. (It's possible that this command + * already refreshed the local lvmetad because of a token change, + * but we need to do it again here since we now hold the global + * lock. Another host may have changed things between the time + * we rescanned for the token, and the time we acquired the global + * lock.) */ - if (!lvmetad_pvscan_all_devs(cmd, NULL)) - stack; /* FIXME: Anything more on this error path ? */ + if (!lvmetad_pvscan_all_devs(cmd, NULL, 1)) { + log_warn("WARNING: Not using lvmetad because cache update failed."); + lvmetad_set_active(cmd, 0); + return; + } /* * Clear the global_invalid flag in lvmetad. @@ -1793,6 +2178,8 @@ void lvmetad_validate_global_cache(struct cmd_context *cmd, int force) * from lvmetad will not see global_invalid until * another host makes another global change. */ + log_debug_lvmetad("lvmetad validate send set_global_info"); + reply = daemon_send_simple(_lvmetad, "set_global_info", "token = %s", "skip", "global_invalid = " FMTd64, INT64_C(0), @@ -1842,7 +2229,7 @@ int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const cha if (!id_write_format((const struct id*)vgid, uuid, sizeof(uuid))) return_0; - reply = _lvmetad_send("vg_lookup", + reply = _lvmetad_send(cmd, "vg_lookup", "uuid = %s", uuid, "name = %s", vgname, NULL); diff --git a/lib/cache/lvmetad.h b/lib/cache/lvmetad.h index ce4affa..5820956 100644 --- a/lib/cache/lvmetad.h +++ b/lib/cache/lvmetad.h @@ -163,11 +163,12 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, int lvmetad_pvscan_single(struct cmd_context *cmd, struct device *dev, activation_handler handler, int ignore_obsolete); -int lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler); +int lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler, int do_wait); int lvmetad_pvscan_foreign_vgs(struct cmd_context *cmd, activation_handler handler); int lvmetad_vg_clear_outdated_pvs(struct volume_group *vg); void lvmetad_validate_global_cache(struct cmd_context *cmd, int force); +int lvmetad_token_matches(struct cmd_context *cmd); int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const char *vgid); @@ -195,11 +196,12 @@ int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const cha # define lvmetad_get_vgnameids(cmd, vgnameids) do { } while (0) # define lvmetad_vg_lookup(cmd, vgname, vgid) (NULL) # define lvmetad_pvscan_single(cmd, dev, handler, ignore_obsolete) (0) -# define lvmetad_pvscan_all_devs(cmd, handler) (0) +# define lvmetad_pvscan_all_devs(cmd, handler, do_wait) (0) # define lvmetad_pvscan_foreign_vgs(cmd, handler) (0) # define lvmetad_vg_clear_outdated_pvs(vg) (1) # define lvmetad_validate_global_cache(cmd, force) do { } while (0) # define lvmetad_vg_is_foreign(cmd, vgname, vgid) (0) +# define lvmetad_token_matches(cmd) (1) # endif /* LVMETAD_SUPPORT */ diff --git a/lib/config/config_settings.h b/lib/config/config_settings.h index 330e223..5d5ac48 100644 --- a/lib/config/config_settings.h +++ b/lib/config/config_settings.h @@ -854,6 +854,11 @@ cfg(global_use_lvmetad_CFG, "use_lvmetad", global_CFG_SECTION, 0, CFG_TYPE_BOOL, "scanning from the LVM system entirely, including lvmetad, use\n" "devices/global_filter.\n") +cfg(global_lvmetad_update_wait_time_CFG, "lvmetad_update_wait_time", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_LVMETAD_UPDATE_WAIT_TIME, vsn(2, 2, 151), NULL, 0, NULL, + "The number of seconds a command will wait for lvmetad update to finish.\n" + "After waiting for this period, a command will not use lvmetad, and\n" + "will revert to disk scanning.\n") + cfg(global_use_lvmlockd_CFG, "use_lvmlockd", global_CFG_SECTION, 0, CFG_TYPE_BOOL, 0, vsn(2, 2, 124), NULL, 0, NULL, "Use lvmlockd for locking among hosts using LVM on shared storage.\n" "Applicable only if LVM is compiled with lockd support in which\n" diff --git a/lib/config/defaults.h b/lib/config/defaults.h index a6806cd..5e10ce0 100644 --- a/lib/config/defaults.h +++ b/lib/config/defaults.h @@ -52,6 +52,7 @@ #define DEFAULT_FALLBACK_TO_CLUSTERED_LOCKING 1 #define DEFAULT_WAIT_FOR_LOCKS 1 #define DEFAULT_LVMLOCKD_LOCK_RETRIES 3 +#define DEFAULT_LVMETAD_UPDATE_WAIT_TIME 10 #define DEFAULT_PRIORITISE_WRITE_LOCKS 1 #define DEFAULT_USE_MLOCKALL 0 #define DEFAULT_METADATA_READ_ONLY 0 diff --git a/tools/commands.h b/tools/commands.h index aba5b40..f49e57f 100644 --- a/tools/commands.h +++ b/tools/commands.h @@ -698,7 +698,7 @@ xx(lvs, xx(lvscan, "List all logical volumes in all volume groups", - PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH, + PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | NO_LVMETAD_AUTOSCAN, "lvscan\n" "\t[-a|--all]\n" "\t[-b|--blockdevice]\n" @@ -971,7 +971,7 @@ xx(pvs, xx(pvscan, "List all physical volumes", - PERMITTED_READ_ONLY | LOCKD_VG_SH, + PERMITTED_READ_ONLY | LOCKD_VG_SH | NO_LVMETAD_AUTOSCAN, "pvscan\n" "\t[-b|--background]\n" "\t[--cache [-a|--activate ay] [ DevicePath | -j|--major major --minor minor]...]\n" @@ -1243,7 +1243,7 @@ xx(vgextend, xx(vgimport, "Register exported volume group with system", - ALL_VGS_IS_DEFAULT, + ALL_VGS_IS_DEFAULT | NO_LVMETAD_AUTOSCAN, "vgimport\n" "\t[-a|--all]\n" "\t[--commandprofile ProfileName]\n" @@ -1382,7 +1382,7 @@ xx(vgs, xx(vgscan, "Search for all volume groups", - PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH, + PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | NO_LVMETAD_AUTOSCAN, "vgscan " "\t[--cache]\n" "\t[--commandprofile ProfileName]\n" diff --git a/tools/lvmcmdline.c b/tools/lvmcmdline.c index 2ee54e8..48c660b 100644 --- a/tools/lvmcmdline.c +++ b/tools/lvmcmdline.c @@ -1643,13 +1643,26 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv) } /* - * Other hosts might have changed foreign VGs so enforce a rescan - * before processing any command using them. + * pvscan/vgscan/lvscan/vgimport want their own control over rescanning + * to populate lvmetad and have similar code of their own. + * Other commands use this general policy for using lvmetad. + * + * The lvmetad cache may need to be repopulated before we use it because: + * - We are reading foreign VGs which others hosts may have changed + * which our lvmetad would not have seen. + * - lvmetad may have just been started and no command has been run + * to populate it yet (e.g. no pvscan --cache was run). + * - Another local command may have run with a different global filter + * which changed the content of lvmetad from what we want (recognized + * by different token values.) */ - if (cmd->include_foreign_vgs && lvmetad_used() && - !lvmetad_pvscan_foreign_vgs(cmd, NULL)) { - log_error("Failed to scan devices."); - return ECMD_FAILED; + if (lvmetad_used() && !(cmd->command->flags & NO_LVMETAD_AUTOSCAN)) { + if (cmd->include_foreign_vgs || !lvmetad_token_matches(cmd)) { + if (lvmetad_used() && !lvmetad_pvscan_all_devs(cmd, NULL, cmd->include_foreign_vgs ? 1 : 0)) { + log_warn("WARNING: Not using lvmetad because cache update failed."); + lvmetad_set_active(cmd, 0); + } + } } /* diff --git a/tools/lvscan.c b/tools/lvscan.c index 751ecb6..666626c 100644 --- a/tools/lvscan.c +++ b/tools/lvscan.c @@ -21,10 +21,8 @@ static int _lvscan_single_lvmetad(struct cmd_context *cmd, struct logical_volume struct dm_list all_pvs; char pvid_s[64] __attribute__((aligned(8))); - if (!lvmetad_used()) { - log_verbose("Ignoring lvscan --cache because lvmetad is not in use."); + if (!lvmetad_used()) return ECMD_PROCESSED; - } dm_list_init(&all_pvs); @@ -98,6 +96,22 @@ int lvscan(struct cmd_context *cmd, int argc, char **argv) return EINVALID_CMD_LINE; } + if (!lvmetad_used() && arg_is_set(cmd, cache_long_ARG)) + log_verbose("Ignoring lvscan --cache because lvmetad is not in use."); + + /* Needed because this command has NO_LVMETAD_AUTOSCAN. */ + if (lvmetad_used() && !lvmetad_token_matches(cmd)) { + if (lvmetad_used() && !lvmetad_pvscan_all_devs(cmd, NULL, 0)) { + log_warn("WARNING: Not using lvmetad because cache update failed."); + lvmetad_set_active(cmd, 0); + } + + /* + * FIXME: doing lvscan --cache after a full scan is pointless. + * Should the cache case just exit here? + */ + } + return process_each_lv(cmd, argc, argv, 0, NULL, &lvscan_single); } diff --git a/tools/pvscan.c b/tools/pvscan.c index b224c30..10297a3 100644 --- a/tools/pvscan.c +++ b/tools/pvscan.c @@ -234,8 +234,6 @@ static int _pvscan_lvmetad(struct cmd_context *cmd, int argc, char **argv) dev_t devno; activation_handler handler = NULL; - cmd->include_foreign_vgs = 1; - /* * Return here immediately if lvmetad is not used. * Also return if locking_type=3 (clustered) as we @@ -273,11 +271,29 @@ static int _pvscan_lvmetad(struct cmd_context *cmd, int argc, char **argv) /* Scan everything? */ if (!argc && !devno_args) { - if (!lvmetad_pvscan_all_devs(cmd, handler)) + if (!lvmetad_pvscan_all_devs(cmd, handler, 1)) { + log_error("Failed to update cache."); ret = ECMD_FAILED; + } goto out; } + /* + * FIXME: when specific devs are named, we generally don't + * want to scan any other devs, but if lvmetad is not yet + * populated, the first 'pvscan --cache dev' does need to + * do a full scan. We want to remove the need for this + * case so that 'pvscan --cache dev' is guaranteed to never + * scan any devices other than those specified. + */ + if (lvmetad_used() && !lvmetad_token_matches(cmd)) { + if (lvmetad_used() && !lvmetad_pvscan_all_devs(cmd, NULL, 0)) { + log_error("Failed to update cache."); + ret = ECMD_FAILED; + goto out; + } + } + log_verbose("Using physical volume(s) on command line"); /* Process any command line PVs first. */ @@ -404,6 +420,14 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv) arg_count(cmd, exported_ARG) ? "of exported volume group(s)" : "in no volume group"); + /* Needed because this command has NO_LVMETAD_AUTOSCAN. */ + if (lvmetad_used() && !lvmetad_token_matches(cmd)) { + if (lvmetad_used() && !lvmetad_pvscan_all_devs(cmd, NULL, 0)) { + log_warn("WARNING: Not using lvmetad because cache update failed."); + lvmetad_set_active(cmd, 0); + } + } + if (!lock_vol(cmd, VG_GLOBAL, LCK_VG_WRITE, NULL)) { log_error("Unable to obtain global lock."); return ECMD_FAILED; diff --git a/tools/tools.h b/tools/tools.h index 3762e8e..7b1bda3 100644 --- a/tools/tools.h +++ b/tools/tools.h @@ -110,6 +110,8 @@ struct arg_value_group_list { #define REQUIRES_FULL_LABEL_SCAN 0x00000080 /* Command must use all specified arg names and fail if all cannot be used. */ #define MUST_USE_ALL_ARGS 0x00000100 +/* Command wants to control the device scan for lvmetad itself. */ +#define NO_LVMETAD_AUTOSCAN 0x00000200 /* a register of the lvm commands */ struct command { diff --git a/tools/vgimport.c b/tools/vgimport.c index caeaf09..3c08876 100644 --- a/tools/vgimport.c +++ b/tools/vgimport.c @@ -93,9 +93,11 @@ int vgimport(struct cmd_context *cmd, int argc, char **argv) * We need to reread it to see that it's been exported before we can * import it. */ - if (lvmetad_active() && !lvmetad_pvscan_all_devs(cmd, NULL)) { - log_error("Failed to scan devices."); - return ECMD_FAILED; + if (lvmetad_used()) { + if (!lvmetad_pvscan_all_devs(cmd, NULL, 1)) { + log_warn("WARNING: Not using lvmetad because cache update failed."); + lvmetad_set_active(cmd, 0); + } } return process_each_vg(cmd, argc, argv, NULL, diff --git a/tools/vgscan.c b/tools/vgscan.c index a5b04a3..9dc0000 100644 --- a/tools/vgscan.c +++ b/tools/vgscan.c @@ -61,21 +61,20 @@ int vgscan(struct cmd_context *cmd, int argc, char **argv) cmd->filter->wipe(cmd->filter); lvmcache_destroy(cmd, 1, 0); - if (arg_count(cmd, cache_long_ARG)) { - cmd->include_foreign_vgs = 1; + if (!lvmetad_used() && arg_is_set(cmd, cache_long_ARG)) + log_verbose("Ignoring vgscan --cache command because lvmetad is not in use."); - if (lvmetad_active()) { - if (!lvmetad_pvscan_all_devs(cmd, NULL)) - return ECMD_FAILED; - } - else { - log_error("Cannot proceed since lvmetad is not active."); - unlock_vg(cmd, VG_GLOBAL); - return ECMD_FAILED; + if (lvmetad_used() && (arg_is_set(cmd, cache_long_ARG) || !lvmetad_token_matches(cmd))) { + if (lvmetad_used() && !lvmetad_pvscan_all_devs(cmd, NULL, arg_is_set(cmd, cache_long_ARG))) { + log_warn("WARNING: Not using lvmetad because cache update failed."); + lvmetad_set_active(cmd, 0); } } - log_print_unless_silent("Reading all physical volumes. This may take a while..."); + if (!lvmetad_used()) + log_print_unless_silent("Reading all physical volumes. This may take a while..."); + else + log_print_unless_silent("Reading volume groups from cache."); maxret = process_each_vg(cmd, argc, argv, NULL, 0, NULL, &vgscan_single);

1 0

master - debug: unify some tracing messages
by Zdenek Kabelac 12 Apr '16

12 Apr '16

Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=a28c81cbae308e37… Commit: a28c81cbae308e371ece31679615d673b29fccec Parent: 1be74cfd7f948123544872abb5e80994182e04d8 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Tue Apr 12 13:06:16 2016 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Tue Apr 12 13:06:16 2016 +0200 debug: unify some tracing messages Introduce FMTVGID - although it might be possibly better to ensure vgid is always \0 ended string. Unify some lvmcache reported messages. --- lib/cache/lvmcache.c | 35 +++++++++++++++++++---------------- lib/format_text/format-text.c | 9 +++------ lib/misc/util.h | 2 ++ 3 files changed, 24 insertions(+), 22 deletions(-) diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c index 394745a..3432ef6 100644 --- a/lib/cache/lvmcache.c +++ b/lib/cache/lvmcache.c @@ -504,12 +504,13 @@ struct lvmcache_vginfo *lvmcache_vginfo_from_vgname(const char *vgname, const ch return lvmcache_vginfo_from_vgid(vgid); if (!_vgname_hash) { - log_debug_cache(INTERNAL_ERROR "Internal cache is no yet initialized."); + log_debug_cache(INTERNAL_ERROR "Internal lvmcache is no yet initialized."); return NULL; } if (!(vginfo = dm_hash_lookup(_vgname_hash, vgname))) { - log_debug_cache("Metadata cache has no info for vgname: \"%s\"", vgname); + log_debug_cache("lvmcache has no info for vgname \"%s\"%s" FMTVGID ".", + vgname, (vgid) ? " with VGID " : "", (vgid) ? : ""); return NULL; } @@ -520,8 +521,8 @@ struct lvmcache_vginfo *lvmcache_vginfo_from_vgname(const char *vgname, const ch while ((vginfo = vginfo->next)); if (!vginfo) - log_debug_cache("Metadata cache has not found vgname \"%s\" with vgid \"%." - DM_TO_STRING(ID_LEN) "s\".", vgname, vgid ? : ""); + log_debug_cache("lvmcache has not found vgname \"%s\"%s" FMTVGID ".", + vgname, (vgid) ? " with VGID " : "", (vgid) ? : ""); return vginfo; } @@ -1273,7 +1274,7 @@ static int _lvmcache_update_vgid(struct lvmcache_info *info, } if (!is_orphan_vg(vginfo->vgname)) - log_debug_cache("lvmcache: %s: setting %s VGID to %s", + log_debug_cache("lvmcache %s: VG %s: set VGID to " FMTVGID ".", (info) ? dev_name(info->dev) : "", vginfo->vgname, vginfo->vgid); @@ -1504,16 +1505,16 @@ static int _lvmcache_update_vgname(struct lvmcache_info *info, if (info) { if (info->mdas.n) - sprintf(mdabuf, " with %u mdas", dm_list_size(&info->mdas)); + sprintf(mdabuf, " with %u mda(s)", dm_list_size(&info->mdas)); else mdabuf[0] = '\0'; - log_debug_cache("lvmcache: %s: now in VG %s%s%s%s%s", + log_debug_cache("lvmcache %s: now in VG %s%s%s%s%s.", dev_name(info->dev), vgname, vginfo->vgid[0] ? " (" : "", vginfo->vgid[0] ? vginfo->vgid : "", vginfo->vgid[0] ? ")" : "", mdabuf); } else - log_debug_cache("lvmcache: initialised VG %s", vgname); + log_debug_cache("lvmcache initialised VG %s.", vgname); return 1; } @@ -1526,7 +1527,7 @@ static int _lvmcache_update_vgstatus(struct lvmcache_info *info, uint32_t vgstat return 1; if ((info->vginfo->status & EXPORTED_VG) != (vgstatus & EXPORTED_VG)) - log_debug_cache("lvmcache: %s: VG %s %s exported", + log_debug_cache("lvmcache %s: VG %s %s exported.", dev_name(info->dev), info->vginfo->vgname, vgstatus & EXPORTED_VG ? "now" : "no longer"); @@ -1543,12 +1544,12 @@ static int _lvmcache_update_vgstatus(struct lvmcache_info *info, uint32_t vgstat dm_free(info->vginfo->creation_host); if (!(info->vginfo->creation_host = dm_strdup(creation_host))) { - log_error("cache creation host alloc failed for %s", + log_error("cache creation host alloc failed for %s.", creation_host); return 0; } - log_debug_cache("lvmcache: %s: VG %s: Set creation host to %s.", + log_debug_cache("lvmcache %s: VG %s: set creation host to %s.", dev_name(info->dev), info->vginfo->vgname, creation_host); set_lock_type: @@ -1567,7 +1568,7 @@ set_lock_type: return 0; } - log_debug_cache("lvmcache: %s: VG %s: Set lock_type to %s.", + log_debug_cache("lvmcache %s: VG %s: set lock_type to %s.", dev_name(info->dev), info->vginfo->vgname, lock_type); set_system_id: @@ -1586,7 +1587,7 @@ set_system_id: return 0; } - log_debug_cache("lvmcache: %s: VG %s: Set system_id to %s.", + log_debug_cache("lvmcache %s: VG %s: set system_id to %s.", dev_name(info->dev), info->vginfo->vgname, system_id); out: @@ -1607,8 +1608,10 @@ static int _lvmcache_update_vg_mda_info(struct lvmcache_info *info, uint32_t mda /* FIXME Add checksum index */ - log_debug_cache("lvmcache: %s: VG %s: Stored metadata checksum %" PRIu32 " with size %" PRIsize_t ".", - dev_name(info->dev), info->vginfo->vgname, mda_checksum, mda_size); + log_debug_cache("lvmcache %s: VG %s: stored metadata checksum 0x%08" + PRIx32 " with size %" PRIsize_t ".", + dev_name(info->dev), info->vginfo->vgname, + mda_checksum, mda_size); return 1; } @@ -1961,7 +1964,7 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid, * device already exists? Things don't seem to work * if we do that for some reason. */ - log_debug_cache("Found same device %s with same pvid %s", + log_debug_cache("Found same device %s with same pvid %s.", dev_name(existing->dev), pvid_s); } diff --git a/lib/format_text/format-text.c b/lib/format_text/format-text.c index 6053610..bd20670 100644 --- a/lib/format_text/format-text.c +++ b/lib/format_text/format-text.c @@ -1153,7 +1153,6 @@ int vgname_from_mda(const struct format_type *fmt, uint32_t wrap = 0; unsigned int len = 0; char buf[NAME_LEN + 1] __attribute__((aligned(8))); - char uuid[64] __attribute__((aligned(8))); uint64_t buffer_size, current_usage; unsigned used_cached_metadata = 0; @@ -1222,16 +1221,14 @@ int vgname_from_mda(const struct format_type *fmt, if (!validate_name(vgsummary->vgname)) return_0; - if (!id_write_format((struct id *)&vgsummary->vgid, uuid, sizeof(uuid))) - return_0; - log_debug_metadata("%s: %s metadata at %" PRIu64 " size %" PRIu64 " (in area at %" PRIu64 " size %" PRIu64 - ") for %s (%s)", + ") for %s (" FMTVGID ")", dev_name(dev_area->dev), used_cached_metadata ? "Using cached" : "Found", dev_area->start + rlocn->offset, - rlocn->size, dev_area->start, dev_area->size, vgsummary->vgname, uuid); + rlocn->size, dev_area->start, dev_area->size, vgsummary->vgname, + (char *)&vgsummary->vgid); if (mda_free_sectors) { current_usage = (rlocn->size + SECTOR_SIZE - UINT64_C(1)) - diff --git a/lib/misc/util.h b/lib/misc/util.h index b08b95d..1011fdd 100644 --- a/lib/misc/util.h +++ b/lib/misc/util.h @@ -72,4 +72,6 @@ #define FMTx32 "%" PRIx32 #define FMTx64 "%" PRIx64 +#define FMTVGID "%." DM_TO_STRING(ID_LEN) "s" + #endif

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

lvm2-commits April 2016