Configuring and managing logical volumes

Procedure

1. Identify the storage device you want to use as a physical volume. To list all available storage devices, use:

   $ lsblk

2. Create an LVM physical volume:

   # pvcreate /dev/sdb

   Replace /dev/sdb with the name of the device you want to initialize as a physical volume.

Procedure

1. List the physical volumes to identify the device you want to remove:

   # pvs
   
     PV           VG Fmt  Attr PSize  PFree
     /dev/sdb1       lvm2 ---  28.87g 28.87g

2. Remove the physical volume:

   # pvremove /dev/sdb1

   Replace /dev/sdb1 with the name of the device associated with the physical volume.

Procedure

1. Log in to the RHEL 9 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the volume group in which you want to create logical volumes.
4. On the Logical volume group page, scroll to the LVM2 logical volumes section and click Create new logical volume.
5. In the Name field, enter a name for the new logical volume. Do not include spaces in the name.

6. In the Purpose drop-down menu, select Block device for filesystems.

   This configuration enables you to create a logical volume with the maximum volume size which is equal to the sum of the capacities of all drives included in the volume group.

   

7. Define the size of the logical volume. Consider:

   • How much space the system using this logical volume will need.
   • How many logical volumes you want to create.

   You do not have to use the whole space. If necessary, you can grow the logical volume later.

   

8. Click Create.

   The logical volume is created. To use the logical volume you must format and mount the volume.

Procedure

1. Log in to the RHEL 9 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the volume group in the logical volumes is created.
4. On the Logical volume group page, scroll to the LVM2 logical volumes section.
5. Click the menu button, ⋮, next to the volume group you want to format.

6. From the drop-down menu, select Format.

   

7. In the Name field, enter a name for the file system.

8. In the Mount Point field, add the mount path.

   

9. In the Type drop-down menu, select a file system:

   • XFS file system supports large logical volumes, switching physical drives online without outage, and growing an existing file system. Leave this file system selected if you do not have a different strong preference.

     XFS does not support reducing the size of a volume formatted with an XFS file system

   • ext4 file system supports:

     • Logical volumes
     • Switching physical drives online without an outage
     • Growing a file system
     • Shrinking a file system

10. Select the Overwrite existing data with zeros checkbox if you want the RHEL web console to rewrite the whole disk with zeros. This option is slower because the program has to go through the whole disk, but it is more secure. Use this option if the disk includes any data and you need to overwrite it.

    If you do not select the Overwrite existing data with zeros checkbox, the RHEL web console rewrites only the disk header. This increases the speed of formatting.

11. From the Encryption drop-down menu, select the type of encryption if you want to enable it on the logical volume.

    You can select a version with either the LUKS1 (Linux Unified Key Setup) or LUKS2 encryption, which allows you to encrypt the volume with a passphrase.

12. In the At boot drop-down menu, select when you want the logical volume to mount after the system boots.
13. Select the required Mount options.

14. Format the logical volume:

    • If you want to format the volume and immediately mount it, click Format and mount.

    • If you want to format the volume without mounting it, click Format only.

      Formatting can take several minutes depending on the volume size and which formatting options are selected.

Verification

1. On the Logical volume group page, scroll to the LVM2 logical volumes section and click the logical volume to check the details and additional options.

   

2. If you selected the Format only option, click the menu button at the end of the line of the logical volume, and select Mount to use the logical volume.

Procedure

1. Log in to the RHEL web console.
2. Click Storage.
3. In the Storage table, click the volume group in the logical volumes is created.

4. On the Logical volume group page, scroll to the LVM2 logical volumes section and click the menu button, ⋮, next to volume group you want to resize.

   

5. From the menu, select Grow or Shrink to resize the volume:

   • Growing the Volume:

     1. Select Grow to increase the size of the volume.

     2. In the Grow logical volume dialog box, adjust the size of the logical volume.

        

     3. Click Grow.

        LVM grows the logical volume without causing a system outage.

   • Shrinking the Volume:

     1. Select Shrink to reduce the size of the volume.

     2. In the Shrink logical volume dialog box, adjust the size of the logical volume.

        

     3. Click Shrink.

        LVM shrinks the logical volume without causing a system outage.

Procedure

1. List and identify the PV that you want to include in the VG:

   # pvs

2. Create a VG:

   # vgcreate VolumeGroupName PhysicalVolumeName1 PhysicalVolumeName2

   Replace VolumeGroupName with the name of the volume group that you want to create. Replace PhysicalVolumeName with the name of the PV.

   To specify the extent size when creating a VG, use the -s ExtentSize option. Replace ExtentSize with the size of the extent. If you provide no size suffix, the command defaults to MB.

Procedure

1. Log in to the RHEL 9 web console.

   For details, see Logging in to the web console.

2. Click Storage.
3. In the Storage table, click the menu button.

4. From the drop-down menu, select Create LVM2 volume group.

   

5. In the Name field, enter a name for the volume group. The name must not include spaces.

6. Select the drives you want to combine to create the volume group.

   

   The RHEL web console displays only unused block devices. If you do not see your device in the list, make sure that it is not being used by your system, or format it to be empty and unused. Used devices include, for example:

   • Devices formatted with a file system
   • Physical volumes in another volume group
   • Physical volumes being a member of another software RAID device

7. Click Create.

   The volume group is created.

Procedure

1. List and identify the VG that you want to rename:

   # vgs

2. Rename the VG:

   # vgrename OldVolumeGroupName NewVolumeGroupName

   Replace OldVolumeGroupName with the name of the VG. Replace NewVolumeGroupName with the new name for the VG.

Procedure

1. List and identify the VG that you want to extend:

   # vgs

2. List and identify the PVs that you want to add to the VG:

   # pvs

3. Extend the VG:

   # vgextend VolumeGroupName PhysicalVolumeName

   Replace VolumeGroupName with the name of the VG. Replace PhysicalVolumeName with the name of the PV.

Procedure

1. List and identify the VG that you want to merge:

   # vgs
   
     VG               #PV #LV #SN Attr   VSize  VFree
     VolumeGroupName1   1   0   0 wz--n- 28.87g 28.87g
     VolumeGroupName2   1   0   0 wz--n-  1.88g  1.88g

2. Merge the source VG into the destination VG:

   # vgmerge VolumeGroupName2 VolumeGroupName1

   Replace VolumeGroupName2 with the name of the source VG. Replace VolumeGroupName1 with the name of the destination VG.

Procedure

1. If the physical volume is still being used, migrate the data to another physical volume from the same volume group:

   # pvmove /dev/vdb3
     /dev/vdb3: Moved: 2.0%
    ...
     /dev/vdb3: Moved: 79.2%
    ...
     /dev/vdb3: Moved: 100.0%

2. If there are not enough free extents on the other physical volumes in the existing volume group:

   1. Create a new physical volume from /dev/vdb4:

      # pvcreate /dev/vdb4
        Physical volume "/dev/vdb4" successfully created

   2. Add the newly created physical volume to the volume group:

      # vgextend VolumeGroupName /dev/vdb4
        Volume group "VolumeGroupName" successfully extended

   3. Move the data from /dev/vdb3 to /dev/vdb4:

      # pvmove /dev/vdb3 /dev/vdb4
        /dev/vdb3: Moved: 33.33%
        /dev/vdb3: Moved: 100.00%

3. Remove the physical volume /dev/vdb3 from the volume group:

   # vgreduce VolumeGroupName /dev/vdb3
   Removed "/dev/vdb3" from volume group "VolumeGroupName"

Procedure

1. Split the existing volume group VolumeGroupName1 to the new volume group VolumeGroupName2:

   # vgsplit VolumeGroupName1 VolumeGroupName2 /dev/vdb3
     Volume group "VolumeGroupName2" successfully split from "VolumeGroupName1"

   Note

   If you have created a logical volume using the existing volume group, use the following command to deactivate the logical volume:

   # lvchange -a n /dev/VolumeGroupName1/LogicalVolumeName

   For more information about creating logical volumes, see Managing LVM logical volumes.

2. View the attributes of the two volume groups:

   # vgs
     VG                  #PV #LV #SN Attr   VSize  VFree
     VolumeGroupName1     2   1   0 wz--n- 34.30G 10.80G
     VolumeGroupName2     1   0   0 wz--n- 17.15G 17.15G

Procedure

1. Unmount the LogicalVolumeName logical volume:

   # umount /dev/mnt/LogicalVolumeName

2. Deactivate all logical volumes in the volume group, which prevents any further activity on the volume group:

   # vgchange -an VolumeGroupName
   vgchange -- volume group "VolumeGroupName" successfully deactivated

3. Export the volume group to prevent it from being accessed by the system from which you are removing it:

   # vgexport VolumeGroupName
   vgexport -- volume group "VolumeGroupName" successfully exported

4. View the exported volume group:

   # pvscan
     PV /dev/sda1    is in exported VG VolumeGroupName [17.15 GB / 7.15 GB free]
     PV /dev/sdc1    is in exported VG VolumeGroupName [17.15 GB / 15.15 GB free]
     PV /dev/sdd1    is in exported VG VolumeGroupName [17.15 GB / 15.15 GB free]
     ...

5. Shut down your system and unplug the disks that make up the volume group and connect them to the new system.

6. Plug the disks into the new system and import the volume group to make it accessible to the new system:

   # vgimport VolumeGroupName

   Note

   You can use the --force argument of the vgimport command to import volume groups that are missing physical volumes and subsequently run the vgreduce --removemissing command.

7. Activate the volume group:

   # vgchange -ay VolumeGroupName

8. Mount the file system to make it available for use:

   # mkdir -p /mnt/VolumeGroupName/users
   # mount /dev/VolumeGroupName/users /mnt/VolumeGroupName/users

Procedure

1. Ensure the volume group does not contain logical volumes:

   # vgs -o vg_name,lv_count VolumeGroupName
   
     VG               #LV
     VolumeGroupName    0

   Replace VolumeGroupName with the name of the volume group.

2. Remove the volume group:

   # vgremove VolumeGroupName

   Replace VolumeGroupName with the name of the volume group.

Procedure

1. Ensure the volume group does not contain logical volumes:

   # vgs -o vg_name,lv_count VolumeGroupName
   
     VG               #LV
     VolumeGroupName    0

   Replace VolumeGroupName with the name of the volume group.

2. Stop the lockspace on all nodes except the node where you are removing the volume group:

   # vgchange --lockstop VolumeGroupName

   Replace VolumeGroupName with the name of the volume group and wait for the lock to stop.

3. Remove the volume group:

   # vgremove VolumeGroupName

   Replace VolumeGroupName with the name of the volume group.

Procedure

1. List the logical volumes and their volume groups:

   # lvs -o lv_name,vg_name
   
     LV                VG
     LogicalVolumeName VolumeGroupName

2. Rename the logical volume:

   # lvrename VolumeGroupName/LogicalVolumeName VolumeGroupName/NewLogicalVolumeName

   Replace VolumeGroupName with name of the volume group. Replace LogicalVolumeName with the name of the logical volume. Replace NewLogicalVolumeName with the new logical volume name.

Procedure

1. List the logical volumes and their paths:

   # lvs -o lv_name,lv_path
   
     LV                Path
     LogicalVolumeName /dev/VolumeGroupName/LogicalVolumeName

2. Check where the logical volume is mounted:

   # findmnt -o SOURCE,TARGET /dev/VolumeGroupName/LogicalVolumeName
   
   SOURCE                                        TARGET
   /dev/mapper/VolumeGroupName-LogicalVolumeName /MountPoint

   Replace /dev/VolumeGroupName/LogicalVolumeName with the path to your logical volume.

3. Unmount the logical volume:

   # umount /MountPoint

   Replace /MountPoint with the mounting point for your logical volume.

4. Remove the logical volume:

   # lvremove VolumeGroupName/LogicalVolumeName

   Replace VolumeGroupName/LogicalVolumeName with the path to your logical volume.

Procedure

1. List the logical volumes, their volume groups, and their paths:

   # lvs -o lv_name,vg_name,lv_path
   
     LV                VG              Path
     LogicalVolumeName VolumeGroupName VolumeGroupName/LogicalVolumeName

2. Activate the logical volume:

   # lvchange --activate y VolumeGroupName/LogicalVolumeName

   Replace VolumeGroupName with the name of the volume group. Replace LogicalVolumeName with the name of the logical volume.

   Note

   When activating a thin LV that was created as a snapshot of another LV, you might need to use the --ignoreactivationskip option to activate it.

Procedure

1. List the logical volumes, their volume groups, and their paths:

   # lvs -o lv_name,vg_name,lv_path
   
     LV                VG              Path
     LogicalVolumeName VolumeGroupName /dev/VolumeGroupName/LogicalVolumeName

2. Check where the logical volume is mounted:

   # findmnt -o SOURCE,TARGET /dev/VolumeGroupName/LogicalVolumeName
   
   SOURCE                                        TARGET
   /dev/mapper/VolumeGroupName-LogicalVolumeName /MountPoint

   Replace /dev/VolumeGroupName/LogicalVolumeName with the path to your logical volume.

3. Unmount the logical volume:

   # umount /MountPoint

   Replace /MountPoint with the mounting point for your logical volume.

4. Deactivate the logical volume:

   # lvchange --activate n VolumeGroupName/LogicalVolumeName

   Replace VolumeGroupName with name of the volume group. Replace LogicalVolumeName with the name of the logical volume.

Procedure

1. Display available volume groups:

   # vgs -o vg_name
   
     VG
     VolumeGroupName

2. List available devices:

   # lsblk

3. Create a LV to hold the thin pool data:

   # lvcreate --name ThinPoolDataName --size Size VolumeGroupName /DevicePath

   Replace ThinPoolDataName with the name for your thin pool data LV. Replace Size with the size for your LV. Replace VolumeGroupName with the name of your volume group.

4. Create a LV to hold the thin pool metadata:

   # lvcreate --name ThinPoolMetadataName --size Size VolumeGroupName /DevicePath

5. Combine the LVs into a thin pool:

   # lvconvert --type thin-pool --poolmetadata ThinPoolMetadataName VolumeGroupName/ThinPoolDataName

Verification

1. Verify that the custom thin pool is created:

   # lvs -o lv_name,seg_type
   
     LV                Type
     ThinPoolDataName  thin-pool

Procedure

1. Display the VGs:

   # vgs
   
     VG               #PV #LV #SN Attr   VSize   VFree
     VolumeGroupName   1   0   0 wz--n-  28.87g 28.87g

2. Create a LV to be converted to a VDO pool:

   # lvcreate --name VDOPoolName --size Size VolumeGroupName

   Replace VDOPoolName with the name for your VDO pool. Replace Size with the size for your VDO pool. Replace VolumeGroupName with the name of the VG.

3. Convert this LV to a VDO pool. In this conversion, you are creating a new VDO LV that uses the VDO pool. Because lvcreate is creating a new VDO LV, you must specify parameters for the new VDO LV. Use --name|-n to specify the name of the new VDO LV, and --virtualsize|-V to specify the size of the new VDO LV.

   # lvconvert --type vdo-pool --name VDOVolumeName --virtualsize VDOVolumeSize VolumeGroupName/VDOPoolName

   Replace VDOVolumeName with the name for your VDO volume. Replace VDOVolumeSize with the size for your VDO volume. Replace VolumeGroupName/VDOPoolName with the names for your VG and your VDO pool.

Verification

1. Verify that the LV is converted to the VDO pool:

   *# lvs -o lv_name,vg_name,seg_type*
   
     LV                     VG              Type
     VDOPoolName            VolumeGroupName vdo-pool
     VDOVolumeName          VolumeGroupName vdo

Procedure:

1. Display the default lvm.conf file:

   # lvmconfig --typeconfig default --withcomments

   By default, the lvm.conf file contains only comments to display possible settings.

2. Customize the lvm.conf file according to your requirements by uncommenting the setting in lvm.conf. The following setting focuses on changing the default display of certain commands:

   • In the lvm.conf file, adjust the lvs_cols parameter to only print the specified fields:

     {
       ...
       lvs_cols="lv_name,vg_name,lv_attr"
       ...
     }

     Use this option instead of the lvs -o lv_name,vg_name,lv_attr command to avoid unnecessary frequent use of the -o option.

   • In the lvm.conf file, use the compact_output=1 setting to avoid printing empty fields for the pvs, vgs, and lvs commands:

     {
       ...
       compact_output = 1
       ...
     }

3. View the default values after modifying the lvm.conf file:

   # lvmconfig --typeconfig diff

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Express volume sizes as a percentage of the pool's total size
     hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.storage
     vars:
       storage_pools:
         - name: myvg
           disks:
             - /dev/sdb
           volumes:
             - name: data
               size: 60%
               mount_point: /opt/mount/data
             - name: web
               size: 30%
               mount_point: /opt/mount/web
             - name: cache
               size: 10%
               mount_point: /opt/cache/mount

   This example specifies the size of LVM volumes as a percentage of the pool size, for example: 60%. Alternatively, you can also specify the size of LVM volumes as a percentage of the pool size in a human-readable size of the file system, for example, 10g or 50 GiB.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. In the lvm.conf file, check if the system.devices file is enabled:

   use_devicesfile=1

2. Exclude the devices in question from the host’s devices file:

   $ lvmdevices --deldev <device>

3. Optional: You can further protect LVM devices:

   1. Set the LVM system ID feature in both the host and the VM in the lvm.conf file:

      system_id_source = "uname"

   2. Set the VG’s system ID to match the VM system ID. This ensures that only the guest VM is capable of activating the VG:

      $ vgchange --systemid <VM_system_id> <VM_vg_name>

Procedure

1. In the lvm.conf file, check if the system.devices file is enabled:

   use_devicesfile=1

2. Exclude the devices in question from the host’s devices file:

   $ lvmdevices --deldev <device>

3. Set the LVM system ID feature in the lvm.conf file:

   system_id_source = "uname"

4. Set the VG’s system ID to match the system ID of the machine using this VG:

   $ vgchange --systemid <system_id> <vg_name>

Procedure

1. In the lvm.conf file, check if the system.devices file is enabled:

   use_devicesfile=1

2. Include the devices in question in the host’s devices file:

   $ lvmdevices --adddev <device>

3. Set the LVM system ID feature in all machines in the lvm.conf file:

   system_id_source = "uname"

Procedure

1. In the lvm.conf file, check if the system.devices file is enabled:

   use_devicesfile=1

2. For each machine that will use the shared LUN, add the LUN in the machines devices file:

   $ lvmdevices --adddev <device>

3. Configure the lvm.conf file to use the lvmlockd daemon on all machines:

   use_lvmlockd=1

4. Start the lvmlockd daemon file on all machines.
5. Start a lock manager to use with lvmlockd, such as dlm or sanlock on all machines.
6. Create a new shared VG using the command vgcreate --shared.
7. Start and stop access to existing shared VGs using the commands vgchange --lockstart and vgchange --lockstop on all machines.

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Create shared LVM device
     hosts: managed-node-01.example.com
     become: true
     tasks:
       - name: Create shared LVM device
         ansible.builtin.include_role:
           name: rhel-system-roles.storage
         vars:
           storage_pools:
             - name: vg1
               disks: /dev/vdb
               type: lvm
               shared: true
               state: present
               volumes:
                 - name: lv1
                   size: 4g
                   mount_point: /opt/test1
           storage_safe_mode: false
           storage_use_partitions: true

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Prerequisites

1. You have created three or more physical volumes. For more information about creating physical volumes, see Creating LVM physical volume.
2. You have created the volume group. For more information, see Creating LVM volume group.

Procedure

1. Create a RAID0 logical volume from the existing volume group. The following command creates the RAID0 volume mylv from the volume group myvg, which is 2G in size, with three stripes and a stripe size of 4kB:

   # lvcreate --type raid0 -L 2G --stripes 3 --stripesize 4 -n mylv my_vg
     Rounding size 2.00 GiB (512 extents) up to stripe boundary size 2.00 GiB(513 extents).
     Logical volume "mylv" created.

2. Create a file system on the RAID0 logical volume. The following command creates an ext4 file system on the logical volume:

   # mkfs.ext4 /dev/my_vg/mylv

3. Mount the logical volume and report the file system disk space usage:

   # mount /dev/my_vg/mylv /mnt
   
   # df
   Filesystem             1K-blocks     Used  Available  Use% Mounted on
   /dev/mapper/my_vg-mylv   2002684     6168  1875072    1%   /mnt

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Configure stripe size for RAID LVM volumes
     hosts: managed-node-01.example.com
     roles:
       - rhel-system-roles.storage
     vars:
       storage_safe_mode: false
       storage_pools:
         - name: my_pool
           type: lvm
           disks: [sdh, sdi]
           volumes:
             - name: my_volume
               size: "1 GiB"
               mount_point: "/mnt/app/shared"
               fs_type: xfs
               raid_level: raid1
               raid_stripe_size: "256 KiB"
               state: present

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a RAID LV with DM integrity. The following example creates a new RAID LV with integrity named test-lv in the my_vg volume group, with a usable size of 256M and RAID level 1:

   # lvcreate --type raid1 --raidintegrity y -L 256M -n test-lv my_vg
   Creating integrity metadata LV test-lv_rimage_0_imeta with size 8.00 MiB.
   Logical volume "test-lv_rimage_0_imeta" created.
   Creating integrity metadata LV test-lv_rimage_1_imeta with size 8.00 MiB.
   Logical volume "test-lv_rimage_1_imeta" created.
   Logical volume "test-lv" created.

   Note

   To add DM integrity to an existing RAID LV, use the following command:

   # lvconvert --raidintegrity y my_vg/test-lv

   Adding integrity to a RAID LV limits the number of operations that you can perform on that RAID LV.

2. Optional: Remove the integrity before performing certain operations.

   # lvconvert --raidintegrity n my_vg/test-lv
   Logical volume my_vg/test-lv has removed integrity.

Procedure

1. View the logical volume device that needs to be converted:

   # lvs -a -o name,copy_percent,devices my_vg
     LV     Copy%  Devices
     my_lv         /dev/sde1(0)

2. Convert the linear logical volume to a RAID device. The following command converts the linear logical volume my_lv in volume group __my_vg, to a 2-way RAID1 array:

   # lvconvert --type raid1 -m 1 my_vg/my_lv
     Are you sure you want to convert linear LV my_vg/my_lv to raid1 with 2 images enhancing resilience? [y/n]: y
     Logical volume my_vg/my_lv successfully converted.

Procedure

1. Display an existing LVM RAID1 logical volume:

   # lvs -a -o name,copy_percent,devices my_vg
     LV               Copy%  Devices
     my_lv            100.00 my_lv_rimage_0(0),my_lv_rimage_1(0)
     [my_lv_rimage_0]        /dev/sde1(1)
     [my_lv_rimage_1]        /dev/sdf1(1)
     [my_lv_rmeta_0]         /dev/sde1(0)
     [my_lv_rmeta_1]         /dev/sdf1(0)

2. Convert an existing RAID1 LVM logical volume to an LVM linear logical volume. The following command converts the LVM RAID1 logical volume my_vg/my_lv to an LVM linear device:

   # lvconvert -m0 my_vg/my_lv
     Are you sure you want to convert raid1 LV my_vg/my_lv to type linear losing all resilience? [y/n]: y
     Logical volume my_vg/my_lv successfully converted.

   When you convert an LVM RAID1 logical volume to an LVM linear volume, you can also specify which physical volumes to remove. In the following example, the lvconvert command specifies that you want to remove /dev/sde1, leaving /dev/sdf1 as the physical volume that makes up the linear device:

   # lvconvert -m0 my_vg/my_lv /dev/sde1

Procedure

1. View the layout of a mirrored logical volume my_vg/my_lv:

   # lvs -a -o name,copy_percent,devices my_vg
     LV               Copy%  Devices
     my_lv             15.20 my_lv_mimage_0(0),my_lv_mimage_1(0)
     [my_lv_mimage_0]        /dev/sde1(0)
     [my_lv_mimage_1]        /dev/sdf1(0)
     [my_lv_mlog]            /dev/sdd1(0)

2. Convert the mirrored logical volume my_vg/my_lv to a RAID1 logical volume:

   # lvconvert --type raid1 my_vg/my_lv
   Are you sure you want to convert mirror LV my_vg/my_lv to raid1 type? [y/n]: y
   Logical volume my_vg/my_lv successfully converted.

Procedure

1. Display the LVM device my_vg/my_lv, which is a 2-way RAID1 array:

   # lvs -a -o name,copy_percent,devices my_vg
     LV                Copy%  Devices
     my_lv             6.25    my_lv_rimage_0(0),my_lv_rimage_1(0)
     [my_lv_rimage_0]         /dev/sde1(0)
     [my_lv_rimage_1]         /dev/sdf1(1)
     [my_lv_rmeta_0]          /dev/sde1(256)
     [my_lv_rmeta_1]          /dev/sdf1(0)

   Metadata subvolumes named rmeta always exist on the same physical devices as their data subvolume counterparts rimage. The metadata/data subvolume pairs will not be created on the same physical volumes as those from another metadata/data subvolume pair in the RAID array unless you specify --alloc anywhere.

2. Convert the 2-way RAID1 logical volume my_vg/my_lv to a 3-way RAID1 logical volume:

   # lvconvert -m 2 my_vg/my_lv
   Are you sure you want to convert raid1 LV my_vg/my_lv to 3 images enhancing resilience? [y/n]: y
   Logical volume my_vg/my_lv successfully converted.

   The following are a few examples of changing the number of images in an existing RAID1 device:

   • You can also specify which physical volumes to use while adding an image to RAID. The following command converts the 2-way RAID1 logical volume my_vg/my_lv to a 3-way RAID1 logical volume by specifying the physical volume /dev/sdd1 to use for the array:

     # lvconvert -m 2 my_vg/my_lv /dev/sdd1

   • Convert the 3-way RAID1 logical volume into a 2-way RAID1 logical volume:

     # lvconvert -m1 my_vg/my_lv
     Are you sure you want to convert raid1 LV my_vg/my_lv to 2 images reducing resilience? [y/n]: y
     Logical volume my_vg/my_lv successfully converted.

   • Convert the 3-way RAID1 logical volume into a 2-way RAID1 logical volume by specifying the physical volume /dev/sde1, which contains the image to remove:

     # lvconvert -m1 my_vg/my_lv /dev/sde1

     Additionally, when you remove an image and its associated metadata subvolume volume, any higher-numbered images will be shifted down to fill the slot. Removing lv_rimage_1 from a 3-way RAID1 array that consists of lv_rimage_0, lv_rimage_1, and lv_rimage_2 results in a RAID1 array that consists of lv_rimage_0 and lv_rimage_1. The subvolume lv_rimage_2 will be renamed and take over the empty slot, becoming lv_rimage_1.

Procedure

1. Display the LVM device my_vg/my_lv, which is a 2-way RAID1 array:

   # lvs -a -o name,copy_percent,devices my_vg
     LV               Copy%  Devices
     my_lv             12.00 my_lv_rimage_0(0),my_lv_rimage_1(0)
     [my_lv_rimage_0]        /dev/sde1(1)
     [my_lv_rimage_1]        /dev/sdf1(1)
     [my_lv_rmeta_0]         /dev/sde1(0)
     [my_lv_rmeta_1]         /dev/sdf1(0)

2. Split the RAID image into a separate logical volume:

   • The following example splits a 2-way RAID1 logical volume, my_lv, into two linear logical volumes, my_lv and new:

     # lvconvert --splitmirror 1 -n new my_vg/my_lv
     Are you sure you want to split raid1 LV my_vg/my_lv losing all resilience? [y/n]: y

   • The following example splits a 3-way RAID1 logical volume, my_lv, into a 2-way RAID1 logical volume, my_lv, and a linear logical volume, new:

     # lvconvert --splitmirror 1 -n new my_vg/my_lv

Procedure

1. Create a RAID logical volume:

   # lvcreate --type raid1 -m 2 -L 1G -n my_lv my_vg
     Logical volume "my_lv" created

2. Optional: View the created RAID logical volume:

   # lvs -a -o name,copy_percent,devices my_vg
     LV               Copy%  Devices
     my_lv          100.00 my_lv_rimage_0(0),my_lv_rimage_1(0),my_lv_rimage_2(0)
     [my_lv_rimage_0]        /dev/sdb1(1)
     [my_lv_rimage_1]        /dev/sdc1(1)
     [my_lv_rimage_2]        /dev/sdd1(1)
     [my_lv_rmeta_0]         /dev/sdb1(0)
     [my_lv_rmeta_1]         /dev/sdc1(0)
     [my_lv_rmeta_2]         /dev/sdd1(0)

3. Split an image from the created RAID logical volume and track the changes to the remaining array:

   # lvconvert --splitmirrors 1 --trackchanges my_vg/my_lv
     my_lv_rimage_2 split from my_lv for read-only purposes.
     Use 'lvconvert --merge my_vg/my_lv_rimage_2' to merge back into my_lv

4. Optional: View the logical volume after splitting the image:

   # lvs -a -o name,copy_percent,devices my_vg
     LV               Copy%  Devices
     my_lv            100.00 my_lv_rimage_0(0),my_lv_rimage_1(0)
     [my_lv_rimage_0]        /dev/sdc1(1)
     [my_lv_rimage_1]          /dev/sdd1(1)
     [my_lv_rmeta_0]         /dev/sdc1(0)
     [my_lv_rmeta_1]         /dev/sdd1(0)

5. Merge the volume back into the array:

   # lvconvert --merge my_vg/my_lv_rimage_1
     my_vg/my_lv_rimage_1 successfully merged back into my_vg/my_lv

Procedure

1. Optional: Limit the I/O bandwidth that the scrubbing process uses. When you perform a RAID scrubbing operation, the background I/O required by the sync actions can crowd out other I/O to LVM devices, such as updates to volume group metadata. This might cause the other LVM operations to slow down.

   You can control the rate of the scrubbing operation by implementing recovery throttling. You can set the recovery rate using --maxrecoveryrate Rate[bBsSkKmMgG] or --minrecoveryrate Rate[bBsSkKmMgG] with the lvchange --syncaction commands. For more information, see Minimum and maximum I/O rate options.

   Specify the Rate value as an amount per second for each device in the array. If you provide no suffix, the options assume kiB per second per device.

2. Display the number of discrepancies in the array, without repairing them:

   # lvchange --syncaction check my_vg/my_lv

   This command initiates a background synchronization action on the array.

3. Optional: View the var/log/syslog file for the kernel messages.

4. Correct the discrepancies in the array:

   # lvchange --syncaction repair my_vg/my_lv

   This command repairs or replaces failed devices in a RAID logical volume. You can view the var/log/syslog file for the kernel messages after executing this command.

Verification

1. Display information about the scrubbing operation:

   # lvs -o +raid_sync_action,raid_mismatch_count my_vg/my_lv
   LV    VG    Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert SyncAction Mismatches
   my_lv my_vg rwi-a-r--- 500.00m                                    100.00           idle        0

Procedure

1. Create a RAID logical volume:

   # lvcreate --type raid5 -i 3 -L 500M -n my_lv my_vg
   Using default stripesize 64.00 KiB.
   Rounding size 500.00 MiB (125 extents) up to stripe boundary size 504.00 MiB (126 extents).
   Logical volume "my_lv" created.

2. View the RAID logical volume:

   # lvs -a -o +devices,segtype
     LV               VG            Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert Devices                                                                 Type
     my_lv            my_vg         rwi-a-r--- 504.00m                                    100.00           my_lv_rimage_0(0),my_lv_rimage_1(0),my_lv_rimage_2(0),my_lv_rimage_3(0) raid5
     [my_lv_rimage_0] my_vg         iwi-aor--- 168.00m                                                     /dev/sda(1)                                                             linear

3. Convert the RAID logical volume to another RAID level:

   # lvconvert --type raid6 my_vg/my_lv
   Using default stripesize 64.00 KiB.
   Replaced LV type raid6 (same as raid6_zr) with possible type raid6_ls_6.
   Repeat this command to convert to raid6 after an interim conversion has finished.
   Are you sure you want to convert raid5 LV my_vg/my_lv to raid6_ls_6 type? [y/n]: y
   Logical volume my_vg/my_lv successfully converted.

4. Optional: If this command prompts to repeat the conversion, run:

   # lvconvert --type raid6 my_vg/my_lv

Verification

1. View the RAID logical volume with the converted RAID level:

   # lvs -a -o +devices,segtype
     LV               VG            Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert Devices                                                                                   Type
     my_lv            my_vg         rwi-a-r--- 504.00m                                    100.00           my_lv_rimage_0(0),my_lv_rimage_1(0),my_lv_rimage_2(0),my_lv_rimage_3(0),my_lv_rimage_4(0) raid6
     [my_lv_rimage_0] my_vg         iwi-aor--- 172.00m                                                     /dev/sda(1)                                                                               linear

Procedure

1. Create a RAID logical volume:

   # lvcreate --type raid5 -i 2 -L 500M -n my_lv my_vg
   
   Using default stripesize 64.00 KiB.
   Rounding size 500.00 MiB (125 extents) up to stripe boundary size 504.00 MiB (126 extents).
   Logical volume "my_lv" created.

2. View the RAID logical volume:

   # lvs -a -o +devices
   
   LV               VG    Attr       LSize   Pool   Origin Data% Meta% Move Log Cpy%Sync Convert Devices
   my_lv            my_vg rwi-a-r--- 504.00m                                    100.00            my_lv_rimage_0(0),my_lv_rimage_1(0),my_lv_rimage_2(0)
   [my_lv_rimage_0] my_vg iwi-aor--- 252.00m                                                      /dev/sda(1)
   [my_lv_rimage_1] my_vg iwi-aor--- 252.00m                                                      /dev/sdb(1)
   [my_lv_rimage_2] my_vg iwi-aor--- 252.00m                                                      /dev/sdc(1)
   [my_lv_rmeta_0]  my_vg ewi-aor---   4.00m                                                      /dev/sda(0)
   [my_lv_rmeta_1]  my_vg ewi-aor---   4.00m                                                      /dev/sdb(0)
   [my_lv_rmeta_2]  my_vg ewi-aor---   4.00m                                                      /dev/sdc(0)

3. Optional: View the stripes images and stripesize of the RAID logical volume:

   # lvs -o stripes my_vg/my_lv
     #Str
        3

   # lvs -o stripesize my_vg/my_lv
     Stripe
     64.00k

4. Modify the attributes of the RAID logical volume by using the following ways depending on your requirement:

   1. Modify the stripes images of the RAID logical volume:

      # lvconvert --stripes 3 my_vg/my_lv
      Using default stripesize 64.00 KiB.
      WARNING: Adding stripes to active logical volume my_vg/my_lv will grow it from 126 to 189 extents!
      Run "lvresize -l126 my_vg/my_lv" to shrink it or use the additional capacity.
      Are you sure you want to add 1 images to raid5 LV my_vg/my_lv? [y/n]: y
      Logical volume my_vg/my_lv successfully converted.

   2. Modify the stripesize of the RAID logical volume:

      # lvconvert --stripesize 128k my_vg/my_lv
        Converting stripesize 64.00 KiB of raid5 LV my_vg/my_lv to 128.00 KiB.
      Are you sure you want to convert raid5 LV my_vg/my_lv? [y/n]: y
        Logical volume my_vg/my_lv successfully converted.

   3. Modify the maxrecoveryrate and minrecoveryrate attributes:

      # lvchange --maxrecoveryrate 4M my_vg/my_lv
        Logical volume my_vg/my_lv changed.

      # lvchange --minrecoveryrate 1M my_vg/my_lv
        Logical volume my_vg/my_lv changed.

   4. Modify the syncaction attribute:

      # lvchange --syncaction check my_vg/my_lv

   5. Modify the writemostly and writebehind attributes:

      # lvchange --writemostly /dev/sdb my_vg/my_lv
        Logical volume my_vg/my_lv changed.

      # lvchange --writebehind 100 my_vg/my_lv
        Logical volume my_vg/my_lv changed.

Verification

1. View the stripes images and stripesize of the RAID logical volume:

   # lvs -o stripes my_vg/my_lv
     #Str
        4

   # lvs -o stripesize my_vg/my_lv
     Stripe
     128.00k

2. View the RAID logical volume after modifying the maxrecoveryrate attribute:

   # lvs -a -o +raid_max_recovery_rate
     LV               VG       Attr        LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert MaxSync
     my_lv            my_vg    rwi-a-r---  10.00g                                     100.00           4096
     [my_lv_rimage_0] my_vg    iwi-aor---  10.00g
    [...]

3. View the RAID logical volume after modifying the minrecoveryrate attribute:

   # lvs -a -o +raid_min_recovery_rate
     LV               VG     Attr        LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert MinSync
     my_lv            my_vg  rwi-a-r---  10.00g                                     100.00           1024
     [my_lv_rimage_0] my_vg  iwi-aor---  10.00g
     [...]

4. View the RAID logical volume after modifying the syncaction attribute:

   # lvs -a
     LV               VG      Attr        LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert
     my_lv            my_vg   rwi-a-r---  10.00g                                     2.66
     [my_lv_rimage_0] my_vg   iwi-aor---  10.00g
     [...]

Procedure

1. Create a RAID logical volume:

   # lvcreate --type raid1 -m 1 -L 10G test
     Logical volume "lvol0" created.

2. View the RAID logical volume:

   # lvs -a -o +devices,region_size
   
   LV                VG      Attr     LSize Pool Origin Data% Meta% Move Log   Cpy%Sync Convert Devices                              Region
   lvol0             test rwi-a-r--- 10.00g                                    100.00           lvol0_rimage_0(0),lvol0_rimage_1(0)  2.00m
   [lvol0_rimage_0]  test iwi-aor--- 10.00g                                                     /dev/sde1(1)                            0
   [lvol0_rimage_1]  test iwi-aor--- 10.00g                                                     /dev/sdf1(1)                            0
   [lvol0_rmeta_0]   test ewi-aor---  4.00m                                                     /dev/sde1(0)                            0
   [lvol0_rmeta_1]   test ewi-aor---  4.00m

   The Region column indicates the raid_region_size parameter’s value.

3. Optional: View the raid_region_size parameter’s value:

   # cat /etc/lvm/lvm.conf | grep raid_region_size
   
   # Configuration option activation/raid_region_size.
   	# raid_region_size = 2048

4. Change the region size of a RAID logical volume:

   # lvconvert -R 4096K my_vg/my_lv
   
   Do you really want to change the region_size 512.00 KiB of LV my_vg/my_lv to 4.00 MiB? [y/n]: y
     Changed region size on RAID LV my_vg/my_lv to 4.00 MiB.

5. Resynchronize the RAID logical volume:

   # lvchange --resync my_vg/my_lv
   
   Do you really want to deactivate logical volume my_vg/my_lv to resync it? [y/n]: y

Verification

1. View the RAID logical volume:

   # lvs -a -o +devices,region_size
   
   LV               VG   Attr        LSize Pool Origin Data% Meta% Move Log Cpy%Sync Convert Devices                              Region
   lvol0            test rwi-a-r--- 10.00g                                    6.25           lvol0_rimage_0(0),lvol0_rimage_1(0)  4.00m
   [lvol0_rimage_0] test iwi-aor--- 10.00g                                                   /dev/sde1(1)                            0
   [lvol0_rimage_1] test iwi-aor--- 10.00g                                                   /dev/sdf1(1)                            0
   [lvol0_rmeta_0]  test ewi-aor---  4.00m                                                   /dev/sde1(0)                            0

   The Region column indicates the changed value of the raid_region_size parameter.

2. View the raid_region_size parameter’s value in the lvm.conf file:

   # cat /etc/lvm/lvm.conf | grep raid_region_size
   
   # Configuration option activation/raid_region_size.
   	# raid_region_size = 4096

Procedure

1. Create a volume group (VG):

   # vgcreate <vg_name> <PV> ...

   Where:

   • <vg_name> is the name of the VG.
   • <PV> are the PVs.

2. You can allocate PV to create different volume types, such as linear or raid:

   1. Allocate extents to create a linear volume:

      # lvcreate -n <lv_name> -L <lv_size> <vg_name> [ <PV> ... ]

      Where:

      • <lv_name> is the name of the LV.
      • <lv_size> is the size of the LV. Default unit is megabytes.
      • <vg_name> is the name of the VG.

      • [ <PV …​> ] are the PVs.

        You can specify one of the PVs, all of them, or none on the command line:

        • If you specify one PV, extents for that LV will be allocated from it.

          Note

          If the PV does not have sufficient free extents for the entire LV, then the lvcreate fails.

        • If you specify two PVs, extents for that LV will be allocated from one of them, or a combination of both.

        • If you do not specify any PV, extents will be allocated from one of the PVs in the VG, or any combination of all PVs in the VG.

          Note

          In these cases, LVM might not use all of the named or available PVs. If the first PV has sufficient free extents for the entire LV, then the other PV will probably not be used. However, if the first PV does not have a set allocation size of free extents, then LV might be allocated partly from the first PV and partly from the second PV.

          Example 10.1. Allocating extents from one PV

          In this example, lv1 extents will be allocated from sda.

          # lvcreate -n lv1 -L1G vg /dev/sda

          Example 10.2. Allocating extents from two PVs

          In this example, lv2 extents will be allocated from either sda, or sdb, or a combination of both.

          # lvcreate -n lv2 L1G vg /dev/sda /dev/sdb

          Example 10.3. Allocating extents without specifying PV

          In this example, lv3 extents will be allocated from one of the PVs in the VG, or any combination of all PVs in the VG.

          # lvcreate -n lv3 -L1G vg

          or

   2. Allocate extents to create a raid volume:

      # lvcreate --type <segment_type> -m <mirror_images> -n <lv_name> -L <lv_size> <vg_name> [ <PV> ... ]

      Where:

      • <segment_type> is the specified segment type (for example raid5, mirror, snapshot).
      • <mirror_images> creates a raid1 or a mirrored LV with the specified number of images. For example, -m 1 would result in a raid1 LV with two images.
      • <lv_name> is the name of the LV.
      • <lv_size> is the size of the LV. Default unit is megabytes.
      • <vg_name> is the name of the VG.

      • <[PV …​]> are the PVs.

        The first raid image will be allocated from the first PV, the second raid image from the second PV, and so on.

        Example 10.4. Allocating raid images from two PVs

        In this example, lv4 first raid image will be allocated from sda and second image will be allocated from sdb.

        # lvcreate --type raid1 -m 1 -n lv4 -L1G vg /dev/sda /dev/sdb

        Example 10.5. Allocating raid images from three PVs

        In this example, lv5 first raid image will be allocated from sda, second image will be allocated from sdb, and third image will be allocated from sdc.

        # lvcreate --type raid1 -m 2 -n lv5 -L1G vg /dev/sda /dev/sdb /dev/sdc

1. Run lvchange --addtag @db2 vg1/lvol2 from any host in the cluster.
2. Run lvchange -ay vg1/lvol2.

Procedure

1. Activate the remaining physical volumes in the volume group:

   # vgchange --activate y --partial myvg

2. Check which logical volumes will be removed:

   # vgreduce --removemissing --test myvg

3. Remove all the logical volumes that used the lost physical volume from the volume group:

   # vgreduce --removemissing --force myvg

4. Optional: If you accidentally removed logical volumes that you wanted to keep, you can reverse the vgreduce operation:

   # vgcfgrestore myvg

   Warning

   If you remove a thin pool, LVM cannot reverse the operation.

Procedure

1. Find the archived metadata file of the volume group that contains the physical volume. The archived metadata files are located at the /etc/lvm/archive/volume-group-name_backup-number.vg path:

   # cat /etc/lvm/archive/myvg_00000-1248998876.vg

   Replace 00000-1248998876 with the backup-number. Select the last known valid metadata file, which has the highest number for the volume group.

2. Find the UUID of the physical volume. Use one of the following methods.

   • List the logical volumes:

     # lvs --all --options +devices
     
       Couldn't find device with uuid 'FmGRh3-zhok-iVI8-7qTD-S5BI-MAEN-NYM5Sk'.

   • Examine the archived metadata file. Find the UUID as the value labeled id = in the physical_volumes section of the volume group configuration.

   • Deactivate the volume group using the --partial option:

     # vgchange --activate n --partial myvg
     
       PARTIAL MODE. Incomplete logical volumes will be processed.
       WARNING: Couldn't find device with uuid 42B7bu-YCMp-CEVD-CmKH-2rk6-fiO9-z1lf4s.
       WARNING: VG myvg is missing PV 42B7bu-YCMp-CEVD-CmKH-2rk6-fiO9-z1lf4s (last written to /dev/vdb1).
       0 logical volume(s) in volume group "myvg" now active

Procedure

1. Restore the metadata on the physical volume:

   # pvcreate --uuid physical-volume-uuid \
              --restorefile /etc/lvm/archive/volume-group-name_backup-number.vg \
              block-device

   Note

   The command overwrites only the LVM metadata areas and does not affect the existing data areas.

   Example 12.4. Restoring a physical volume on /dev/vdb1

   The following example labels the /dev/vdb1 device as a physical volume with the following properties:

   • The UUID of FmGRh3-zhok-iVI8-7qTD-S5BI-MAEN-NYM5Sk
   • The metadata information contained in VG_00050.vg, which is the most recent good archived metadata for the volume group

   # pvcreate --uuid "FmGRh3-zhok-iVI8-7qTD-S5BI-MAEN-NYM5Sk" \
              --restorefile /etc/lvm/archive/VG_00050.vg \
              /dev/vdb1
   
     ...
     Physical volume "/dev/vdb1" successfully created

2. Restore the metadata of the volume group:

   # vgcfgrestore myvg
   
     Restored volume group myvg

3. Display the logical volumes on the volume group:

   # lvs --all --options +devices myvg

   The logical volumes are currently inactive. For example:

     LV     VG   Attr   LSize   Origin Snap%  Move Log Copy%  Devices
     mylv myvg   -wi--- 300.00G                               /dev/vdb1 (0),/dev/vdb1(0)
     mylv myvg   -wi--- 300.00G                               /dev/vdb1 (34728),/dev/vdb1(0)

4. If the segment type of the logical volumes is RAID, resynchronize the logical volumes:

   # lvchange --resync myvg/mylv

5. Activate the logical volumes:

   # lvchange --activate y myvg/mylv

6. If the on-disk LVM metadata takes at least as much space as what overrode it, this procedure can recover the physical volume. If what overrode the metadata went past the metadata area, the data on the volume may have been affected. You might be able to use the fsck command to recover that data.

Procedure

1. Find the number of free physical extents in the volume group:

   # vgdisplay myvg

   Example 12.5. Free extents in a volume group

   For example, the following volume group has 8780 free physical extents:

   --- Volume group ---
    VG Name               myvg
    System ID
    Format                lvm2
    Metadata Areas        4
    Metadata Sequence No  6
    VG Access             read/write
   [...]
   Free  PE / Size       8780 / 34.30 GB

2. Create the logical volume. Enter the volume size in extents rather than bytes.

   Example 12.6. Creating a logical volume by specifying the number of extents

   # lvcreate --extents 8780 --name mylv myvg

   Example 12.7. Creating a logical volume to occupy all the remaining space

   Alternatively, you can extend the logical volume to use a percentage of the remaining free space in the volume group. For example:

   # lvcreate --extents 100%FREE --name mylv myvg

Procedure

1. Collect the following information needed for the pvcreate and vgcfgrestore commands. You can collect the information about your disk and UUID by running the # pvs -o+uuid command.

   • metadata-file is the path to the most recent metadata backup file for the VG, for example, /etc/lvm/backup/<vg-name>
   • vg-name is the name of the VG that has the damaged or missing PV.
   • UUID of the PV that was damaged on this device is the value taken from the output of the # pvs -i+uuid command.
   • disk is the name of the disk where the PV is supposed to be, for example, /dev/sdb. Be certain this is the correct disk, or seek help, otherwise following these steps may lead to data loss.

2. Recreate LVM headers on the disk:

   # pvcreate --restorefile <metadata-file> --uuid <UUID> <disk>

   Optionally, verify that the headers are valid:

   # pvck --dump headers <disk>

3. Restore the VG metadata on the disk:

   # vgcfgrestore --file <metadata-file> <vg-name>

   Optionally, verify the metadata is restored:

   # pvck --dump metadata <disk>