Chapter 2, “Linux Fundamentals,” covers Linux basics, and by now, you should be familiar with the Linux environment and feel comfortable performing general system maintenance tasks. This chapter takes you a step further in your Linux journey and covers storage, security, and networking.
Linux Storage
Many network engineers struggle with concepts such as what mounting a volume means and the relationship between physical and logical volumes. This section covers everything you need to know about storage to effectively manage a Linux-based environment, whether it is your development environment or the underlying Linux system on which a network operating system is based, such as IOS XR and NX-OS.
Physical Storage
The /dev directory contains device files, which are special files used to access the hardware on a system. A program trying to access a device uses a device file as an interface to the device driver of that device. Writing data to a device file is the same as sending data to the device represented by that device file, and reading data from a device file is the same as receiving data from that device. For example, writing data to the printer device file prints this data, and reading data from the device file of a hard disk partition is the same as reading data from that partition on the disk.
Example 3-1 shows the output of the ls -l command for the /dev directory. Notice that, unlike other directories, the first bit of the file permissions is one of five characters:
- for regular files
d for directories
l for links
c for character device files
b for block device files
You learned about the first three of these bits in Chapter 2, and the other two are covered here.
Example 3-1 Contents of the /dev Directory
[netdev@server1 dev]$ ls -l total 0 -rw-r--r--. 1 root root 0 Aug 10 00:28 any_regular_file crw-r--r--. 1 root root 10, 235 Aug 10 00:19 autofs drwxr-xr-x. 2 root root 140 Aug 10 00:18 block drwxr-xr-x. 2 root root 60 Aug 10 00:18 bsg drwxr-xr-x. 3 root root 60 Aug 10 00:19 bus drwxr-xr-x. 2 root root 2940 Aug 10 00:20 char drwxr-xr-x. 2 root root 80 Aug 10 00:18 cl crw-------. 1 root root 5, 1 Aug 10 00:20 console lrwxrwxrwx. 1 root root 11 Aug 10 00:18 core -> /proc/kcore drwxr-xr-x. 6 root root 120 Aug 10 00:19 cpu crw-------. 1 root root 10, 62 Aug 10 00:19 cpu_dma_latency drwxr-xr-x. 6 root root 120 Aug 10 00:18 disk brw-rw----. 1 root disk 253, 0 Aug 10 00:19 dm-0 brw-rw----. 1 root disk 253, 1 Aug 10 00:19 dm-1 --------- OUTPUT TRUNCATED FOR BREVITY ---------
Character device files provide unbuffered access to hardware. This means that what is written to the file is transmitted to the hardware device right away, byte by byte. The same applies to read operations. Think of data sent to the device file of an audio output device or data read from the device file representing your keyboard. This data should not be buffered.
On the other hand, block device files provide buffered access; that is, data written to a device file is buffered by the kernel before it is passed on to the hardware device. The same applies to read operations. Think of data written to or read from a partition on your hard disk. This is typically done in data blocks, not individual bytes.
However, note that the device file type (as seen in the /dev directory) is not necessarily the same as the device type. Storage devices such as hard disks are block devices, which means that data is read from and written to the device in fixed-size blocks. Although this may sound counterintuitive, block devices may be accessed using character device files on some operating systems, such as BSD. This is not the case with Linux, where block devices are always associated with block device files. The difference between block devices and block device files is sometimes a source of confusion.
The first step in analyzing a storage and file system is getting to know the hard disks. Each hard disk and partition has a corresponding device file in the /dev directory. By listing the contents of this directory, you find the sda file for the first hard disk, and, if installed, sdb for the second hard disk, sdc for the third hard disk, and so forth. Partitions are named after the hard disk that the partition belongs to, with the partition number appended to the name. For example, the first partition on the second hard disk is named sdb1. The hard disk naming convention follows the configuration in the /lib/udev/rules.d/60-persistent-storage.rules file, and the configuration is per hard disk type (ATA, USB, SCSI, SATA, and so on). Example 3-2 lists the relevant files in the /dev directory on a CentOS 7 distro. As you can see, this system has two hard disks. The first hard disk is named sda and has two partitions–sda1 and sda2–and the second is named sdb and has three partitions–sdb1, sdb2, and sdb3.
Example 3-2 Hard Disks and Partitions in the /dev Directory
[root@localhost ~]# ls -l /dev | grep sd brw-rw----. 1 root disk 8, 0 Jun 8 04:55 sda brw-rw----. 1 root disk 8, 1 Jun 8 04:55 sda1 brw-rw----. 1 root disk 8, 2 Jun 8 04:55 sda2 brw-rw----. 1 root disk 8, 16 Jun 8 04:55 sdb brw-rw----. 1 root disk 8, 17 Jun 8 04:55 sdb1 brw-rw----. 1 root disk 8, 18 Jun 8 04:55 sdb2 brw-rw----. 1 root disk 8, 19 Jun 8 04:55 sdb3
Notice the letter b at the beginning of each line of the output in Example 3-2. This indicates a block device file. A character device file would have the letter c instead.
The command fdisk -l lists all the disks and partitions on a system, along with some useful details. Example 3-3 shows the output of this command for the same system as in Example 3-2.
Example 3-3 Using the fdisk -l Command to Get Hard Disk and Partition Details
[root@localhost ~]# fdisk -l Disk /dev/sda: 26.8 GB, 26843545600 bytes, 52428800 sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk label type: dos Disk identifier: 0x000b4fba Device Boot Start End Blocks Id System /dev/sda1 * 2048 2099199 1048576 83 Linux /dev/sda2 2099200 52428799 25164800 8e Linux LVM Disk /dev/sdb: 107.4 GB, 107374182400 bytes, 209715200 sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk label type: dos Disk identifier: 0x149c8964 Device Boot Start End Blocks Id System /dev/sdb1 2048 41945087 20971520 83 Linux /dev/sdb2 41945088 83888127 20971520 83 Linux /dev/sdb3 83888128 115345407 15728640 83 Linux Disk /dev/mapper/centos-root: 23.1 GB, 23081254912 bytes, 45080576 sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk /dev/mapper/centos-swap: 2684 MB, 2684354560 bytes, 5242880 sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes [root@localhost ~]#
In addition to physical disks /dev/sda and /dev/sdb and their respective partitions, the command output in Example 3-3 lists two other disks: /dev/mapper/centos-root and /dev/mapper/centos-swap. These are two logical volumes. (Logical volumes are discussed in detail in the next section.) Notice that there is an asterisk (*) under the title Boot for partition /dev/sda1. As you may have guessed, this indicates that this is the partition on which the boot sector resides, containing the boot loader. The boot loader is the software that will eventually load the kernel image into memory during the system boot process, as you have read in Section “The Linux Boot Process” in Chapter 2.
In addition to displaying existing partition details, fdisk can create new partitions and delete existing ones. For example, after a third hard disk, sdc, is added to the system, the fdisk utility can be used to create two partitions, sdc1 and sdc2, as shown in Example 3-4.
Example 3-4 Creating New Hard Disk Partitions by Using the fdisk Utility
! Current status of the sdc hard disk: no partitions exist
[root@localhost ~]# fdisk -l /dev/sdc
Disk /dev/sdc: 21.5 GB, 21474836480 bytes, 41943040 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
! Using fdisk to create two new partitions on sdc
[root@localhost ~]# fdisk /dev/sdc
Welcome to fdisk (util-linux 2.23.2).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
Device does not contain a recognized partition table
Building a new DOS disklabel with disk identifier 0x4cd00767.
Command (m for help): m
Command action
a toggle a bootable flag
b edit bsd disklabel
c toggle the dos compatibility flag
d delete a partition
g create a new empty GPT partition table
G create an IRIX (SGI) partition table
l list known partition types
m print this menu
n add a new partition
o create a new empty DOS partition table
p print the partition table
q quit without saving changes
s create a new empty Sun disklabel
t change a partition's system id
u change display/entry units
v verify the partition table
w write table to disk and exit
x extra functionality (experts only)
Command (m for help): n
Partition type:
p primary (0 primary, 0 extended, 4 free)
e extended
Select (default p): p
Partition number (1-4, default 1):
First sector (2048-41943039, default 2048):
Using default value 2048
Last sector, +sectors or +size{K,M,G} (2048-41943039, default 41943039): +5G
Partition 1 of type Linux and of size 5 GiB is set
Command (m for help): n
Partition type:
p primary (1 primary, 0 extended, 3 free)
e extended
Select (default p):
Using default response p
Partition number (2-4, default 2):
First sector (10487808-41943039, default 10487808):
Using default value 10487808
Last sector, +sectors or +size{K,M,G} (10487808-41943039, default 41943039):
Using default value 41943039
Partition 2 of type Linux and of size 15 GiB is set
Command (m for help): w
The partition table has been altered!
Calling ioctl() to re-read partition table.
Syncing disks.
! Status after creating the two new partitions sdc1 and sdc2
[root@localhost ~]# fdisk -l /dev/sdc
Disk /dev/sdc: 21.5 GB, 21474836480 bytes, 41943040 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk label type: dos
Disk identifier: 0x4cd00767
Device Boot Start End Blocks Id System
/dev/sdc1 2048 10487807 5242880 83 Linux
/dev/sdc2 10487808 41943039 15727616 83 Linux3
[root@localhost ~]#
The interactive dialogue of the fdisk utility is self-explanatory. After the fdisk /dev/sdc command is issued, you can enter m to see all available options. You can enter n to start the new partition dialogue. Note the different methods to specify the size of the partition. If you go with the default option (by simply pressing Enter), the command uses all the remaining space on the disk to create that particular partition.
Before a hard disk partition can be used to store data, the partition needs to be formatted; that is, a file system has to be created. (File systems are discussed in some detail in Chapter 2.) At the time of writing, the two most common file systems used on Linux are ext4 and xfs. A partition is formatted using the mkfs utility. In Example 3-5, the sdc1 partition is formatted to use the ext4 file system, and sdc2 is formatted to use the xfs file system.
Example 3-5 Creating File Systems by Using the mkfs Command
[root@localhost ~]# mkfs -t ext4 /dev/sdc1
mke2fs 1.42.9 (28-Dec-2013)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
327680 inodes, 1310720 blocks
65536 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=1342177280
40 block groups
32768 blocks per group, 32768 fragments per group
8192 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736
Allocating group tables: done
Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done
[root@localhost ~]# mkfs -t xfs /dev/sdc2
meta-data=/dev/sdc2 isize=512 agcount=4, agsize=982976 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=0, sparse=0
data = bsize=4096 blocks=3931904, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0 ftype=1
log =internal log bsize=4096 blocks=2560, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
[root@localhost ~]#
To specify a file system type, you use mkfs with the -t option. Keep in mind that the command output depends on the file system type used with the command.
The final step toward making a partition usable is to mount that partition or file system. Mounting is usually an ambiguous concept to engineers who are new to Linux. As discussed in Chapter 2, the Linux file hierarchy always starts at the root directory, represented by /, and branches down. For a file system to be accessible, it has to be mounted to a mount point–that is, attached (mounted) to the file hierarchy at a specific path in that hierarchy (mount point). The mount point is the path in the file hierarchy that the file system is attached to and through which the contents of that file system can be accessed. For example, mounting the /dev/sdc1 partition to the /Operations directory maps the content of /dev/sdc1 to, and makes it accessible through, the /Operations directory, for both read and write operations. Example 3-6 shows the /Operations directory being created and the sdc1 partition being mounted to it.
Example 3-6 Mounting /dev/sdc1 to /Operations
[root@localhost ~]# mkdir /Operations [root@localhost ~]# mount /dev/sdc1 /Operations
To display all the mounted file systems, you use the df command, as shown in Example 3-7. The option -h displays the file system sizes in human-readable format.
Example 3-7 Output of the df -h Command
[root@localhost ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/centos-root 22G 5.3G 17G 25% /
devtmpfs 3.9G 0 3.9G 0% /dev
tmpfs 3.9G 0 3.9G 0% /dev/shm
tmpfs 3.9G 9.4M 3.9G 1% /run
tmpfs 3.9G 0 3.9G 0% /sys/fs/cgroup
/dev/sda1 1014M 333M 682M 33% /boot
tmpfs 783M 32K 783M 1% /run/user/1000
/dev/sdc1 4.8G 20M 4.6G 1% /Operations
[root@localhost ~]#
Each row in the output in Example 3-7 is a separate file system. The entry /dev/mapper/centos-root is a logical volume (and is discussed in detail in the next section). The following few entries are tmpfs file systems, which are temporary file systems created in memory (not on disk) for cache-like operations due to the high speed of RAM, as compared to the low speed of hard disks. An entry exists in the list for partition /dev/sda1 that is mounted to directory /boot. Then the entry at the bottom is for /dev/sdc1 that was mounted to directory /Operations as shown in Example 3-6.
To unmount the /dev/sdc1 file system, you use the umount /dev/sdc1 command. You can also use the mount point, in which case the command is umount /Operations. Note that the command is umount, not unmount. Adding the letter n is a very common error.
The mounting done by using the mount command is not persistent. In other words, once the system is rebooted, the volumes mounted using the mount command are no longer mounted. For persistent mounting, an entry needs to be added to the /etc/fstab file. Example 3-8 shows the contents of the /etc/fstab file after the entry for /dev/sdc1 is added.
Example 3-8 Editing the /etc/fstab File for Persistent Mounting
! Adding an entry for /etc/sdc1 using the echo command [root@localhost ~]# echo "/dev/sdc1 /Operations ext4 defaults 0 0" >> /etc/fstab ! After adding an entry for /etc/sdc1 [root@localhost ~]# cat /etc/fstab # # /etc/fstab # Created by anaconda on Sat May 26 04:28:54 2018 # # Accessible filesystems, by reference, are maintained under '/dev/disk' # See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info # /dev/mapper/centos-root / xfs defaults 0 0 UUID=dfe65618-19ab-458d-b5e3-dafdb59b4e68 /boot xfs defaults 0 0 /dev/mapper/centos-swap swap swap defaults 0 0 /dev/sdc1 /Operations ext4 defaults 0 0 ! Command mount -a immediately mounts all file systems listed in fstab [root@localhost ~]# mount -a
The command mount -a immediately mounts all file systems listed in /etc/fstab.
The /etc/fstab file has one entry for each file system that is to be mounted at system boot. It is important to understand the entries in the /etc/fstab file because this is the file that defines what file systems a system will have mounted right after it boots and the options that each of these file systems will be mounted with. Each line has the following fields:
The first field can be either the file system path, the universal unique identifier (UUID), or the label. You can learn the UUID (and type) of all file systems by using the command blkid. You can show the label by using the command tune2fs -l {file_system} for ext2/3/4 file systems or xfs_admin -l {file_system} for xfs file systems. Using the file system path, which is /dev/sdc1 in this case, is pretty straightforward. However, when a system has tens of hard disks installed, it would be wiser to use the partition UUIDs. A UUID is a unique number that identifies a partition. The UUID does not change if the hard disk containing the partition is moved to another system, and hence it is universal. Using a UUID eliminates the possibility of errors in the /etc/fstab file.
The second field is the file system mount point, which is /Operations in this case.
The third field is the file system type, which is ext4 in this example.
The fourth field is the mounting options. In this example, defaults indicates that the default mounting options will be used. You can also add non-default mounting options such as acl for ACL support. You add options in a comma-separated list.
The fifth field indicates which file systems are to be backed up by the dump utility. The zero value in this case indicates that this file system will not be automatically backed up.
The sixth field is used by the fsck utility to determine whether to check the health of the file system. The fsck utility checks file systems with a nonzero value in this field, in order, starting with the file system that has the value one. A zero in this field tells the fsck utility not to check that file system.
fdisk is not the only Linux utility available to manipulate disk partitions. Two other popular utilities for disk partitioning are gdisk and parted. You can use the man pages for these utilities to explore them and use a non-production environment (ideally a virtual machine) to experiment with using them. You may run into a distro that has one of them implemented but not the other. The more utilities you are familiar with, the better.
Logical Volume Manager
Linux generally uses the concept of logical volumes to provide storage to users. Logical volumes abstract the storage that is available to a user from the actual physical disks. Logical volumes on Linux are managed by system software called Logical Volume Manager (LVM). LVM operates by grouping physical disks or disk partitions, each referred to as a physical volume (PV), such as /dev/sda or /dev/sdb2, into a volume group (VG). LVM then manages a VG as one pool of storage that is split by the LVM into one or more logical volumes (LVs). Figure 3-1 illustrates these concepts.
)
Figure 3-1 Physical Volumes, Volume Groups, and Logical Volumes
To better understand the concept of logical volumes, keep in mind the following:
The different PVs that constitute a VG do not have to be equal in size.
The different PVs that constitute a VG may be different disks, or different partitions on the same disk, or different partitions on different disks.
Two different partitions on the same disk may be members of two different VGs.
The LVs that are created from a VG do not correlate to the PVs that constitute the VG in either size or number.
Using LVs created by LVM provides several advantages over using physical storage directly. The most significant benefit is the disassociation between user data and specific physical storage volumes. From a capacity perspective, capacity can be added to and removed from a logical volume without having to repartition a physical disk to create a bigger or smaller partition, and a file system is not limited by the size of the physical disk that it resides on. From a performance perspective, data may be striped across several physical volumes (for added throughput) transparently from the user. These are just a few of the advantages.
The following steps are involved in creating a logical volume that is ready to use:
Step 1. Using the command pvcreate {physical_disk/partition}, label the physical volumes that will constitute the volume group as LVM physical volumes.
Step 2. Using the command vgcreate {vg_name} {pv1} {pv2} .. {pvN}, create the VG by using the physical volumes pv1, pv2,…pvN.
Step 3. Using the command lvcreate -n {lv_name} -L {lv_size} {vg_name}, create the logical volume named lv_name from the volume group named vg_name.
Step 4. Create the file system of choice on the new logical volume by using the mkfs command, exactly as you would on a physical partition.
Step 5. Mount the new file system by using the mount command exactly as you would mount a file system created on a physical partition.
In Example 3-9, two disks, sdb and sdc, are each divided into two partitions as follows:
sdb1: 12 GB
sdb2: 8 GB
sdc1: 15 GB
sdc2: 10 GB
Example 3-9 The Four Partitions That Will Be Used to Create a Volume Group
[root@server1 ~]# fdisk -l | grep –E sd[b,c] Disk /dev/sdc: 26.8 GB, 26843545600 bytes, 52428800 sectors /dev/sdc1 2048 31459327 15728640 83 Linux /dev/sdc2 31459328 52428799 10484736 83 Linux Disk /dev/sdb: 21.5 GB, 21474836480 bytes, 41943040 sectors /dev/sdb1 2048 25167871 12582912 83 Linux /dev/sdb2 25167872 41943039 8387584 83 Linux [root@server1 ~]#
After each of the four partitions is labeled as a PV, all four partitions are added to the VG VGNetProg, which has a total capacity of 40 GB. The volume group capacity is then used to create two logical volumes–LVNetAutom with a capacity of 10 GB and LVNetDev with a capacity of 30 GB–as shown in Example 3-10.
Example 3-10 Creating Physical Volumes, Volume Groups, and Logical Volumes
! Label the physical volumes [root@server1 ~]# pvcreate /dev/sdb1 /dev/sdb2 /dev/sdc1 /dev/sdc2 Physical volume "/dev/sdb1" successfully created. Physical volume "/dev/sdb2" successfully created. Physical volume "/dev/sdc1" successfully created. Physical volume "/dev/sdc2" successfully created. ! Create the volume group [root@server1 ~]# vgcreate VGNetProg /dev/sdb1 /dev/sdb2 /dev/sdc1 /dev/sdc2 Volume group "VGNetProg" successfully created ! Create the two logical volumes [root@server1 ~]# lvcreate -n LVNetAutom -L 10G VGNetProg Logical volume "LVNetAutom" created. [root@server1 ~]# lvcreate -n LVNetDev -L 30G VGNetProg Logical volume "LVNetDev" created. [root@server1 ~]#
Example 3-11 shows the pvdisplay command being used to display the details of the physical volumes.
Example 3-11 Displaying Physical Volume Details by Using the pvdisplay Command
[root@server1 ~]# pvdisplay /dev/sdb1 --- Physical volume --- PV Name /dev/sdb1 VG Name VGNetProg PV Size 12.00 GiB / not usable 4.00 MiB Allocatable yes PE Size 4.00 MiB Total PE 3071 Free PE 511 Allocated PE 2560 PV UUID dPYPj6-Wv1i-iX7H-3iH0-oCnE-OzkA-2LcJlx [root@server1 ~]# pvdisplay /dev/sdb2 --- Physical volume --- PV Name /dev/sdb2 VG Name VGNetProg PV Size <8.00 GiB / not usable 3.00 MiB Allocatable yes PE Size 4.00 MiB Total PE 2047 Free PE 765 Allocated PE 1282 PV UUID ftOYQo-a19G-0Gs6-01ir-i6M5-Yj1N-TRREDR [root@server1 ~]# pvdisplay /dev/sdc1 --- Physical volume --- PV Name /dev/sdc1 VG Name VGNetProg PV Size 15.00 GiB / not usable 4.00 MiB Allocatable yes (but full) PE Size 4.00 MiB Total PE 3839 Free PE 0 Allocated PE 3839 PV UUID DYW0TD-vXGl-8Ssr-BCcy-SLQQ-mkfi-rvQFVd [root@server1 ~]# pvdisplay /dev/sdc2 --- Physical volume --- PV Name /dev/sdc2 VG Name VGNetProg PV Size <10.00 GiB / not usable 3.00 MiB Allocatable yes (but full) PE Size 4.00 MiB Total PE 2559 Free PE 0 Allocated PE 2559 PV UUID n1snhx-aevL-X5ay-la43-ljlo-83uC-LIkIT7 [root@server1 ~]#
Example 3-12 shows the vgdisplay command being used to display the volume group that has been created.
Example 3-12 Displaying Volume Group Details by Using the vgdisplay Command
[root@server1 ~]# vgdisplay VGNetProg --- Volume group --- VG Name VGNetProg System ID Format lvm2 Metadata Areas 4 Metadata Sequence No 3 VG Access read/write VG Status resizable MAX LV 0 Cur LV 2 Open LV 0 Max PV 0 Cur PV 4 Act PV 4 VG Size 44.98 GiB PE Size 4.00 MiB Total PE 11516 Alloc PE / Size 10240 / 40.00 GiB Free PE / Size 1276 / 4.98 GiB VG UUID PSi3RJ-9lkc-lZFE-oCVA-RaXC-HDh5-K0VuV3 [root@server1 ~]#
Example 3-13 shows the lvdisplay command being used to display the logical volumes that have been created. A logical volume is addressed using its full path in the /dev directory, as shown in the example.
Example 3-13 Displaying Logical Volume Details by Using the lvdisplay Command
[root@server1 ~]# lvdisplay /dev/VGNetProg/LVNetAutom --- Logical volume --- LV Path /dev/VGNetProg/LVNetAutom LV Name LVNetAutom VG Name VGNetProg LV UUID Y09QdN-J8Fw-s3Nb-RB84-bBPs-1USv-tzMfAw LV Write Access read/write LV Creation host, time server1, 2018-08-05 21:57:42 +0300 LV Status available # open 0 LV Size 10.00 GiB Current LE 2560 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 8192 Block device 253:2 [root@server1 ~]# lvdisplay /dev/VGNetProg/LVNetDev --- Logical volume --- LV Path /dev/VGNetProg/LVNetDev LV Name LVNetDev VG Name VGNetProg LV UUID Z9VRTv-CUe6-uSa8-S821-jGY5-ymKh-zsKfHZ LV Write Access read/write LV Creation host, time server1, 2018-08-05 21:58:17 +0300 LV Status available # open 0 LV Size 30.00 GiB Current LE 7680 Segments 3 Allocation inherit Read ahead sectors auto - currently set to 8192 Block device 253:3 [root@server1 ~]#
Note that you can issue the pvdisplay, vgdisplay, and lvdisplay commands without any arguments to display all physical volumes, all volume groups, and all logical volumes, respectively, that are configured on the system.
To delete a physical volume, volume group, or logical volume, you use the commands pvremove, vgremove, or lvremove, respectively.
After logical volumes are created, you use the mkfs command to format the LVNetAutom LV as an ext4 file system and the LVNetDev LV as an xfs file system, as shown in Example 3-14.
Example 3-14 Creating File Systems on the new Logical Volumes by Using the mkfs Command
[root@server1 ~]# mkfs -t ext4 /dev/VGNetProg/LVNetAutom
mke2fs 1.42.9 (28-Dec-2013)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
655360 inodes, 2621440 blocks
131072 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=2151677952
80 block groups
32768 blocks per group, 32768 fragments per group
8192 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Allocating group tables: done
Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done
[root@server1 ~]# mkfs -t xfs /dev/VGNetProg/LVNetDev
meta-data=/dev/VGNetProg/LVNetDev isize=512 agcount=4, agsize=1966080 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=0, sparse=0
data = bsize=4096 blocks=7864320, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0 ftype=1
log =internal log bsize=4096 blocks=3840, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
[root@server1 ~]#
Finally, in Example 3-15, both logical volumes are mounted, which means they are usable for storing and retrieving data.
Example 3-15 Mounting Both Logical Volumes by Using the mount Command
[root@server1 ~]# mkdir /Automation [root@server1 ~]# mkdir /Development [root@server1 ~]# ls / Automation dev hd3 lib64 opt root srv usr bin Development home media proc run sys var boot etc lib mnt Programming sbin tmp [root@server1 ~]# mount /dev/VGNetProg/LVNetAutom /Automation [root@server1 ~]# mount /dev/VGNetProg/LVNetDev /Development/ [root@server1 ~]# df -h Filesystem Size Used Avail Use% Mounted on /dev/mapper/centos-root 44G 6.7G 38G 16% / devtmpfs 3.9G 0 3.9G 0% /dev tmpfs 3.9G 0 3.9G 0% /dev/shm tmpfs 3.9G 8.8M 3.9G 1% /run tmpfs 3.9G 0 3.9G 0% /sys/fs/cgroup /dev/sda1 1014M 233M 782M 23% /boot tmpfs 783M 20K 783M 1% /run/user/1001 /dev/mapper/VGNetProg-LVNetAutom 9.8G 37M 9.2G 1% /Automation /dev/mapper/VGNetProg-LVNetDev 30G 33M 30G 1% /Development [root@server1 ~]#
Of course, the mounting done in Example 3-15 is not persistent. To mount both logical volumes during system boot, two entries need to be added to the /etc/fstab file–one entry for each LV.
You may have noticed in the output of the df -h command in Example 3-15 that each LV appears as a subdirectory to the directory /dev/mapper. The device mapper is a kernel space driver that provides the generic function of creating mappings between different storage volumes. The term generic is used here because the mapper is not particularly aware of the constructs used by LVM to implement logical volumes. LVM uses the device mapper to create the mappings between a volume group and its constituent logical volumes, without the device mapper explicitly knowing that the latter is a logical volume (rather than a physical one).
The examples in this section show only the very basic functionality of LVM–that is, creating the basic building blocks for having and using logical volumes on a system. However, the real power of LVM becomes clear when you use advanced features such as increasing or decreasing the size of a logical volume, without having to delete the volume and re-create it, or the several options for high availability of logical volumes. Red Hat has a 147-page document titled “Logical Volume Manager Administration” on managing logical volumes. You can check out the document for RHEL 8 at https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/configuring_and_managing_logical_volumes/index/.