Strictly ignore duplicate PVs

In commands and lvmetad, if a pvid already exists on
one device, and a second device appears with the same
pvid, then ignore the second device.

Previously, commands and lvmetad attempted to juggle both
devices for the same PV.

Commands using lvmetad will no longer see persistent
warnings about duplicates because they won't be seen.

In 'pvs -a' or 'pvs dev', an ignored duplicate device
now looks like a non-PV, and the chosen device in a
duplicate pair looks like the only device for the PV.

5 files changed, 33 insertions, 547 deletions

diff --git a/daemons/lvmetad/lvmetad-core.c b/daemons/lvmetad/lvmetad-core.c
index d0c5589a1..4f1fd9ecb 100644
--- a/daemons/lvmetad/lvmetad-core.c
+++ b/daemons/lvmetad/lvmetad-core.c
@@ -1971,46 +1971,12 @@ out:
 	return retval;
 }
 
-static dev_t device_remove(lvmetad_state *s, struct dm_config_tree *pvmeta, dev_t device)
-{
-	struct dm_config_node *pvmeta_tmp;
-	struct dm_config_value *v = NULL;
-	dev_t alt_device = 0, prim_device = 0;
-
-	if ((pvmeta_tmp = dm_config_find_node(pvmeta->root, "pvmeta/devices_alternate")))
-		v = pvmeta_tmp->v;
-
-	prim_device = dm_config_find_int64(pvmeta->root, "pvmeta/device", 0);
-
-	/* it is the primary device */
-	if (device > 0 && device == prim_device && pvmeta_tmp && pvmeta_tmp->v)
-	{
-		alt_device = pvmeta_tmp->v->v.i;
-		pvmeta_tmp->v = pvmeta_tmp->v->next;
-		pvmeta_tmp = dm_config_find_node(pvmeta->root, "pvmeta/device");
-		pvmeta_tmp->v->v.i = alt_device;
-	} else if (device != prim_device)
-		alt_device = prim_device;
-
-	/* it is an alternate device */
-	if (device > 0 && v && v->v.i == device)
-		pvmeta_tmp->v = v->next;
-	else while (device > 0 && pvmeta_tmp && v) {
-		if (v->next && v->next->v.i == device)
-			v->next = v->next->next;
-		v = v->next;
-	}
-
-	return alt_device;
-}
-
 static response pv_gone(lvmetad_state *s, request r)
 {
 	const char *arg_pvid = NULL;
 	char *old_pvid = NULL;
 	const char *pvid;
 	int64_t device;
-	int64_t alt_device = 0;
 	struct dm_config_tree *pvmeta;
 	char *vgid;
 
@@ -2040,17 +2006,7 @@ static response pv_gone(lvmetad_state *s, request r)
 	vgid = dm_hash_lookup(s->pvid_to_vgid, pvid);
 
 	dm_hash_remove_binary(s->device_to_pvid, &device, sizeof(device));
-
-	alt_device = device_remove(s, pvmeta, device);
-
-	if (!alt_device) {
-		/* The PV was not a duplicate, so remove it. */
-		dm_hash_remove(s->pvid_to_pvmeta, pvid);
-	} else {
-		/* The PV remains on another device. */
-		DEBUGLOG(s, "pv_gone %s device %" PRIu64 " has alt_device %" PRIu64,
-			 pvid, device, alt_device);
-	}
+	dm_hash_remove(s->pvid_to_pvmeta, pvid);
 
 	unlock_pvid_to_pvmeta(s);
 
@@ -2072,18 +2028,11 @@ static response pv_gone(lvmetad_state *s, request r)
 		vgid = NULL;
 	}
 
-	if (!alt_device) {
-		dm_config_destroy(pvmeta);
-		if (old_pvid)
-			dm_free(old_pvid);
-	}
+	dm_config_destroy(pvmeta);
+	if (old_pvid)
+		dm_free(old_pvid);
 
-	if (alt_device) {
-		return daemon_reply_simple("OK",
-					   "device = %"PRId64, alt_device,
-					   NULL);
-	} else
-		return daemon_reply_simple("OK", NULL );
+	return daemon_reply_simple("OK", NULL );
 }
 
 static response pv_clear_all(lvmetad_state *s, request r)
@@ -2202,10 +2151,7 @@ static response pv_found(lvmetad_state *s, request r)
 	struct dm_config_tree *new_pvmeta = NULL;
 	struct dm_config_tree *prev_pvmeta_on_dev = NULL;
 	struct dm_config_tree *vgmeta = NULL;
-	struct dm_config_node *altdev = NULL;
-	struct dm_config_value *altdev_v = NULL;
 	const char *arg_pvid = NULL;
-	const char *arg_pvid_dup = NULL;
 	const char *arg_pvid_lookup = NULL;
 	const char *new_pvid = NULL;
 	const char *new_pvid_dup = NULL;
@@ -2383,40 +2329,14 @@ static response pv_found(lvmetad_state *s, request r)
 	} else if (new_pvid && !new_device) {
 		/*
 		 * New PV on old device (existing device reused for new PV).
-		 * The previous PV on arg_device may or may not still exist,
-		 * this is determined by device_remove() which checks the
-		 * pvmeta for the previous PV (prev_pvid_on_dev and
-		 * prev_pvmeta_on_dev) to see if arg_device was the only
-		 * device for the PV, or if arg_device was a duplicate for
-		 * the PV.  If arg_device was previously a duplicate, then
-		 * the prev PV should be kept, but with arg_device removed.
-		 * If arg_device was the only device for the prev PV, then
-		 * the prev PV should be removed entirely.
+		 * The previous PV on arg_device is replaced by the new one.
 		 *
-		 * In either case, don't free prev_pvid or prev_vgid
-		 * strings because they are used at the end to check
-		 * the VG metadata.
+		 * Don't free prev_pvid or prev_vgid strings because they are
+		 * used at the end to check the VG metadata.
 		 */
 		changed |= 1;
 
-		if (prev_pvmeta_on_dev &&
-		    !device_remove(s, prev_pvmeta_on_dev, arg_device)) {
-			/*
-			 * The prev PV has no remaining device after
-			 * removing arg_device, so arg_device was not a
-			 * duplicate; remove the prev PV entirely.
-			 *
-			 * (hash_remove in pvid_to_vgid is done at the
-			 * end after the VG metadata is checked)
-			 *
-			 * FIXME: we could check if the new pvid is a new
-			 * duplicate of another existing PV.  This can happen:
-			 * start with two different pvs A and B,
-			 * dd if=A of=B, pvscan --cache B.  This detects that
-			 * B is removed, but doesn't detect that A is now a
-			 * duplicate.  ('pvscan --cache' does detect the
-			 * dup because all pvs are scanned.)
-			 */
+		if (prev_pvmeta_on_dev) {
 			DEBUGLOG(s, "pv_found new pvid device_to_pvid %" PRIu64 " to %s removes prev pvid %s",
 				 arg_device, new_pvid, prev_pvid_on_dev);
 
@@ -2426,23 +2346,22 @@ static response pv_found(lvmetad_state *s, request r)
 
 			/* removes arg_device/prev_pvid_on_dev mapping */
 			dm_hash_remove_binary(s->device_to_pvid, &arg_device, sizeof(arg_device));
-		} else {
+
 			/*
-			 * The prev PV existing on a remaining alternate
-			 * device after removing arg_device, so arg_device
-			 * was a duplicate; keep the prev PV.
-			 *
-			 * FIXME: if the duplicate devices were path aliases
-			 * to the same underlying device, then keeping the
-			 * prev PV for the remaining alt device isn't nice.
+			 * The new PV replacing the prev PV was copied from
+			 * another existing PV, creating a duplicate PV which
+			 * we ignore.
 			 */
-			DEBUGLOG(s, "pv_found new pvid device_to_pvid %" PRIu64 " to %s keeping prev pvid %s",
-				 arg_device, new_pvid, prev_pvid_on_dev);
-
-			/* removes arg_device/prev_pvid_on_dev mapping */
-			dm_hash_remove_binary(s->device_to_pvid, &arg_device, sizeof(arg_device));
+			if (dm_hash_lookup(s->pvid_to_pvmeta, new_pvid)) {
+				DEBUGLOG(s, "pv_found ignore duplicate device %" PRIu64 " of existing PV for pvid %s",
+				         arg_device, arg_pvid);
+				unlock_pvid_to_pvmeta(s);
+				dm_config_destroy(new_pvmeta);
+				return reply_fail("Ignore duplicate PV");
+			}
 		}
 
+
 		if (!(new_pvid_dup = dm_strdup(new_pvid)))
 			goto nomem;
 
@@ -2455,57 +2374,13 @@ static response pv_found(lvmetad_state *s, request r)
 	} else if (new_device && !new_pvid) {
 		/*
 		 * Old PV on new device (duplicate)
-		 * . add new_device/arg_pvid mapping
-		 * . leave existing old_device/arg_pvid mapping
-		 * . add new_pvmeta, replacing old_pvmeta
-		 * . modify new_pvmeta, adding an alternate device entry for old_device
+		 * Ignore it.
 		 */
-		changed |= 1;
-
-		DEBUGLOG(s, "pv_found new device device_to_pvid %" PRIu64 " to %s also %" PRIu64 " to %s",
-			 new_device, arg_pvid, old_device, arg_pvid);
-
-		if (!(arg_pvid_dup = dm_strdup(arg_pvid)))
-			goto nomem;
-
-		if (!dm_hash_insert_binary(s->device_to_pvid, &new_device, sizeof(new_device), (char *)arg_pvid_dup))
-			goto nomem;
-
-		if (!dm_hash_insert(s->pvid_to_pvmeta, arg_pvid, new_pvmeta))
-			goto nomem;
-
-		/* Copy existing altdev info, or create new, and add it to new pvmeta. */
-		if ((altdev = dm_config_find_node(old_pvmeta->root, "pvmeta/devices_alternate"))) {
-			if (!(altdev = dm_config_clone_node(new_pvmeta, altdev, 0)))
-				goto nomem;
-			chain_node(altdev, new_pvmeta->root, 0);
-		} else {
-			if (!(altdev = make_config_node(new_pvmeta, "devices_alternate", new_pvmeta->root, 0)))
-				goto nomem;
-		}
-
-		/* Add an altdev entry for old_device. */
-		altdev_v = altdev->v;
-		while (1) {
-			if (altdev_v && altdev_v->v.i == old_device)
-				break;
-			if (altdev_v)
-				altdev_v = altdev_v->next;
-			if (!altdev_v) {
-				if (!(altdev_v = dm_config_create_value(new_pvmeta)))
-					goto nomem;
-				altdev_v->next = altdev->v;
-				altdev->v = altdev_v;
-				altdev->v->v.i = old_device;
-				break;
-			}
-		};
-		altdev_v = altdev->v;
-		while (altdev_v) {
-			if (altdev_v->next && altdev_v->next->v.i == new_device)
-				altdev_v->next = altdev_v->next->next;
-			altdev_v = altdev_v->next;
-		}
+		DEBUGLOG(s, "pv_found ignore duplicate device %" PRIu64 " of existing device %" PRIu64 " for pvid %s",
+			 new_device, old_device, arg_pvid);
+		unlock_pvid_to_pvmeta(s);
+		dm_config_destroy(new_pvmeta);
+		return reply_fail("Ignore duplicate PV");
 	}
 
 	unlock_pvid_to_pvmeta(s);
diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c
index 8ab1a3191..acb6ae927 100644
--- a/lib/cache/lvmcache.c
+++ b/lib/cache/lvmcache.c
@@ -68,7 +68,6 @@ struct lvmcache_vginfo {
 	unsigned vg_use_count;	/* Counter of vg reusage */
 	unsigned precommitted;	/* Is vgmetadata live or precommitted? */
 	unsigned cached_vg_invalidated;	/* Signal to regenerate cached_vg */
-	unsigned preferred_duplicates; /* preferred duplicate pvs have been set */
 };
 
 static struct dm_hash_table *_pvid_hash = NULL;
@@ -80,7 +79,6 @@ static int _scanning_in_progress = 0;
 static int _has_scanned = 0;
 static int _vgs_locked = 0;
 static int _vg_global_lock_held = 0;	/* Global lock held when cache wiped? */
-static int _found_duplicate_pvs = 0;	/* If we never see a duplicate PV we can skip checking for them later. */
 
 int lvmcache_init(void)
 {
@@ -117,47 +115,6 @@ int lvmcache_init(void)
 	return 1;
 }
 
-/*
- * Once PV info has been populated in lvmcache and
- * lvmcache has chosen preferred duplicate devices,
- * set this flag so that lvmcache will not try to
- * compare and choose preferred duplicate devices
- * again (which may result in different preferred
- * devices.)  PV info can be populated in lvmcache
- * multiple times, each time causing lvmcache to
- * compare the duplicate devices, so we need to
- * record that the comparison/preferences have
- * already been done, so the preferrences from the
- * first time through are not changed.
- *
- * This is something of a hack to work around the
- * fact that the code isn't really designed to
- * handle duplicate PVs, and the fact that lvmetad
- * has its own way of picking a preferred duplicate
- * and lvmcache has another way based on having
- * more information than lvmetad does.
- *
- * If we come up with a better overall method to
- * handle duplicate PVs, then this can probably be
- * removed.
- *
- * FIXME: if we want to make lvmetad work with clvmd,
- * then this may need to be changed to set
- * preferred_duplicates back to 0.
- */
-
-void lvmcache_set_preferred_duplicates(const char *vgid)
-{
-	struct lvmcache_vginfo *vginfo;
-
-	if (!(vginfo = lvmcache_vginfo_from_vgid(vgid))) {
-		stack;
-		return;
-	}
-
-	vginfo->preferred_duplicates = 1;
-}
-
 void lvmcache_seed_infos_from_lvmetad(struct cmd_context *cmd)
 {
 	if (!lvmetad_active() || _has_scanned)
@@ -451,16 +408,6 @@ int lvmcache_vgs_locked(void)
 	return _vgs_locked;
 }
 
-/*
- * When lvmcache sees a duplicate PV, this is set.
- * process_each_pv() can avoid searching for duplicates
- * by checking this and seeing that no duplicate PVs exist.
- */
-int lvmcache_found_duplicate_pvs(void)
-{
-	return _found_duplicate_pvs;
-}
-
 static void _vginfo_attach_info(struct lvmcache_vginfo *vginfo,
 				struct lvmcache_info *info)
 {
@@ -1597,92 +1544,11 @@ int lvmcache_update_vg(struct volume_group *vg, unsigned precommitted)
 	return 1;
 }
 
-/*
- * Replace pv->dev with dev so that dev will appear for reporting.
- */
-
-void lvmcache_replace_dev(struct cmd_context *cmd, struct physical_volume *pv,
-			  struct device *dev)
-{
-	struct lvmcache_info *info;
-	char pvid_s[ID_LEN + 1] __attribute__((aligned(8)));
-
-	strncpy(pvid_s, (char *) &pv->id, sizeof(pvid_s) - 1);
-	pvid_s[sizeof(pvid_s) - 1] = '\0';
-
-	if (!(info = lvmcache_info_from_pvid(pvid_s, 0)))
-		return;
-
-	info->dev = dev;
-	info->label->dev = dev;
-	pv->dev = dev;
-}
-
-/*
- * We can see multiple different devices with the
- * same pvid, i.e. duplicates.
- *
- * There may be different reasons for seeing two
- * devices with the same pvid:
- * - multipath showing two paths to the same thing
- * - one device copied to another, e.g. with dd,
- *   also referred to as cloned devices.
- * - a "subsystem" taking a device and creating
- *   another device of its own that represents the
- *   underlying device it is using, e.g. using dm
- *   to create an identity mapping of a PV.
- *
- * Given duplicate devices, we have to choose one
- * of them to be the "preferred" dev, i.e. the one
- * that will be referenced in lvmcache, by pv->dev.
- * We can keep the existing dev, that's currently
- * used in lvmcache, or we can replace the existing
- * dev with the new duplicate.
- *
- * Regardless of which device is preferred, we need
- * to print messages explaining which devices were
- * found so that a user can sort out for themselves
- * what has happened if the preferred device is not
- * the one they are interested in.
- *
- * If a user wants to use the non-preferred device,
- * they will need to filter out the device that
- * lvm is preferring.
- *
- * The dev_subsystem calls check if the major number
- * of the dev is part of a subsystem like DM/MD/DRBD.
- * A dev that's part of a subsystem is preferred over a
- * duplicate of that dev that is not part of a
- * subsystem.
- *
- * The has_holders calls check if the device is being
- * used by another, and prefers one that's being used.
- *
- * FIXME: why do we prefer a device without holders
- * over a device with holders?  We should understand
- * the reason for that choice.
- *
- * FIXME: there may be other reasons to prefer one
- * device over another:
- *
- * . are there other use/open counts we could check
- *   beyond the holders?
- *
- * . check if either is bad/usable and prefer
- *   the good one?
- *
- * . prefer the one with smaller minor number?
- *   Might avoid disturbing things due to a new
- *   transient duplicate?
- */
-
 struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 				   struct device *dev,
 				   const char *vgname, const char *vgid,
 				   uint32_t vgstatus)
 {
-	const struct format_type *fmt = labeller->fmt;
-	struct dev_types *dt = fmt->cmd->dev_types;
 	struct label *label;
 	struct lvmcache_info *existing, *info;
 	char pvid_s[ID_LEN + 1] __attribute__((aligned(8)));
@@ -1723,142 +1589,10 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 		lvmcache_del_bas(info);
 	} else {
 		if (existing->dev != dev) {
-			int old_in_subsystem = 0;
-			int new_in_subsystem = 0;
-			int old_is_dm = 0;
-			int new_is_dm = 0;
-			int old_has_holders = 0;
-			int new_has_holders = 0;
-
-			/*
-			 * Here are different devices with the same pvid:
-			 * duplicates.  See comment above.
-			 */
-
-			/*
-			 * This flag tells the process_each_pv code to search
-			 * the devices list for duplicates, so that devices
-			 * can be processed together with their duplicates
-			 * (while processing the VG, rather than reporting
-			 * pv->dev under the VG, and its duplicate outside
-			 * the VG context.)
-			 */
-			_found_duplicate_pvs = 1;
-
-			/*
-			 * The new dev may not have pvid set.
-			 * The process_each_pv code needs to have the pvid
-			 * set in each device to detect that the devices
-			 * are duplicates.
-			 */
-			strncpy(dev->pvid, pvid_s, sizeof(dev->pvid));
-
-			/*
-			 * Now decide if we are going to ignore the new
-			 * device, or replace the existing/old device in
-			 * lvmcache with the new one.
-			 */
-			old_in_subsystem = dev_subsystem_part_major(dt, existing->dev);
-			new_in_subsystem = dev_subsystem_part_major(dt, dev);
-
-			old_is_dm = dm_is_dm_major(MAJOR(existing->dev->dev));
-			new_is_dm = dm_is_dm_major(MAJOR(dev->dev));
-
-			old_has_holders = dm_device_has_holders(MAJOR(existing->dev->dev), MINOR(existing->dev->dev));
-			new_has_holders = dm_device_has_holders(MAJOR(dev->dev), MINOR(dev->dev));
-
-			if (old_has_holders && new_has_holders) {
-				/*
-				 * This is not a selection of old or new, but
-				 * just a warning to be aware of.
-				 */
-				log_warn("WARNING: duplicate PV %s is being used from both devices %s and %s",
-					 pvid_s,
-					 dev_name(existing->dev),
-					 dev_name(dev));
-			}
-
-			if (existing->vginfo->preferred_duplicates) {
-				/*
-				 * The preferred duplicate devs have already
-				 * been chosen during a previous populating of
-				 * lvmcache, so just use the existing preferences.
-				 */
-				log_warn("Found duplicate PV %s: using existing dev %s",
-					 pvid_s,
-					 dev_name(existing->dev));
-				return NULL;
-			}
-
-			if (old_in_subsystem && !new_in_subsystem) {
-				/* Use old, ignore new. */
-				log_warn("Found duplicate PV %s: using %s not %s",
-					 pvid_s,
-					 dev_name(existing->dev),
-					 dev_name(dev));
-				log_warn("Using duplicate PV %s from subsystem %s, ignoring %s",
-					 dev_name(existing->dev),
-					 dev_subsystem_name(dt, existing->dev),
-					 dev_name(dev));
-				return NULL;
-
-			} else if (!old_in_subsystem && new_in_subsystem) {
-				/* Use new, replace old. */
-				log_warn("Found duplicate PV %s: using %s not %s",
-					 pvid_s,
-					 dev_name(dev),
-					 dev_name(existing->dev));
-				log_warn("Using duplicate PV %s from subsystem %s, replacing %s",
-					 dev_name(dev),
-					 dev_subsystem_name(dt, dev),
-					 dev_name(existing->dev));
-
-			} else if (old_has_holders && !new_has_holders) {
-				/* Use new, replace old. */
-				/* FIXME: why choose the one without olders? */
-				log_warn("Found duplicate PV %s: using %s not %s",
-					 pvid_s,
-					 dev_name(dev),
-					 dev_name(existing->dev));
-				log_warn("Using duplicate PV %s without holders, replacing %s",
-					 dev_name(dev),
-					 dev_name(existing->dev));
-
-			} else if (!old_has_holders && new_has_holders) {
-				/* Use old, ignore new. */
-				log_warn("Found duplicate PV %s: using %s not %s",
-					 pvid_s,
-					 dev_name(existing->dev),
-					 dev_name(dev));
-				log_warn("Using duplicate PV %s without holders, ignoring %s",
-					 dev_name(existing->dev),
-					 dev_name(dev));
-				return NULL;
-
-			} else if (old_is_dm && new_is_dm) {
-				/* Use new, replace old. */
-				/* FIXME: why choose the new instead of the old? */
-				log_warn("Found duplicate PV %s: using %s not %s",
-					 pvid_s,
-					 dev_name(dev),
-					 dev_name(existing->dev));
-				log_warn("Using duplicate PV %s which is last seen, replacing %s",
-					 dev_name(dev),
-					 dev_name(existing->dev));
-
-			} else if (!strcmp(pvid_s, existing->dev->pvid)) {
-				/* No criteria to use for preferring old or new. */
-				/* FIXME: why choose the new instead of the old? */
-				/* FIXME: a transient duplicate would be a reason
-				 * to select the old instead of the new. */
-				log_warn("Found duplicate PV %s: using %s not %s",
-					 pvid_s,
-					 dev_name(dev),
-					 dev_name(existing->dev));
-				log_warn("Using duplicate PV %s which is last seen, replacing %s",
-					 dev_name(dev),
-					 dev_name(existing->dev));
-			}
+			log_warn("Ignore duplicate PV on device %s. Already using PV from device %s. (%s)",
+				 dev_name(dev), dev_name(existing->dev), pvid_s);
+			log_warn("Use the global_filter to select a different device.");
+			return NULL;
 		} else {
 			/*
 			 * The new dev is the same as the existing dev.
diff --git a/lib/cache/lvmcache.h b/lib/cache/lvmcache.h
index ccf3eb498..b2abfa549 100644
--- a/lib/cache/lvmcache.h
+++ b/lib/cache/lvmcache.h
@@ -181,13 +181,6 @@ unsigned lvmcache_mda_count(struct lvmcache_info *info);
 int lvmcache_vgid_is_cached(const char *vgid);
 uint64_t lvmcache_smallest_mda_size(struct lvmcache_info *info);
 
-void lvmcache_replace_dev(struct cmd_context *cmd, struct physical_volume *pv,
-			struct device *dev);
-
-int lvmcache_found_duplicate_pvs(void);
-
-void lvmcache_set_preferred_duplicates(const char *vgid);
-
 int lvmcache_contains_lock_type_sanlock(struct cmd_context *cmd);
 
 void lvmcache_get_max_name_lengths(struct cmd_context *cmd,
diff --git a/lib/cache/lvmetad.c b/lib/cache/lvmetad.c
index 15cc3fbe8..466d962dc 100644
--- a/lib/cache/lvmetad.c
+++ b/lib/cache/lvmetad.c
@@ -469,17 +469,14 @@ static int _pv_populate_lvmcache(struct cmd_context *cmd,
 				 struct dm_config_node *cn,
 				 struct format_type *fmt, dev_t fallback)
 {
-	struct device *dev, *dev_alternate, *dev_alternate_cache = NULL;
-	struct label *label;
+	struct device *dev;
 	struct id pvid, vgid;
 	char mda_id[32];
 	char da_id[32];
 	int i = 0;
 	struct dm_config_node *mda, *da;
-	struct dm_config_node *alt_devices = dm_config_find_node(cn->child, "devices_alternate");
-	struct dm_config_value *alt_device = NULL;
 	uint64_t offset, size;
-	struct lvmcache_info *info, *info_alternate;
+	struct lvmcache_info *info;
 	const char *pvid_txt = dm_config_find_str(cn->child, "id", NULL),
 		   *vgid_txt = dm_config_find_str(cn->child, "vgid", NULL),
 		   *vgname = dm_config_find_str(cn->child, "vgname", NULL),
@@ -562,41 +559,6 @@ static int _pv_populate_lvmcache(struct cmd_context *cmd,
 		++i;
 	} while (da);
 
-	if (alt_devices)
-		alt_device = alt_devices->v;
-
-	while (alt_device) {
-		dev_alternate = dev_cache_get_by_devt(alt_device->v.i, cmd->filter);
-
-		log_verbose("PV on device %s (%d:%d %d) is also on device %s (%d:%d %d) %s",
-			    dev_name(dev),
-			    (int)MAJOR(devt), (int)MINOR(devt), (int)devt,
-			    dev_alternate ? dev_name(dev_alternate) : "unknown",
-			    (int)MAJOR(alt_device->v.i), (int)MINOR(alt_device->v.i), (int)alt_device->v.i,
-			    pvid_txt);
-
-		if (dev_alternate) {
-			if ((info_alternate = lvmcache_add(fmt->labeller, (const char *)&pvid, dev_alternate,
-							   vgname, (const char *)&vgid, 0))) {
-				dev_alternate_cache = dev_alternate;
-				info = info_alternate;
-				lvmcache_get_label(info)->dev = dev_alternate;
-			}
-		}
-		alt_device = alt_device->next;
-	}
-
-	/*
-	 * Update lvmcache with the info about the alternate device by
-	 * reading its label, which should update lvmcache.
-	 */
-	if (dev_alternate_cache) {
-		if (!label_read(dev_alternate_cache, &label, 0)) {
-			log_warn("No PV label found on duplicate device %s.", dev_name(dev_alternate_cache));
-		}
-	}
-
-	lvmcache_set_preferred_duplicates((const char *)&vgid);
 	return 1;
 }
 
diff --git a/tools/toollib.c b/tools/toollib.c
index a52252e97..7ac4a2665 100644
--- a/tools/toollib.c
+++ b/tools/toollib.c
@@ -2802,7 +2802,6 @@ static int _process_pvs_in_vg(struct cmd_context *cmd,
 	struct physical_volume *pv;
 	struct pv_list *pvl;
 	struct device_id_list *dil;
-	struct device *dev_orig;
 	const char *pv_name;
 	int selected;
 	int process_pv;
@@ -2883,83 +2882,6 @@ static int _process_pvs_in_vg(struct cmd_context *cmd,
 				if (ret > ret_max)
 					ret_max = ret;
 			}
-
-			/*
-			 * We have processed the PV on device pv->dev.  Now
-			 * deal with any duplicates of this PV on other
-			 * devices.
-			 */
-
-			/*
-			 * This is a very rare and obscure case where multiple
-			 * duplicate devices are specified on the command line
-			 * referring to this PV.  In this case we want to
-			 * process this PV once for each specified device.
-			 */
-			if (!skip && !dm_list_empty(arg_devices)) {
-				while ((dil = _device_list_find_pvid(arg_devices, pv))) {
-					_device_list_remove(arg_devices, dil->dev);
-
-					/*
-					 * Replace pv->dev with this dil->dev
-					 * in lvmcache so the duplicate dev
-					 * info will be reported.  FIXME: it
-					 * would be nicer to override pv->dev
-					 * without munging lvmcache content.
-					 */
-					dev_orig = pv->dev;
-					lvmcache_replace_dev(cmd, pv, dil->dev);
-
-					log_very_verbose("Processing PV %s device %s in VG %s.",
-							 pv_name, dev_name(dil->dev), vg->name);
-
-					ret = process_single_pv(cmd, vg, pv, handle);
-					if (ret != ECMD_PROCESSED)
-						stack;
-					if (ret > ret_max)
-						ret_max = ret;
-
-					/* Put the cache state back as it was. */
-					lvmcache_replace_dev(cmd, pv, dev_orig);
-				}
-			}
-
-			/*
-			 * This is another rare and obscure case where multiple
-			 * duplicate devices are being displayed by pvs -a, and
-			 * we want each of them to be displayed in the context
-			 * of this VG, so that this VG name appears next to it.
-			 */
-			if (process_all_devices && lvmcache_found_duplicate_pvs()) {
-				while ((dil = _device_list_find_pvid(all_devices, pv))) {
-					_device_list_remove(all_devices, dil->dev);
-
-					dev_orig = pv->dev;
-					lvmcache_replace_dev(cmd, pv, dil->dev);
-
-					ret = process_single_pv(cmd, vg, pv, handle);
-					if (ret != ECMD_PROCESSED)
-						stack;
-					if (ret > ret_max)
-						ret_max = ret;
-
-					lvmcache_replace_dev(cmd, pv, dev_orig);
-				}
-			}
-
-			/*
-			 * Remove any duplicates of the processed device from
-			 * the list of all devices.  If they were left in the
-			 * list of all devices, they would be considered
-			 * "missed" at the end.
-			 */
-			if (process_all_pvs && lvmcache_found_duplicate_pvs()) {
-				while ((dil = _device_list_find_pvid(all_devices, pv))) {
-					log_very_verbose("Skip duplicate device %s of processed device %s",
-							 dev_name(dil->dev), dev_name(pv->dev));
-					_device_list_remove(all_devices, dil->dev);
-				}
-			}
 		}
 
 		/*