feat(growpart): add LVM resize support

Fixes GH-3265

This change integrates LVM logical volume resizing into the existing
growpart flow. When the target block device is an LVM LV, cloud-init
now:
 - Performs lvs lookup to determine the volume group
 - Enumerates all PVs in the VG using new helper functions
 - Intelligently handles pvresize:
   * Skips pvresize for single-PV VGs when using growpart (growpart
     already handles it via maybe_lvm_resize)
   * Resizes all PVs for multi-PV VGs (growpart only resizes the
     partition's PV)
 - Conditionally extends LV based on `resize_lv` config option
   * When `resize_lv: true` (default): lvextend +100%FREE on the LV
   * When `resize_lv: false`: Only resize PVs, leaving LV unchanged
     (useful for multi-LV setups where free space should be preserved)

The `resize_lv` option is particularly useful when multiple LVs exist
in the same VG (e.g., separate LVs for /home, /var/log, etc.), allowing
users to preserve free space for other LVs.

New helper functions:
 - `_get_vg_for_lv()`: Returns VG name for a given LV device
 - `_get_pvs_for_vg()`: Returns list of PV device paths for a VG

Filesystem resizing is intentionally omitted because resizefs is handled
by a separate module.

Unit tests have been added under test_cc_growpart.py to validate:
 - successful pvresize and lvextend calls
 - error propagation for failed operations
 - resize_lv=False behavior
 - Single-PV VG with growpart (skip pvresize)
 - Multi-PV VG with growpart (resize all PVs)

This change does not affect existing non-LVM growpart behaviour.

Signed-off-by: Amy Chen <xiachen@redhat.com>

Author: xiachen-rh

cloudinit/config/cc_growpart.py

@@ -39,6 +39,7 @@
     "mode": "auto",
     "devices": ["/"],
     "ignore_growroot_disabled": False,
+    "resize_lv": True,
 }
 
 KEYDATA_PATH = Path("/cc_growpart_keydata")
@@ -363,6 +364,149 @@ def resize_encrypted(blockdev, partition) -> Tuple[str, str]:
     )
 
 
+def _get_vg_for_lv(lv_dev):
+    """
+    Return the VG name for a logical volume device,
+    e.g. /dev/mapper/vg-lv or /dev/vg/lv.
+    Uses `lvs --noheadings -o vg_name <lv_dev>`.
+    """
+    try:
+        out = subp.subp(
+            ["lvs", "--noheadings", "-o", "vg_name", lv_dev]
+        ).stdout
+        # lvs often prints whitespace padded output; take last token
+        vg = out.strip().split()[-1]
+        LOG.debug("lv %s belongs to vg %s", lv_dev, vg)
+        return vg
+    except Exception as e:
+        LOG.warning("failed to get VG for %s: %s", lv_dev, e)
+        raise
+
+
+def _get_pvs_for_vg(vg_name):
+    """
+    Return list of PV device paths for a volume group,
+    using `vgs -o pv_name --noheadings --separator ' ' <vg>`.
+    """
+    try:
+        out = subp.subp(
+            [
+                "vgs",
+                "--noheadings",
+                "-o",
+                "pv_name",
+                "--separator",
+                " ",
+                vg_name,
+            ]
+        ).stdout
+        # vgs returns space separated PV names (may include trailing spaces)
+        pvs = [p for p in out.split() if p]
+        LOG.debug("vg %s pvs: %s", vg_name, pvs)
+        return pvs
+    except Exception as e:
+        LOG.warning("failed to list PVs for VG %s: %s", vg_name, e)
+        raise
+
+
+def _pvresize(pv_dev):
+    """Run pvresize on each PV; idempotent: if it fails log and raise."""
+    try:
+        subp.subp(["pvresize", pv_dev])
+        LOG.info("pvresize succeeded for %s", pv_dev)
+        return True
+    except Exception as e:
+        LOG.warning("pvresize failed for %s: %s", pv_dev, e)
+        raise
+
+
+def _lvextend_to_free(lv_dev):
+    """Extend the LV to consume all free extents in its VG."""
+    try:
+        subp.subp(["lvextend", "-l", "+100%FREE", lv_dev])
+        LOG.info("lvextend +100%%FREE succeeded for %s", lv_dev)
+        return True
+    except Exception as e:
+        LOG.warning("lvextend failed for %s: %s", lv_dev, e)
+        raise
+
+
+def resize_lvm(
+    blockdev, resize_lv: bool = True, skip_pvresize: bool = False
+) -> Tuple[str, str]:
+    """
+    High-level procedure to resize LVM logical volume
+    after underlying PVs were expanded:
+      - find VG for lv (devpath)
+      - for each PV in VG: pvresize (unless skip_pvresize=True)
+      - optionally lvextend the lv to use free space (if resize_lv=True)
+
+    Args:
+        blockdev: The logical volume device path
+        resize_lv: If True, extend the LV to consume all free space in the VG.
+                   If False, only resize PVs, leaving LV size unchanged.
+                   Default: True (for backward compatibility).
+        skip_pvresize: If True, skip pvresize (e.g., when growpart already
+                       handled it). If False, run pvresize on all PVs in
+                       the VG. Default: False.
+    """
+    LOG.info("starting LVM resize flow for %s", blockdev)
+    vg = _get_vg_for_lv(blockdev)
+    pvs = _get_pvs_for_vg(vg)
+
+    # try pvresize for each PV (unless skipped, e.g., growpart already did it)
+    if not skip_pvresize:
+        for pv in pvs:
+            try:
+                _pvresize(pv)
+            except Exception:
+                LOG.warning(
+                    "pvresize failed for %s, continuing to next PV", pv
+                )
+    else:
+        LOG.debug(
+            "Skipping pvresize for %s (already handled by partition resizer)",
+            blockdev,
+        )
+
+    # extend the LV to use free space (if enabled)
+    if resize_lv:
+        _lvextend_to_free(blockdev)
+        pv_status = (
+            "PV already resized" if skip_pvresize else "PV and LV resized"
+        )
+        return (
+            RESIZE.CHANGED,
+            f"Successfully resized LVM device '{blockdev}' ({pv_status})",
+        )
+    else:
+        LOG.info(
+            "LV resize disabled for %s; %s. "
+            "Free space remains available in VG for other LVs.",
+            blockdev,
+            "PV already resized" if skip_pvresize else "PVs were resized",
+        )
+        pv_status = "PV already resized" if skip_pvresize else "PV resized"
+        return (
+            RESIZE.CHANGED,
+            f"Successfully resized LVM device '{blockdev}' "
+            f"({pv_status}, LV unchanged)",
+        )
+
+
+def is_lvm_device(blockdev) -> bool:
+    """
+    Checks if a given device path points to an LVM device.
+    """
+    try:
+        # Run lsblk to check if the device type is 'lvm'
+        out = subp.subp(["lsblk", "-n", "-o", "TYPE", blockdev]).stdout
+        return out.strip() == "lvm"
+    except Exception as e:
+        LOG.warning("Error checking if device is LVM: %s", e)
+        return False
+
+
 def _call_resizer(resizer, devent, disk, ptnum, blockdev, fs):
     info = []
     try:
@@ -409,7 +553,9 @@ def _call_resizer(resizer, devent, disk, ptnum, blockdev, fs):
     return info
 
 
-def resize_devices(resizer: Resizer, devices, distro: Distro):
+def resize_devices(
+    resizer: Resizer, devices, distro: Distro, resize_lv: bool = True
+):
     # returns a tuple of tuples containing (entry-in-devices, action, message)
     devices = copy.copy(devices)
     info = []
@@ -488,21 +634,88 @@ def resize_devices(resizer: Resizer, devices, distro: Distro):
                             message,
                         )
                     )
+                # If device is lvm
+                elif is_lvm_device(blockdev):
+                    # resize the partition firstly
+                    disk, ptnum = distro.device_part_info(partition)
+                    info += _call_resizer(
+                        resizer, devent, disk, ptnum, partition, fs
+                    )
+                    try:
+                        # Call the LVM resize procedure
+                        # Skip pvresize if using growpart AND VG has only
+                        # one PV
+                        # (growpart's maybe_lvm_resize only resizes the
+                        # specific partition's PV, so for multi-PV VGs we need
+                        # to resize all PVs)
+                        skip_pvresize = False
+                        if isinstance(resizer, ResizeGrowPart):
+                            try:
+                                vg = _get_vg_for_lv(blockdev)
+                                pvs = _get_pvs_for_vg(vg)
+                                # Only skip if single PV
+                                # (growpart already handled it)
+                                if len(pvs) == 1:
+                                    skip_pvresize = True
+                                    LOG.debug(
+                                        "VG %s has single PV, "
+                                        "skipping pvresize "
+                                        "(growpart already handled it)",
+                                        vg,
+                                    )
+                                else:
+                                    LOG.info(
+                                        "VG %s has %d PVs, resizing all PVs "
+                                        "(growpart only resized the "
+                                        "partition's PV)",
+                                        vg,
+                                        len(pvs),
+                                    )
+                            except Exception as e:
+                                LOG.warning(
+                                    "Failed to check VG PV count, will resize "
+                                    "all PVs: %s",
+                                    e,
+                                )
+                                # On error, don't skip (safer to resize all)
+                                skip_pvresize = False
+
+                        status, message = resize_lvm(
+                            blockdev,
+                            resize_lv=resize_lv,
+                            skip_pvresize=skip_pvresize,
+                        )
+                        info.append(
+                            (
+                                devent,
+                                status,
+                                message,
+                            )
+                        )
+                    except Exception as e:
+                        info.append(
+                            (
+                                devent,
+                                RESIZE.FAILED,
+                                f"Resizing LVM device ({blockdev}) failed: "
+                                f"{e}",
+                            )
+                        )
                 else:
                     info.append(
                         (
                             devent,
                             RESIZE.SKIPPED,
                             f"Resizing mapped device ({blockdev}) skipped "
-                            "as it is not encrypted.",
+                            f"as it is neither encrypted nor lvm.",
                         )
                     )
             except Exception as e:
                 info.append(
                     (
                         devent,
                         RESIZE.FAILED,
-                        f"Resizing encrypted device ({blockdev}) failed: {e}",
+                        f"Resizing device ({blockdev}) failed: {e}",
                     )
                 )
             # At this point, we WON'T resize a non-encrypted mapped device
@@ -559,6 +772,8 @@ def handle(name: str, cfg: Config, cloud: Cloud, args: list) -> None:
         LOG.debug("growpart: empty device list")
         return
 
+    resize_lv = util.get_cfg_option_bool(mycfg, "resize_lv", True)
+
     try:
         resizer = resizer_factory(mode, distro=cloud.distro, devices=devices)
     except (ValueError, TypeError) as e:
@@ -568,7 +783,9 @@ def handle(name: str, cfg: Config, cloud: Cloud, args: list) -> None:
         return
 
     with performance.Timed("Resizing devices"):
-        resized = resize_devices(resizer, devices, cloud.distro)
+        resized = resize_devices(
+            resizer, devices, cloud.distro, resize_lv=resize_lv
+        )
     for entry, action, msg in resized:
         if action == RESIZE.CHANGED:
             LOG.info("'%s' resized: %s", entry, msg)

cloudinit/config/schemas/schema-cloud-config-v1.json

@@ -1682,6 +1682,11 @@
               "type": "boolean",
               "default": false,
               "description": "If ``true``, ignore the presence of ``/etc/growroot-disabled``. If ``false`` and the file exists, then don't resize. Default: ``false``."
+            },
+            "resize_lv": {
+              "type": "boolean",
+              "default": true,
+              "description": "For LVM devices, if ``true``, extend the logical volume to consume all free space in the volume group after resizing physical volumes. If ``false``, only resize physical volumes, leaving the logical volume size unchanged. This is useful when multiple logical volumes exist in the same volume group (e.g., separate LVs for ``/home``, ``/var/log``, etc.) and you want to preserve free space for other LVs. Default: ``true``."
             }
           }
         }

doc/module-docs/cc_growpart/data.yaml

@@ -9,6 +9,24 @@ cc_growpart:
     on a disk with classic partitioning scheme (MBR, BSD, GPT). LVM, Btrfs and
     ZFS have no such restrictions.
 
+    For LVM devices, the module will resize physical volumes (PVs) after the
+    underlying partition is grown. When using the ``growpart`` utility (the
+    default), ``pvresize`` is automatically handled by ``growpart`` itself for
+    the specific partition's PV. However, if a Volume Group spans multiple
+    Physical Volumes, ``growpart`` only resizes the PV corresponding to the
+    resized partition. In this case, cloud-init will detect the multi-PV
+    configuration and resize all PVs in the Volume Group to ensure complete
+    coverage. For single-PV Volume Groups, cloud-init skips ``pvresize`` to
+    avoid duplication. For other resizers (e.g., ``gpart``), cloud-init will
+    always perform ``pvresize`` on all PVs in the Volume Group.
+
+    By default, the module will also extend the logical volume (LV) to consume
+    all free space in the volume group. This behavior can be controlled with
+    the ``resize_lv`` option. When multiple logical volumes exist in the same
+    volume group (e.g., separate LVs for ``/home``, ``/var/log``, etc.),
+    setting ``resize_lv: false`` will preserve free space in the volume group
+    for other LVs.
+
     The devices on which to run growpart are specified as a list under the
     ``devices`` key.
 
@@ -45,6 +63,7 @@ cc_growpart:
          mode: auto
          devices: [\"/\"]
          ignore_growroot_disabled: false
+         resize_lv: true
   examples:
   - comment: |
       Example 1:

tests/integration_tests/modules/test_growpart.py

@@ -70,3 +70,57 @@ def test_grow_part(self, client: IntegrationInstance):
         assert len(sdb["children"]) == 1
         assert sdb["children"][0]["name"] == "sdb1"
         assert sdb["size"] == "16M"
+
+
+class TestGrowPartLVM:
+    """
+    Test that LVM partitions are correctly resized.
+
+    This test uses a bootcmd to create a loop device and partition it using
+    LVM.  The underlying partition does not used the whole loop "disk", nor
+    does the Logical Volume we create use the whole of the Physical Volume.
+
+    This test checks that, after boot, the Logical Volume has been resized to
+    use the whole loop device (with some allowance for partitioning/LVM
+    overhead).
+    """
+
+    # These steps pulled from https://ops.tips/blog/lvm-on-loopback-devices/
+    LVM_USER_DATA = """\
+    #cloud-config
+    bootcmd:
+        # Create our LVM "disk"
+        - dd if=/dev/zero of=/lvm0.img bs=50 count=1M
+        # Use loop7 because snaps take up the early numbers
+        - losetup /dev/loop7 /lvm0.img
+        # Create an LVM partition on the first half of the disk
+        - echo "start=1,size=25M,type=8e" | sfdisk /dev/loop7
+        # Update the kernel's partition table
+        - partx --update /dev/loop7
+        # Create our LVM PV and VG
+        - pvcreate /dev/loop7p1
+        - vgcreate myvg /dev/loop7p1
+        # Create our LV with a smaller size than the whole PV
+        - lvcreate --size 10M --name lv1 myvg
+        # Create a filesystem to resize
+        - mkfs.ext4 /dev/mapper/myvg-lv1
+    growpart:
+        devices: ["/dev/mapper/myvg-lv1"]
+    """
+
+    # Our disk is 50M; with 4MB extents, this will mean 48M for the Logical
+    # Volume, so use a slightly lower threshold than that
+    LVM_LOWER_THRESHOLD = 47 * 1024 * 1024
+
+    @pytest.mark.user_data(LVM_USER_DATA)
+    def test_resize_successful(self, client):
+        def _get_size_of(device):
+            ret = client.execute(
+                ["lsblk", "-b", "--output", "SIZE", "-n", "-d", device]
+            )
+            if ret.ok:
+                return int(ret.stdout.strip())
+            pytest.fail("Failed to get size of {}: {}".format(device, ret))
+
+        assert _get_size_of("/dev/loop7p1") > self.LVM_LOWER_THRESHOLD
+        assert _get_size_of("/dev/mapper/myvg-lv1") > self.LVM_LOWER_THRESHOLD