LVM - Httqm's Docs

Data striping with LVM is (theoretically) similar to RAID 0 : it allows (advertises ?) better performance by sharing I/O across several devices (to the cost of data protection, though).
LVM also allows mirroring data, like RAID 1 does. article about LVM mirroring

When looking for redundancy (RAIDx, LVM on RAID, ...), redundancy layers must come closest to the hardware (source).
In a general-purpose workstation context, there is no real guarantee of I/O throughput increase with LVM striping : it depends on other factors (hardware, file size, number of files, concurrent I/O, ...) (details)
LVM is designed for flexibility of storage management (add, remove, extend, ...), whereas RAID offers performance and reliability.

I tested all this on a virtual machine. The first step was to create 3 new virtual disks.

apt install lvm2

lsblk

NAME	MAJ:MIN	RM	SIZE	RO	TYPE	MOUNTPOINT
sda	8:0	0	12G	0	disk
├─sda1	8:1	0	11G	0	part	/
├─sda2	8:2	0	1K	0	part
└─sda5	8:5	0	1022M	0	part	[SWAP]
sdb	8:16	0	100M	0	disk			disk 1
sdc	8:32	0	100M	0	disk			disk 2
sdd	8:48	0	100M	0	disk			disk 3
sr0	11:0	1	1024M	0	rom

for device in sdb sdc sdd; do pvcreate "/dev/$device"; done

Physical volume "/dev/sdb" successfully created.
Physical volume "/dev/sdc" successfully created.
Physical volume "/dev/sdd" successfully created.

pvcreate /dev/sd[bcd] might have done the job as well

vgcreate myVolumeGroup /dev/sd{b,c,d}

Volume group "myVolumeGroup" successfully created

vgdisplay

--- Volume group ---
VG Name			myVolumeGroup
System ID
Format			lvm2
Metadata Areas		3
Metadata Sequence No	1
VG Access		read/write
VG Status		resizable
MAX LV			0
Cur LV			0
Open LV			0
Max PV			0
Cur PV			3
Act PV			3
VG Size			288.00 MiB		approximately the sum of the 3 disks size
PE Size			4.00 MiB
Total PE		72
Alloc PE / Size		0 / 0
Free  PE / Size		72 / 288.00 MiB
VG UUID			D3vnxv-UV8u-fhkH-K63N-9Wpn-r9Ix-lOkda7

lvcreate -i3 -I128 -L200M -n myLogicalVolume myVolumeGroup
The 128KB stripe size is arbitrary since I've not (yet) been able to find a generic guide to compute this value.
```
Rounding size 200.00 MiB (50 extents) up to stripe boundary size 204.00 MiB (51 extents).
Logical volume "myLogicalVolume" created.
```

Let's see what we have :

lvs --segments

LV			VG		Attr		#Str	Type		SSize
myLogicalVolume		myVolumeGroup	-wi-a-----	3	striped	204.00m

details about a striped logical volume :

lvdisplay -m

--- Logical volume ---
LV Path			/dev/myVolumeGroup/myLogicalVolume
LV Name			myLogicalVolume
VG Name			myVolumeGroup
LV UUID			vQlrkI-SNm8-qMtL-pyOi-f5XI-4oTh-yIFkEO
LV Write Access		read/write
LV Creation host, time	myVirtualMachine, 2017-10-26 16:55:17 +0200
LV Status		available
# open			0
LV Size			204.00 MiB
Current LE		51
Segments		1
Allocation		inherit
Read ahead sectors	auto
- currently set to	1536
Block device		254:0

--- Segments ---
Logical extents 0 to 50:
	Type				striped
	Stripes				3
	Stripe size			128.00 KiB
	Stripe 0:
		Physical volume		/dev/sdb
		Physical extents	0 to 16
	Stripe 1:
		Physical volume		/dev/sdc
		Physical extents	0 to 16
	Stripe 2:
		Physical volume		/dev/sdd
		Physical extents	0 to 16

Time to create a filesystem :
mkfs.ext4 /dev/myVolumeGroup/myLogicalVolume
mountPoint='/mnt/myMountPoint'; mkdir -p "$mountPoint"; mount /dev/myVolumeGroup/myLogicalVolume "$mountPoint"; df -h "$mountPoint"
```
Filesystem					Size	Used	Avail	Use%	Mounted on
/dev/mapper/myVolumeGroup-myLogicalVolume	194M	1.8M	178M	1%	/mnt/myMountPoint
```
/dev/myVolumeGroup/myLogicalVolume and /dev/mapper/myVolumeGroup-myLogicalVolume are both symlinks pointing to a child of /dev.

Now let's write some data :

testFile="$mountPoint/myFile"; fallocate -l 160m "$testFile"; ll "$testFile"; df -h "$mountPoint"

-rw-r--r--	1	root	root	160M	Nov	3	15:53	/mnt/myMountPoint/myFile

Filesystem					Size	Used	Avail	Use%	Mounted on
/dev/mapper/myVolumeGroup-myLogicalVolume	194M	162M	18M	91%	/mnt/myMountPoint

Logical volumes can be thinly provisioned. This allows to create logical volumes that are larger than the available extents. In other words, this allows to over-commit the physical storage with logical volumes expanding as they're written to.

thin pool: storage space containing thin volumes. This can be expanded dynamically.
thin volume: thin volumes are a special flavor of logical volumes. They are not actually as big as their "official" size. Instead, they grow only when they are written to.

How to detect whether a logical volume is a "regular" or a "thin" one ?

Just read it from the logical volume attributes :

lvs docker/thinpool docker/thinpoolmeta -o lv_name,lv_attr,modules,metadata_lv

regular :

LV		Attr		Modules		Meta
thinpool	-wi-a-----
thinpoolmeta	-wi-a-----

thin :
```
LV		Attr		Modules		Meta
thinpool	twi-a-t---	thin-pool	[thinpool_tmeta]
thinpoolmeta	-wi-a-----
```
- the 1^st t (bit 1) means the volume type is thin pool
- the 2^nd t (bit 7) mean the target type is thin
For details : man lvs, then search lv_attr bits.

I've hit this thin / regular volumes subject while configuring Docker. After the lvconvert step (see previous link), there should be no more thinpoolmeta logical volume. This one is still visible in my examples above because of an Ansible playbook that was not actually idempotent.

Let's say we want to add the /dev/sdb storage device to the /dev/myLVM/homes logical volume :

check the storage device is available :
- ls -l /dev/sdb
- lsblk | grep sdb
turn the whole unpartitioned + unformatted storage device into a LVM physical volume (details) :
pvcreate /dev/sdb
- this implies the whole storage device is dedicated to LVM
- if you want only a fraction of the storage device to be used by LVM, you have to :
  1. create a new partition on this storage device :
    fdisk /dev/sdb
  2. format it :
    mkfs.ext4 /dev/sdbn
  3. don't forget to refer to /dev/sdbn in the steps below
Partitioning a storage device is discouraged because :
- it adds extra steps and complexity after enlarging a virtual disk to resize the whole stack : partition + PV + VG + LV (related)
- if the remainder of the storage device —which is not used by LVM— is used by the operating system's root filesystem, you'll have to boot from an external media to be able to alter the partition table of the storage device
add this new volume to the existing volume group myLVM (source) :
vgextend myLVM /dev/sdb

Since a VG is just a collection of PVs, this step isn't even necessary : anything that belongs to a PV also belongs to its VG. The extra PV space is already available to the VG. Check it with vgs
resize the logical volume /dev/myLVM/homes by assigning it the extra space :
- this syntax is a special case (details)
  
  lvextend /dev/myLVM/homes /dev/sdb
- in a not-so-specific situation, that would be :
  lvextend -t -l +100%FREE -r /dev/myLVM/homes
  
  Thanks to the -r flag, this also resizes the underlying filesystem, making the next steps useless
umount the partition, check it, then resize it accordingly.
It is possible to enlarge a logical volume and the filesystem on it at the same time (and without unmounting it!).

apt install lvm2
it all starts here
pvcreate /dev/sda1
initialize a physical volume (disk or partition) for use by LVM
You can also use an entire unpartitioned unformatted drive if you like : pvcreate /dev/sdx
vgcreate myVolumeGroup /dev/sda1 /dev/sdb1
create a volume group named myVolumeGroup with /dev/sda1 and /dev/sdb1
view details of volume groups
- vgscan : list volume groups
- vgdisplay myVolumeGroup : display details of the volume group myVolumeGroup (or all volume groups if omitted)
lvcreate -n myLogicalVolume --size 1g myVolumeGroup
create a 1GB logical volume named myLogicalVolume in the existing volume group myVolumeGroup
view details of logical volumes
- lvscan : list logical volumes
- lvdisplay : show details of logical volumes
- There are several ways to refer to the new volume :
  - /dev/myVolumeGroup/myLogicalVolume
  - /dev/mapper/myVolumeGroup-myLogicalVolume
  fdisk -l newVolume
mkfs [options] newVolume
this is why you did all this

Here are the step-by-step instructions to resize my /home partition.

Preliminary steps :

Consider cleaning up old / unused / dusty / obsolete / ... data from /home
Backup everything important from /home

Get the device name :

mount | grep /home

/dev/mapper/myLVM-homes on /home type ext4 (rw,relatime,data=ordered)

Determine the new filesystem size, considering the currently available free space (you can only remove free space, but you'll still want some free space afterwards)
lvreduce's manual is not very explicit, but it sounds like you _may_ actually remove some used storage space :
df -h /home
```
Filesystem		Size	Used	Avail	Use%	Mounted on
/dev/mapper/myLVM-homes	5.2T	2.0T	3.2T	39%	/home
```
2TB are used so far, so a final size of 4TB looks ok.

Honey, I shrunk my /home :

Unmount the target filesystem : umount /home
Check it :
fsck.ext4 -f /dev/mapper/myLVM-homes
- Use the fsck flavor matching your filesystem type
- All fsck steps must be OK
Now let's resize it :
resize2fs /dev/mapper/myLVM-homes 4096G
Then reduce the logical volume holding it :
lvreduce --size 4096G /dev/mapper/myLVM-homes

Note it worked :

vgdisplay | grep Size

VG Size			5.23 TiB		/home was 100% of that
PE Size			4.00 MiB
Alloc PE / Size		1054536 / 4.02 TiB	now /home is this
Free  PE / Size		316641 / 1.21 TiB	this is available for new logical volumes

shorter version : vgs

VG	#PV	#LV	#SN	Attr	VSize	VFree
myLVM	3	2	0	wz--n-	5.23t	1.21t

Re-check the filesystem
And now, you can re-mount the resized volume : mount /dev/mapper/myLVM-homes /home

lvdisplay : show logical volumes.
vgdisplay : show volume groups (including free space available). Check the Free PE / Size line.
pvdisplay : show physical volumes. Check the Free PE line of each PV.

The idea

Let's consider a machine with 3 data disks (3x 100MB virtual disks) concatenated into a large virtual volume via linear LVM. The setup is pretty similar to what has been done while playing with striped LVM, which is why I won't give too much details on the commands used to create the "BEFORE" picture .
This time, our goal is to remove the second disk : /dev/sdc.

lsblk

NAME	MAJ:MIN	RM	SIZE	RO	TYPE	MOUNTPOINT
sda	8:0	0	12G	0	disk
├─sda1	8:1	0	11G	0	part	/
├─sda2	8:2	0	1K	0	part
└─sda5	8:5	0	1022M	0	part	[SWAP]
sdb	8:16	0	100M	0	disk
sdc	8:32	0	100M	0	disk
sdd	8:48	0	100M	0	disk
sr0	11:0	1	1024M	0	rom

Now let's do our LVM magic. We'll get a ~270MB volume that will be filled with 16x 10MB files :

myDisks='/dev/sd[bcd]'; vgName='myVolumeGroup'; lvName='myLogicalVolume'; lvmDisk="/dev/$vgName/$lvName"; mountPoint='/mnt/mountPoint'; testFile="$mountPoint/testFile_"; md5File="$mountPoint/MD5SUM"; \
	pvcreate $myDisks \
	&& vgcreate "$vgName" $myDisks \
	&& lvcreate -l 100%VG -n "$lvName" "$vgName" \
	&& mkfs.ext4 "$lvmDisk" \
	&& mkdir -p "$mountPoint" \
	&& mount "$lvmDisk" "$mountPoint" \
	&& df -h "$mountPoint" \
	&& for i in {01..16}; do fallocate -l 10m "$testFile$i"; done \
	&& df -h "$mountPoint"; md5sum "$testFile"* > "$md5File"

Filesystem					Size	Used	Avail	Use%	Mounted on
/dev/mapper/myVolumeGroup-myLogicalVolume	271M	2.1M	251M	1%	/mnt/mountPoint
Filesystem					Size	Used	Avail	Use%	Mounted on
/dev/mapper/myVolumeGroup-myLogicalVolume	271M	163M	251M	65%	/mnt/mountPoint

To quickly destroy everything and retry the step above :
umount "$mountPoint" && vgremove -f "$vgName" && pvremove $myDisks

We now have ~270MB in total, with ~160MB used. This means the 1^st disk is full, the 2^nd disk is ~50% used and the 3^rd is empty.
Our mission is now to remove the 2^nd disk (/dev/sdc). To do so, we'll have to move the used space of this disk to the others.

Let's free 1 disk

Let's see what we have :

pvs

PV		VG		Fmt	Attr	PSize	PFree
/dev/sdb	myVolumeGroup	lvm2	a--	96.00m	0
/dev/sdc	myVolumeGroup	lvm2	a--	96.00m	0		the one I want to remove
/dev/sdd	myVolumeGroup	lvm2	a--	96.00m	0

Theoretically, this should suffice :
umount "$mountPoint" && lvreduce -r --extents 48 "$vgName/$lvName" && vgreduce "$vgName" /dev/sdc
... but it doesn't actually .
- This is caused by special conditions in my test environment (read below)
- AND the fact that the data written to /dev/sdc has to go somewhere before I remove the disk
The part that fails is :
lvreduce -r --extents 48 "$vgName/$lvName"
```
fsck from util-linux 2.29.2
/dev/mapper/myVolumeGroup-myLogicalVolume: clean, 27/73728 files, 183415/294912 blocks
	resize2fs: New size smaller than minimum (294912)

fsadm: Resize ext4 failed
	fsadm failed: 1
	Filesystem resize failed.
```
There's a known bug in resize2fs :
```
Known Bugs
The minimum size of the filesystem as estimated by resize2fs may be incorrect, especially for filesystems with 1k and 2k blocksizes.
```
Guess the current block size (source) ?
dumpe2fs -h /dev/mapper/myVolumeGroup-myLogicalVolume | grep -E 'Block (count|size)'
```
Block count:		294912
Block size:		1024		1 KiB
```
Let's do the maths :
```
294912 blocks of 1 KiB each
	x 1024 gives bytes
	/ 1024 gives KiB
	/ 1024 gives MiB
```
echo 294912/1024 | bc
```
288
```
resize2fs computes a wrong minimum size (telling me the current size is actually the minimum size), then refuses to shrink the filesystem. We'll have to compute the final size ourselves and somewhat "force it".
Let's compute the final size, in number of blocks :
- Our target is to use 2 out of 3 drives : 2x 96MiB = 192MiB (96MB is the PV size reported by pvs)
- 192MiB of 1KiB blocks : echo 192*1024 | bc
```
196608
```
- which also gives, in number of extents : echo 192/4 | bc
```
48
```
  with 4MiB being the PE Size reported by :
  vgdisplay | grep 'PE Size'
```
PE Size		4.00 MiB
```
  (we'll use this 48 later )

Now we have all the numbers, we're ready to go :

umount "$mountPoint" && resize2fs -f /dev/mapper/myVolumeGroup-myLogicalVolume 196608

Resizing the filesystem on /dev/mapper/myVolumeGroup-myLogicalVolume to 196608 (1k) blocks.
The filesystem on /dev/mapper/myVolumeGroup-myLogicalVolume is now 196608 (1k) blocks long.

Done with shrinking the filesystem. Let's go for the logical volume :

lvreduce --extents 48 "$vgName/$lvName"

	WARNING: Reducing active logical volume to 192.00 MiB.
	THIS MAY DESTROY YOUR DATA (filesystem etc.)
Do you really want to reduce myVolumeGroup/myLogicalVolume? [y/n]: y
	Size of logical volume myVolumeGroup/myLogicalVolume changed from 288.00 MiB (72 extents) to 192.00 MiB (48 extents).
	Logical volume myVolumeGroup/myLogicalVolume successfully resized.

Check :

pvs

PV		VG		Fmt	Attr	PSize	PFree
/dev/sdb	myVolumeGroup	lvm2	a--	96.00m	0
/dev/sdc	myVolumeGroup	lvm2	a--	96.00m	0
/dev/sdd	myVolumeGroup	lvm2	a--	96.00m	96.00m		free space here (double check with pvdisplay -m)

We've almost reached our goal : 1 of the 3 disks is now free, but not (yet) the right one.

Let's make /dev/sdc free

Let's proceed by moving used space from /dev/sdc to /dev/sdd. This is slow like hell !!!
pvmove /dev/sdc /dev/sdd
```
/dev/sdc: Moved: %
/dev/sdc: Moved: %
/dev/sdc: Moved: 100.00%
```

Check :

pvs

PV		VG		Fmt	Attr	PSize	PFree
/dev/sdb	myVolumeGroup	lvm2	a--	96.00m	0
/dev/sdc	myVolumeGroup	lvm2	a--	96.00m	96.00m		moved here...
/dev/sdd	myVolumeGroup	lvm2	a--	96.00m	0		... from here

Now we can declare /dev/sdc is no longer part of the "myVolumeGroup" volume group :
vgreduce "$vgName" /dev/sdc
```
Removed "/dev/sdc" from volume group "myVolumeGroup"
```

Check :

pvs

PV		VG		Fmt	Attr	PSize	PFree
/dev/sdb	myVolumeGroup	lvm2	a--	96.00m	0
/dev/sdc			lvm2	---	100.00m	100.00m		not allocatable anymore
/dev/sdd	myVolumeGroup	lvm2	a--	96.00m	0

For details about attributes : man pvs, then search pv_attr bits

mount "$lvmDisk" "$mountPoint" && df -h "$mountPoint" && md5sum -c "$md5File"

Filesystem					Size	Used	Avail	Use%	Mounted on
/dev/mapper/myVolumeGroup-myLogicalVolume	178M	162M	3.0M	99%	/mnt/mountPoint

/mnt/mountPoint/testFile_01: OK
/mnt/mountPoint/testFile_02: OK

/mnt/mountPoint/testFile_16: OK

No files were harmed in the process

Final test : what if filesystems were created with 4KB blocks ?

The whole procedure above has been performed on a test machine, where I created tiny disks on purpose (3x 100MB), to stay light on resources. Filesystems were created with defaults options, which led to 1KB blocks and difficulties with resize2fs. With 4KB blocks (which is the standard block size on any decent "data" volume), things are WAY easier :

myDisks='/dev/sd[bcd]'; vgName='myVolumeGroup'; lvName='myLogicalVolume'; lvmDisk="/dev/$vgName/$lvName"; mountPoint='/mnt/mountPoint'; testFile="$mountPoint/testFile_"; md5File="$mountPoint/MD5SUM"; \
	pvcreate $myDisks \
	&& vgcreate "$vgName" $myDisks \
	&& lvcreate -l 100%VG -n "$lvName" "$vgName" \
	&& mkfs.ext4 -b 4096 "$lvmDisk" \
	&& mkdir -p "$mountPoint" \
	&& mount "$lvmDisk" "$mountPoint" \
	&& df -h "$mountPoint" \
	&& for i in {01..16}; do fallocate -l 10m "$testFile$i"; done \
	&& df -h "$mountPoint"; md5sum "$testFile"* > "$md5File"

umount "$mountPoint" && lvreduce -r --extents 48 "$vgName/$lvName" && vgreduce "$vgName" /dev/sdd
mount "$lvmDisk" "$mountPoint" && df -h "$mountPoint" && md5sum -c "$md5File"

About segments

Here's a good example of what segments are :

lvdisplay -m

--- Logical volume ---
LV Path			/dev/myVolumeGroup/myLogicalVolume
LV Name			myLogicalVolume
VG Name			myVolumeGroup

LV Size			192.00 MiB
Current LE		48
Segments		2


--- Segments ---
Logical extents 0 to 23:
	Type			linear
	Physical volume		/dev/sdb
	Physical extents	0 to 23

Logical extents 24 to 47:
	Type			linear
	Physical volume		/dev/sdc
	Physical extents	0 to 23

pvs --segments

PV		VG		Fmt	Attr	PSize	PFree	Start	SSize
/dev/sdb	myVolumeGroup	lvm2	a--	96.00m	0	0	24
/dev/sdc	myVolumeGroup	lvm2	a--	96.00m	0	0	24
/dev/sdd			lvm2	---	100.00m	100.00m	0	0

lvs --segments -o +devices,seg_size_pe

LV			VG		Attr		#Str	Type	SSize	Devices		SSize
myLogicalVolume		myVolumeGroup	-wi-a-----	1	linear	96.00m	/dev/sdb(0)	24
myLogicalVolume		myVolumeGroup	-wi-a-----	1	linear	96.00m	/dev/sdc(0)	24

Logical Extent (LE) :: Each logical volume is split into chunks of data, known as logical extents. The extent size is the same for all logical volumes in the volume group.
Logical Volume (LV): The equivalent of a disk partition in a non-LVM system. The LV is visible as a standard block device; as such the LV can contain a file system (eg. /home).
Volume Group (VG): The Volume Group is the highest level abstraction used within the LVM. It gathers together a collection of logical volumes and physical volumes into one administrative unit.
Physical Extent (PE) :: Each physical volume is divided chunks of data, known as physical extents, these extents have the same size as the logical extents for the volume group.
Physical Volume (PV): A physical volume is typically a hard disk, though it may well just be a device that 'looks' like a hard disk (eg. a software raid device).
Extent: A contiguous area of storage reserved for a file in a file system, represented as a range. A file can consist of zero or more extents; one file fragment requires one extent. The direct benefit is in storing each range compactly as two numbers, instead of canonically storing every block number in the range. Also, extent allocation results in less file fragmentation.
Segment: Contiguous allocation of space on a physical volume, i.e. uninterrupted sequence of physical extents (source : man pvs + search --segments)

How things stack up :

Stack level	What's there ?	Example value	To get information on this (and learn about what's right below)	Sample output
top	file system	/var/lib/mysql	mount \| grep /var/lib/mysql	/dev/mapper/vg1-mysql on /var/lib/mysql type ext4 (rw,noatime,user_xattr,barrier=1,data=ordered)
...	logical volume	/dev/mapper/vg1-mysql	lvs /dev/mapper/vg1-mysql	LV VG Attr LSize Pool Origin Data% Move Log Copy% Convert mysql vg1 -wi-ao-- 25,00g
...	logical volume	/dev/mapper/vg1-mysql	lvdisplay /dev/mapper/vg1-mysql	--- Logical volume --- LV Path /dev/vg1/mysql LV Name mysql VG Name vg1 LV UUID 5wJtup-Nedb-cMIM-Xi6N-V4Vf-6Nc0-hJfLfB LV Write Access read/write LV Creation host, time myServer, 2015-11-05 11:29:48 +0100 LV Status available # open 1 LV Size 25,00 GiB Current LE 6399 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 254:2
...	volume group	vg1	pvs \| grep -E 'PV\|vg1'	PV VG Fmt Attr PSize PFree /dev/sdb vg1 lvm2 a-- 25,00g 0 A volume group is usually made of several distinct physical volumes : PV VG Fmt Attr PSize PFree /dev/sda3 caramba-vg lvm2 a-- 40.00g 19.17g /dev/sda5 caramba-vg lvm2 a-- 39.76g 0
...	volume group	vg1	pvdisplay \| grep -B2 -A7 vg1	--- Physical volume --- PV Name /dev/sdb VG Name vg1 PV Size 25,00 GiB / not usable 4,00 MiB Allocatable yes (but full) PE Size 4,00 MiB Total PE 6399 Free PE 0 Allocated PE 6399 PV UUID 60OAZ0-XRcm-YF5k-2EA2-4V5W-6wMI-WclhqN
...	physical volume	/dev/sdb		This is a special case since we're using the full disk as a physical volume (details). This could also be a partition : /dev/sdbx
bottom	hardware storage unit (hard drive)
Stack level	What's there ?	Example value	To get information on this (and learn about what's right below)	Sample output

A one-liner to sort this out :

spaceSeparatedListOfMountPoints='/home /tmp /var'; for mountPoint in $spaceSeparatedListOfMountPoints; do echo -e "\nMount point :\t\t$mountPoint"; logicalVolume=$(mount | grep "$mountPoint " | cut -d' ' -f1); echo -e "Logical volume :\t$logicalVolume"; volumeGroup=$(lvs --noheadings "$logicalVolume" | awk '{print $2}'); echo -e "Volume group :\t\t$volumeGroup"; physicalVolumes=$(pvs | awk '/'$volumeGroup'/ {print $1}' | xargs); echo -e "Physical volume(s) :\t$physicalVolumes"; echo -e "\tPV\t\tSize\tFree"; for volume in $physicalVolumes; do pvs --noheadings "$volume" | awk '{print "\t"$1"\t"$5"\t"$6}'; done; done

Mount point :		/home
Logical volume :	/dev/mapper/caramba--vg-home
Volume group :		caramba-vg
Physical volume(s) :	/dev/sda3 /dev/sda5
	PV		Size	Free
	/dev/sda3	40.00g	19.17g
	/dev/sda5	39.76g	0

Mount point :		/tmp
Logical volume :	/dev/mapper/caramba--vg-tmp
Volume group :		caramba-vg
Physical volume(s) :	/dev/sda3 /dev/sda5
	PV		Size	Free
	/dev/sda3	40.00g	19.17g
	/dev/sda5	39.76g	0

Mount point :		/var
Logical volume :	/dev/mapper/caramba--vg-var
Volume group :		caramba-vg
Physical volume(s) :	/dev/sda3 /dev/sda5
	PV		Size	Free
	/dev/sda3	40.00g	19.17g
	/dev/sda5	39.76g	0

lsblk gives a pretty good overview too :

NAME                   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda                      8:0    0    80G  0 disk
├─sda1                   8:1    0   243M  0 part /boot
├─sda2                   8:2    0     1K  0 part
├─sda3                   8:3    0    40G  0 part
│ ├─caramba--vg-root   254:0    0    20G  0 lvm  /
│ └─caramba--vg-var    254:1    0    12G  0 lvm  /var		
└─sda5                   8:5    0  39.8G  0 part
  ├─caramba--vg-root   254:0    0    20G  0 lvm  /
  ├─caramba--vg-var    254:1    0    12G  0 lvm  /var		
  ├─caramba--vg-swap_1 254:2    0   3.8G  0 lvm  [SWAP]
  ├─caramba--vg-tmp    254:3    0   380M  0 lvm  /tmp
  └─caramba--vg-home   254:4    0  24.4G  0 lvm  /home
sdb                      8:16   0 596.2G  0 disk
└─sdb1                   8:17   0 596.2G  0 part /media/usb
sr0                     11:0    1  1024M  0 rom

LVM - Logical Volume Management

How to setup LVM with striping ?

thin pool, thin volume

How to detect whether a logical volume is a "regular" or a "thin" one ?

How to add a disk (a physical volume) into an existing volume group + logical volume ?

How to setup a LVM architecture ?

How to reduce a logical volume ?

Preliminary steps :

Honey, I shrunk my /home :

How to display used devices/free space when using LVM ?

How to remove a disk from a logical volume ?

The idea

Let's free 1 disk

Let's make /dev/sdc free

Final test : what if filesystems were created with 4KB blocks ?

About segments

LVM glossary

How things stack up :

A one-liner to sort this out :