SOURCES/0094-multipath-return-failure-on-an-invalid-remove-comman.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 30 Mar 2022 15:14:56 -0500
+Subject: [PATCH] multipath: return failure on an invalid remove command
+
+When "multipath -f" is run on a device that doesn't exist or isn't a
+multipath device, the command will not remove any device, but it will
+still return success.  Multiple functions rely on _dm_flush_map()
+returning success when called with name that doesn't match any
+multipath device. So before calling _dm_flush_map(), call dm_is_mpath(),
+to check if the device exists and is a multipath device, and return
+failure if it's not.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com
+---
+ multipath/main.c | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/multipath/main.c b/multipath/main.c
+index 14d045c9..d5e6499c 100644
+--- a/multipath/main.c
++++ b/multipath/main.c
+@@ -1150,6 +1150,11 @@ main (int argc, char *argv[])
+ 	if (retries < 0)
+ 		retries = conf->remove_retries;
+ 	if (cmd == CMD_FLUSH_ONE) {
++		if (dm_is_mpath(dev) != 1) {
++			condlog(0, "%s is not a multipath device", dev);
++			r = RTVL_FAIL;
++			goto out;
++		}
+ 		r = dm_suspend_and_flush_map(dev, retries) ?
+ 		    RTVL_FAIL : RTVL_OK;
+ 		goto out;

SOURCES/0095-libmultipath-steal-the-src-string-pointer-in-merge_s.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 13 Apr 2022 23:27:35 -0500
+Subject: [PATCH] libmultipath: steal the src string pointer in merge_str()
+
+Instead of allocating a copy when the original string is going to be
+freed right after the merge, just steal the pointer. Also, merge_mpe()
+can't get called with NULL arguments.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/config.c | 16 +++++-----------
+ 1 file changed, 5 insertions(+), 11 deletions(-)
+
+diff --git a/libmultipath/config.c b/libmultipath/config.c
+index abbddaf1..aa79561e 100644
+--- a/libmultipath/config.c
++++ b/libmultipath/config.c
+@@ -323,9 +323,9 @@ set_param_str(const char * str)
+ }
+ 
+ #define merge_str(s) \
+-	if (!dst->s && src->s) { \
+-		if (!(dst->s = set_param_str(src->s))) \
+-			return 1; \
++	if (!dst->s && src->s && strlen(src->s)) { \
++		dst->s = src->s; \
++		src->s = NULL; \
+ 	}
+ 
+ #define merge_num(s) \
+@@ -333,7 +333,7 @@ set_param_str(const char * str)
+ 		dst->s = src->s
+ 
+ 
+-static int
++static void
+ merge_hwe (struct hwentry * dst, struct hwentry * src)
+ {
+ 	char id[SCSI_VENDOR_SIZE+PATH_PRODUCT_SIZE];
+@@ -385,15 +385,11 @@ merge_hwe (struct hwentry * dst, struct hwentry * src)
+ 	reconcile_features_with_options(id, &dst->features,
+ 					&dst->no_path_retry,
+ 					&dst->retain_hwhandler);
+-	return 0;
+ }
+ 
+-static int
++static void
+ merge_mpe(struct mpentry *dst, struct mpentry *src)
+ {
+-	if (!dst || !src)
+-		return 1;
+-
+ 	merge_str(alias);
+ 	merge_str(uid_attribute);
+ 	merge_str(getuid);
+@@ -435,8 +431,6 @@ merge_mpe(struct mpentry *dst, struct mpentry *src)
+ 	merge_num(uid);
+ 	merge_num(gid);
+ 	merge_num(mode);
+-
+-	return 0;
+ }
+ 
+ void merge_mptable(vector mptable)

SOURCES/0096-libmultipath-enable-linear-ordering-of-bus-proto-tup.patch

@@ -0,0 +1,75 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martin Wilck <mwilck@suse.com>
+Date: Thu, 17 Feb 2022 17:22:32 +0100
+Subject: [PATCH] libmultipath: enable linear ordering of bus/proto tuple
+
+We categorized protocols by bus/proto_id, while we only differentiate
+protocol IDs for SCSI. Allow transforming this into a linear sequence
+of bus/protocol IDs by having non-SCSI first, and follwing up with
+the different SCSI protocols.
+
+Signed-off-by: Martin Wilck <mwilck@suse.com>
+Reviewed-by: Benjamin Marzinski <bmarzins@redhat.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/structs.c | 10 ++++++++++
+ libmultipath/structs.h | 14 ++++++++++++--
+ 2 files changed, 22 insertions(+), 2 deletions(-)
+
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index dda9884c..aaf85297 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -722,3 +722,13 @@ out:
+ 
+ 	return 0;
+ }
++
++unsigned int bus_protocol_id(const struct path *pp) {
++	if (!pp || pp->bus < 0 || pp->bus > SYSFS_BUS_SCSI)
++		return SYSFS_BUS_UNDEF;
++	if (pp->bus != SYSFS_BUS_SCSI)
++		return pp->bus;
++	if ((int)pp->sg_id.proto_id < 0 || pp->sg_id.proto_id > SCSI_PROTOCOL_UNSPEC)
++		return SYSFS_BUS_UNDEF;
++	return SYSFS_BUS_SCSI + pp->sg_id.proto_id;
++}
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index a5dbad5b..5e29ae38 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -57,12 +57,13 @@ enum failback_mode {
+ 	FAILBACK_FOLLOWOVER
+ };
+ 
++/* SYSFS_BUS_SCSI should be last, see bus_protocol_id() */
+ enum sysfs_buses {
+ 	SYSFS_BUS_UNDEF,
+-	SYSFS_BUS_SCSI,
+ 	SYSFS_BUS_CCW,
+ 	SYSFS_BUS_CCISS,
+ 	SYSFS_BUS_NVME,
++	SYSFS_BUS_SCSI,
+ };
+ 
+ enum pathstates {
+@@ -190,9 +191,18 @@ enum scsi_protocol {
+ 	SCSI_PROTOCOL_SAS = 6,
+ 	SCSI_PROTOCOL_ADT = 7,	/* Media Changers */
+ 	SCSI_PROTOCOL_ATA = 8,
+-	SCSI_PROTOCOL_UNSPEC = 0xf, /* No specific protocol */
++	SCSI_PROTOCOL_USB = 9,  /* USB Attached SCSI (UAS), and others */
++	SCSI_PROTOCOL_UNSPEC = 0xa, /* No specific protocol */
+ };
+ 
++/*
++ * Linear ordering of bus/protocol
++ * This assumes that SYSFS_BUS_SCSI is last in enum sysfs_buses
++ * SCSI is the only bus type for which we distinguish protocols.
++ */
++#define LAST_BUS_PROTOCOL_ID (SYSFS_BUS_SCSI + SCSI_PROTOCOL_UNSPEC)
++unsigned int bus_protocol_id(const struct path *pp);
++
+ enum no_undef_states {
+ 	NU_NO = -1,
+ 	NU_UNDEF = 0,

SOURCES/0097-libmultipath-use-bus_protocol_id-in-snprint_path_pro.patch

@@ -0,0 +1,82 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martin Wilck <mwilck@suse.com>
+Date: Thu, 17 Feb 2022 17:24:25 +0100
+Subject: [PATCH] libmultipath: use bus_protocol_id() in
+ snprint_path_protocol()
+
+Simplify bus_protocol_id() by using the linear ordering.
+
+Signed-off-by: Martin Wilck <mwilck@suse.com>
+Reviewed-by: Benjamin Marzinski <bmarzins@redhat.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/print.c | 56 +++++++++++++++++---------------------------
+ 1 file changed, 21 insertions(+), 35 deletions(-)
+
+diff --git a/libmultipath/print.c b/libmultipath/print.c
+index 298b3764..ff4d1854 100644
+--- a/libmultipath/print.c
++++ b/libmultipath/print.c
+@@ -662,41 +662,27 @@ snprint_path_failures(char * buff, size_t len, const struct path * pp)
+ int
+ snprint_path_protocol(char * buff, size_t len, const struct path * pp)
+ {
+-	switch (pp->bus) {
+-	case SYSFS_BUS_SCSI:
+-		switch (pp->sg_id.proto_id) {
+-		case SCSI_PROTOCOL_FCP:
+-			return snprintf(buff, len, "scsi:fcp");
+-		case SCSI_PROTOCOL_SPI:
+-			return snprintf(buff, len, "scsi:spi");
+-		case SCSI_PROTOCOL_SSA:
+-			return snprintf(buff, len, "scsi:ssa");
+-		case SCSI_PROTOCOL_SBP:
+-			return snprintf(buff, len, "scsi:sbp");
+-		case SCSI_PROTOCOL_SRP:
+-			return snprintf(buff, len, "scsi:srp");
+-		case SCSI_PROTOCOL_ISCSI:
+-			return snprintf(buff, len, "scsi:iscsi");
+-		case SCSI_PROTOCOL_SAS:
+-			return snprintf(buff, len, "scsi:sas");
+-		case SCSI_PROTOCOL_ADT:
+-			return snprintf(buff, len, "scsi:adt");
+-		case SCSI_PROTOCOL_ATA:
+-			return snprintf(buff, len, "scsi:ata");
+-		case SCSI_PROTOCOL_UNSPEC:
+-		default:
+-			return snprintf(buff, len, "scsi:unspec");
+-		}
+-	case SYSFS_BUS_CCW:
+-		return snprintf(buff, len, "ccw");
+-	case SYSFS_BUS_CCISS:
+-		return snprintf(buff, len, "cciss");
+-	case SYSFS_BUS_NVME:
+-		return snprintf(buff, len, "nvme");
+-	case SYSFS_BUS_UNDEF:
+-	default:
+-		return snprintf(buff, len, "undef");
+-	}
++	static const char * const protocol_name[LAST_BUS_PROTOCOL_ID + 1] = {
++		[SYSFS_BUS_UNDEF] = "undef",
++		[SYSFS_BUS_CCW] = "ccw",
++		[SYSFS_BUS_CCISS] = "cciss",
++		[SYSFS_BUS_NVME] = "nvme",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_FCP] = "scsi:fcp",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SPI] = "scsi:spi",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SSA] = "scsi:ssa",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SBP] = "scsi:sbp",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SRP] = "scsi:srp",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ISCSI] = "scsi:iscsi",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SAS] = "scsi:sas",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ADT] = "scsi:adt",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ATA] = "scsi:ata",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_USB] = "scsi:usb",
++		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_UNSPEC] = "scsi:unspec",
++	};
++	const char *pn = protocol_name[bus_protocol_id(pp)];
++
++	assert(pn != NULL);
++	return snprintf(buff, len, "%s", pn);
+ }
+ 
+ int

SOURCES/0098-libmultipath-make-protocol_name-global.patch

@@ -0,0 +1,85 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 13 Apr 2022 23:27:36 -0500
+Subject: [PATCH] libmultipath: make protocol_name global
+
+Future patches will make use of this, so move it out of
+snprint_path_protocol()
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/print.c   | 17 -----------------
+ libmultipath/structs.c | 18 ++++++++++++++++++
+ libmultipath/structs.h |  1 +
+ 3 files changed, 19 insertions(+), 17 deletions(-)
+
+diff --git a/libmultipath/print.c b/libmultipath/print.c
+index ff4d1854..1f6d27bd 100644
+--- a/libmultipath/print.c
++++ b/libmultipath/print.c
+@@ -662,23 +662,6 @@ snprint_path_failures(char * buff, size_t len, const struct path * pp)
+ int
+ snprint_path_protocol(char * buff, size_t len, const struct path * pp)
+ {
+-	static const char * const protocol_name[LAST_BUS_PROTOCOL_ID + 1] = {
+-		[SYSFS_BUS_UNDEF] = "undef",
+-		[SYSFS_BUS_CCW] = "ccw",
+-		[SYSFS_BUS_CCISS] = "cciss",
+-		[SYSFS_BUS_NVME] = "nvme",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_FCP] = "scsi:fcp",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SPI] = "scsi:spi",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SSA] = "scsi:ssa",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SBP] = "scsi:sbp",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SRP] = "scsi:srp",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ISCSI] = "scsi:iscsi",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SAS] = "scsi:sas",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ADT] = "scsi:adt",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ATA] = "scsi:ata",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_USB] = "scsi:usb",
+-		[SYSFS_BUS_SCSI + SCSI_PROTOCOL_UNSPEC] = "scsi:unspec",
+-	};
+ 	const char *pn = protocol_name[bus_protocol_id(pp)];
+ 
+ 	assert(pn != NULL);
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index aaf85297..19099bed 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -20,6 +20,24 @@
+ #include "prioritizers/alua_spc3.h"
+ #include "dm-generic.h"
+ 
++const char * const protocol_name[LAST_BUS_PROTOCOL_ID + 1] = {
++	[SYSFS_BUS_UNDEF] = "undef",
++	[SYSFS_BUS_CCW] = "ccw",
++	[SYSFS_BUS_CCISS] = "cciss",
++	[SYSFS_BUS_NVME] = "nvme",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_FCP] = "scsi:fcp",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SPI] = "scsi:spi",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SSA] = "scsi:ssa",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SBP] = "scsi:sbp",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SRP] = "scsi:srp",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ISCSI] = "scsi:iscsi",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SAS] = "scsi:sas",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ADT] = "scsi:adt",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ATA] = "scsi:ata",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_USB] = "scsi:usb",
++	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_UNSPEC] = "scsi:unspec",
++};
++
+ struct adapter_group *
+ alloc_adaptergroup(void)
+ {
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index 5e29ae38..ab99852f 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -202,6 +202,7 @@ enum scsi_protocol {
+  */
+ #define LAST_BUS_PROTOCOL_ID (SYSFS_BUS_SCSI + SCSI_PROTOCOL_UNSPEC)
+ unsigned int bus_protocol_id(const struct path *pp);
++extern const char * const protocol_name[];
+ 
+ enum no_undef_states {
+ 	NU_NO = -1,

SOURCES/0099-libmultipath-add-a-protocol-subsection-to-multipath..patch

@@ -0,0 +1,419 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 13 Apr 2022 23:27:37 -0500
+Subject: [PATCH] libmultipath: add a protocol subsection to multipath.conf
+
+Some storage arrays can be accessed using multiple protocols at the same
+time.  In these cases, users may want to set path attributes
+differently, depending on the protocol that the path is using. To allow
+this, add a protocol subsection to the overrides section in
+multipath.conf, which allows select path-specific options to be set.
+This commit simply adds the subsection, and handles merging matching
+entries. Future patches will make use of the section.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/config.c | 83 ++++++++++++++++++++++++++++++++++++
+ libmultipath/config.h | 10 +++++
+ libmultipath/dict.c   | 99 +++++++++++++++++++++++++++++++++++++++++++
+ libmultipath/print.c  | 44 +++++++++++++++++++
+ 4 files changed, 236 insertions(+)
+
+diff --git a/libmultipath/config.c b/libmultipath/config.c
+index aa79561e..88975323 100644
+--- a/libmultipath/config.c
++++ b/libmultipath/config.c
+@@ -173,6 +173,18 @@ char *get_mpe_wwid(vector mptable, char *alias)
+ 	return NULL;
+ }
+ 
++static void
++free_pctable (vector pctable)
++{
++	int i;
++	struct pcentry *pce;
++
++	vector_foreach_slot(pctable, pce, i)
++		free(pce);
++
++	vector_free(pctable);
++}
++
+ void
+ free_hwe (struct hwentry * hwe)
+ {
+@@ -218,6 +230,9 @@ free_hwe (struct hwentry * hwe)
+ 	if (hwe->bl_product)
+ 		FREE(hwe->bl_product);
+ 
++	if (hwe->pctable)
++		free_pctable(hwe->pctable);
++
+ 	FREE(hwe);
+ }
+ 
+@@ -299,6 +314,15 @@ alloc_hwe (void)
+ 	return hwe;
+ }
+ 
++struct pcentry *
++alloc_pce (void)
++{
++	struct pcentry *pce = (struct pcentry *)
++				calloc(1, sizeof(struct pcentry));
++	pce->type = -1;
++	return pce;
++}
++
+ static char *
+ set_param_str(const char * str)
+ {
+@@ -332,6 +356,13 @@ set_param_str(const char * str)
+ 	if (!dst->s && src->s) \
+ 		dst->s = src->s
+ 
++static void
++merge_pce(struct pcentry *dst, struct pcentry *src)
++{
++	merge_num(fast_io_fail);
++	merge_num(dev_loss);
++	merge_num(eh_deadline);
++}
+ 
+ static void
+ merge_hwe (struct hwentry * dst, struct hwentry * src)
+@@ -538,6 +569,51 @@ out:
+ 	return 1;
+ }
+ 
++static void
++validate_pctable(struct hwentry *ovr, int idx, const char *table_desc)
++{
++	struct pcentry *pce;
++
++	if (!ovr || !ovr->pctable)
++		return;
++
++	vector_foreach_slot_after(ovr->pctable, pce, idx) {
++		if (pce->type < 0) {
++			condlog(0, "protocol section in %s missing type",
++				table_desc);
++			vector_del_slot(ovr->pctable, idx--);
++			free(pce);
++		}
++	}
++
++	if (VECTOR_SIZE(ovr->pctable) == 0) {
++		vector_free(ovr->pctable);
++		ovr->pctable = NULL;
++	}
++}
++
++static void
++merge_pctable(struct hwentry *ovr)
++{
++	struct pcentry *pce1, *pce2;
++	int i, j;
++
++	if (!ovr || !ovr->pctable)
++		return;
++
++	vector_foreach_slot(ovr->pctable, pce1, i) {
++		j = i + 1;
++		vector_foreach_slot_after(ovr->pctable, pce2, j) {
++			if (pce1->type != pce2->type)
++				continue;
++			merge_pce(pce2,pce1);
++			vector_del_slot(ovr->pctable, i--);
++			free(pce1);
++			break;
++		}
++	}
++}
++
+ static void
+ factorize_hwtable (vector hw, int n, const char *table_desc)
+ {
+@@ -666,6 +742,7 @@ process_config_dir(struct config *conf, char *dir)
+ 	int i, n;
+ 	char path[LINE_MAX];
+ 	int old_hwtable_size;
++	int old_pctable_size = 0;
+ 
+ 	if (dir[0] != '/') {
+ 		condlog(1, "config_dir '%s' must be a fully qualified path",
+@@ -692,11 +769,15 @@ process_config_dir(struct config *conf, char *dir)
+ 			continue;
+ 
+ 		old_hwtable_size = VECTOR_SIZE(conf->hwtable);
++		old_pctable_size = conf->overrides ?
++				   VECTOR_SIZE(conf->overrides->pctable) : 0;
+ 		snprintf(path, LINE_MAX, "%s/%s", dir, namelist[i]->d_name);
+ 		path[LINE_MAX-1] = '\0';
+ 		process_file(conf, path);
+ 		factorize_hwtable(conf->hwtable, old_hwtable_size,
+ 				  namelist[i]->d_name);
++		validate_pctable(conf->overrides, old_pctable_size,
++				 namelist[i]->d_name);
+ 	}
+ 	pthread_cleanup_pop(1);
+ }
+@@ -784,6 +865,7 @@ load_config (char * file)
+ 			goto out;
+ 		}
+ 		factorize_hwtable(conf->hwtable, builtin_hwtable_size, file);
++		validate_pctable(conf->overrides, 0, file);
+ 	} else {
+ 		condlog(0, "/etc/multipath.conf does not exist, blacklisting all devices.");
+ 		condlog(0, "You can run \"/sbin/mpathconf --enable\" to create");
+@@ -898,6 +980,7 @@ load_config (char * file)
+ 			goto out;
+ 	}
+ 
++	merge_pctable(conf->overrides);
+ 	merge_mptable(conf->mptable);
+ 	merge_blacklist(conf->blist_devnode);
+ 	merge_blacklist(conf->blist_property);
+diff --git a/libmultipath/config.h b/libmultipath/config.h
+index e2e3f143..143116b3 100644
+--- a/libmultipath/config.h
++++ b/libmultipath/config.h
+@@ -41,6 +41,13 @@ enum force_reload_types {
+ 	FORCE_RELOAD_WEAK,
+ };
+ 
++struct pcentry {
++	int type;
++	int fast_io_fail;
++	unsigned int dev_loss;
++	int eh_deadline;
++};
++
+ struct hwentry {
+ 	char * vendor;
+ 	char * product;
+@@ -86,6 +93,8 @@ struct hwentry {
+ 	int vpd_vendor_id;
+ 	int recheck_wwid;
+ 	char * bl_product;
++
++	vector pctable;
+ };
+ 
+ struct mpentry {
+@@ -240,6 +249,7 @@ char * get_mpe_wwid (vector mptable, char * alias);
+ 
+ struct hwentry * alloc_hwe (void);
+ struct mpentry * alloc_mpe (void);
++struct pcentry * alloc_pce (void);
+ 
+ void free_hwe (struct hwentry * hwe);
+ void free_hwtable (vector hwtable);
+diff --git a/libmultipath/dict.c b/libmultipath/dict.c
+index 5a0255b0..8321ec1e 100644
+--- a/libmultipath/dict.c
++++ b/libmultipath/dict.c
+@@ -457,6 +457,29 @@ snprint_mp_ ## option (struct config *conf, char * buff, int len,	\
+ 	return function (buff, len, mpe->option);			\
+ }
+ 
++#define declare_pc_handler(option, function)				\
++static int								\
++pc_ ## option ## _handler (struct config *conf, vector strvec,		\
++			   const char *file, int line_nr)		\
++{									\
++	struct pcentry *pce;						\
++	if (!conf->overrides || !conf->overrides->pctable)		\
++		return 1;						\
++	pce = VECTOR_LAST_SLOT(conf->overrides->pctable);		\
++	if (!pce)							\
++		return 1;						\
++	return function (strvec, &pce->option, file, line_nr);		\
++}
++
++#define declare_pc_snprint(option, function)				\
++static int								\
++snprint_pc_ ## option (struct config *conf, char * buff, int len,	\
++		       const void *data)				\
++{									\
++	const struct pcentry *pce  = (const struct pcentry *)data;	\
++	return function(buff, len, pce->option);			\
++}
++
+ static int checkint_handler(struct config *conf, vector strvec,
+ 			    const char *file, int line_nr)
+ {
+@@ -1022,6 +1045,8 @@ declare_ovr_handler(fast_io_fail, set_undef_off_zero)
+ declare_ovr_snprint(fast_io_fail, print_undef_off_zero)
+ declare_hw_handler(fast_io_fail, set_undef_off_zero)
+ declare_hw_snprint(fast_io_fail, print_undef_off_zero)
++declare_pc_handler(fast_io_fail, set_undef_off_zero)
++declare_pc_snprint(fast_io_fail, print_undef_off_zero)
+ 
+ static int
+ set_dev_loss(vector strvec, void *ptr, const char *file, int line_nr)
+@@ -1059,6 +1084,8 @@ declare_ovr_handler(dev_loss, set_dev_loss)
+ declare_ovr_snprint(dev_loss, print_dev_loss)
+ declare_hw_handler(dev_loss, set_dev_loss)
+ declare_hw_snprint(dev_loss, print_dev_loss)
++declare_pc_handler(dev_loss, set_dev_loss)
++declare_pc_snprint(dev_loss, print_dev_loss)
+ 
+ declare_def_handler(eh_deadline, set_undef_off_zero)
+ declare_def_snprint(eh_deadline, print_undef_off_zero)
+@@ -1066,6 +1093,8 @@ declare_ovr_handler(eh_deadline, set_undef_off_zero)
+ declare_ovr_snprint(eh_deadline, print_undef_off_zero)
+ declare_hw_handler(eh_deadline, set_undef_off_zero)
+ declare_hw_snprint(eh_deadline, print_undef_off_zero)
++declare_pc_handler(eh_deadline, set_undef_off_zero)
++declare_pc_snprint(eh_deadline, print_undef_off_zero)
+ 
+ static int
+ set_pgpolicy(vector strvec, void *ptr, const char *file, int line_nr)
+@@ -1876,6 +1905,69 @@ declare_mp_snprint(wwid, print_str)
+ declare_mp_handler(alias, set_str_noslash)
+ declare_mp_snprint(alias, print_str)
+ 
++
++static int
++protocol_handler(struct config *conf, vector strvec, const char *file,
++               int line_nr)
++{
++	struct pcentry *pce;
++
++	if (!conf->overrides)
++		return 1;
++
++	if (!conf->overrides->pctable &&
++	    !(conf->overrides->pctable = vector_alloc()))
++		return 1;
++
++	if (!(pce = alloc_pce()))
++		return 1;
++
++	if (!vector_alloc_slot(conf->overrides->pctable)) {
++		free(pce);
++		return 1;
++	}
++	vector_set_slot(conf->overrides->pctable, pce);
++
++	return 0;
++}
++
++static int
++set_protocol_type(vector strvec, void *ptr, const char *file, int line_nr)
++{
++	int *int_ptr = (int *)ptr;
++	char *buff;
++	int i;
++
++	buff = set_value(strvec);
++
++	if (!buff)
++		return 1;
++
++	for (i = 0; i <= LAST_BUS_PROTOCOL_ID; i++) {
++		if (protocol_name[i] && !strcmp(buff, protocol_name[i])) {
++			*int_ptr = i;
++			break;
++		}
++	}
++	if (i > LAST_BUS_PROTOCOL_ID)
++		condlog(1, "%s line %d, invalid value for type: \"%s\"",
++			file, line_nr, buff);
++
++	free(buff);
++	return 0;
++}
++
++static int
++print_protocol_type(char *buff, int len, int type)
++{
++	if (type < 0)
++		return 0;
++	return snprintf(buff, len, "\"%s\"", protocol_name[type]);
++}
++
++declare_pc_handler(type, set_protocol_type)
++declare_pc_snprint(type, print_protocol_type)
++
+ /*
+  * deprecated handlers
+  */
+@@ -2117,6 +2209,13 @@ init_keywords(vector keywords)
+ 	install_keyword("ghost_delay", &ovr_ghost_delay_handler, &snprint_ovr_ghost_delay);
+ 	install_keyword("all_tg_pt", &ovr_all_tg_pt_handler, &snprint_ovr_all_tg_pt);
+ 	install_keyword("recheck_wwid", &ovr_recheck_wwid_handler, &snprint_ovr_recheck_wwid);
++	install_keyword_multi("protocol", &protocol_handler, NULL);
++	install_sublevel();
++	install_keyword("type", &pc_type_handler, &snprint_pc_type);
++	install_keyword("fast_io_fail_tmo", &pc_fast_io_fail_handler, &snprint_pc_fast_io_fail);
++	install_keyword("dev_loss_tmo", &pc_dev_loss_handler, &snprint_pc_dev_loss);
++	install_keyword("eh_deadline", &pc_eh_deadline_handler, &snprint_pc_eh_deadline);
++	install_sublevel_end();
+ 
+ 	install_keyword_root("multipaths", &multipaths_handler);
+ 	install_keyword_multi("multipath", &multipath_handler, NULL);
+diff --git a/libmultipath/print.c b/libmultipath/print.c
+index 1f6d27bd..8a6fbe83 100644
+--- a/libmultipath/print.c
++++ b/libmultipath/print.c
+@@ -1392,6 +1392,39 @@ snprint_multipath_topology_json (char * buff, int len, const struct vectors * ve
+ 	return fwd;
+ }
+ 
++static int
++snprint_pcentry (const struct config *conf, char *buff, int len,
++		 const struct pcentry *pce)
++{
++	int i;
++	int fwd = 0;
++	struct keyword *kw;
++	struct keyword *rootkw;
++
++	rootkw = find_keyword(conf->keywords, NULL, "overrides");
++	if (!rootkw || !rootkw->sub)
++		return 0;
++
++	rootkw = find_keyword(conf->keywords, rootkw->sub, "protocol");
++	if (!rootkw)
++		return 0;
++
++	fwd += snprintf(buff + fwd, len - fwd, "\tprotocol {\n");
++	if (fwd >= len)
++		return len;
++
++	iterate_sub_keywords(rootkw, kw, i) {
++		fwd += snprint_keyword(buff + fwd, len - fwd, "\t\t%k %v\n",
++				kw, pce);
++		if (fwd >= len)
++			return len;
++	}
++	fwd += snprintf(buff + fwd, len - fwd, "\t}\n");
++	if (fwd >= len)
++		return len;
++	return fwd;
++}
++
+ static int
+ snprint_hwentry (const struct config *conf,
+ 		 char * buff, int len, const struct hwentry * hwe)
+@@ -1575,6 +1608,17 @@ static int snprint_overrides(const struct config *conf, char * buff, int len,
+ 		if (fwd >= len)
+ 			return len;
+ 	}
++
++	if (overrides->pctable) {
++		struct pcentry *pce;
++
++		vector_foreach_slot(overrides->pctable, pce, i) {
++			fwd += snprint_pcentry(conf, buff + fwd, len - fwd,
++					       pce);
++			if (fwd >= len)
++				return len;
++		}
++	}
+ out:
+ 	fwd += snprintf(buff + fwd, len - fwd, "}\n");
+ 	if (fwd >= len)

SOURCES/0100-libmultipath-Set-the-scsi-timeout-parameters-by-path.patch

@@ -0,0 +1,472 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 13 Apr 2022 23:27:38 -0500
+Subject: [PATCH] libmultipath: Set the scsi timeout parameters by path
+
+Instead of dev_loss, fast_io_fail, and eh_deadline belonging to the
+multipath structure, have them belong to the path structure. This means
+that they are selected per path, and that sysfs_set_scsi_tmo() doesn't
+assume that all paths of a multipath device will have the same value.
+Currently they will all be the same, but a future patch will make it
+possible for paths to have different values based on their protocol.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/configure.c |   5 +-
+ libmultipath/discovery.c | 149 +++++++++++++++++++++++----------------
+ libmultipath/discovery.h |   2 +-
+ libmultipath/propsel.c   |  42 +++++------
+ libmultipath/propsel.h   |   6 +-
+ libmultipath/structs.c   |   1 -
+ libmultipath/structs.h   |   6 +-
+ 7 files changed, 118 insertions(+), 93 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index 9a9890f5..6cad0468 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -338,9 +338,6 @@ int setup_map(struct multipath *mpp, char *params, int params_size,
+ 	select_mode(conf, mpp);
+ 	select_uid(conf, mpp);
+ 	select_gid(conf, mpp);
+-	select_fast_io_fail(conf, mpp);
+-	select_dev_loss(conf, mpp);
+-	select_eh_deadline(conf, mpp);
+ 	select_reservation_key(conf, mpp);
+ 	select_deferred_remove(conf, mpp);
+ 	select_marginal_path_err_sample_time(conf, mpp);
+@@ -356,7 +353,7 @@ int setup_map(struct multipath *mpp, char *params, int params_size,
+ 	select_ghost_delay(conf, mpp);
+ 	select_flush_on_last_del(conf, mpp);
+ 
+-	sysfs_set_scsi_tmo(mpp, conf->checkint);
++	sysfs_set_scsi_tmo(conf, mpp);
+ 	marginal_pathgroups = conf->marginal_pathgroups;
+ 	pthread_cleanup_pop(1);
+ 
+diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c
+index 2404cb87..36cc389e 100644
+--- a/libmultipath/discovery.c
++++ b/libmultipath/discovery.c
+@@ -581,13 +581,13 @@ sysfs_get_asymmetric_access_state(struct path *pp, char *buff, int buflen)
+ }
+ 
+ static int
+-sysfs_set_eh_deadline(struct multipath *mpp, struct path *pp)
++sysfs_set_eh_deadline(struct path *pp)
+ {
+ 	struct udev_device *hostdev;
+ 	char host_name[HOST_NAME_LEN], value[16];
+ 	int ret;
+ 
+-	if (mpp->eh_deadline == EH_DEADLINE_UNSET)
++	if (pp->eh_deadline == EH_DEADLINE_UNSET)
+ 		return 0;
+ 
+ 	sprintf(host_name, "host%d", pp->sg_id.host_no);
+@@ -596,12 +596,12 @@ sysfs_set_eh_deadline(struct multipath *mpp, struct path *pp)
+ 	if (!hostdev)
+ 		return 1;
+ 
+-	if (mpp->eh_deadline == EH_DEADLINE_OFF)
++	if (pp->eh_deadline == EH_DEADLINE_OFF)
+ 		sprintf(value, "off");
+-	else if (mpp->eh_deadline == EH_DEADLINE_ZERO)
++	else if (pp->eh_deadline == EH_DEADLINE_ZERO)
+ 		sprintf(value, "0");
+ 	else
+-		snprintf(value, 16, "%u", mpp->eh_deadline);
++		snprintf(value, 16, "%u", pp->eh_deadline);
+ 
+ 	ret = sysfs_attr_set_value(hostdev, "eh_deadline",
+ 				   value, strlen(value));
+@@ -625,6 +625,9 @@ sysfs_set_rport_tmo(struct multipath *mpp, struct path *pp)
+ 	unsigned int tmo;
+ 	int ret;
+ 
++	if (!pp->dev_loss && pp->fast_io_fail == MP_FAST_IO_FAIL_UNSET)
++		return;
++
+ 	sprintf(rport_id, "rport-%d:%d-%d",
+ 		pp->sg_id.host_no, pp->sg_id.channel, pp->sg_id.transport_id);
+ 	rport_dev = udev_device_new_from_subsystem_sysname(udev,
+@@ -664,14 +667,14 @@ sysfs_set_rport_tmo(struct multipath *mpp, struct path *pp)
+ 	 * then set fast_io_fail, and _then_ set dev_loss_tmo
+ 	 * to the correct value.
+ 	 */
+-	if (mpp->fast_io_fail != MP_FAST_IO_FAIL_UNSET &&
+-	    mpp->fast_io_fail != MP_FAST_IO_FAIL_ZERO &&
+-	    mpp->fast_io_fail != MP_FAST_IO_FAIL_OFF) {
++	if (pp->fast_io_fail != MP_FAST_IO_FAIL_UNSET &&
++	    pp->fast_io_fail != MP_FAST_IO_FAIL_ZERO &&
++	    pp->fast_io_fail != MP_FAST_IO_FAIL_OFF) {
+ 		/* Check if we need to temporarily increase dev_loss_tmo */
+-		if ((unsigned int)mpp->fast_io_fail >= tmo) {
++		if ((unsigned int)pp->fast_io_fail >= tmo) {
+ 			/* Increase dev_loss_tmo temporarily */
+ 			snprintf(value, sizeof(value), "%u",
+-				 (unsigned int)mpp->fast_io_fail + 1);
++				 (unsigned int)pp->fast_io_fail + 1);
+ 			ret = sysfs_attr_set_value(rport_dev, "dev_loss_tmo",
+ 						   value, strlen(value));
+ 			if (ret <= 0) {
+@@ -685,20 +688,20 @@ sysfs_set_rport_tmo(struct multipath *mpp, struct path *pp)
+ 				goto out;
+ 			}
+ 		}
+-	} else if (mpp->dev_loss > DEFAULT_DEV_LOSS_TMO &&
+-		mpp->no_path_retry != NO_PATH_RETRY_QUEUE) {
++	} else if (pp->dev_loss > DEFAULT_DEV_LOSS_TMO &&
++		   mpp->no_path_retry != NO_PATH_RETRY_QUEUE) {
+ 		condlog(3, "%s: limiting dev_loss_tmo to %d, since "
+ 			"fast_io_fail is not set",
+ 			rport_id, DEFAULT_DEV_LOSS_TMO);
+-		mpp->dev_loss = DEFAULT_DEV_LOSS_TMO;
++		pp->dev_loss = DEFAULT_DEV_LOSS_TMO;
+ 	}
+-	if (mpp->fast_io_fail != MP_FAST_IO_FAIL_UNSET) {
+-		if (mpp->fast_io_fail == MP_FAST_IO_FAIL_OFF)
++	if (pp->fast_io_fail != MP_FAST_IO_FAIL_UNSET) {
++		if (pp->fast_io_fail == MP_FAST_IO_FAIL_OFF)
+ 			sprintf(value, "off");
+-		else if (mpp->fast_io_fail == MP_FAST_IO_FAIL_ZERO)
++		else if (pp->fast_io_fail == MP_FAST_IO_FAIL_ZERO)
+ 			sprintf(value, "0");
+ 		else
+-			snprintf(value, 16, "%u", mpp->fast_io_fail);
++			snprintf(value, 16, "%u", pp->fast_io_fail);
+ 		ret = sysfs_attr_set_value(rport_dev, "fast_io_fail_tmo",
+ 					   value, strlen(value));
+ 		if (ret <= 0) {
+@@ -709,8 +712,8 @@ sysfs_set_rport_tmo(struct multipath *mpp, struct path *pp)
+ 					rport_id, value, -ret);
+ 		}
+ 	}
+-	if (mpp->dev_loss > 0) {
+-		snprintf(value, 16, "%u", mpp->dev_loss);
++	if (pp->dev_loss > 0) {
++		snprintf(value, 16, "%u", pp->dev_loss);
+ 		ret = sysfs_attr_set_value(rport_dev, "dev_loss_tmo",
+ 					   value, strlen(value));
+ 		if (ret <= 0) {
+@@ -726,7 +729,7 @@ out:
+ }
+ 
+ static void
+-sysfs_set_session_tmo(struct multipath *mpp, struct path *pp)
++sysfs_set_session_tmo(struct path *pp)
+ {
+ 	struct udev_device *session_dev = NULL;
+ 	char session_id[64];
+@@ -743,18 +746,18 @@ sysfs_set_session_tmo(struct multipath *mpp, struct path *pp)
+ 	condlog(4, "target%d:%d:%d -> %s", pp->sg_id.host_no,
+ 		pp->sg_id.channel, pp->sg_id.scsi_id, session_id);
+ 
+-	if (mpp->dev_loss) {
++	if (pp->dev_loss) {
+ 		condlog(3, "%s: ignoring dev_loss_tmo on iSCSI", pp->dev);
+ 	}
+-	if (mpp->fast_io_fail != MP_FAST_IO_FAIL_UNSET) {
+-		if (mpp->fast_io_fail == MP_FAST_IO_FAIL_OFF) {
++	if (pp->fast_io_fail != MP_FAST_IO_FAIL_UNSET) {
++		if (pp->fast_io_fail == MP_FAST_IO_FAIL_OFF) {
+ 			condlog(3, "%s: can't switch off fast_io_fail_tmo "
+ 				"on iSCSI", pp->dev);
+-		} else if (mpp->fast_io_fail == MP_FAST_IO_FAIL_ZERO) {
++		} else if (pp->fast_io_fail == MP_FAST_IO_FAIL_ZERO) {
+ 			condlog(3, "%s: can't set fast_io_fail_tmo to '0'"
+ 				"on iSCSI", pp->dev);
+ 		} else {
+-			snprintf(value, 11, "%u", mpp->fast_io_fail);
++			snprintf(value, 11, "%u", pp->fast_io_fail);
+ 			if (sysfs_attr_set_value(session_dev, "recovery_tmo",
+ 						 value, strlen(value)) <= 0) {
+ 				condlog(3, "%s: Failed to set recovery_tmo, "
+@@ -767,12 +770,15 @@ sysfs_set_session_tmo(struct multipath *mpp, struct path *pp)
+ }
+ 
+ static void
+-sysfs_set_nexus_loss_tmo(struct multipath *mpp, struct path *pp)
++sysfs_set_nexus_loss_tmo(struct path *pp)
+ {
+ 	struct udev_device *sas_dev = NULL;
+ 	char end_dev_id[64];
+ 	char value[11];
+ 
++	if (!pp->udev || !pp->dev_loss)
++		return;
++
+ 	sprintf(end_dev_id, "end_device-%d:%d",
+ 		pp->sg_id.host_no, pp->sg_id.transport_id);
+ 	sas_dev = udev_device_new_from_subsystem_sysname(udev,
+@@ -785,8 +791,8 @@ sysfs_set_nexus_loss_tmo(struct multipath *mpp, struct path *pp)
+ 	condlog(4, "target%d:%d:%d -> %s", pp->sg_id.host_no,
+ 		pp->sg_id.channel, pp->sg_id.scsi_id, end_dev_id);
+ 
+-	if (mpp->dev_loss) {
+-		snprintf(value, 11, "%u", mpp->dev_loss);
++	if (pp->dev_loss) {
++		snprintf(value, 11, "%u", pp->dev_loss);
+ 		if (sysfs_attr_set_value(sas_dev, "I_T_nexus_loss_timeout",
+ 					 value, strlen(value)) <= 0)
+ 			condlog(3, "%s: failed to update "
+@@ -798,53 +804,76 @@ sysfs_set_nexus_loss_tmo(struct multipath *mpp, struct path *pp)
+ }
+ 
+ int
+-sysfs_set_scsi_tmo (struct multipath *mpp, unsigned int checkint)
++sysfs_set_scsi_tmo (struct config *conf, struct multipath *mpp)
+ {
+ 	struct path *pp;
+ 	int i;
+-	unsigned int dev_loss_tmo = mpp->dev_loss;
++	unsigned int min_dev_loss = 0;
++	bool warn_dev_loss = false;
++	bool warn_fast_io_fail = false;
+ 
+ 	if (mpp->no_path_retry > 0) {
+ 		uint64_t no_path_retry_tmo =
+-			(uint64_t)mpp->no_path_retry * checkint;
++			(uint64_t)mpp->no_path_retry * conf->checkint;
+ 
+ 		if (no_path_retry_tmo > MAX_DEV_LOSS_TMO)
+-			no_path_retry_tmo = MAX_DEV_LOSS_TMO;
+-		if (no_path_retry_tmo > dev_loss_tmo)
+-			dev_loss_tmo = no_path_retry_tmo;
+-		condlog(3, "%s: update dev_loss_tmo to %u",
+-			mpp->alias, dev_loss_tmo);
+-	} else if (mpp->no_path_retry == NO_PATH_RETRY_QUEUE) {
+-		dev_loss_tmo = MAX_DEV_LOSS_TMO;
+-		condlog(3, "%s: update dev_loss_tmo to %u",
+-			mpp->alias, dev_loss_tmo);
+-	}
+-	mpp->dev_loss = dev_loss_tmo;
+-	if (mpp->dev_loss && mpp->fast_io_fail > 0 &&
+-	    (unsigned int)mpp->fast_io_fail >= mpp->dev_loss) {
+-		condlog(3, "%s: turning off fast_io_fail (%d is not smaller than dev_loss_tmo)",
+-			mpp->alias, mpp->fast_io_fail);
+-		mpp->fast_io_fail = MP_FAST_IO_FAIL_OFF;
+-	}
+-	if (!mpp->dev_loss && mpp->fast_io_fail == MP_FAST_IO_FAIL_UNSET &&
+-	    mpp->eh_deadline == EH_DEADLINE_UNSET)
+-		return 0;
++			min_dev_loss = MAX_DEV_LOSS_TMO;
++		else
++			min_dev_loss = no_path_retry_tmo;
++	} else if (mpp->no_path_retry == NO_PATH_RETRY_QUEUE)
++		min_dev_loss = MAX_DEV_LOSS_TMO;
+ 
+ 	vector_foreach_slot(mpp->paths, pp, i) {
++		select_fast_io_fail(conf, pp);
++		select_dev_loss(conf, pp);
++		select_eh_deadline(conf, pp);
++
++		if (!pp->dev_loss && pp->eh_deadline == EH_DEADLINE_UNSET &&
++		    pp->fast_io_fail == MP_FAST_IO_FAIL_UNSET)
++			continue;
++
+ 		if (pp->bus != SYSFS_BUS_SCSI)
+ 			continue;
++		sysfs_set_eh_deadline(pp);
++
++		if (!pp->dev_loss && pp->fast_io_fail == MP_FAST_IO_FAIL_UNSET)
++			continue;
++
++		if (pp->sg_id.proto_id != SCSI_PROTOCOL_FCP &&
++		    pp->sg_id.proto_id != SCSI_PROTOCOL_ISCSI &&
++		    pp->sg_id.proto_id != SCSI_PROTOCOL_SAS)
++			continue;
++
++		if (pp->dev_loss > 0 && pp->dev_loss < min_dev_loss) {
++			warn_dev_loss = true;
++			pp->dev_loss = min_dev_loss;
++		}
++		if (pp->dev_loss > 0 && pp->fast_io_fail > 0 &&
++		    (unsigned int)pp->fast_io_fail >= pp->dev_loss) {
++			warn_fast_io_fail = true;
++			pp->fast_io_fail = MP_FAST_IO_FAIL_OFF;
++		}
+ 
+-		if (mpp->dev_loss ||
+-		    mpp->fast_io_fail != MP_FAST_IO_FAIL_UNSET) {
+-			if (pp->sg_id.proto_id == SCSI_PROTOCOL_FCP)
+-				sysfs_set_rport_tmo(mpp, pp);
+-			else if (pp->sg_id.proto_id == SCSI_PROTOCOL_ISCSI)
+-				sysfs_set_session_tmo(mpp, pp);
+-			else if (pp->sg_id.proto_id == SCSI_PROTOCOL_SAS)
+-				sysfs_set_nexus_loss_tmo(mpp, pp);
++		switch (pp->sg_id.proto_id) {
++		case SCSI_PROTOCOL_FCP:
++			sysfs_set_rport_tmo(mpp, pp);
++			break;
++		case SCSI_PROTOCOL_ISCSI:
++			sysfs_set_session_tmo(pp);
++			break;
++		case SCSI_PROTOCOL_SAS:
++			sysfs_set_nexus_loss_tmo(pp);
++			break;
++		default:
++			break;
+ 		}
+-		sysfs_set_eh_deadline(mpp, pp);
+ 	}
++	if (warn_dev_loss)
++		condlog(2, "%s: Raising dev_loss_tmo to %u because of no_path_retry setting",
++			mpp->alias, min_dev_loss);
++	if (warn_fast_io_fail)
++		condlog(3, "%s: turning off fast_io_fail (not smaller than dev_loss_tmo)",
++			mpp->alias);
+ 	return 0;
+ }
+ 
+diff --git a/libmultipath/discovery.h b/libmultipath/discovery.h
+index a5446b4d..b6eea258 100644
+--- a/libmultipath/discovery.h
++++ b/libmultipath/discovery.h
+@@ -42,7 +42,7 @@ int alloc_path_with_pathinfo (struct config *conf, struct udev_device *udevice,
+ int store_pathinfo (vector pathvec, struct config *conf,
+ 		    struct udev_device *udevice, int flag,
+ 		    struct path **pp_ptr);
+-int sysfs_set_scsi_tmo (struct multipath *mpp, unsigned int checkint);
++int sysfs_set_scsi_tmo (struct config *conf, struct multipath *mpp);
+ int sysfs_get_timeout(const struct path *pp, unsigned int *timeout);
+ int sysfs_get_host_pci_name(const struct path *pp, char *pci_name);
+ int sysfs_get_iscsi_ip_address(const struct path *pp, char *ip_address);
+diff --git a/libmultipath/propsel.c b/libmultipath/propsel.c
+index 127b3370..25326eb6 100644
+--- a/libmultipath/propsel.c
++++ b/libmultipath/propsel.c
+@@ -766,51 +766,51 @@ int select_minio(struct config *conf, struct multipath *mp)
+ 		return select_minio_bio(conf, mp);
+ }
+ 
+-int select_fast_io_fail(struct config *conf, struct multipath *mp)
++int select_fast_io_fail(struct config *conf, struct path *pp)
+ {
+ 	const char *origin;
+ 	char buff[12];
+ 
+-	mp_set_ovr(fast_io_fail);
+-	mp_set_hwe(fast_io_fail);
+-	mp_set_conf(fast_io_fail);
+-	mp_set_default(fast_io_fail, DEFAULT_FAST_IO_FAIL);
++	pp_set_ovr(fast_io_fail);
++	pp_set_hwe(fast_io_fail);
++	pp_set_conf(fast_io_fail);
++	pp_set_default(fast_io_fail, DEFAULT_FAST_IO_FAIL);
+ out:
+-	print_undef_off_zero(buff, 12, mp->fast_io_fail);
+-	condlog(3, "%s: fast_io_fail_tmo = %s %s", mp->alias, buff, origin);
++	print_undef_off_zero(buff, 12, pp->fast_io_fail);
++	condlog(3, "%s: fast_io_fail_tmo = %s %s", pp->dev, buff, origin);
+ 	return 0;
+ }
+ 
+-int select_dev_loss(struct config *conf, struct multipath *mp)
++int select_dev_loss(struct config *conf, struct path *pp)
+ {
+ 	const char *origin;
+ 	char buff[12];
+ 
+-	mp_set_ovr(dev_loss);
+-	mp_set_hwe(dev_loss);
+-	mp_set_conf(dev_loss);
+-	mp->dev_loss = 0;
++	pp_set_ovr(dev_loss);
++	pp_set_hwe(dev_loss);
++	pp_set_conf(dev_loss);
++	pp->dev_loss = 0;
+ 	return 0;
+ out:
+-	print_dev_loss(buff, 12, mp->dev_loss);
+-	condlog(3, "%s: dev_loss_tmo = %s %s", mp->alias, buff, origin);
++	print_dev_loss(buff, 12, pp->dev_loss);
++	condlog(3, "%s: dev_loss_tmo = %s %s", pp->dev, buff, origin);
+ 	return 0;
+ }
+ 
+-int select_eh_deadline(struct config *conf, struct multipath *mp)
++int select_eh_deadline(struct config *conf, struct path *pp)
+ {
+ 	const char *origin;
+ 	char buff[12];
+ 
+-	mp_set_ovr(eh_deadline);
+-	mp_set_hwe(eh_deadline);
+-	mp_set_conf(eh_deadline);
+-	mp->eh_deadline = EH_DEADLINE_UNSET;
++	pp_set_ovr(eh_deadline);
++	pp_set_hwe(eh_deadline);
++	pp_set_conf(eh_deadline);
++	pp->eh_deadline = EH_DEADLINE_UNSET;
+ 	/* not changing sysfs in default cause, so don't print anything */
+ 	return 0;
+ out:
+-	print_undef_off_zero(buff, 12, mp->eh_deadline);
+-	condlog(3, "%s: eh_deadline = %s %s", mp->alias, buff, origin);
++	print_undef_off_zero(buff, 12, pp->eh_deadline);
++	condlog(3, "%s: eh_deadline = %s %s", pp->dev, buff, origin);
+ 	return 0;
+ }
+ 
+diff --git a/libmultipath/propsel.h b/libmultipath/propsel.h
+index 72a7e33c..152ca44c 100644
+--- a/libmultipath/propsel.h
++++ b/libmultipath/propsel.h
+@@ -16,9 +16,9 @@ int select_minio(struct config *conf, struct multipath *mp);
+ int select_mode(struct config *conf, struct multipath *mp);
+ int select_uid(struct config *conf, struct multipath *mp);
+ int select_gid(struct config *conf, struct multipath *mp);
+-int select_fast_io_fail(struct config *conf, struct multipath *mp);
+-int select_dev_loss(struct config *conf, struct multipath *mp);
+-int select_eh_deadline(struct config *conf, struct multipath *mp);
++int select_fast_io_fail(struct config *conf, struct path *pp);
++int select_dev_loss(struct config *conf, struct path *pp);
++int select_eh_deadline(struct config *conf, struct path *pp);
+ int select_reservation_key(struct config *conf, struct multipath *mp);
+ int select_retain_hwhandler (struct config *conf, struct multipath * mp);
+ int select_detect_prio(struct config *conf, struct path * pp);
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index 19099bed..9f86eb69 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -230,7 +230,6 @@ alloc_multipath (void)
+ 		mpp->bestpg = 1;
+ 		mpp->mpcontext = NULL;
+ 		mpp->no_path_retry = NO_PATH_RETRY_UNDEF;
+-		mpp->fast_io_fail = MP_FAST_IO_FAIL_UNSET;
+ 		dm_multipath_to_gen(mpp)->ops = &dm_gen_multipath_ops;
+ 	}
+ 	return mpp;
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index ab99852f..875e726e 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -344,6 +344,9 @@ struct path {
+ 	int marginal;
+ 	int vpd_vendor_id;
+ 	int recheck_wwid;
++	int fast_io_fail;
++	unsigned int dev_loss;
++	int eh_deadline;
+ 	/* configlet pointers */
+ 	vector hwe;
+ 	struct gen_path generic_path;
+@@ -371,7 +374,6 @@ struct multipath {
+ 	int minio;
+ 	int flush_on_last_del;
+ 	int attribute_flags;
+-	int fast_io_fail;
+ 	int retain_hwhandler;
+ 	int deferred_remove;
+ 	bool in_recovery;
+@@ -389,8 +391,6 @@ struct multipath {
+ 	int needs_paths_uevent;
+ 	int ghost_delay;
+ 	int ghost_delay_tick;
+-	unsigned int dev_loss;
+-	int eh_deadline;
+ 	uid_t uid;
+ 	gid_t gid;
+ 	mode_t mode;

SOURCES/0101-libmultipath-check-the-overrides-pctable-for-path-va.patch

@@ -0,0 +1,84 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 13 Apr 2022 23:27:39 -0500
+Subject: [PATCH] libmultipath: check the overrides pctable for path variables
+
+Paths will now also check the pctable when checking for attribtes that
+exists in both the overrides section and the protocol subsection. Values
+in a matching pcentry will be used in preference to values in the
+overrides hwentry.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/propsel.c | 29 ++++++++++++++++++++++++++---
+ 1 file changed, 26 insertions(+), 3 deletions(-)
+
+diff --git a/libmultipath/propsel.c b/libmultipath/propsel.c
+index 25326eb6..209c1d67 100644
+--- a/libmultipath/propsel.c
++++ b/libmultipath/propsel.c
+@@ -79,6 +79,8 @@ static const char conf_origin[] =
+ 	"(setting: multipath.conf defaults/devices section)";
+ static const char overrides_origin[] =
+ 	"(setting: multipath.conf overrides section)";
++static const char overrides_pce_origin[] =
++	"(setting: multipath.conf overrides protocol section)";
+ static const char cmdline_origin[] =
+ 	"(setting: multipath command line [-p] flag)";
+ static const char autodetect_origin[] =
+@@ -144,6 +146,27 @@ do {									\
+ 	}								\
+ } while (0)
+ 
++#define pp_set_ovr_pce(var)						\
++do {									\
++	struct pcentry *_pce;						\
++	int _i;								\
++									\
++	if (conf->overrides) {						\
++		vector_foreach_slot(conf->overrides->pctable, _pce, _i) {	\
++			if (_pce->type == (int)bus_protocol_id(pp) && _pce->var) {	\
++				pp->var = _pce->var;			\
++				origin = overrides_pce_origin;		\
++				goto out;				\
++			}						\
++		}							\
++		if (conf->overrides->var) {				\
++			pp->var = conf->overrides->var;			\
++			origin = overrides_origin;			\
++			goto out;					\
++		}							\
++	}								\
++} while (0)
++
+ int select_mode(struct config *conf, struct multipath *mp)
+ {
+ 	const char *origin;
+@@ -771,7 +794,7 @@ int select_fast_io_fail(struct config *conf, struct path *pp)
+ 	const char *origin;
+ 	char buff[12];
+ 
+-	pp_set_ovr(fast_io_fail);
++	pp_set_ovr_pce(fast_io_fail);
+ 	pp_set_hwe(fast_io_fail);
+ 	pp_set_conf(fast_io_fail);
+ 	pp_set_default(fast_io_fail, DEFAULT_FAST_IO_FAIL);
+@@ -786,7 +809,7 @@ int select_dev_loss(struct config *conf, struct path *pp)
+ 	const char *origin;
+ 	char buff[12];
+ 
+-	pp_set_ovr(dev_loss);
++	pp_set_ovr_pce(dev_loss);
+ 	pp_set_hwe(dev_loss);
+ 	pp_set_conf(dev_loss);
+ 	pp->dev_loss = 0;
+@@ -802,7 +825,7 @@ int select_eh_deadline(struct config *conf, struct path *pp)
+ 	const char *origin;
+ 	char buff[12];
+ 
+-	pp_set_ovr(eh_deadline);
++	pp_set_ovr_pce(eh_deadline);
+ 	pp_set_hwe(eh_deadline);
+ 	pp_set_conf(eh_deadline);
+ 	pp->eh_deadline = EH_DEADLINE_UNSET;

SOURCES/0102-libmultipath-fix-eh_deadline-documentation.patch

@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 13 Apr 2022 23:27:40 -0500
+Subject: [PATCH] libmultipath: fix eh_deadline documentation
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ multipath/multipath.conf.5 | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5
+index 0c04c7e4..b14fd215 100644
+--- a/multipath/multipath.conf.5
++++ b/multipath/multipath.conf.5
+@@ -1602,6 +1602,8 @@ section:
+ .TP
+ .B dev_loss_tmo
+ .TP
++.B eh_deadline
++.TP
+ .B flush_on_last_del
+ .TP
+ .B user_friendly_names
+@@ -1688,6 +1690,8 @@ the values are taken from the \fIdevices\fR or \fIdefaults\fR sections:
+ .TP
+ .B dev_loss_tmo
+ .TP
++.B eh_deadline
++.TP
+ .B user_friendly_names
+ .TP
+ .B retain_attached_hw_handler

SOURCES/0103-libmultipath-Add-documentation-for-the-protocol-subs.patch

@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 13 Apr 2022 23:27:41 -0500
+Subject: [PATCH] libmultipath: Add documentation for the protocol subsection
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ multipath/multipath.conf.5 | 32 ++++++++++++++++++++++++++++++++
+ 1 file changed, 32 insertions(+)
+
+diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5
+index b14fd215..abbc89af 100644
+--- a/multipath/multipath.conf.5
++++ b/multipath/multipath.conf.5
+@@ -1730,6 +1730,38 @@ the values are taken from the \fIdevices\fR or \fIdefaults\fR sections:
+ .RE
+ .PD
+ .LP
++The overrides section also recognizes the optional \fIprotocol\fR subsection,
++and can contain multiple protocol subsections. Path devices are matched against
++the protocol subsection using the mandatory \fItype\fR attribute.  Attributes
++in a matching protocol subsection take precedence over attributes in the rest
++of the overrides section. If there are multiple matching protocol subsections,
++later entries take precedence.
++.TP
++.B protocol subsection
++The protocol subsection recognizes the following mandatory attribute:
++.RS
++.TP
++.B type
++The protocol string of the path device. The possible values are \fIscsi:fcp\fR,
++\fIscsi:spi\fR, \fIscsi:ssa\fR, \fIscsi:sbp\fR, \fIscsi:srp\fR,
++\fIscsi:iscsi\fR, \fIscsi:sas\fR, \fIscsi:adt\fR, \fIscsi:ata\fR,
++\fIscsi:unspec\fR, \fIccw\fR, \fIcciss\fR, \fInvme\fR, and \fIundef\fR. This is
++\fBnot\fR a regular expression. the path device protcol string must match
++exactly. The protocol that a path is using can be viewed by running
++\fBmultipathd show paths format "%d %P"\fR
++.LP
++The following attributes are optional; if not set, the default values are taken
++from the \fIoverrides\fR, \fIdevices\fR, or \fIdefaults\fR section:
++.sp 1
++.PD .1v
++.RS
++.TP
++.B fast_io_fail_tmo
++.TP
++.B dev_loss_tmo
++.TP
++.B eh_deadline
++.PD
+ .
+ .
+ .\" ----------------------------------------------------------------------------

SOURCES/0104-libmultipath-use-symbolic-value-for-invalid-pcentry.patch

@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Thu, 14 Apr 2022 16:11:10 -0500
+Subject: [PATCH] libmultipath: use symbolic value for invalid pcentry
+
+Suggested-by: Martin Wilck <mwilck@suse.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/config.c | 4 ++--
+ libmultipath/config.h | 1 +
+ 2 files changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/libmultipath/config.c b/libmultipath/config.c
+index 88975323..bcd8b541 100644
+--- a/libmultipath/config.c
++++ b/libmultipath/config.c
+@@ -319,7 +319,7 @@ alloc_pce (void)
+ {
+ 	struct pcentry *pce = (struct pcentry *)
+ 				calloc(1, sizeof(struct pcentry));
+-	pce->type = -1;
++	pce->type = PCE_INVALID;
+ 	return pce;
+ }
+ 
+@@ -578,7 +578,7 @@ validate_pctable(struct hwentry *ovr, int idx, const char *table_desc)
+ 		return;
+ 
+ 	vector_foreach_slot_after(ovr->pctable, pce, idx) {
+-		if (pce->type < 0) {
++		if (pce->type == PCE_INVALID) {
+ 			condlog(0, "protocol section in %s missing type",
+ 				table_desc);
+ 			vector_del_slot(ovr->pctable, idx--);
+diff --git a/libmultipath/config.h b/libmultipath/config.h
+index 143116b3..477f8bfa 100644
+--- a/libmultipath/config.h
++++ b/libmultipath/config.h
+@@ -41,6 +41,7 @@ enum force_reload_types {
+ 	FORCE_RELOAD_WEAK,
+ };
+ 
++#define PCE_INVALID -1
+ struct pcentry {
+ 	int type;
+ 	int fast_io_fail;

SOURCES/0106-multipathd-disallow-changing-to-from-fpin-marginal-p.patch

@@ -0,0 +1,73 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 11 Feb 2022 17:23:39 -0600
+Subject: [PATCH] multipathd: disallow changing to/from fpin marginal paths on
+ reconfig
+
+Setting marginal_pathgroups to fpin causes two new threads to be created
+when multipathd starts.  Turning it on after multipathd starts up won't
+cause the theads to start, and turing it off won't keep the threads from
+working. So disallow changing marginal_pathgroups to/from "fpin" on
+reconfigure.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ multipath/multipath.conf.5 | 13 ++++++++-----
+ multipathd/main.c          |  9 +++++++++
+ 2 files changed, 17 insertions(+), 5 deletions(-)
+
+diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5
+index 805b7a5e..8e418372 100644
+--- a/multipath/multipath.conf.5
++++ b/multipath/multipath.conf.5
+@@ -1077,15 +1077,18 @@ have been tried first. This prevents the possibility of IO errors occuring
+ while marginal paths are still usable. After the path has been monitored
+ for the configured time, and is declared healthy, it will be returned to its
+ normal pathgroup.
+-However if this option is set to \fIfpin\fR multipathd will receive fpin
++If this option is set to \fIfpin\fR, multipathd will receive fpin
+ notifications, set path states to "marginal" accordingly, and regroup paths
+-as described for "marginal_pathgroups yes". This option can't be used in combination
+-with other options for "Shaky path detection" (see below).If it is set to fpin,
+-marginal_path_xyz and san_path_err_xyz parameters are implicitly set to 0.
++as described for \fIon\fR. This option can't be used in combination
++with other options for "Shaky path detection" (see below). \fBNote:\fR If this
++is set to \fIfpin\fR, the \fImarginal_path_*\fR and \fIsan_path_err_*\fR
++options are implicitly set to \fIno\fP. Also, this option cannot be switched
++either to or from \fIfpin\fR on a multipathd reconfigure. multipathd must be
++restarted for the change to take effect.
+ See "Shaky paths detection" below for more information.
+ .RS
+ .TP
+-The default  is: \fBno\fR
++The default is: \fBoff\fR
+ .RE
+ .
+ .
+diff --git a/multipathd/main.c b/multipathd/main.c
+index 4cf5bc41..a6ffbe32 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -2675,6 +2675,7 @@ int
+ reconfigure (struct vectors * vecs)
+ {
+ 	struct config * old, *conf;
++	int old_marginal_pathgroups;
+ 
+ 	conf = load_config(DEFAULT_CONFIGFILE);
+ 	if (!conf)
+@@ -2702,6 +2703,14 @@ reconfigure (struct vectors * vecs)
+ 	uxsock_timeout = conf->uxsock_timeout;
+ 
+ 	old = rcu_dereference(multipath_conf);
++	old_marginal_pathgroups = old->marginal_pathgroups;
++	if ((old_marginal_pathgroups == MARGINAL_PATHGROUP_FPIN) !=
++	    (conf->marginal_pathgroups == MARGINAL_PATHGROUP_FPIN)) {
++		condlog(1, "multipathd must be restarted to turn %s fpin marginal paths",
++			(old_marginal_pathgroups == MARGINAL_PATHGROUP_FPIN)?
++			"off" : "on");
++		conf->marginal_pathgroups = old_marginal_pathgroups;
++	}
+ 	conf->sequence_nr = old->sequence_nr + 1;
+ 	rcu_assign_pointer(multipath_conf, conf);
+ 	call_rcu(&old->rcu, rcu_free_config);

SOURCES/0107-libmultipath-unset-detect_checker-for-clariion-Unity.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 10 May 2022 14:17:22 -0500
+Subject: [PATCH] libmultipath: unset detect_checker for clariion / Unity
+ arrays
+
+Dell EMC would like to always use the emc_clariion checker. Currently
+detect_checker will switch the checker to TUR for Unity arrays.
+This can cause problems on some setups with replicated Unity LUNs,
+which are handled correctly the the emc_checker, but not the TUR
+checker.
+
+Cc: vincent.chen1@dell.com
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/hwtable.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/libmultipath/hwtable.c b/libmultipath/hwtable.c
+index d6325864..2bb274c5 100644
+--- a/libmultipath/hwtable.c
++++ b/libmultipath/hwtable.c
+@@ -343,6 +343,7 @@ static struct hwentry default_hw[] = {
+ 		.no_path_retry = (300 / DEFAULT_CHECKINT),
+ 		.checker_name  = EMC_CLARIION,
+ 		.prio_name     = PRIO_EMC,
++		.detect_checker = DETECT_CHECKER_OFF,
+ 	},
+ 	{
+ 		/* Invista / VPLEX */

SOURCES/0108-multipathd-Add-missing-ctype-include.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Bastian Germann <bage@debian.org>
+Date: Thu, 14 Oct 2021 00:34:33 +0200
+Subject: [PATCH] multipathd: Add missing ctype include
+
+In uxclnt.c, there are isspace calls. Add an explicit include.
+
+Signed-off-by: Bastian Germann <bage@debian.org>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ multipathd/uxclnt.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/multipathd/uxclnt.c b/multipathd/uxclnt.c
+index a76f8e29..f16a7309 100644
+--- a/multipathd/uxclnt.c
++++ b/multipathd/uxclnt.c
+@@ -8,6 +8,7 @@
+ #include <stdlib.h>
+ #include <unistd.h>
+ #include <stdarg.h>
++#include <ctype.h>
+ #include <fcntl.h>
+ #include <errno.h>
+ #include <sys/ioctl.h>

SOURCES/0109-multipathd-replace-libreadline-with-libedit.patch

@@ -0,0 +1,102 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martin Wilck <mwilck@suse.com>
+Date: Fri, 12 Aug 2022 18:58:15 +0200
+Subject: [PATCH] multipathd: replace libreadline with libedit
+
+Linking multipathd with libreadline may cause a license conflict,
+because libreadline is licensed under GPL-3.0-or-later, and
+libmultipath contains several files under GPL-2.0.
+
+See:
+   https://github.com/opensvc/multipath-tools/issues/36
+   https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=979095
+   https://www.gnu.org/licenses/gpl-faq.html#AllCompatibility
+
+Replace the readline functionality with libedit, which comes under
+a BSD license. The readline library can still be enabled (e.g. for
+binaries not intended to be distributed) by running
+"make READLINE=libreadline".
+
+Signed-off-by: Martin Wilck <mwilck@suse.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ Makefile.inc        |  5 +++++
+ multipathd/Makefile | 11 ++++++++++-
+ multipathd/cli.c    |  5 +++++
+ multipathd/uxclnt.c |  6 ++++++
+ 4 files changed, 26 insertions(+), 1 deletion(-)
+
+diff --git a/Makefile.inc b/Makefile.inc
+index 25c16f4e..d471f045 100644
+--- a/Makefile.inc
++++ b/Makefile.inc
+@@ -14,6 +14,11 @@
+ #
+ # Uncomment to disable dmevents polling support
+ # ENABLE_DMEVENTS_POLL = 0
++#
++# Readline library to use, libedit or libreadline
++# Caution: Using libreadline may make the multipathd binary undistributable,
++# see https://github.com/opensvc/multipath-tools/issues/36
++READLINE = libedit
+ 
+ ifeq ($(TOPDIR),)
+ 	TOPDIR	= ..
+diff --git a/multipathd/Makefile b/multipathd/Makefile
+index 835edd93..4874ec3a 100644
+--- a/multipathd/Makefile
++++ b/multipathd/Makefile
+@@ -15,7 +15,16 @@ CFLAGS += $(BIN_CFLAGS) -I$(multipathdir) -I$(mpathpersistdir) \
+ LDFLAGS += $(BIN_LDFLAGS)
+ LIBDEPS += -L$(multipathdir) -lmultipath -L$(mpathpersistdir) -lmpathpersist \
+ 	   -L$(mpathcmddir) -lmpathcmd -ludev -ldl -lurcu -lpthread \
+-	   -ldevmapper -lreadline
++	   -ldevmapper
++
++ifeq ($(READLINE),libedit)
++CFLAGS += -DUSE_LIBEDIT
++LIBDEPS += -ledit
++endif
++ifeq ($(READLINE),libreadline)
++CFLAGS += -DUSE_LIBREADLINE
++LIBDEPS += -lreadline
++endif
+ 
+ ifdef SYSTEMD
+ 	CFLAGS += -DUSE_SYSTEMD=$(SYSTEMD)
+diff --git a/multipathd/cli.c b/multipathd/cli.c
+index bdc9fb10..85d73dfb 100644
+--- a/multipathd/cli.c
++++ b/multipathd/cli.c
+@@ -11,7 +11,12 @@
+ #include "parser.h"
+ #include "util.h"
+ #include "version.h"
++#ifdef USE_LIBEDIT
++#include <editline/readline.h>
++#endif
++#ifdef USE_LIBREADLINE
+ #include <readline/readline.h>
++#endif
+ 
+ #include "mpath_cmd.h"
+ #include "cli.h"
+diff --git a/multipathd/uxclnt.c b/multipathd/uxclnt.c
+index f16a7309..2c17d8fc 100644
+--- a/multipathd/uxclnt.c
++++ b/multipathd/uxclnt.c
+@@ -16,8 +16,14 @@
+ #include <sys/socket.h>
+ #include <sys/un.h>
+ #include <poll.h>
++
++#ifdef USE_LIBEDIT
++#include <editline/readline.h>
++#endif
++#ifdef USE_LIBREADLINE
+ #include <readline/readline.h>
+ #include <readline/history.h>
++#endif
+ 
+ #include "mpath_cmd.h"
+ #include "uxsock.h"

SOURCES/0110-multipath-fix-systemd-timers-in-the-initramfs.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 5 Aug 2022 18:16:03 -0500
+Subject: [PATCH] multipath: fix systemd timers in the initramfs
+
+The systemd timers created for "find_multipaths smart" conflict with
+shutdown.target, but not with initrd-cleanup.service.  This can make
+these timers trigger after the inirtd has started shutting down,
+restarting multipathd (which then stops initrd-cleanup.service, since it
+conflicts).  To avoid this, make sure the timers and the unit they
+trigger conflict with inird-cleanup.service. Also don't make them start
+multipathd.  "multipath -u" will not return "maybe" if multipathd isn't
+running or set to run, and since we no longer wait for udev-settle,
+multipathd starts up pretty quickly, so it shouldn't be a problem to
+not trigger it here.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ multipath/multipath.rules | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/multipath/multipath.rules b/multipath/multipath.rules
+index 0486bf70..68c30644 100644
+--- a/multipath/multipath.rules
++++ b/multipath/multipath.rules
+@@ -72,7 +72,7 @@ ENV{.SAVED_FM_WAIT_UNTIL}=="?*", GOTO="pretend_mpath"
+ #
+ # We must trigger an "add" event because LVM2 will only act on those.
+ 
+-RUN+="/usr/bin/systemd-run --unit=cancel-multipath-wait-$kernel --description 'cancel waiting for multipath siblings of $kernel' --no-block --timer-property DefaultDependencies=no --timer-property Conflicts=shutdown.target --timer-property Before=shutdown.target --timer-property AccuracySec=500ms --property DefaultDependencies=no --property Conflicts=shutdown.target --property Before=shutdown.target --property Wants=multipathd.service --property After=multipathd.service --on-active=$env{FIND_MULTIPATHS_WAIT_UNTIL} /usr/bin/udevadm trigger --action=add $sys$devpath"
++RUN+="/usr/bin/systemd-run --unit=cancel-multipath-wait-$kernel --description 'cancel waiting for multipath siblings of $kernel' --no-block --timer-property DefaultDependencies=no --timer-property Conflicts=shutdown.target --timer-property Before=shutdown.target --timer-property Conflicts=initrd-cleanup.service --timer-property Before=initrd-cleanup.service --timer-property AccuracySec=500ms --property DefaultDependencies=no --property Conflicts=shutdown.target --property Before=shutdown.target --property Conflicts=initrd-cleanup.service --property Before=initrd-cleanup.service --on-active=$env{FIND_MULTIPATHS_WAIT_UNTIL} /usr/bin/udevadm trigger --action=add $sys$devpath"
+ 
+ LABEL="pretend_mpath"
+ ENV{DM_MULTIPATH_DEVICE_PATH}="1"

SOURCES/0111-multipathd-factor-out-the-code-to-flush-a-map-with-n.patch

@@ -0,0 +1,90 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 9 Aug 2022 16:46:26 -0500
+Subject: [PATCH] multipathd: factor out the code to flush a map with no paths
+
+The code to flush a multipath device because all of its paths have
+been removed will be used by another caller, so factor it out of
+ev_remove_path().
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ multipathd/main.c | 56 ++++++++++++++++++++++++-----------------------
+ 1 file changed, 29 insertions(+), 27 deletions(-)
+
+diff --git a/multipathd/main.c b/multipathd/main.c
+index a6ffbe32..9b1098f6 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -487,6 +487,30 @@ int update_multipath (struct vectors *vecs, char *mapname, int reset)
+ 	return 0;
+ }
+ 
++static bool
++flush_map_nopaths(struct multipath *mpp, struct vectors *vecs) {
++	char alias[WWID_SIZE];
++
++	/*
++	 * flush_map will fail if the device is open
++	 */
++	strlcpy(alias, mpp->alias, WWID_SIZE);
++	if (mpp->flush_on_last_del == FLUSH_ENABLED) {
++		condlog(2, "%s Last path deleted, disabling queueing",
++			mpp->alias);
++		mpp->retry_tick = 0;
++		mpp->no_path_retry = NO_PATH_RETRY_FAIL;
++		mpp->disable_queueing = 1;
++		mpp->stat_map_failures++;
++		dm_queue_if_no_path(mpp->alias, 0);
++	}
++	if (!flush_map(mpp, vecs, 1)) {
++		condlog(2, "%s: removed map after removing all paths", alias);
++		return true;
++	}
++	return false;
++}
++
+ static int
+ update_map (struct multipath *mpp, struct vectors *vecs, int new_map)
+ {
+@@ -1185,34 +1209,12 @@ ev_remove_path (struct path *pp, struct vectors * vecs, int need_do_map)
+ 			vector_del_slot(mpp->paths, i);
+ 
+ 		/*
+-		 * remove the map IF removing the last path
++		 * remove the map IF removing the last path. If
++		 * flush_map_nopaths succeeds, the path has been removed.
+ 		 */
+-		if (VECTOR_SIZE(mpp->paths) == 0) {
+-			char alias[WWID_SIZE];
+-
+-			/*
+-			 * flush_map will fail if the device is open
+-			 */
+-			strlcpy(alias, mpp->alias, WWID_SIZE);
+-			if (mpp->flush_on_last_del == FLUSH_ENABLED) {
+-				condlog(2, "%s Last path deleted, disabling queueing", mpp->alias);
+-				mpp->retry_tick = 0;
+-				mpp->no_path_retry = NO_PATH_RETRY_FAIL;
+-				mpp->disable_queueing = 1;
+-				mpp->stat_map_failures++;
+-				dm_queue_if_no_path(mpp->alias, 0);
+-			}
+-			if (!flush_map(mpp, vecs, 1)) {
+-				condlog(2, "%s: removed map after"
+-					" removing all paths",
+-					alias);
+-				retval = 0;
+-				goto out;
+-			}
+-			/*
+-			 * Not an error, continue
+-			 */
+-		}
++		if (VECTOR_SIZE(mpp->paths) == 0 &&
++		    flush_map_nopaths(mpp, vecs))
++			goto out;
+ 
+ 		if (mpp->hwe == NULL)
+ 			extract_hwe_from_path(mpp);

SOURCES/0112-libmultipath-return-success-if-we-raced-to-remove-a-.patch

@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 9 Aug 2022 16:46:27 -0500
+Subject: [PATCH] libmultipath: return success if we raced to remove a map and
+ lost
+
+_dm_flush_map() was returning failure if it failed to remove a map,
+even if that was because the map had already been removed. Return
+success in this case.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/devmapper.c | 4 ++++
+ multipathd/main.c        | 4 ----
+ 2 files changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/libmultipath/devmapper.c b/libmultipath/devmapper.c
+index e3c3c119..ee81acc3 100644
+--- a/libmultipath/devmapper.c
++++ b/libmultipath/devmapper.c
+@@ -916,6 +916,10 @@ int _dm_flush_map (const char * mapname, int need_sync, int deferred_remove,
+ 			}
+ 			condlog(4, "multipath map %s removed", mapname);
+ 			return 0;
++		} else if (dm_is_mpath(mapname) != 1) {
++			condlog(4, "multipath map %s removed externally",
++				mapname);
++			return 0; /*we raced with someone else removing it */
+ 		} else {
+ 			condlog(2, "failed to remove multipath map %s",
+ 				mapname);
+diff --git a/multipathd/main.c b/multipathd/main.c
+index 9b1098f6..9eafd5b7 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -673,10 +673,6 @@ flush_map(struct multipath * mpp, struct vectors * vecs, int nopaths)
+ 	 * the spurious uevent we may generate with the dm_flush_map call below
+ 	 */
+ 	if (r) {
+-		/*
+-		 * May not really be an error -- if the map was already flushed
+-		 * from the device mapper by dmsetup(8) for instance.
+-		 */
+ 		if (r == 1)
+ 			condlog(0, "%s: can't flush", mpp->alias);
+ 		else {

SOURCES/0113-multipathd-Handle-losing-all-path-in-update_map.patch

@@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 9 Aug 2022 16:46:28 -0500
+Subject: [PATCH] multipathd: Handle losing all path in update_map
+
+Its possible that when a multipath device is being updated, it will end
+up that all the paths for it are gone. This can happen if paths are
+added and then removed again before multipathd processes the uevent for
+the newly created multipath device. In this case multipathd wasn't
+taking the proper action for the case where all the paths had been
+removed. If flush_on_last_del was set, multipathd wasn't disabling
+flushing and if deferred_remove was set, it wasn't doing a deferred
+remove. Multipathd should call flush_map_nopaths(), just like
+ev_remove_path() does when the last path is removed.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ multipathd/main.c | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/multipathd/main.c b/multipathd/main.c
+index 9eafd5b7..870ae7d8 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -526,6 +526,10 @@ retry:
+ 		goto fail;
+ 	}
+ 	verify_paths(mpp, vecs);
++	if (VECTOR_SIZE(mpp->paths) == 0 &&
++	    flush_map_nopaths(mpp, vecs))
++		return 1;
++
+ 	mpp->action = ACT_RELOAD;
+ 
+ 	if (setup_map(mpp, params, PARAMS_SIZE, vecs)) {

SOURCES/0114-multipathd-ignore-duplicated-multipathd-command-keys.patch

@@ -0,0 +1,153 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Thu, 8 Sep 2022 11:54:49 -0500
+Subject: [PATCH] multipathd: ignore duplicated multipathd command keys
+
+multipath adds rather than or-s the values of command keys. Fix this.
+Also, return an invalid fingerprint if a key is used more than once.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ multipathd/cli.c  |   8 ++--
+ multipathd/main.c | 106 +++++++++++++++++++++++-----------------------
+ 2 files changed, 58 insertions(+), 56 deletions(-)
+
+diff --git a/multipathd/cli.c b/multipathd/cli.c
+index 85d73dfb..45e80197 100644
+--- a/multipathd/cli.c
++++ b/multipathd/cli.c
+@@ -341,9 +341,11 @@ fingerprint(vector vec)
+ 	if (!vec)
+ 		return 0;
+ 
+-	vector_foreach_slot(vec, kw, i)
+-		fp += kw->code;
+-
++	vector_foreach_slot(vec, kw, i) {
++		if (fp & kw->code)
++			return (uint64_t)-1;
++		fp |= kw->code;
++	}
+ 	return fp;
+ }
+ 
+diff --git a/multipathd/main.c b/multipathd/main.c
+index 870ae7d8..cd68a9d2 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -1628,62 +1628,62 @@ uxlsnrloop (void * ap)
+ 	/* Tell main thread that thread has started */
+ 	post_config_state(DAEMON_CONFIGURE);
+ 
+-	set_handler_callback(LIST+PATHS, cli_list_paths);
+-	set_handler_callback(LIST+PATHS+FMT, cli_list_paths_fmt);
+-	set_handler_callback(LIST+PATHS+RAW+FMT, cli_list_paths_raw);
+-	set_handler_callback(LIST+PATH, cli_list_path);
+-	set_handler_callback(LIST+MAPS, cli_list_maps);
+-	set_handler_callback(LIST+STATUS, cli_list_status);
+-	set_unlocked_handler_callback(LIST+DAEMON, cli_list_daemon);
+-	set_handler_callback(LIST+MAPS+STATUS, cli_list_maps_status);
+-	set_handler_callback(LIST+MAPS+STATS, cli_list_maps_stats);
+-	set_handler_callback(LIST+MAPS+FMT, cli_list_maps_fmt);
+-	set_handler_callback(LIST+MAPS+RAW+FMT, cli_list_maps_raw);
+-	set_handler_callback(LIST+MAPS+TOPOLOGY, cli_list_maps_topology);
+-	set_handler_callback(LIST+TOPOLOGY, cli_list_maps_topology);
+-	set_handler_callback(LIST+MAPS+JSON, cli_list_maps_json);
+-	set_handler_callback(LIST+MAP+TOPOLOGY, cli_list_map_topology);
+-	set_handler_callback(LIST+MAP+FMT, cli_list_map_fmt);
+-	set_handler_callback(LIST+MAP+RAW+FMT, cli_list_map_fmt);
+-	set_handler_callback(LIST+MAP+JSON, cli_list_map_json);
+-	set_handler_callback(LIST+CONFIG+LOCAL, cli_list_config_local);
+-	set_handler_callback(LIST+CONFIG, cli_list_config);
+-	set_handler_callback(LIST+BLACKLIST, cli_list_blacklist);
+-	set_handler_callback(LIST+DEVICES, cli_list_devices);
+-	set_handler_callback(LIST+WILDCARDS, cli_list_wildcards);
+-	set_handler_callback(RESET+MAPS+STATS, cli_reset_maps_stats);
+-	set_handler_callback(RESET+MAP+STATS, cli_reset_map_stats);
+-	set_handler_callback(ADD+PATH, cli_add_path);
+-	set_handler_callback(DEL+PATH, cli_del_path);
+-	set_handler_callback(ADD+MAP, cli_add_map);
+-	set_handler_callback(DEL+MAP, cli_del_map);
+-	set_handler_callback(DEL+MAPS, cli_del_maps);
+-	set_handler_callback(SWITCH+MAP+GROUP, cli_switch_group);
++	set_handler_callback(LIST|PATHS, cli_list_paths);
++	set_handler_callback(LIST|PATHS|FMT, cli_list_paths_fmt);
++	set_handler_callback(LIST|PATHS|RAW|FMT, cli_list_paths_raw);
++	set_handler_callback(LIST|PATH, cli_list_path);
++	set_handler_callback(LIST|MAPS, cli_list_maps);
++	set_handler_callback(LIST|STATUS, cli_list_status);
++	set_unlocked_handler_callback(LIST|DAEMON, cli_list_daemon);
++	set_handler_callback(LIST|MAPS|STATUS, cli_list_maps_status);
++	set_handler_callback(LIST|MAPS|STATS, cli_list_maps_stats);
++	set_handler_callback(LIST|MAPS|FMT, cli_list_maps_fmt);
++	set_handler_callback(LIST|MAPS|RAW|FMT, cli_list_maps_raw);
++	set_handler_callback(LIST|MAPS|TOPOLOGY, cli_list_maps_topology);
++	set_handler_callback(LIST|TOPOLOGY, cli_list_maps_topology);
++	set_handler_callback(LIST|MAPS|JSON, cli_list_maps_json);
++	set_handler_callback(LIST|MAP|TOPOLOGY, cli_list_map_topology);
++	set_handler_callback(LIST|MAP|FMT, cli_list_map_fmt);
++	set_handler_callback(LIST|MAP|RAW|FMT, cli_list_map_fmt);
++	set_handler_callback(LIST|MAP|JSON, cli_list_map_json);
++	set_handler_callback(LIST|CONFIG|LOCAL, cli_list_config_local);
++	set_handler_callback(LIST|CONFIG, cli_list_config);
++	set_handler_callback(LIST|BLACKLIST, cli_list_blacklist);
++	set_handler_callback(LIST|DEVICES, cli_list_devices);
++	set_handler_callback(LIST|WILDCARDS, cli_list_wildcards);
++	set_handler_callback(RESET|MAPS|STATS, cli_reset_maps_stats);
++	set_handler_callback(RESET|MAP|STATS, cli_reset_map_stats);
++	set_handler_callback(ADD|PATH, cli_add_path);
++	set_handler_callback(DEL|PATH, cli_del_path);
++	set_handler_callback(ADD|MAP, cli_add_map);
++	set_handler_callback(DEL|MAP, cli_del_map);
++	set_handler_callback(DEL|MAPS, cli_del_maps);
++	set_handler_callback(SWITCH|MAP|GROUP, cli_switch_group);
+ 	set_unlocked_handler_callback(RECONFIGURE, cli_reconfigure);
+-	set_handler_callback(SUSPEND+MAP, cli_suspend);
+-	set_handler_callback(RESUME+MAP, cli_resume);
+-	set_handler_callback(RESIZE+MAP, cli_resize);
+-	set_handler_callback(RELOAD+MAP, cli_reload);
+-	set_handler_callback(RESET+MAP, cli_reassign);
+-	set_handler_callback(REINSTATE+PATH, cli_reinstate);
+-	set_handler_callback(FAIL+PATH, cli_fail);
+-	set_handler_callback(DISABLEQ+MAP, cli_disable_queueing);
+-	set_handler_callback(RESTOREQ+MAP, cli_restore_queueing);
+-	set_handler_callback(DISABLEQ+MAPS, cli_disable_all_queueing);
+-	set_handler_callback(RESTOREQ+MAPS, cli_restore_all_queueing);
++	set_handler_callback(SUSPEND|MAP, cli_suspend);
++	set_handler_callback(RESUME|MAP, cli_resume);
++	set_handler_callback(RESIZE|MAP, cli_resize);
++	set_handler_callback(RELOAD|MAP, cli_reload);
++	set_handler_callback(RESET|MAP, cli_reassign);
++	set_handler_callback(REINSTATE|PATH, cli_reinstate);
++	set_handler_callback(FAIL|PATH, cli_fail);
++	set_handler_callback(DISABLEQ|MAP, cli_disable_queueing);
++	set_handler_callback(RESTOREQ|MAP, cli_restore_queueing);
++	set_handler_callback(DISABLEQ|MAPS, cli_disable_all_queueing);
++	set_handler_callback(RESTOREQ|MAPS, cli_restore_all_queueing);
+ 	set_unlocked_handler_callback(QUIT, cli_quit);
+ 	set_unlocked_handler_callback(SHUTDOWN, cli_shutdown);
+-	set_handler_callback(GETPRSTATUS+MAP, cli_getprstatus);
+-	set_handler_callback(SETPRSTATUS+MAP, cli_setprstatus);
+-	set_handler_callback(UNSETPRSTATUS+MAP, cli_unsetprstatus);
+-	set_handler_callback(FORCEQ+DAEMON, cli_force_no_daemon_q);
+-	set_handler_callback(RESTOREQ+DAEMON, cli_restore_no_daemon_q);
+-	set_handler_callback(GETPRKEY+MAP, cli_getprkey);
+-	set_handler_callback(SETPRKEY+MAP+KEY, cli_setprkey);
+-	set_handler_callback(UNSETPRKEY+MAP, cli_unsetprkey);
+-	set_handler_callback(SETMARGINAL+PATH, cli_set_marginal);
+-	set_handler_callback(UNSETMARGINAL+PATH, cli_unset_marginal);
+-	set_handler_callback(UNSETMARGINAL+MAP, cli_unset_all_marginal);
++	set_handler_callback(GETPRSTATUS|MAP, cli_getprstatus);
++	set_handler_callback(SETPRSTATUS|MAP, cli_setprstatus);
++	set_handler_callback(UNSETPRSTATUS|MAP, cli_unsetprstatus);
++	set_handler_callback(FORCEQ|DAEMON, cli_force_no_daemon_q);
++	set_handler_callback(RESTOREQ|DAEMON, cli_restore_no_daemon_q);
++	set_handler_callback(GETPRKEY|MAP, cli_getprkey);
++	set_handler_callback(SETPRKEY|MAP|KEY, cli_setprkey);
++	set_handler_callback(UNSETPRKEY|MAP, cli_unsetprkey);
++	set_handler_callback(SETMARGINAL|PATH, cli_set_marginal);
++	set_handler_callback(UNSETMARGINAL|PATH, cli_unset_marginal);
++	set_handler_callback(UNSETMARGINAL|MAP, cli_unset_all_marginal);
+ 
+ 	umask(077);
+ 	uxsock_listen(&uxsock_trigger, ux_sock, ap);

SOURCES/0115-multipath-tools-use-run-instead-of-dev-shm.patch

@@ -0,0 +1,141 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martin Wilck <mwilck@suse.com>
+Date: Thu, 1 Sep 2022 19:21:30 +0200
+Subject: [PATCH] multipath-tools: use /run instead of /dev/shm
+
+/dev/shm may have unsafe permissions. Use /run instead.
+Use systemd's tmpfiles.d mechanism to create /run/multipath
+early during boot.
+
+For backward compatibilty, make the runtime directory configurable
+via the "runtimedir" make variable.
+
+Signed-off-by: Martin Wilck <mwilck@suse.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ .gitignore                                        | 2 ++
+ Makefile.inc                                      | 4 +++-
+ libmultipath/defaults.h                           | 2 +-
+ multipath/Makefile                                | 9 +++++++--
+ multipath/{multipath.rules => multipath.rules.in} | 4 ++--
+ multipath/tmpfiles.conf.in                        | 1 +
+ 6 files changed, 16 insertions(+), 6 deletions(-)
+ rename multipath/{multipath.rules => multipath.rules.in} (96%)
+ create mode 100644 multipath/tmpfiles.conf.in
+
+diff --git a/.gitignore b/.gitignore
+index 9926756b..f90b0350 100644
+--- a/.gitignore
++++ b/.gitignore
+@@ -8,6 +8,8 @@
+ *.d
+ kpartx/kpartx
+ multipath/multipath
++multipath/multipath.rules
++multipath/tmpfiles.conf
+ multipathd/multipathd
+ mpathpersist/mpathpersist
+ .nfs*
+diff --git a/Makefile.inc b/Makefile.inc
+index d471f045..287f0e7b 100644
+--- a/Makefile.inc
++++ b/Makefile.inc
+@@ -60,6 +60,7 @@ exec_prefix	= $(prefix)
+ usr_prefix	= $(prefix)
+ bindir		= $(exec_prefix)/usr/sbin
+ libudevdir	= $(prefix)/$(SYSTEMDPATH)/udev
++tmpfilesdir	= $(prefix)/$(SYSTEMDPATH)/tmpfiles.d
+ udevrulesdir	= $(libudevdir)/rules.d
+ multipathdir	= $(TOPDIR)/libmultipath
+ man8dir		= $(prefix)/usr/share/man/man8
+@@ -76,6 +77,7 @@ libdmmpdir	= $(TOPDIR)/libdmmp
+ nvmedir		= $(TOPDIR)/libmultipath/nvme
+ includedir	= $(prefix)/usr/include
+ pkgconfdir	= $(usrlibdir)/pkgconfig
++runtimedir	= /$(RUN)
+ 
+ GZIP		= gzip -9 -c
+ RM		= rm -f
+@@ -117,7 +119,7 @@ OPTFLAGS	+= -Werror -Wextra -Wstrict-prototypes -Wformat=2 \
+ 		   -Werror=cast-qual $(ERROR_DISCARDED_QUALIFIERS) \
+ 		   --param=ssp-buffer-size=4
+ 
+-CFLAGS		:= $(OPTFLAGS) -DBIN_DIR=\"$(bindir)\" -DLIB_STRING=\"${LIB}\" -DRUN_DIR=\"${RUN}\" \
++CFLAGS		:= $(OPTFLAGS) -DBIN_DIR=\"$(bindir)\" -DLIB_STRING=\"${LIB}\" -DRUN_DIR=\"${RUN}\" -DRUNTIME_DIR=\"$(runtimedir)\" \
+ 		   -MMD -MP $(CFLAGS)
+ BIN_CFLAGS	= -fPIE -DPIE
+ LIB_CFLAGS	= -fPIC
+diff --git a/libmultipath/defaults.h b/libmultipath/defaults.h
+index f1cb000d..dcd9f5a7 100644
+--- a/libmultipath/defaults.h
++++ b/libmultipath/defaults.h
+@@ -65,7 +65,7 @@
+ #define DEFAULT_WWIDS_FILE	"/etc/multipath/wwids"
+ #define DEFAULT_PRKEYS_FILE    "/etc/multipath/prkeys"
+ #define DEFAULT_CONFIG_DIR	"/etc/multipath/conf.d"
+-#define MULTIPATH_SHM_BASE	"/dev/shm/multipath/"
++#define MULTIPATH_SHM_BASE	RUNTIME_DIR "/multipath/"
+ 
+ 
+ static inline char *set_default(char *str)
+diff --git a/multipath/Makefile b/multipath/Makefile
+index e720c7f6..f3d98012 100644
+--- a/multipath/Makefile
++++ b/multipath/Makefile
+@@ -12,7 +12,7 @@ EXEC = multipath
+ 
+ OBJS = main.o
+ 
+-all: $(EXEC)
++all: $(EXEC) multipath.rules tmpfiles.conf
+ 
+ $(EXEC): $(OBJS) $(multipathdir)/libmultipath.so $(mpathcmddir)/libmpathcmd.so
+ 	$(CC) $(CFLAGS) $(OBJS) -o $(EXEC) $(LDFLAGS) $(LIBDEPS)
+@@ -27,6 +27,8 @@ install:
+ 	$(INSTALL_PROGRAM) -d $(DESTDIR)$(udevrulesdir)
+ 	$(INSTALL_PROGRAM) -m 644 11-dm-mpath.rules $(DESTDIR)$(udevrulesdir)
+ 	$(INSTALL_PROGRAM) -m 644 $(EXEC).rules $(DESTDIR)$(libudevdir)/rules.d/62-multipath.rules
++	$(INSTALL_PROGRAM) -d $(DESTDIR)$(tmpfilesdir)
++	$(INSTALL_PROGRAM) -m 644 tmpfiles.conf $(DESTDIR)$(tmpfilesdir)/multipath.conf
+ 	$(INSTALL_PROGRAM) -d $(DESTDIR)$(man8dir)
+ 	$(INSTALL_PROGRAM) -m 644 $(EXEC).8.gz $(DESTDIR)$(man8dir)
+ 	$(INSTALL_PROGRAM) -d $(DESTDIR)$(man5dir)
+@@ -43,9 +45,12 @@ uninstall:
+ 	$(RM) $(DESTDIR)$(man8dir)/mpathconf.8.gz
+ 
+ clean: dep_clean
+-	$(RM) core *.o $(EXEC) *.gz
++	$(RM) core *.o $(EXEC) *.gz multipath.rules tmpfiles.conf
+ 
+ include $(wildcard $(OBJS:.o=.d))
+ 
+ dep_clean:
+ 	$(RM) $(OBJS:.o=.d)
++
++%: %.in
++	sed 's,@RUNTIME_DIR@,$(runtimedir),' $< >$@
+diff --git a/multipath/multipath.rules b/multipath/multipath.rules.in
+similarity index 96%
+rename from multipath/multipath.rules
+rename to multipath/multipath.rules.in
+index 68c30644..5c4447a2 100644
+--- a/multipath/multipath.rules
++++ b/multipath/multipath.rules.in
+@@ -1,8 +1,8 @@
+ # Set DM_MULTIPATH_DEVICE_PATH if the device should be handled by multipath
+ SUBSYSTEM!="block", GOTO="end_mpath"
+ KERNEL!="sd*|dasd*|nvme*", GOTO="end_mpath"
+-ACTION=="remove", TEST=="/dev/shm/multipath/find_multipaths/$major:$minor", \
+-	RUN+="/usr/bin/rm -f /dev/shm/multipath/find_multipaths/$major:$minor"
++ACTION=="remove", TEST=="@RUNTIME_DIR@/multipath/find_multipaths/$major:$minor", \
++	RUN+="/usr/bin/rm -f @RUNTIME_DIR@/multipath/find_multipaths/$major:$minor"
+ ACTION!="add|change", GOTO="end_mpath"
+ 
+ IMPORT{cmdline}="nompath"
+diff --git a/multipath/tmpfiles.conf.in b/multipath/tmpfiles.conf.in
+new file mode 100644
+index 00000000..21be438a
+--- /dev/null
++++ b/multipath/tmpfiles.conf.in
+@@ -0,0 +1 @@
++d @RUNTIME_DIR@/multipath 0700 root root -

SOURCES/0116-kpartx-hold-device-open-until-partitions-have-been-c.patch

@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 19 Oct 2022 12:57:10 -0500
+Subject: [PATCH] kpartx: hold device open until partitions have been created
+
+kpartx was closing the whole device after it read the partition
+information off it.  This allowed a race, where the device could be
+removed and another one created with the same major:minor, after kpartx
+read the partition information but before it created the partition
+devices.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ kpartx/kpartx.c | 11 +++--------
+ 1 file changed, 3 insertions(+), 8 deletions(-)
+
+diff --git a/kpartx/kpartx.c b/kpartx/kpartx.c
+index a337a07b..e62b764f 100644
+--- a/kpartx/kpartx.c
++++ b/kpartx/kpartx.c
+@@ -426,12 +426,7 @@ main(int argc, char **argv){
+ 		if (n >= 0)
+ 			printf("%s: %d slices\n", ptp->type, n);
+ #endif
+-
+-		if (n > 0) {
+-			close(fd);
+-			fd = -1;
+-		}
+-		else
++		if (n <= 0)
+ 			continue;
+ 
+ 		switch(what) {
+@@ -649,9 +644,9 @@ main(int argc, char **argv){
+ 		if (n > 0)
+ 			break;
+ 	}
++	if (fd != -1)
++		close(fd);
+ 	if (what == LIST && loopcreated) {
+-		if (fd != -1)
+-			close(fd);
+ 		if (del_loop(device)) {
+ 			if (verbose)
+ 				fprintf(stderr, "can't del loop : %s\n",

SOURCES/0117-libmultipath-cleanup-remove_feature.patch

@@ -0,0 +1,153 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:37 -0500
+Subject: [PATCH] libmultipath: cleanup remove_feature
+
+remove_feature() didn't correctly handle feature strings that used
+whitespace other than spaces, which the kernel allows. It also didn't
+check if the feature string to be removed was part of a larger feature
+token. Finally, it did a lot of unnecessary work. By failing if the
+feature string to be removed contains leading or trailing whitespace,
+the function can be significanly simplified.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/structs.c | 82 +++++++++++++++---------------------------
+ 1 file changed, 29 insertions(+), 53 deletions(-)
+
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index 9f86eb69..471087e2 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -6,6 +6,7 @@
+ #include <unistd.h>
+ #include <libdevmapper.h>
+ #include <libudev.h>
++#include <ctype.h>
+ 
+ #include "checkers.h"
+ #include "memory.h"
+@@ -633,7 +634,7 @@ int add_feature(char **f, const char *n)
+ 
+ int remove_feature(char **f, const char *o)
+ {
+-	int c = 0, d, l;
++	int c = 0, d;
+ 	char *e, *p, *n;
+ 	const char *q;
+ 
+@@ -644,33 +645,35 @@ int remove_feature(char **f, const char *o)
+ 	if (!o || *o == '\0')
+ 		return 0;
+ 
+-	/* Check if not present */
+-	if (!strstr(*f, o))
++	d = strlen(o);
++	if (isspace(*o) || isspace(*(o + d - 1))) {
++		condlog(0, "internal error: feature \"%s\" has leading or trailing spaces", o);
++		return 1;
++	}
++
++	/* Check if present and not part of a larger feature token*/
++	p = *f + 1; /* the size must be at the start of the features string */
++	while ((p = strstr(p, o)) != NULL) {
++		if (isspace(*(p - 1)) &&
++		    (isspace(*(p + d)) || *(p + d) == '\0'))
++			break;
++		p += d;
++	}
++	if (!p)
+ 		return 0;
+ 
+ 	/* Get feature count */
+ 	c = strtoul(*f, &e, 10);
+-	if (*f == e)
+-		/* parse error */
++	if (*f == e || !isspace(*e)) {
++		condlog(0, "parse error in feature string \"%s\"", *f);
+ 		return 1;
+-
+-	/* Normalize features */
+-	while (*o == ' ') {
+-		o++;
+ 	}
+-	/* Just spaces, return */
+-	if (*o == '\0')
+-		return 0;
+-	q = o + strlen(o);
+-	while (*q == ' ')
+-		q--;
+-	d = (int)(q - o);
+ 
+ 	/* Update feature count */
+ 	c--;
+ 	q = o;
+-	while (q[0] != '\0') {
+-		if (q[0] == ' ' && q[1] != ' ' && q[1] != '\0')
++	while (*q != '\0') {
++		if (isspace(*q) && !isspace(*(q + 1)) && *(q + 1) != '\0')
+ 			c--;
+ 		q++;
+ 	}
+@@ -684,15 +687,8 @@ int remove_feature(char **f, const char *o)
+ 		goto out;
+ 	}
+ 
+-	/* Search feature to be removed */
+-	e = strstr(*f, o);
+-	if (!e)
+-		/* Not found, return */
+-		return 0;
+-
+ 	/* Update feature count space */
+-	l = strlen(*f) - d;
+-	n =  MALLOC(l + 1);
++	n =  MALLOC(strlen(*f) - d + 1);
+ 	if (!n)
+ 		return 1;
+ 
+@@ -702,36 +698,16 @@ int remove_feature(char **f, const char *o)
+ 	 * Copy existing features up to the feature
+ 	 * about to be removed
+ 	 */
+-	p = strchr(*f, ' ');
+-	if (!p) {
+-		/* Internal error, feature string inconsistent */
+-		FREE(n);
+-		return 1;
+-	}
+-	while (*p == ' ')
+-		p++;
+-	p--;
+-	if (e != p) {
+-		do {
+-			e--;
+-			d++;
+-		} while (*e == ' ');
+-		e++; d--;
+-		strncat(n, p, (size_t)(e - p));
+-		p += (size_t)(e - p);
+-	}
++	strncat(n, e, (size_t)(p - e));
+ 	/* Skip feature to be removed */
+ 	p += d;
+-
+ 	/* Copy remaining features */
+-	if (strlen(p)) {
+-		while (*p == ' ')
+-			p++;
+-		if (strlen(p)) {
+-			p--;
+-			strcat(n, p);
+-		}
+-	}
++	while (isspace(*p))
++		p++;
++	if (*p != '\0')
++		strcat(n, p);
++	else
++		strchop(n);
+ 
+ out:
+ 	FREE(*f);

SOURCES/0118-libmultipath-cleanup-add_feature.patch

@@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:38 -0500
+Subject: [PATCH] libmultipath: cleanup add_feature
+
+add_feature() didn't correctly handle feature strings that used
+whitespace other than spaces, which the kernel allows. It also didn't
+allow adding features with multiple tokens. When it looked to see if the
+feature string to be added already existed, it didn't check if the match
+was part of a larger token. Finally, it did unnecessary work.  By using
+asprintf() to create the string, the function can be signifcantly
+simplified.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/structs.c | 49 +++++++++++++++++++++---------------------
+ 1 file changed, 24 insertions(+), 25 deletions(-)
+
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index 471087e2..84f9c959 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -572,23 +572,33 @@ int add_feature(char **f, const char *n)
+ {
+ 	int c = 0, d, l;
+ 	char *e, *t;
++	const char *p;
+ 
+ 	if (!f)
+ 		return 1;
+ 
+ 	/* Nothing to do */
+-	if (!n || *n == '0')
++	if (!n || *n == '\0')
+ 		return 0;
+ 
+-	if (strchr(n, ' ') != NULL) {
+-		condlog(0, "internal error: feature \"%s\" contains spaces", n);
++	l = strlen(n);
++	if (isspace(*n) || isspace(*(n + l - 1))) {
++		condlog(0, "internal error: feature \"%s\" has leading or trailing spaces", n);
+ 		return 1;
+ 	}
+ 
++	p = n;
++	d = 1;
++	while (*p != '\0') {
++		if (isspace(*p) && !isspace(*(p + 1)) && *(p + 1) != '\0')
++			d++;
++		p++;
++	}
++
+ 	/* default feature is null */
+ 	if(!*f)
+ 	{
+-		l = asprintf(&t, "1 %s", n);
++		l = asprintf(&t, "%0d %s", d, n);
+ 		if(l == -1)
+ 			return 1;
+ 
+@@ -597,35 +607,24 @@ int add_feature(char **f, const char *n)
+ 	}
+ 
+ 	/* Check if feature is already present */
+-	if (strstr(*f, n))
+-		return 0;
++	e = *f;
++	while ((e = strstr(e, n)) != NULL) {
++		if (isspace(*(e - 1)) &&
++		    (isspace(*(e + l)) || *(e + l) == '\0'))
++			return 0;
++		e += l;
++	}
+ 
+ 	/* Get feature count */
+ 	c = strtoul(*f, &e, 10);
+-	if (*f == e || (*e != ' ' && *e != '\0')) {
++	if (*f == e || (!isspace(*e) && *e != '\0')) {
+ 		condlog(0, "parse error in feature string \"%s\"", *f);
+ 		return 1;
+ 	}
+-
+-	/* Add 1 digit and 1 space */
+-	l = strlen(e) + strlen(n) + 2;
+-
+-	c++;
+-	/* Check if we need more digits for feature count */
+-	for (d = c; d >= 10; d /= 10)
+-		l++;
+-
+-	t = MALLOC(l + 1);
+-	if (!t)
++	c += d;
++	if (asprintf(&t, "%0d%s %s", c, e, n) < 0)
+ 		return 1;
+ 
+-	/* e: old feature string with leading space, or "" */
+-	if (*e == ' ')
+-		while (*(e + 1) == ' ')
+-			e++;
+-
+-	snprintf(t, l + 1, "%0d%s %s", c, e, n);
+-
+ 	FREE(*f);
+ 	*f = t;
+ 

SOURCES/0119-multipath-tests-tests-for-adding-and-removing-featur.patch

@@ -0,0 +1,350 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:39 -0500
+Subject: [PATCH] multipath tests: tests for adding and removing features
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ tests/Makefile   |   2 +-
+ tests/features.c | 318 +++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 319 insertions(+), 1 deletion(-)
+ create mode 100644 tests/features.c
+
+diff --git a/tests/Makefile b/tests/Makefile
+index 77ff3249..914413b8 100644
+--- a/tests/Makefile
++++ b/tests/Makefile
+@@ -13,7 +13,7 @@ CFLAGS += $(BIN_CFLAGS) -I$(multipathdir) -I$(mpathcmddir) \
+ LIBDEPS += -L$(multipathdir) -lmultipath -lcmocka
+ 
+ TESTS := uevent parser util dmevents hwtable blacklist unaligned vpd pgpolicy \
+-	 alias directio
++	 alias directio features
+ 
+ .SILENT: $(TESTS:%=%.o)
+ .PRECIOUS: $(TESTS:%=%-test)
+diff --git a/tests/features.c b/tests/features.c
+new file mode 100644
+index 00000000..1e2e6bff
+--- /dev/null
++++ b/tests/features.c
+@@ -0,0 +1,318 @@
++#include <stddef.h>
++#include <stdarg.h>
++#include <setjmp.h>
++#include <cmocka.h>
++
++#include "structs.h"
++#include "globals.c"
++
++static void test_af_null_features_ptr(void **state)
++{
++	assert_int_equal(add_feature(NULL, "test"), 1);
++}
++
++static void af_helper(const char *features_start, const char *addition,
++		      const char *features_end, int result)
++{
++	char *f = NULL, *orig = NULL;
++
++	if (features_start) {
++		f = strdup(features_start);
++		assert_non_null(f);
++		orig = f;
++	}
++	assert_int_equal(add_feature(&f, addition), result);
++	if (result != 0 || features_end == NULL)
++		assert_ptr_equal(orig, f);
++	else
++		assert_string_equal(f, features_end);
++	free(f);
++}
++
++static void test_af_null_addition1(void **state)
++{
++	af_helper("0", NULL, NULL, 0);
++}
++
++static void test_af_null_addition2(void **state)
++{
++	af_helper("1 queue_if_no_path", NULL, NULL, 0);
++}
++
++static void test_af_empty_addition(void **state)
++{
++	af_helper("2 pg_init_retries 5", "", NULL, 0);
++}
++
++static void test_af_invalid_addition1(void **state)
++{
++	af_helper("2 pg_init_retries 5", " ", NULL, 1);
++}
++
++static void test_af_invalid_addition2(void **state)
++{
++	af_helper("2 pg_init_retries 5", "\tbad", NULL, 1);
++}
++
++static void test_af_invalid_addition3(void **state)
++{
++	af_helper("2 pg_init_retries 5", "bad ", NULL, 1);
++}
++ 
++static void test_af_invalid_addition4(void **state)
++{
++	af_helper("2 pg_init_retries 5", " bad ", NULL, 1);
++}
++ 
++static void test_af_null_features1(void **state)
++{
++	af_helper(NULL, "test", "1 test", 0);
++}
++
++static void test_af_null_features2(void **state)
++{
++	af_helper(NULL, "test\t  more", "2 test\t  more", 0);
++}
++
++static void test_af_null_features3(void **state)
++{
++	af_helper(NULL, "test\neven\tmore", "3 test\neven\tmore", 0);
++}
++
++static void test_af_already_exists1(void **state)
++{
++	af_helper("4 this is a test", "test", NULL, 0);
++}
++
++static void test_af_already_exists2(void **state)
++{
++	af_helper("5 contest testy intestine test retest", "test", NULL, 0);
++}
++
++static void test_af_almost_exists(void **state)
++{
++	af_helper("3 contest testy intestine", "test",
++		  "4 contest testy intestine test", 0);
++}
++
++static void test_af_bad_features1(void **state)
++{
++	af_helper("bad", "test", NULL, 1);
++}
++
++static void test_af_bad_features2(void **state)
++{
++	af_helper("1bad", "test", NULL, 1);
++}
++
++static void test_af_add1(void **state)
++{
++	af_helper("0", "test", "1 test", 0);
++}
++
++static void test_af_add2(void **state)
++{
++	af_helper("0", "this is a test", "4 this is a test", 0);
++}
++
++static void test_af_add3(void **state)
++{
++	af_helper("1 features", "more values", "3 features more values", 0);
++}
++
++static void test_af_add4(void **state)
++{
++	af_helper("2 one\ttwo", "three\t four", "4 one\ttwo three\t four", 0);
++}
++
++static int test_add_features(void)
++{
++	const struct CMUnitTest tests[] = {
++		cmocka_unit_test(test_af_null_features_ptr),
++		cmocka_unit_test(test_af_null_addition1),
++		cmocka_unit_test(test_af_null_addition2),
++		cmocka_unit_test(test_af_empty_addition),
++		cmocka_unit_test(test_af_invalid_addition1),
++		cmocka_unit_test(test_af_invalid_addition2),
++		cmocka_unit_test(test_af_invalid_addition3),
++		cmocka_unit_test(test_af_invalid_addition4),
++		cmocka_unit_test(test_af_null_features1),
++		cmocka_unit_test(test_af_null_features2),
++		cmocka_unit_test(test_af_null_features3),
++		cmocka_unit_test(test_af_already_exists1),
++		cmocka_unit_test(test_af_already_exists2),
++		cmocka_unit_test(test_af_almost_exists),
++		cmocka_unit_test(test_af_bad_features1),
++		cmocka_unit_test(test_af_bad_features2),
++		cmocka_unit_test(test_af_add1),
++		cmocka_unit_test(test_af_add2),
++		cmocka_unit_test(test_af_add3),
++		cmocka_unit_test(test_af_add4),
++	};
++	return cmocka_run_group_tests(tests, NULL, NULL);
++}
++
++static void test_rf_null_features_ptr(void **state)
++{
++	assert_int_equal(remove_feature(NULL, "test"), 1);
++}
++
++static void test_rf_null_features(void **state)
++{
++	char *f = NULL;
++	assert_int_equal(remove_feature(&f, "test"), 1);
++}
++
++static void rf_helper(const char *features_start, const char *removal,
++		      const char *features_end, int result)
++{
++	char *f = strdup(features_start);
++	char *orig = f;
++
++	assert_non_null(f);
++	assert_int_equal(remove_feature(&f, removal), result);
++	if (result != 0 || features_end == NULL)
++		assert_ptr_equal(orig, f);
++	else
++		assert_string_equal(f, features_end);
++	free(f);
++}
++
++static void test_rf_null_removal(void **state)
++{
++	rf_helper("1 feature", NULL, NULL, 0);
++}
++
++static void test_rf_empty_removal(void **state)
++{
++	rf_helper("1 feature", "", NULL, 0);
++}
++
++static void test_rf_invalid_removal1(void **state)
++{
++	rf_helper("1 feature", " ", NULL, 1);
++}
++
++static void test_rf_invalid_removal2(void **state)
++{
++	rf_helper("1 feature", " bad", NULL, 1);
++}
++
++static void test_rf_invalid_removal3(void **state)
++{
++	rf_helper("1 feature", "bad\n", NULL, 1);
++}
++
++static void test_rf_invalid_removal4(void **state)
++{
++	rf_helper("1 feature", "\tbad  \n", NULL, 1);
++}
++
++static void test_rf_bad_features1(void **state)
++{
++	rf_helper("invalid feature test string", "test", NULL, 1);
++}
++
++static void test_rf_bad_features2(void **state)
++{
++	rf_helper("2no space test", "test", NULL, 1);
++}
++
++static void test_rf_missing_removal1(void **state)
++{
++	rf_helper("0", "test", NULL, 0);
++}
++
++static void test_rf_missing_removal2(void **state)
++{
++	rf_helper("1 detest", "test", NULL, 0);
++}
++
++static void test_rf_missing_removal3(void **state)
++{
++	rf_helper("4 testing one two three", "test", NULL, 0);
++}
++
++static void test_rf_missing_removal4(void **state)
++{
++	rf_helper("1 contestant", "test", NULL, 0);
++}
++
++static void test_rf_missing_removal5(void **state)
++{
++	rf_helper("3 testament protest detestable", "test", NULL, 0);
++}
++
++static void test_rf_remove_all_features1(void **state)
++{
++	rf_helper("1 test", "test", "0", 0);
++}
++
++static void test_rf_remove_all_features2(void **state)
++{
++	rf_helper("2 another\t test", "another\t test", "0", 0);
++}
++
++static void test_rf_remove1(void **state)
++{
++	rf_helper("2 feature1 feature2", "feature2", "1 feature1", 0);
++}
++
++static void test_rf_remove2(void **state)
++{
++	rf_helper("2 feature1 feature2", "feature1", "1 feature2", 0);
++}
++
++static void test_rf_remove3(void **state)
++{
++	rf_helper("3 test1 test\ttest2", "test", "2 test1 test2", 0);
++}
++
++static void test_rf_remove4(void **state)
++{
++	rf_helper("4 this\t is a test", "is a", "2 this\t test", 0);
++}
++
++static void test_rf_remove5(void **state)
++{
++	rf_helper("3 one more test", "more test", "1 one", 0);
++}
++
++static int test_remove_features(void)
++{
++	const struct CMUnitTest tests[] = {
++		cmocka_unit_test(test_rf_null_features_ptr),
++		cmocka_unit_test(test_rf_null_features),
++		cmocka_unit_test(test_rf_null_removal),
++		cmocka_unit_test(test_rf_empty_removal),
++		cmocka_unit_test(test_rf_invalid_removal1),
++		cmocka_unit_test(test_rf_invalid_removal2),
++		cmocka_unit_test(test_rf_invalid_removal3),
++		cmocka_unit_test(test_rf_invalid_removal4),
++		cmocka_unit_test(test_rf_bad_features1),
++		cmocka_unit_test(test_rf_bad_features2),
++		cmocka_unit_test(test_rf_missing_removal1),
++		cmocka_unit_test(test_rf_missing_removal2),
++		cmocka_unit_test(test_rf_missing_removal3),
++		cmocka_unit_test(test_rf_missing_removal4),
++		cmocka_unit_test(test_rf_missing_removal5),
++		cmocka_unit_test(test_rf_remove_all_features1),
++		cmocka_unit_test(test_rf_remove_all_features2),
++		cmocka_unit_test(test_rf_remove1),
++		cmocka_unit_test(test_rf_remove2),
++		cmocka_unit_test(test_rf_remove3),
++		cmocka_unit_test(test_rf_remove4),
++		cmocka_unit_test(test_rf_remove5),
++	};
++	return cmocka_run_group_tests(tests, NULL, NULL);
++}
++
++int main(void)
++{
++	int ret = 0;
++
++	ret += test_add_features();
++	ret += test_remove_features();
++
++	return ret;
++}

SOURCES/0120-libmultipath-fix-queue_mode-feature-handling.patch

@@ -0,0 +1,212 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:40 -0500
+Subject: [PATCH] libmultipath: fix queue_mode feature handling
+
+device-mapper is not able to change the queue_mode on a table reload.
+Make sure that when multipath sets up the map, both on regular reloads
+and reconfigures, it keeps the queue_mode the same.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/configure.c   |  4 +++
+ libmultipath/dmparser.c    |  2 ++
+ libmultipath/propsel.c     | 55 ++++++++++++++++++++++++++++++++++++++
+ libmultipath/structs.h     |  7 +++++
+ libmultipath/util.c        | 10 +++++++
+ libmultipath/util.h        |  1 +
+ multipath/multipath.conf.5 |  7 +++--
+ 7 files changed, 84 insertions(+), 2 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index 6cad0468..287289f7 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -1102,6 +1102,7 @@ int coalesce_paths (struct vectors * vecs, vector newmp, char * refwwid,
+ 	uint64_t *size_mismatch_seen;
+ 	bool map_processed = false;
+ 	bool no_daemon = false;
++	struct multipath * cmpp;
+ 
+ 	/* ignore refwwid if it's empty */
+ 	if (refwwid && !strlen(refwwid))
+@@ -1197,6 +1198,9 @@ int coalesce_paths (struct vectors * vecs, vector newmp, char * refwwid,
+ 		}
+ 		verify_paths(mpp, vecs);
+ 
++		cmpp = find_mp_by_wwid(curmp, mpp->wwid);
++		if (cmpp)
++			mpp->queue_mode = cmpp->queue_mode;
+ 		params[0] = '\0';
+ 		if (setup_map(mpp, params, PARAMS_SIZE, vecs)) {
+ 			remove_map(mpp, vecs, 0);
+diff --git a/libmultipath/dmparser.c b/libmultipath/dmparser.c
+index b856a07f..b9c4dabc 100644
+--- a/libmultipath/dmparser.c
++++ b/libmultipath/dmparser.c
+@@ -164,6 +164,8 @@ int disassemble_map(vector pathvec, char *params, struct multipath *mpp,
+ 
+ 		FREE(word);
+ 	}
++	mpp->queue_mode = strstr(mpp->features, "queue_mode bio") ?
++			  QUEUE_MODE_BIO : QUEUE_MODE_RQ;
+ 
+ 	/*
+ 	 * hwhandler
+diff --git a/libmultipath/propsel.c b/libmultipath/propsel.c
+index be79902f..3f119dd9 100644
+--- a/libmultipath/propsel.c
++++ b/libmultipath/propsel.c
+@@ -26,6 +26,7 @@
+ #include "propsel.h"
+ #include <inttypes.h>
+ #include <libudev.h>
++#include <ctype.h>
+ 
+ pgpolicyfn *pgpolicies[] = {
+ 	NULL,
+@@ -413,6 +414,59 @@ void reconcile_features_with_options(const char *id, char **features, int* no_pa
+ 	}
+ }
+ 
++static void reconcile_features_with_queue_mode(struct multipath *mp)
++{
++	char *space = NULL, *val = NULL, *mode_str = NULL, *feat;
++	int features_mode = QUEUE_MODE_UNDEF;
++
++	if (!mp->features)
++		return;
++
++	pthread_cleanup_push(cleanup_free_ptr, &space);
++	pthread_cleanup_push(cleanup_free_ptr, &val);
++	pthread_cleanup_push(cleanup_free_ptr, &mode_str);
++
++	if (!(feat = strstr(mp->features, "queue_mode")) ||
++	    feat == mp->features || !isspace(*(feat - 1)) ||
++	    sscanf(feat, "queue_mode%m[ \f\n\r\t\v]%ms", &space, &val) != 2)
++		goto sync_mode;
++	if (asprintf(&mode_str, "queue_mode%s%s", space, val) < 0) {
++		condlog(1, "failed to allocate space for queue_mode feature string");
++		mode_str = NULL; /* value undefined on failure */
++		goto exit;
++	}
++
++	if (!strcmp(val, "rq") || !strcmp(val, "mq"))
++		features_mode = QUEUE_MODE_RQ;
++	else if (!strcmp(val, "bio"))
++		features_mode = QUEUE_MODE_BIO;
++	if (features_mode == QUEUE_MODE_UNDEF) {
++		condlog(2, "%s: ignoring invalid feature '%s'",
++			mp->alias, mode_str);
++		goto sync_mode;
++	}
++
++	if (mp->queue_mode == QUEUE_MODE_UNDEF)
++		mp->queue_mode = features_mode;
++	if (mp->queue_mode == features_mode)
++		goto exit;
++
++	condlog(2,
++		"%s: ignoring feature '%s' because queue_mode is set to '%s'",
++		mp->alias, mode_str,
++		(mp->queue_mode == QUEUE_MODE_RQ)? "rq" : "bio");
++
++sync_mode:
++	if (mode_str)
++		remove_feature(&mp->features, mode_str);
++	if (mp->queue_mode == QUEUE_MODE_BIO)
++		add_feature(&mp->features, "queue_mode bio");
++exit:
++	pthread_cleanup_pop(1);
++	pthread_cleanup_pop(1);
++	pthread_cleanup_pop(1);
++}
++
+ int select_features(struct config *conf, struct multipath *mp)
+ {
+ 	const char *origin;
+@@ -428,6 +482,7 @@ out:
+ 	reconcile_features_with_options(mp->alias, &mp->features,
+ 					&mp->no_path_retry,
+ 					&mp->retain_hwhandler);
++	reconcile_features_with_queue_mode(mp);
+ 	condlog(3, "%s: features = \"%s\" %s", mp->alias, mp->features, origin);
+ 	return 0;
+ }
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index 3ed5cfc1..9a404da7 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -187,6 +187,12 @@ enum max_sectors_kb_states {
+ 	MAX_SECTORS_KB_MIN = 4,  /* can't be smaller than page size */
+ };
+ 
++enum queue_mode_states {
++	QUEUE_MODE_UNDEF = 0,
++	QUEUE_MODE_BIO,
++	QUEUE_MODE_RQ,
++};
++
+ enum scsi_protocol {
+ 	SCSI_PROTOCOL_FCP = 0,	/* Fibre Channel */
+ 	SCSI_PROTOCOL_SPI = 1,	/* parallel SCSI */
+@@ -397,6 +403,7 @@ struct multipath {
+ 	int needs_paths_uevent;
+ 	int ghost_delay;
+ 	int ghost_delay_tick;
++	int queue_mode;
+ 	uid_t uid;
+ 	gid_t gid;
+ 	mode_t mode;
+diff --git a/libmultipath/util.c b/libmultipath/util.c
+index dd30a46e..e04d20ab 100644
+--- a/libmultipath/util.c
++++ b/libmultipath/util.c
+@@ -465,6 +465,16 @@ void free_scandir_result(struct scandir_result *res)
+ 	FREE(res->di);
+ }
+ 
++void cleanup_free_ptr(void *arg)
++{
++	void **p = arg;
++
++	if (p && *p) {
++		free(*p);
++		*p = NULL;
++	}
++}
++
+ void close_fd(void *arg)
+ {
+ 	close((long)arg);
+diff --git a/libmultipath/util.h b/libmultipath/util.h
+index ce277680..f898c829 100644
+--- a/libmultipath/util.h
++++ b/libmultipath/util.h
+@@ -44,6 +44,7 @@ void set_max_fds(rlim_t max_fds);
+ 	pthread_cleanup_push(((void (*)(void *))&f), (arg))
+ 
+ void close_fd(void *arg);
++void cleanup_free_ptr(void *arg);
+ void cleanup_mutex(void *arg);
+ 
+ struct scandir_result {
+diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5
+index 8e418372..61d2712b 100644
+--- a/multipath/multipath.conf.5
++++ b/multipath/multipath.conf.5
+@@ -458,8 +458,11 @@ precedence. See KNOWN ISSUES.
+ <mode> can be \fIbio\fR, \fIrq\fR or \fImq\fR, which corresponds to
+ bio-based, request-based, and block-multiqueue (blk-mq) request-based,
+ respectively.
+-The default depends on the kernel parameter \fBdm_mod.use_blk_mq\fR. It is
+-\fImq\fR if the latter is set, and \fIrq\fR otherwise.
++Before kernel 4.20 The default depends on the kernel parameter
++\fBdm_mod.use_blk_mq\fR. It is \fImq\fR if the latter is set, and \fIrq\fR
++otherwise. Since kernel 4.20, \fIrq\fR and \fImq\fR both correspond to
++block-multiqueue. Once a multipath device has been created, its queue_mode
++cannot be changed.
+ .TP
+ The default is: \fB<unset>\fR
+ .RE

SOURCES/0121-multipath-tests-tests-for-reconcile_features_with_qu.patch

@@ -0,0 +1,290 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:41 -0500
+Subject: [PATCH] multipath tests: tests for reconcile_features_with_queue_mode
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ tests/Makefile   |   2 +
+ tests/features.c | 232 ++++++++++++++++++++++++++++++++++++++++++++++-
+ 2 files changed, 233 insertions(+), 1 deletion(-)
+
+diff --git a/tests/Makefile b/tests/Makefile
+index 914413b8..f3e49487 100644
+--- a/tests/Makefile
++++ b/tests/Makefile
+@@ -29,6 +29,7 @@ endif
+ ifneq ($(DIO_TEST_DEV),)
+ directio-test_FLAGS := -DDIO_TEST_DEV=\"$(DIO_TEST_DEV)\"
+ endif
++features-test_FLAGS := -I$(multipathdir)/nvme
+ 
+ # test-specific linker flags
+ # XYZ-test_TESTDEPS: test libraries containing __wrap_xyz functions
+@@ -53,6 +54,7 @@ alias-test_LIBDEPS := -lpthread -ldl
+ ifneq ($(DIO_TEST_DEV),)
+ directio-test_LIBDEPS := -laio
+ endif
++features-test_LIBDEPS := -ludev -lpthread
+ 
+ %.o: %.c
+ 	$(CC) $(CFLAGS) $($*-test_FLAGS) -c -o $@ $<
+diff --git a/tests/features.c b/tests/features.c
+index 1e2e6bff..01fbccb7 100644
+--- a/tests/features.c
++++ b/tests/features.c
+@@ -1,9 +1,10 @@
++#define _GNU_SOURCE
+ #include <stddef.h>
+ #include <stdarg.h>
+ #include <setjmp.h>
+ #include <cmocka.h>
+ 
+-#include "structs.h"
++#include "../libmultipath/propsel.c"
+ #include "globals.c"
+ 
+ static void test_af_null_features_ptr(void **state)
+@@ -307,12 +308,241 @@ static int test_remove_features(void)
+ 	return cmocka_run_group_tests(tests, NULL, NULL);
+ }
+ 
++static void test_cf_null_features(void **state)
++{
++	struct multipath mp = {
++			.alias = "test",
++	};
++	reconcile_features_with_queue_mode(&mp);
++	assert_null(mp.features);
++}
++
++static void cf_helper(const char *features_start, const char *features_end,
++		      int queue_mode_start, int queue_mode_end)
++{
++	struct multipath mp = {
++			.alias = "test",
++			.features = strdup(features_start),
++			.queue_mode = queue_mode_start,
++	};
++	char *orig = mp.features;
++
++	assert_non_null(orig);
++	reconcile_features_with_queue_mode(&mp);
++	if (!features_end)
++		assert_ptr_equal(orig, mp.features);
++	else
++		assert_string_equal(mp.features, features_end);
++	free(mp.features);
++	assert_int_equal(mp.queue_mode, queue_mode_end);
++}
++
++static void test_cf_unset_unset1(void **state)
++{
++	cf_helper("0", NULL, QUEUE_MODE_UNDEF, QUEUE_MODE_UNDEF);
++}
++
++static void test_cf_unset_unset2(void **state)
++{
++	cf_helper("1 queue_mode", NULL, QUEUE_MODE_UNDEF, QUEUE_MODE_UNDEF);
++}
++
++static void test_cf_unset_unset3(void **state)
++{
++	cf_helper("queue_mode", NULL, QUEUE_MODE_UNDEF, QUEUE_MODE_UNDEF);
++}
++
++static void test_cf_unset_unset4(void **state)
++{
++	cf_helper("2 queue_model bio", NULL, QUEUE_MODE_UNDEF,
++		  QUEUE_MODE_UNDEF);
++}
++
++static void test_cf_unset_unset5(void **state)
++{
++	cf_helper("1 queue_if_no_path", NULL, QUEUE_MODE_UNDEF,
++		  QUEUE_MODE_UNDEF);
++}
++
++static void test_cf_invalid_unset1(void **state)
++{
++	cf_helper("2 queue_mode biop", "0", QUEUE_MODE_UNDEF, QUEUE_MODE_UNDEF);
++}
++
++static void test_cf_invalid_unset2(void **state)
++{
++	cf_helper("3 queue_mode rqs queue_if_no_path", "1 queue_if_no_path",
++		  QUEUE_MODE_UNDEF, QUEUE_MODE_UNDEF);
++}
++
++static void test_cf_rq_unset1(void **state)
++{
++	cf_helper("2 queue_mode rq", NULL, QUEUE_MODE_UNDEF, QUEUE_MODE_RQ);
++}
++
++static void test_cf_rq_unset2(void **state)
++{
++	cf_helper("2 queue_mode mq", NULL, QUEUE_MODE_UNDEF, QUEUE_MODE_RQ);
++}
++
++static void test_cf_bio_unset(void **state)
++{
++	cf_helper("2 queue_mode bio", NULL, QUEUE_MODE_UNDEF, QUEUE_MODE_BIO);
++}
++
++static void test_cf_unset_bio1(void **state)
++{
++	cf_helper("1 queue_if_no_path", "3 queue_if_no_path queue_mode bio",
++		  QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_unset_bio2(void **state)
++{
++	cf_helper("0", "2 queue_mode bio", QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_unset_bio3(void **state)
++{
++	cf_helper("2 pg_init_retries 50", "4 pg_init_retries 50 queue_mode bio",
++		  QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_invalid_bio1(void **state)
++{
++	cf_helper("2 queue_mode bad", "2 queue_mode bio",
++		  QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_invalid_bio2(void **state)
++{
++	cf_helper("3 queue_if_no_path queue_mode\tbad", "3 queue_if_no_path queue_mode bio",
++		  QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_bio_bio1(void **state)
++{
++	cf_helper("2 queue_mode bio", NULL, QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_bio_bio2(void **state)
++{
++	cf_helper("3 queue_if_no_path queue_mode bio", NULL, QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_bio_bio3(void **state)
++{
++	cf_helper("3 queue_mode\nbio queue_if_no_path", NULL, QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_bio_rq1(void **state)
++{
++	cf_helper("2\nqueue_mode\tbio", "0", QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_bio_rq2(void **state)
++{
++	cf_helper("3 queue_if_no_path\nqueue_mode bio", "1 queue_if_no_path",
++		  QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_bio_rq3(void **state)
++{
++	cf_helper("4 queue_mode bio pg_init_retries 20", "2 pg_init_retries 20",
++		  QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_unset_rq1(void **state)
++{
++	cf_helper("0", NULL, QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_unset_rq2(void **state)
++{
++	cf_helper("2 pg_init_retries 15", NULL, QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_invalid_rq1(void **state)
++{
++	cf_helper("2 queue_mode bionic", "0", QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_invalid_rq2(void **state)
++{
++	cf_helper("3 queue_mode b\nqueue_if_no_path", "1 queue_if_no_path",
++		  QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_rq_rq1(void **state)
++{
++	cf_helper("2 queue_mode rq", NULL, QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_rq_rq2(void **state)
++{
++	cf_helper("3 queue_mode\t \trq\nqueue_if_no_path", NULL, QUEUE_MODE_RQ, QUEUE_MODE_RQ);
++}
++
++static void test_cf_rq_bio1(void **state)
++{
++	cf_helper("2 queue_mode rq", "2 queue_mode bio", QUEUE_MODE_BIO,
++		  QUEUE_MODE_BIO);
++}
++
++static void test_cf_rq_bio2(void **state)
++{
++	cf_helper("3 queue_if_no_path\nqueue_mode rq", "3 queue_if_no_path queue_mode bio", QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static void test_cf_rq_bio3(void **state)
++{
++	cf_helper("3 queue_mode rq\nqueue_if_no_path", "3 queue_if_no_path queue_mode bio", QUEUE_MODE_BIO, QUEUE_MODE_BIO);
++}
++
++static int test_reconcile_features(void)
++{
++	const struct CMUnitTest tests[] = {
++		cmocka_unit_test(test_cf_null_features),
++		cmocka_unit_test(test_cf_unset_unset1),
++		cmocka_unit_test(test_cf_unset_unset2),
++		cmocka_unit_test(test_cf_unset_unset3),
++		cmocka_unit_test(test_cf_unset_unset4),
++		cmocka_unit_test(test_cf_unset_unset5),
++		cmocka_unit_test(test_cf_invalid_unset1),
++		cmocka_unit_test(test_cf_invalid_unset2),
++		cmocka_unit_test(test_cf_rq_unset1),
++		cmocka_unit_test(test_cf_rq_unset2),
++		cmocka_unit_test(test_cf_bio_unset),
++		cmocka_unit_test(test_cf_unset_bio1),
++		cmocka_unit_test(test_cf_unset_bio2),
++		cmocka_unit_test(test_cf_unset_bio3),
++		cmocka_unit_test(test_cf_invalid_bio1),
++		cmocka_unit_test(test_cf_invalid_bio2),
++		cmocka_unit_test(test_cf_bio_bio1),
++		cmocka_unit_test(test_cf_bio_bio2),
++		cmocka_unit_test(test_cf_bio_bio3),
++		cmocka_unit_test(test_cf_bio_rq1),
++		cmocka_unit_test(test_cf_bio_rq2),
++		cmocka_unit_test(test_cf_bio_rq3),
++		cmocka_unit_test(test_cf_unset_rq1),
++		cmocka_unit_test(test_cf_unset_rq2),
++		cmocka_unit_test(test_cf_invalid_rq1),
++		cmocka_unit_test(test_cf_invalid_rq2),
++		cmocka_unit_test(test_cf_rq_rq1),
++		cmocka_unit_test(test_cf_rq_rq2),
++		cmocka_unit_test(test_cf_rq_bio1),
++		cmocka_unit_test(test_cf_rq_bio2),
++		cmocka_unit_test(test_cf_rq_bio3),
++	};
++	return cmocka_run_group_tests(tests, NULL, NULL);
++}
++
+ int main(void)
+ {
+ 	int ret = 0;
+ 
+ 	ret += test_add_features();
+ 	ret += test_remove_features();
++	ret += test_reconcile_features();
+ 
+ 	return ret;
+ }

SOURCES/0122-libmultipath-prepare-proto_id-for-use-by-non-scsi-de.patch

@@ -0,0 +1,143 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:42 -0500
+Subject: [PATCH] libmultipath: prepare proto_id for use by non-scsi devivces
+
+Make sure that when we are checking for a scsi protocol, we are first
+checking that we are working with a scsi path.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/configure.c   |  9 +++++----
+ libmultipath/discovery.c   | 13 ++++++++-----
+ libmultipath/print.c       |  6 ++++--
+ libmultipath/structs.c     |  2 +-
+ libmultipath/structs.h     |  4 +++-
+ multipathd/fpin_handlers.c |  2 +-
+ 6 files changed, 22 insertions(+), 14 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index 287289f7..8e1bc488 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -223,10 +223,11 @@ int rr_optimize_path_order(struct pathgroup *pgp)
+ 
+ 	total_paths = VECTOR_SIZE(pgp->paths);
+ 	vector_foreach_slot(pgp->paths, pp, i) {
+-		if (pp->sg_id.proto_id != SCSI_PROTOCOL_FCP &&
+-			pp->sg_id.proto_id != SCSI_PROTOCOL_SAS &&
+-			pp->sg_id.proto_id != SCSI_PROTOCOL_ISCSI &&
+-			pp->sg_id.proto_id != SCSI_PROTOCOL_SRP) {
++		if (pp->bus != SYSFS_BUS_SCSI ||
++		    (pp->sg_id.proto_id != SCSI_PROTOCOL_FCP &&
++		     pp->sg_id.proto_id != SCSI_PROTOCOL_SAS &&
++		     pp->sg_id.proto_id != SCSI_PROTOCOL_ISCSI &&
++		     pp->sg_id.proto_id != SCSI_PROTOCOL_SRP)) {
+ 			/* return success as default path order
+ 			 * is maintained in path group
+ 			 */
+diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c
+index 36cc389e..5f4e0794 100644
+--- a/libmultipath/discovery.c
++++ b/libmultipath/discovery.c
+@@ -468,10 +468,11 @@ int sysfs_get_host_adapter_name(const struct path *pp, char *adapter_name)
+ 
+ 	proto_id = pp->sg_id.proto_id;
+ 
+-	if (proto_id != SCSI_PROTOCOL_FCP &&
+-	    proto_id != SCSI_PROTOCOL_SAS &&
+-	    proto_id != SCSI_PROTOCOL_ISCSI &&
+-	    proto_id != SCSI_PROTOCOL_SRP) {
++	if (pp->bus != SYSFS_BUS_SCSI ||
++	    (proto_id != SCSI_PROTOCOL_FCP &&
++	     proto_id != SCSI_PROTOCOL_SAS &&
++	     proto_id != SCSI_PROTOCOL_ISCSI &&
++	     proto_id != SCSI_PROTOCOL_SRP)) {
+ 		return 1;
+ 	}
+ 	/* iscsi doesn't have adapter info in sysfs
+@@ -1722,8 +1723,10 @@ sysfs_pathinfo(struct path * pp, vector hwtable)
+ 		pp->bus = SYSFS_BUS_CCISS;
+ 	if (!strncmp(pp->dev,"dasd", 4))
+ 		pp->bus = SYSFS_BUS_CCW;
+-	if (!strncmp(pp->dev,"sd", 2))
++	if (!strncmp(pp->dev,"sd", 2)) {
+ 		pp->bus = SYSFS_BUS_SCSI;
++		pp->sg_id.proto_id = SCSI_PROTOCOL_UNSPEC;
++	}
+ 	if (!strncmp(pp->dev,"nvme", 4))
+ 		pp->bus = SYSFS_BUS_NVME;
+ 
+diff --git a/libmultipath/print.c b/libmultipath/print.c
+index 8a6fbe83..8a85df66 100644
+--- a/libmultipath/print.c
++++ b/libmultipath/print.c
+@@ -558,7 +558,8 @@ snprint_host_attr (char * buff, size_t len, const struct path * pp, char *attr)
+ 	const char *value = NULL;
+ 	int ret;
+ 
+-	if (pp->sg_id.proto_id != SCSI_PROTOCOL_FCP)
++	if (pp->bus != SYSFS_BUS_SCSI ||
++	    pp->sg_id.proto_id != SCSI_PROTOCOL_FCP)
+ 		return snprintf(buff, len, "[undef]");
+ 	sprintf(host_id, "host%d", pp->sg_id.host_no);
+ 	host_dev = udev_device_new_from_subsystem_sysname(udev, "fc_host",
+@@ -597,7 +598,8 @@ snprint_tgt_wwpn (char * buff, size_t len, const struct path * pp)
+ 	const char *value = NULL;
+ 	int ret;
+ 
+-	if (pp->sg_id.proto_id != SCSI_PROTOCOL_FCP)
++	if (pp->bus != SYSFS_BUS_SCSI ||
++	    pp->sg_id.proto_id != SCSI_PROTOCOL_FCP)
+ 		return snprintf(buff, len, "[undef]");
+ 	sprintf(rport_id, "rport-%d:%d-%d",
+ 		pp->sg_id.host_no, pp->sg_id.channel, pp->sg_id.transport_id);
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index 84f9c959..1122cfae 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -115,7 +115,7 @@ alloc_path (void)
+ 		pp->sg_id.channel = -1;
+ 		pp->sg_id.scsi_id = -1;
+ 		pp->sg_id.lun = -1;
+-		pp->sg_id.proto_id = SCSI_PROTOCOL_UNSPEC;
++		pp->sg_id.proto_id = PROTOCOL_UNSET;
+ 		pp->fd = -1;
+ 		pp->tpgs = TPGS_UNDEF;
+ 		pp->priority = PRIO_UNDEF;
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index 9a404da7..960ea024 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -193,6 +193,8 @@ enum queue_mode_states {
+ 	QUEUE_MODE_RQ,
+ };
+ 
++#define PROTOCOL_UNSET -1
++
+ enum scsi_protocol {
+ 	SCSI_PROTOCOL_FCP = 0,	/* Fibre Channel */
+ 	SCSI_PROTOCOL_SPI = 1,	/* parallel SCSI */
+@@ -294,7 +296,7 @@ struct sg_id {
+ 	int lun;
+ 	short h_cmd_per_lun;
+ 	short d_queue_depth;
+-	enum scsi_protocol proto_id;
++	int proto_id;
+ 	int transport_id;
+ };
+ 
+diff --git a/multipathd/fpin_handlers.c b/multipathd/fpin_handlers.c
+index b14366d7..599f2893 100644
+--- a/multipathd/fpin_handlers.c
++++ b/multipathd/fpin_handlers.c
+@@ -220,7 +220,7 @@ static int  fpin_chk_wwn_setpath_marginal(uint16_t host_num,  struct vectors *ve
+ 
+ 	vector_foreach_slot(vecs->pathvec, pp, k) {
+ 		/* Checks the host number and also for the SCSI FCP */
+-		if (pp->sg_id.proto_id != SCSI_PROTOCOL_FCP || host_num !=  pp->sg_id.host_no)
++		if (pp->bus != SYSFS_BUS_SCSI || pp->sg_id.proto_id != SCSI_PROTOCOL_FCP || host_num !=  pp->sg_id.host_no)
+ 			continue;
+ 		sprintf(rport_id, "rport-%d:%d-%d",
+ 				pp->sg_id.host_no, pp->sg_id.channel, pp->sg_id.transport_id);

SOURCES/0123-libmultipath-get-nvme-path-transport-protocol.patch

@@ -0,0 +1,194 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:43 -0500
+Subject: [PATCH] libmultipath: get nvme path transport protocol
+
+Read the transport protocol from /sys/block/nvmeXnY/device/transport.
+Update protocol_name[] and bus_protocol_id() to store the nvme protocol
+names after the scsi protocol names.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/discovery.c   | 18 ++++++++++++++++--
+ libmultipath/structs.c     | 22 +++++++++++++++++-----
+ libmultipath/structs.h     | 33 +++++++++++++++++++++------------
+ multipath/multipath.conf.5 | 10 +++++++---
+ 4 files changed, 61 insertions(+), 22 deletions(-)
+
+diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c
+index 5f4e0794..eb7a634b 100644
+--- a/libmultipath/discovery.c
++++ b/libmultipath/discovery.c
+@@ -1455,6 +1455,7 @@ nvme_sysfs_pathinfo (struct path * pp, vector hwtable)
+ 	struct udev_device *parent;
+ 	const char *attr_path = NULL;
+ 	const char *attr;
++	int i;
+ 
+ 	attr_path = udev_device_get_sysname(pp->udev);
+ 	if (!attr_path)
+@@ -1476,6 +1477,18 @@ nvme_sysfs_pathinfo (struct path * pp, vector hwtable)
+ 	attr = udev_device_get_sysattr_value(parent, "cntlid");
+ 	pp->sg_id.channel = attr ? atoi(attr) : 0;
+ 
++	attr = udev_device_get_sysattr_value(parent, "transport");
++	if (attr) {
++		for (i = 0; i < NVME_PROTOCOL_UNSPEC; i++){
++			if (protocol_name[SYSFS_BUS_NVME + i] &&
++			    !strcmp(attr,
++				    protocol_name[SYSFS_BUS_NVME + i] + 5)) {
++				pp->sg_id.proto_id = i;
++				break;
++			}
++		}
++	}
++
+ 	snprintf(pp->vendor_id, SCSI_VENDOR_SIZE, "NVME");
+ 	snprintf(pp->product_id, PATH_PRODUCT_SIZE, "%s",
+ 		 udev_device_get_sysattr_value(parent, "model"));
+@@ -1727,9 +1740,10 @@ sysfs_pathinfo(struct path * pp, vector hwtable)
+ 		pp->bus = SYSFS_BUS_SCSI;
+ 		pp->sg_id.proto_id = SCSI_PROTOCOL_UNSPEC;
+ 	}
+-	if (!strncmp(pp->dev,"nvme", 4))
++	if (!strncmp(pp->dev,"nvme", 4)) {
+ 		pp->bus = SYSFS_BUS_NVME;
+-
++		pp->sg_id.proto_id = NVME_PROTOCOL_UNSPEC;
++	}
+ 	switch (pp->bus) {
+ 	case SYSFS_BUS_SCSI:
+ 		return scsi_sysfs_pathinfo(pp, hwtable);
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index 1122cfae..7bdf9152 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -25,7 +25,6 @@ const char * const protocol_name[LAST_BUS_PROTOCOL_ID + 1] = {
+ 	[SYSFS_BUS_UNDEF] = "undef",
+ 	[SYSFS_BUS_CCW] = "ccw",
+ 	[SYSFS_BUS_CCISS] = "cciss",
+-	[SYSFS_BUS_NVME] = "nvme",
+ 	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_FCP] = "scsi:fcp",
+ 	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SPI] = "scsi:spi",
+ 	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_SSA] = "scsi:ssa",
+@@ -37,6 +36,13 @@ const char * const protocol_name[LAST_BUS_PROTOCOL_ID + 1] = {
+ 	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_ATA] = "scsi:ata",
+ 	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_USB] = "scsi:usb",
+ 	[SYSFS_BUS_SCSI + SCSI_PROTOCOL_UNSPEC] = "scsi:unspec",
++	[SYSFS_BUS_NVME + NVME_PROTOCOL_PCIE] = "nvme:pcie",
++	[SYSFS_BUS_NVME + NVME_PROTOCOL_RDMA] = "nvme:rdma",
++	[SYSFS_BUS_NVME + NVME_PROTOCOL_FC] = "nvme:fc",
++	[SYSFS_BUS_NVME + NVME_PROTOCOL_TCP] = "nvme:tcp",
++	[SYSFS_BUS_NVME + NVME_PROTOCOL_LOOP] = "nvme:loop",
++	[SYSFS_BUS_NVME + NVME_PROTOCOL_APPLE_NVME] = "nvme:apple-nvme",
++	[SYSFS_BUS_NVME + NVME_PROTOCOL_UNSPEC] = "nvme:unspec",
+ };
+ 
+ struct adapter_group *
+@@ -716,11 +722,17 @@ out:
+ }
+ 
+ unsigned int bus_protocol_id(const struct path *pp) {
+-	if (!pp || pp->bus < 0 || pp->bus > SYSFS_BUS_SCSI)
++	if (!pp || pp->bus < 0 || pp->bus > SYSFS_BUS_NVME)
+ 		return SYSFS_BUS_UNDEF;
+-	if (pp->bus != SYSFS_BUS_SCSI)
++	if (pp->bus != SYSFS_BUS_SCSI && pp->bus != SYSFS_BUS_NVME)
+ 		return pp->bus;
+-	if ((int)pp->sg_id.proto_id < 0 || pp->sg_id.proto_id > SCSI_PROTOCOL_UNSPEC)
++	if (pp->sg_id.proto_id < 0)
+ 		return SYSFS_BUS_UNDEF;
+-	return SYSFS_BUS_SCSI + pp->sg_id.proto_id;
++	if (pp->bus == SYSFS_BUS_SCSI &&
++	    pp->sg_id.proto_id > SCSI_PROTOCOL_UNSPEC)
++		return SYSFS_BUS_UNDEF;
++	if (pp->bus == SYSFS_BUS_NVME &&
++	    pp->sg_id.proto_id > NVME_PROTOCOL_UNSPEC)
++		return SYSFS_BUS_UNDEF;
++	return pp->bus + pp->sg_id.proto_id;
+ }
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index 960ea024..9130efb5 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -57,15 +57,6 @@ enum failback_mode {
+ 	FAILBACK_FOLLOWOVER
+ };
+ 
+-/* SYSFS_BUS_SCSI should be last, see bus_protocol_id() */
+-enum sysfs_buses {
+-	SYSFS_BUS_UNDEF,
+-	SYSFS_BUS_CCW,
+-	SYSFS_BUS_CCISS,
+-	SYSFS_BUS_NVME,
+-	SYSFS_BUS_SCSI,
+-};
+-
+ enum pathstates {
+ 	PSTATE_UNDEF,
+ 	PSTATE_FAILED,
+@@ -207,14 +198,32 @@ enum scsi_protocol {
+ 	SCSI_PROTOCOL_ATA = 8,
+ 	SCSI_PROTOCOL_USB = 9,  /* USB Attached SCSI (UAS), and others */
+ 	SCSI_PROTOCOL_UNSPEC = 0xa, /* No specific protocol */
++	SCSI_PROTOCOL_END = 0xb, /* offset of the next sysfs_buses entry */
++};
++
++/* values from /sys/class/nvme/nvmeX */
++enum nvme_protocol {
++	NVME_PROTOCOL_PCIE = 0,
++	NVME_PROTOCOL_RDMA = 1,
++	NVME_PROTOCOL_FC = 2,
++	NVME_PROTOCOL_TCP = 3,
++	NVME_PROTOCOL_LOOP = 4,
++	NVME_PROTOCOL_APPLE_NVME = 5,
++	NVME_PROTOCOL_UNSPEC = 6, /* unknown protocol */
++};
++
++enum sysfs_buses {
++	SYSFS_BUS_UNDEF,
++	SYSFS_BUS_CCW,
++	SYSFS_BUS_CCISS,
++	SYSFS_BUS_SCSI,
++	SYSFS_BUS_NVME = SYSFS_BUS_SCSI + SCSI_PROTOCOL_END,
+ };
+ 
+ /*
+  * Linear ordering of bus/protocol
+- * This assumes that SYSFS_BUS_SCSI is last in enum sysfs_buses
+- * SCSI is the only bus type for which we distinguish protocols.
+  */
+-#define LAST_BUS_PROTOCOL_ID (SYSFS_BUS_SCSI + SCSI_PROTOCOL_UNSPEC)
++#define LAST_BUS_PROTOCOL_ID (SYSFS_BUS_NVME + NVME_PROTOCOL_UNSPEC)
+ unsigned int bus_protocol_id(const struct path *pp);
+ extern const char * const protocol_name[];
+ 
+diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5
+index 61d2712b..1f5a40b6 100644
+--- a/multipath/multipath.conf.5
++++ b/multipath/multipath.conf.5
+@@ -1369,7 +1369,9 @@ Regular expression for the protocol of a device to be excluded/included.
+ The protocol strings that multipath recognizes are \fIscsi:fcp\fR,
+ \fIscsi:spi\fR, \fIscsi:ssa\fR, \fIscsi:sbp\fR, \fIscsi:srp\fR,
+ \fIscsi:iscsi\fR, \fIscsi:sas\fR, \fIscsi:adt\fR, \fIscsi:ata\fR,
+-\fIscsi:unspec\fR, \fIccw\fR, \fIcciss\fR, \fInvme\fR, and \fIundef\fR.
++\fIscsi:unspec\fR, \fInvme:pcie\fR, \fInvme:rdma\fR, \fInvme:fc\fR,
++\fInvme:tcp\fR, \fInvme:loop\fR, \fInvme:apple-nvme\fR, \fInvme:unspec\fR,
++\fIccw\fR, \fIcciss\fR, and \fIundef\fR.
+ The protocol that a path is using can be viewed by running
+ \fBmultipathd show paths format "%d %P"\fR
+ .RE
+@@ -1757,8 +1759,10 @@ The protocol subsection recognizes the following mandatory attribute:
+ The protocol string of the path device. The possible values are \fIscsi:fcp\fR,
+ \fIscsi:spi\fR, \fIscsi:ssa\fR, \fIscsi:sbp\fR, \fIscsi:srp\fR,
+ \fIscsi:iscsi\fR, \fIscsi:sas\fR, \fIscsi:adt\fR, \fIscsi:ata\fR,
+-\fIscsi:unspec\fR, \fIccw\fR, \fIcciss\fR, \fInvme\fR, and \fIundef\fR. This is
+-\fBnot\fR a regular expression. the path device protcol string must match
++\fIscsi:unspec\fR, \fInvme:pcie\fR, \fInvme:rdma\fR, \fInvme:fc\fR,
++\fInvme:tcp\fR, \fInvme:loop\fR, \fInvme:apple-nvme\fR, \fInvme:unspec\fR,
++\fIccw\fR, \fIcciss\fR, and \fIundef\fR. This is
++\fBnot\fR a regular expression. the path device protocol string must match
+ exactly. The protocol that a path is using can be viewed by running
+ \fBmultipathd show paths format "%d %P"\fR
+ .LP

SOURCES/0124-libmultipath-enforce-queue_mode-bio-for-nmve-tcp-pat.patch

@@ -0,0 +1,111 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Fri, 7 Oct 2022 12:35:44 -0500
+Subject: [PATCH] libmultipath: enforce queue_mode bio for nmve:tcp paths
+
+nvme:tcp devices set BLK_MQ_F_BLOCKING (they are the only block devices
+which multipath supports that do so), meaning that block_mq expects that
+they can block at certain points while servicing a request.  However,
+due to the way device-mapper sets up its queue, it is not able to set
+BLK_MQ_F_BLOCKING when it includes paths that set this flag.  Patches
+were written to address this issue but they were rejected upstream
+
+https://lore.kernel.org/linux-block/YcH%2FE4JNag0QYYAa@infradead.org/T/#t
+
+The proposed solution was to have multipath use the bio queue_mode for
+multipath devices that include nvme:tcp paths.
+
+Multipath devices now automatically add the "queue_mode bio" feature if
+they include nvme:tcp paths.  If a multipath devices was created with
+"queue_mode rq", it will disallow the addition of nvme:tcp paths.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/configure.c   | 17 ++++++++++++++++-
+ libmultipath/structs_vec.c |  7 +++++++
+ multipath/multipath.conf.5 |  4 +++-
+ 3 files changed, 26 insertions(+), 2 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index 8e1bc488..c341793c 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -297,6 +297,7 @@ int setup_map(struct multipath *mpp, char *params, int params_size,
+ 	      struct vectors *vecs)
+ {
+ 	struct pathgroup * pgp;
++	struct path *pp;
+ 	struct config *conf;
+ 	int i, n_paths, marginal_pathgroups;
+ 
+@@ -308,6 +309,14 @@ int setup_map(struct multipath *mpp, char *params, int params_size,
+ 		return 1;
+ 	}
+ 
++	/* Force QUEUE_MODE_BIO for maps with nvme:tcp paths */
++	vector_foreach_slot(mpp->paths, pp, i) {
++		if (pp->bus == SYSFS_BUS_NVME &&
++		    pp->sg_id.proto_id == NVME_PROTOCOL_TCP) {
++			mpp->queue_mode = QUEUE_MODE_BIO;
++			break;
++		}
++	}
+ 	/*
+ 	 * free features, selector, and hwhandler properties if they are being reused
+ 	 */
+@@ -1161,6 +1170,13 @@ int coalesce_paths (struct vectors * vecs, vector newmp, char * refwwid,
+ 			continue;
+ 		}
+ 
++		cmpp = find_mp_by_wwid(curmp, pp1->wwid);
++		if (cmpp && cmpp->queue_mode == QUEUE_MODE_RQ &&
++		    pp1->bus == SYSFS_BUS_NVME && pp1->sg_id.proto_id ==
++		    NVME_PROTOCOL_TCP) {
++			orphan_path(pp1, "nvme:tcp path not allowed with request queue_mode multipath device");
++			continue;
++		}
+ 		/*
+ 		 * at this point, we know we really got a new mp
+ 		 */
+@@ -1199,7 +1215,6 @@ int coalesce_paths (struct vectors * vecs, vector newmp, char * refwwid,
+ 		}
+ 		verify_paths(mpp, vecs);
+ 
+-		cmpp = find_mp_by_wwid(curmp, mpp->wwid);
+ 		if (cmpp)
+ 			mpp->queue_mode = cmpp->queue_mode;
+ 		params[0] = '\0';
+diff --git a/libmultipath/structs_vec.c b/libmultipath/structs_vec.c
+index 8137ea21..24ac022e 100644
+--- a/libmultipath/structs_vec.c
++++ b/libmultipath/structs_vec.c
+@@ -68,6 +68,13 @@ int adopt_paths(vector pathvec, struct multipath *mpp)
+ 					pp->dev, mpp->alias);
+ 				continue;
+ 			}
++			if (mpp->queue_mode == QUEUE_MODE_RQ &&
++			    pp->bus == SYSFS_BUS_NVME &&
++			    pp->sg_id.proto_id == NVME_PROTOCOL_TCP) {
++				condlog(2, "%s: mulitpath device %s created with request queue_mode. Unable to add nvme:tcp paths",
++					pp->dev, mpp->alias);
++				continue;
++			}
+ 			condlog(3, "%s: ownership set to %s",
+ 				pp->dev, mpp->alias);
+ 			pp->mpp = mpp;
+diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5
+index 1f5a40b6..cb07a62c 100644
+--- a/multipath/multipath.conf.5
++++ b/multipath/multipath.conf.5
+@@ -462,7 +462,9 @@ Before kernel 4.20 The default depends on the kernel parameter
+ \fBdm_mod.use_blk_mq\fR. It is \fImq\fR if the latter is set, and \fIrq\fR
+ otherwise. Since kernel 4.20, \fIrq\fR and \fImq\fR both correspond to
+ block-multiqueue. Once a multipath device has been created, its queue_mode
+-cannot be changed.
++cannot be changed. \fInvme:tcp\fR paths are only supported in multipath
++devices with queue_mode set to \fIbio\fR. multipath will automatically
++set this when creating a device with \fInvme:tcp\fR paths.
+ .TP
+ The default is: \fB<unset>\fR
+ .RE

SOURCES/0125-multipath-add-historical-service-time-to-the-man-pag.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 15 Nov 2022 09:01:36 -0600
+Subject: [PATCH] multipath: add historical-service-time to the man page
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ multipath/multipath.conf.5 | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/multipath/multipath.conf.5 b/multipath/multipath.conf.5
+index cb07a62c..d8a98435 100644
+--- a/multipath/multipath.conf.5
++++ b/multipath/multipath.conf.5
+@@ -205,6 +205,11 @@ of outstanding I/O to the path.
+ (Since 2.6.31 kernel) Choose the path for the next bunch of I/O based on the amount
+ of outstanding I/O to the path and its relative throughput.
+ .TP
++.I "historical-service-time 0"
++(Since 4.18.0-305.3.el8 kernel) Choose the path for the next bunch of I/O based
++on the estimation of future service time based on the history of previous I/O
++submitted to each path.
++.TP
+ The default is: \fBservice-time 0\fR
+ .RE
+ .

SOURCES/0126-libmultipath-copy-mpp-hwe-from-pp-hwe.patch

@@ -0,0 +1,215 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martin Wilck <mwilck@suse.com>
+Date: Wed, 16 Sep 2020 22:22:36 +0200
+Subject: [PATCH] libmultipath: copy mpp->hwe from pp->hwe
+
+Since f0462f0 ("libmultipath: use vector for for pp->hwe and mp->hwe"),
+we've been trying to fix issues caused by paths getting freed and mpp->hwe
+dangling. This approach couldn't work because we need mpp->hwe to persist,
+even if all paths are removed from the map. Before f0462f0, a simple
+assignment worked, because the lifetime of the hwe wasn't bound to the
+path. But now, we need to copy the vector. It turns out that we need to set
+mpp->hwe only in two places, add_map_with_path() and setup_map(), and
+that the code is simplified overall.
+
+Even now, it can happen that a map is added with add_map_without_paths(),
+and has no paths. In that case, calling do_set_from_hwe() with a NULL
+pointer is not a bug, so remove the message.
+
+Fixes: f0462f0 ("libmultipath: use vector for for pp->hwe and mp->hwe")
+Reviewed-by: Benjamin Marzinski <bmarzins@redhat.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/configure.c   |  8 ++++++++
+ libmultipath/propsel.c     |  2 +-
+ libmultipath/structs.c     | 15 ++++++++++++++
+ libmultipath/structs.h     |  1 +
+ libmultipath/structs_vec.c | 41 +++++++++++++++++++-------------------
+ multipathd/main.c          | 10 ----------
+ 6 files changed, 45 insertions(+), 32 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index c341793c..6e06fea2 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -324,6 +324,14 @@ int setup_map(struct multipath *mpp, char *params, int params_size,
+ 	if (mpp->disable_queueing && VECTOR_SIZE(mpp->paths) != 0)
+ 		mpp->disable_queueing = 0;
+ 
++	/*
++	 * If this map was created with add_map_without_path(),
++	 * mpp->hwe might not be set yet.
++	 */
++	if (!mpp->hwe)
++		extract_hwe_from_path(mpp);
++
++
+ 	/*
+ 	 * properties selectors
+ 	 *
+diff --git a/libmultipath/propsel.c b/libmultipath/propsel.c
+index 3f119dd9..bc5c27ab 100644
+--- a/libmultipath/propsel.c
++++ b/libmultipath/propsel.c
+@@ -66,7 +66,7 @@ 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 && __do_set_from_hwe(var, src, dest)) {		\
+ 		origin = msg;						\
+ 		goto out;						\
+ 	}
+diff --git a/libmultipath/structs.c b/libmultipath/structs.c
+index 7bdf9152..5bb6caf8 100644
+--- a/libmultipath/structs.c
++++ b/libmultipath/structs.c
+@@ -242,6 +242,17 @@ alloc_multipath (void)
+ 	return mpp;
+ }
+ 
++void *set_mpp_hwe(struct multipath *mpp, const struct path *pp)
++{
++	if (!mpp || !pp || !pp->hwe)
++		return NULL;
++	if (mpp->hwe)
++		return mpp->hwe;
++	mpp->hwe = vector_convert(NULL, pp->hwe,
++				  struct hwentry, identity);
++	return mpp->hwe;
++}
++
+ void free_multipath_attributes(struct multipath *mpp)
+ {
+ 	if (!mpp)
+@@ -283,6 +294,10 @@ free_multipath (struct multipath * mpp, enum free_path_mode free_paths)
+ 
+ 	free_pathvec(mpp->paths, free_paths);
+ 	free_pgvec(mpp->pg, free_paths);
++	if (mpp->hwe) {
++		vector_free(mpp->hwe);
++		mpp->hwe = NULL;
++	}
+ 	FREE_PTR(mpp->mpcontext);
+ 	FREE(mpp);
+ }
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index 9130efb5..44980b4e 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -499,6 +499,7 @@ struct host_group {
+ struct path * alloc_path (void);
+ struct pathgroup * alloc_pathgroup (void);
+ struct multipath * alloc_multipath (void);
++void *set_mpp_hwe(struct multipath *mpp, const struct path *pp);
+ void free_path (struct path *);
+ void free_pathvec (vector vec, enum free_path_mode free_paths);
+ void free_pathgroup (struct pathgroup * pgp, enum free_path_mode free_paths);
+diff --git a/libmultipath/structs_vec.c b/libmultipath/structs_vec.c
+index 24ac022e..9613252f 100644
+--- a/libmultipath/structs_vec.c
++++ b/libmultipath/structs_vec.c
+@@ -180,24 +180,24 @@ extract_hwe_from_path(struct multipath * mpp)
+ 	if (mpp->hwe || !mpp->paths)
+ 		return;
+ 
+-	condlog(3, "%s: searching paths for valid hwe", mpp->alias);
++	condlog(4, "%s: searching paths for valid hwe", mpp->alias);
+ 	/* doing this in two passes seems like paranoia to me */
+ 	vector_foreach_slot(mpp->paths, pp, i) {
+-		if (pp->state != PATH_UP)
+-			continue;
+-		if (pp->hwe) {
+-			mpp->hwe = pp->hwe;
+-			return;
+-		}
++		if (pp->state == PATH_UP && pp->hwe)
++			goto done;
+ 	}
+ 	vector_foreach_slot(mpp->paths, pp, i) {
+-		if (pp->state == PATH_UP)
+-			continue;
+-		if (pp->hwe) {
+-			mpp->hwe = pp->hwe;
+-			return;
+-		}
++		if (pp->state != PATH_UP && pp->hwe)
++			goto done;
+ 	}
++done:
++	if (i < VECTOR_SIZE(mpp->paths))
++		(void)set_mpp_hwe(mpp, pp);
++
++	if (mpp->hwe)
++		condlog(3, "%s: got hwe from path %s", mpp->alias, pp->dev);
++	else
++		condlog(2, "%s: no hwe found", mpp->alias);
+ }
+ 
+ int
+@@ -445,9 +445,15 @@ struct multipath *add_map_with_path(struct vectors *vecs, struct path *pp,
+ 
+ 	conf = get_multipath_config();
+ 	mpp->mpe = find_mpe(conf->mptable, pp->wwid);
+-	mpp->hwe = pp->hwe;
+ 	put_multipath_config(conf);
+ 
++	/*
++	 * We need to call this before select_alias(),
++	 * because that accesses hwe properties.
++	 */
++	if (pp->hwe && !set_mpp_hwe(mpp, pp))
++		goto out;
++
+ 	strcpy(mpp->wwid, pp->wwid);
+ 	find_existing_alias(mpp, vecs);
+ 	if (select_alias(conf, mpp))
+@@ -497,12 +503,6 @@ int verify_paths(struct multipath *mpp, struct vectors *vecs)
+ 			vector_del_slot(mpp->paths, i);
+ 			i--;
+ 
+-			/* Make sure mpp->hwe doesn't point to freed memory.
+-			 * We call extract_hwe_from_path() below to restore
+-			 * mpp->hwe
+-			 */
+-			if (mpp->hwe == pp->hwe)
+-				mpp->hwe = NULL;
+ 			if ((j = find_slot(vecs->pathvec,
+ 					   (void *)pp)) != -1)
+ 				vector_del_slot(vecs->pathvec, j);
+@@ -512,7 +512,6 @@ int verify_paths(struct multipath *mpp, struct vectors *vecs)
+ 				mpp->alias, pp->dev, pp->dev_t);
+ 		}
+ 	}
+-	extract_hwe_from_path(mpp);
+ 	return count;
+ }
+ 
+diff --git a/multipathd/main.c b/multipathd/main.c
+index cd68a9d2..769dcaee 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -1198,13 +1198,6 @@ ev_remove_path (struct path *pp, struct vectors * vecs, int need_do_map)
+ 			goto fail;
+ 		}
+ 
+-		/*
+-		 * Make sure mpp->hwe doesn't point to freed memory
+-		 * We call extract_hwe_from_path() below to restore mpp->hwe
+-		 */
+-		if (mpp->hwe == pp->hwe)
+-			mpp->hwe = NULL;
+-
+ 		if ((i = find_slot(mpp->paths, (void *)pp)) != -1)
+ 			vector_del_slot(mpp->paths, i);
+ 
+@@ -1216,9 +1209,6 @@ ev_remove_path (struct path *pp, struct vectors * vecs, int need_do_map)
+ 		    flush_map_nopaths(mpp, vecs))
+ 			goto out;
+ 
+-		if (mpp->hwe == NULL)
+-			extract_hwe_from_path(mpp);
+-
+ 		if (setup_map(mpp, params, PARAMS_SIZE, vecs)) {
+ 			condlog(0, "%s: failed to setup map for"
+ 				" removal of path %s", mpp->alias, pp->dev);

SOURCES/0127-libmultipath-don-t-leak-memory-on-invalid-strings.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 14 Dec 2022 15:38:19 -0600
+Subject: [PATCH] libmultipath: don't leak memory on invalid strings
+
+If set_path() or set_str_noslash() are called with a bad value, they
+ignore it and continue to use the old value. But they weren't freeing
+the bad value, causing a memory leak.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/dict.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/libmultipath/dict.c b/libmultipath/dict.c
+index d7cd94a5..a8c9e989 100644
+--- a/libmultipath/dict.c
++++ b/libmultipath/dict.c
+@@ -169,6 +169,7 @@ set_path(vector strvec, void *ptr, const char *file, int line_nr)
+ 	if ((*str_ptr)[0] != '/'){
+ 		condlog(1, "%s line %d, %s is not an absolute path. Ignoring",
+ 			file, line_nr, *str_ptr);
++		free(*str_ptr);
+ 		*str_ptr = old_str;
+ 	} else
+ 		free(old_str);
+@@ -189,6 +190,7 @@ set_str_noslash(vector strvec, void *ptr, const char *file, int line_nr)
+ 	if (strchr(*str_ptr, '/')) {
+ 		condlog(1, "%s line %d, %s cannot contain a slash. Ignoring",
+ 			file, line_nr, *str_ptr);
++		free(*str_ptr);
+ 		*str_ptr = old_str;
+ 	} else
+ 		free(old_str);

SOURCES/0128-libmutipath-validate-the-argument-count-of-config-st.patch

@@ -0,0 +1,195 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 14 Dec 2022 15:38:20 -0600
+Subject: [PATCH] libmutipath: validate the argument count of config strings
+
+The features, path_selector, and hardware_handler config options pass
+their strings directly into the kernel.  If users omit the argument
+counts from these strings, or use the wrong value, the kernel's table
+parsing gets completely messed up, and the error messages it prints
+don't reflect what actully went wrong. To avoid messing up the
+kernel table parsing, verify that these strings correctly set the
+argument count to the number of arguments they have.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmultipath/dict.c | 110 ++++++++++++++++++++++++++++++++++++++++----
+ 1 file changed, 101 insertions(+), 9 deletions(-)
+
+diff --git a/libmultipath/dict.c b/libmultipath/dict.c
+index a8c9e989..952b33d0 100644
+--- a/libmultipath/dict.c
++++ b/libmultipath/dict.c
+@@ -155,6 +155,58 @@ set_dir(vector strvec, void *ptr, const char *file, int line_nr)
+ 	return 0;
+ }
+ 
++static int
++set_arg_str(vector strvec, void *ptr, int count_idx, const char *file,
++	    int line_nr)
++{
++	char **str_ptr = (char **)ptr;
++	char *old_str = *str_ptr;
++	const char * const spaces = " \f\r\t\v";
++	char *p, *end;
++	int idx = -1;
++	long int count = -1;
++
++	*str_ptr = set_value(strvec);
++	if (!*str_ptr) {
++		free(old_str);
++		return 1;
++	}
++	p = *str_ptr;
++	while (*p != '\0') {
++		p += strspn(p, spaces);
++		if (*p == '\0')
++			break;
++		idx += 1;
++		if (idx == count_idx) {
++			errno = 0;
++			count = strtol(p, &end, 10);
++			if (errno == ERANGE || end == p ||
++			    !(isspace(*end) || *end == '\0')) {
++				count = -1;
++				break;
++			}
++		}
++		p += strcspn(p, spaces);
++	}
++	if (count < 0) {
++		condlog(1, "%s line %d, missing argument count for %s",
++			file, line_nr, (char*)VECTOR_SLOT(strvec, 0));
++		goto fail;
++	}
++	if (count != idx - count_idx) {
++		condlog(1, "%s line %d, invalid argument count for %s:, got '%ld' expected '%d'",
++			file, line_nr, (char*)VECTOR_SLOT(strvec, 0), count,
++			idx - count_idx);
++		goto fail;
++	}
++	free(old_str);
++	return 0;
++fail:
++	free(*str_ptr);
++	*str_ptr = old_str;
++	return 0;
++}
++
+ static int
+ set_path(vector strvec, void *ptr, const char *file, int line_nr)
+ {
+@@ -337,6 +389,14 @@ def_ ## option ## _handler (struct config *conf, vector strvec,         \
+ 	return set_int(strvec, &conf->option, minval, maxval, file, line_nr); \
+ }
+ 
++#define declare_def_arg_str_handler(option, count_idx)			\
++static int								\
++def_ ## option ## _handler (struct config *conf, vector strvec,		\
++			    const char *file, int line_nr)		\
++{									\
++	return set_arg_str(strvec, &conf->option, count_idx, file, line_nr); \
++}
++
+ #define declare_def_snprint(option, function)				\
+ static int								\
+ snprint_def_ ## option (struct config *conf, char * buff, int len,	\
+@@ -389,6 +449,17 @@ hw_ ## option ## _handler (struct config *conf, vector strvec,		\
+ 	return set_int(strvec, &hwe->option, minval, maxval, file, line_nr); \
+ }
+ 
++#define declare_hw_arg_str_handler(option, count_idx)			\
++static int								\
++hw_ ## option ## _handler (struct config *conf, vector strvec,		\
++			    const char *file, int line_nr)		\
++{									\
++	struct hwentry * hwe = VECTOR_LAST_SLOT(conf->hwtable);		\
++	if (!hwe)							\
++		return 1;						\
++	return set_arg_str(strvec, &hwe->option, count_idx, file, line_nr); \
++}
++
+ 
+ #define declare_hw_snprint(option, function)				\
+ static int								\
+@@ -420,6 +491,16 @@ ovr_ ## option ## _handler (struct config *conf, vector strvec,		\
+ 		       file, line_nr); \
+ }
+ 
++#define declare_ovr_arg_str_handler(option, count_idx)			\
++static int								\
++ovr_ ## option ## _handler (struct config *conf, vector strvec,		\
++			    const char *file, int line_nr)		\
++{									\
++	if (!conf->overrides)						\
++		return 1;						\
++	return set_arg_str(strvec, &conf->overrides->option, count_idx, file, line_nr); \
++}
++
+ #define declare_ovr_snprint(option, function)				\
+ static int								\
+ snprint_ovr_ ## option (struct config *conf, char * buff, int len,	\
+@@ -450,6 +531,17 @@ mp_ ## option ## _handler (struct config *conf, vector strvec,		\
+ 	return set_int(strvec, &mpe->option, minval, maxval, file, line_nr); \
+ }
+ 
++#define declare_mp_arg_str_handler(option, count_idx)			\
++static int								\
++mp_ ## option ## _handler (struct config *conf, vector strvec,		\
++			    const char *file, int line_nr)		\
++{									\
++	struct mpentry * mpe = VECTOR_LAST_SLOT(conf->mptable);		\
++	if (!mpe)							\
++		return 1;						\
++	return set_arg_str(strvec, &mpe->option, count_idx, file, line_nr); \
++}
++
+ #define declare_mp_snprint(option, function)				\
+ static int								\
+ snprint_mp_ ## option (struct config *conf, char * buff, int len,	\
+@@ -634,13 +726,13 @@ snprint_def_marginal_pathgroups(struct config *conf, char *buff, int len,
+ }
+ 
+ 
+-declare_def_handler(selector, set_str)
++declare_def_arg_str_handler(selector, 1)
+ declare_def_snprint_defstr(selector, print_str, DEFAULT_SELECTOR)
+-declare_hw_handler(selector, set_str)
++declare_hw_arg_str_handler(selector, 1)
+ declare_hw_snprint(selector, print_str)
+-declare_ovr_handler(selector, set_str)
++declare_ovr_arg_str_handler(selector, 1)
+ declare_ovr_snprint(selector, print_str)
+-declare_mp_handler(selector, set_str)
++declare_mp_arg_str_handler(selector, 1)
+ declare_mp_snprint(selector, print_str)
+ 
+ static int snprint_uid_attrs(struct config *conf, char *buff, int len,
+@@ -717,13 +809,13 @@ declare_hw_snprint(prio_args, print_str)
+ declare_mp_handler(prio_args, set_str)
+ declare_mp_snprint(prio_args, print_str)
+ 
+-declare_def_handler(features, set_str)
++declare_def_arg_str_handler(features, 0)
+ declare_def_snprint_defstr(features, print_str, DEFAULT_FEATURES)
+-declare_ovr_handler(features, set_str)
++declare_ovr_arg_str_handler(features, 0)
+ declare_ovr_snprint(features, print_str)
+-declare_hw_handler(features, set_str)
++declare_hw_arg_str_handler(features, 0)
+ declare_hw_snprint(features, print_str)
+-declare_mp_handler(features, set_str)
++declare_mp_arg_str_handler(features, 0)
+ declare_mp_snprint(features, print_str)
+ 
+ declare_def_handler(checker_name, set_str)
+@@ -1894,7 +1986,7 @@ declare_hw_snprint(revision, print_str)
+ declare_hw_handler(bl_product, set_regex)
+ declare_hw_snprint(bl_product, print_str)
+ 
+-declare_hw_handler(hwhandler, set_str)
++declare_hw_arg_str_handler(hwhandler, 0)
+ declare_hw_snprint(hwhandler, print_str)
+ 
+ /*

SOURCES/0129-libmultipath-select-resize-action-even-if-reload-is-.patch

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 31 Jan 2023 09:58:55 -0600
+Subject: [PATCH] libmultipath: select resize action even if reload is forced
+
+The ACT_RESIZE action is the same as the ACT_RELOAD action, except that
+it flushes outstanding IO because the device size is changing and
+the new size might be too small for some of the outstanding IO. If we've
+detected a size change, and a forced reload is requested, we still need
+to flush the IO because the reload will change the device size.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/configure.c | 13 +++++++------
+ 1 file changed, 7 insertions(+), 6 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index 6e06fea2..ecf24f95 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -734,17 +734,18 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 		return;
+ 	}
+ 
+-	if (force_reload) {
++	if (cmpp->size != mpp->size) {
+ 		mpp->force_udev_reload = 1;
+-		mpp->action = ACT_RELOAD;
+-		condlog(3, "%s: set ACT_RELOAD (forced by user)",
++		mpp->action = ACT_RESIZE;
++		condlog(3, "%s: set ACT_RESIZE (size change)",
+ 			mpp->alias);
+ 		return;
+ 	}
+-	if (cmpp->size != mpp->size) {
++
++	if (force_reload) {
+ 		mpp->force_udev_reload = 1;
+-		mpp->action = ACT_RESIZE;
+-		condlog(3, "%s: set ACT_RESIZE (size change)",
++		mpp->action = ACT_RELOAD;
++		condlog(3, "%s: set ACT_RELOAD (forced by user)",
+ 			mpp->alias);
+ 		return;
+ 	}

SOURCES/0130-libmultipath-cleanup-ACT_CREATE-code-in-select_actio.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 31 Jan 2023 10:35:10 -0600
+Subject: [PATCH] libmultipath: cleanup ACT_CREATE code in select_action
+
+Combine the two separate blocks that set ACT_CREATE into one.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/configure.c | 38 +++++++++++++++++---------------------
+ 1 file changed, 17 insertions(+), 21 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index ecf24f95..303d2380 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -693,33 +693,29 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 	cmpp = find_mp_by_wwid(curmp, mpp->wwid);
+ 	cmpp_by_name = find_mp_by_alias(curmp, mpp->alias);
+ 
+-	if (!cmpp_by_name) {
+-		if (cmpp) {
+-			condlog(2, "%s: rename %s to %s", mpp->wwid,
+-				cmpp->alias, mpp->alias);
+-			strlcpy(mpp->alias_old, cmpp->alias, WWID_SIZE);
+-			mpp->action = ACT_RENAME;
+-			if (force_reload) {
+-				mpp->force_udev_reload = 1;
+-				mpp->action = ACT_FORCERENAME;
+-			}
+-			return;
++	if (!cmpp) {
++		if (cmpp_by_name) {
++			condlog(1, "%s: can't use alias \"%s\" used by %s, falling back to WWID",
++				mpp->wwid, mpp->alias, cmpp_by_name->wwid);
++			/* We can do this because wwid wasn't found */
++			free(mpp->alias);
++			mpp->alias = strdup(mpp->wwid);
+ 		}
+ 		mpp->action = ACT_CREATE;
+-		condlog(3, "%s: set ACT_CREATE (map does not exist)",
+-			mpp->alias);
++		condlog(3, "%s: set ACT_CREATE (map does not exist%s)",
++			mpp->alias, cmpp_by_name ? ", name changed" : "");
+ 		return;
+ 	}
+ 
+-	if (!cmpp) {
+-		condlog(1, "%s: can't use alias \"%s\" used by %s, falling back to WWID",
+-			mpp->wwid, mpp->alias, cmpp_by_name->wwid);
+-		/* We can do this because wwid wasn't found */
+-		free(mpp->alias);
+-		mpp->alias = strdup(mpp->wwid);
+-		mpp->action = ACT_CREATE;
+-		condlog(3, "%s: set ACT_CREATE (map does not exist, name changed)",
++	if (!cmpp_by_name) {
++		condlog(2, "%s: rename %s to %s", mpp->wwid, cmpp->alias,
+ 			mpp->alias);
++		strlcpy(mpp->alias_old, cmpp->alias, WWID_SIZE);
++		mpp->action = ACT_RENAME;
++		if (force_reload) {
++			mpp->force_udev_reload = 1;
++			mpp->action = ACT_FORCERENAME;
++		}
+ 		return;
+ 	}
+ 

SOURCES/0131-libmultipath-keep-renames-from-stopping-other-multip.patch

@@ -0,0 +1,270 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 31 Jan 2023 12:00:31 -0600
+Subject: [PATCH] libmultipath: keep renames from stopping other multipath
+ actions
+
+If select_action() is called and a multipath device needs to be renamed,
+the code currently checks if force_reload is set, and if so, does the
+reload after the rename.  But if force_reload isn't set, only the rename
+happens, regardless of what other actions are needed. This can happen if
+multipathd starts up and a device needs both a reload and a rename.
+
+Make multipath check for resize, reload, and switch pathgroup along with
+rename, and do both if necessary.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/configure.c | 92 +++++++++++++++++++++-------------------
+ libmultipath/configure.h |  4 +-
+ 2 files changed, 51 insertions(+), 45 deletions(-)
+
+diff --git a/libmultipath/configure.c b/libmultipath/configure.c
+index 303d2380..65a0b208 100644
+--- a/libmultipath/configure.c
++++ b/libmultipath/configure.c
+@@ -690,6 +690,7 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 	struct multipath * cmpp_by_name;
+ 	char * mpp_feat, * cmpp_feat;
+ 
++	mpp->action = ACT_NOTHING;
+ 	cmpp = find_mp_by_wwid(curmp, mpp->wwid);
+ 	cmpp_by_name = find_mp_by_alias(curmp, mpp->alias);
+ 
+@@ -712,14 +713,8 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 			mpp->alias);
+ 		strlcpy(mpp->alias_old, cmpp->alias, WWID_SIZE);
+ 		mpp->action = ACT_RENAME;
+-		if (force_reload) {
+-			mpp->force_udev_reload = 1;
+-			mpp->action = ACT_FORCERENAME;
+-		}
+-		return;
+-	}
+-
+-	if (cmpp != cmpp_by_name) {
++		/* don't return here. Check for other needed actions */
++	} else if (cmpp != cmpp_by_name) {
+ 		condlog(2, "%s: unable to rename %s to %s (%s is used by %s)",
+ 			mpp->wwid, cmpp->alias, mpp->alias,
+ 			mpp->alias, cmpp_by_name->wwid);
+@@ -727,12 +722,13 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 		FREE(mpp->alias);
+ 		mpp->alias = STRDUP(cmpp->alias);
+ 		mpp->action = ACT_IMPOSSIBLE;
+-		return;
++		/* don't return here. Check for other needed actions */
+ 	}
+ 
+ 	if (cmpp->size != mpp->size) {
+ 		mpp->force_udev_reload = 1;
+-		mpp->action = ACT_RESIZE;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RESIZE_RENAME :
++			      ACT_RESIZE;
+ 		condlog(3, "%s: set ACT_RESIZE (size change)",
+ 			mpp->alias);
+ 		return;
+@@ -740,7 +736,8 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 
+ 	if (force_reload) {
+ 		mpp->force_udev_reload = 1;
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (forced by user)",
+ 			mpp->alias);
+ 		return;
+@@ -749,7 +746,8 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 	if (mpp->no_path_retry != NO_PATH_RETRY_UNDEF &&
+ 	    !!strstr(mpp->features, "queue_if_no_path") !=
+ 	    !!strstr(cmpp->features, "queue_if_no_path")) {
+-		mpp->action =  ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (no_path_retry change)",
+ 			mpp->alias);
+ 		return;
+@@ -759,7 +757,8 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 	    (strlen(cmpp->hwhandler) != strlen(mpp->hwhandler) ||
+ 	     strncmp(cmpp->hwhandler, mpp->hwhandler,
+ 		    strlen(mpp->hwhandler)))) {
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (hwhandler change)",
+ 			mpp->alias);
+ 		return;
+@@ -769,7 +768,8 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 	    !!strstr(mpp->features, "retain_attached_hw_handler") !=
+ 	    !!strstr(cmpp->features, "retain_attached_hw_handler") &&
+ 	    get_linux_version_code() < KERNEL_VERSION(4, 3, 0)) {
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (retain_hwhandler change)",
+ 			mpp->alias);
+ 		return;
+@@ -783,9 +783,13 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 		remove_feature(&cmpp_feat, "queue_if_no_path");
+ 		remove_feature(&cmpp_feat, "retain_attached_hw_handler");
+ 		if (strncmp(mpp_feat, cmpp_feat, PARAMS_SIZE)) {
+-			mpp->action =  ACT_RELOAD;
++			mpp->action = mpp->action == ACT_RENAME ?
++				      ACT_RELOAD_RENAME : ACT_RELOAD;
+ 			condlog(3, "%s: set ACT_RELOAD (features change)",
+ 				mpp->alias);
++			FREE(cmpp_feat);
++			FREE(mpp_feat);
++			return;
+ 		}
+ 	}
+ 	FREE(cmpp_feat);
+@@ -793,44 +797,49 @@ select_action (struct multipath * mpp, vector curmp, int force_reload)
+ 
+ 	if (!cmpp->selector || strncmp(cmpp->selector, mpp->selector,
+ 		    strlen(mpp->selector))) {
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (selector change)",
+ 			mpp->alias);
+ 		return;
+ 	}
+ 	if (cmpp->minio != mpp->minio) {
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (minio change, %u->%u)",
+ 			mpp->alias, cmpp->minio, mpp->minio);
+ 		return;
+ 	}
+ 	if (!cmpp->pg || VECTOR_SIZE(cmpp->pg) != VECTOR_SIZE(mpp->pg)) {
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (path group number change)",
+ 			mpp->alias);
+ 		return;
+ 	}
+ 	if (pgcmp(mpp, cmpp)) {
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_RELOAD_RENAME :
++			      ACT_RELOAD;
+ 		condlog(3, "%s: set ACT_RELOAD (path group topology change)",
+ 			mpp->alias);
+ 		return;
+ 	}
+ 	if (cmpp->nextpg != mpp->bestpg) {
+-		mpp->action = ACT_SWITCHPG;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_SWITCHPG_RENAME :
++			      ACT_SWITCHPG;
+ 		condlog(3, "%s: set ACT_SWITCHPG (next path group change)",
+ 			mpp->alias);
+ 		return;
+ 	}
+ 	if (!is_mpp_known_to_udev(cmpp)) {
+-		mpp->action = ACT_RELOAD;
++		mpp->action = mpp->action == ACT_RENAME ? ACT_SWITCHPG_RENAME :
++			      ACT_SWITCHPG;
+ 		condlog(3, "%s: set ACT_RELOAD (udev device not initialized)",
+ 			mpp->alias);
+ 		return;
+ 	}
+-	mpp->action = ACT_NOTHING;
+-	condlog(3, "%s: set ACT_NOTHING (map unchanged)",
+-		mpp->alias);
++	if (mpp->action == ACT_NOTHING)
++		condlog(3, "%s: set ACT_NOTHING (map unchanged)", mpp->alias);
+ 	return;
+ }
+ 
+@@ -924,6 +933,17 @@ int domap(struct multipath *mpp, char *params, int is_daemon)
+ 		mpp->action = ACT_RELOAD;
+ 	}
+ 
++	if (mpp->action == ACT_RENAME || mpp->action == ACT_SWITCHPG_RENAME ||
++	    mpp->action == ACT_RELOAD_RENAME ||
++	    mpp->action == ACT_RESIZE_RENAME) {
++		conf = get_multipath_config();
++		pthread_cleanup_push(put_multipath_config, conf);
++		r = dm_rename(mpp->alias_old, mpp->alias,
++			      conf->partition_delim, mpp->skip_kpartx);
++		pthread_cleanup_pop(1);
++		if (r == DOMAP_FAIL)
++			return r;
++	}
+ 	switch (mpp->action) {
+ 	case ACT_REJECT:
+ 	case ACT_NOTHING:
+@@ -931,6 +951,7 @@ int domap(struct multipath *mpp, char *params, int is_daemon)
+ 		return DOMAP_EXIST;
+ 
+ 	case ACT_SWITCHPG:
++	case ACT_SWITCHPG_RENAME:
+ 		dm_switchgroup(mpp->alias, mpp->bestpg);
+ 		/*
+ 		 * we may have avoided reinstating paths because there where in
+@@ -957,6 +978,7 @@ int domap(struct multipath *mpp, char *params, int is_daemon)
+ 		break;
+ 
+ 	case ACT_RELOAD:
++	case ACT_RELOAD_RENAME:
+ 		sysfs_set_max_sectors_kb(mpp, 1);
+ 		if (mpp->ghost_delay_tick > 0 && pathcount(mpp, PATH_UP))
+ 			mpp->ghost_delay_tick = 0;
+@@ -964,6 +986,7 @@ int domap(struct multipath *mpp, char *params, int is_daemon)
+ 		break;
+ 
+ 	case ACT_RESIZE:
++	case ACT_RESIZE_RENAME:
+ 		sysfs_set_max_sectors_kb(mpp, 1);
+ 		if (mpp->ghost_delay_tick > 0 && pathcount(mpp, PATH_UP))
+ 			mpp->ghost_delay_tick = 0;
+@@ -971,29 +994,10 @@ int domap(struct multipath *mpp, char *params, int is_daemon)
+ 		break;
+ 
+ 	case ACT_RENAME:
+-		conf = get_multipath_config();
+-		pthread_cleanup_push(put_multipath_config, conf);
+-		r = dm_rename(mpp->alias_old, mpp->alias,
+-			      conf->partition_delim, mpp->skip_kpartx);
+-		pthread_cleanup_pop(1);
+-		break;
+-
+-	case ACT_FORCERENAME:
+-		conf = get_multipath_config();
+-		pthread_cleanup_push(put_multipath_config, conf);
+-		r = dm_rename(mpp->alias_old, mpp->alias,
+-			      conf->partition_delim, mpp->skip_kpartx);
+-		pthread_cleanup_pop(1);
+-		if (r) {
+-			sysfs_set_max_sectors_kb(mpp, 1);
+-			if (mpp->ghost_delay_tick > 0 &&
+-			    pathcount(mpp, PATH_UP))
+-				mpp->ghost_delay_tick = 0;
+-			r = dm_addmap_reload(mpp, params, 0);
+-		}
+ 		break;
+ 
+ 	default:
++		r = DOMAP_FAIL;
+ 		break;
+ 	}
+ 
+diff --git a/libmultipath/configure.h b/libmultipath/configure.h
+index 5cf08d45..1a93f49d 100644
+--- a/libmultipath/configure.h
++++ b/libmultipath/configure.h
+@@ -18,9 +18,11 @@ enum actions {
+ 	ACT_RENAME,
+ 	ACT_CREATE,
+ 	ACT_RESIZE,
+-	ACT_FORCERENAME,
++	ACT_RELOAD_RENAME,
+ 	ACT_DRY_RUN,
+ 	ACT_IMPOSSIBLE,
++	ACT_RESIZE_RENAME,
++	ACT_SWITCHPG_RENAME,
+ };
+ 
+ /*

SOURCES/0132-multipathd-make-pr-registration-consistent.patch

@@ -0,0 +1,136 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 20 Dec 2022 17:41:10 -0600
+Subject: [PATCH] multipathd: make pr registration consistent
+
+multipathd was inconsistent on what it did with persistent reservations
+when a multipath device was created. If a multipath device with a
+configured reservation key was created during configure(), multipathd
+would try to read the registered keys using an active path. If it saw a
+matching key, it would set the prflag, but not attempt to register the
+key on any of the other paths.  This means that if a new path had
+appeared while multipathd was not running, it wouldn't register the key
+on this path.
+
+If the multipath device was created during ev_add_path(), multipathd
+would used the added path to check if there was a matching key and if
+there was, register the key only on the added path and then set the
+prflag. This could be problematic if the device was created with
+multiple paths, for instance because find_mutipaths was set to "yes" and
+a second path just appeared. In this case, if the device happened to be
+only registered on the second path, it would not get registered on the
+first path.
+
+If the multipath device was added to multipathd during a call to
+ev_add_map(), multipathd wouldn't set the prflag or register the key on
+any paths.
+
+After a device was created with the prflag set, if a new path appeared
+before the creation uevent, and multipathd was forced to delay adding
+it, when it finally updated the multipath device, the key would be
+registered on all paths, fixing any paths missed during creation.
+However, if a new path appeared after the creation uevent, the key would
+only be registered on that new path. Any paths that were missed on
+creation would stay missed.
+
+persistent key registration needs to be handled consistently.  This
+patch does so by making sure that however a multipath device is added to
+multipathd, it will check to see if the configured key is registered. If
+it is, multipathd will set the prflag and register the key on all the
+currently active paths.
+
+When a new path is added, multipathd will use it to check for active
+keys, as before. But if it finds a matching key and prflag isn't
+currently set, it will register the key on all paths.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ multipathd/main.c | 32 +++++++++++++++++++++++++++++---
+ 1 file changed, 29 insertions(+), 3 deletions(-)
+
+diff --git a/multipathd/main.c b/multipathd/main.c
+index 769dcaee..d84027dc 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -511,6 +511,21 @@ flush_map_nopaths(struct multipath *mpp, struct vectors *vecs) {
+ 	return false;
+ }
+ 
++static void
++pr_register_active_paths(struct multipath *mpp)
++{
++	unsigned int i, j;
++	struct path *pp;
++	struct pathgroup *pgp;
++
++	vector_foreach_slot (mpp->pg, pgp, i) {
++		vector_foreach_slot (pgp->paths, pp, j) {
++			if ((pp->state == PATH_UP) || (pp->state == PATH_GHOST))
++				mpath_pr_event_handle(pp);
++		}
++	}
++}
++
+ static int
+ update_map (struct multipath *mpp, struct vectors *vecs, int new_map)
+ {
+@@ -556,6 +571,11 @@ fail:
+ 
+ 	sync_map_state(mpp);
+ 
++	if (!mpp->prflag)
++		update_map_pr(mpp);
++	if (mpp->prflag)
++		pr_register_active_paths(mpp);
++
+ 	if (retries < 0)
+ 		condlog(0, "%s: failed reload in new map update", mpp->alias);
+ 	return 0;
+@@ -1014,6 +1034,7 @@ ev_add_path (struct path * pp, struct vectors * vecs, int need_do_map)
+ 	int start_waiter = 0;
+ 	int ret;
+ 	int ro;
++	unsigned char prflag = 0;
+ 
+ 	/*
+ 	 * need path UID to go any further
+@@ -1056,6 +1077,8 @@ rescan:
+ 
+ 		verify_paths(mpp, vecs);
+ 		mpp->action = ACT_RELOAD;
++		prflag = mpp->prflag;
++		mpath_pr_event_handle(pp);
+ 	} else {
+ 		if (!should_multipath(pp, vecs->pathvec, vecs->mpvec)) {
+ 			orphan_path(pp, "only one path");
+@@ -1074,9 +1097,6 @@ rescan:
+ 			goto fail; /* leave path added to pathvec */
+ 	}
+ 
+-	/* persistent reservation check*/
+-	mpath_pr_event_handle(pp);
+-
+ 	/* ro check - if new path is ro, force map to be ro as well */
+ 	ro = sysfs_get_ro(pp);
+ 	if (ro == 1)
+@@ -1140,6 +1160,10 @@ rescan:
+ 	sync_map_state(mpp);
+ 
+ 	if (retries >= 0) {
++		if (start_waiter)
++			update_map_pr(mpp);
++		if (mpp->prflag && !prflag)
++				pr_register_active_paths(mpp);
+ 		condlog(2, "%s [%s]: path added to devmap %s",
+ 			pp->dev, pp->dev_t, mpp->alias);
+ 		return 0;
+@@ -2608,6 +2632,8 @@ configure (struct vectors * vecs)
+ 		if (remember_wwid(mpp->wwid) == 1)
+ 			trigger_paths_udev_change(mpp, true);
+ 		update_map_pr(mpp);
++		if (mpp->prflag)
++			pr_register_active_paths(mpp);
+ 	}
+ 
+ 	/*

SOURCES/0133-libmultipath-make-prflag-an-enum.patch

@@ -0,0 +1,165 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 20 Dec 2022 17:41:11 -0600
+Subject: [PATCH] libmultipath: make prflag an enum
+
+In preparation for a future patch, make prflag an enum, and change the
+reply of cli_getprstatus() to a string.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmpathpersist/mpath_persist.c |  2 +-
+ libmultipath/structs.h          |  8 +++++++-
+ multipathd/cli_handlers.c       | 16 +++++++++-------
+ multipathd/main.c               | 14 +++++++-------
+ 4 files changed, 24 insertions(+), 16 deletions(-)
+
+diff --git a/libmpathpersist/mpath_persist.c b/libmpathpersist/mpath_persist.c
+index d0744773..e361435a 100644
+--- a/libmpathpersist/mpath_persist.c
++++ b/libmpathpersist/mpath_persist.c
+@@ -949,7 +949,7 @@ int update_map_pr(struct multipath *mpp)
+ 
+ 	if (isFound)
+ 	{
+-		mpp->prflag = 1;
++		mpp->prflag = PRFLAG_SET;
+ 		condlog(2, "%s: prflag flag set.", mpp->alias );
+ 	}
+ 
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index 44980b4e..8acea3cb 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -377,6 +377,12 @@ struct path {
+ 
+ typedef int (pgpolicyfn) (struct multipath *, vector);
+ 
++
++enum prflag_value {
++	PRFLAG_UNSET,
++	PRFLAG_SET,
++};
++
+ struct multipath {
+ 	char wwid[WWID_SIZE];
+ 	char alias_old[WWID_SIZE];
+@@ -450,7 +456,7 @@ struct multipath {
+ 	int prkey_source;
+ 	struct be64 reservation_key;
+ 	uint8_t sa_flags;
+-	unsigned char prflag;
++	int prflag;
+ 	int all_tg_pt;
+ 	struct gen_multipath generic_mp;
+ 	bool fpin_must_reload;
+diff --git a/multipathd/cli_handlers.c b/multipathd/cli_handlers.c
+index 8b4bd187..6dbbb7e2 100644
+--- a/multipathd/cli_handlers.c
++++ b/multipathd/cli_handlers.c
+@@ -1407,6 +1407,10 @@ cli_shutdown (void * v, char ** reply, int * len, void * data)
+ int
+ cli_getprstatus (void * v, char ** reply, int * len, void * data)
+ {
++	static const char * const prflag_str[] = {
++		[PRFLAG_UNSET] = "unset\n",
++		[PRFLAG_SET] = "set\n",
++	};
+ 	struct multipath * mpp;
+ 	struct vectors * vecs = (struct vectors *)data;
+ 	char * param = get_keyparam(v, MAP);
+@@ -1418,9 +1422,7 @@ cli_getprstatus (void * v, char ** reply, int * len, void * data)
+ 	if (!mpp)
+ 		return 1;
+ 
+-	condlog(3, "%s: prflag = %u", param, (unsigned int)mpp->prflag);
+-
+-	*len = asprintf(reply, "%d", mpp->prflag);
++	*len = asprintf(reply, "%s", prflag_str[mpp->prflag]);
+ 	if (*len < 0)
+ 		return 1;
+ 
+@@ -1443,8 +1445,8 @@ cli_setprstatus(void * v, char ** reply, int * len, void * data)
+ 	if (!mpp)
+ 		return 1;
+ 
+-	if (!mpp->prflag) {
+-		mpp->prflag = 1;
++	if (mpp->prflag != PRFLAG_SET) {
++		mpp->prflag = PRFLAG_SET;
+ 		condlog(2, "%s: prflag set", param);
+ 	}
+ 
+@@ -1466,8 +1468,8 @@ cli_unsetprstatus(void * v, char ** reply, int * len, void * data)
+ 	if (!mpp)
+ 		return 1;
+ 
+-	if (mpp->prflag) {
+-		mpp->prflag = 0;
++	if (mpp->prflag != PRFLAG_UNSET) {
++		mpp->prflag = PRFLAG_UNSET;
+ 		condlog(2, "%s: prflag unset", param);
+ 	}
+ 
+diff --git a/multipathd/main.c b/multipathd/main.c
+index d84027dc..81bb0deb 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -571,9 +571,9 @@ fail:
+ 
+ 	sync_map_state(mpp);
+ 
+-	if (!mpp->prflag)
++	if (mpp->prflag == PRFLAG_UNSET)
+ 		update_map_pr(mpp);
+-	if (mpp->prflag)
++	if (mpp->prflag == PRFLAG_SET)
+ 		pr_register_active_paths(mpp);
+ 
+ 	if (retries < 0)
+@@ -1034,7 +1034,7 @@ ev_add_path (struct path * pp, struct vectors * vecs, int need_do_map)
+ 	int start_waiter = 0;
+ 	int ret;
+ 	int ro;
+-	unsigned char prflag = 0;
++	unsigned char prflag = PRFLAG_UNSET;
+ 
+ 	/*
+ 	 * need path UID to go any further
+@@ -1162,7 +1162,7 @@ rescan:
+ 	if (retries >= 0) {
+ 		if (start_waiter)
+ 			update_map_pr(mpp);
+-		if (mpp->prflag && !prflag)
++		if (mpp->prflag == PRFLAG_SET && prflag == PRFLAG_UNSET)
+ 				pr_register_active_paths(mpp);
+ 		condlog(2, "%s [%s]: path added to devmap %s",
+ 			pp->dev, pp->dev_t, mpp->alias);
+@@ -2306,7 +2306,7 @@ check_path (struct vectors * vecs, struct path * pp, unsigned int ticks)
+ 		}
+ 
+ 		if (newstate == PATH_UP || newstate == PATH_GHOST) {
+-			if (pp->mpp->prflag) {
++			if (pp->mpp->prflag == PRFLAG_SET) {
+ 				/*
+ 				 * Check Persistent Reservation.
+ 				 */
+@@ -2632,7 +2632,7 @@ configure (struct vectors * vecs)
+ 		if (remember_wwid(mpp->wwid) == 1)
+ 			trigger_paths_udev_change(mpp, true);
+ 		update_map_pr(mpp);
+-		if (mpp->prflag)
++		if (mpp->prflag == PRFLAG_SET)
+ 			pr_register_active_paths(mpp);
+ 	}
+ 
+@@ -3438,7 +3438,7 @@ void *  mpath_pr_event_handler_fn (void * pathp )
+ 	{
+ 		condlog(0,"%s: Reservation registration failed. Error: %d", pp->dev, ret);
+ 	}
+-	mpp->prflag = 1;
++	mpp->prflag = PRFLAG_SET;
+ 
+ 	free(param);
+ out:

SOURCES/0134-multipathd-handle-no-active-paths-in-update_map_pr.patch

@@ -0,0 +1,152 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Tue, 20 Dec 2022 17:41:12 -0600
+Subject: [PATCH] multipathd: handle no active paths in update_map_pr
+
+When a multipath device is first created, if it has a reservation key
+configured, update_map_pr() will check for a matching key on the active
+paths. If there were no active paths to check with, multipathd was
+leaving mpp->prflag in PRFLAG_UNSET, as if there were no matching keys.
+It's possible that when update_map_pr() is called, all the paths will be
+in the PATH_PENDING state because the checkers haven't completed yet. In
+this case, multipathd was treating the device as having no registered
+keys without ever checking.
+
+To solve this, multipath devices now start with prflag = PRFLAG_UNKNOWN.
+It will remain in this state until multipathd actually tries to get the
+registered keys down a path. If the map is in this state, it will check
+newly active paths, and if it finds a matching key, it will register
+the key down all active paths.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ libmpathpersist/mpath_persist.c |  8 ++++++++
+ libmultipath/structs.h          |  1 +
+ multipathd/cli_handlers.c       |  1 +
+ multipathd/main.c               | 19 ++++++++++++++-----
+ 4 files changed, 24 insertions(+), 5 deletions(-)
+
+diff --git a/libmpathpersist/mpath_persist.c b/libmpathpersist/mpath_persist.c
+index e361435a..440a329f 100644
+--- a/libmpathpersist/mpath_persist.c
++++ b/libmpathpersist/mpath_persist.c
+@@ -904,6 +904,7 @@ int update_map_pr(struct multipath *mpp)
+ 	if (!get_be64(mpp->reservation_key))
+ 	{
+ 		/* Nothing to do. Assuming pr mgmt feature is disabled*/
++		mpp->prflag = PRFLAG_UNSET;
+ 		condlog(4, "%s: reservation_key not set in multipath.conf",
+ 			mpp->alias);
+ 		return MPATH_PR_SUCCESS;
+@@ -915,6 +916,13 @@ int update_map_pr(struct multipath *mpp)
+ 		condlog(0,"%s : failed to alloc resp in update_map_pr", mpp->alias);
+ 		return MPATH_PR_OTHER;
+ 	}
++	if (count_active_paths(mpp) == 0)
++	{
++		condlog(0,"%s: No available paths to check pr status",
++			mpp->alias);
++		return MPATH_PR_OTHER;
++	}
++	mpp->prflag = PRFLAG_UNSET;
+ 	ret = mpath_prin_activepath(mpp, MPATH_PRIN_RKEY_SA, resp, noisy);
+ 
+ 	if (ret != MPATH_PR_SUCCESS )
+diff --git a/libmultipath/structs.h b/libmultipath/structs.h
+index 8acea3cb..7f2fb944 100644
+--- a/libmultipath/structs.h
++++ b/libmultipath/structs.h
+@@ -379,6 +379,7 @@ typedef int (pgpolicyfn) (struct multipath *, vector);
+ 
+ 
+ enum prflag_value {
++	PRFLAG_UNKNOWN,
+ 	PRFLAG_UNSET,
+ 	PRFLAG_SET,
+ };
+diff --git a/multipathd/cli_handlers.c b/multipathd/cli_handlers.c
+index 6dbbb7e2..260b7a17 100644
+--- a/multipathd/cli_handlers.c
++++ b/multipathd/cli_handlers.c
+@@ -1408,6 +1408,7 @@ int
+ cli_getprstatus (void * v, char ** reply, int * len, void * data)
+ {
+ 	static const char * const prflag_str[] = {
++		[PRFLAG_UNKNOWN] = "unknown\n",
+ 		[PRFLAG_UNSET] = "unset\n",
+ 		[PRFLAG_SET] = "set\n",
+ 	};
+diff --git a/multipathd/main.c b/multipathd/main.c
+index 81bb0deb..e7dad6b9 100644
+--- a/multipathd/main.c
++++ b/multipathd/main.c
+@@ -571,7 +571,7 @@ fail:
+ 
+ 	sync_map_state(mpp);
+ 
+-	if (mpp->prflag == PRFLAG_UNSET)
++	if (mpp->prflag != PRFLAG_SET)
+ 		update_map_pr(mpp);
+ 	if (mpp->prflag == PRFLAG_SET)
+ 		pr_register_active_paths(mpp);
+@@ -1162,7 +1162,7 @@ rescan:
+ 	if (retries >= 0) {
+ 		if (start_waiter)
+ 			update_map_pr(mpp);
+-		if (mpp->prflag == PRFLAG_SET && prflag == PRFLAG_UNSET)
++		if (mpp->prflag == PRFLAG_SET && prflag != PRFLAG_SET)
+ 				pr_register_active_paths(mpp);
+ 		condlog(2, "%s [%s]: path added to devmap %s",
+ 			pp->dev, pp->dev_t, mpp->alias);
+@@ -2306,13 +2306,17 @@ check_path (struct vectors * vecs, struct path * pp, unsigned int ticks)
+ 		}
+ 
+ 		if (newstate == PATH_UP || newstate == PATH_GHOST) {
+-			if (pp->mpp->prflag == PRFLAG_SET) {
++			if (pp->mpp->prflag != PRFLAG_UNSET) {
++				int prflag = pp->mpp->prflag;
+ 				/*
+ 				 * Check Persistent Reservation.
+ 				 */
+ 				condlog(2, "%s: checking persistent "
+ 					"reservation registration", pp->dev);
+ 				mpath_pr_event_handle(pp);
++				if (pp->mpp->prflag == PRFLAG_SET &&
++				    prflag != PRFLAG_SET)
++					pr_register_active_paths(pp->mpp);
+ 			}
+ 		}
+ 
+@@ -3386,6 +3390,7 @@ void *  mpath_pr_event_handler_fn (void * pathp )
+ 		goto out;
+ 	}
+ 
++	mpp->prflag = PRFLAG_UNSET;
+ 	ret = prin_do_scsi_ioctl(pp->dev, MPATH_PRIN_RKEY_SA, resp, 0);
+ 	if (ret != MPATH_PR_SUCCESS )
+ 	{
+@@ -3456,12 +3461,12 @@ int mpath_pr_event_handle(struct path *pp)
+ 	struct multipath * mpp;
+ 
+ 	if (pp->bus != SYSFS_BUS_SCSI)
+-		return 0;
++		goto no_pr;
+ 
+ 	mpp = pp->mpp;
+ 
+ 	if (!get_be64(mpp->reservation_key))
+-		return -1;
++		goto no_pr;
+ 
+ 	pthread_attr_init(&attr);
+ 	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+@@ -3474,4 +3479,8 @@ int mpath_pr_event_handle(struct path *pp)
+ 	pthread_attr_destroy(&attr);
+ 	rc = pthread_join(thread, NULL);
+ 	return 0;
++
++no_pr:
++	pp->mpp->prflag = PRFLAG_UNSET;
++	return 0;
+ }

SOURCES/0135-libmpathpersist-fix-resource-leak-in-update_map_pr.patch

@@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martin Wilck <mwilck@suse.com>
+Date: Thu, 2 Feb 2023 09:20:35 +0100
+Subject: [PATCH] libmpathpersist: fix resource leak in update_map_pr()
+
+The "no available paths" case would leak the memory resp points to.
+Found by coverity.
+
+Fixes: 50e2c16 ("multipathd: handle no active paths in update_map_pr")
+
+Signed-off-by: Martin Wilck <mwilck@suse.com>
+Reviewed-by: Benjamin Marzinski <bmarzins@redhat.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmpathpersist/mpath_persist.c | 15 ++++++++-------
+ 1 file changed, 8 insertions(+), 7 deletions(-)
+
+diff --git a/libmpathpersist/mpath_persist.c b/libmpathpersist/mpath_persist.c
+index 440a329f..a4c1461f 100644
+--- a/libmpathpersist/mpath_persist.c
++++ b/libmpathpersist/mpath_persist.c
+@@ -899,7 +899,7 @@ int update_map_pr(struct multipath *mpp)
+ 	int noisy=0;
+ 	struct prin_resp *resp;
+ 	unsigned int i;
+-	int ret, isFound;
++	int ret = MPATH_PR_OTHER, isFound;
+ 
+ 	if (!get_be64(mpp->reservation_key))
+ 	{
+@@ -920,7 +920,7 @@ int update_map_pr(struct multipath *mpp)
+ 	{
+ 		condlog(0,"%s: No available paths to check pr status",
+ 			mpp->alias);
+-		return MPATH_PR_OTHER;
++		goto out;
+ 	}
+ 	mpp->prflag = PRFLAG_UNSET;
+ 	ret = mpath_prin_activepath(mpp, MPATH_PRIN_RKEY_SA, resp, noisy);
+@@ -928,15 +928,15 @@ int update_map_pr(struct multipath *mpp)
+ 	if (ret != MPATH_PR_SUCCESS )
+ 	{
+ 		condlog(0,"%s : pr in read keys service action failed Error=%d", mpp->alias, ret);
+-		free(resp);
+-		return  ret;
++		goto out;
+ 	}
+ 
++	ret = MPATH_PR_SUCCESS;
++
+ 	if (resp->prin_descriptor.prin_readkeys.additional_length == 0 )
+ 	{
+ 		condlog(3,"%s: No key found. Device may not be registered. ", mpp->alias);
+-		free(resp);
+-		return MPATH_PR_SUCCESS;
++		goto out;
+ 	}
+ 
+ 	condlog(2, "%s: Multipath  reservation_key: 0x%" PRIx64 " ", mpp->alias,
+@@ -961,6 +961,7 @@ int update_map_pr(struct multipath *mpp)
+ 		condlog(2, "%s: prflag flag set.", mpp->alias );
+ 	}
+ 
++out:
+ 	free(resp);
+-	return MPATH_PR_SUCCESS;
++	return ret;
+ }

SOURCES/0136-multipathd-Added-support-to-handle-FPIN-Li-events-fo.patch

@@ -0,0 +1,300 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Muneendra <muneendra.kumar@broadcom.com>
+Date: Wed, 20 Sep 2023 20:41:15 -0700
+Subject: [PATCH] multipathd: Added support to handle FPIN-Li events for
+ FC-NVMe
+
+    This patch adds the support to handle FPIN-Li for FC-NVMe.
+    On receiving the FPIN-Li events this patch moves the devices paths
+    which are affected due to link integrity to marginal path groups.
+    The paths which are set to marginal path group will be unset
+    on receiving the RSCN events
+
+(mwilck: minor compile fix for 32-bit architectures)
+
+Signed-off-by: Muneendra <muneendra.kumar@broadcom.com>
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+Reviewed-by: Martin Wilck <mwilck@suse.com>
+---
+ multipathd/fpin_handlers.c | 206 +++++++++++++++++++++++++++----------
+ 1 file changed, 151 insertions(+), 55 deletions(-)
+
+diff --git a/multipathd/fpin_handlers.c b/multipathd/fpin_handlers.c
+index 599f2893..6b90cded 100644
+--- a/multipathd/fpin_handlers.c
++++ b/multipathd/fpin_handlers.c
+@@ -60,18 +60,15 @@ static void _udev_device_unref(void *p)
+ 
+ 
+ /*set/unset the path state to marginal*/
+-static int fpin_set_pathstate(struct path *pp, bool set)
++static void fpin_set_pathstate(struct path *pp, bool set)
+ {
+ 	const char *action = set ? "set" : "unset";
+ 
+-	if (!pp || !pp->mpp || !pp->mpp->alias)
+-		return -1;
+-
+-	condlog(3, "\n%s: %s  marginal path %s (fpin)",
+-		action, pp->mpp->alias, pp->dev_t);
++	condlog(3, "%s: %s marginal path %s (fpin)",
++		pp->mpp ? pp->mpp->alias : "orphan", action, pp->dev_t);
+ 	pp->marginal = set;
+-	pp->mpp->fpin_must_reload = true;
+-	return 0;
++	if (pp->mpp)
++		pp->mpp->fpin_must_reload = true;
+ }
+ 
+ /* This will unset marginal state of a device*/
+@@ -82,14 +79,14 @@ static void fpin_path_unsetmarginal(char *devname, struct vectors *vecs)
+ 	pp = find_path_by_dev(vecs->pathvec, devname);
+ 	if (!pp)
+ 		pp = find_path_by_devt(vecs->pathvec, devname);
+-
+-	fpin_set_pathstate(pp, false);
++	if (pp)
++		fpin_set_pathstate(pp, false);
+ }
+ 
+ /*This will set the marginal state of a device*/
+-static int fpin_path_setmarginal(struct path *pp)
++static void  fpin_path_setmarginal(struct path *pp)
+ {
+-	return fpin_set_pathstate(pp, true);
++	fpin_set_pathstate(pp, true);
+ }
+ 
+ /* Unsets all the devices in the list from marginal state */
+@@ -176,8 +173,8 @@ static void fpin_set_rport_marginal(struct udev_device *rport_dev)
+ 				"Marginal", strlen("Marginal"));
+ }
+ 
+-/*Add the marginal devices info into the list*/
+-static void
++/*Add the marginal devices info into the list and return 0 on success*/
++static int
+ fpin_add_marginal_dev_info(uint32_t host_num, char *devname)
+ {
+ 	struct marginal_dev_list *newdev = NULL;
+@@ -192,65 +189,160 @@ fpin_add_marginal_dev_info(uint32_t host_num, char *devname)
+ 		list_add_tail(&(newdev->node),
+ 				&fpin_li_marginal_dev_list_head);
+ 		pthread_mutex_unlock(&fpin_li_marginal_dev_mutex);
+-	}
++	} else
++		return -ENOMEM;
++	return 0;
+ }
+ 
+ /*
+- * This function goes through the vecs->pathvec, and for
+- * each path, check that the host  number,
+- * the target WWPN associated with the path matches
+- * with the els wwpn and sets the path and port state to
++ * This function compares Transport Address Controller Port pn,
++ * Host Transport Address Controller Port pn with the els wwpn ,attached_wwpn
++ * and return 1 (match) or 0 (no match) or a negative error code
++ */
++static int  extract_nvme_addresses_chk_path_pwwn(const char *address,
++		uint64_t els_wwpn, uint64_t els_attached_wwpn)
++
++{
++	uint64_t traddr;
++	uint64_t host_traddr;
++
++	/*
++	 *  Find the position of "traddr=" and "host_traddr="
++	 *  and the address will be in the below format
++	 *  "traddr=nn-0x200400110dff9400:pn-0x200400110dff9400,
++	 *  host_traddr=nn-0x200400110dff9400:pn-0x200400110dff9400"
++	 */
++	const char *traddr_start = strstr(address, "traddr=");
++	const char *host_traddr_start = strstr(address, "host_traddr=");
++
++	if (!traddr_start || !host_traddr_start)
++		return -EINVAL;
++
++	/* Extract traddr pn */
++	if (sscanf(traddr_start, "traddr=nn-%*[^:]:pn-%" SCNx64, &traddr) != 1)
++		return -EINVAL;
++
++	/* Extract host_traddr pn*/
++	if (sscanf(host_traddr_start, "host_traddr=nn-%*[^:]:pn-%" SCNx64,
++				&host_traddr) != 1)
++		return -EINVAL;
++	condlog(4, "traddr 0x%" PRIx64 " hosttraddr 0x%" PRIx64 " els_wwpn 0x%"
++		PRIx64" els_host_traddr 0x%" PRIx64,
++			traddr, host_traddr,
++			els_wwpn, els_attached_wwpn);
++	if ((host_traddr == els_attached_wwpn) && (traddr == els_wwpn))
++		return 1;
++	return 0;
++}
++
++/*
++ * This function check that the Transport Address Controller Port pn,
++ * Host Transport Address Controller Port pn associated with the path matches
++ * with the els wwpn ,attached_wwpn and sets the path state to
+  * Marginal
+  */
+-static int  fpin_chk_wwn_setpath_marginal(uint16_t host_num,  struct vectors *vecs,
++static void fpin_check_set_nvme_path_marginal(uint16_t host_num, struct path *pp,
++		uint64_t els_wwpn, uint64_t attached_wwpn)
++{
++	struct udev_device *ctl = NULL;
++	const char *address = NULL;
++	int ret = 0;
++
++	ctl = udev_device_get_parent_with_subsystem_devtype(pp->udev, "nvme", NULL);
++	if (ctl == NULL) {
++		condlog(2, "%s: No parent device for ", pp->dev);
++		return;
++	}
++	address = udev_device_get_sysattr_value(ctl, "address");
++	if (!address) {
++		condlog(2, "%s: unable to get the address ", pp->dev);
++		return;
++	}
++	condlog(4, "\n address %s: dev :%s\n", address, pp->dev);
++	ret = extract_nvme_addresses_chk_path_pwwn(address, els_wwpn, attached_wwpn);
++	if (ret <= 0)
++		return;
++	ret = fpin_add_marginal_dev_info(host_num, pp->dev);
++	if (ret < 0)
++		return;
++	fpin_path_setmarginal(pp);
++}
++
++/*
++ * This function check the host  number, the target WWPN
++ * associated with the path matches with the els wwpn and
++ * sets the path and port state to Marginal
++ */
++static void fpin_check_set_scsi_path_marginal(uint16_t host_num, struct path *pp,
+ 		uint64_t els_wwpn)
+ {
+-	struct path *pp;
+-	struct multipath *mpp;
+-	int i, k;
+ 	char rport_id[42];
+ 	const char *value = NULL;
+ 	struct udev_device *rport_dev = NULL;
+ 	uint64_t wwpn;
+ 	int ret = 0;
++	sprintf(rport_id, "rport-%d:%d-%d",
++			pp->sg_id.host_no, pp->sg_id.channel, pp->sg_id.transport_id);
++	rport_dev = udev_device_new_from_subsystem_sysname(udev,
++			"fc_remote_ports", rport_id);
++	if (!rport_dev) {
++		condlog(2, "%s: No fc_remote_port device for '%s'", pp->dev,
++				rport_id);
++		return;
++	}
++	pthread_cleanup_push(_udev_device_unref, rport_dev);
++	value = udev_device_get_sysattr_value(rport_dev, "port_name");
++	if (!value)
++		goto unref;
++
++	wwpn =  strtol(value, NULL, 16);
++	/*
++	 * If the port wwpn matches sets the path and port state
++	 * to marginal
++	 */
++	if (wwpn == els_wwpn) {
++		ret = fpin_add_marginal_dev_info(host_num, pp->dev);
++		if (ret < 0)
++			goto unref;
++		fpin_path_setmarginal(pp);
++		fpin_set_rport_marginal(rport_dev);
++	}
++unref:
++	pthread_cleanup_pop(1);
++	return;
++
++}
++
++/*
++ * This function goes through the vecs->pathvec, and for
++ * each path, it checks and sets the path state to marginal
++ * if the path's associated port wwpn ,hostnum  matches with
++ * els wwnpn ,attached_wwpn
++ */
++static int  fpin_chk_wwn_setpath_marginal(uint16_t host_num,  struct vectors *vecs,
++		uint64_t els_wwpn, uint64_t attached_wwpn)
++{
++	struct path *pp;
++	struct multipath *mpp;
++	int i, k;
++	int ret = 0;
+ 
+ 	pthread_cleanup_push(cleanup_lock, &vecs->lock);
+ 	lock(&vecs->lock);
+ 	pthread_testcancel();
+ 
+ 	vector_foreach_slot(vecs->pathvec, pp, k) {
+-		/* Checks the host number and also for the SCSI FCP */
+-		if (pp->bus != SYSFS_BUS_SCSI || pp->sg_id.proto_id != SCSI_PROTOCOL_FCP || host_num !=  pp->sg_id.host_no)
++		if (!pp->mpp)
+ 			continue;
+-		sprintf(rport_id, "rport-%d:%d-%d",
+-				pp->sg_id.host_no, pp->sg_id.channel, pp->sg_id.transport_id);
+-		rport_dev = udev_device_new_from_subsystem_sysname(udev,
+-				"fc_remote_ports", rport_id);
+-		if (!rport_dev) {
+-			condlog(2, "%s: No fc_remote_port device for '%s'", pp->dev,
+-					rport_id);
+-			continue;
+-		}
+-		pthread_cleanup_push(_udev_device_unref, rport_dev);
+-		value = udev_device_get_sysattr_value(rport_dev, "port_name");
+-		if (!value)
+-			goto unref;
+-
+-		if (value)
+-			wwpn =  strtol(value, NULL, 16);
+-		/*
+-		 * If the port wwpn matches sets the path and port state
+-		 * to marginal
+-		 */
+-		if (wwpn == els_wwpn) {
+-			ret = fpin_path_setmarginal(pp);
+-			if (ret < 0)
+-				goto unref;
+-			fpin_set_rport_marginal(rport_dev);
+-			fpin_add_marginal_dev_info(host_num, pp->dev);
++		/*checks if the bus type is nvme  and the protocol is FC-NVMe*/
++		if ((pp->bus == SYSFS_BUS_NVME) && (pp->sg_id.proto_id == NVME_PROTOCOL_FC)) {
++			fpin_check_set_nvme_path_marginal(host_num, pp, els_wwpn, attached_wwpn);
++		} else if ((pp->bus == SYSFS_BUS_SCSI) &&
++			(pp->sg_id.proto_id == SCSI_PROTOCOL_FCP) &&
++			(host_num ==  pp->sg_id.host_no)) {
++			/* Checks the host number and also for the SCSI FCP */
++			fpin_check_set_scsi_path_marginal(host_num, pp, els_wwpn);
+ 		}
+-unref:
+-		pthread_cleanup_pop(1);
+ 	}
+ 	/* walk backwards because update_path_groups() can remove mpp */
+ 	vector_foreach_slot_backwards(vecs->mpvec, mpp, i) {
+@@ -279,14 +371,18 @@ fpin_parse_li_els_setpath_marginal(uint16_t host_num, struct fc_tlv_desc *tlv,
+ 	struct fc_fn_li_desc *li_desc = (struct fc_fn_li_desc *)tlv;
+ 	int count = 0;
+ 	int ret = 0;
++	uint64_t attached_wwpn;
+ 
+ 	/* Update the wwn to list */
+ 	wwn_count = be32_to_cpu(li_desc->pname_count);
+-	condlog(4, "Got wwn count as %d\n", wwn_count);
++	attached_wwpn = be64_to_cpu(li_desc->attached_wwpn);
++	condlog(4, "Got wwn count as %d detecting wwn 0x%" PRIx64
++		" attached_wwpn 0x%" PRIx64 "\n",
++			wwn_count, be64_to_cpu(li_desc->detecting_wwpn), attached_wwpn);
+ 
+ 	for (iter = 0; iter < wwn_count; iter++) {
+ 		wwpn = be64_to_cpu(li_desc->pname_list[iter]);
+-		ret = fpin_chk_wwn_setpath_marginal(host_num, vecs, wwpn);
++		ret = fpin_chk_wwn_setpath_marginal(host_num, vecs, wwpn, attached_wwpn);
+ 		if (ret < 0)
+ 			condlog(2, "failed to set the path marginal associated with wwpn: 0x%" PRIx64 "\n", wwpn);
+ 

SOURCES/0137-multipathd-Make-sure-to-disable-queueing-if-recovery.patch

@@ -0,0 +1,76 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Benjamin Marzinski <bmarzins@redhat.com>
+Date: Wed, 22 Nov 2023 16:41:22 -0500
+Subject: [PATCH] multipathd: Make sure to disable queueing if recovery has
+ failed.
+
+If a multipath device has no_path_retry set to a number and has lost all
+paths, gone into recovery mode, and timed out, it will disable
+queue_if_no_paths. After that, if the device is reloaded by multipath
+outside of multipathd, it will re-enable queuieng on the device. When
+multipathd later calls set_no_path_retry() to update the queueing state,
+it will not disable queue_if_no_paths, since the device is still in the
+recovery state, so it believes no work needs to be done. The device will
+remain in the recovery state, with retry_ticks at 0, and queueing
+enabled, even though there are no usable paths.
+
+To fix this, in set_no_path_retry(), if no_path_retry is set to a number
+and the device is queueing but it is in recovery mode and out of
+retries with no usable paths, manually disable queue_if_no_path.
+
+Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
+---
+ libmultipath/structs_vec.c | 26 ++++++++++++++++++++++++--
+ 1 file changed, 24 insertions(+), 2 deletions(-)
+
+diff --git a/libmultipath/structs_vec.c b/libmultipath/structs_vec.c
+index 9613252f..0304777b 100644
+--- a/libmultipath/structs_vec.c
++++ b/libmultipath/structs_vec.c
+@@ -377,8 +377,19 @@ void __set_no_path_retry(struct multipath *mpp, bool check_features)
+ 			    !mpp->in_recovery)
+ 				dm_queue_if_no_path(mpp->alias, 1);
+ 			leave_recovery_mode(mpp);
+-		} else
+-			enter_recovery_mode(mpp);
++		} else {
++			/*
++			 * If in_recovery is set, enter_recovery_mode does
++			 * nothing. If the device is already in recovery
++			 * mode and has already timed out, manually call
++			 * dm_queue_if_no_path to stop it from queueing.
++			 */
++			if ((!mpp->features || is_queueing) &&
++			    mpp->in_recovery && mpp->retry_tick == 0)
++				dm_queue_if_no_path(mpp->alias, 0);
++			if (pathcount(mpp, PATH_PENDING) == 0)
++				enter_recovery_mode(mpp);
++		}
+ 		break;
+ 	}
+ }
+@@ -521,6 +532,11 @@ int verify_paths(struct multipath *mpp, struct vectors *vecs)
+  *   -1 (FAIL)  : fail_if_no_path
+  *    0 (UNDEF) : nothing
+  *   >0         : queue_if_no_path enabled, turned off after polling n times
++ *
++ * Since this will only be called when fail_path(), update_multipath(), or
++ * io_err_stat_handle_pathfail() are failing a previously active path, the
++ * device cannot already be in recovery mode, so there will never be a need
++ * to disable queueing here.
+  */
+ void update_queue_mode_del_path(struct multipath *mpp)
+ {
+@@ -534,6 +550,12 @@ void update_queue_mode_del_path(struct multipath *mpp)
+ 	condlog(2, "%s: remaining active paths: %d", mpp->alias, active);
+ }
+ 
++/*
++ * Since this will only be called from check_path() -> reinstate_path() after
++ * the queueing state has been updated in set_no_path_retry, this does not
++ * need to worry about modifying the queueing state except when actually
++ * leaving recovery mode.
++ */
+ void update_queue_mode_add_path(struct multipath *mpp)
+ {
+ 	int active = count_active_paths(mpp);

SPECS/device-mapper-multipath.spec

@@ -1,7 +1,7 @@
 Summary: Tools to manage multipath devices using device-mapper
 Name: device-mapper-multipath
 Version: 0.8.4
-Release: 23%{?dist}
+Release: 41%{?dist}
 License: GPLv2
 Group: System Environment/Base
 URL: http://christophe.varoqui.free.fr/
@@ -104,12 +104,57 @@ Patch00090: 0090-RH-add-support-to-mpathconf-for-setting-arbitrary-de.patch
 Patch00091: 0091-multipath-tools-add-HPE-MSA-1060-2060-to-hwtable.patch
 Patch00092: 0092-multipath-tools-update-mpp-force_readonly-in-ev_add_.patch
 Patch00093: 0093-updated-HPE-MSA-builtin-config.patch
+Patch00094: 0094-multipath-return-failure-on-an-invalid-remove-comman.patch
+Patch00095: 0095-libmultipath-steal-the-src-string-pointer-in-merge_s.patch
+Patch00096: 0096-libmultipath-enable-linear-ordering-of-bus-proto-tup.patch
+Patch00097: 0097-libmultipath-use-bus_protocol_id-in-snprint_path_pro.patch
+Patch00098: 0098-libmultipath-make-protocol_name-global.patch
+Patch00099: 0099-libmultipath-add-a-protocol-subsection-to-multipath..patch
+Patch00100: 0100-libmultipath-Set-the-scsi-timeout-parameters-by-path.patch
+Patch00101: 0101-libmultipath-check-the-overrides-pctable-for-path-va.patch
+Patch00102: 0102-libmultipath-fix-eh_deadline-documentation.patch
+Patch00103: 0103-libmultipath-Add-documentation-for-the-protocol-subs.patch
+Patch00104: 0104-libmultipath-use-symbolic-value-for-invalid-pcentry.patch
+Patch00105: 0105-multipathd-handle-fpin-events.patch
+Patch00106: 0106-multipathd-disallow-changing-to-from-fpin-marginal-p.patch
+Patch00107: 0107-libmultipath-unset-detect_checker-for-clariion-Unity.patch
+Patch00108: 0108-multipathd-Add-missing-ctype-include.patch
+Patch00109: 0109-multipathd-replace-libreadline-with-libedit.patch
+Patch00110: 0110-multipath-fix-systemd-timers-in-the-initramfs.patch
+Patch00111: 0111-multipathd-factor-out-the-code-to-flush-a-map-with-n.patch
+Patch00112: 0112-libmultipath-return-success-if-we-raced-to-remove-a-.patch
+Patch00113: 0113-multipathd-Handle-losing-all-path-in-update_map.patch
+Patch00114: 0114-multipathd-ignore-duplicated-multipathd-command-keys.patch
+Patch00115: 0115-multipath-tools-use-run-instead-of-dev-shm.patch
+Patch00116: 0116-kpartx-hold-device-open-until-partitions-have-been-c.patch
+Patch00117: 0117-libmultipath-cleanup-remove_feature.patch
+Patch00118: 0118-libmultipath-cleanup-add_feature.patch
+Patch00119: 0119-multipath-tests-tests-for-adding-and-removing-featur.patch
+Patch00120: 0120-libmultipath-fix-queue_mode-feature-handling.patch
+Patch00121: 0121-multipath-tests-tests-for-reconcile_features_with_qu.patch
+Patch00122: 0122-libmultipath-prepare-proto_id-for-use-by-non-scsi-de.patch
+Patch00123: 0123-libmultipath-get-nvme-path-transport-protocol.patch
+Patch00124: 0124-libmultipath-enforce-queue_mode-bio-for-nmve-tcp-pat.patch
+Patch00125: 0125-multipath-add-historical-service-time-to-the-man-pag.patch
+Patch00126: 0126-libmultipath-copy-mpp-hwe-from-pp-hwe.patch
+Patch00127: 0127-libmultipath-don-t-leak-memory-on-invalid-strings.patch
+Patch00128: 0128-libmutipath-validate-the-argument-count-of-config-st.patch
+Patch00129: 0129-libmultipath-select-resize-action-even-if-reload-is-.patch
+Patch00130: 0130-libmultipath-cleanup-ACT_CREATE-code-in-select_actio.patch
+Patch00131: 0131-libmultipath-keep-renames-from-stopping-other-multip.patch
+Patch00132: 0132-multipathd-make-pr-registration-consistent.patch
+Patch00133: 0133-libmultipath-make-prflag-an-enum.patch
+Patch00134: 0134-multipathd-handle-no-active-paths-in-update_map_pr.patch
+Patch00135: 0135-libmpathpersist-fix-resource-leak-in-update_map_pr.patch
+Patch00136: 0136-multipathd-Added-support-to-handle-FPIN-Li-events-fo.patch
+Patch00137: 0137-multipathd-Make-sure-to-disable-queueing-if-recovery.patch
 
 # runtime
 Requires: %{name}-libs = %{version}-%{release}
 Requires: kpartx = %{version}-%{release}
 Requires: device-mapper >= 1.02.96
 Requires: userspace-rcu
+Requires: libedit
 Requires(post): systemd-units
 Requires(preun): systemd-units
 Requires(postun): systemd-units
@@ -117,7 +162,7 @@ Requires(postun): systemd-units
 # build/setup
 BuildRequires: libaio-devel, device-mapper-devel >= 1.02.89
 BuildRequires: libselinux-devel, libsepol-devel
-BuildRequires: readline-devel, ncurses-devel
+BuildRequires: libedit-devel, ncurses-devel
 BuildRequires: systemd-units, systemd-devel
 BuildRequires: json-c-devel, perl-interpreter, pkgconfig, gcc
 BuildRequires: userspace-rcu-devel
@@ -201,7 +246,8 @@ make install \
 	rcdir=%{_initrddir} \
 	unitdir=%{_unitdir} \
 	includedir=%{_includedir} \
-	pkgconfdir=%{_pkgconfdir}
+	pkgconfdir=%{_pkgconfdir} \
+	tmpfilesdir=%{_tmpfilesdir}
 
 # tree fix up
 install -d %{buildroot}/etc/multipath
@@ -240,6 +286,7 @@ fi
 %{_mandir}/man8/mpathpersist.8.gz
 %config %{_udevrulesdir}/62-multipath.rules
 %config %{_udevrulesdir}/11-dm-mpath.rules
+%{_tmpfilesdir}/multipath.conf
 %{!?_licensedir:%global license %%doc}
 %license LICENSES/GPL-2.0 LICENSES/LGPL-2.0
 %doc README
@@ -279,7 +326,7 @@ fi
 %{!?_licensedir:%global license %%doc}
 %license LICENSES/GPL-2.0
 %{_sbindir}/kpartx
-/usr/lib/udev/kpartx_id
+%{_udevrulesdir}/../kpartx_id
 %{_mandir}/man8/kpartx.8.gz
 %config %{_udevrulesdir}/11-dm-parts.rules
 %config %{_udevrulesdir}/66-kpartx.rules
@@ -305,6 +352,123 @@ fi
 %{_pkgconfdir}/libdmmp.pc
 
 %changelog
+* Fri Jan  5 2024 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-41
+- Add 0137-multipathd-Make-sure-to-disable-queueing-if-recovery.patch
+- Resolves: RHEL-16563
+
+* Thu Nov  2 2023 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-40
+- Add 0136-multipathd-Added-support-to-handle-FPIN-Li-events-fo.patch
+  * Add support in multipathd for NVMe to listen for FPIN-Li events and
+    mark effected paths as marginal
+- Resolves: RHEL-6677
+
+* Thu Mar 16 2023 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-39
+- Add OSCI tests directory
+- Make kpartx_id installation location relative to %{_udevrulesdir}
+- Resolves: bz #2164871
+
+* Wed Mar 15 2023 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-38
+- Add 0132-multipathd-make-pr-registration-consistent.patch
+- Add 0133-libmultipath-make-prflag-an-enum.patch
+- Add 0134-multipathd-handle-no-active-paths-in-update_map_pr.patch
+- Add 0135-libmpathpersist-fix-resource-leak-in-update_map_pr.patch
+- Resolves: bz #2164871
+
+* Fri Feb  3 2023 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-37
+- Fix bugzilla linked to the changes (was previously linked to
+  the wrong bug, 2162537)
+- Resolves: bz #2166468
+
+* Wed Feb  1 2023 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-36
+- Add 0129-libmultipath-select-resize-action-even-if-reload-is-.patch
+- Add 0130-libmultipath-cleanup-ACT_CREATE-code-in-select_actio.patch
+- Add 0131-libmultipath-keep-renames-from-stopping-other-multip.patch
+- Resolves: bz #2166468
+
+* Mon Jan 16 2023 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-35
+- Add 0127-libmultipath-don-t-leak-memory-on-invalid-strings.patch
+- Add 0128-libmutipath-validate-the-argument-count-of-config-st.patch
+- Resolves: bz #2155560
+
+* Tue Nov 29 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-34
+- Add 0126-libmultipath-copy-mpp-hwe-from-pp-hwe.patch
+  * Fixes bz #2126714
+- Cleanup multiple CI tests
+- Resolves: bz #2126714
+
+* Wed Nov 23 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-33
+- Add 0125-multipath-add-historical-service-time-to-the-man-pag.patch
+  * Fixes bz #2141996
+- Modify tests/multipath_conf_syntax/main.sh
+  * fix unrelated test error
+- Resolves: bz #2141996
+
+* Thu Nov 10 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-32
+- Add 0116-kpartx-hold-device-open-until-partitions-have-been-c.patch
+  * Fixes bz #2128885
+- Add 0117-libmultipath-cleanup-remove_feature.patch
+- Add 0118-libmultipath-cleanup-add_feature.patch
+- Add 0119-multipath-tests-tests-for-adding-and-removing-featur.patch
+- Add 0120-libmultipath-fix-queue_mode-feature-handling.patch
+- Add 0121-multipath-tests-tests-for-reconcile_features_with_qu.patch
+- Add 0122-libmultipath-prepare-proto_id-for-use-by-non-scsi-de.patch
+- Add 0123-libmultipath-get-nvme-path-transport-protocol.patch
+- Add 0124-libmultipath-enforce-queue_mode-bio-for-nmve-tcp-pat.patch
+  * Fixes bz #2022359
+- Resolves: bz #2022359, #2128885
+
+* Thu Oct 13 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-31
+- Add 0114-multipathd-ignore-duplicated-multipathd-command-keys.patch
+  * Fixes bz #2133996
+- Add 0115-multipath-tools-use-run-instead-of-dev-shm.patch
+  * Fixes bz #2133990
+- Resolves: bz #2133990, #2133996
+
+* Fri Sep  9 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-30
+- Add 0111-multipathd-factor-out-the-code-to-flush-a-map-with-n.patch
+- Add 0112-libmultipath-return-success-if-we-raced-to-remove-a-.patch
+- Add 0113-multipathd-Handle-losing-all-path-in-update_map.patch
+- Resolves: bz #2110485
+
+* Fri Sep  2 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-29
+- Rebuild for rhel-8.8.0
+- Resolves: bz #2123446
+
+* Wed Aug 24 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-28
+- Add 0110-multipath-fix-systemd-timers-in-the-initramfs.patch
+- Resolves: bz #1916168
+
+* Fri Aug 19 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-27
+- Add 0108-multipathd-Add-missing-ctype-include.patch
+- Add 0109-multipathd-replace-libreadline-with-libedit.patch
+  * replace readline with libedit, to avoid license conflicts
+- Resolves: bz #2119887
+
+* Wed Jun  8 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-26
+- Add 0107-libmultipath-unset-detect_checker-for-clariion-Unity.patch
+- Resolves: bz #2082205
+
+* Tue May 17 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-25
+- Add 0105-multipathd-handle-fpin-events.patch
+- Add 0106-multipathd-disallow-changing-to-from-fpin-marginal-p.patch
+- Resolves: bz #2083077
+
+* Mon May 16 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-24
+- Add 0094-multipath-return-failure-on-an-invalid-remove-comman.patch
+  * Fixes bz #2052054
+- Add 0095-libmultipath-steal-the-src-string-pointer-in-merge_s.patch
+- Add 0096-libmultipath-enable-linear-ordering-of-bus-proto-tup.patch
+- Add 0097-libmultipath-use-bus_protocol_id-in-snprint_path_pro.patch
+- Add 0098-libmultipath-make-protocol_name-global.patch
+- Add 0099-libmultipath-add-a-protocol-subsection-to-multipath..patch
+- Add 0100-libmultipath-Set-the-scsi-timeout-parameters-by-path.patch
+- Add 0101-libmultipath-check-the-overrides-pctable-for-path-va.patch
+- Add 0102-libmultipath-fix-eh_deadline-documentation.patch
+- Add 0103-libmultipath-Add-documentation-for-the-protocol-subs.patch
+- Add 0104-libmultipath-use-symbolic-value-for-invalid-pcentry.patch
+  * The above 10 patches implement feature from bz #2065477
+- Resolves: bz #2052054, #2065477
+
 * Tue May 10 2022 Benjamin Marzinski <bmarzins@redhat.com> 0.8.4-23
 - Add 0091-multipath-tools-add-HPE-MSA-1060-2060-to-hwtable.patch
   * Partial fix for bz #2058222