feat: add LVM status controller

Signed-off-by: Mateusz Urbanek <mateusz.urbanek@siderolabs.com>

Author: shanduur

api/resource/definitions/storage/storage.proto

@@ -0,0 +1,109 @@
+syntax = "proto3";
+
+package talos.resource.definitions.storage;
+
+option go_package = "github.com/siderolabs/talos/pkg/machinery/api/resource/definitions/storage";
+option java_package = "dev.talos.api.resource.definitions.storage";
+
+// LVMLogicalVolumeStatusSpec is the spec for LVMLogicalVolumeStatus resource.
+//
+// Fields mirror the colon-separated output of `lvdisplay -c`.
+message LVMLogicalVolumeStatusSpec {
+  // Path is the device-mapper path of the LV, e.g. /dev/vg0/data.
+  string path = 1;
+  // VGName is the parent volume group name.
+  string vg_name = 2;
+  // Access is a bitmask of LV access flags (1=read, 2=write, 4=visible).
+  uint64 access = 3;
+  // Status is a bitmask of LV status flags (1=active, 2=allocated, …).
+  uint64 status = 4;
+  // InternalLVNumber is the historical internal LV index; always -1 in modern LVM, normalised to 0.
+  uint64 internal_lv_number = 5;
+  // OpenCount is the number of times the LV is currently open (mounted/held).
+  uint64 open_count = 6;
+  // SizeBytes is the LV size in bytes (sectors × 512 from the raw output).
+  uint64 size_bytes = 7;
+  // CurrentLE is the current number of logical extents allocated to the LV.
+  uint64 current_le = 8;
+  // AllocatedLE is the number of LEs allocated for snapshot/mirror copies; 0 for plain LVs.
+  uint64 allocated_le = 9;
+  // AllocPolicy is the allocation policy enum (0=normal, 1=contiguous, 2=anywhere, 3=cling, 4=inherit).
+  uint64 alloc_policy = 10;
+  // ReadAheadSectors is the configured read-ahead in 512-byte sectors; 0 means auto.
+  uint64 read_ahead_sectors = 11;
+  // Major is the kernel block-device major number for the LV.
+  uint32 major = 12;
+  // Minor is the kernel block-device minor number for the LV.
+  uint32 minor = 13;
+}
+
+// LVMPhysicalVolumeStatusSpec is the spec for LVMPhysicalVolumeStatus resource.
+//
+// Fields mirror the colon-separated output of `pvdisplay -c`.
+message LVMPhysicalVolumeStatusSpec {
+  // Device is the block-device path backing the PV, e.g. /dev/sda1.
+  string device = 1;
+  // VGName is the parent volume group name; empty if the PV is not assigned to a VG.
+  string vg_name = 2;
+  // SizeBytes is the usable PV size in bytes (sectors × 512 from the raw output).
+  uint64 size_bytes = 3;
+  // InternalPVNumber is the historical internal PV index; always -1 in modern LVM, normalised to 0.
+  uint64 internal_pv_number = 4;
+  // Status is a bitmask of PV status flags (allocatable, exported, missing, …).
+  uint64 status = 5;
+  // Allocatable mirrors the allocatable bit from Status; non-zero means new LVs can use this PV.
+  uint64 allocatable = 6;
+  // CurrentLE is the number of LEs currently in use on this PV; -1 in raw output is normalised to 0.
+  uint64 current_le = 7;
+  // PESize is the physical-extent size in bytes (KiB × 1024); matches the parent VG.
+  uint64 pe_size = 8;
+  // TotalPE is the total number of physical extents on this PV.
+  uint64 total_pe = 9;
+  // FreePE is the number of physical extents on this PV not yet allocated.
+  uint64 free_pe = 10;
+  // AllocPE is the number of physical extents on this PV currently allocated to LVs.
+  uint64 alloc_pe = 11;
+  // UUID is the stable PV identifier written to the PV label.
+  string uuid = 12;
+}
+
+// LVMVolumeGroupStatusSpec is the spec for LVMVolumeGroupStatus resource.
+//
+// Fields mirror the colon-separated output of `vgdisplay -c`.
+message LVMVolumeGroupStatusSpec {
+  // Name is the volume group name.
+  string name = 1;
+  // Access is the VG access mode string emitted by vgdisplay (e.g. "r/w", "r--").
+  string access = 2;
+  // Status is a bitmask of VG status flags (resizable, exported, clustered, …).
+  uint64 status = 3;
+  // InternalVGNumber is the historical internal VG index; always -1 in modern LVM, normalised to 0.
+  uint64 internal_vg_number = 4;
+  // MaxLV is the configured max number of LVs in the VG; 0 means no limit.
+  uint64 max_lv = 5;
+  // CurLV is the current number of LVs in the VG.
+  uint64 cur_lv = 6;
+  // OpenLV is the number of LVs in the VG that are currently open.
+  uint64 open_lv = 7;
+  // MaxLVSize is the configured per-LV size cap in sectors; 0 means no limit.
+  uint64 max_lv_size = 8;
+  // MaxPV is the configured max number of PVs in the VG; 0 means no limit.
+  uint64 max_pv = 9;
+  // CurPV is the current number of PVs in the VG.
+  uint64 cur_pv = 10;
+  // ActPV is the number of currently active PVs (online and accessible).
+  uint64 act_pv = 11;
+  // SizeBytes is the total VG size in bytes (KiB × 1024 from the raw output).
+  uint64 size_bytes = 12;
+  // PESize is the physical-extent size in bytes (KiB × 1024); 4 MiB by default.
+  uint64 pe_size = 13;
+  // TotalPE is the total number of physical extents in the VG.
+  uint64 total_pe = 14;
+  // AllocPE is the number of physical extents currently allocated to LVs.
+  uint64 alloc_pe = 15;
+  // FreePE is the number of physical extents available for new allocations.
+  uint64 free_pe = 16;
+  // UUID is the stable VG identifier used in LVM metadata.
+  string uuid = 17;
+}
+

hack/release.toml

@@ -114,6 +114,12 @@ The DNS protocol can be configured on a per-name server basis in the `ResolverCo
         description = """\
 Talos now supports a new `ImageCacheConfig` document for configuring the Image Cache feature, replacing the old `machine.features.imageCache` field in the v1alpha1 config.
 Old configuration is still supported for backwards compatibility.
+"""
+
+    [notes.lvm_status]
+        title = "LVM Status"
+        description = """\
+Talos now provides detailed LVM status information, allowing for better monitoring and management of LVM volumes.
 """
 
 [make_deps]

…pp/machined/pkg/controllers/block/lvm.go …kg/controllers/storage/lvm_activation.gointernal/app/machined/pkg/controllers/block/lvm.go renamed to internal/app/machined/pkg/controllers/storage/lvm_activation.go internal/app/machined/pkg/controllers/block/lvm.go renamed to internal/app/machined/pkg/controllers/storage/lvm_activation.go

@@ -2,28 +2,27 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-package block
+package storage
 
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/cosi-project/runtime/pkg/controller"
 	"github.com/cosi-project/runtime/pkg/safe"
 	"github.com/cosi-project/runtime/pkg/state"
 	"github.com/hashicorp/go-multierror"
 	"github.com/siderolabs/gen/optional"
-	"github.com/siderolabs/go-cmd/pkg/cmd"
 	"go.uber.org/zap"
 
 	machineruntime "github.com/siderolabs/talos/internal/app/machined/pkg/runtime"
+	"github.com/siderolabs/talos/pkg/lvm"
 	"github.com/siderolabs/talos/pkg/machinery/constants"
 	"github.com/siderolabs/talos/pkg/machinery/resources/block"
 	"github.com/siderolabs/talos/pkg/machinery/resources/v1alpha1"
 )
 
-// LVMActivationController activates LVM volumes when they are discovered by the block.DiscoveryController.
+// LVMActivationController activates LVM volume groups discovered by the block.DiscoveryController.
 type LVMActivationController struct {
 	V1Alpha1Mode machineruntime.Mode
 
@@ -33,7 +32,7 @@ type LVMActivationController struct {
 
 // Name implements controller.Controller interface.
 func (ctrl *LVMActivationController) Name() string {
-	return "block.LVMActivationController"
+	return "storage.LVMActivationController"
 }
 
 // Inputs implements controller.Controller interface.
@@ -161,18 +160,7 @@ func (ctrl *LVMActivationController) Run(ctx context.Context, r controller.Runti
 
 			logger.Info("activating LVM volume", zap.String("name", vgName))
 
-			// activate the volume group
-			if _, err = cmd.RunWithOptions(
-				ctx,
-				"/sbin/lvm",
-				[]string{
-					"vgchange",
-					"-aay",
-					"--autoactivation",
-					"event",
-					vgName,
-				},
-			); err != nil {
+			if err = lvm.VGChangeActivate(ctx, vgName); err != nil {
 				multiErr = multierror.Append(multiErr, fmt.Errorf("failed to activate LVM volume %s: %w", vgName, err))
 			} else {
 				ctrl.activatedVGs[vgName] = struct{}{}
@@ -185,43 +173,14 @@ func (ctrl *LVMActivationController) Run(ctx context.Context, r controller.Runti
 	}
 }
 
-// checkVGNeedsActivation checks if the device is part of a volume group and returns the volume group name
-// if it needs to be activated, otherwise it returns an empty string.
+// checkVGNeedsActivation checks if the device is part of a complete volume
+// group and returns that VG name when activation is needed; otherwise returns
+// an empty string. See lvmautoactivation(7).
 func (ctrl *LVMActivationController) checkVGNeedsActivation(ctx context.Context, devicePath string) (string, error) {
-	// first we check if all associated volumes are available
-	// https://man7.org/linux/man-pages/man7/lvmautoactivation.7.html
-	stdOut, err := cmd.RunWithOptions(
-		ctx,
-		"/sbin/lvm",
-		[]string{
-			"pvscan",
-			"--cache",
-			"--listvg",
-			"--checkcomplete",
-			"--vgonline",
-			"--autoactivation",
-			"event",
-			"--udevoutput",
-			devicePath,
-		},
-	)
+	udev, err := lvm.PVScanAutoActivation(ctx, devicePath)
 	if err != nil {
 		return "", fmt.Errorf("failed to check if LVM volume backed by device %s needs activation: %w", devicePath, err)
 	}
 
-	// parse the key-value pairs from the udev output
-	for line := range strings.SplitSeq(stdOut, "\n") {
-		key, value, ok := strings.Cut(line, "=")
-		if !ok {
-			continue
-		}
-
-		value = strings.Trim(value, "'\"")
-
-		if key == "LVM_VG_NAME_COMPLETE" {
-			return value, nil
-		}
-	}
-
-	return "", nil
+	return udev[lvm.UdevKeyVGNameComplete], nil
 }

internal/app/machined/pkg/controllers/storage/lvm_logical_volume_status.go

@@ -0,0 +1,124 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package storage
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/cosi-project/runtime/pkg/controller"
+	"github.com/cosi-project/runtime/pkg/safe"
+	"go.uber.org/zap"
+
+	"github.com/siderolabs/talos/pkg/lvm"
+	"github.com/siderolabs/talos/pkg/machinery/resources/block"
+	"github.com/siderolabs/talos/pkg/machinery/resources/storage"
+)
+
+// LVMLogicalVolumeStatusController manages LVMLogicalVolumeStatus resources.
+type LVMLogicalVolumeStatusController struct{}
+
+// Name implements controller.Controller interface.
+func (ctrl *LVMLogicalVolumeStatusController) Name() string {
+	return "storage.LVMLogicalVolumeStatusController"
+}
+
+// Inputs implements controller.Controller interface.
+func (ctrl *LVMLogicalVolumeStatusController) Inputs() []controller.Input {
+	return []controller.Input{
+		{
+			Namespace: block.NamespaceName,
+			Type:      block.DiscoveredVolumeType,
+			Kind:      controller.InputWeak,
+		},
+		{
+			Namespace: storage.NamespaceName,
+			Type:      storage.LVMPhysicalVolumeStatusType,
+			Kind:      controller.InputWeak,
+		},
+	}
+}
+
+// Outputs implements controller.Controller interface.
+func (ctrl *LVMLogicalVolumeStatusController) Outputs() []controller.Output {
+	return []controller.Output{
+		{
+			Type: storage.LVMLogicalVolumeStatusType,
+			Kind: controller.OutputExclusive,
+		},
+	}
+}
+
+// Run implements controller.Controller interface.
+func (ctrl *LVMLogicalVolumeStatusController) Run(ctx context.Context, r controller.Runtime, logger *zap.Logger) error {
+	ticker := time.NewTicker(pollInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case <-r.EventCh():
+		case <-ticker.C:
+		}
+
+		if err := ctrl.reconcile(ctx, r, logger); err != nil {
+			return err
+		}
+	}
+}
+
+func (ctrl *LVMLogicalVolumeStatusController) reconcile(ctx context.Context, r controller.Runtime, logger *zap.Logger) error {
+	lvs, err := lvm.LVDisplay(ctx)
+	if err != nil {
+		if errors.Is(err, exec.ErrNotFound) {
+			logger.Debug("lvm binary not found; skipping lv scan")
+
+			return nil
+		}
+
+		return fmt.Errorf("lvdisplay: %w", err)
+	}
+
+	r.StartTrackingOutputs()
+
+	for _, lv := range lvs {
+		if err := safe.WriterModify(ctx, r, storage.NewLVMLogicalVolumeStatus(storage.NamespaceName, lvID(lv.Path)), func(s *storage.LVMLogicalVolumeStatus) error {
+			spec := s.TypedSpec()
+			spec.Path = lv.Path
+			spec.VGName = lv.VGName
+			spec.Access = lv.Access
+			spec.Status = lv.Status
+			spec.InternalLVNumber = lv.InternalLVNumber
+			spec.OpenCount = lv.OpenCount
+			spec.SizeBytes = lv.SizeSectors * sectorSize
+			spec.CurrentLE = lv.CurrentLE
+			spec.AllocatedLE = lv.AllocatedLE
+			spec.AllocPolicy = lv.AllocPolicy
+			spec.ReadAheadSectors = lv.ReadAheadSectors
+			spec.Major = uint32(lv.Major)
+			spec.Minor = uint32(lv.Minor)
+
+			return nil
+		}); err != nil {
+			return fmt.Errorf("modify lv %q: %w", lv.Path, err)
+		}
+	}
+
+	if err := safe.CleanupOutputs[*storage.LVMLogicalVolumeStatus](ctx, r); err != nil {
+		return fmt.Errorf("cleanup lv outputs: %w", err)
+	}
+
+	return nil
+}
+
+// lvID derives a resource ID from an LV path. /dev/vg0/data → vg0-data.
+func lvID(path string) string {
+	return strings.TrimPrefix(strings.ReplaceAll(path, "/", "-"), "-dev-")
+}