master - lvmdbusd: Spelling correction
by Tony Asleson
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=1ed4b3f23baf13e224d...
Commit: 1ed4b3f23baf13e224d0c24735304f872c0930e8
Parent: 4c1fd827748a0b5a1a2c3e54c5fdc0478b45515f
Author: Tony Asleson <tasleson(a)redhat.com>
AuthorDate: Mon Jan 14 09:11:06 2019 -0600
Committer: Tony Asleson <tasleson(a)redhat.com>
CommitterDate: Wed Jan 16 16:29:05 2019 -0600
lvmdbusd: Spelling correction
---
daemons/lvmdbusd/vg.py | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/daemons/lvmdbusd/vg.py b/daemons/lvmdbusd/vg.py
index c00084d..b9a23c2 100644
--- a/daemons/lvmdbusd/vg.py
+++ b/daemons/lvmdbusd/vg.py
@@ -216,7 +216,7 @@ class Vg(AutomatedProperties):
# TODO: This should be broken into a number of different methods
# instead of having one method that takes a hash for parameters. Some of
# the changes that vgchange does works on entire system, not just a
- # specfic vg, thus that should be in the Manager interface.
+ # specific vg, thus that should be in the Manager interface.
@dbus.service.method(
dbus_interface=VG_INTERFACE,
in_signature='ia{sv}',
5 years, 3 months
master - lvmdbusd: Ensure all paths return value
by Tony Asleson
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=b6d26245fbde5e66a61...
Commit: b6d26245fbde5e66a616f27363118dc370062f7a
Parent: 5f102b3421873a6111e477b40fdbe1a93ef258b9
Author: Tony Asleson <tasleson(a)redhat.com>
AuthorDate: Mon Jan 14 09:08:55 2019 -0600
Committer: Tony Asleson <tasleson(a)redhat.com>
CommitterDate: Wed Jan 16 16:29:05 2019 -0600
lvmdbusd: Ensure all paths return value
---
daemons/lvmdbusd/automatedproperties.py | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/daemons/lvmdbusd/automatedproperties.py b/daemons/lvmdbusd/automatedproperties.py
index e188fa4..b591948 100644
--- a/daemons/lvmdbusd/automatedproperties.py
+++ b/daemons/lvmdbusd/automatedproperties.py
@@ -155,7 +155,7 @@ class AutomatedProperties(dbus.service.Object):
# through all dbus objects as some don't have a search method, like
# 'Manager' object.
if not self._ap_search_method:
- return
+ return 0
search = self.lvm_id
if search_key:
5 years, 3 months
master - lvmdbusd: LookUpByLvmId: Add doc for cb, cbe
by Tony Asleson
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=4c1fd827748a0b5a1a2...
Commit: 4c1fd827748a0b5a1a2c3e54c5fdc0478b45515f
Parent: b6d26245fbde5e66a616f27363118dc370062f7a
Author: Tony Asleson <tasleson(a)redhat.com>
AuthorDate: Mon Jan 14 09:10:24 2019 -0600
Committer: Tony Asleson <tasleson(a)redhat.com>
CommitterDate: Wed Jan 16 16:29:05 2019 -0600
lvmdbusd: LookUpByLvmId: Add doc for cb, cbe
---
daemons/lvmdbusd/manager.py | 2 ++
1 files changed, 2 insertions(+), 0 deletions(-)
diff --git a/daemons/lvmdbusd/manager.py b/daemons/lvmdbusd/manager.py
index d77c7b4..8de05db 100644
--- a/daemons/lvmdbusd/manager.py
+++ b/daemons/lvmdbusd/manager.py
@@ -164,6 +164,8 @@ class Manager(AutomatedProperties):
return the object path in O(1) time.
:param key: The lookup value
+ :param cb: dbus python call back parameter, not client visible
+ :param cbe: dbus python error call back parameter, not client visible
:return: Return the object path. If object not found you will get '/'
"""
r = RequestEntry(-1, Manager._lookup_by_lvm_id, (key,), cb, cbe, False)
5 years, 3 months
master - hints: invalidate when pvscan --cache sees a new PV
by David Teigland
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=5f102b3421873a6111e...
Commit: 5f102b3421873a6111e477b40fdbe1a93ef258b9
Parent: facd5209311d0f205229c6943fa3b2ef42fc981f
Author: David Teigland <teigland(a)redhat.com>
AuthorDate: Wed Jan 16 14:19:09 2019 -0600
Committer: David Teigland <teigland(a)redhat.com>
CommitterDate: Wed Jan 16 15:34:20 2019 -0600
hints: invalidate when pvscan --cache sees a new PV
An idea from Zdenek for better ensuring valid hints by invalidating
them when pvscan --cache <device> sees a new PV, which is a case
where we know that hints should be invalidated. This is triggered
from systemd/udev logic, and there may be some cases where it would
invalidate hints that the existing methods wouldn't detect.
---
lib/label/hints.c | 15 +++++++++++++++
lib/label/hints.h | 2 ++
test/shell/hints.sh | 23 +++++++++++++++++++++--
tools/pvscan.c | 16 ++++++++++++++++
4 files changed, 54 insertions(+), 2 deletions(-)
diff --git a/lib/label/hints.c b/lib/label/hints.c
index a9c40c2..4fe44b0 100644
--- a/lib/label/hints.c
+++ b/lib/label/hints.c
@@ -1026,6 +1026,21 @@ void clear_hint_file(struct cmd_context *cmd)
}
/*
+ * This is used when pvscan --cache sees a new PV, which
+ * means we should refresh hints. It could catch some case
+ * which the other methods of detecting stale hints may miss.
+ */
+void invalidate_hints(struct cmd_context *cmd)
+{
+ /* No commands are using hints. */
+ if (!cmd->enable_hints)
+ return;
+
+ if (!_touch_newhints())
+ stack;
+}
+
+/*
* Currently, all the commands using hints (ALLOW_HINTS) take an optional or
* required first position arg of a VG name or LV name. If some other command
* began using hints which took some other kind of position arg, we would
diff --git a/lib/label/hints.h b/lib/label/hints.h
index a17214c..469e8c4 100644
--- a/lib/label/hints.h
+++ b/lib/label/hints.h
@@ -28,6 +28,8 @@ int write_hint_file(struct cmd_context *cmd, int newhints);
void clear_hint_file(struct cmd_context *cmd);
+void invalidate_hints(struct cmd_context *cmd);
+
int get_hints(struct cmd_context *cmd, struct dm_list *hints, int *newhints,
struct dm_list *devs_in, struct dm_list *devs_out);
diff --git a/test/shell/hints.sh b/test/shell/hints.sh
index bdaf3be..31628b0 100644
--- a/test/shell/hints.sh
+++ b/test/shell/hints.sh
@@ -273,11 +273,12 @@ diff $HINTS $PREV
#
# pvs (no change), pvscan (hints are new), pvs (no change)
+rm $HINTS $PREV
pvs
cp $HINTS $PREV
-diff $HINTS $PREV
-cp $HINTS $PREV
+# this next pvscan recreates the hints file
pvscan --cache
+# the only diff will be "Created by pvscan ..." vs "Created by pvs ..."
not diff $HINTS $PREV
cp $HINTS $PREV
pvs
@@ -285,6 +286,8 @@ diff $HINTS $PREV
grep 'Created by pvscan' $HINTS
# dev4 is a PV not used by a VG, dev5 is not a PV
# using dd to copy skirts hint tracking so dev5 won't be seen
+# (unless the dd triggers udev which triggers pvscan --cache $dev5,
+# but I've not seen that happen in tests so far.)
dd if="$dev4" of="$dev5" bs=1M
# this pvs won't see dev5
pvs > foo
@@ -314,6 +317,22 @@ not grep "$dev5" foo
grep "$dev4" $HINTS
not grep "$dev5" $HINTS
+#
+# Test pvscan --cache <dev> forces refresh
+#
+
+rm $HINTS $PREV
+pvs
+cp $HINTS $PREV
+# this next pvscan creates newhints to trigger a refresh
+pvscan --cache "$dev5"
+cat $NEWHINTS
+# this next pvs creates new hints
+pvs
+# the only diff will be "Created by..."
+not diff $HINTS $PREV
+
+
#
# Test incorrect dev-to-pvid info in hints is detected
diff --git a/tools/pvscan.c b/tools/pvscan.c
index da1e435..098c502 100644
--- a/tools/pvscan.c
+++ b/tools/pvscan.c
@@ -17,6 +17,7 @@
#include "lib/cache/lvmcache.h"
#include "lib/metadata/metadata.h"
+#include "lib/label/hints.h"
#include <dirent.h>
@@ -632,6 +633,7 @@ int pvscan_cache_cmd(struct cmd_context *cmd, int argc, char **argv)
int do_activate = arg_is_set(cmd, activate_ARG);
int all_vgs = 0;
int add_errors = 0;
+ int add_single_count = 0;
int ret = ECMD_PROCESSED;
dm_list_init(&single_devs);
@@ -750,6 +752,8 @@ int pvscan_cache_cmd(struct cmd_context *cmd, int argc, char **argv)
if (dev->flags & DEV_FILTER_OUT_SCAN)
continue;
+ add_single_count++;
+
/*
* Devices that exist and pass the lvmetad filter
* are online.
@@ -801,6 +805,8 @@ int pvscan_cache_cmd(struct cmd_context *cmd, int argc, char **argv)
if (dev->flags & DEV_FILTER_OUT_SCAN)
continue;
+ add_single_count++;
+
/*
* Devices that exist and pass the lvmetad filter
* are online.
@@ -812,6 +818,16 @@ int pvscan_cache_cmd(struct cmd_context *cmd, int argc, char **argv)
activate:
/*
+ * When a new PV appears, the system runs pvscan --cache dev.
+ * This also means that existing hints are invalid, and
+ * we can force hints to be refreshed here. There may be
+ * cases where this detects a change that the other methods
+ * of detecting invalid hints doesn't catch.
+ */
+ if (add_single_count)
+ invalidate_hints(cmd);
+
+ /*
* Special case: pvscan --cache -aay dev
* where dev has no VG metadata, and it's the final device to
* complete the VG. In this case we want to autoactivate the
5 years, 3 months
master - lvmlockd: fix make lockstart wait
by David Teigland
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=facd5209311d0f20522...
Commit: facd5209311d0f205229c6943fa3b2ef42fc981f
Parent: ebaaff3590b60933f6f1e2bfd010a86fc373f7eb
Author: David Teigland <teigland(a)redhat.com>
AuthorDate: Wed Jan 16 13:24:29 2019 -0600
Committer: David Teigland <teigland(a)redhat.com>
CommitterDate: Wed Jan 16 13:24:29 2019 -0600
lvmlockd: fix make lockstart wait
when building without lvmlockd
---
lib/locking/lvmlockd.h | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/lib/locking/lvmlockd.h b/lib/locking/lvmlockd.h
index 1fbf765..e5ae331 100644
--- a/lib/locking/lvmlockd.h
+++ b/lib/locking/lvmlockd.h
@@ -148,7 +148,7 @@ static inline int lockd_rename_vg_final(struct cmd_context *cmd, struct volume_g
return 1;
}
-static inline int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init)
+static inline int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init, int *exists)
{
return 0;
}
5 years, 3 months
master - move init_use_aio
by David Teigland
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=ebaaff3590b60933f6f...
Commit: ebaaff3590b60933f6f1e2bfd010a86fc373f7eb
Parent: e158835a05963c8cb4166100c9d01e7ff3991c82
Author: David Teigland <teigland(a)redhat.com>
AuthorDate: Tue Jan 15 15:19:04 2019 -0600
Committer: David Teigland <teigland(a)redhat.com>
CommitterDate: Wed Jan 16 11:45:53 2019 -0600
move init_use_aio
it doesn't make sense to call from init_logging
---
lib/commands/toolcontext.c | 4 ++--
1 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/lib/commands/toolcontext.c b/lib/commands/toolcontext.c
index bd216aa..62e21f7 100644
--- a/lib/commands/toolcontext.c
+++ b/lib/commands/toolcontext.c
@@ -328,8 +328,6 @@ static void _init_logging(struct cmd_context *cmd)
find_config_tree_bool(cmd, global_test_CFG, NULL);
init_test(cmd->default_settings.test);
- init_use_aio(find_config_tree_bool(cmd, global_use_aio_CFG, NULL));
-
/* Settings for logging to file */
if (find_config_tree_bool(cmd, log_overwrite_CFG, NULL))
append = 0;
@@ -1661,6 +1659,8 @@ struct cmd_context *create_toolcontext(unsigned is_clvmd,
find_config_tree_array(cmd, devices_types_CFG, NULL))))
goto_out;
+ init_use_aio(find_config_tree_bool(cmd, global_use_aio_CFG, NULL));
+
if (!_init_dev_cache(cmd))
goto_out;
5 years, 3 months
master - lvmlockd: make lockstart wait for existing start
by David Teigland
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=e158835a05963c8cb41...
Commit: e158835a05963c8cb4166100c9d01e7ff3991c82
Parent: 7b5abc3fb19c7569ad86107cfbf30f39ca261fed
Author: David Teigland <teigland(a)redhat.com>
AuthorDate: Wed Jan 16 10:41:43 2019 -0600
Committer: David Teigland <teigland(a)redhat.com>
CommitterDate: Wed Jan 16 10:49:04 2019 -0600
lvmlockd: make lockstart wait for existing start
If there are two independent scripts doing:
vgchange --lockstart vg
lvchange -ay vg/lv
The first vgchange to do the lockstart will wait for
the lockstart to complete before returning.
The second vgchange to do the lockstart will see that
the start is already in progress (from the first) and
will do nothing. This means the second does not wait
for any lockstart to complete, and moves on to the
lvchange which may find the lockspace still starting
and fail.
To fix this, make the vgchange lockstart command
wait for any lockstart's in progress to complete.
---
daemons/lvmlockd/lvmlockd-core.c | 9 ++++++---
lib/locking/lvmlockd.c | 12 +++++++++---
lib/locking/lvmlockd.h | 2 +-
tools/vgchange.c | 5 ++++-
tools/vgcreate.c | 2 +-
5 files changed, 21 insertions(+), 9 deletions(-)
diff --git a/daemons/lvmlockd/lvmlockd-core.c b/daemons/lvmlockd/lvmlockd-core.c
index 1ec3efd..60ae537 100644
--- a/daemons/lvmlockd/lvmlockd-core.c
+++ b/daemons/lvmlockd/lvmlockd-core.c
@@ -2743,6 +2743,9 @@ static int add_lockspace_thread(const char *ls_name,
if (ls2->thread_stop) {
log_debug("add_lockspace_thread %s exists and stopping", ls->name);
rv = -EAGAIN;
+ } else if (!ls2->create_fail && !ls2->create_done) {
+ log_debug("add_lockspace_thread %s exists and starting", ls->name);
+ rv = -ESTARTING;
} else {
log_debug("add_lockspace_thread %s exists", ls->name);
rv = -EEXIST;
@@ -2984,7 +2987,7 @@ static int count_lockspace_starting(uint32_t client_id)
pthread_mutex_lock(&lockspaces_mutex);
list_for_each_entry(ls, &lockspaces, list) {
- if (ls->start_client_id != client_id)
+ if (client_id && (ls->start_client_id != client_id))
continue;
if (!ls->create_done && !ls->create_fail) {
@@ -3389,7 +3392,7 @@ static void *worker_thread_main(void *arg_in)
add_client_result(act);
} else if (act->op == LD_OP_START_WAIT) {
- act->result = count_lockspace_starting(act->client_id);
+ act->result = count_lockspace_starting(0);
if (!act->result)
add_client_result(act);
else
@@ -3423,7 +3426,7 @@ static void *worker_thread_main(void *arg_in)
list_for_each_entry_safe(act, safe, &delayed_list, list) {
if (act->op == LD_OP_START_WAIT) {
log_debug("work delayed start_wait for client %u", act->client_id);
- act->result = count_lockspace_starting(act->client_id);
+ act->result = count_lockspace_starting(0);
if (!act->result) {
list_del(&act->list);
add_client_result(act);
diff --git a/lib/locking/lvmlockd.c b/lib/locking/lvmlockd.c
index 9fb7b36..9b2d050 100644
--- a/lib/locking/lvmlockd.c
+++ b/lib/locking/lvmlockd.c
@@ -1072,7 +1072,7 @@ void lockd_free_vg_final(struct cmd_context *cmd, struct volume_group *vg)
* that the VG lockspace being started is new.
*/
-int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init)
+int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init, int *exists)
{
char uuid[64] __attribute__((aligned(8)));
daemon_reply reply;
@@ -1147,6 +1147,12 @@ int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_i
log_debug("VG %s start error: already started", vg->name);
ret = 1;
break;
+ case -ESTARTING:
+ log_debug("VG %s start error: already starting", vg->name);
+ if (exists)
+ *exists = 1;
+ ret = 1;
+ break;
case -EARGS:
log_error("VG %s start failed: invalid parameters for %s", vg->name, vg->lock_type);
break;
@@ -2668,7 +2674,7 @@ int lockd_rename_vg_final(struct cmd_context *cmd, struct volume_group *vg, int
* Depending on the problem that caused the rename to
* fail, it may make sense to not restart the VG here.
*/
- if (!lockd_start_vg(cmd, vg, 0))
+ if (!lockd_start_vg(cmd, vg, 0, NULL))
log_error("Failed to restart VG %s lockspace.", vg->name);
return 1;
}
@@ -2708,7 +2714,7 @@ int lockd_rename_vg_final(struct cmd_context *cmd, struct volume_group *vg, int
}
}
- if (!lockd_start_vg(cmd, vg, 1))
+ if (!lockd_start_vg(cmd, vg, 1, NULL))
log_error("Failed to start VG %s lockspace.", vg->name);
return 1;
diff --git a/lib/locking/lvmlockd.h b/lib/locking/lvmlockd.h
index 0a6ea96..1fbf765 100644
--- a/lib/locking/lvmlockd.h
+++ b/lib/locking/lvmlockd.h
@@ -63,7 +63,7 @@ int lockd_rename_vg_final(struct cmd_context *cmd, struct volume_group *vg, int
/* start and stop the lockspace for a vg */
-int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init);
+int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init, int *exists);
int lockd_stop_vg(struct cmd_context *cmd, struct volume_group *vg);
int lockd_start_wait(struct cmd_context *cmd);
diff --git a/tools/vgchange.c b/tools/vgchange.c
index bbdf2e4..f831fd9 100644
--- a/tools/vgchange.c
+++ b/tools/vgchange.c
@@ -560,6 +560,7 @@ static int _vgchange_lock_start(struct cmd_context *cmd, struct volume_group *vg
{
const char *start_opt = arg_str_value(cmd, lockopt_ARG, NULL);
int auto_opt = 0;
+ int exists = 0;
int r;
if (!vg_is_shared(vg))
@@ -586,10 +587,12 @@ static int _vgchange_lock_start(struct cmd_context *cmd, struct volume_group *vg
}
do_start:
- r = lockd_start_vg(cmd, vg, 0);
+ r = lockd_start_vg(cmd, vg, 0, &exists);
if (r)
vp->lock_start_count++;
+ else if (exists)
+ vp->lock_start_count++;
if (!strcmp(vg->lock_type, "sanlock"))
vp->lock_start_sanlock = 1;
diff --git a/tools/vgcreate.c b/tools/vgcreate.c
index c146ab7..f9bf10e 100644
--- a/tools/vgcreate.c
+++ b/tools/vgcreate.c
@@ -204,7 +204,7 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
if (vg_is_shared(vg)) {
const char *start_opt = arg_str_value(cmd, lockopt_ARG, NULL);
- if (!lockd_start_vg(cmd, vg, 1)) {
+ if (!lockd_start_vg(cmd, vg, 1, NULL)) {
log_error("Failed to start locking");
goto out;
}
5 years, 3 months
master - hints: fix hint flock when using lvm shell
by David Teigland
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=7b5abc3fb19c7569ad8...
Commit: 7b5abc3fb19c7569ad86107cfbf30f39ca261fed
Parent: 3cf7668e347af547e6d986ffbfa7fe0d5b425a7f
Author: David Teigland <teigland(a)redhat.com>
AuthorDate: Tue Jan 15 12:23:16 2019 -0600
Committer: David Teigland <teigland(a)redhat.com>
CommitterDate: Tue Jan 15 12:23:16 2019 -0600
hints: fix hint flock when using lvm shell
also cmd->use_hints needs to be set for each shell command
---
lib/commands/toolcontext.c | 3 +++
lib/label/hints.c | 14 +++++++++-----
lib/label/hints.h | 2 ++
tools/lvmcmdline.c | 3 +++
4 files changed, 17 insertions(+), 5 deletions(-)
diff --git a/lib/commands/toolcontext.c b/lib/commands/toolcontext.c
index 39ab3df..bd216aa 100644
--- a/lib/commands/toolcontext.c
+++ b/lib/commands/toolcontext.c
@@ -22,6 +22,7 @@
#include "lib/activate/activate.h"
#include "lib/filters/filter.h"
#include "lib/label/label.h"
+#include "lib/label/hints.h"
#include "lib/misc/lvm-file.h"
#include "lib/format_text/format-text.h"
#include "lib/display/display.h"
@@ -1781,6 +1782,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
*/
activation_release();
+ hints_exit();
lvmcache_destroy(cmd, 0, 0);
label_scan_destroy(cmd);
label_exit();
@@ -1900,6 +1902,7 @@ void destroy_toolcontext(struct cmd_context *cmd)
archive_exit(cmd);
backup_exit(cmd);
+ hints_exit();
lvmcache_destroy(cmd, 0, 0);
label_scan_destroy(cmd);
label_exit();
diff --git a/lib/label/hints.c b/lib/label/hints.c
index bdd70a9..a9c40c2 100644
--- a/lib/label/hints.c
+++ b/lib/label/hints.c
@@ -344,6 +344,13 @@ static void _unlock_hints(void)
_hints_fd = -1;
}
+void hints_exit(void)
+{
+ if (_hints_fd == -1)
+ return;
+ return _unlock_hints();
+}
+
static struct hint *_find_hint_name(struct dm_list *hints, const char *name)
{
struct hint *hint;
@@ -989,6 +996,8 @@ void clear_hint_file(struct cmd_context *cmd)
if (!cmd->enable_hints)
return;
+ log_debug("clear_hint_file");
+
/*
* This function runs even when cmd->use_hints is 0,
* which means this command does not use hints, but
@@ -999,11 +1008,6 @@ void clear_hint_file(struct cmd_context *cmd)
if (!_touch_nohints())
stack;
- /*
- * We are relying on the command exit to release this flock,
- * we should probably add an explicit unlock_hints call.
- */
-
if (!_lock_hints(LOCK_EX, 0))
stack;
diff --git a/lib/label/hints.h b/lib/label/hints.h
index d80016e..a17214c 100644
--- a/lib/label/hints.h
+++ b/lib/label/hints.h
@@ -33,5 +33,7 @@ int get_hints(struct cmd_context *cmd, struct dm_list *hints, int *newhints,
int validate_hints(struct cmd_context *cmd, struct dm_list *hints);
+void hints_exit(void);
+
#endif
diff --git a/tools/lvmcmdline.c b/tools/lvmcmdline.c
index 55a068f..49a6038 100644
--- a/tools/lvmcmdline.c
+++ b/tools/lvmcmdline.c
@@ -2331,6 +2331,8 @@ static int _get_current_settings(struct cmd_context *cmd)
/* Only certain commands need to be optimized by using hints. */
if (cmd->cname->flags & ALLOW_HINTS)
cmd->use_hints = 1;
+ else
+ cmd->use_hints = 0;
if ((hint_mode = find_config_tree_str(cmd, devices_hints_CFG, NULL))) {
if (!strcmp(hint_mode, "none"))
@@ -2986,6 +2988,7 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv)
out:
+ hints_exit();
lvmcache_destroy(cmd, 1, 1);
label_scan_destroy(cmd);
5 years, 3 months
master - WHATS_NEW: device hints
by David Teigland
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=3cf7668e347af547e6d...
Commit: 3cf7668e347af547e6d986ffbfa7fe0d5b425a7f
Parent: 6620dc9475d55207bfcd5e666f0379bcdf11831a
Author: David Teigland <teigland(a)redhat.com>
AuthorDate: Tue Jan 15 10:33:25 2019 -0600
Committer: David Teigland <teigland(a)redhat.com>
CommitterDate: Tue Jan 15 10:33:25 2019 -0600
WHATS_NEW: device hints
---
WHATS_NEW | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)
diff --git a/WHATS_NEW b/WHATS_NEW
index 822d045..1187fb4 100644
--- a/WHATS_NEW
+++ b/WHATS_NEW
@@ -1,5 +1,6 @@
Version 2.03.02 -
===================================
+ Add device hints to reduce scanning.
Introduce LVM_SUPPRESS_SYSLOG to suppress syslog usage by generator.
Fix generator quering lvmconfig unpresent config option.
Fix memleak on bcache error path code.
5 years, 3 months
master - add device hints to reduce scanning
by David Teigland
Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=6620dc9475d55207bfc...
Commit: 6620dc9475d55207bfcd5e666f0379bcdf11831a
Parent: 81b3b71dae7775c93adebdea60308e11057a4ee8
Author: David Teigland <teigland(a)redhat.com>
AuthorDate: Fri Dec 7 14:35:22 2018 -0600
Committer: David Teigland <teigland(a)redhat.com>
CommitterDate: Tue Jan 15 10:23:47 2019 -0600
add device hints to reduce scanning
Save the list of PVs in /run/lvm/hints. These hints
are used to reduce scanning in a number of commands
to only the PVs on the system, or only the PVs in a
requested VG (rather than all devices on the system.)
---
lib/Makefile.in | 1 +
lib/cache/lvmcache.c | 18 +
lib/cache/lvmcache.h | 3 +
lib/commands/toolcontext.c | 1 +
lib/commands/toolcontext.h | 7 +-
lib/config/config_settings.h | 14 +
lib/config/defaults.h | 2 +
lib/device/dev-cache.c | 6 +-
lib/device/dev-cache.h | 3 +-
lib/device/dev-type.c | 30 +
lib/device/dev-type.h | 2 +
lib/device/device.h | 1 +
lib/filters/filter-composite.c | 11 +-
lib/filters/filter-fwraid.c | 3 +-
lib/filters/filter-internal.c | 3 +-
lib/filters/filter-md.c | 3 +-
lib/filters/filter-mpath.c | 3 +-
lib/filters/filter-partitioned.c | 3 +-
lib/filters/filter-persistent.c | 8 +-
lib/filters/filter-regex.c | 3 +-
lib/filters/filter-signature.c | 3 +-
lib/filters/filter-sysfs.c | 3 +-
lib/filters/filter-type.c | 3 +-
lib/filters/filter-usable.c | 3 +-
lib/label/hints.c | 1241 ++++++++++++++++++++++++++++++
lib/label/hints.h | 37 +
lib/label/label.c | 71 ++-
test/shell/hints.sh | 377 +++++++++
test/shell/process-each-duplicate-pvs.sh | 18 +-
tools/command.c | 2 +
tools/commands.h | 34 +-
tools/lvmcmdline.c | 30 +
tools/pvchange.c | 2 +
tools/pvcreate.c | 2 +
tools/pvdisplay.c | 7 +
tools/pvremove.c | 2 +
tools/pvscan.c | 9 +
tools/reporter.c | 7 +
tools/toollib.c | 33 +-
tools/tools.h | 3 +
tools/vgcfgrestore.c | 2 +
tools/vgcreate.c | 2 +
tools/vgextend.c | 2 +
tools/vgimportclone.c | 2 +
tools/vgmerge.c | 2 +
tools/vgreduce.c | 2 +
tools/vgremove.c | 2 +
tools/vgrename.c | 2 +
tools/vgsplit.c | 2 +
49 files changed, 1979 insertions(+), 51 deletions(-)
diff --git a/lib/Makefile.in b/lib/Makefile.in
index bde66f9..654c322 100644
--- a/lib/Makefile.in
+++ b/lib/Makefile.in
@@ -61,6 +61,7 @@ SOURCES =\
format_text/text_label.c \
freeseg/freeseg.c \
label/label.c \
+ label/hints.c \
locking/file_locking.c \
locking/locking.c \
log/log.c \
diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c
index da8b4d8..0ffa604 100644
--- a/lib/cache/lvmcache.c
+++ b/lib/cache/lvmcache.c
@@ -69,6 +69,7 @@ static DM_LIST_INIT(_unused_duplicate_devs);
static int _scanning_in_progress = 0;
static int _vgs_locked = 0;
static int _found_duplicate_pvs = 0; /* If we never see a duplicate PV we can skip checking for them later. */
+static int _found_duplicate_vgnames = 0;
int lvmcache_init(struct cmd_context *cmd)
{
@@ -131,6 +132,11 @@ int lvmcache_found_duplicate_pvs(void)
return _found_duplicate_pvs;
}
+int lvmcache_found_duplicate_vgnames(void)
+{
+ return _found_duplicate_vgnames;
+}
+
int lvmcache_get_unused_duplicate_devs(struct cmd_context *cmd, struct dm_list *head)
{
struct device_list *devl, *devl2;
@@ -1225,6 +1231,8 @@ static int _insert_vginfo(struct lvmcache_vginfo *new_vginfo, const char *vgid,
sizeof(uuid_primary)))
return_0;
+ _found_duplicate_vgnames = 1;
+
/*
* vginfo is kept for each VG with the same name.
* They are saved with the vginfo->next list.
@@ -2278,3 +2286,13 @@ int lvmcache_scan_mismatch(struct cmd_context *cmd, const char *vgname, const ch
return 1;
}
+int lvmcache_vginfo_has_pvid(struct lvmcache_vginfo *vginfo, char *pvid)
+{
+ struct lvmcache_info *info;
+
+ dm_list_iterate_items(info, &vginfo->infos) {
+ if (!strcmp(info->dev->pvid, pvid))
+ return 1;
+ }
+ return 0;
+}
diff --git a/lib/cache/lvmcache.h b/lib/cache/lvmcache.h
index ba60405..12f17df 100644
--- a/lib/cache/lvmcache.h
+++ b/lib/cache/lvmcache.h
@@ -169,6 +169,7 @@ int lvmcache_vgid_is_cached(const char *vgid);
uint64_t lvmcache_smallest_mda_size(struct lvmcache_info *info);
int lvmcache_found_duplicate_pvs(void);
+int lvmcache_found_duplicate_vgnames(void);
void lvmcache_pvscan_duplicate_check(struct cmd_context *cmd);
@@ -198,6 +199,8 @@ void lvmcache_set_independent_location(const char *vgname);
int lvmcache_scan_mismatch(struct cmd_context *cmd, const char *vgname, const char *vgid);
+int lvmcache_vginfo_has_pvid(struct lvmcache_vginfo *vginfo, char *pvid);
+
/*
* These are clvmd-specific functions and are not related to lvmcache.
* FIXME: rename these with a clvm_ prefix in place of lvmcache_
diff --git a/lib/commands/toolcontext.c b/lib/commands/toolcontext.c
index 63eafe8..39ab3df 100644
--- a/lib/commands/toolcontext.c
+++ b/lib/commands/toolcontext.c
@@ -1484,6 +1484,7 @@ struct cmd_context *create_config_context(void)
dm_list_init(&cmd->config_files);
dm_list_init(&cmd->tags);
+ dm_list_init(&cmd->hints);
if (!_init_lvm_conf(cmd))
goto_out;
diff --git a/lib/commands/toolcontext.h b/lib/commands/toolcontext.h
index 6396f6c..e8ce312 100644
--- a/lib/commands/toolcontext.h
+++ b/lib/commands/toolcontext.h
@@ -172,11 +172,16 @@ struct cmd_context {
unsigned is_clvmd:1;
unsigned use_full_md_check:1;
unsigned is_activating:1;
+ unsigned enable_hints:1; /* hints are enabled for cmds in general */
+ unsigned use_hints:1; /* if hints are enabled this cmd can use them */
+ unsigned pvscan_recreate_hints:1; /* enable special case hint handling for pvscan --cache */
+ unsigned scan_lvs:1;
/*
- * Filtering.
+ * Devices and filtering.
*/
struct dev_filter *filter;
+ struct dm_list hints;
/*
* Configuration.
diff --git a/lib/config/config_settings.h b/lib/config/config_settings.h
index f1d2826..e15494d 100644
--- a/lib/config/config_settings.h
+++ b/lib/config/config_settings.h
@@ -255,6 +255,20 @@ cfg(devices_external_device_info_source_CFG, "external_device_info_source", devi
" compiled with udev support.\n"
"#\n")
+cfg(devices_hints_CFG, "hints", devices_CFG_SECTION, 0, CFG_TYPE_STRING, DEFAULT_HINTS, vsn(2, 3, 2), NULL, 0, NULL,
+ "Use a local file to remember which devices have PVs on them.\n"
+ "Some commands will use this as an optimization to reduce device\n"
+ "scanning, and will only scan the listed PVs. Removing the hint file\n"
+ "will cause lvm to generate a new one. Disable hints if PVs will\n"
+ "be copied onto devices using non-lvm commands, like dd.\n"
+ "#\n"
+ "Accepted values:\n"
+ " all\n"
+ " Use all hints.\n"
+ " none\n"
+ " Use no hints.\n"
+ "#\n")
+
cfg_array(devices_preferred_names_CFG, "preferred_names", devices_CFG_SECTION, CFG_ALLOW_EMPTY | CFG_DEFAULT_UNDEFINED , CFG_TYPE_STRING, NULL, vsn(1, 2, 19), NULL, 0, NULL,
"Select which path name to display for a block device.\n"
"If multiple path names exist for a block device, and LVM needs to\n"
diff --git a/lib/config/defaults.h b/lib/config/defaults.h
index b45324b..06a5ecf 100644
--- a/lib/config/defaults.h
+++ b/lib/config/defaults.h
@@ -312,4 +312,6 @@
#define DEFAULT_SCAN_LVS 1
+#define DEFAULT_HINTS "all"
+
#endif /* _LVM_DEFAULTS_H */
diff --git a/lib/device/dev-cache.c b/lib/device/dev-cache.c
index fb48f1a..8afebfe 100644
--- a/lib/device/dev-cache.c
+++ b/lib/device/dev-cache.c
@@ -1473,7 +1473,7 @@ struct device *dev_cache_get(struct cmd_context *cmd, const char *name, struct d
return d;
if (f && !(d->flags & DEV_REGULAR)) {
- ret = f->passes_filter(cmd, f, d);
+ ret = f->passes_filter(cmd, f, d, NULL);
if (ret == -EAGAIN) {
log_debug_devs("get device by name defer filter %s", dev_name(d));
@@ -1546,7 +1546,7 @@ struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t dev, struct
if (!f)
return d;
- ret = f->passes_filter(cmd, f, d);
+ ret = f->passes_filter(cmd, f, d, NULL);
if (ret == -EAGAIN) {
log_debug_devs("get device by number defer filter %s", dev_name(d));
@@ -1603,7 +1603,7 @@ struct device *dev_iter_get(struct cmd_context *cmd, struct dev_iter *iter)
f = iter->filter;
if (f && !(d->flags & DEV_REGULAR)) {
- ret = f->passes_filter(cmd, f, d);
+ ret = f->passes_filter(cmd, f, d, NULL);
if (ret == -EAGAIN) {
log_debug_devs("get device by iter defer filter %s", dev_name(d));
diff --git a/lib/device/dev-cache.h b/lib/device/dev-cache.h
index 41c4a9c..9233c52 100644
--- a/lib/device/dev-cache.h
+++ b/lib/device/dev-cache.h
@@ -25,11 +25,12 @@ struct cmd_context;
* predicate for devices.
*/
struct dev_filter {
- int (*passes_filter) (struct cmd_context *cmd, struct dev_filter *f, struct device *dev);
+ int (*passes_filter) (struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name);
void (*destroy) (struct dev_filter *f);
void (*wipe) (struct dev_filter *f);
void *private;
unsigned use_count;
+ const char *name;
};
int dev_cache_index_devs(void);
diff --git a/lib/device/dev-type.c b/lib/device/dev-type.c
index 638f4b2..9278b51 100644
--- a/lib/device/dev-type.c
+++ b/lib/device/dev-type.c
@@ -79,6 +79,36 @@ int dev_is_pmem(struct device *dev)
return 0;
}
+int dev_is_lv(struct device *dev)
+{
+ FILE *fp;
+ char path[PATH_MAX];
+ char buffer[64];
+
+ if (dm_snprintf(path, sizeof(path), "%sdev/block/%d:%d/dm/uuid",
+ dm_sysfs_dir(),
+ (int) MAJOR(dev->dev),
+ (int) MINOR(dev->dev)) < 0) {
+ log_warn("Sysfs dm uuid path for %s is too long.", dev_name(dev));
+ return 0;
+ }
+
+ if (!(fp = fopen(path, "r")))
+ return 0;
+
+ if (!fgets(buffer, sizeof(buffer), fp)) {
+ log_warn("Failed to read %s.", path);
+ fclose(fp);
+ return 0;
+ }
+
+ fclose(fp);
+
+ if (!strncmp(buffer, "LVM-", 4))
+ return 1;
+ return 0;
+}
+
struct dev_types *create_dev_types(const char *proc_dir,
const struct dm_config_node *cn)
{
diff --git a/lib/device/dev-type.h b/lib/device/dev-type.h
index 75539e8..d349905 100644
--- a/lib/device/dev-type.h
+++ b/lib/device/dev-type.h
@@ -95,4 +95,6 @@ int dev_is_rotational(struct dev_types *dt, struct device *dev);
int dev_is_pmem(struct device *dev);
+int dev_is_lv(struct device *dev);
+
#endif
diff --git a/lib/device/device.h b/lib/device/device.h
index e879dbb..fa7e738 100644
--- a/lib/device/device.h
+++ b/lib/device/device.h
@@ -36,6 +36,7 @@
#define DEV_FILTER_AFTER_SCAN 0x00002000 /* apply filter after bcache has data */
#define DEV_FILTER_OUT_SCAN 0x00004000 /* filtered out during label scan */
#define DEV_BCACHE_WRITE 0x00008000 /* bcache_fd is open with RDWR */
+#define DEV_SCAN_FOUND_LABEL 0x00010000 /* label scan read dev and found label */
/*
* Support for external device info.
diff --git a/lib/filters/filter-composite.c b/lib/filters/filter-composite.c
index a9374ab..b0063f1 100644
--- a/lib/filters/filter-composite.c
+++ b/lib/filters/filter-composite.c
@@ -18,13 +18,15 @@
#include "lib/filters/filter.h"
#include "lib/device/device.h"
-static int _and_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _and_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
struct dev_filter **filters;
int ret;
for (filters = (struct dev_filter **) f->private; *filters; ++filters) {
- ret = (*filters)->passes_filter(cmd, *filters, dev);
+ if (use_filter_name && strcmp((*filters)->name, use_filter_name))
+ continue;
+ ret = (*filters)->passes_filter(cmd, *filters, dev, use_filter_name);
if (!ret)
return 0; /* No 'stack': a filter, not an error. */
@@ -33,12 +35,12 @@ static int _and_p(struct cmd_context *cmd, struct dev_filter *f, struct device *
return 1;
}
-static int _and_p_with_dev_ext_info(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _and_p_with_dev_ext_info(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
int r;
dev_ext_enable(dev, external_device_info_source());
- r = _and_p(cmd, f, dev);
+ r = _and_p(cmd, f, dev, use_filter_name);
dev_ext_disable(dev);
return r;
@@ -93,6 +95,7 @@ struct dev_filter *composite_filter_create(int n, int use_dev_ext_info, struct d
cft->wipe = _wipe;
cft->use_count = 0;
cft->private = filters_copy;
+ cft->name = "composite";
log_debug_devs("Composite filter initialised.");
diff --git a/lib/filters/filter-fwraid.c b/lib/filters/filter-fwraid.c
index 6f47692..992eba8 100644
--- a/lib/filters/filter-fwraid.c
+++ b/lib/filters/filter-fwraid.c
@@ -65,7 +65,7 @@ static int _dev_is_fwraid(struct device *dev)
#define MSG_SKIPPING "%s: Skipping firmware RAID component device"
static int _ignore_fwraid(struct cmd_context *cmd, struct dev_filter *f __attribute__((unused)),
- struct device *dev)
+ struct device *dev, const char *use_filter_name)
{
int ret;
@@ -113,6 +113,7 @@ struct dev_filter *fwraid_filter_create(struct dev_types *dt __attribute__((unus
f->destroy = _destroy;
f->use_count = 0;
f->private = NULL;
+ f->name = "fwraid";
log_debug_devs("Firmware RAID filter initialised.");
diff --git a/lib/filters/filter-internal.c b/lib/filters/filter-internal.c
index 8cc0011..c10e810 100644
--- a/lib/filters/filter-internal.c
+++ b/lib/filters/filter-internal.c
@@ -38,7 +38,7 @@ void internal_filter_clear(void)
}
static int _passes_internal(struct cmd_context *cmd, struct dev_filter *f __attribute__((unused)),
- struct device *dev)
+ struct device *dev, const char *use_filter_name)
{
struct device_list *devl;
@@ -74,6 +74,7 @@ struct dev_filter *internal_filter_create(void)
f->passes_filter = _passes_internal;
f->destroy = _destroy;
f->use_count = 0;
+ f->name = "internal";
log_debug_devs("Internal filter initialised.");
diff --git a/lib/filters/filter-md.c b/lib/filters/filter-md.c
index 9cc1a06..d6dd28c 100644
--- a/lib/filters/filter-md.c
+++ b/lib/filters/filter-md.c
@@ -82,7 +82,7 @@
* that will not pass.
*/
-static int _passes_md_filter(struct cmd_context *cmd, struct dev_filter *f __attribute__((unused)), struct device *dev)
+static int _passes_md_filter(struct cmd_context *cmd, struct dev_filter *f __attribute__((unused)), struct device *dev, const char *use_filter_name)
{
int ret;
@@ -145,6 +145,7 @@ struct dev_filter *md_filter_create(struct cmd_context *cmd, struct dev_types *d
f->destroy = _destroy;
f->use_count = 0;
f->private = dt;
+ f->name = "md";
log_debug_devs("MD filter initialised.");
diff --git a/lib/filters/filter-mpath.c b/lib/filters/filter-mpath.c
index bcd1e52..f0374b4 100644
--- a/lib/filters/filter-mpath.c
+++ b/lib/filters/filter-mpath.c
@@ -247,7 +247,7 @@ static int _dev_is_mpath(struct dev_filter *f, struct device *dev)
#define MSG_SKIPPING "%s: Skipping mpath component device"
-static int _ignore_mpath(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _ignore_mpath(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
if (_dev_is_mpath(f, dev) == 1) {
if (dev->ext.src == DEV_EXT_NONE)
@@ -288,6 +288,7 @@ struct dev_filter *mpath_filter_create(struct dev_types *dt)
f->destroy = _destroy;
f->use_count = 0;
f->private = dt;
+ f->name = "mpath";
log_debug_devs("mpath filter initialised.");
diff --git a/lib/filters/filter-partitioned.c b/lib/filters/filter-partitioned.c
index 6418cdf..1a70054 100644
--- a/lib/filters/filter-partitioned.c
+++ b/lib/filters/filter-partitioned.c
@@ -19,7 +19,7 @@
#define MSG_SKIPPING "%s: Skipping: Partition table signature found"
-static int _passes_partitioned_filter(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _passes_partitioned_filter(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
struct dev_types *dt = (struct dev_types *) f->private;
int ret;
@@ -66,6 +66,7 @@ struct dev_filter *partitioned_filter_create(struct dev_types *dt)
f->destroy = _partitioned_filter_destroy;
f->use_count = 0;
f->private = dt;
+ f->name = "partitioned";
log_debug_devs("Partitioned filter initialised.");
diff --git a/lib/filters/filter-persistent.c b/lib/filters/filter-persistent.c
index 130b1e5..afa32d4 100644
--- a/lib/filters/filter-persistent.c
+++ b/lib/filters/filter-persistent.c
@@ -71,13 +71,16 @@ static void _persistent_filter_wipe(struct dev_filter *f)
dm_hash_wipe(pf->devices);
}
-static int _lookup_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _lookup_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
struct pfilter *pf = (struct pfilter *) f->private;
void *l;
struct dm_str_list *sl;
int pass = 1;
+ if (use_filter_name && strcmp(f->name, use_filter_name))
+ return pf->real->passes_filter(cmd, pf->real, dev, use_filter_name);
+
if (dm_list_empty(&dev->aliases)) {
log_debug_devs("%d:%d: filter cache skipping (no name)",
(int)MAJOR(dev->dev), (int)MINOR(dev->dev));
@@ -102,7 +105,7 @@ static int _lookup_p(struct cmd_context *cmd, struct dev_filter *f, struct devic
if (!l) {
dev->flags &= ~DEV_FILTER_AFTER_SCAN;
- pass = pf->real->passes_filter(cmd, pf->real, dev);
+ pass = pf->real->passes_filter(cmd, pf->real, dev, use_filter_name);
if (!pass) {
/*
@@ -182,6 +185,7 @@ struct dev_filter *persistent_filter_create(struct dev_types *dt, struct dev_fil
f->use_count = 0;
f->private = pf;
f->wipe = _persistent_filter_wipe;
+ f->name = "persistent";
log_debug_devs("Persistent filter initialised.");
diff --git a/lib/filters/filter-regex.c b/lib/filters/filter-regex.c
index 1a8e8a2..e439b36 100644
--- a/lib/filters/filter-regex.c
+++ b/lib/filters/filter-regex.c
@@ -145,7 +145,7 @@ static int _build_matcher(struct rfilter *rf, const struct dm_config_value *val)
return r;
}
-static int _accept_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _accept_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
int m, first = 1, rejected = 0;
struct rfilter *rf = (struct rfilter *) f->private;
@@ -212,6 +212,7 @@ struct dev_filter *regex_filter_create(const struct dm_config_value *patterns)
f->destroy = _regex_destroy;
f->use_count = 0;
f->private = rf;
+ f->name = "regex";
log_debug_devs("Regex filter initialised.");
diff --git a/lib/filters/filter-signature.c b/lib/filters/filter-signature.c
index 5c5796f..6a81203 100644
--- a/lib/filters/filter-signature.c
+++ b/lib/filters/filter-signature.c
@@ -22,7 +22,7 @@
#define BUFSIZE 4096
static int _ignore_signature(struct cmd_context *cmd, struct dev_filter *f __attribute__((unused)),
- struct device *dev)
+ struct device *dev, const char *use_filter_name)
{
char buf[BUFSIZE];
int ret = 0;
@@ -81,6 +81,7 @@ struct dev_filter *signature_filter_create(struct dev_types *dt)
f->destroy = _destroy;
f->use_count = 0;
f->private = dt;
+ f->name = "signature";
log_debug_devs("signature filter initialised.");
diff --git a/lib/filters/filter-sysfs.c b/lib/filters/filter-sysfs.c
index c77c4a6..ebca808 100644
--- a/lib/filters/filter-sysfs.c
+++ b/lib/filters/filter-sysfs.c
@@ -260,7 +260,7 @@ static int _init_devs(struct dev_set *ds)
}
-static int _accept_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _accept_p(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
struct dev_set *ds = (struct dev_set *) f->private;
@@ -323,6 +323,7 @@ struct dev_filter *sysfs_filter_create(void)
f->destroy = _destroy;
f->use_count = 0;
f->private = ds;
+ f->name = "sysfs";
log_debug_devs("Sysfs filter initialised.");
diff --git a/lib/filters/filter-type.c b/lib/filters/filter-type.c
index 3b0a644..1d08370 100644
--- a/lib/filters/filter-type.c
+++ b/lib/filters/filter-type.c
@@ -17,7 +17,7 @@
#include "lib/misc/lib.h"
#include "lib/filters/filter.h"
-static int _passes_lvm_type_device_filter(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _passes_lvm_type_device_filter(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
struct dev_types *dt = (struct dev_types *) f->private;
const char *name = dev_name(dev);
@@ -53,6 +53,7 @@ struct dev_filter *lvm_type_filter_create(struct dev_types *dt)
f->destroy = _lvm_type_filter_destroy;
f->use_count = 0;
f->private = dt;
+ f->name = "type";
log_debug_devs("LVM type filter initialised.");
diff --git a/lib/filters/filter-usable.c b/lib/filters/filter-usable.c
index 6997368..b3ff650 100644
--- a/lib/filters/filter-usable.c
+++ b/lib/filters/filter-usable.c
@@ -105,7 +105,7 @@ static int _check_pv_min_size(struct device *dev)
return 0;
}
-static int _passes_usable_filter(struct cmd_context *cmd, struct dev_filter *f, struct device *dev)
+static int _passes_usable_filter(struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name)
{
struct filter_data *data = f->private;
filter_mode_t mode = data->mode;
@@ -185,6 +185,7 @@ struct dev_filter *usable_filter_create(struct cmd_context *cmd, struct dev_type
f->passes_filter = _passes_usable_filter;
f->destroy = _usable_filter_destroy;
f->use_count = 0;
+ f->name = "usable";
if (!(data = zalloc(sizeof(struct filter_data)))) {
log_error("Usable device filter mode allocation failed");
diff --git a/lib/label/hints.c b/lib/label/hints.c
new file mode 100644
index 0000000..bdd70a9
--- /dev/null
+++ b/lib/label/hints.c
@@ -0,0 +1,1241 @@
+/*
+ * Copyright (C) 2018 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * There are four different ways that commands handle hints:
+ *
+ * 1. Commands that use hints to reduce scanning, and create new
+ * hints when needed:
+ *
+ * fullreport, lvchange, lvcreate, lvdisplay, lvremove, lvresize,
+ * lvs, pvdisplay, lvpoll, pvs, vgchange, vgck, vgdisplay, vgs,
+ * lvextend, lvreduce, lvrename
+ *
+ * 2. Commands that just remove existing hints:
+ *
+ * pvcreate, pvremove, vgcreate, vgremove, vgextend, vgreduce,
+ * vgcfgrestore, vgimportclone, vgmerge, vgsplit, pvchange
+ *
+ * 3. Commands that ignore hints:
+ *
+ * lvconvert, lvmdiskscan, lvscan, pvresize, pvck, pvmove, pvscan,
+ * vgcfgbackup, vgexport, vgimport, vgscan, pvs -a, pvdisplay -a
+ *
+ * 4. Command that removes existing hints and creates new hints:
+ *
+ * pvscan --cache
+ *
+ *
+ * For 1, hints are used to reduce scanning by:
+ * . get the list of all devices on the system from dev_cache_scan()
+ * . remove devices from that list which are not listed in hints
+ * . do scan the remaining list of devices
+ *
+ * label_scan() is where those steps are implemented:
+ * . dev_cache_scan() produces all_devs list
+ * . get_hints(all_devs, scan_devs, &newhints)
+ * moves some devs from all_devs to scan_devs list (or sets newhints
+ * if no hints are applied, and a new hints file should be created)
+ * . _scan_list(scan_devs) does the label scan
+ * . if newhints was set, call write_hint_file() to create new hints
+ * based on which devs _scan_list saw an lvm label on
+ *
+ * For 2, commands that change "global state" remove existing hints.
+ * The hints become incorrect as a result of the changes the command
+ * is making. "global state" is lvm state that is not isolated within a VG.
+ * (This is basically: which devices are PVs, and which VG names are used.)
+ *
+ * Commands that change global state do not create new hints because
+ * it's much simpler to create hints based solely on the result of a
+ * full standard label scan, i.e. which devices had an lvm label.
+ * (It's much more complicated to create hints based on making specific
+ * changes to existing hints based on what the command has changed.)
+ *
+ * For 3, these commands are a combination of: uncommon commands that
+ * don't need optimization, commands where the purpose is to read all
+ * devices, commands dealing with global state where it's important to
+ * not miss anything, commands where it's safer to know everything.
+ *
+ * For 4, this is the traditional way of forcing any locally cached
+ * state to be cleared and regenerated. This would be used to reset
+ * hints after doing something that invalidates the hints in a way
+ * that lvm couldn't detect itself, e.g. using dd to copy a PV to
+ * a non-PV device. (A user could also just rm /run/lvm/hints in
+ * place of running pvscan --cache.)
+ *
+ *
+ * Creating hints:
+ *
+ * A command in list 1 above calls get_hints() to try to read the
+ * hints file. get_hints() will sometimes not return any hints, in
+ * which case the label_scan will scan all devices. This happens if:
+ *
+ * a. the /run/lvm/hints file does not exist *
+ * b. the /run/lvm/hints file is empty *
+ * c. the /run/lvm/hints file content is not applicable *
+ * d. the /run/lvm/newhints file exists *
+ * e. the /run/lvm/nohints file exists
+ * f. a shared nonblocking flock on /run/lvm/hints fails
+ *
+ * When get_hints(all_devs, scan_devs, &newhints) does not find hints to use,
+ * it will sometimes set "newhints" so that the command will create a new
+ * hints file after scanning all the devs. [* These commands create a
+ * new hint file after scanning.]
+ *
+ * After scanning a dev list that was reduced by applying hints, label_scan
+ * calls validate_hints() to check if the hints were consistent with what
+ * the scan saw on the devs. Sometimes it's not, in which case the command
+ * then scans the remaining devs, and creates /run/lvm/newhints to signal
+ * to the next command that it should create new hints.
+ *
+ * Causes of each case above:
+ * a) First command run, or a user removed the file
+ * b) A command from list 2 cleared the hint file
+ * c) See below
+ * d) Another command from list 1 found invalid hints after scanning.
+ * A command from list 2 also creates a newhints file in addition
+ * to clearing the hint file.
+ * e) A command from list 2 is blocking other commands from using
+ * hints while it makes global changes.
+ * f) A command from list 2 is holding the ex flock to block
+ * other commands from using hints while it makes global changes.
+ *
+ * The content of the hint file is ignored and invalidated in get_hints if:
+ *
+ * . The lvm.conf filters or scan_lvs setting used by the command that
+ * created the hints do not match the settings used by this command.
+ * When these settings change, different PVs can become visible,
+ * making previous hints invalid.
+ *
+ * . The list of devices on the system changes. When a new device
+ * appears on the system, it may have a PV that was not not around
+ * when the hints were created, and it needs to be scanned.
+ * (A hash of all dev names on the system is used to detect when
+ * the list of devices changes and hints need to be recreated.)
+ *
+ * The hint file is invalidated in validate_hints if:
+ *
+ * . The devs in the hint file have a different PVID or VG name
+ * than what was seen during the scan.
+ *
+ * . Duplicate PVs were seen in the scan.
+ *
+ * . Others may be added.
+ *
+ */
+
+#include "base/memory/zalloc.h"
+#include "lib/misc/lib.h"
+#include "lib/label/label.h"
+#include "lib/misc/crc.h"
+#include "lib/mm/xlate.h"
+#include "lib/cache/lvmcache.h"
+#include "lib/device/bcache.h"
+#include "lib/commands/toolcontext.h"
+#include "lib/activate/activate.h"
+#include "lib/label/hints.h"
+#include "lib/device/dev-type.h"
+
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/sysmacros.h>
+
+static const char *_hints_file = DEFAULT_RUN_DIR "/hints";
+static const char *_nohints_file = DEFAULT_RUN_DIR "/nohints";
+static const char *_newhints_file = DEFAULT_RUN_DIR "/newhints";
+
+/*
+ * Format of hints file. Increase the major number when
+ * making a change to the hint file format that older lvm
+ * versions can't use. Older lvm versions will not try to
+ * use the hint file if the major number in it is larger
+ * than they were built with. Increase the minor number
+ * when adding features that older lvm versions can just
+ * ignore while continuing to use the other content.
+ */
+#define HINTS_VERSION_MAJOR 1
+#define HINTS_VERSION_MINOR 1
+
+#define HINT_LINE_LEN (PATH_MAX + NAME_LEN + ID_LEN + 64)
+#define HINT_LINE_WORDS 4
+static char _hint_line[HINT_LINE_LEN];
+
+static int _hints_fd = -1;
+
+#define NONBLOCK 1
+
+#define NEWHINTS_NONE 0
+#define NEWHINTS_FILE 1
+#define NEWHINTS_INIT 2
+#define NEWHINTS_REFRESH 3
+#define NEWHINTS_EMPTY 4
+
+static int _hints_exists(void)
+{
+ struct stat buf;
+
+ if (!stat(_hints_file, &buf))
+ return 1;
+ if (errno != ENOENT)
+ log_debug("hints_exist errno %d", errno);
+ return 0;
+}
+
+static int _nohints_exists(void)
+{
+ struct stat buf;
+
+ if (!stat(_nohints_file, &buf))
+ return 1;
+ if (errno != ENOENT)
+ log_debug("nohints_exist errno %d", errno);
+ return 0;
+}
+
+static int _newhints_exists(void)
+{
+ struct stat buf;
+
+ if (!stat(_newhints_file, &buf))
+ return 1;
+ if (errno != ENOENT)
+ log_debug("newhints_exist errno %d", errno);
+ return 0;
+}
+
+static int _touch_newhints(void)
+{
+ FILE *fp;
+
+ if (!(fp = fopen(_newhints_file, "w")))
+ return_0;
+ if (fclose(fp))
+ stack;
+ return 1;
+}
+
+static int _touch_nohints(void)
+{
+ FILE *fp;
+
+ if (!(fp = fopen(_nohints_file, "w")))
+ return_0;
+ if (fclose(fp))
+ stack;
+ return 1;
+}
+
+static int _touch_hints(void)
+{
+ FILE *fp;
+
+ if (!(fp = fopen(_hints_file, "w")))
+ return_0;
+ if (fclose(fp))
+ stack;
+ return 1;
+}
+
+static void _unlink_nohints(void)
+{
+ if (unlink(_nohints_file))
+ log_debug("unlink_nohints errno %d", errno);
+}
+
+static void _unlink_hints(void)
+{
+ if (unlink(_hints_file))
+ log_debug("unlink_hints errno %d", errno);
+}
+
+static void _unlink_newhints(void)
+{
+ if (unlink(_newhints_file))
+ log_debug("unlink_newhints errno %d", errno);
+}
+
+static int _clear_hints(struct cmd_context *cmd)
+{
+ FILE *fp;
+ time_t t;
+
+ if (!(fp = fopen(_hints_file, "w"))) {
+ log_warn("Failed to clear hint file.");
+ /* shouldn't happen, but try to unlink in case */
+ _unlink_hints();
+ return 0;
+ }
+
+ t = time(NULL);
+
+ fprintf(fp, "# Created empty by %s pid %d %s", cmd->name, getpid(), ctime(&t));
+
+ if (fflush(fp))
+ log_debug("clear_hints flush errno %d", errno);
+
+ if (fclose(fp))
+ log_debug("clear_hints close errno %d", errno);
+
+ return 1;
+}
+
+static int _lock_hints(int mode, int nonblock)
+{
+ int fd;
+ int op = mode;
+ int ret;
+
+ if (nonblock)
+ op |= LOCK_NB;
+
+ if (_hints_fd != -1) {
+ log_warn("lock_hints existing fd %d", _hints_fd);
+ return 0;
+ }
+
+ fd = open(_hints_file, O_RDWR);
+ if (fd < 0) {
+ log_debug("lock_hints open errno %d", errno);
+ return 0;
+ }
+
+
+ ret = flock(fd, op);
+ if (!ret) {
+ _hints_fd = fd;
+ return 1;
+ }
+
+ if (close(fd))
+ stack;
+ return 0;
+}
+
+static void _unlock_hints(void)
+{
+ int ret;
+
+ if (_hints_fd == -1) {
+ log_warn("unlock_hints no existing fd");
+ return;
+ }
+
+ ret = flock(_hints_fd, LOCK_UN);
+ if (ret)
+ log_warn("unlock_hints flock errno %d", errno);
+
+ if (close(_hints_fd))
+ stack;
+ _hints_fd = -1;
+}
+
+static struct hint *_find_hint_name(struct dm_list *hints, const char *name)
+{
+ struct hint *hint;
+
+ dm_list_iterate_items(hint, hints) {
+ if (!strcmp(hint->name, name))
+ return hint;
+ }
+ return NULL;
+}
+
+/*
+ * Decide if a given device name should be included in the hint hash.
+ * If it is, then the hash changes if the device is added or removed
+ * from the system, which causes the hints to be regenerated.
+ * If it is not, then the device being added/removed from the system
+ * does not change the hint hash, which means hints remain unchanged.
+ *
+ * If we know that lvm does not want to scan this device, then it should
+ * be excluded from the hint hash. If a dev is excluded by the regex
+ * filter or by scan_lvs setting, then we know lvm doesn't want to scan
+ * it, so when it is added/removed the scanning results won't change, and
+ * we don't want to regenerate hints.
+ *
+ * One effect of this is that the regex filter and scan_lvs setting also
+ * need to be saved in the hint file, since if those settings change,
+ * it may impact what devs lvm wants to scan, and therefore change what
+ * the hints are.
+ *
+ * We do not need or want to apply all filters to a device here. The full
+ * filters still determine if a device is scanned and used. This is simply
+ * used to decide if the device name should be included in the hash,
+ * where the changing hash triggers hints to be recreated. So, by
+ * including a device here which is excluded by the real filters, the result is
+ * simply that we could end up recreating hints more often than necessary,
+ * which is not a problem. Not recreating hints when we should is a bigger
+ * problem, so it's best to include devices here if we're unsure.
+ *
+ * Any filter used here obviously cannot rely on reading the device, since
+ * the whole point of the hints is to avoid reading the device.
+ *
+ * It's common for the system to include a device path for a disconnected
+ * device and report zero size for it (e.g. a loop device). When the
+ * device is connected, a new device name doesn't appear, but the dev size
+ * for the existing device is now reported as non-zero. So, if a device
+ * is connected/disconnected, changing the size from/to zero, it is
+ * included/excluded in the hint hash.
+ */
+
+static int _dev_in_hint_hash(struct cmd_context *cmd, struct device *dev)
+{
+ uint64_t devsize = 0;
+
+ if (!cmd->filter->passes_filter(cmd, cmd->filter, dev, "regex"))
+ return 0;
+
+ if (!cmd->filter->passes_filter(cmd, cmd->filter, dev, "type"))
+ return 0;
+
+ /* exclude LVs from hint accounting when scan_lvs is 0 */
+ if (!cmd->scan_lvs && dm_is_dm_major(MAJOR(dev->dev)) && dev_is_lv(dev))
+ return 0;
+
+ if (dev_get_size(dev, &devsize) && !devsize)
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Hints were used to reduce devs that were scanned. After the reduced
+ * scanning is done, this is called to check if the hints may have been
+ * incorrect or insufficient, in which case we want to continue scanning all
+ * the other (unhinted) devices, as would be done when no hints are used.
+ * This should not generally happen, but is done in an attempt to catch
+ * any unusual situations where the hints become incorrect from something
+ * unexpected.
+ */
+int validate_hints(struct cmd_context *cmd, struct dm_list *hints)
+{
+ struct hint *hint;
+ struct dev_iter *iter;
+ struct device *dev;
+ int ret = 1;
+
+ /* No commands are using hints. */
+ if (!cmd->enable_hints)
+ return 0;
+
+ /* This command does not use hints. */
+ if (!cmd->use_hints && !cmd->pvscan_recreate_hints)
+ return 0;
+
+ if (lvmcache_found_duplicate_pvs()) {
+ log_debug("Hints not used with duplicate pvs");
+ ret = 0;
+ goto out;
+ }
+
+ if (lvmcache_found_duplicate_vgnames()) {
+ log_debug("Hints not used with duplicate vg names");
+ ret = 0;
+ goto out;
+ }
+
+ /*
+ * Check that the PVID saved in the hint for each device matches the
+ * PVID that the scan found on the device. If not, then the hints
+ * became stale somehow (e.g. manually copying devices with dd) and
+ * need to be refreshed.
+ */
+ if (!(iter = dev_iter_create(NULL, 0)))
+ return 0;
+ while ((dev = dev_iter_get(cmd, iter))) {
+ if (!(hint = _find_hint_name(hints, dev_name(dev))))
+ continue;
+
+ /* The cmd hasn't needed this hint's dev so it's not been scanned. */
+ if (!hint->chosen)
+ continue;
+
+ if (strcmp(dev->pvid, hint->pvid)) {
+ log_debug("Invalid hint device %d:%d %s pvid %s had hint pvid %s",
+ major(hint->devt), minor(hint->devt), dev_name(dev),
+ dev->pvid, hint->pvid);
+ ret = 0;
+ }
+ }
+ dev_iter_destroy(iter);
+
+ /*
+ * Check in lvmcache to see if the scan noticed any missing PVs
+ * which might mean the hints left out a device that we should
+ * have scanned.
+ *
+ * FIXME: the scan cannot currently detect missing PVs.
+ * They are only detected in vg_read when the PVIDs listed
+ * in the metadata are looked for and not found. This could
+ * be addressed by at least saving the number of expected PVs
+ * during the scan (in the summary), and then comparing that
+ * number with the number of PVs found in the hints listing
+ * that VG name.
+ */
+
+ /*
+ * The scan placed a summary of each VG (vginfo) and PV (info)
+ * into lvmcache lists. Check in lvmcache to see if the VG name
+ * for each PV matches the vgname saved in the hint for the PV.
+ */
+ dm_list_iterate_items(hint, hints) {
+ struct lvmcache_vginfo *vginfo;
+
+ /* The cmd hasn't needed this hint's dev so it's not been scanned. */
+ if (!hint->chosen)
+ continue;
+
+ if (!hint->vgname[0] || (hint->vgname[0] == '-'))
+ continue;
+
+ if (!(vginfo = lvmcache_vginfo_from_vgname(hint->vgname, NULL))) {
+ log_debug("Invalid hint device %d:%d %s pvid %s had vgname %s no VG info.",
+ major(hint->devt), minor(hint->devt), hint->name,
+ hint->pvid, hint->vgname);
+ ret = 0;
+ continue;
+ }
+
+ if (!lvmcache_vginfo_has_pvid(vginfo, hint->pvid)) {
+ log_debug("Invalid hint device %d:%d %s pvid %s had vgname %s no PV info.",
+ major(hint->devt), minor(hint->devt), hint->name,
+ hint->pvid, hint->vgname);
+ ret = 0;
+ continue;
+ }
+ }
+
+out:
+ if (!ret) {
+ /*
+ * Force next cmd to recreate hints. If we can't
+ * create newhints, the next cmd should get here
+ * like we have. We don't use _clear_hints because
+ * we don't want to take an ex lock here.
+ */
+ if (!_touch_newhints())
+ stack;
+ }
+
+ return ret;
+}
+
+/*
+ * For devs that match entries in hints, move them from devs_in to devs_out.
+ */
+static void _apply_hints(struct cmd_context *cmd, struct dm_list *hints,
+ char *vgname, struct dm_list *devs_in, struct dm_list *devs_out)
+{
+ struct hint *hint;
+ struct device_list *devl, *devl2;
+ struct dm_list *name_list;
+ struct dm_str_list *name_sl;
+
+ dm_list_iterate_items_safe(devl, devl2, devs_in) {
+ if (!(name_list = dm_list_first(&devl->dev->aliases)))
+ continue;
+ name_sl = dm_list_item(name_list, struct dm_str_list);
+
+ if (!(hint = _find_hint_name(hints, name_sl->str)))
+ continue;
+
+ /* if vgname is set, pick hints with matching vgname */
+ if (vgname && hint->vgname[0] && (hint->vgname[0] != '-')) {
+ if (strcmp(vgname, hint->vgname))
+ continue;
+ }
+
+ dm_list_del(&devl->list);
+ dm_list_add(devs_out, &devl->list);
+ hint->chosen = 1;
+ }
+}
+
+/*
+ * Return 1 and needs_refresh 0: the hints can be used
+ * Return 1 and needs_refresh 1: the hints can't be used and should be updated
+ * Return 0: the hints can't be used
+ *
+ * recreate is set if hint file should be refreshed/recreated
+ */
+static int _read_hint_file(struct cmd_context *cmd, struct dm_list *hints, int *needs_refresh)
+{
+ char devpath[PATH_MAX];
+ FILE *fp;
+ const struct dm_config_node *cn;
+ struct dev_iter *iter;
+ struct hint *hint;
+ struct device *dev;
+ char *split[HINT_LINE_WORDS];
+ char *name, *pvid, *devn, *vgname, *p;
+ uint32_t read_hash = 0;
+ uint32_t calc_hash = INITIAL_CRC;
+ uint32_t read_count = 0;
+ uint32_t calc_count = 0;
+ int found = 0;
+ int keylen;
+ int hv_major, hv_minor;
+ int major, minor;
+ int ret = 1;
+ int i;
+
+ if (!(fp = fopen(_hints_file, "r")))
+ return 0;
+
+ for (i = 0; i < HINT_LINE_WORDS; i++)
+ split[i] = NULL;
+
+ while (fgets(_hint_line, sizeof(_hint_line), fp)) {
+ if (!(hint = zalloc(sizeof(struct hint)))) {
+ ret = 0;
+ break;
+ }
+
+ if (_hint_line[0] == '#')
+ continue;
+
+ if ((p = strchr(_hint_line, '\n')))
+ *p = '\0';
+
+ /*
+ * Data in the hint file cannot be used if:
+ * - the hints file major version is larger than used by this cmd
+ * - filters used for hints don't match filters used by this cmd
+ * - scan_lvs setting used when creating hints doesn't match the
+ * scan_lvs setting used by this cmd
+ * - the list of devs used when creating hints does not match the
+ * list of devs used by this cmd
+ */
+
+ keylen = strlen("hints_version:");
+ if (!strncmp(_hint_line, "hints_version:", keylen)) {
+ if (sscanf(_hint_line + keylen, "%d.%d", &hv_major, &hv_minor) != 2) {
+ log_debug("ignore hints with unknown version %d.%d", hv_major, hv_minor);
+ *needs_refresh = 1;
+ break;
+ }
+
+ if (hv_major > HINTS_VERSION_MAJOR) {
+ log_debug("ignore hints with newer major version %d.%d", hv_major, hv_minor);
+ *needs_refresh = 1;
+ break;
+ }
+ continue;
+ }
+
+ keylen = strlen("global_filter:");
+ if (!strncmp(_hint_line, "global_filter:", keylen)) {
+ cn = find_config_tree_array(cmd, devices_global_filter_CFG, NULL);
+ if (strcmp(cn->v->v.str, _hint_line + keylen)) {
+ log_debug("ignore hints with different global_filter");
+ *needs_refresh = 1;
+ break;
+ }
+ continue;
+ }
+
+ keylen = strlen("filter:");
+ if (!strncmp(_hint_line, "filter:", keylen)) {
+ cn = find_config_tree_array(cmd, devices_filter_CFG, NULL);
+ if (strcmp(cn->v->v.str, _hint_line + keylen)) {
+ log_debug("ignore hints with different filter");
+ *needs_refresh = 1;
+ break;
+ }
+ continue;
+ }
+
+ keylen = strlen("scan_lvs:");
+ if (!strncmp(_hint_line, "scan_lvs:", keylen)) {
+ int scan_lvs = 0;
+ sscanf(_hint_line + keylen, "%u", &scan_lvs);
+
+ if (scan_lvs != cmd->scan_lvs) {
+ log_debug("ignore hints with different scan_lvs");
+ *needs_refresh = 1;
+ break;
+ }
+ continue;
+ }
+
+ keylen = strlen("devs_hash:");
+ if (!strncmp(_hint_line, "devs_hash:", keylen)) {
+ sscanf(_hint_line + keylen, "%u %u", &read_hash, &read_count);
+ continue;
+ }
+
+ /*
+ * Ignore any other line prefixes that we don't recognize.
+ */
+ keylen = strlen("scan:");
+ if (strncmp(_hint_line, "scan:", keylen))
+ continue;
+
+ if (dm_split_words(_hint_line, HINT_LINE_WORDS, 0, split) < 1)
+ continue;
+
+ name = split[0];
+ pvid = split[1];
+ devn = split[2];
+ vgname = split[3];
+
+ if (name && !strncmp(name, "scan:", 5))
+ strncpy(hint->name, name+5, PATH_MAX);
+
+ if (pvid && !strncmp(pvid, "pvid:", 5))
+ strncpy(hint->pvid, pvid+5, ID_LEN);
+
+ if (devn && sscanf(devn, "devn:%d:%d", &major, &minor) == 2)
+ hint->devt = makedev(major, minor);
+
+ if (vgname && (strlen(vgname) > 3) && (vgname[4] != '-'))
+ strncpy(hint->vgname, vgname+3, NAME_LEN);
+
+ log_debug("add hint %s %s %d:%d %s", hint->name, hint->pvid, major, minor, vgname);
+ dm_list_add(hints, &hint->list);
+ found++;
+ }
+
+ if (fclose(fp))
+ stack;
+
+ if (!ret)
+ return 0;
+
+ if (!found)
+ return 1;
+
+ if (*needs_refresh)
+ return 1;
+
+ /*
+ * Calculate and compare hash of devices that may be scanned.
+ */
+ if (!(iter = dev_iter_create(NULL, 0)))
+ return 0;
+ while ((dev = dev_iter_get(cmd, iter))) {
+ if (!_dev_in_hint_hash(cmd, dev))
+ continue;
+ memset(devpath, 0, sizeof(devpath));
+ strncpy(devpath, dev_name(dev), PATH_MAX);
+ calc_hash = calc_crc(calc_hash, (const uint8_t *)devpath, strlen(devpath));
+ calc_count++;
+ }
+ dev_iter_destroy(iter);
+
+ if (read_hash && (read_hash != calc_hash)) {
+ /* The count is just informational. */
+ log_debug("ignore hints with read_hash %u count %u calc_hash %u count %u",
+ read_hash, read_count, calc_hash, calc_count);
+ *needs_refresh = 1;
+ return 1;
+ }
+
+ log_debug("accept hints found %d", dm_list_size(hints));
+ return 1;
+}
+
+/*
+ * Include any device in the hints that label_scan saw which had an lvm label
+ * header. label_scan set DEV_SCAN_FOUND_LABEL on the dev if it saw an lvm
+ * header. We only create new hints here after a complete label_scan at the
+ * start of the command. (It makes things far simpler to always just recreate
+ * hints from a clean, full scan, than to try to make granular updates to the
+ * content of an existing hint file.)
+ *
+ * Hints are not valid from one command to the next if the commands are using
+ * different filters or different scan_lvs settings. These differences would
+ * cause the two commands to consider different devices for scanning.
+ *
+ * If the set of devices on the system changes from one cmd to the next
+ * (excluding those skipped by filters or scan_lvs), the hints are ignored
+ * since there may be a new device that is now present that should be scanned
+ * that was not present when the hints were created. The change in the set of
+ * devices is detected by creating a hash of all dev names. When a device is
+ * added or removed from this system, this hash changes triggering hints to be
+ * recreated.
+ *
+ * (This hash detection depends on the two commands iterating through dev names
+ * in the same order, which happens because the devs are inserted into the
+ * btree using devno. If the btree implementation changes, then we need
+ * to sort the dev names here before iterating through them.)
+ *
+ * N.B. the config setting pv_min_size should technically be included in
+ * the hint file like the filter and scan_lvs setting, since increasing
+ * pv_min_size can cause new devices to be scanned that were not before.
+ * It is left out since it is not often changed, but could be easily added.
+ */
+
+int write_hint_file(struct cmd_context *cmd, int newhints)
+{
+ char devpath[PATH_MAX];
+ FILE *fp;
+ const struct dm_config_node *cn;
+ struct lvmcache_info *info;
+ struct dev_iter *iter;
+ struct device *dev;
+ const char *vgname;
+ uint32_t hash = INITIAL_CRC;
+ uint32_t count = 0;
+ time_t t;
+ int ret = 1;
+
+ /* This function should not be called if !enable_hints or !use_hints. */
+
+ /* No commands are using hints. */
+ if (!cmd->enable_hints)
+ return 0;
+
+ /* This command does not use hints. */
+ if (!cmd->use_hints && !cmd->pvscan_recreate_hints)
+ return 0;
+
+ if (lvmcache_found_duplicate_pvs() || lvmcache_found_duplicate_vgnames()) {
+ /*
+ * When newhints is EMPTY, it means get_hints() found an empty
+ * hint file. So we scanned all devs and found duplicate pvids
+ * or duplicate vgnames (which is probably why the hints were
+ * empty.) Since the hint file is already empty, we don't need
+ * to recreate an empty file.
+ */
+ if (newhints == NEWHINTS_EMPTY)
+ return 1;
+ }
+
+ log_debug("Writing hint file %d", newhints);
+
+ if (!(fp = fopen(_hints_file, "w"))) {
+ ret = 0;
+ goto out_unlock;
+ }
+
+ t = time(NULL);
+
+ if (lvmcache_found_duplicate_pvs() || lvmcache_found_duplicate_vgnames()) {
+ fprintf(fp, "# Created empty by %s pid %d %s", cmd->name, getpid(), ctime(&t));
+
+ /* leave a comment about why it's empty in case someone is curious */
+ if (lvmcache_found_duplicate_pvs())
+ fprintf(fp, "# info: duplicate_pvs\n");
+ if (lvmcache_found_duplicate_vgnames())
+ fprintf(fp, "# info: duplicate_vgnames\n");
+ goto out_flush;
+ }
+
+ fprintf(fp, "# Created by %s pid %d %s", cmd->name, getpid(), ctime(&t));
+ fprintf(fp, "hints_version: %d.%d\n", HINTS_VERSION_MAJOR, HINTS_VERSION_MINOR);
+
+ cn = find_config_tree_array(cmd, devices_global_filter_CFG, NULL);
+ fprintf(fp, "global_filter:%s\n", cn->v->v.str);
+
+ cn = find_config_tree_array(cmd, devices_filter_CFG, NULL);
+ fprintf(fp, "filter:%s\n", cn->v->v.str);
+
+ fprintf(fp, "scan_lvs:%d\n", cmd->scan_lvs);
+
+ /*
+ * iterate through all devs and write a line for each
+ * dev flagged DEV_SCAN_FOUND_LABEL
+ */
+
+ if (!(iter = dev_iter_create(NULL, 0))) {
+ ret = 0;
+ goto out_close;
+ }
+
+ /*
+ * This loop does two different things (for clarity this should be
+ * two separate dev_iter loops, but one is used for efficiency).
+ * 1. compute the hint hash from all relevant devs
+ * 2. add PVs to the hint file
+ */
+ while ((dev = dev_iter_get(cmd, iter))) {
+ if (!_dev_in_hint_hash(cmd, dev)) {
+ if (dev->flags & DEV_SCAN_FOUND_LABEL) {
+ /* should never happen */
+ log_error("skip hint hash but found label %s", dev_name(dev));
+ }
+ continue;
+ }
+
+ /*
+ * Create a hash of all device names on the system so we can
+ * detect when the devices on the system change, which
+ * invalidates the existing hints.
+ */
+ memset(devpath, 0, sizeof(devpath));
+ strncpy(devpath, dev_name(dev), PATH_MAX);
+ hash = calc_crc(hash, (const uint8_t *)devpath, strlen(devpath));
+ count++;
+
+ if (!(dev->flags & DEV_SCAN_FOUND_LABEL))
+ continue;
+
+ /*
+ * No vgname will be found here for a PV with no mdas,
+ * in which case the vgname hint will be incomplete.
+ * (The label scan cannot associate nomda-pvs with the
+ * correct vg in lvmcache; that is only done by vg_read.)
+ * When using vgname hint we would always want to also
+ * scan any PVs missing a vgname hint in case they are
+ * part of the vg we are looking for.
+ */
+ if ((info = lvmcache_info_from_pvid(dev->pvid, dev, 0)))
+ vgname = lvmcache_vgname_from_info(info);
+ else
+ vgname = NULL;
+
+ if (vgname && is_orphan_vg(vgname))
+ vgname = NULL;
+
+ fprintf(fp, "scan:%s pvid:%s devn:%d:%d vg:%s\n",
+ dev_name(dev),
+ dev->pvid,
+ major(dev->dev), minor(dev->dev),
+ vgname ?: "-");
+ }
+
+ fprintf(fp, "devs_hash: %u %u\n", hash, count);
+ dev_iter_destroy(iter);
+
+ out_flush:
+ if (fflush(fp))
+ stack;
+
+ log_debug("Wrote hint file with devs_hash %u count %u", hash, count);
+
+ /*
+ * We are writing refreshed hints because another command told us to by
+ * touching newhints, so unlink the newhints file.
+ */
+ if (newhints == NEWHINTS_FILE)
+ _unlink_newhints();
+
+ out_close:
+ if (fclose(fp))
+ stack;
+
+ out_unlock:
+ /* get_hints() took ex lock before returning with newhints set */
+ _unlock_hints();
+
+ return ret;
+}
+
+/*
+ * Commands that do things that would change existing hints (i.e. create or
+ * remove PVs) call this function before they start to get rid of the existing
+ * hints. This function clears the content of the hint file so that subsequent
+ * commands will recreate it. These commands do not try to recreate hints when
+ * they are done (this keeps hint creation simple, always done in one way from
+ * one place.) While this command runs, it holds an ex lock on the hint file.
+ * This causes any other command that tries to use the hints to ignore the
+ * hints by failing in _lock_hints(SH). We do not want another command to
+ * be creating new hints at the same time that this command is changing things
+ * that would invalidate them, so we block new hints from being created until
+ * we are done with the changes.
+ *
+ * This is the only place that makes a blocking lock request on the hints file.
+ * It does this so that it won't clear the hint file while a previous command
+ * is still reading it, and to ensure we are holding the hints lock before we
+ * begin changing things. (In place of a blocking request we could add a retry
+ * loop around nonblocking requests, which would allow us to better handle
+ * instances where a bad/stuck lock is blocking this for a long time.)
+ *
+ * To handle cases of indefinite postponement (repeated commands taking sh lock
+ * on the hints file, preventing us from ever getting the ex lock), we touch
+ * the nohints file first. The nohints file causes all other commands to
+ * ignore hints. This means we should only have to block waiting for
+ * pre-existing commands that have locked the hints file.
+ *
+ * (If the command were to crash or be SIGKILLed between touch_nohints
+ * and unlink_nohints, it could leave the nohints file in place. This
+ * is not a huge deal - it would be cleared by the next command like
+ * this that doesn't crash, or by a reboot, or manually. If it's still
+ * an issue we could easily write the pid in the nohints file, and
+ * others could check if the pid is still around before obeying it.)
+ *
+ * The intention is to call this function after the global ex lock has been
+ * taken, which is the official lock serializing commands changing which
+ * devs are PVs or not. This means that a command should never block in
+ * this function due to another command that has used this function --
+ * they would be serialized by the official global lock first.
+ * e.g. two pvcreates should never block each other from the hint lock,
+ * but rather from the global lock...
+ *
+ * Unfortunately, the global(orphan) lock is not used consistently so it's not
+ * quite doing its job right and needs some cleanup. Until that's done,
+ * concurrent commands like pvcreate may block each other on the hint lock.
+ */
+
+void clear_hint_file(struct cmd_context *cmd)
+{
+ /* No commands are using hints. */
+ if (!cmd->enable_hints)
+ return;
+
+ /*
+ * This function runs even when cmd->use_hints is 0,
+ * which means this command does not use hints, but
+ * others do, so we are clearing the hints for them.
+ */
+
+ /* limit potential delay blocking on hints lock next */
+ if (!_touch_nohints())
+ stack;
+
+ /*
+ * We are relying on the command exit to release this flock,
+ * we should probably add an explicit unlock_hints call.
+ */
+
+ if (!_lock_hints(LOCK_EX, 0))
+ stack;
+
+ _unlink_nohints();
+
+ if (!_clear_hints(cmd))
+ stack;
+
+ /*
+ * Creating a newhints file here is not necessary, since
+ * get_hints would see an empty hints file, but get_hints
+ * is more efficient if it sees a newhints file first.
+ */
+ if (!_touch_newhints())
+ stack;
+}
+
+/*
+ * Currently, all the commands using hints (ALLOW_HINTS) take an optional or
+ * required first position arg of a VG name or LV name. If some other command
+ * began using hints which took some other kind of position arg, we would
+ * probably want to exclude that command from attempting this optimization,
+ * because it would be difficult to know what VG that command wanted to use.
+ */
+static void _get_single_vgname_cmd_arg(struct cmd_context *cmd,
+ struct dm_list *hints, char **vgname)
+{
+ struct hint *hint;
+ char namebuf[NAME_LEN];
+ char *name = NULL;
+ char *arg, *st, *p;
+ int i = 0;
+
+ memset(namebuf, 0, sizeof(namebuf));
+
+ if (cmd->position_argc != 1)
+ return;
+
+ if (!cmd->position_argv[0])
+ return;
+
+ arg = cmd->position_argv[0];
+
+ /* tag */
+ if (arg[0] == '@')
+ return;
+
+ /* /dev/path - strip chars before vgname */
+ if (arg[0] == '/') {
+#if 0
+ /* skip_dev_dir only available in tools layer */
+ const char *strip;
+ if (!(strip = skip_dev_dir(cmd, (const char *)arg, NULL)))
+ return;
+ arg = (char *)strip;
+#endif
+ return;
+ }
+
+ if (!(st = strchr(arg, '/'))) {
+ /* simple vgname */
+ name = strdup(arg);
+ goto check;
+ }
+
+ /* take vgname from vgname/lvname */
+ for (p = arg; p < st; p++)
+ namebuf[i++] = *p;
+
+ name = strdup(namebuf);
+
+check:
+ /*
+ * Only use this vgname hint if there are hints that contain this
+ * vgname. This might happen if we aren't able to properly extract the
+ * vgname from the command args (could happen in some odd cases, e.g.
+ * only LV name is specified without VG name).
+ */
+ dm_list_iterate_items(hint, hints) {
+ if (!strcmp(hint->vgname, name)) {
+ *vgname = name;
+ return;
+ }
+ }
+}
+
+/*
+ * Returns 0: no hints are used.
+ * . newhints is set if this command should create new hints after scan
+ * for subsequent commands to use.
+ *
+ * Returns 1: use hints that are returned in hints list.
+ */
+
+int get_hints(struct cmd_context *cmd, struct dm_list *hints, int *newhints,
+ struct dm_list *devs_in, struct dm_list *devs_out)
+{
+ int needs_refresh = 0;
+ char *vgname = NULL;
+
+ /* Decide below if the caller should create new hints. */
+ *newhints = NEWHINTS_NONE;
+
+ /* No commands are using hints. */
+ if (!cmd->enable_hints)
+ return 0;
+
+ /*
+ * Special case for 'pvscan --cache' which removes hints,
+ * and then creates new hints. pvscan does not use hints,
+ * so this has to be checked before the cmd->use_hints check.
+ */
+ if (cmd->pvscan_recreate_hints) {
+ /* clear_hint_file already locked hints ex */
+ /* create new hints after scan */
+ log_debug("get_hints: pvscan recreate");
+ *newhints = NEWHINTS_FILE;
+ return 0;
+ }
+
+ /* This command does not use hints. */
+ if (!cmd->use_hints)
+ return 0;
+
+ /*
+ * Check if another command created the nohints file to prevent us from
+ * using hints.
+ */
+ if (_nohints_exists()) {
+ log_debug("get_hints: nohints file");
+ return 0;
+ }
+
+ /*
+ * Check if another command created the newhints file to cause us to
+ * ignore current hints and recreate new ones. We'll unlink_newhints
+ * to remove newhints file after writing refreshed hints file.
+ */
+ if (_newhints_exists()) {
+ log_debug("get_hints: newhints file");
+ if (!_hints_exists())
+ _touch_hints();
+ if (!_lock_hints(LOCK_EX, NONBLOCK))
+ return 0;
+ /* create new hints after scan */
+ *newhints = NEWHINTS_FILE;
+ return 0;
+ }
+
+ /*
+ * no hints file exists, a normal case
+ */
+ if (!_hints_exists()) {
+ log_debug("get_hints: no file");
+ if (!_touch_hints())
+ return 0;
+ if (!_lock_hints(LOCK_EX, NONBLOCK))
+ return 0;
+ /* create new hints after scan */
+ *newhints = NEWHINTS_INIT;
+ return 0;
+ }
+
+ /*
+ * hints are locked by a command modifying things, just skip using
+ * hints this time since they aren't accurate while things change.
+ * We hold a sh lock on the hints file while reading it to prevent
+ * another command from clearing it while we're reading
+ */
+ if (!_lock_hints(LOCK_SH, NONBLOCK)) {
+ log_debug("get_hints: lock fail");
+ return 0;
+ }
+
+ /*
+ * couln't read file for some reason, not normal, just skip using hints
+ */
+ if (!_read_hint_file(cmd, hints, &needs_refresh)) {
+ log_debug("get_hints: read fail");
+ _unlock_hints();
+ return 0;
+ }
+
+ _unlock_hints();
+
+ /*
+ * The content of the hint file is invalid and should be refreshed,
+ * so we'll scan everything and then recreate the hints.
+ */
+ if (needs_refresh) {
+ log_debug("get_hints: needs refresh");
+
+ if (!_lock_hints(LOCK_EX, NONBLOCK))
+ return 0;
+
+ /* create new hints after scan */
+ *newhints = NEWHINTS_REFRESH;
+ return 0;
+
+ }
+
+ /*
+ * A command that changes global state clears the content
+ * of the hints file so it will be recreated, and we must
+ * be following that since we found no hints.
+ */
+ if (dm_list_empty(hints)) {
+ log_debug("get_hints: no entries");
+
+ if (!_lock_hints(LOCK_EX, NONBLOCK))
+ return 0;
+
+ /* create new hints after scan */
+ *newhints = NEWHINTS_EMPTY;
+ return 0;
+ }
+
+ /*
+ * If the command specifies a single VG (alone or as part of a single
+ * LV), then we can set vgname to further reduce scanning by only
+ * scanning the hints for the given vgname.
+ *
+ * (This is a further optimization beyond the basic hints that tell
+ * us which devs are PVs. We might want to enable this optimization
+ * separately.)
+ */
+ _get_single_vgname_cmd_arg(cmd, hints, &vgname);
+
+ _apply_hints(cmd, hints, vgname, devs_in, devs_out);
+
+ log_debug("get_hints: applied using %d other %d",
+ dm_list_size(devs_out), dm_list_size(devs_in));
+ return 1;
+}
+
diff --git a/lib/label/hints.h b/lib/label/hints.h
new file mode 100644
index 0000000..d80016e
--- /dev/null
+++ b/lib/label/hints.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2004-2018 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _LVM_HINTS_H
+#define _LVM_HINTS_H
+
+struct hint {
+ struct dm_list list;
+ char name[PATH_MAX];
+ char pvid[ID_LEN + 1];
+ char vgname[NAME_LEN];
+ dev_t devt;
+ unsigned chosen:1; /* this hint's dev was chosen for scanning */
+};
+
+int write_hint_file(struct cmd_context *cmd, int newhints);
+
+void clear_hint_file(struct cmd_context *cmd);
+
+int get_hints(struct cmd_context *cmd, struct dm_list *hints, int *newhints,
+ struct dm_list *devs_in, struct dm_list *devs_out);
+
+int validate_hints(struct cmd_context *cmd, struct dm_list *hints);
+
+#endif
+
diff --git a/lib/label/label.c b/lib/label/label.c
index 6fe1e41..7d5073e 100644
--- a/lib/label/label.c
+++ b/lib/label/label.c
@@ -22,6 +22,7 @@
#include "lib/device/bcache.h"
#include "lib/commands/toolcontext.h"
#include "lib/activate/activate.h"
+#include "lib/label/hints.h"
#include <sys/stat.h>
#include <fcntl.h>
@@ -358,6 +359,8 @@ static int _process_block(struct cmd_context *cmd, struct dev_filter *f,
int ret = 0;
int pass;
+ dev->flags &= ~DEV_SCAN_FOUND_LABEL;
+
/*
* The device may have signatures that exclude it from being processed.
* If filters were applied before bcache data was available, some
@@ -370,7 +373,7 @@ static int _process_block(struct cmd_context *cmd, struct dev_filter *f,
log_debug_devs("Scan filtering %s", dev_name(dev));
- pass = f->passes_filter(cmd, f, dev);
+ pass = f->passes_filter(cmd, f, dev, NULL);
if ((pass == -EAGAIN) || (dev->flags & DEV_FILTER_AFTER_SCAN)) {
/* Shouldn't happen */
@@ -412,6 +415,7 @@ static int _process_block(struct cmd_context *cmd, struct dev_filter *f,
goto_out;
}
+ dev->flags |= DEV_SCAN_FOUND_LABEL;
*is_lvm_device = 1;
/*
@@ -827,6 +831,16 @@ static int _setup_bcache(int cache_blocks)
return 1;
}
+static void _free_hints(struct dm_list *hints)
+{
+ struct hint *hint, *hint2;
+
+ dm_list_iterate_items_safe(hint, hint2, hints) {
+ dm_list_del(&hint->list);
+ free(hint);
+ }
+}
+
/*
* Scan and cache lvm data from all devices on the system.
* The cache should be empty/reset before calling this.
@@ -835,13 +849,18 @@ static int _setup_bcache(int cache_blocks)
int label_scan(struct cmd_context *cmd)
{
struct dm_list all_devs;
+ struct dm_list scan_devs;
+ struct dm_list hints;
struct dev_iter *iter;
struct device_list *devl, *devl2;
struct device *dev;
+ int newhints = 0;
log_debug_devs("Finding devices to scan");
dm_list_init(&all_devs);
+ dm_list_init(&scan_devs);
+ dm_list_init(&hints);
/*
* Iterate through all the devices in dev-cache (block devs that appear
@@ -889,20 +908,64 @@ int label_scan(struct cmd_context *cmd)
};
dev_iter_destroy(iter);
- log_debug_devs("Found %d devices to scan", dm_list_size(&all_devs));
-
if (!scan_bcache) {
if (!_setup_bcache(dm_list_size(&all_devs)))
return 0;
}
- _scan_list(cmd, cmd->filter, &all_devs, NULL);
+ /*
+ * In some common cases we can avoid scanning all devices.
+ *
+ * TODO: if the command is using hints and a single vgname
+ * arg, we can also take the vg lock here, prior to scanning.
+ * This means we would not need to rescan the PVs in the VG
+ * in vg_read (skip lvmcache_label_rescan_vg) after the
+ * vg lock is usually taken. (Some commands are already
+ * able to avoid rescan in vg_read, but locking early would
+ * apply to more cases.)
+ */
+ if (!get_hints(cmd, &hints, &newhints, &all_devs, &scan_devs))
+ dm_list_splice(&scan_devs, &all_devs);
+
+ log_debug("Will scan %d devices skip %d", dm_list_size(&scan_devs), dm_list_size(&all_devs));
+
+ /*
+ * Do the main scan.
+ */
+ _scan_list(cmd, cmd->filter, &scan_devs, NULL);
+
+ dm_list_init(&cmd->hints);
+
+ if (!dm_list_empty(&hints)) {
+ if (!validate_hints(cmd, &hints)) {
+ /*
+ * We scanned a subset of all devices based on hints.
+ * With the results from the scan we may decide that
+ * the hints are not valid, so scan all others.
+ */
+ log_debug("Will scan %d remaining devices", dm_list_size(&all_devs));
+ _scan_list(cmd, cmd->filter, &all_devs, NULL);
+ _free_hints(&hints);
+ newhints = 0;
+ } else {
+ /* The hints may be used by another device iteration. */
+ dm_list_splice(&cmd->hints, &hints);
+ }
+ }
dm_list_iterate_items_safe(devl, devl2, &all_devs) {
dm_list_del(&devl->list);
free(devl);
}
+ dm_list_iterate_items_safe(devl, devl2, &scan_devs) {
+ dm_list_del(&devl->list);
+ free(devl);
+ }
+
+ if (newhints)
+ write_hint_file(cmd, newhints);
+
return 1;
}
diff --git a/test/shell/hints.sh b/test/shell/hints.sh
new file mode 100644
index 0000000..bdaf3be
--- /dev/null
+++ b/test/shell/hints.sh
@@ -0,0 +1,377 @@
+#!/usr/bin/env bash
+
+# Copyright (C) 2012 Red Hat, Inc. All rights reserved.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU General Public License v.2.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+SKIP_WITH_LVMPOLLD=1
+
+/* hints are currently disabled with lvmlockd */
+SKIP_WITH_LVMLOCKD=1
+
+RUNDIR="/run"
+test -d "$RUNDIR" || RUNDIR="/var/run"
+HINTS="$RUNDIR/lvm/hints"
+NOHINTS="$RUNDIR/lvm/nohints"
+NEWHINTS="$RUNDIR/lvm/newhints"
+PREV="$RUNDIR/lvm/prev-hints"
+
+. lib/inittest
+
+# TODO:
+# Test commands that ignore hints
+# Test flock
+
+
+aux lvmconf 'devices/scan_lvs = 0'
+
+aux prepare_devs 6
+
+# no PVs yet so hints should have no devs
+pvs
+not grep scan: $HINTS
+
+#
+# vg1 uses dev1,dev2
+#
+# Test basics that PVs are in hints, not non-PV devs,
+# and that only PVs are scanned when using hints.
+#
+
+vgcreate $vg1 "$dev1" "$dev2"
+lvcreate -n $lv1 -l 4 $vg1
+
+# test that only the two PVs are in hints
+pvs
+grep -v -E "$dev1|$dev2" $HINTS > tmptest
+not grep scan: tmptest
+
+# test that 'pvs' submits only two reads, one for each PV in hints
+strace -e io_submit pvs 2>&1|tee tmptest
+test "$(grep io_submit tmptest | wc -l)" -eq 2
+
+# test that 'pvs -a' submits six reads, one for each device
+strace -e io_submit pvs -a 2>&1|tee tmptest
+test "$(grep io_submit tmptest | wc -l)" -eq 6
+
+#
+# vg2 uses dev3,dev4
+#
+# Test common commands that cause hints to be refreshed:
+# pvcreate/vgcreate/vgextend/vgreduce/vgremove/pvremove
+#
+
+not pvs "$dev3"
+not grep "$dev3" $HINTS
+cp $HINTS $PREV
+pvcreate "$dev3"
+grep "# Created empty" $HINTS
+cat $NEWHINTS
+# next cmd recreates hints
+pvs "$dev3"
+grep "$dev3" $HINTS
+not diff $HINTS $PREV
+not cat $NEWHINTS
+
+not vgs $vg2
+cp $HINTS $PREV
+vgcreate $vg2 "$dev3"
+grep "# Created empty" $HINTS
+cat $NEWHINTS
+# next cmd recreates hints
+vgs $vg2
+grep $vg2 $HINTS
+not diff $HINTS $PREV
+not cat $NEWHINTS
+
+cp $HINTS $PREV
+vgextend $vg2 "$dev4"
+grep "# Created empty" $HINTS
+cat $NEWHINTS
+# next cmd recreates hints
+vgs $vg2
+grep "$dev4" $HINTS
+not diff $HINTS $PREV
+not cat $NEWHINTS
+
+cp $HINTS $PREV
+vgreduce $vg2 "$dev4"
+grep "# Created empty" $HINTS
+cat $NEWHINTS
+# next cmd recreates hints
+vgs $vg2
+grep "$dev4" $HINTS
+not diff $HINTS $PREV
+not cat $NEWHINTS
+
+cp $HINTS $PREV
+vgremove $vg2
+grep "# Created empty" $HINTS
+cat $NEWHINTS
+# next cmd recreates hints
+not vgs $vg2
+not grep $vg2 $HINTS
+not diff $HINTS $PREV
+not cat $NEWHINTS
+
+cp $HINTS $PREV
+pvremove "$dev3" "$dev4"
+grep "# Created empty" $HINTS
+cat $NEWHINTS
+# next cmd recreates hints
+not pvs "$dev3"
+not pvs "$dev4"
+not grep "$dev3" $HINTS
+not grep "$dev4" $HINTS
+not diff $HINTS $PREV
+not cat $NEWHINTS
+
+#
+# Test that adding a new device and removing a device
+# causes hints to be recreated.
+#
+
+not pvs "$dev5"
+
+# create a new temp device that will cause hint hash to change
+DEVNAME=${PREFIX}pv99
+echo "0 `blockdev --getsize $dev5` linear $dev5 0" | dmsetup create $DEVNAME
+dmsetup status $DEVNAME
+
+cp $HINTS $PREV
+# pvs ignores current hints because of different dev hash and refreshes new hints
+pvs
+# devs listed in hints before and after are the same
+grep scan: $PREV > scan1
+grep scan: $HINTS > scan2
+diff scan1 scan2
+# hash listed before and after are different
+cat $PREV
+cat $HINTS
+grep devs_hash $PREV > devs_hash1
+grep devs_hash $HINTS > devs_hash2
+not diff devs_hash1 devs_hash2
+
+# hints are stable/unchanging
+cp $HINTS $PREV
+pvs
+diff $HINTS $PREV
+
+# remove the temp device which will cause hint hash to change again
+dmsetup remove $DEVNAME
+
+cp $HINTS $PREV
+# pvs ignores current hints because of different dev hash and refreshes new hints
+pvs
+# devs listed in hints before and after are the same
+grep scan: $PREV > scan1
+grep scan: $HINTS > scan2
+diff scan1 scan2
+# hash listed before and after are different
+grep devs_hash $PREV > devs_hash1
+grep devs_hash $HINTS > devs_hash2
+not diff devs_hash1 devs_hash2
+
+#
+# Test that hints don't change from a bunch of commands
+# that use hints and shouldn't change it.
+#
+
+# first create some more metadata using vg2
+pvcreate "$dev3" "$dev4"
+vgcreate $vg2 "$dev3"
+lvcreate -n $lv1 -l1 $vg2
+lvcreate -n $lv2 -l1 $vg2
+
+cp $HINTS $PREV
+lvm fullreport
+lvchange -ay $vg1
+lvchange -an $vg1
+lvcreate -l1 -n $lv2 $vg1
+lvcreate -l1 -an -n $lv3 $vg1
+lvchange -an $vg1
+lvremove $vg1/$lv3
+lvresize -l+1 $vg1/$lv2
+lvresize -l-1 $vg1/$lv2
+lvdisplay
+pvdisplay
+vgdisplay
+lvs
+pvs
+vgs
+vgchange -ay $vg2
+vgchange -an $vg2
+vgck $vg2
+lvrename $vg1 $lv2 $lv3
+# no change in hints after all that
+diff $HINTS $PREV
+
+#
+# Test that changing the filter will cause hint refresh
+#
+
+rm $HINTS $PREV
+vgs
+cp $HINTS $PREV
+# this changes the filter to exclude dev5 which is not a PV
+aux hide_dev "$dev5"
+# next cmd sees different filter, ignores hints, creates new hints
+pvs
+not diff $HINTS $PREV
+# run cmds using new filter
+pvs
+cp $HINTS $PREV
+vgs
+# hints are stable once refreshed
+diff $HINTS $PREV
+# this changes the filter to include dev5
+aux unhide_dev "$dev5"
+# next cmd sees different filter, ignores hints, creates new hints
+pvs
+not diff $HINTS $PREV
+# hints are stable
+cp $HINTS $PREV
+vgs
+diff $HINTS $PREV
+
+#
+# Test that changing scan_lvs will cause hint refresh
+#
+
+rm $HINTS $PREV
+vgs
+cp $HINTS $PREV
+# change lvm.conf
+aux lvmconf 'devices/scan_lvs = 1'
+# next cmd sees new setting, ignores hints, creates new hints
+pvs
+not diff $HINTS $PREV
+# run cmds using new filter
+pvs
+cp $HINTS $PREV
+vgs
+# hints are stable once refreshed
+diff $HINTS $PREV
+# change lvm.conf back
+aux lvmconf 'devices/scan_lvs = 0'
+# next cmd sees different scan_lvs, ignores hints, creates new hints
+pvs
+not diff $HINTS $PREV
+# hints are stable once refreshed
+cp $HINTS $PREV
+pvs
+diff $HINTS $PREV
+
+#
+# Test pvscan --cache to force hints refresh
+#
+
+# pvs (no change), pvscan (hints are new), pvs (no change)
+pvs
+cp $HINTS $PREV
+diff $HINTS $PREV
+cp $HINTS $PREV
+pvscan --cache
+not diff $HINTS $PREV
+cp $HINTS $PREV
+pvs
+diff $HINTS $PREV
+grep 'Created by pvscan' $HINTS
+# dev4 is a PV not used by a VG, dev5 is not a PV
+# using dd to copy skirts hint tracking so dev5 won't be seen
+dd if="$dev4" of="$dev5" bs=1M
+# this pvs won't see dev5
+pvs > foo
+cat foo
+grep "$dev4" foo
+not grep "$dev5" foo
+# no hints have changed after dd and pvs since dd cannot be detected
+diff $HINTS $PREV
+# force hints refresh, will see duplicate now
+pvscan --cache
+not diff $HINTS $PREV
+cat $HINTS
+pvs -a > foo
+# after force refresh, both devs (dups) appear in output
+cat foo
+grep "$dev4" foo
+grep "$dev5" foo
+# clear PV from dev5
+dd if=/dev/zero of="$dev5" bs=1M count=1
+# this pvs won't use hints because of duplicate PVs,
+# and will create new hints
+cp $HINTS $PREV
+pvs > foo
+not diff $HINTS $PREV
+grep "$dev4" foo
+not grep "$dev5" foo
+grep "$dev4" $HINTS
+not grep "$dev5" $HINTS
+
+
+#
+# Test incorrect dev-to-pvid info in hints is detected
+# dev4 is a PV not in a VG
+#
+
+pvs
+cp $HINTS tmp-old
+# this pvchange will invalidate current hints
+pvchange -u "$dev4"
+grep "# Created empty" $HINTS
+cat $NEWHINTS
+# this next pvs will create new hints with the new uuid
+pvs
+grep "$dev4" $HINTS > tmp-newuuid
+cp $HINTS tmp-new
+not diff tmp-old tmp-new
+# hints are stable
+pvs
+diff $HINTS tmp-new
+# replace the current hints with the old hints with the old uuid
+cp tmp-old $HINTS
+# this next pvs will see wrong dev-to-pvid mapping and invalidate hints
+pvs
+cat $HINTS
+cat $NEWHINTS
+# this next pvs will create new hints with the new uuid
+pvs
+cat $HINTS
+grep -f tmp-newuuid $HINTS
+rm tmp-old tmp-new tmp-newuuid
+
+
+#
+# Test incorrent pvid-to-vgname info in hints is detected
+#
+
+# this vgcreate invalidates current hints
+vgcreate $vg3 $dev4
+# this pvs creates new hints
+pvs
+cp $HINTS tmp-old
+# this vgrename will invalidate current hints
+vgrename $vg3 $vg4
+# this pvs will create new hints with the new vg name
+pvs
+cp $HINTS tmp-new
+not diff tmp-old tmp-new
+# replace the current hints with the old hints with the old vg name
+cp tmp-old $HINTS
+# this pvs will see wrong pvid-to-vgname mapping and invalidate hints
+pvs
+cat $NEWHINTS
+# this pvs will create new hints with the new vg name
+pvs
+grep $vg4 $HINTS
+
+vgremove -y $vg4
+vgremove -y $vg2
+vgremove -y $vg1
+
diff --git a/test/shell/process-each-duplicate-pvs.sh b/test/shell/process-each-duplicate-pvs.sh
index b8a8774..ffd085a 100644
--- a/test/shell/process-each-duplicate-pvs.sh
+++ b/test/shell/process-each-duplicate-pvs.sh
@@ -55,7 +55,7 @@ check pv_field "$dev2" dev_size "$SIZE2"
# Copy dev1 over dev2.
dd if="$dev1" of="$dev2" bs=1M iflag=direct oflag=direct,sync
-pvscan --cache
+#pvscan --cache
# The single preferred dev is shown from 'pvs'.
pvs -o+uuid,duplicate 2>&1 | tee out
@@ -292,7 +292,7 @@ grep "$dev3" out
grep "$dev4" out
dd if="$dev3" of="$dev4" bs=1M iflag=direct oflag=direct,sync
-pvscan --cache
+#pvscan --cache
# One appears with 'pvs'
@@ -375,7 +375,7 @@ check pv_field "$dev4" dev_size "$SIZE4"
dd if=/dev/zero of="$dev3" bs=1M oflag=direct,sync || true
dd if=/dev/zero of="$dev4" bs=1M oflag=direct,sync || true
-pvscan --cache
+#pvscan --cache
# The previous steps prevent us from nicely cleaning up
# the vg lockspace in lvmlockd, so just restart it;
@@ -392,6 +392,9 @@ lvcreate -l1 -n $lv2 $vg2 "$dev4"
dd if="$dev3" of="$dev5" bs=1M iflag=direct oflag=direct,sync
dd if="$dev4" of="$dev6" bs=1M iflag=direct oflag=direct,sync
+# dev5/dev6 not pvs so dd'ing pv onto them causes invalid hints
+# that won't be detected, so 5/6 won't be scanned unless we
+# force hint recreation
pvscan --cache
pvs -o+uuid,duplicate 2>&1 | tee out
@@ -450,7 +453,7 @@ not grep "prefers device $dev6" warn
dd if=/dev/zero of="$dev5" bs=1M oflag=direct,sync || true
dd if=/dev/zero of="$dev6" bs=1M oflag=direct,sync || true
-pvscan --cache
+#pvscan --cache
lvremove -y $vg2/$lv1
lvremove -y $vg2/$lv2
@@ -460,7 +463,7 @@ pvremove -ff -y "$dev4"
dd if=/dev/zero of="$dev3" bs=1M oflag=direct,sync || true
dd if=/dev/zero of="$dev4" bs=1M oflag=direct,sync || true
-pvscan --cache
+#pvscan --cache
# Reverse devs in the previous in case dev3/dev4 would be
# preferred even without an active LV using them.
@@ -471,6 +474,9 @@ lvcreate -l1 -n $lv2 $vg2 "$dev6"
dd if="$dev5" of="$dev3" bs=1M iflag=direct oflag=direct,sync
dd if="$dev6" of="$dev4" bs=1M iflag=direct oflag=direct,sync
+# dev3/dev4 are not pvs (zeroed above) so dd'ing pv onto them causes
+# invalid hints that won't be detected, so 3/4 won't be scanned
+# unless we force hint recreation
pvscan --cache
pvs -o+uuid,duplicate 2>&1 | tee out
@@ -506,7 +512,7 @@ not grep "prefers device $dev4" warn
dd if=/dev/zero of="$dev3" bs=1M oflag=direct,sync || true
dd if=/dev/zero of="$dev4" bs=1M oflag=direct,sync || true
-pvscan --cache
+#pvscan --cache
lvremove -y $vg2/$lv1
lvremove -y $vg2/$lv2
diff --git a/tools/command.c b/tools/command.c
index 6931e44..bf2879f 100644
--- a/tools/command.c
+++ b/tools/command.c
@@ -136,6 +136,8 @@ static inline int configtype_arg(struct cmd_context *cmd __attribute__((unused))
#define DISALLOW_TAG_ARGS 0x00000800
#define GET_VGNAME_FROM_OPTIONS 0x00001000
#define CAN_USE_ONE_SCAN 0x00002000
+#define ALLOW_HINTS 0x00004000
+
/* create foo_CMD enums for command def ID's in command-lines.in */
diff --git a/tools/commands.h b/tools/commands.h
index 8c653e6..83e50e7 100644
--- a/tools/commands.h
+++ b/tools/commands.h
@@ -35,7 +35,7 @@ xx(help,
xx(fullreport,
"Display full report",
- PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH)
+ PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | ALLOW_HINTS)
xx(lastlog,
"Display last command's log report",
@@ -43,7 +43,7 @@ xx(lastlog,
xx(lvchange,
"Change the attributes of logical volume(s)",
- PERMITTED_READ_ONLY)
+ PERMITTED_READ_ONLY | ALLOW_HINTS)
xx(lvconvert,
"Change logical volume layout",
@@ -51,15 +51,15 @@ xx(lvconvert,
xx(lvcreate,
"Create a logical volume",
- 0)
+ ALLOW_HINTS)
xx(lvdisplay,
"Display information about a logical volume",
- PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN)
+ PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN | ALLOW_HINTS)
xx(lvextend,
"Add space to a logical volume",
- 0)
+ ALLOW_HINTS)
xx(lvmchange,
"With the device mapper, this is obsolete and does nothing.",
@@ -83,23 +83,23 @@ xx(lvmsar,
xx(lvreduce,
"Reduce the size of a logical volume",
- 0)
+ ALLOW_HINTS)
xx(lvremove,
"Remove logical volume(s) from the system",
- ALL_VGS_IS_DEFAULT) /* all VGs only with --select */
+ ALL_VGS_IS_DEFAULT | ALLOW_HINTS) /* all VGs only with --select */
xx(lvrename,
"Rename a logical volume",
- 0)
+ ALLOW_HINTS)
xx(lvresize,
"Resize a logical volume",
- 0)
+ ALLOW_HINTS)
xx(lvs,
"Display information about logical volumes",
- PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN)
+ PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN | ALLOW_HINTS)
xx(lvscan,
"List all logical volumes in all volume groups",
@@ -127,7 +127,7 @@ xx(pvdata,
xx(pvdisplay,
"Display various attributes of physical volume(s)",
- PERMITTED_READ_ONLY | ENABLE_ALL_DEVS | ENABLE_DUPLICATE_DEVS | LOCKD_VG_SH | CAN_USE_ONE_SCAN)
+ PERMITTED_READ_ONLY | ENABLE_ALL_DEVS | ENABLE_DUPLICATE_DEVS | LOCKD_VG_SH | CAN_USE_ONE_SCAN | ALLOW_HINTS)
/* ALL_VGS_IS_DEFAULT is for polldaemon to find pvmoves in-progress using process_each_vg. */
@@ -137,7 +137,7 @@ xx(pvmove,
xx(lvpoll,
"Continue already initiated poll operation on a logical volume",
- 0)
+ ALLOW_HINTS)
xx(pvremove,
"Remove LVM label(s) from physical volume(s)",
@@ -145,7 +145,7 @@ xx(pvremove,
xx(pvs,
"Display information about physical volumes",
- PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | ENABLE_ALL_DEVS | ENABLE_DUPLICATE_DEVS | LOCKD_VG_SH | CAN_USE_ONE_SCAN)
+ PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | ENABLE_ALL_DEVS | ENABLE_DUPLICATE_DEVS | LOCKD_VG_SH | CAN_USE_ONE_SCAN | ALLOW_HINTS)
xx(pvscan,
"List all physical volumes",
@@ -173,11 +173,11 @@ xx(vgcfgrestore,
xx(vgchange,
"Change volume group attributes",
- PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT)
+ PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | ALLOW_HINTS)
xx(vgck,
"Check the consistency of volume group(s)",
- ALL_VGS_IS_DEFAULT | LOCKD_VG_SH)
+ ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | ALLOW_HINTS)
xx(vgconvert,
"Change volume group metadata format",
@@ -189,7 +189,7 @@ xx(vgcreate,
xx(vgdisplay,
"Display volume group information",
- PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN)
+ PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN | ALLOW_HINTS)
xx(vgexport,
"Unregister volume group(s) from the system",
@@ -228,7 +228,7 @@ xx(vgrename,
xx(vgs,
"Display information about volume groups",
- PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN)
+ PERMITTED_READ_ONLY | ALL_VGS_IS_DEFAULT | LOCKD_VG_SH | CAN_USE_ONE_SCAN | ALLOW_HINTS)
xx(vgscan,
"Search for all volume groups",
diff --git a/tools/lvmcmdline.c b/tools/lvmcmdline.c
index 9c0476e..55a068f 100644
--- a/tools/lvmcmdline.c
+++ b/tools/lvmcmdline.c
@@ -2286,6 +2286,7 @@ static void _apply_current_output_settings(struct cmd_context *cmd)
static int _get_current_settings(struct cmd_context *cmd)
{
const char *activation_mode;
+ const char *hint_mode;
_get_current_output_settings_from_args(cmd);
@@ -2313,6 +2314,29 @@ static int _get_current_settings(struct cmd_context *cmd)
if (cmd->cname->flags & CAN_USE_ONE_SCAN)
cmd->can_use_one_scan = 1;
+ cmd->scan_lvs = find_config_tree_bool(cmd, devices_scan_lvs_CFG, NULL);
+
+ /*
+ * enable_hints is set to 1 if any commands are using hints.
+ * use_hints is set to 1 if this command doesn't use the hints.
+ * enable_hints=1 and use_hints=0 means that this command won't
+ * use the hints, but it may invalidate the hints that are used
+ * by other commands.
+ *
+ * enable_hints=0 means no commands are using hints, so this
+ * command would not need to invalidate hints for other cmds.
+ */
+ cmd->enable_hints = 1;
+
+ /* Only certain commands need to be optimized by using hints. */
+ if (cmd->cname->flags & ALLOW_HINTS)
+ cmd->use_hints = 1;
+
+ if ((hint_mode = find_config_tree_str(cmd, devices_hints_CFG, NULL))) {
+ if (!strcmp(hint_mode, "none"))
+ cmd->enable_hints = 0;
+ }
+
cmd->partial_activation = 0;
cmd->degraded_activation = 0;
activation_mode = find_config_tree_str(cmd, activation_mode_CFG, NULL);
@@ -2688,6 +2712,12 @@ static int _init_lvmlockd(struct cmd_context *cmd)
const char *lvmlockd_socket;
int use_lvmlockd = find_config_tree_bool(cmd, global_use_lvmlockd_CFG, NULL);
+ /*
+ * Think about when/how to enable hints with lvmlockd.
+ */
+ if (use_lvmlockd)
+ cmd->enable_hints = 0;
+
if (use_lvmlockd && arg_is_set(cmd, nolocking_ARG)) {
/* --nolocking is only allowed with vgs/lvs/pvs commands */
cmd->lockd_gl_disable = 1;
diff --git a/tools/pvchange.c b/tools/pvchange.c
index 8c19268..696dab4 100644
--- a/tools/pvchange.c
+++ b/tools/pvchange.c
@@ -252,6 +252,8 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
set_pv_notify(cmd);
+ clear_hint_file(cmd);
+
ret = process_each_pv(cmd, argc, argv, NULL, 0, READ_FOR_UPDATE | READ_ALLOW_EXPORTED, handle, _pvchange_single);
if (!argc)
diff --git a/tools/pvcreate.c b/tools/pvcreate.c
index 4ffb12f..c244a1f 100644
--- a/tools/pvcreate.c
+++ b/tools/pvcreate.c
@@ -148,6 +148,8 @@ int pvcreate(struct cmd_context *cmd, int argc, char **argv)
return_ECMD_FAILED;
cmd->lockd_gl_disable = 1;
+ clear_hint_file(cmd);
+
if (!(handle = init_processing_handle(cmd, NULL))) {
log_error("Failed to initialize processing handle.");
return ECMD_FAILED;
diff --git a/tools/pvdisplay.c b/tools/pvdisplay.c
index 3c97a7f..11f38eb 100644
--- a/tools/pvdisplay.c
+++ b/tools/pvdisplay.c
@@ -93,6 +93,13 @@ int pvdisplay(struct cmd_context *cmd, int argc, char **argv)
return EINVALID_CMD_LINE;
}
+ /*
+ * Without -a, command only looks at PVs and can use hints,
+ * with -a, the command looks at all (non-hinted) devices.
+ */
+ if (arg_is_set(cmd, all_ARG))
+ cmd->use_hints = 0;
+
ret = process_each_pv(cmd, argc, argv, NULL,
arg_is_set(cmd, all_ARG), 0,
NULL, _pvdisplay_single);
diff --git a/tools/pvremove.c b/tools/pvremove.c
index 06a7e73..5f76de6 100644
--- a/tools/pvremove.c
+++ b/tools/pvremove.c
@@ -48,6 +48,8 @@ int pvremove(struct cmd_context *cmd, int argc, char **argv)
}
cmd->lockd_gl_disable = 1;
+ clear_hint_file(cmd);
+
/* When forcibly clearing a PV we don't care about a VG lock. */
if (pp.force == DONT_PROMPT_OVERRIDE)
cmd->lockd_vg_disable = 1;
diff --git a/tools/pvscan.c b/tools/pvscan.c
index 3f3c745..da1e435 100644
--- a/tools/pvscan.c
+++ b/tools/pvscan.c
@@ -656,6 +656,15 @@ int pvscan_cache_cmd(struct cmd_context *cmd, int argc, char **argv)
* Scan all devices when no args are given.
*/
if (!argc && !devno_args) {
+ /*
+ * pvscan --cache removes existing hints and recreates new ones.
+ * We begin by clearing hints at the start of the command like
+ * vgcreate would do. The pvscan_recreate_hints flag is used
+ * to enable the special case hint recreation in label_scan.
+ */
+ cmd->pvscan_recreate_hints = 1;
+ clear_hint_file(cmd);
+
log_verbose("pvscan all devices.");
_online_pvid_files_remove();
_online_pvscan_all_devs(cmd, NULL, NULL);
diff --git a/tools/reporter.c b/tools/reporter.c
index c321d21..ee38db3 100644
--- a/tools/reporter.c
+++ b/tools/reporter.c
@@ -1456,6 +1456,13 @@ int pvs(struct cmd_context *cmd, int argc, char **argv)
{
report_type_t type;
+ /*
+ * Without -a, command only looks at PVs and can use hints,
+ * with -a, the command looks at all (non-hinted) devices.
+ */
+ if (arg_is_set(cmd, all_ARG))
+ cmd->use_hints = 0;
+
if (arg_is_set(cmd, segments_ARG))
type = PVSEGS;
else
diff --git a/tools/toollib.c b/tools/toollib.c
index d8394a3..5206e26 100644
--- a/tools/toollib.c
+++ b/tools/toollib.c
@@ -15,6 +15,7 @@
#include "tools.h"
#include "lib/format_text/format-text.h"
+#include "lib/label/hints.h"
#include <sys/stat.h>
#include <signal.h>
@@ -3908,14 +3909,40 @@ static int _get_arg_devices(struct cmd_context *cmd,
return ret_max;
}
-static int _get_all_devices(struct cmd_context *cmd, struct dm_list *all_devices)
+static int _get_all_devices(struct cmd_context *cmd,
+ int process_all_devices,
+ struct dm_list *all_devices)
{
struct dev_iter *iter;
struct device *dev;
struct device_id_list *dil;
+ struct hint *hint;
int r = ECMD_FAILED;
- log_debug("Getting list of all devices");
+ /*
+ * If command is using hints and is only looking for PVs
+ * (not all devices), then we can use only devs from hints.
+ */
+ if (!process_all_devices && !dm_list_empty(&cmd->hints)) {
+ log_debug("Getting list of all devices from hints");
+
+ dm_list_iterate_items(hint, &cmd->hints) {
+ if (!(dev = dev_cache_get(cmd, hint->name, NULL)))
+ continue;
+
+ if (!(dil = dm_pool_alloc(cmd->mem, sizeof(*dil)))) {
+ log_error("device_id_list alloc failed.");
+ goto out;
+ }
+
+ strncpy(dil->pvid, hint->pvid, ID_LEN);
+ dil->dev = dev;
+ dm_list_add(all_devices, &dil->list);
+ }
+ return 1;
+ }
+
+ log_debug("Getting list of all devices from system");
if (!(iter = dev_iter_create(cmd->filter, 1))) {
log_error("dev_iter creation failed.");
@@ -4488,7 +4515,7 @@ int process_each_pv(struct cmd_context *cmd,
* from all VGs are processed first, removing them from all_devices. Then
* any devs remaining in all_devices are processed.
*/
- if ((ret = _get_all_devices(cmd, &all_devices)) != ECMD_PROCESSED) {
+ if ((ret = _get_all_devices(cmd, process_all_devices, &all_devices)) != ECMD_PROCESSED) {
ret_max = ret;
goto_out;
}
diff --git a/tools/tools.h b/tools/tools.h
index 5e0cd30..ab9503e 100644
--- a/tools/tools.h
+++ b/tools/tools.h
@@ -42,6 +42,7 @@
#include "lib/commands/toolcontext.h"
#include "toollib.h"
#include "lib/notify/lvmnotify.h"
+#include "lib/label/hints.h"
#include <ctype.h>
#include <sys/types.h>
@@ -133,6 +134,8 @@ struct arg_value_group_list {
#define GET_VGNAME_FROM_OPTIONS 0x00001000
/* The data read from disk by label scan can be used for vg_read. */
#define CAN_USE_ONE_SCAN 0x00002000
+/* Command can use hints file */
+#define ALLOW_HINTS 0x00004000
void usage(const char *name);
diff --git a/tools/vgcfgrestore.c b/tools/vgcfgrestore.c
index 84032f1..2302f0a 100644
--- a/tools/vgcfgrestore.c
+++ b/tools/vgcfgrestore.c
@@ -130,6 +130,8 @@ int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
return ECMD_FAILED;
}
+ clear_hint_file(cmd);
+
lvmcache_label_scan(cmd);
cmd->handles_unknown_segments = 1;
diff --git a/tools/vgcreate.c b/tools/vgcreate.c
index 2a40bc7..c146ab7 100644
--- a/tools/vgcreate.c
+++ b/tools/vgcreate.c
@@ -64,6 +64,8 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
return_ECMD_FAILED;
cmd->lockd_gl_disable = 1;
+ clear_hint_file(cmd);
+
/* Check for old md signatures at the end of devices. */
cmd->use_full_md_check = 1;
diff --git a/tools/vgextend.c b/tools/vgextend.c
index 5287a36..c727d75 100644
--- a/tools/vgextend.c
+++ b/tools/vgextend.c
@@ -166,6 +166,8 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv)
return_ECMD_FAILED;
cmd->lockd_gl_disable = 1;
+ clear_hint_file(cmd);
+
if (!(handle = init_processing_handle(cmd, NULL))) {
log_error("Failed to initialize processing handle.");
return ECMD_FAILED;
diff --git a/tools/vgimportclone.c b/tools/vgimportclone.c
index b7fae61..34c211c 100644
--- a/tools/vgimportclone.c
+++ b/tools/vgimportclone.c
@@ -345,6 +345,8 @@ retry_name:
*/
cmd->lockd_vg_disable = 1;
+ clear_hint_file(cmd);
+
ret = process_each_vg(cmd, 0, NULL, vp.old_vgname, NULL, READ_FOR_UPDATE | READ_ALLOW_EXPORTED, 0, handle, _vgimportclone_vg_single);
unlock_vg(cmd, NULL, vp.new_vgname);
diff --git a/tools/vgmerge.c b/tools/vgmerge.c
index f2c785b..8c8f2a2 100644
--- a/tools/vgmerge.c
+++ b/tools/vgmerge.c
@@ -210,6 +210,8 @@ int vgmerge(struct cmd_context *cmd, int argc, char **argv)
if (!lockd_gl(cmd, "ex", LDGL_UPDATE_NAMES))
return ECMD_FAILED;
+ clear_hint_file(cmd);
+
vg_name_to = skip_dev_dir(cmd, argv[0], NULL);
argc--;
argv++;
diff --git a/tools/vgreduce.c b/tools/vgreduce.c
index ce3d155..1bca33f 100644
--- a/tools/vgreduce.c
+++ b/tools/vgreduce.c
@@ -224,6 +224,8 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
return_ECMD_FAILED;
cmd->lockd_gl_disable = 1;
+ clear_hint_file(cmd);
+
if (!(handle = init_processing_handle(cmd, NULL))) {
log_error("Failed to initialize processing handle.");
return ECMD_FAILED;
diff --git a/tools/vgremove.c b/tools/vgremove.c
index 5010e7d..2120858 100644
--- a/tools/vgremove.c
+++ b/tools/vgremove.c
@@ -101,6 +101,8 @@ int vgremove(struct cmd_context *cmd, int argc, char **argv)
if (!lockd_gl(cmd, "ex", LDGL_UPDATE_NAMES))
return ECMD_FAILED;
+ clear_hint_file(cmd);
+
/*
* This is a special case: if vgremove is given a tag, it causes
* process_each_vg to do lockd_gl(sh) when getting a list of all
diff --git a/tools/vgrename.c b/tools/vgrename.c
index 5e386cc..1286ed9 100644
--- a/tools/vgrename.c
+++ b/tools/vgrename.c
@@ -195,6 +195,8 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv)
if (!lockd_gl(cmd, "ex", LDGL_UPDATE_NAMES))
return_ECMD_FAILED;
+ clear_hint_file(cmd);
+
/*
* Special case where vg_name_old may be a UUID:
* If vg_name_old is a UUID, then process_each may
diff --git a/tools/vgsplit.c b/tools/vgsplit.c
index fc99d2e..87f48df 100644
--- a/tools/vgsplit.c
+++ b/tools/vgsplit.c
@@ -569,6 +569,8 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv)
if (!lockd_gl(cmd, "ex", LDGL_UPDATE_NAMES))
return_ECMD_FAILED;
+ clear_hint_file(cmd);
+
if (arg_is_set(cmd, name_ARG))
lv_name = arg_value(cmd, name_ARG);
else
5 years, 3 months