An Introduction to the Linux Logical Volume Manager (LVM)

Table of Contents

1. Why Use LVM? Key Benefits
2. LVM Components Explained
3. How LVM Works: The Basic Workflow
4. Step-by-Step Guide to Setting Up LVM
5. Common LVM Operations
6. LVM vs. Traditional Partitioning: A Comparison
7. Advanced LVM Features
8. Troubleshooting Common LVM Issues
9. Conclusion
10. References

Why Use LVM? Key Benefits

LVM addresses the limitations of traditional partitioning with several compelling advantages:

• Dynamic Resizing: Resize logical volumes (LVs) on-the-fly (no downtime for most operations) as storage needs change.
• Storage Pooling: Combine multiple physical disks/partitions into a single “volume group” (VG), treating them as a unified storage pool.
• Snapshots: Create point-in-time snapshots of LVs for backups or testing, without interrupting the original volume.
• Flexible Naming: Logical volumes can be named descriptively (e.g., data_lv, backup_lv) instead of relying on cryptic device names like /dev/sdb1.
• Abstraction: Isolate logical storage from physical hardware, making it easier to replace or upgrade disks without disrupting services.
• Redundancy & Performance: Advanced features like mirroring (for redundancy) and striping (for performance) enhance reliability and speed.

LVM Components Explained

To understand LVM, you first need to grasp its core components, which work together to abstract physical storage into logical volumes:

1. Physical Volume (PV)

A Physical Volume is the lowest level of LVM: a physical disk (e.g., /dev/sda) or partition (e.g., /dev/sdb1) that has been initialized for LVM use. When you create a PV, LVM writes a header and metadata to the disk/partition, enabling it to be recognized as part of the LVM system.

2. Volume Group (VG)

A Volume Group is a pool of storage created by combining one or more PVs. Think of a VG as a “virtual disk” that aggregates all the space from its underlying PVs. For example, if you have two 100GB disks, you can create a VG with 200GB of total storage.

3. Logical Volume (LV)

A Logical Volume is the “partition” you actually use. LVs are created from the free space in a VG and can be formatted with a filesystem (e.g., ext4, XFS) and mounted like a traditional partition. LVs are flexible: they can be resized, moved between PVs, or snapshotted.

4. Physical Extent (PE)

The Physical Extent is the smallest unit of storage in a VG. All PVs in a VG are divided into PEs (default size: 4MB). When you create an LV, it is allocated a number of PEs from the VG.

5. Logical Extent (LE)

A Logical Extent is the unit used by LVs. Each LE maps directly to a PE in the VG, ensuring the LV’s data is stored across the VG’s PVs.

How LVM Works: The Basic Workflow

LVM operates in a layered fashion, abstracting physical storage into logical volumes. Here’s a simplified workflow:

1. Prepare Physical Storage: Convert disks/partitions into PVs using pvcreate.
2. Create a Volume Group: Combine PVs into a VG using vgcreate, creating a pool of storage.
3. Create Logical Volumes: Carve out LVs from the VG using lvcreate, specifying size and name.
4. Use the Logical Volume: Format the LV with a filesystem (e.g., mkfs.ext4) and mount it (e.g., mount /dev/my_vg/my_lv /mnt/data).

This workflow decouples logical storage (LVs) from physical hardware (PVs), allowing you to resize, move, or snapshot LVs without touching the underlying disks.

Step-by-Step Guide to Setting Up LVM

Let’s walk through setting up LVM on a Linux system. We’ll use two example disks: /dev/sdb (100GB) and /dev/sdc (100GB).

Prerequisites

• Root or sudo access.
• One or more unused disks/partitions (we’ll use /dev/sdb and /dev/sdc).
• LVM tools installed (usually pre-installed on most Linux distros; if not, install via apt install lvm2 or yum install lvm2).

Step 1: Prepare Disks as Physical Volumes (PVs)

First, initialize the disks as PVs. If using partitions (instead of whole disks), create a partition with type 8e (LVM) using fdisk or parted first. For whole disks:

# Initialize /dev/sdb and /dev/sdc as PVs
sudo pvcreate /dev/sdb /dev/sdc

Verify PVs were created:

sudo pvs  # List all PVs
sudo pvdisplay /dev/sdb  # Detailed info about /dev/sdb

Step 2: Create a Volume Group (VG)

Next, combine the PVs into a VG. We’ll name our VG my_vg and add /dev/sdb and /dev/sdc to it:

# Create VG "my_vg" with PVs /dev/sdb and /dev/sdc
sudo vgcreate my_vg /dev/sdb /dev/sdc

Verify the VG:

sudo vgs  # List all VGs (should show "my_vg" with ~200GB total)
sudo vgdisplay my_vg  # Detailed info about "my_vg"

Step 3: Create a Logical Volume (LV)

Now, create an LV from my_vg. Let’s create a 150GB LV named data_lv:

# Create LV "data_lv" with 150GB from VG "my_vg"
sudo lvcreate -L 150G -n data_lv my_vg

• -L 150G: Size of the LV (use -l 100%FREE to use all free space in the VG).
• -n data_lv: Name of the LV.

Verify the LV:

sudo lvs  # List all LVs (should show "data_lv" in "my_vg")
sudo lvdisplay /dev/my_vg/data_lv  # Detailed info

Step 4: Format and Mount the LV

Format the LV with a filesystem (we’ll use ext4) and mount it:

# Format the LV with ext4
sudo mkfs.ext4 /dev/my_vg/data_lv

# Create a mount point
sudo mkdir /mnt/data

# Mount the LV
sudo mount /dev/my_vg/data_lv /mnt/data

To make the mount persistent across reboots, add an entry to /etc/fstab:

# Get the LV's UUID (use blkid)
sudo blkid /dev/my_vg/data_lv

Add this line to /etc/fstab (replace UUID=... with your LV’s UUID):

UUID=your-lv-uuid /mnt/data ext4 defaults 0 0

Common LVM Operations

LVM’s true power lies in its flexibility. Here are essential operations for managing LVM.

Extending a Logical Volume

To increase the size of an LV (e.g., add 50GB to data_lv):

1. Ensure the VG has free space:

   sudo vgs  # Check "Free" column for "my_vg"

   If the VG is full, add a new PV first (see “Adding a New PV” below).

2. Extend the LV:

   sudo lvextend -L +50G /dev/my_vg/data_lv  # Add 50GB
   # Or use -l +100%FREE to use all free space in the VG

3. Resize the filesystem (required for the OS to recognize the new size):

   • For ext4/XFS:

     # ext4:
     sudo resize2fs /dev/my_vg/data_lv
     
     # XFS (use xfs_growfs; XFS cannot be shrunk!):
     sudo xfs_growfs /mnt/data  # Mount point, not LV path

Reducing a Logical Volume (Caution!)

Shrinking an LV is risky (data loss possible). Always back up data first!

1. Unmount the LV:

   sudo umount /mnt/data

2. Check the filesystem for errors:

   sudo e2fsck -f /dev/my_vg/data_lv  # For ext4

3. Shrink the filesystem (must be smaller than the LV size):

   sudo resize2fs /dev/my_vg/data_lv 100G  # Shrink to 100GB

4. Shrink the LV:

   sudo lvreduce -L 100G /dev/my_vg/data_lv

5. Remount the LV:

   sudo mount /dev/my_vg/data_lv /mnt/data

Adding a New PV to a VG

To expand a VG with a new disk (e.g., /dev/sdd):

# Initialize the new disk as a PV
sudo pvcreate /dev/sdd

# Add the PV to the existing VG "my_vg"
sudo vgextend my_vg /dev/sdd

# Verify the VG now has more space
sudo vgs

Removing a PV from a VG

To remove a PV (e.g., /dev/sdb) from a VG, first move its data to other PVs:

# Move data from /dev/sdb to other PVs in the VG
sudo pvmove /dev/sdb

# Remove /dev/sdb from the VG
sudo vgreduce my_vg /dev/sdb

# Optionally, delete the PV (if no longer needed)
sudo pvremove /dev/sdb

Creating Snapshots

Snapshots capture the state of an LV at a point in time (useful for backups).

# Create a 10GB snapshot of "data_lv" named "data_lv_snap"
sudo lvcreate -s -L 10G -n data_lv_snap /dev/my_vg/data_lv

# Mount the snapshot to access its contents (read-only by default)
sudo mkdir /mnt/snap
sudo mount /dev/my_vg/data_lv_snap /mnt/snap -o ro

Delete the snapshot when done:

sudo umount /mnt/snap
sudo lvremove /dev/my_vg/data_lv_snap

LVM vs. Traditional Partitioning

Advanced LVM Features

LVM offers advanced features for performance, redundancy, and efficiency:

Thin Provisioning

Over-allocate storage (e.g., create a 100GB LV that only uses space when data is written). Ideal for VMs or environments with variable storage needs:

# Create a thin pool (20GB) in "my_vg"
sudo lvcreate -L 20G -T my_vg/thin_pool

# Create a 50GB thin-provisioned LV from the pool
sudo lvcreate -V 50G -T my_vg/thin_pool -n thin_lv

Striping

Improve read/write performance by spreading data across multiple PVs (like RAID 0):

# Create a 40GB striped LV across 2 PVs (strip size: 64KB)
sudo lvcreate -i 2 -I 64K -L 40G -n striped_lv my_vg

Mirroring

Add redundancy by mirroring data across PVs (like RAID 1). Requires at least 2 PVs:

# Create a 20GB mirrored LV (1 mirror copy)
sudo lvcreate -m 1 -L 20G -n mirrored_lv my_vg

Troubleshooting Common LVM Issues

• PV Not Detected: Check if the disk is connected (lsblk). Run sudo pvscan to rescan for PVs.
• VG Full: Add more PVs with vgextend.
• LV Won’t Mount: Check the filesystem with e2fsck /dev/my_vg/my_lv.
• Snapshot Runs Out of Space: Delete old snapshots or increase snapshot size with lvextend.
• Corrupted Metadata: Restore from backup with vgcfgrestore my_vg (backups are stored in /etc/lvm/backup/).

Conclusion

LVM transforms storage management from a rigid, disk-bound process into a flexible, dynamic workflow. By abstracting physical storage into logical volumes, LVM simplifies resizing, pooling, and snapshotting, making it indispensable for servers, VMs, and anyone with evolving storage needs. While it has a learning curve, the benefits—flexibility, efficiency, and scalability—far outweigh the effort.

Whether you’re managing a home server or a data center, LVM is a tool worth mastering.

References

• Red Hat LVM Documentation
• Ubuntu LVM Guide
• LVM Man Pages
• The Linux LVM Handbook