diff --git a/0048-libmultipath-add-device-to-hwtable.c.patch b/0048-libmultipath-add-device-to-hwtable.c.patch new file mode 100644 index 0000000..9d5e780 --- /dev/null +++ b/0048-libmultipath-add-device-to-hwtable.c.patch @@ -0,0 +1,44 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Steve Schremmer +Date: Mon, 6 Jul 2020 20:22:35 +0000 +Subject: [PATCH] libmultipath: add device to hwtable.c + +Add FUJITSU ETERNUS_AHB defaults. + +Signed-off-by: Steve Schremmer +Reviewed-by: Martin Wilck +Signed-off-by: Benjamin Marzinski +--- + libmultipath/hwtable.c | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) + +diff --git a/libmultipath/hwtable.c b/libmultipath/hwtable.c +index d1fcfdb3..d680bdfc 100644 +--- a/libmultipath/hwtable.c ++++ b/libmultipath/hwtable.c +@@ -428,6 +428,22 @@ static struct hwentry default_hw[] = { + .pgpolicy = MULTIBUS, + .no_path_retry = 10, + }, ++ { ++ /* ++ * ETERNUS AB/HB ++ * Maintainer: NetApp RDAC team ++ */ ++ .vendor = "FUJITSU", ++ .product = "ETERNUS_AHB", ++ .bl_product = "Universal Xport", ++ .pgpolicy = GROUP_BY_PRIO, ++ .checker_name = RDAC, ++ .features = "2 pg_init_retries 50", ++ .hwhandler = "1 rdac", ++ .prio_name = PRIO_RDAC, ++ .pgfailback = -FAILBACK_IMMEDIATE, ++ .no_path_retry = 30, ++ }, + /* + * Hitachi Vantara + * +-- +2.17.2 + diff --git a/0049-master-libmultipath-fix-use-after-free-when-iscsi-lo.patch b/0049-master-libmultipath-fix-use-after-free-when-iscsi-lo.patch new file mode 100644 index 0000000..bfb9f8f --- /dev/null +++ b/0049-master-libmultipath-fix-use-after-free-when-iscsi-lo.patch @@ -0,0 +1,84 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: lixiaokeng +Date: Mon, 13 Jul 2020 13:07:40 +0200 +Subject: [PATCH] master - libmultipath: fix use after free when iscsi logs in + +When two iscsi ips log in and out alternately and the following scripts run +at the same time, + +#!/bin/bash +interval=5 +while true +do + iscsiadm -m node -p 9.41.147.171 &> /dev/null + iscsiadm -m node -p 9.41.148.172 &> /dev/null + iscsiadm -m session &> /dev/null + rescan-scsi-bus.sh &> /dev/null + multipath -v2 &> /dev/null + multipath -ll &> /dev/null + sleep $interval +done + +multipathd will have a segfault after about 30 mins. + +The reason is that mpp->hwe is accessed after hwe is already freed. In +extract_hwe_from_path func, mpp->hwe is set to pp->hwe, so they points to the +same hwe. For some reasons, pp->mpp will be set to NULL in orphan_path func. +Then, pp and hwe will be freed with (pp->mpp == NULL) in free_path func +called by ev_remove_path func. However, mpp->hwe is not set to NULL while hwe +is already freed. So, when iscsi device logs in and new path is added to mpp, +mpp->hwe will be accessed in select_pgfailback func. Finally, use-after-free +problem occurs. + +The procedure details given as follows, +1.wait_dmevents thread +wait_dmevents + ->dmevent_loop + ->update_multipath + ->__setup_multipath + ->update_multipath_strings + -> sync_paths + ->orphan_path +2.uevqloop thread (iscsi log out, remove path) +uevqloop +->uevent_dispatch + ->service_uevq + ->uev_remove_path + ->ev_remove_path //pp->mpp is NULL + ->free_path(pp) + //pp->hew are freed but mpp->hwe is not set to NULL +3.ev_remove_path (iscsi log in, add path) +uevqloop +->uevent_dispatch + ->service_uevq + ->ev_add_path + ->select_pgfailback //mpp->hwe is accessed + +Here, we will set mpp->hwe to NULL before setting pp->map to NULL in orphan_path +func. + +Signed-off-by: Tianxiong Lu +Signed-off-by: lixiaokeng +Signed-off-by: Zhiqiang Liu +Signed-off-by: Martin Wilck +Signed-off-by: Benjamin Marzinski +--- + libmultipath/structs_vec.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/libmultipath/structs_vec.c b/libmultipath/structs_vec.c +index 8137ea21..430eaad7 100644 +--- a/libmultipath/structs_vec.c ++++ b/libmultipath/structs_vec.c +@@ -93,6 +93,8 @@ int adopt_paths(vector pathvec, struct multipath *mpp) + void orphan_path(struct path *pp, const char *reason) + { + condlog(3, "%s: orphan path, %s", pp->dev, reason); ++ if (pp->mpp && pp->mpp->hwe == pp->hwe) ++ pp->mpp->hwe = NULL; + pp->mpp = NULL; + pp->dmstate = PSTATE_UNDEF; + pp->uid_attribute = NULL; +-- +2.17.2 + diff --git a/0050-libmultipath-warn-if-freeing-path-that-holds-mpp-hwe.patch b/0050-libmultipath-warn-if-freeing-path-that-holds-mpp-hwe.patch new file mode 100644 index 0000000..3c286fa --- /dev/null +++ b/0050-libmultipath-warn-if-freeing-path-that-holds-mpp-hwe.patch @@ -0,0 +1,33 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Martin Wilck +Date: Mon, 13 Jul 2020 13:07:41 +0200 +Subject: [PATCH] libmultipath: warn if freeing path that holds mpp->hwe + +This just adds an error message to the previous patch. + +Signed-off-by: Martin Wilck +Signed-off-by: Benjamin Marzinski +--- + libmultipath/structs_vec.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +diff --git a/libmultipath/structs_vec.c b/libmultipath/structs_vec.c +index 430eaad7..cde4dbe6 100644 +--- a/libmultipath/structs_vec.c ++++ b/libmultipath/structs_vec.c +@@ -93,8 +93,11 @@ int adopt_paths(vector pathvec, struct multipath *mpp) + void orphan_path(struct path *pp, const char *reason) + { + condlog(3, "%s: orphan path, %s", pp->dev, reason); +- if (pp->mpp && pp->mpp->hwe == pp->hwe) ++ if (pp->mpp && pp->hwe && pp->mpp->hwe == pp->hwe) { ++ condlog(0, "BUG: orphaning path %s that holds hwe of %s", ++ pp->dev, pp->mpp->alias); + pp->mpp->hwe = NULL; ++ } + pp->mpp = NULL; + pp->dmstate = PSTATE_UNDEF; + pp->uid_attribute = NULL; +-- +2.17.2 + diff --git a/0051-libmultipath-warn-about-NULL-value-of-mpp-hwe.patch b/0051-libmultipath-warn-about-NULL-value-of-mpp-hwe.patch new file mode 100644 index 0000000..a50b9b2 --- /dev/null +++ b/0051-libmultipath-warn-about-NULL-value-of-mpp-hwe.patch @@ -0,0 +1,33 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Martin Wilck +Date: Mon, 13 Jul 2020 13:07:42 +0200 +Subject: [PATCH] libmultipath: warn about NULL value of mpp->hwe + +mpp->hwe is only accessed in propsel.c. It may become unset if +all paths of the mpp have been deleted. Access to mpp->hwe in this +case should be avoided. + +Signed-off-by: Martin Wilck +Signed-off-by: Benjamin Marzinski +--- + libmultipath/propsel.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/libmultipath/propsel.c b/libmultipath/propsel.c +index d362beb4..68228272 100644 +--- a/libmultipath/propsel.c ++++ b/libmultipath/propsel.c +@@ -65,7 +65,9 @@ do { \ + __do_set_from_vec(struct hwentry, var, (src)->hwe, dest) + + #define do_set_from_hwe(var, src, dest, msg) \ +- if (__do_set_from_hwe(var, src, dest)) { \ ++ if (!src->hwe) { \ ++ condlog(0, "BUG: do_set_from_hwe called with hwe == NULL"); \ ++ } else if (__do_set_from_hwe(var, src, dest)) { \ + origin = msg; \ + goto out; \ + } +-- +2.17.2 + diff --git a/0052-libmultipath-fix-mpp-hwe-handling-in-sync_paths.patch b/0052-libmultipath-fix-mpp-hwe-handling-in-sync_paths.patch new file mode 100644 index 0000000..b9caf46 --- /dev/null +++ b/0052-libmultipath-fix-mpp-hwe-handling-in-sync_paths.patch @@ -0,0 +1,45 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Martin Wilck +Date: Mon, 13 Jul 2020 13:07:43 +0200 +Subject: [PATCH] libmultipath: fix mpp->hwe handling in sync_paths() + +This is anologous to + +1f96269 ("multipathd: fix mpp->hwe handling on path removal") +f6839eb ("multipathd: fix mpp->hwe handling when paths are freed") + +When paths are removed from a map, we need to make sure that +mpp->hwe doesn't become stale. + +Reported-by: Lixiaokeng +Signed-off-by: Martin Wilck +Signed-off-by: Benjamin Marzinski +--- + libmultipath/structs_vec.c | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/libmultipath/structs_vec.c b/libmultipath/structs_vec.c +index cde4dbe6..ede14297 100644 +--- a/libmultipath/structs_vec.c ++++ b/libmultipath/structs_vec.c +@@ -260,6 +260,8 @@ void sync_paths(struct multipath *mpp, vector pathvec) + } + if (!found) { + condlog(3, "%s dropped path %s", mpp->alias, pp->dev); ++ if (mpp->hwe == pp->hwe) ++ mpp->hwe = NULL; + vector_del_slot(mpp->paths, i--); + orphan_path(pp, "path removed externally"); + } +@@ -267,6 +269,8 @@ void sync_paths(struct multipath *mpp, vector pathvec) + update_mpp_paths(mpp, pathvec); + vector_foreach_slot (mpp->paths, pp, i) + pp->mpp = mpp; ++ if (mpp->hwe == NULL) ++ extract_hwe_from_path(mpp); + } + + int +-- +2.17.2 + diff --git a/0048-Makefile.inc-trim-extra-information-from-systemd-ver.patch b/0053-Makefile.inc-trim-extra-information-from-systemd-ver.patch similarity index 100% rename from 0048-Makefile.inc-trim-extra-information-from-systemd-ver.patch rename to 0053-Makefile.inc-trim-extra-information-from-systemd-ver.patch diff --git a/0049-kpartx-fix-Wsign-compare-error.patch b/0054-kpartx-fix-Wsign-compare-error.patch similarity index 100% rename from 0049-kpartx-fix-Wsign-compare-error.patch rename to 0054-kpartx-fix-Wsign-compare-error.patch diff --git a/0055-libmultipath-remove-code-duplication-in-path-countin.patch b/0055-libmultipath-remove-code-duplication-in-path-countin.patch new file mode 100644 index 0000000..699049a --- /dev/null +++ b/0055-libmultipath-remove-code-duplication-in-path-countin.patch @@ -0,0 +1,129 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Tue, 21 Jul 2020 01:12:05 -0500 +Subject: [PATCH] libmultipath: remove code duplication in path counting + +pathcountgr() is never used except by pathcount(), and neither is the +special case for PATH_WILD. Simplify this and make one function that is +used by both pathcount() and count_active_paths(). This will be used +again in a future patch. + +Also use count_active_paths() in mpath_persist. + +Signed-off-by: Benjamin Marzinski +--- + libmpathpersist/mpath_persist.c | 4 +-- + libmultipath/structs.c | 47 +++++++++++++-------------------- + libmultipath/structs.h | 1 - + 3 files changed, 21 insertions(+), 31 deletions(-) + +diff --git a/libmpathpersist/mpath_persist.c b/libmpathpersist/mpath_persist.c +index 3da7a6cf..a132f4e9 100644 +--- a/libmpathpersist/mpath_persist.c ++++ b/libmpathpersist/mpath_persist.c +@@ -436,7 +436,7 @@ int mpath_prout_reg(struct multipath *mpp,int rq_servact, int rq_scope, + + all_tg_pt = (mpp->all_tg_pt == ALL_TG_PT_ON || + paramp->sa_flags & MPATH_F_ALL_TG_PT_MASK); +- active_pathcount = pathcount(mpp, PATH_UP) + pathcount(mpp, PATH_GHOST); ++ active_pathcount = count_active_paths(mpp); + + if (active_pathcount == 0) { + condlog (0, "%s: no path available", mpp->wwid); +@@ -648,7 +648,7 @@ int mpath_prout_rel(struct multipath *mpp,int rq_servact, int rq_scope, + if (!mpp) + return MPATH_PR_DMMP_ERROR; + +- active_pathcount = pathcount (mpp, PATH_UP) + pathcount (mpp, PATH_GHOST); ++ active_pathcount = count_active_paths(mpp); + + struct threadinfo thread[active_pathcount]; + memset(thread, 0, sizeof(thread)); +diff --git a/libmultipath/structs.c b/libmultipath/structs.c +index 2dd378c4..3eac3d61 100644 +--- a/libmultipath/structs.c ++++ b/libmultipath/structs.c +@@ -455,49 +455,40 @@ find_path_by_devt (const struct _vector *pathvec, const char * dev_t) + return NULL; + } + +-int pathcountgr(const struct pathgroup *pgp, int state) ++static int do_pathcount(const struct multipath *mpp, const int *states, ++ unsigned int nr_states) + { ++ struct pathgroup *pgp; + struct path *pp; + int count = 0; +- int i; ++ unsigned int i, j, k; + +- vector_foreach_slot (pgp->paths, pp, i) +- if ((pp->state == state) || (state == PATH_WILD)) +- count++; ++ if (!mpp->pg || !nr_states) ++ return count; + ++ vector_foreach_slot (mpp->pg, pgp, i) { ++ vector_foreach_slot (pgp->paths, pp, j) { ++ for (k = 0; k < nr_states; k++) { ++ if (pp->state == states[k]) { ++ count++; ++ break; ++ } ++ } ++ } ++ } + return count; + } + + int pathcount(const struct multipath *mpp, int state) + { +- struct pathgroup *pgp; +- int count = 0; +- int i; +- +- if (mpp->pg) { +- vector_foreach_slot (mpp->pg, pgp, i) +- count += pathcountgr(pgp, state); +- } +- return count; ++ return do_pathcount(mpp, &state, 1); + } + + int count_active_paths(const struct multipath *mpp) + { +- struct pathgroup *pgp; +- struct path *pp; +- int count = 0; +- int i, j; +- +- if (!mpp->pg) +- return 0; ++ int states[] = {PATH_UP, PATH_GHOST}; + +- vector_foreach_slot (mpp->pg, pgp, i) { +- vector_foreach_slot (pgp->paths, pp, j) { +- if (pp->state == PATH_UP || pp->state == PATH_GHOST) +- count++; +- } +- } +- return count; ++ return do_pathcount(mpp, states, 2); + } + + int pathcmp(const struct pathgroup *pgp, const struct pathgroup *cpgp) +diff --git a/libmultipath/structs.h b/libmultipath/structs.h +index d69bc2e9..0c03e711 100644 +--- a/libmultipath/structs.h ++++ b/libmultipath/structs.h +@@ -446,7 +446,6 @@ struct path * find_path_by_devt (const struct _vector *pathvec, const char *devt + struct path * find_path_by_dev (const struct _vector *pathvec, const char *dev); + struct path * first_path (const struct multipath *mpp); + +-int pathcountgr (const struct pathgroup *, int); + int pathcount (const struct multipath *, int); + int count_active_paths(const struct multipath *); + int pathcmp (const struct pathgroup *, const struct pathgroup *); +-- +2.17.2 + diff --git a/0056-libmultipath-count-pending-paths-as-active-on-loads.patch b/0056-libmultipath-count-pending-paths-as-active-on-loads.patch new file mode 100644 index 0000000..5320297 --- /dev/null +++ b/0056-libmultipath-count-pending-paths-as-active-on-loads.patch @@ -0,0 +1,73 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Tue, 21 Jul 2020 01:19:30 -0500 +Subject: [PATCH] libmultipath: count pending paths as active on loads + +When multipath loads a table, it signals to udev if there are no active +paths. Multipath wasn't counting pending paths as active. This meant +that if all the paths were pending, udev would treat the device as not +ready, and not run kpartx on it. Even if the pending paths later +because active and were reinstated, the kernel would not send a new +uevent, because from its point of view, they were always up. + +The alternative would be to continue to treat them as failed in the udev +rules, but then also tell the kernel that they were down, so that it +would trigger a uevent when they were reinstated. However, this could +lead to newly created multipath devices failing IO, simply because the +path checkers hadn't returned yet. Having udev assume that the the +device is up, like the kernel does, seems like the safer option. + +Signed-off-by: Benjamin Marzinski +--- + libmultipath/devmapper.c | 3 ++- + libmultipath/structs.c | 7 +++++++ + libmultipath/structs.h | 1 + + 3 files changed, 10 insertions(+), 1 deletion(-) + +diff --git a/libmultipath/devmapper.c b/libmultipath/devmapper.c +index f597ff8b..126cd728 100644 +--- a/libmultipath/devmapper.c ++++ b/libmultipath/devmapper.c +@@ -417,7 +417,8 @@ static uint16_t build_udev_flags(const struct multipath *mpp, int reload) + /* DM_UDEV_DISABLE_LIBRARY_FALLBACK is added in dm_addmap */ + return (mpp->skip_kpartx == SKIP_KPARTX_ON ? + MPATH_UDEV_NO_KPARTX_FLAG : 0) | +- ((count_active_paths(mpp) == 0 || mpp->ghost_delay_tick > 0) ? ++ ((count_active_pending_paths(mpp) == 0 || ++ mpp->ghost_delay_tick > 0) ? + MPATH_UDEV_NO_PATHS_FLAG : 0) | + (reload && !mpp->force_udev_reload ? + MPATH_UDEV_RELOAD_FLAG : 0); +diff --git a/libmultipath/structs.c b/libmultipath/structs.c +index 3eac3d61..0d1f969d 100644 +--- a/libmultipath/structs.c ++++ b/libmultipath/structs.c +@@ -491,6 +491,13 @@ int count_active_paths(const struct multipath *mpp) + return do_pathcount(mpp, states, 2); + } + ++int count_active_pending_paths(const struct multipath *mpp) ++{ ++ int states[] = {PATH_UP, PATH_GHOST, PATH_PENDING}; ++ ++ return do_pathcount(mpp, states, 3); ++} ++ + int pathcmp(const struct pathgroup *pgp, const struct pathgroup *cpgp) + { + int i, j; +diff --git a/libmultipath/structs.h b/libmultipath/structs.h +index 0c03e711..917e4083 100644 +--- a/libmultipath/structs.h ++++ b/libmultipath/structs.h +@@ -448,6 +448,7 @@ struct path * first_path (const struct multipath *mpp); + + int pathcount (const struct multipath *, int); + int count_active_paths(const struct multipath *); ++int count_active_pending_paths(const struct multipath *); + int pathcmp (const struct pathgroup *, const struct pathgroup *); + int add_feature (char **, const char *); + int remove_feature (char **, const char *); +-- +2.17.2 + diff --git a/0057-libmultipath-deal-with-flushing-no-maps.patch b/0057-libmultipath-deal-with-flushing-no-maps.patch new file mode 100644 index 0000000..0aee761 --- /dev/null +++ b/0057-libmultipath-deal-with-flushing-no-maps.patch @@ -0,0 +1,33 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Tue, 21 Jul 2020 01:28:22 -0500 +Subject: [PATCH] libmultipath: deal with flushing no maps + +dm_flush_maps() was failing if there were no device-mapper devices at +all, instead of returning success, since there is nothing to do. + +Fixes: "libmultipath: make dm_flush_maps only return 0 on success" +Signed-off-by: Benjamin Marzinski +--- + libmultipath/devmapper.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/libmultipath/devmapper.c b/libmultipath/devmapper.c +index 126cd728..b8199cb5 100644 +--- a/libmultipath/devmapper.c ++++ b/libmultipath/devmapper.c +@@ -1024,10 +1024,10 @@ int dm_flush_maps (int need_suspend, int retries) + if (!(names = dm_task_get_names (dmt))) + goto out; + ++ r = 0; + if (!names->dev) + goto out; + +- r = 0; + do { + if (need_suspend) + r |= dm_suspend_and_flush_map(names->name, retries); +-- +2.17.2 + diff --git a/0058-multipath-deal-with-delegation-failures-correctly.patch b/0058-multipath-deal-with-delegation-failures-correctly.patch new file mode 100644 index 0000000..e8d0050 --- /dev/null +++ b/0058-multipath-deal-with-delegation-failures-correctly.patch @@ -0,0 +1,39 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Tue, 21 Jul 2020 01:37:18 -0500 +Subject: [PATCH] multipath: deal with delegation failures correctly + +delegate_to_multipathd() was returning success, even if the multipathd +command failed. Also, if the command was set to fail with NOT_DELEGATED, +it shouldn't print any errors, since multipath will try to issue to +command itself. + +Fixes: "multipath: delegate flushing maps to multipathd" +Signed-off-by: Benjamin Marzinski +--- + multipath/main.c | 9 ++++++--- + 1 file changed, 6 insertions(+), 3 deletions(-) + +diff --git a/multipath/main.c b/multipath/main.c +index 4c43314e..3da692dc 100644 +--- a/multipath/main.c ++++ b/multipath/main.c +@@ -861,9 +861,12 @@ int delegate_to_multipathd(enum mpath_cmds cmd, + goto out; + } + +- if (reply != NULL && *reply != '\0' && strcmp(reply, "ok\n")) +- printf("%s", reply); +- r = DELEGATE_OK; ++ if (reply != NULL && *reply != '\0') { ++ if (strcmp(reply, "fail\n")) ++ r = DELEGATE_OK; ++ if (r != NOT_DELEGATED && strcmp(reply, "ok\n")) ++ printf("%s", reply); ++ } + + out: + FREE(reply); +-- +2.17.2 + diff --git a/0050-RH-fixup-udev-rules-for-redhat.patch b/0059-RH-fixup-udev-rules-for-redhat.patch similarity index 100% rename from 0050-RH-fixup-udev-rules-for-redhat.patch rename to 0059-RH-fixup-udev-rules-for-redhat.patch diff --git a/0051-RH-Remove-the-property-blacklist-exception-builtin.patch b/0060-RH-Remove-the-property-blacklist-exception-builtin.patch similarity index 100% rename from 0051-RH-Remove-the-property-blacklist-exception-builtin.patch rename to 0060-RH-Remove-the-property-blacklist-exception-builtin.patch diff --git a/0052-RH-don-t-start-without-a-config-file.patch b/0061-RH-don-t-start-without-a-config-file.patch similarity index 100% rename from 0052-RH-don-t-start-without-a-config-file.patch rename to 0061-RH-don-t-start-without-a-config-file.patch diff --git a/0053-RH-use-rpm-optflags-if-present.patch b/0062-RH-use-rpm-optflags-if-present.patch similarity index 100% rename from 0053-RH-use-rpm-optflags-if-present.patch rename to 0062-RH-use-rpm-optflags-if-present.patch diff --git a/0054-RH-add-mpathconf.patch b/0063-RH-add-mpathconf.patch similarity index 100% rename from 0054-RH-add-mpathconf.patch rename to 0063-RH-add-mpathconf.patch diff --git a/0055-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch b/0064-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch similarity index 97% rename from 0055-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch rename to 0064-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch index a10f147..0b95ee6 100644 --- a/0055-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch +++ b/0064-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch @@ -86,7 +86,7 @@ index 0c6ee54d..e32a0b0e 100644 enum { WWID_IS_NOT_FAILED = 0, diff --git a/multipath/main.c b/multipath/main.c -index 4c43314e..c73f6963 100644 +index 3da692dc..ce48a932 100644 --- a/multipath/main.c +++ b/multipath/main.c @@ -135,7 +135,7 @@ usage (char * progname) @@ -107,7 +107,7 @@ index 4c43314e..c73f6963 100644 " -c check if a device should be a path in a multipath device\n" " -C check if a multipath device has usable paths\n" " -q allow queue_if_no_path when multipathd is not running\n" -@@ -893,7 +895,7 @@ main (int argc, char *argv[]) +@@ -896,7 +898,7 @@ main (int argc, char *argv[]) multipath_conf = conf; conf->retrigger_tries = 0; conf->force_sync = 1; @@ -116,7 +116,7 @@ index 4c43314e..c73f6963 100644 switch(arg) { case 1: printf("optarg : %s\n",optarg); break; -@@ -970,6 +972,10 @@ main (int argc, char *argv[]) +@@ -973,6 +975,10 @@ main (int argc, char *argv[]) case 'T': cmd = CMD_DUMP_CONFIG; break; diff --git a/0056-RH-warn-on-invalid-regex-instead-of-failing.patch b/0065-RH-warn-on-invalid-regex-instead-of-failing.patch similarity index 100% rename from 0056-RH-warn-on-invalid-regex-instead-of-failing.patch rename to 0065-RH-warn-on-invalid-regex-instead-of-failing.patch diff --git a/0057-RH-reset-default-find_mutipaths-value-to-off.patch b/0066-RH-reset-default-find_mutipaths-value-to-off.patch similarity index 100% rename from 0057-RH-reset-default-find_mutipaths-value-to-off.patch rename to 0066-RH-reset-default-find_mutipaths-value-to-off.patch diff --git a/0058-RH-Fix-nvme-compilation-warning.patch b/0067-RH-Fix-nvme-compilation-warning.patch similarity index 100% rename from 0058-RH-Fix-nvme-compilation-warning.patch rename to 0067-RH-Fix-nvme-compilation-warning.patch diff --git a/0059-RH-attempt-to-get-ANA-info-via-sysfs-first.patch b/0068-RH-attempt-to-get-ANA-info-via-sysfs-first.patch similarity index 100% rename from 0059-RH-attempt-to-get-ANA-info-via-sysfs-first.patch rename to 0068-RH-attempt-to-get-ANA-info-via-sysfs-first.patch diff --git a/0060-RH-work-around-gcc-10-format-truncation-issue.patch b/0069-RH-work-around-gcc-10-format-truncation-issue.patch similarity index 100% rename from 0060-RH-work-around-gcc-10-format-truncation-issue.patch rename to 0069-RH-work-around-gcc-10-format-truncation-issue.patch diff --git a/0070-multipath-add-libmpathvalid-library.patch b/0070-multipath-add-libmpathvalid-library.patch new file mode 100644 index 0000000..b3863cd --- /dev/null +++ b/0070-multipath-add-libmpathvalid-library.patch @@ -0,0 +1,369 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Wed, 13 May 2020 17:04:24 -0500 +Subject: [PATCH] multipath: add libmpathvalid library + +This library allows other programs to check if a path should be claimed +by multipath. It exports an init and exit function, that need to be +called before any other functions can be called, a pointer to a struct +config, that stores the configuration which is dealt with in the +init and exit functions, and two more functions. + +mpath_get_mode() get the configured find_multipaths mode. +mpath_is_path() returns whether the device is claimed by multipath, and +optionally returns the wwid. This code works slightly different than +the multipath -c/u code for SMART mode. Instead of checking all the +existing paths to see if another has the same wwid, it expects the +caller to pass in an array of the already known path wwids, and checks +if the current path matches any of those. + +The library also doesn't set up the device-mapper log fuctions. It +leaves this up to the caller. + +Signed-off-by: Benjamin Marzinski +--- + Makefile | 3 +- + Makefile.inc | 1 + + libmpathvalid/Makefile | 38 +++++++ + libmpathvalid/libmpathvalid.version | 10 ++ + libmpathvalid/mpath_valid.c | 168 ++++++++++++++++++++++++++++ + libmpathvalid/mpath_valid.h | 57 ++++++++++ + 6 files changed, 276 insertions(+), 1 deletion(-) + create mode 100644 libmpathvalid/Makefile + create mode 100644 libmpathvalid/libmpathvalid.version + create mode 100644 libmpathvalid/mpath_valid.c + create mode 100644 libmpathvalid/mpath_valid.h + +diff --git a/Makefile b/Makefile +index 8bcaba66..f157a549 100644 +--- a/Makefile ++++ b/Makefile +@@ -9,6 +9,7 @@ BUILDDIRS := \ + libmultipath/checkers \ + libmultipath/foreign \ + libmpathpersist \ ++ libmpathvalid \ + multipath \ + multipathd \ + mpathpersist \ +@@ -29,7 +30,7 @@ $(BUILDDIRS): + $(MAKE) -C $@ + + libmultipath libdmmp: libmpathcmd +-libmpathpersist multipath multipathd: libmultipath ++libmpathpersist libmpathvalid multipath multipathd: libmultipath + mpathpersist multipathd: libmpathpersist + + libmultipath/checkers.install \ +diff --git a/Makefile.inc b/Makefile.inc +index e2f5d0dc..936e5833 100644 +--- a/Makefile.inc ++++ b/Makefile.inc +@@ -66,6 +66,7 @@ libdir = $(prefix)/$(LIB)/multipath + unitdir = $(prefix)/$(SYSTEMDPATH)/systemd/system + mpathpersistdir = $(TOPDIR)/libmpathpersist + mpathcmddir = $(TOPDIR)/libmpathcmd ++mpathvaliddir = $(TOPDIR)/libmpathvalid + thirdpartydir = $(TOPDIR)/third-party + libdmmpdir = $(TOPDIR)/libdmmp + nvmedir = $(TOPDIR)/libmultipath/nvme +diff --git a/libmpathvalid/Makefile b/libmpathvalid/Makefile +new file mode 100644 +index 00000000..70b97eca +--- /dev/null ++++ b/libmpathvalid/Makefile +@@ -0,0 +1,38 @@ ++include ../Makefile.inc ++ ++SONAME = 0 ++DEVLIB = libmpathvalid.so ++LIBS = $(DEVLIB).$(SONAME) ++ ++CFLAGS += $(LIB_CFLAGS) -I$(multipathdir) -I$(mpathcmddir) ++ ++LIBDEPS += -lpthread -ldevmapper -ldl -L$(multipathdir) \ ++ -lmultipath -L$(mpathcmddir) -lmpathcmd -ludev ++ ++OBJS = mpath_valid.o ++ ++all: $(LIBS) ++ ++$(LIBS): $(OBJS) ++ $(CC) $(LDFLAGS) $(SHARED_FLAGS) -Wl,-soname=$@ -o $@ $(OBJS) $(LIBDEPS) -Wl,--version-script=libmpathvalid.version ++ $(LN) $(LIBS) $(DEVLIB) ++ ++install: $(LIBS) ++ $(INSTALL_PROGRAM) -m 755 -d $(DESTDIR)$(syslibdir) ++ $(INSTALL_PROGRAM) -m 755 $(LIBS) $(DESTDIR)$(syslibdir)/$(LIBS) ++ $(LN) $(LIBS) $(DESTDIR)$(syslibdir)/$(DEVLIB) ++ $(INSTALL_PROGRAM) -m 755 -d $(DESTDIR)$(includedir) ++ $(INSTALL_PROGRAM) -m 644 mpath_valid.h $(DESTDIR)$(includedir) ++ ++uninstall: ++ $(RM) $(DESTDIR)$(syslibdir)/$(LIBS) ++ $(RM) $(DESTDIR)$(syslibdir)/$(DEVLIB) ++ $(RM) $(DESTDIR)$(includedir)/mpath_valid.h ++ ++clean: dep_clean ++ $(RM) core *.a *.o *.so *.so.* *.gz ++ ++include $(wildcard $(OBJS:.o=.d)) ++ ++dep_clean: ++ $(RM) $(OBJS:.o=.d) +diff --git a/libmpathvalid/libmpathvalid.version b/libmpathvalid/libmpathvalid.version +new file mode 100644 +index 00000000..4d8a8ba4 +--- /dev/null ++++ b/libmpathvalid/libmpathvalid.version +@@ -0,0 +1,10 @@ ++MPATH_1.0 { ++ global: ++ mpathvalid_conf; ++ mpathvalid_init; ++ mpathvalid_exit; ++ mpathvalid_is_path; ++ mpathvalid_get_mode; ++ local: ++ *; ++}; +diff --git a/libmpathvalid/mpath_valid.c b/libmpathvalid/mpath_valid.c +new file mode 100644 +index 00000000..6153e8b7 +--- /dev/null ++++ b/libmpathvalid/mpath_valid.c +@@ -0,0 +1,168 @@ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "devmapper.h" ++#include "structs.h" ++#include "util.h" ++#include "config.h" ++#include "discovery.h" ++#include "wwids.h" ++#include "sysfs.h" ++#include "mpath_cmd.h" ++#include "valid.h" ++#include "mpath_valid.h" ++ ++static struct config default_config = { .verbosity = -1 }; ++struct config *mpathvalid_conf = &default_config; ++ ++static unsigned int get_conf_mode(struct config *conf) ++{ ++ if (conf->find_multipaths == FIND_MULTIPATHS_SMART) ++ return MPATH_SMART; ++ if (conf->find_multipaths == FIND_MULTIPATHS_GREEDY) ++ return MPATH_GREEDY; ++ return MPATH_STRICT; ++} ++ ++static void set_conf_mode(struct config *conf, unsigned int mode) ++{ ++ if (mode == MPATH_SMART) ++ conf->find_multipaths = FIND_MULTIPATHS_SMART; ++ else if (mode == MPATH_GREEDY) ++ conf->find_multipaths = FIND_MULTIPATHS_GREEDY; ++ else ++ conf->find_multipaths = FIND_MULTIPATHS_STRICT; ++} ++ ++unsigned int mpathvalid_get_mode(void) ++{ ++ int mode; ++ struct config *conf; ++ ++ conf = get_multipath_config(); ++ if (!conf) ++ return -1; ++ mode = get_conf_mode(conf); ++ put_multipath_config(conf); ++ return mode; ++} ++ ++static int convert_result(int result) { ++ switch (result) { ++ case PATH_IS_ERROR: ++ return MPATH_IS_ERROR; ++ case PATH_IS_NOT_VALID: ++ return MPATH_IS_NOT_VALID; ++ case PATH_IS_VALID: ++ return MPATH_IS_VALID; ++ case PATH_IS_VALID_NO_CHECK: ++ return MPATH_IS_VALID_NO_CHECK; ++ case PATH_IS_MAYBE_VALID: ++ return MPATH_IS_MAYBE_VALID; ++ } ++ return MPATH_IS_ERROR; ++} ++ ++int ++mpathvalid_init(int verbosity) ++{ ++ unsigned int version[3]; ++ struct config *conf; ++ ++ default_config.verbosity = verbosity; ++ skip_libmp_dm_init(); ++ conf = load_config(DEFAULT_CONFIGFILE); ++ if (!conf) ++ return -1; ++ conf->verbosity = verbosity; ++ if (dm_prereq(version)) ++ goto fail; ++ memcpy(conf->version, version, sizeof(version)); ++ ++ mpathvalid_conf = conf; ++ return 0; ++fail: ++ free_config(conf); ++ return -1; ++} ++ ++int ++mpathvalid_exit(void) ++{ ++ struct config *conf = mpathvalid_conf; ++ ++ default_config.verbosity = -1; ++ if (mpathvalid_conf == &default_config) ++ return 0; ++ mpathvalid_conf = &default_config; ++ free_config(conf); ++ return 0; ++} ++ ++/* ++ * name: name of path to check ++ * mode: mode to use for determination. MPATH_DEFAULT uses configured mode ++ * info: on success, contains the path wwid ++ * paths: array of the returned mpath_info from other claimed paths ++ * nr_paths: the size of the paths array ++ */ ++int ++mpathvalid_is_path(const char *name, unsigned int mode, char **wwid, ++ const char **path_wwids, unsigned int nr_paths) ++{ ++ struct config *conf; ++ int r = MPATH_IS_ERROR; ++ unsigned int i; ++ struct path *pp; ++ ++ if (!name || mode >= MPATH_MAX_MODE) ++ return r; ++ ++ if (nr_paths > 0 && !path_wwids) ++ return r; ++ ++ pp = alloc_path(); ++ if (!pp) ++ return r; ++ ++ if (wwid) { ++ *wwid = (char *)malloc(WWID_SIZE); ++ if (!*wwid) ++ goto out; ++ } ++ ++ conf = get_multipath_config(); ++ if (!conf || conf == &default_config) ++ goto out_wwid; ++ if (mode != MPATH_DEFAULT) ++ set_conf_mode(conf, mode); ++ r = convert_result(is_path_valid(name, conf, pp, true)); ++ put_multipath_config(conf); ++ ++ if (r == MPATH_IS_MAYBE_VALID) { ++ for (i = 0; i < nr_paths; i++) { ++ if (strncmp(path_wwids[i], pp->wwid, WWID_SIZE) == 0) { ++ r = MPATH_IS_VALID; ++ break; ++ } ++ } ++ } ++ ++out_wwid: ++ if (wwid) { ++ if (r == MPATH_IS_VALID || r == MPATH_IS_VALID_NO_CHECK || ++ r == MPATH_IS_MAYBE_VALID) ++ strlcpy(*wwid, pp->wwid, WWID_SIZE); ++ else { ++ free(*wwid); ++ *wwid = NULL; ++ } ++ } ++out: ++ free_path(pp); ++ return r; ++} +diff --git a/libmpathvalid/mpath_valid.h b/libmpathvalid/mpath_valid.h +new file mode 100644 +index 00000000..7fd8aa47 +--- /dev/null ++++ b/libmpathvalid/mpath_valid.h +@@ -0,0 +1,57 @@ ++/* ++ * Copyright (C) 2015 Red Hat, Inc. ++ * ++ * This file is part of the device-mapper multipath userspace tools. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public License ++ * along with this program. If not, see . ++ */ ++ ++#ifndef LIB_MPATH_VALID_H ++#define LIB_MPATH_VALID_H ++ ++#ifdef __cpluscplus ++extern "C" { ++#endif ++ ++enum mpath_valid_mode { ++ MPATH_DEFAULT, ++ MPATH_STRICT, ++ MPATH_SMART, ++ MPATH_GREEDY, ++ MPATH_MAX_MODE, /* used only for bounds checking */ ++}; ++ ++/* MPATH_IS_VALID_NO_CHECK is used to skip checks to see if the device ++ * has already been unclaimed by multipath in the past */ ++enum mpath_valid_result { ++ MPATH_IS_ERROR = -1, ++ MPATH_IS_NOT_VALID, ++ MPATH_IS_VALID, ++ MPATH_IS_VALID_NO_CHECK, ++ MPATH_IS_MAYBE_VALID, ++}; ++ ++struct config; ++extern struct config *mpathvalid_conf; ++int mpathvalid_init(int verbosity); ++int mpathvalid_exit(void); ++unsigned int mpathvalid_get_mode(void); ++int mpathvalid_is_path(const char *name, unsigned int mode, char **wwid, ++ const char **path_wwids, unsigned int nr_paths); ++ ++ ++#ifdef __cplusplus ++} ++#endif ++#endif /* LIB_PATH_VALID_H */ +-- +2.17.2 + diff --git a/0071-libmultipath-add-uid-failback-for-dasd-devices.patch b/0071-libmultipath-add-uid-failback-for-dasd-devices.patch new file mode 100644 index 0000000..2515095 --- /dev/null +++ b/0071-libmultipath-add-uid-failback-for-dasd-devices.patch @@ -0,0 +1,89 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Tue, 19 May 2020 15:55:15 -0500 +Subject: [PATCH] libmultipath: add uid failback for dasd devices + +Add failback code to get the uid for dasd devices from sysfs. Copied +from dasdinfo + +Signed-off-by: Benjamin Marzinski +--- + libmultipath/defaults.h | 1 + + libmultipath/discovery.c | 37 ++++++++++++++++++++++++++++++++++++- + 2 files changed, 37 insertions(+), 1 deletion(-) + +diff --git a/libmultipath/defaults.h b/libmultipath/defaults.h +index 984d8dd8..6a678a83 100644 +--- a/libmultipath/defaults.h ++++ b/libmultipath/defaults.h +@@ -8,6 +8,7 @@ + */ + #define DEFAULT_UID_ATTRIBUTE "ID_SERIAL" + #define DEFAULT_NVME_UID_ATTRIBUTE "ID_WWN" ++#define DEFAULT_DASD_UID_ATTRIBUTE "ID_UID" + #define DEFAULT_UDEVDIR "/dev" + #define DEFAULT_MULTIPATHDIR "/" LIB_STRING "/multipath" + #define DEFAULT_SELECTOR "service-time 0" +diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c +index aa5942c3..002d3d18 100644 +--- a/libmultipath/discovery.c ++++ b/libmultipath/discovery.c +@@ -1920,12 +1920,44 @@ get_vpd_uid(struct path * pp) + return get_vpd_sysfs(parent, 0x83, pp->wwid, WWID_SIZE); + } + ++/* based on code from s390-tools/dasdinfo/dasdinfo.c */ ++static ssize_t dasd_get_uid(struct path *pp) ++{ ++ struct udev_device *parent; ++ char value[80]; ++ char *p; ++ int i; ++ ++ parent = udev_device_get_parent_with_subsystem_devtype(pp->udev, "ccw", ++ NULL); ++ if (!parent) ++ return -1; ++ ++ if (sysfs_attr_get_value(parent, "uid", value, 80) < 0) ++ return -1; ++ ++ p = value - 1; ++ /* look for the 4th '.' and cut there */ ++ for (i = 0; i < 4; i++) { ++ p = index(p + 1, '.'); ++ if (!p) ++ break; ++ } ++ if (p) ++ *p = '\0'; ++ ++ return strlcpy(pp->wwid, value, WWID_SIZE); ++} ++ + static ssize_t uid_fallback(struct path *pp, int path_state, + const char **origin) + { + ssize_t len = -1; + +- if (pp->bus == SYSFS_BUS_SCSI) { ++ if (pp->bus == SYSFS_BUS_CCW) { ++ len = dasd_get_uid(pp); ++ *origin = "sysfs"; ++ } else if (pp->bus == SYSFS_BUS_SCSI) { + len = get_vpd_uid(pp); + *origin = "sysfs"; + if (len < 0 && path_state == PATH_UP) { +@@ -1970,6 +2002,9 @@ static bool has_uid_fallback(struct path *pp) + !strcmp(pp->uid_attribute, ""))) || + (pp->bus == SYSFS_BUS_NVME && + (!strcmp(pp->uid_attribute, DEFAULT_NVME_UID_ATTRIBUTE) || ++ !strcmp(pp->uid_attribute, ""))) || ++ (pp->bus == SYSFS_BUS_CCW && ++ (!strcmp(pp->uid_attribute, DEFAULT_DASD_UID_ATTRIBUTE) || + !strcmp(pp->uid_attribute, "")))); + } + +-- +2.17.2 + diff --git a/0072-libmultipath-add-ignore_udev_uid-option.patch b/0072-libmultipath-add-ignore_udev_uid-option.patch new file mode 100644 index 0000000..d9cf8a7 --- /dev/null +++ b/0072-libmultipath-add-ignore_udev_uid-option.patch @@ -0,0 +1,192 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Benjamin Marzinski +Date: Wed, 20 May 2020 16:46:55 -0500 +Subject: [PATCH] libmultipath: add ignore_udev_uid option + +Setting this option to yes will force multipath to get the uid by using +the fallback sysfs methods, instead of getting it from udev. This will +cause devices that can't get their uid from the standard locations to +not get a uid. It will also disable uevent merging. + +It will not stop uevents from being resent for device that failed to +get a WWID, although I'm on the fence about the benefit of this. + +Signed-off-by: Benjamin Marzinski +--- + libmultipath/config.h | 1 + + libmultipath/dict.c | 4 ++++ + libmultipath/discovery.c | 17 +++++++++++------ + libmultipath/discovery.h | 8 +++++++- + libmultipath/uevent.c | 2 +- + multipath/multipath.conf.5 | 13 +++++++++++++ + multipathd/main.c | 7 ++++++- + 7 files changed, 43 insertions(+), 9 deletions(-) + +diff --git a/libmultipath/config.h b/libmultipath/config.h +index 160867cd..c7a73fba 100644 +--- a/libmultipath/config.h ++++ b/libmultipath/config.h +@@ -192,6 +192,7 @@ struct config { + int find_multipaths_timeout; + int marginal_pathgroups; + int skip_delegate; ++ int ignore_udev_uid; + unsigned int version[3]; + unsigned int sequence_nr; + +diff --git a/libmultipath/dict.c b/libmultipath/dict.c +index 184d4b22..9a0729bf 100644 +--- a/libmultipath/dict.c ++++ b/libmultipath/dict.c +@@ -1406,6 +1406,9 @@ declare_hw_snprint(all_tg_pt, print_yes_no_undef) + declare_def_handler(marginal_pathgroups, set_yes_no) + declare_def_snprint(marginal_pathgroups, print_yes_no) + ++declare_def_handler(ignore_udev_uid, set_yes_no) ++declare_def_snprint(ignore_udev_uid, print_yes_no) ++ + static int + def_uxsock_timeout_handler(struct config *conf, vector strvec) + { +@@ -1816,6 +1819,7 @@ init_keywords(vector keywords) + install_keyword("enable_foreign", &def_enable_foreign_handler, + &snprint_def_enable_foreign); + install_keyword("marginal_pathgroups", &def_marginal_pathgroups_handler, &snprint_def_marginal_pathgroups); ++ install_keyword("ignore_udev_uid", &def_ignore_udev_uid_handler, &snprint_def_ignore_udev_uid); + __deprecated install_keyword("default_selector", &def_selector_handler, NULL); + __deprecated install_keyword("default_path_grouping_policy", &def_pgpolicy_handler, NULL); + __deprecated install_keyword("default_uid_attribute", &def_uid_attribute_handler, NULL); +diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c +index 002d3d18..f0e92227 100644 +--- a/libmultipath/discovery.c ++++ b/libmultipath/discovery.c +@@ -2010,7 +2010,7 @@ static bool has_uid_fallback(struct path *pp) + + int + get_uid (struct path * pp, int path_state, struct udev_device *udev, +- int allow_fallback) ++ int fallback) + { + char *c; + const char *origin = "unknown"; +@@ -2043,7 +2043,9 @@ get_uid (struct path * pp, int path_state, struct udev_device *udev, + } else + len = strlen(pp->wwid); + origin = "callout"; +- } else { ++ } else if (fallback == UID_FALLBACK_FORCE) ++ len = uid_fallback(pp, path_state, &origin); ++ else { + bool udev_available = udev && pp->uid_attribute + && *pp->uid_attribute; + +@@ -2056,8 +2058,9 @@ get_uid (struct path * pp, int path_state, struct udev_device *udev, + else + origin = "udev"; + } +- if ((!udev_available || (len <= 0 && allow_fallback)) +- && has_uid_fallback(pp)) { ++ if ((!udev_available || ++ (len <= 0 && fallback == UID_FALLBACK_ALLOW)) && ++ has_uid_fallback(pp)) { + used_fallback = 1; + len = uid_fallback(pp, path_state, &origin); + } +@@ -2197,8 +2200,10 @@ int pathinfo(struct path *pp, struct config *conf, int mask) + } + + if ((mask & DI_WWID) && !strlen(pp->wwid)) { +- get_uid(pp, path_state, pp->udev, +- (pp->retriggers >= conf->retrigger_tries)); ++ int fallback = conf->ignore_udev_uid? UID_FALLBACK_FORCE : ++ (pp->retriggers >= conf->retrigger_tries)? ++ UID_FALLBACK_ALLOW : UID_FALLBACK_NONE; ++ get_uid(pp, path_state, pp->udev, fallback); + if (!strlen(pp->wwid)) { + if (pp->bus == SYSFS_BUS_UNDEF) + return PATHINFO_SKIPPED; +diff --git a/libmultipath/discovery.h b/libmultipath/discovery.h +index 6444887d..ca8542d6 100644 +--- a/libmultipath/discovery.h ++++ b/libmultipath/discovery.h +@@ -54,8 +54,14 @@ ssize_t sysfs_get_inquiry(struct udev_device *udev, + unsigned char *buff, size_t len); + int sysfs_get_asymmetric_access_state(struct path *pp, + char *buff, int buflen); ++ ++enum { ++ UID_FALLBACK_NONE, ++ UID_FALLBACK_ALLOW, ++ UID_FALLBACK_FORCE, ++}; + int get_uid(struct path * pp, int path_state, struct udev_device *udev, +- int allow_fallback); ++ int fallback); + + /* + * discovery bitmask +diff --git a/libmultipath/uevent.c b/libmultipath/uevent.c +index e0d13b11..d67129d1 100644 +--- a/libmultipath/uevent.c ++++ b/libmultipath/uevent.c +@@ -179,7 +179,7 @@ uevent_need_merge(void) + bool need_merge = false; + + conf = get_multipath_config(); +- if (VECTOR_SIZE(&conf->uid_attrs) > 0) ++ if (!conf->ignore_udev_uid && VECTOR_SIZE(&conf->uid_attrs) > 0) + need_merge = true; + put_multipath_config(conf); + +diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5 +index 42a192f6..175ca095 100644 +--- a/multipath/multipath.conf.5 ++++ b/multipath/multipath.conf.5 +@@ -286,6 +286,19 @@ The default is: \fB\fR + . + . + .TP ++.B ignore_udev_uid ++Setting this option to yes will force multipath to ignore the the uid_attrs ++and uid_attribute settings, and generate the WWID by the \fIsysfs\fR ++method. This will cause devices that cannot get their WWID from the standard ++locations for their device type to not get a WWID; see \fBWWID generation\fR ++below. ++.RS ++.TP ++The default is: \fBno\fR ++.RE ++. ++. ++.TP + .B prio + The name of the path priority routine. The specified routine + should return a numeric value specifying the relative priority +diff --git a/multipathd/main.c b/multipathd/main.c +index f014d2a1..48b62937 100644 +--- a/multipathd/main.c ++++ b/multipathd/main.c +@@ -1226,6 +1226,7 @@ uev_update_path (struct uevent *uev, struct vectors * vecs) + if (pp) { + struct multipath *mpp = pp->mpp; + char wwid[WWID_SIZE]; ++ int fallback; + + if (pp->initialized == INIT_REQUESTED_UDEV) { + needs_reinit = 1; +@@ -1237,7 +1238,11 @@ uev_update_path (struct uevent *uev, struct vectors * vecs) + goto out; + + strcpy(wwid, pp->wwid); +- rc = get_uid(pp, pp->state, uev->udev, 0); ++ conf = get_multipath_config(); ++ fallback = conf->ignore_udev_uid? UID_FALLBACK_FORCE: ++ UID_FALLBACK_NONE; ++ put_multipath_config(conf); ++ rc = get_uid(pp, pp->state, uev->udev, fallback); + + if (rc != 0) + strcpy(pp->wwid, wwid); +-- +2.17.2 + diff --git a/device-mapper-multipath.spec b/device-mapper-multipath.spec index b492b91..953787c 100644 --- a/device-mapper-multipath.spec +++ b/device-mapper-multipath.spec @@ -1,6 +1,6 @@ Name: device-mapper-multipath Version: 0.8.4 -Release: 3%{?dist} +Release: 4%{?dist} Summary: Tools to manage multipath devices using device-mapper License: GPLv2 URL: http://christophe.varoqui.free.fr/ @@ -57,19 +57,31 @@ Patch0044: 0044-multipathd-add-del-maps-multipathd-command.patch Patch0045: 0045-multipath-make-flushing-maps-work-like-other-command.patch Patch0046: 0046-multipath-delegate-flushing-maps-to-multipathd.patch Patch0047: 0047-multipath-add-option-to-skip-multipathd-delegation.patch -Patch0048: 0048-Makefile.inc-trim-extra-information-from-systemd-ver.patch -Patch0049: 0049-kpartx-fix-Wsign-compare-error.patch -Patch0050: 0050-RH-fixup-udev-rules-for-redhat.patch -Patch0051: 0051-RH-Remove-the-property-blacklist-exception-builtin.patch -Patch0052: 0052-RH-don-t-start-without-a-config-file.patch -Patch0053: 0053-RH-use-rpm-optflags-if-present.patch -Patch0054: 0054-RH-add-mpathconf.patch -Patch0055: 0055-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch -Patch0056: 0056-RH-warn-on-invalid-regex-instead-of-failing.patch -Patch0057: 0057-RH-reset-default-find_mutipaths-value-to-off.patch -Patch0058: 0058-RH-Fix-nvme-compilation-warning.patch -Patch0059: 0059-RH-attempt-to-get-ANA-info-via-sysfs-first.patch -Patch0060: 0060-RH-work-around-gcc-10-format-truncation-issue.patch +Patch0048: 0048-libmultipath-add-device-to-hwtable.c.patch +Patch0049: 0049-master-libmultipath-fix-use-after-free-when-iscsi-lo.patch +Patch0050: 0050-libmultipath-warn-if-freeing-path-that-holds-mpp-hwe.patch +Patch0051: 0051-libmultipath-warn-about-NULL-value-of-mpp-hwe.patch +Patch0052: 0052-libmultipath-fix-mpp-hwe-handling-in-sync_paths.patch +Patch0053: 0053-Makefile.inc-trim-extra-information-from-systemd-ver.patch +Patch0054: 0054-kpartx-fix-Wsign-compare-error.patch +Patch0055: 0055-libmultipath-remove-code-duplication-in-path-countin.patch +Patch0056: 0056-libmultipath-count-pending-paths-as-active-on-loads.patch +Patch0057: 0057-libmultipath-deal-with-flushing-no-maps.patch +Patch0058: 0058-multipath-deal-with-delegation-failures-correctly.patch +Patch0059: 0059-RH-fixup-udev-rules-for-redhat.patch +Patch0060: 0060-RH-Remove-the-property-blacklist-exception-builtin.patch +Patch0061: 0061-RH-don-t-start-without-a-config-file.patch +Patch0062: 0062-RH-use-rpm-optflags-if-present.patch +Patch0063: 0063-RH-add-mpathconf.patch +Patch0064: 0064-RH-add-wwids-from-kernel-cmdline-mpath.wwids-with-A.patch +Patch0065: 0065-RH-warn-on-invalid-regex-instead-of-failing.patch +Patch0066: 0066-RH-reset-default-find_mutipaths-value-to-off.patch +Patch0067: 0067-RH-Fix-nvme-compilation-warning.patch +Patch0068: 0068-RH-attempt-to-get-ANA-info-via-sysfs-first.patch +Patch0069: 0069-RH-work-around-gcc-10-format-truncation-issue.patch +Patch0070: 0070-multipath-add-libmpathvalid-library.patch +Patch0071: 0071-libmultipath-add-uid-failback-for-dasd-devices.patch +Patch0072: 0072-libmultipath-add-ignore_udev_uid-option.patch # runtime Requires: %{name}-libs = %{version}-%{release} @@ -222,6 +234,7 @@ fi %{_libdir}/libmultipath.so.* %{_libdir}/libmpathpersist.so.* %{_libdir}/libmpathcmd.so.* +%{_libdir}/libmpathvalid.so.* %dir %{_libmpathdir} %{_libmpathdir}/* @@ -231,8 +244,10 @@ fi %doc README %{_libdir}/libmpathpersist.so %{_libdir}/libmpathcmd.so +%{_libdir}/libmpathvalid.so %{_includedir}/mpath_cmd.h %{_includedir}/mpath_persist.h +%{_includedir}/mpath_valid.h %{_mandir}/man3/mpath_persistent_reserve_in.3.gz %{_mandir}/man3/mpath_persistent_reserve_out.3.gz @@ -263,6 +278,24 @@ fi %{_pkgconfdir}/libdmmp.pc %changelog +* Tue Jul 21 2020 Benjamin Marzinski - 0.8.4-4 +- Rebased on top of additional commits staged for upstream + * Previous patches 0048-0060 are now patches 0053-0054 & 0059-0069 +- Add 0048-libmultipath-add-device-to-hwtable.c.patch +- Add 0049-master-libmultipath-fix-use-after-free-when-iscsi-lo.patch +- Add 0050-libmultipath-warn-if-freeing-path-that-holds-mpp-hwe.patch +- Add 0051-libmultipath-warn-about-NULL-value-of-mpp-hwe.patch +- Add 0052-libmultipath-fix-mpp-hwe-handling-in-sync_paths.patch +- Add 0055-libmultipath-remove-code-duplication-in-path-countin.patch +- Add 0056-libmultipath-count-pending-paths-as-active-on-loads.patch +- Add 0057-libmultipath-deal-with-flushing-no-maps.patch +- Add 0058-multipath-deal-with-delegation-failures-correctly.patch +- Add 0070-multipath-add-libmpathvalid-library.patch + * adds the libmpathvalid.so library to determine if devices are + valid multipath paths. +- Add 0071-libmultipath-add-uid-failback-for-dasd-devices.patch +- Add 0072-libmultipath-add-ignore_udev_uid-option.patch + * Mon Jul 13 2020 Tom Stellard - 0.8.4-3 - Use make macros - https://fedoraproject.org/wiki/Changes/UseMakeBuildInstallMacro