fix(applycheck): exclude kernel-virtual disks from selector candidates and hints

Real Talos hosts running cozystack accumulate dozens of virtual block
devices (dm-* from LVM, drbd* from DRBD-replicated PVs, loop* from
container image layers). Talos's block.DiskSpec marks all of these
with bus_path="/virtual"; the install-disk picker never lands on
them, and a pre-apply selector hitting one would be a silent misdirect.

Surface that exclusion in both validation paths:

- matchSelector now skips bus_path=/virtual disks the same way it
  skips Readonly and CDROM, so a 'type: ssd' selector on a host with
  hundreds of loop/dm/drbd devices doesn't surface a spurious
  'multiple matches' warning.
- diskPathList and summarizeDisks omit the virtual class from operator-
  facing hints, replacing a 19-entry scroll of dm/drbd/loop noise on
  a cozystack host with the actionable 'available disks: /dev/sda,
  /dev/sdb' two-name list verified on a live OCI v1.12.6 cluster.

Refs: #172
Signed-off-by: Aleksei Sviridkin <f@lex.la>

Author: lexfrei

pkg/applycheck/selector.go

@@ -35,10 +35,16 @@ const (
 	transportNVMe = "nvme"
 )
 
+// virtualBusPath is the BusPath value Talos assigns to kernel-virtual
+// block devices (loop, dm, drbd, ram, ...). Real disks live under a
+// PCI / virtio / etc. bus path; matchSelector excludes virtual devices
+// from candidacy so a selector never silently lands on /dev/loop0.
+const virtualBusPath = "/virtual"
+
 // matchSelector returns every disk in candidates that satisfies every
-// non-empty field of sel, excluding read-only and CD-ROM devices the
-// way Talos's install-disk resolution does. An empty selector matches
-// every non-excluded candidate.
+// non-empty field of sel, excluding read-only, CD-ROM, and kernel-virtual
+// devices the way Talos's install-disk resolution does. An empty
+// selector matches every non-excluded candidate.
 //
 // Match semantics mirror Talos's InstallDiskSelector at the level the
 // pre-apply gate cares about — model and busPath are shell-globs (Talos
@@ -52,7 +58,7 @@ func matchSelector(sel *DiskSelector, candidates []DiskInfo) []DiskInfo {
 	for i := range candidates {
 		disk := &candidates[i]
 
-		if disk.Readonly || disk.CDROM {
+		if isExcludedDisk(disk) {
 			continue
 		}
 
@@ -64,6 +70,14 @@ func matchSelector(sel *DiskSelector, candidates []DiskInfo) []DiskInfo {
 	return matches
 }
 
+// isExcludedDisk reports whether a disk should never be a selector
+// candidate. Readonly and CDROM are explicit Talos exclusions; virtual
+// devices (dm-*, drbd*, loop*) carry bus_path "/virtual" and are
+// inappropriate install / volume targets.
+func isExcludedDisk(disk *DiskInfo) bool {
+	return disk.Readonly || disk.CDROM || disk.BusPath == virtualBusPath
+}
+
 // diskPredicate is one rule the candidate disk has to satisfy. matchAll
 // short-circuits on the first false.
 type diskPredicate func(sel *DiskSelector, disk *DiskInfo) bool
@@ -232,12 +246,19 @@ func parseSize(raw string) (uint64, bool) {
 	return value, true
 }
 
-// diskPathList returns the sorted set of DiskInfo.DevPath values so error
-// messages list them in a stable, scannable order.
+// diskPathList returns the sorted set of DiskInfo.DevPath values for
+// non-excluded candidates so error messages list them in a stable,
+// scannable order without burying real candidates under noise from
+// dm/drbd/loop entries.
 func diskPathList(disks []DiskInfo) []string {
-	paths := make([]string, len(disks))
+	var paths []string
+
 	for i := range disks {
-		paths[i] = disks[i].DevPath
+		if isExcludedDisk(&disks[i]) {
+			continue
+		}
+
+		paths = append(paths, disks[i].DevPath)
 	}
 
 	sort.Strings(paths)
@@ -266,17 +287,24 @@ func joinAvailable(items []string) string {
 	return strings.Join(sorted, ", ")
 }
 
-// summarizeDisks returns a compact human-readable list of disks, one per
-// `path model serial size` triple. Used in selector-mismatch findings so
-// the operator can pick the right disk without running another command.
+// summarizeDisks returns a compact human-readable list of non-excluded
+// disks, one per `path model serial size` triple. Used in selector-
+// mismatch findings so the operator can pick the right disk without
+// running another command. Excluded devices (virtual, readonly, CD)
+// are omitted from the summary to keep the hint actionable.
 func summarizeDisks(disks []DiskInfo) string {
-	if len(disks) == 0 {
-		return noneText
-	}
+	var parts []string
 
-	parts := make([]string, len(disks))
 	for i := range disks {
-		parts[i] = formatDisk(&disks[i])
+		if isExcludedDisk(&disks[i]) {
+			continue
+		}
+
+		parts = append(parts, formatDisk(&disks[i]))
+	}
+
+	if len(parts) == 0 {
+		return noneText
 	}
 
 	sort.Strings(parts)

pkg/applycheck/validate_test.go

@@ -238,6 +238,69 @@ func TestValidateRefs_ReadonlyAndCDROMExcluded(t *testing.T) {
 	}
 }
 
+// TestValidateRefs_VirtualDisksExcluded pins the exclusion of kernel-
+// virtual block devices (loop, dm, drbd, ram). Talos block.DiskSpec
+// reports BusPath="/virtual" for those; the gate must skip them so a
+// selector like `type: ssd` on a cozystack host (which hosts many
+// loop/dm/drbd devices for DRBD-replicated PVs) doesn't surface a
+// spurious "multiple matches" warning across every install. Verified
+// on a live OCI cluster: real disks (sda, sdb) have PCI bus paths,
+// virtual disks (dm-*, drbd*, loop*) carry "/virtual".
+func TestValidateRefs_VirtualDisksExcluded(t *testing.T) {
+	t.Parallel()
+
+	refs := []applycheck.Ref{{
+		Kind:     applycheck.RefKindDiskSelector,
+		Selector: applycheck.DiskSelector{Type: "ssd"},
+	}}
+	snapshot := applycheck.HostSnapshot{
+		Disks: []applycheck.DiskInfo{
+			{DevPath: "/dev/sda", BusPath: "/pci0000:00/0000:00:04.0", Transport: "virtio", Rotational: false},
+			{DevPath: "/dev/dm-0", BusPath: "/virtual", Rotational: false},
+			{DevPath: "/dev/drbd1000", BusPath: "/virtual", Rotational: false},
+			{DevPath: "/dev/loop0", BusPath: "/virtual", Rotational: false},
+		},
+	}
+
+	findings := applycheck.ValidateRefs(refs, snapshot)
+	if len(findings) != 0 {
+		t.Errorf("expected one clean match (sda); virtual disks must be excluded, got findings=%+v", findings)
+	}
+}
+
+// TestValidateRefs_DiskLiteralHint_OmitsVirtual pins the hint output
+// scope: when a literal disk path doesn't resolve, the operator-facing
+// hint must list real block devices only, not virtual noise.
+func TestValidateRefs_DiskLiteralHint_OmitsVirtual(t *testing.T) {
+	t.Parallel()
+
+	refs := []applycheck.Ref{{
+		Kind: applycheck.RefKindDiskLiteral,
+		Name: "/dev/sdz",
+	}}
+	snapshot := applycheck.HostSnapshot{
+		Disks: []applycheck.DiskInfo{
+			{DevPath: "/dev/sda", BusPath: "/pci0000:00/0000:00:04.0"},
+			{DevPath: "/dev/dm-0", BusPath: "/virtual"},
+			{DevPath: "/dev/loop0", BusPath: "/virtual"},
+		},
+	}
+
+	findings := applycheck.ValidateRefs(refs, snapshot)
+	if len(findings) != 1 {
+		t.Fatalf("expected one blocker, got %+v", findings)
+	}
+
+	hint := findings[0].Hint
+	if strings.Contains(hint, "/dev/dm-0") || strings.Contains(hint, "/dev/loop0") {
+		t.Errorf("hint should omit virtual devices, got %q", hint)
+	}
+
+	if !strings.Contains(hint, "/dev/sda") {
+		t.Errorf("hint should list real disks, got %q", hint)
+	}
+}
+
 func TestValidateRefs_SelectorBySize_GreaterThanOrEqual(t *testing.T) {
 	t.Parallel()