diff --git a/0083-multipath.rules-fix-smart-bug-with-failed-valid-path.patch b/0083-multipath.rules-fix-smart-bug-with-failed-valid-path.patch new file mode 100644 index 0000000..c162aa2 --- /dev/null +++ b/0083-multipath.rules-fix-smart-bug-with-failed-valid-path.patch @@ -0,0 +1,70 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Tue, 7 Feb 2023 15:39:26 -0600 +Subject: [PATCH] multipath.rules: fix "smart" bug with failed valid path check + +If "multipath -u" fails, udev doesn't import any values from the +program. This means that multipath.rules will continue to use the values +for DM_MULTIPATH_DEVICE_PATH and FIND_MULTIPATHS_WAIT_UNTIL that it has +already imported from the database. This is the correct thing to do for +every case except the MAYBE case for "find_multipaths smart". In that +case, DM_MULTIPATH_DEVICE_PATH will be set to 1, and the rules will +assume that the device has been definitively claimed. + +In this case, we know that the device shouldn't have been claimed +before, but we don't know if it should be claimed now, or if we have hit +the timeout and it should be released, since we didn't get any +information from multipath. The safest thing to do is assume that this +was the timeout, and the device shouldn't be claimed. The only time when +this could be the wrong answer is when we first see a new multipath +device, and it could only cause problems if there is metadata on the +device that will cause it to get autoassembled by something else, before +multipathd can autoassemble it. If we assume that it is a multipath +device, or we assume that this wasn't actually the timeout uevent, we +can keep a necessary device from getting released to the reset of the +system. + +Signed-off-by: Benjamin Marzinski +--- + multipath/multipath.rules.in | 22 ++++++++++++++++------ + 1 file changed, 16 insertions(+), 6 deletions(-) + +diff --git a/multipath/multipath.rules.in b/multipath/multipath.rules.in +index 5c4447a2..70b69a06 100644 +--- a/multipath/multipath.rules.in ++++ b/multipath/multipath.rules.in +@@ -32,7 +32,8 @@ IMPORT{db}="DM_MULTIPATH_DEVICE_PATH" + + # multipath -u sets DM_MULTIPATH_DEVICE_PATH and, + # if "find_multipaths smart", also FIND_MULTIPATHS_WAIT_UNTIL. +-IMPORT{program}="$env{MPATH_SBIN_PATH}/multipath -u %k" ++IMPORT{program}=="$env{MPATH_SBIN_PATH}/multipath -u %k", \ ++ ENV{.MPATH_CHECK_PASSED}="1" + + # case 1: this is definitely multipath + ENV{DM_MULTIPATH_DEVICE_PATH}=="1", \ +@@ -83,10 +84,19 @@ LABEL="stop_wait" + # If timeout hasn't expired but we're not in "maybe" state any more, stop timer + # Do this only once, and only if the timer has been started before + IMPORT{db}="FIND_MULTIPATHS_WAIT_CANCELLED" +-ENV{FIND_MULTIPATHS_WAIT_CANCELLED}!="?*", \ +- ENV{FIND_MULTIPATHS_WAIT_UNTIL}=="?*", \ +- ENV{FIND_MULTIPATHS_WAIT_UNTIL}!="0", \ +- ENV{FIND_MULTIPATHS_WAIT_CANCELLED}="1", \ +- RUN+="/usr/bin/systemctl stop cancel-multipath-wait-$kernel.timer" ++ENV{FIND_MULTIPATHS_WAIT_CANCELLED}=="?*", GOTO="end_mpath" ++ENV{FIND_MULTIPATHS_WAIT_UNTIL}!="?*", GOTO="end_mpath" ++ENV{FIND_MULTIPATHS_WAIT_UNTIL}=="0", GOTO="end_mpath" ++ ++ENV{FIND_MULTIPATHS_WAIT_CANCELLED}="1" ++RUN+="/usr/bin/systemctl stop cancel-multipath-wait-$kernel.timer" ++ ++# If "multipath -u" failed, no values are imported from the program, ++# and we are still using the values for DM_MULTIPATH_DEVICE_PATH and ++# FIND_MULTIPATHS_WAIT_UNTIL that were imported from the database. ++# If we are in "smart" mode, we need to give up on the path now, ++# since this may have been the timeout event. Without the imports ++# from "multipath -u", we can't tell. ++ENV{.MPATH_CHECK_PASSED}!="?*", ENV{DM_MULTIPATH_DEVICE_PATH}="0" + + LABEL="end_mpath" diff --git a/0084-libmultipath-limit-paths-that-can-get-wwid-from-envi.patch b/0084-libmultipath-limit-paths-that-can-get-wwid-from-envi.patch new file mode 100644 index 0000000..51cf9c4 --- /dev/null +++ b/0084-libmultipath-limit-paths-that-can-get-wwid-from-envi.patch @@ -0,0 +1,64 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Wed, 8 Feb 2023 19:31:02 -0600 +Subject: [PATCH] libmultipath: limit paths that can get wwid from environment + +Currently, whenever getting the uid_attribute from udev database fails, +multipath will try to get it from the environment variables. This +normally isn't a problem, since either multipath -u is getting called +from a uevent, and the environment will have the correct value in that +variable, or that variable won't be set. However, when find_multipaths +is configured to "smart", this causes problems. For maybe devices, +multipath needs to get the WWIDs of all the other block devices, to see +if they match the maybe device wwid. If one of those devices doesn't +have uid_attribute set in its udev database, multipath will check the +environment for it, and it will find that variable set to the WWID +of the maybe device that this uevent is for. This means that all +devices with no WWID will end up appearing to have the same WWID as +the maybe device, causing multipath to incorrectly claim it. + +Signed-off-by: Benjamin Marzinski +--- + libmultipath/discovery.c | 2 +- + libmultipath/structs.h | 1 + + multipath/main.c | 2 ++ + 3 files changed, 4 insertions(+), 1 deletion(-) + +diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c +index f593a7bf..a592a54e 100644 +--- a/libmultipath/discovery.c ++++ b/libmultipath/discovery.c +@@ -2032,7 +2032,7 @@ get_udev_uid(struct path * pp, char *uid_attribute, struct udev_device *udev) + const char *value; + + value = udev_device_get_property_value(udev, uid_attribute); +- if (!value || strlen(value) == 0) ++ if ((!value || strlen(value) == 0) && pp->can_use_env_uid) + value = getenv(uid_attribute); + if (value && strlen(value)) { + len = strlcpy(pp->wwid, value, WWID_SIZE); +diff --git a/libmultipath/structs.h b/libmultipath/structs.h +index 0867b91d..4b308561 100644 +--- a/libmultipath/structs.h ++++ b/libmultipath/structs.h +@@ -360,6 +360,7 @@ struct path { + int fast_io_fail; + unsigned int dev_loss; + int eh_deadline; ++ bool can_use_env_uid; + /* configlet pointers */ + vector hwe; + struct gen_path generic_path; +diff --git a/multipath/main.c b/multipath/main.c +index 41d01c7e..e056c51c 100644 +--- a/multipath/main.c ++++ b/multipath/main.c +@@ -653,6 +653,8 @@ check_path_valid(const char *name, struct config *conf, bool is_uevent) + pp = alloc_path(); + if (!pp) + return RTVL_FAIL; ++ if (is_uevent) ++ pp->can_use_env_uid = true; + + r = is_path_valid(name, conf, pp, is_uevent); + if (r <= PATH_IS_ERROR || r >= PATH_MAX_VALID_RESULT) diff --git a/device-mapper-multipath.spec b/device-mapper-multipath.spec index 89567fb..2c8e86f 100644 --- a/device-mapper-multipath.spec +++ b/device-mapper-multipath.spec @@ -1,6 +1,6 @@ Name: device-mapper-multipath Version: 0.8.7 -Release: 19%{?dist} +Release: 20%{?dist} Summary: Tools to manage multipath devices using device-mapper License: GPLv2 URL: http://christophe.varoqui.free.fr/ @@ -92,6 +92,8 @@ Patch0079: 0079-libmultipath-use-select_reload_action-in-select_acti.patch Patch0080: 0080-libmultipath-select-resize-action-even-if-reload-is-.patch Patch0081: 0081-libmultipath-cleanup-ACT_CREATE-code-in-select_actio.patch Patch0082: 0082-libmultipath-keep-renames-from-stopping-other-multip.patch +Patch0083: 0083-multipath.rules-fix-smart-bug-with-failed-valid-path.patch +Patch0084: 0084-libmultipath-limit-paths-that-can-get-wwid-from-envi.patch # runtime @@ -183,7 +185,6 @@ cp %{SOURCE1} . %build %define _sbindir /usr/sbin %define _libdir /usr/%{_lib} -%define _udevdir /usr/lib/udev %define _libmpathdir %{_libdir}/multipath %define _pkgconfdir %{_libdir}/pkgconfig %make_build LIB=%{_lib} @@ -271,7 +272,7 @@ fi %license LICENSES/GPL-2.0 %doc README.md %{_sbindir}/kpartx -%{_udevdir}/kpartx_id +%{_udevrulesdir}/../kpartx_id %{_mandir}/man8/kpartx.8.gz %config %{_udevrulesdir}/11-dm-parts.rules %config %{_udevrulesdir}/66-kpartx.rules @@ -294,6 +295,12 @@ fi %{_pkgconfdir}/libdmmp.pc %changelog +* Thu Feb 9 2023 Benjamin Marzinski - 0.8.7-20 +- Add 0083-multipath.rules-fix-smart-bug-with-failed-valid-path.patch +- Add 0084-libmultipath-limit-paths-that-can-get-wwid-from-envi.patch +- Change how the installation dir for kpartx_id is specified +- Resolves: bz #1926147 + * Fri Feb 3 2023 Benjamin Marzinski - 0.8.7-19 - Fix bugzilla linked to the changes (was previously linked to the wrong bug, 2162536)