RED HAT ENTERPRISE LINUX

Storage Management

Partitions, Filesystems, and Swap from the Command Line

College-Level Course Module | RHEL System Administration

Welcome to this fundamental module on storage management in Red Hat Enterprise Linux. Storage is the foundation of any system - without properly configured storage, you can't store data, install software, or run applications. In this module, you'll learn to manage storage from the command line: identifying disks, creating partitions, building filesystems, and configuring swap space. These are core skills every system administrator needs. You'll work with tools like lsblk, fdisk, parted, and mkfs to transform raw disk space into usable storage. We'll also cover mounting filesystems and making mounts persistent across reboots using /etc/fstab. These skills are essential for the RHCSA exam and daily system administration work. By the end, you'll confidently prepare new disks for use and troubleshoot storage issues.

Learning Objectives

Identify and examine storage devices

Use lsblk, fdisk, and blkid to view disk information

Create and manage disk partitions

Use fdisk and parted to partition disks with MBR or GPT

Create and mount filesystems

Format partitions with XFS or ext4 and mount them for use

Configure swap space

Create and activate swap partitions and swap files

We have four main learning objectives. First, you'll learn to identify and examine storage devices. Before you can manage storage, you need to see what's available - disk names, sizes, existing partitions. Tools like lsblk, fdisk -l, and blkid provide this information. Second, you'll create and manage partitions using fdisk for MBR disks and parted for GPT disks. Partitioning divides a physical disk into logical sections that can be used independently. Third, you'll create filesystems and mount them. A partition is just allocated space - you need a filesystem to actually store files. You'll learn XFS (RHEL default) and ext4, then mount filesystems to make them accessible. Fourth, you'll configure swap space. Swap extends virtual memory when RAM is full. You'll create both swap partitions and swap files.

Storage Concepts

Linux storage follows a hierarchy: physical disks are divided into partitions, partitions are formatted with filesystems, and filesystems are mounted to directories.

Physical Disk

/dev/sda, /dev/nvme0n1. The raw storage device. Appears as a block device in /dev.

Partition

/dev/sda1, /dev/nvme0n1p1. A section of a disk. Has a defined start and end.

Filesystem

XFS, ext4, vfat. Organizes data into files and directories. Created with mkfs.

Mount Point

/mnt/data, /home. Directory where filesystem is attached. Makes data accessible.

The workflow: Identify disk → Create partition → Create filesystem → Mount to directory → (Optional) Add to /etc/fstab for persistence

Understanding the storage hierarchy is essential. Physical disks are the hardware - HDDs, SSDs, NVMe drives. Linux represents them as block devices in /dev. Traditional SATA/SAS drives are /dev/sda, /dev/sdb, etc. NVMe drives are /dev/nvme0n1, /dev/nvme1n1. Partitions divide a disk into sections. Each partition can be used independently - different filesystems, different purposes. Partition names append numbers: /dev/sda1, /dev/sda2 for SATA; /dev/nvme0n1p1, /dev/nvme0n1p2 for NVMe. Filesystems organize the raw partition space into something usable - files and directories with names, permissions, timestamps. Without a filesystem, a partition is just bytes with no structure. Mount points connect filesystems to the directory tree. Linux has one unified directory structure; you mount filesystems at directories to make them accessible. The standard workflow: identify available disks, create partitions, format with filesystem, mount to use. For permanent mounts, add entries to /etc/fstab.

Identifying Devices

# List block devices with lsblk
[root@server ~]# lsblk
NAME          MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sda             8:0    0   100G  0 disk 
├─sda1          8:1    0     1G  0 part /boot
└─sda2          8:2    0    99G  0 part 
  ├─rhel-root 253:0    0    50G  0 lvm  /
  └─rhel-swap 253:1    0     4G  0 lvm  [SWAP]
sdb             8:16   0    50G  0 disk 
nvme0n1       259:0    0   500G  0 disk 
└─nvme0n1p1   259:1    0   500G  0 part /data

# Show filesystems with lsblk -f
[root@server ~]# lsblk -f
NAME        FSTYPE      FSVER    LABEL UUID                                   MOUNTPOINTS
sda                                                                           
├─sda1      xfs                        a1b2c3d4-...                            /boot
└─sda2      LVM2_member LVM2 001       e5f6g7h8-...                            
sdb                                                                           

# Show all block device attributes
[root@server ~]# blkid
/dev/sda1: UUID="a1b2c3d4-..." TYPE="xfs" PARTUUID="..."
/dev/sda2: UUID="e5f6g7h8-..." TYPE="LVM2_member" PARTUUID="..."

Before managing storage, you need to see what's available. lsblk (list block devices) is your primary tool. It shows devices in a tree structure: disks, their partitions, and any logical volumes. Key columns: NAME is the device name, SIZE shows capacity, TYPE indicates disk/part/lvm, MOUNTPOINTS shows where it's mounted. In this example, sda has two partitions - sda1 for /boot and sda2 for LVM. sdb is an empty 50GB disk with no partitions - a candidate for our work. nvme0n1 is an NVMe drive with one partition mounted at /data. lsblk -f adds filesystem information: type (xfs, ext4), label, and UUID. This helps identify what's formatted and what's raw. blkid shows detailed attributes including UUIDs. UUIDs are unique identifiers that persist even if device names change. They're important for /etc/fstab entries. The key insight: sdb has no partitions and no filesystem type - it's unused and ready for partitioning.

Device Naming

Device Type	Disk Name	Partition Name	Example
SATA/SAS/USB	/dev/sdX	/dev/sdX#	/dev/sda, /dev/sda1
NVMe SSD	/dev/nvmeXnY	/dev/nvmeXnYp#	/dev/nvme0n1, /dev/nvme0n1p1
Virtual (VirtIO)	/dev/vdX	/dev/vdX#	/dev/vda, /dev/vda1
SD Card/MMC	/dev/mmcblkX	/dev/mmcblkXp#	/dev/mmcblk0, /dev/mmcblk0p1

# View detailed disk information
[root@server ~]# fdisk -l /dev/sdb
Disk /dev/sdb: 50 GiB, 53687091200 bytes, 104857600 sectors
Disk model: Virtual disk    
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x00000000

# Check if disk has partitions
[root@server ~]# cat /proc/partitions | grep sdb
   8       16   52428800 sdb

Device names can change! Use UUIDs or labels in /etc/fstab, not device names like /dev/sdb1. Device order may change on reboot.

Understanding naming conventions helps you identify devices correctly. SATA, SAS, and USB drives use /dev/sd naming. Letters indicate different disks (sda, sdb, sdc), numbers indicate partitions (sda1, sda2). NVMe drives use a different scheme: /dev/nvmeXnY where X is the controller number and Y is the namespace. Partitions add 'p' then the number: nvme0n1p1. This avoids ambiguity (is nvme0n11 partition 11 or namespace 11?). Virtual machines using VirtIO get /dev/vd names - same pattern as SATA. fdisk -l shows detailed information about a specific disk: total size, sector size, partition table type (dos = MBR, gpt = GPT), and existing partitions. Important warning: device names like /dev/sdb can change! If you add or remove disks, what was sdb might become sdc. Always use UUIDs or labels in /etc/fstab to ensure you mount the right filesystem regardless of device enumeration order.

MBR vs GPT

MBR (Master Boot Record)

Legacy standard, widely compatible
Maximum disk size: 2 TB
Maximum 4 primary partitions
Or 3 primary + 1 extended (with logical)
Use: Legacy systems, small disks
Tool: fdisk

GPT (GUID Partition Table)

Modern standard, UEFI systems
Maximum disk size: 9.4 ZB (huge)
Up to 128 partitions (default)
No extended/logical distinction
Use: Modern systems, large disks
Tool: gdisk or parted

MBR Partition Layout

MBR

Primary 1

Primary 2

Log 5

Log 6

Two partition table formats exist: MBR and GPT. Understanding both is necessary because you'll encounter both. MBR (Master Boot Record) is the legacy standard from the 1980s. It works everywhere but has significant limitations: maximum disk size of 2 TB (larger disks can't be fully used), and maximum of 4 primary partitions. The workaround for more partitions is to make one primary partition "extended" and create "logical" partitions inside it. Logical partitions are numbered starting at 5. GPT (GUID Partition Table) is the modern standard. It supports essentially unlimited disk sizes and 128 partitions by default (expandable). There's no primary/extended distinction - all partitions are equal. GPT is required for UEFI boot and disks over 2 TB. For new systems, prefer GPT unless you need legacy compatibility. For the RHCSA exam, know both: fdisk for MBR, parted or gdisk for GPT. The diagram shows MBR layout with primary partitions and an extended partition containing logical partitions.

Partitioning with fdisk

# Start fdisk on a disk
[root@server ~]# fdisk /dev/sdb

Welcome to fdisk (util-linux 2.37.4).
Command (m for help): n          # New partition
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p           # Primary partition
Partition number (1-4, default 1): 1
First sector (2048-104857599, default 2048): [Enter]  # Accept default
Last sector... (+/-sectors or +/-size{K,M,G,T,P}): +10G  # 10 GB partition

Created a new partition 1 of type 'Linux' and of size 10 GiB.

Command (m for help): p          # Print partition table
Device     Boot   Start      End  Sectors Size Id Type
/dev/sdb1          2048 20973567 20971520  10G 83 Linux

Command (m for help): w          # Write changes and exit
The partition table has been altered.
Syncing disks.

Key commands: n=new, p=print, d=delete, t=change type, w=write, q=quit without saving

fdisk is the traditional MBR partitioning tool. It's interactive - you enter commands at a prompt. Start with fdisk /dev/sdX where X is your target disk. Be careful to choose the right disk! The 'n' command creates a new partition. For MBR, you choose primary or extended. Primary is the default and what you'll usually want. Accept the default first sector to start at the beginning of free space. For the last sector, you can specify a size with +SIZE notation: +10G for 10 gigabytes, +500M for 500 megabytes. This is easier than calculating sector numbers. The 'p' command prints the current partition table so you can verify your work before writing. The 'w' command writes changes to disk. Until you press 'w', nothing is actually changed - you can quit with 'q' to abandon changes. The 'd' command deletes partitions. The 't' command changes the partition type (e.g., to swap type 82, or Linux LVM type 8e). After creating a partition, the kernel needs to be notified. Usually this happens automatically, but you might need to run 'partprobe' to update the kernel's view.

Partitioning with parted

# Start parted on a disk
[root@server ~]# parted /dev/sdb
(parted) print
Error: /dev/sdb: unrecognised disk label

# Create GPT partition table
(parted) mklabel gpt
Warning: The existing disk label on /dev/sdb will be destroyed...
(parted)

# Create a partition
(parted) mkpart primary xfs 1MiB 10GiB
(parted) mkpart primary xfs 10GiB 20GiB

# View partitions
(parted) print
Number  Start   End     Size    File system  Name     Flags
 1      1049kB  10.7GB  10.7GB               primary
 2      10.7GB  21.5GB  10.7GB               primary

(parted) quit

# One-liner (non-interactive)
[root@server ~]# parted /dev/sdb mkpart primary xfs 20GiB 30GiB

parted changes are immediate! Unlike fdisk, parted writes to disk as you go. There's no "write" command - be careful!

parted is the modern partitioning tool that supports both MBR and GPT. It's required for GPT disks and disks over 2 TB. Key difference from fdisk: parted writes changes immediately. There's no "write" step - every command takes effect instantly. Be very careful! The 'mklabel' command creates a partition table. Use 'mklabel gpt' for GPT or 'mklabel msdos' for MBR. This destroys any existing partitions! The 'mkpart' command creates partitions. Syntax: mkpart NAME TYPE START END. For GPT, NAME is a label; TYPE is the filesystem type hint (doesn't actually create the filesystem). Start and end can be specified in various units: MiB, GiB, percentages, or sector numbers. Using MiB/GiB ensures proper alignment. The 'print' command shows the current partition table. parted can also be used non-interactively by putting commands on the command line. This is useful for scripting. After partitioning, you may need to run 'udevadm settle' or 'partprobe' to ensure the kernel sees the new partitions.

Filesystem Types

XFS

RHEL Default

Excellent for large files

Good parallel I/O

Can grow, not shrink

Robust journaling

ext4

Traditional Linux

Mature, well-tested

Can grow AND shrink

Good general purpose

Better for small files

vfat

Cross-Platform

Windows compatible

USB drives, EFI

No permissions

4GB file size limit

# Check which filesystems are supported
[root@server ~]# cat /proc/filesystems | grep -v nodev
	xfs
	ext4
	ext3
	vfat
	iso9660

# View filesystem of mounted partitions
[root@server ~]# df -Th
Filesystem          Type      Size  Used Avail Use% Mounted on
/dev/mapper/rhel-root xfs       50G  4.5G   46G   9% /
/dev/sda1            xfs      1014M  186M  829M  19% /boot

Choosing the right filesystem matters. Each has strengths and tradeoffs. XFS is RHEL's default and recommendation for most workloads. It excels with large files and parallel I/O, making it great for servers. It has robust journaling for crash recovery. Key limitation: XFS can be grown but not shrunk. ext4 is the traditional Linux filesystem, evolved from ext2/ext3. It's mature, well-tested, and works well for general purpose use. Key advantage: it can both grow AND shrink, which adds flexibility. Some prefer it for root filesystems for this reason. vfat (FAT32) is for cross-platform compatibility. Use it for USB drives that need to work with Windows, or for EFI System Partitions. Major limitations: no Unix permissions, no symbolic links, 4GB maximum file size. Other filesystems exist (btrfs, exfat, ntfs) but XFS and ext4 cover most Linux server needs. The RHCSA exam focuses on XFS and ext4.

Creating Filesystems

# Create XFS filesystem (RHEL default)
[root@server ~]# mkfs.xfs /dev/sdb1
meta-data=/dev/sdb1              isize=512    agcount=4, agsize=655360 blks
         =                       sectsz=512   attr=2, projid32bit=1
data     =                       bsize=4096   blocks=2621440, imaxpct=25
naming   =version 2              bsize=4096   ascii-ci=0, ftype=1
log      =internal log           bsize=4096   blocks=2560, version=2
realtime =none                   extsz=4096   blocks=0, rtextents=0

# Create ext4 filesystem
[root@server ~]# mkfs.ext4 /dev/sdb2
Creating filesystem with 2621440 4k blocks and 655360 inodes
Superblock backups stored on blocks: ...

# Create filesystem with label
[root@server ~]# mkfs.xfs -L "data_storage" /dev/sdb1

# Force creation (overwrite existing)
[root@server ~]# mkfs.xfs -f /dev/sdb1

# Verify filesystem
[root@server ~]# blkid /dev/sdb1
/dev/sdb1: LABEL="data_storage" UUID="abc123..." TYPE="xfs"

⚠ Warning: mkfs destroys all data on the partition! Double-check the device name before running.

mkfs (make filesystem) formats a partition with a filesystem structure. This is what transforms raw disk space into something that can store files. The command is mkfs.TYPE /dev/partition. Common types: mkfs.xfs, mkfs.ext4, mkfs.vfat. The -L option sets a label, which is a human-readable name. Labels can be used in /etc/fstab and make it easier to identify filesystems. The -f option forces creation, overwriting any existing filesystem. mkfs normally refuses if it detects an existing filesystem - -f overrides this. After creation, blkid confirms the filesystem type, label, and UUID. The UUID is a unique identifier generated during creation - it's the best way to reference the filesystem. Critical warning: mkfs destroys all existing data. There's no undo. Always verify you're formatting the correct partition. A common mistake is formatting the wrong partition and losing data.

Mounting Filesystems

# Create mount point directory
[root@server ~]# mkdir /mnt/data

# Mount the filesystem
[root@server ~]# mount /dev/sdb1 /mnt/data

# Verify the mount
[root@server ~]# mount | grep sdb1
/dev/sdb1 on /mnt/data type xfs (rw,relatime,seclabel,attr2,inode64,logbufs=8)

# Check available space
[root@server ~]# df -h /mnt/data
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb1        10G   33M   10G   1% /mnt/data

# Mount using UUID (more reliable)
[root@server ~]# mount UUID="abc123-def456-..." /mnt/data

# Mount using label
[root@server ~]# mount LABEL="data_storage" /mnt/data

# Mount with specific options
[root@server ~]# mount -o ro,noexec /dev/sdb1 /mnt/data

# Unmount when done
[root@server ~]# umount /mnt/data

Mounting connects a filesystem to a directory, making its contents accessible. First, create the mount point - it's just a directory. By convention, temporary mounts go in /mnt, but you can mount anywhere. The basic mount command is mount DEVICE MOUNTPOINT. The kernel auto-detects the filesystem type. mount without arguments shows all current mounts. Use grep to find specific ones. df -h shows space usage. The -h option makes sizes human-readable. You can mount by UUID or LABEL instead of device name. This is more reliable because UUIDs/labels don't change when device enumeration changes. The -o option specifies mount options: ro (read-only), noexec (prevent execution), nosuid (ignore setuid bits), and many more. umount (note: not "unmount") disconnects the filesystem. It fails if any process is using files on the filesystem. Use 'lsof +D /mnt/data' to find processes using it. Important: manual mounts don't survive reboot. For permanent mounts, you need /etc/fstab.

Persistent Mounts: /etc/fstab

# View current fstab
[root@server ~]# cat /etc/fstab
#
# /etc/fstab - Static filesystem mount table
#
#                                            
UUID=a1b2c3d4-e5f6-7890-abcd-ef1234567890 /           xfs     defaults         0 0
UUID=b2c3d4e5-f6a7-8901-bcde-f12345678901 /boot       xfs     defaults         0 0
/dev/mapper/rhel-swap                     none        swap    defaults         0 0

# Get UUID for new partition
[root@server ~]# blkid /dev/sdb1
/dev/sdb1: UUID="f1e2d3c4-b5a6-9807-6543-210987654321" TYPE="xfs"

# Add entry to /etc/fstab
[root@server ~]# vim /etc/fstab
# Add this line:
UUID=f1e2d3c4-b5a6-9807-6543-210987654321 /mnt/data   xfs     defaults         0 0

# Test fstab entry (mount all unmounted entries)
[root@server ~]# mount -a

# Verify
[root@server ~]# df -h /mnt/data

⚠ Critical: A typo in /etc/fstab can prevent system boot! Always test with mount -a before rebooting.

The /etc/fstab file defines filesystems to mount at boot. Each line has six fields. Field 1: Device - use UUID for reliability. Field 2: Mount point - the directory where it mounts. Field 3: Filesystem type - xfs, ext4, swap, etc. Field 4: Options - defaults is usually fine; can add noexec, nosuid, etc. Field 5: Dump - backup flag, usually 0. Field 6: fsck order - filesystem check order at boot, usually 0 for non-root. To add a new persistent mount: get the UUID with blkid, edit /etc/fstab, add a line with all six fields. Always test with 'mount -a' before rebooting. This attempts to mount all fstab entries that aren't already mounted. If there's an error, you'll see it now rather than at boot time. A common mistake: typos in UUID or mount point. If fstab has errors and you reboot, the system may fail to boot or drop to emergency mode. Always test! The mount point directory must exist before mounting. Create it with mkdir if needed.

fstab Fields

UUID=abc123... /mnt/data xfs defaults 0 0

Field	Purpose	Examples
Device	What to mount	UUID=..., LABEL=..., /dev/sdb1
Mount Point	Where to mount	/mnt/data, /home, /var/log
Type	Filesystem type	xfs, ext4, swap, auto
Options	Mount options	defaults, ro, noexec, nosuid
Dump	Backup with dump	0 (don't backup), 1 (backup)
fsck	Check order at boot	0 (skip), 1 (first), 2 (after 1)

# Common mount options
defaults    = rw,suid,dev,exec,auto,nouser,async
ro          = Read-only
noexec      = Prevent execution of binaries
nosuid      = Ignore setuid/setgid bits
noatime     = Don't update access times (performance)
nofail      = Don't fail boot if device missing

# Example with options
UUID=abc123... /mnt/backup xfs defaults,noexec,nosuid,nofail 0 0

Let's examine each fstab field in detail. Device field identifies what to mount. UUID is best practice - it's unique and doesn't change. LABEL is also reliable if you set one. Device names like /dev/sdb1 can change and should be avoided. Mount point is the directory. It must exist. Commonly /mnt/something for data disks. Type is the filesystem type. Use 'auto' to let the system detect, but specifying explicitly is clearer. Options control mount behavior. 'defaults' means rw,suid,dev,exec,auto,nouser,async - reasonable for most cases. Add others as needed: noexec prevents running programs (security), nosuid ignores setuid (security), noatime improves performance by not updating access times. nofail is important for removable or optional devices - without it, the system won't boot if the device is missing. Dump field is for the dump backup utility. Usually 0 since dump isn't commonly used. fsck field determines filesystem check order at boot. Root should be 1, other local filesystems 2, remote or special filesystems 0 (skip).

Introduction to Swap

Swap is disk space used as virtual memory when physical RAM is full. The kernel moves inactive memory pages to swap, freeing RAM for active processes.

Swap Partition

A dedicated partition formatted as swap. Traditional approach. Fixed size, very fast.

Swap File

A file on a filesystem used as swap. Flexible sizing. Can be added without repartitioning.

# Check current swap status
[root@server ~]# swapon --show
NAME           TYPE      SIZE USED PRIO
/dev/dm-1      partition   4G   0B   -2

# Check memory and swap usage
[root@server ~]# free -h
              total        used        free      shared  buff/cache   available
Mem:           7.8Gi       2.1Gi       4.2Gi       128Mi       1.5Gi       5.3Gi
Swap:          4.0Gi          0B       4.0Gi

How much swap? Traditional rule: 2x RAM. Modern guidance: at least equal to RAM for hibernation, otherwise 2-8GB is often sufficient depending on workload.

Swap extends virtual memory beyond physical RAM. When the system needs more memory than available RAM, it moves less-used memory pages to swap, freeing RAM for active work. This is slower than RAM but prevents out-of-memory conditions. Two ways to create swap: partitions or files. Swap partitions are the traditional approach - a partition formatted specifically for swap. They're slightly faster and simpler for the kernel. Swap files are more flexible - you can create, resize, or remove them without repartitioning. Modern Linux handles swap files efficiently. swapon --show lists active swap areas with their type, size, and priority. Priority determines which swap area is used first (higher numbers first). free -h shows memory and swap usage. If swap is heavily used while RAM is available, you might need to tune vm.swappiness. Sizing guidance varies. Old rule was 2x RAM, but with systems having 64GB+ RAM, that's excessive. For hibernation, you need at least RAM size. For servers, 2-8GB usually suffices. The RHCSA exam tests both swap partitions and swap files.

Creating Swap Partition

# Create partition with fdisk (set type to 82 for swap)
[root@server ~]# fdisk /dev/sdb
Command (m for help): n          # New partition
Partition number: 3
First sector: [Enter]
Last sector: +2G
Command (m for help): t          # Change type
Partition number: 3
Hex code or alias: 82          # Linux swap type
Command (m for help): w          # Write and exit

# Format as swap
[root@server ~]# mkswap /dev/sdb3
Setting up swapspace version 1, size = 2 GiB (2147479552 bytes)
no label, UUID=swap-uuid-here-1234-567890abcdef

# Activate swap
[root@server ~]# swapon /dev/sdb3

# Verify
[root@server ~]# swapon --show
NAME      TYPE      SIZE USED PRIO
/dev/dm-1 partition   4G   0B   -2
/dev/sdb3 partition   2G   0B   -3

Three steps: 1) Create partition (type 82), 2) mkswap to format, 3) swapon to activate.

Creating a swap partition follows a three-step process. Step 1: Create the partition. Use fdisk (or parted for GPT). After creating the partition, use the 't' command to change its type to 82 (Linux swap). This isn't strictly required but helps tools identify the partition's purpose. Step 2: Format with mkswap. This writes swap headers to the partition, making it usable as swap. mkswap outputs the UUID - save this for /etc/fstab. Step 3: Activate with swapon. This tells the kernel to start using the swap area. swapon --show confirms it's active. To make it persistent across reboots, add to /etc/fstab. The priority (-2, -3 in the output) determines order of use. You can set priority explicitly with swapon -p PRIORITY. Higher priority swap is used first. This is useful if you have swap on both SSD and HDD - give SSD higher priority.

Persistent Swap

# Get UUID of swap partition
[root@server ~]# blkid /dev/sdb3
/dev/sdb3: UUID="swap-uuid-1234-5678-90ab-cdef12345678" TYPE="swap"

# Add to /etc/fstab
[root@server ~]# vim /etc/fstab
# Add this line:
UUID=swap-uuid-1234-5678-90ab-cdef12345678  none  swap  defaults  0  0

# Or use device name (less reliable)
/dev/sdb3  none  swap  defaults  0  0

# Test by deactivating and reactivating all swap
[root@server ~]# swapoff /dev/sdb3
[root@server ~]# swapon -a          # Activate all swap in fstab
[root@server ~]# swapon --show

# View swap entry in fstab
[root@server ~]# grep swap /etc/fstab
/dev/mapper/rhel-swap                         none  swap  defaults  0  0
UUID=swap-uuid-1234-5678-90ab-cdef12345678    none  swap  defaults  0  0

Mount point for swap: Use none or swap as the mount point. Swap isn't mounted to a directory.

Making swap persistent requires an /etc/fstab entry. The format is similar to filesystem mounts but with some differences. Device field: use UUID for reliability, same as regular mounts. Mount point: use 'none' or 'swap' - swap isn't mounted to a directory, it's used directly by the kernel. Type: 'swap'. Options: 'defaults' is fine. You can add 'pri=N' to set priority. Dump and fsck: both 0 - swap isn't backed up or checked like a filesystem. After adding to fstab, test with swapoff then swapon -a. The -a flag tells swapon to activate all swap entries in /etc/fstab. If there's an error, you'll see it now. The system may have existing swap from installation (often on LVM). Your new swap adds to the total. You can have multiple swap areas - the kernel uses them according to priority.

Creating Swap File

# Create a 1GB swap file using dd
[root@server ~]# dd if=/dev/zero of=/swapfile bs=1M count=1024 status=progress
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 2.5 s, 429 MB/s
1024+0 records in
1024+0 records out

# Or use fallocate (faster)
[root@server ~]# fallocate -l 1G /swapfile

# Set correct permissions (required!)
[root@server ~]# chmod 600 /swapfile
[root@server ~]# ls -l /swapfile
-rw------- 1 root root 1073741824 Jan 20 14:00 /swapfile

# Format as swap
[root@server ~]# mkswap /swapfile
Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes)

# Activate
[root@server ~]# swapon /swapfile

# Add to /etc/fstab for persistence
/swapfile  none  swap  defaults  0  0

# Verify
[root@server ~]# swapon --show

Permissions matter! Swap file must be 600 (owner read/write only). World-readable swap is a security risk.

Swap files offer flexibility - create, resize, or remove without repartitioning. Step 1: Create the file. Use dd to write zeros, or fallocate for faster allocation. The example creates a 1GB file. fallocate is faster but may not work on all filesystems. Step 2: Set permissions to 600. This is critical - swap may contain sensitive data from memory. Only root should read it. mkswap will warn if permissions are wrong. Step 3: Format with mkswap, same as a partition. Step 4: Activate with swapon. For persistence, add to /etc/fstab. For swap files, use the path (/swapfile) instead of UUID. The fstab entry uses 'none' for mount point and 'swap' for type. Swap files have slightly more overhead than partitions but it's negligible on modern systems. The flexibility advantage usually outweighs this. To resize: swapoff the file, resize with dd or truncate, mkswap again, swapon. To remove: swapoff, remove fstab entry, delete the file.

Managing Swap

# View all swap with details
[root@server ~]# swapon --show
NAME       TYPE       SIZE USED PRIO
/dev/dm-1  partition    4G  10M   -2
/swapfile  file         1G   0B   -3

# Set priority when activating
[root@server ~]# swapon -p 10 /swapfile

# Deactivate specific swap
[root@server ~]# swapoff /swapfile

# Deactivate all swap
[root@server ~]# swapoff -a

# Check swap usage
[root@server ~]# free -h
[root@server ~]# vmstat 1 3
procs -----------memory---------- ---swap--
 r  b   swpd   free   buff  cache   si   so
 1  0  10240 524288  65536 1048576    0    0

# Adjust swappiness (tendency to use swap)
[root@server ~]# sysctl vm.swappiness
vm.swappiness = 60
[root@server ~]# sysctl vm.swappiness=10    # Reduce swap usage

vm.swappiness: 0-100. Higher values = more aggressive swapping. Default is 60. Reduce to 10-20 for servers with plenty of RAM.

Active swap management includes monitoring, priority adjustment, and tuning. swapon --show displays all active swap areas with size, usage, and priority. Higher priority means that swap area is used first. swapon -p sets priority when activating. Useful for preferring faster storage (SSD over HDD). swapoff deactivates swap. The system must have enough free RAM to hold anything currently in that swap, or swapoff will fail. swapoff -a deactivates all swap - use carefully! Monitoring: free shows total and used swap. vmstat shows swap activity (si = swap in, so = swap out). High swap I/O while RAM is available suggests poor memory access patterns or high memory pressure. vm.swappiness controls how aggressively the kernel uses swap. Value 60 (default) means the kernel will start swapping fairly readily. Value 10 means it strongly prefers keeping data in RAM. For servers with plenty of RAM, lower values (10-20) reduce unnecessary swapping. For desktops or memory-constrained systems, default or higher is fine. To make swappiness persistent: add vm.swappiness=10 to /etc/sysctl.conf.

Complete Workflow

Identify disk: lsblk, fdisk -l to find available disk (e.g., /dev/sdb)

Create partition: fdisk /dev/sdb or parted /dev/sdb

Create filesystem: mkfs.xfs /dev/sdb1 or mkfs.ext4 /dev/sdb1

Create mount point: mkdir /mnt/data

Test mount: mount /dev/sdb1 /mnt/data

Get UUID: blkid /dev/sdb1

Add to fstab: UUID=... /mnt/data xfs defaults 0 0

Test fstab: umount /mnt/data && mount -a

Always test! Test mount before fstab. Test fstab with mount -a before reboot. Errors in fstab can prevent boot!

This workflow summarizes everything for adding a new data disk. Step 1: Identify the disk with lsblk or fdisk -l. Make absolutely sure you have the right disk - partitioning the wrong one destroys data. Step 2: Create partitions with fdisk (MBR) or parted (GPT). Plan your partition layout before starting. Step 3: Create filesystems with mkfs. XFS is RHEL default. Add labels for easier identification. Step 4: Create the mount point directory. It must exist before mounting. Step 5: Test with manual mount. Verify it works, check you can read/write files. Step 6: Get the UUID with blkid. Copy it exactly - typos cause boot failures. Step 7: Add fstab entry using UUID. Triple-check the syntax. Step 8: Test by unmounting and running mount -a. If there's any error, fix it before rebooting! The testing steps are critical. I've seen production outages from untested fstab entries. Always verify before rebooting.

Best Practices

✓ Do

Use UUID in /etc/fstab
Test mounts before adding to fstab
Test fstab with mount -a before reboot
Label filesystems for easy identification
Use GPT for new disks (especially >2TB)
Use XFS for most workloads (RHEL default)
Document your storage layout
Use nofail for non-critical mounts

✗ Don't

Use device names in fstab (/dev/sdb1)
Skip testing before reboot
Format the wrong partition
Forget to create mount point
Ignore fstab syntax errors
Use MBR for disks >2TB
Make swap world-readable
Forget backups before partitioning

Recovery tip: If system won't boot due to fstab error, boot rescue mode, mount root filesystem, fix /etc/fstab, reboot.

Following best practices prevents common disasters. Always use UUID in fstab. Device names like /dev/sdb can change when you add or remove hardware. UUIDs are permanent. Test everything before making it permanent. Manual mount first, then fstab, then mount -a, only then reboot. Each step catches different types of errors. Label filesystems with meaningful names. "data_storage" is more helpful than trying to remember which UUID is which. Use GPT for new disks unless you need legacy compatibility. GPT handles large disks and has no practical partition count limit. Use nofail option for non-essential mounts. Without it, a missing or broken device prevents boot. Common disaster: formatting the wrong partition. Always double-check with lsblk before mkfs. Another common disaster: typos in fstab UUID. Copy-paste carefully, verify with blkid. Recovery: if fstab breaks boot, use rescue/emergency mode. Mount root filesystem (often automatic), edit fstab, comment out the problematic line, reboot, fix properly.

Key Takeaways

Identify: lsblk, fdisk -l, blkid to view disks, partitions, and UUIDs.

Partition: fdisk for MBR, parted for GPT. Remember to write changes (fdisk) or they're immediate (parted).

Filesystem: mkfs.xfs or mkfs.ext4. Mount with mount command. Persist in /etc/fstab using UUID.

Swap: Partition or file. mkswap to format, swapon to activate. Add to /etc/fstab for persistence.

LAB EXERCISES

List all block devices with lsblk and lsblk -f
Create a partition on an available disk using fdisk
Create an XFS filesystem with a label
Mount the filesystem and add it to /etc/fstab
Create a 512MB swap file and activate it
Add the swap file to /etc/fstab and test with swapon -a

Next: Managing Logical Volumes

Let's summarize the key storage management skills. For identifying storage, use lsblk to see disk and partition hierarchy, lsblk -f to see filesystem types, fdisk -l for detailed disk info, and blkid for UUIDs. These tools are your first step in any storage task. For partitioning, know both fdisk (MBR, interactive, writes on 'w') and parted (GPT, immediate writes). Choose GPT for modern systems and large disks. For filesystems, use mkfs.xfs for RHEL default or mkfs.ext4 for flexibility. Mount with mount command, persist in /etc/fstab using UUIDs. Always test with mount -a before rebooting. For swap, you can use partitions or files. mkswap formats, swapon activates. Both need fstab entries for persistence. Swap files offer flexibility without repartitioning. Your lab exercises give you hands-on practice with each step. The complete workflow - identify, partition, format, mount, persist - is a fundamental skill you'll use throughout your career.