RED HAT ENTERPRISE LINUX

Mounting File Systems

Accessing Removable Media and Storage Devices

College-Level Course Module | RHEL System Administration

Welcome to this essential module on mounting file systems in Linux. Unlike Windows, where drives automatically appear as letters like D: or E:, Linux requires you to explicitly mount storage devices before accessing their contents. This process connects a device's file system to a specific location in the directory tree, called a mount point. Understanding mounting is fundamental for system administration. You will work with USB drives, external hard drives, network storage, ISO images, and internal partitions. All of these require mounting to access. In this module, you will learn how Linux identifies storage devices, how to mount and unmount file systems manually, how to make mounts persistent across reboots, and how to work with various types of removable media. These skills are essential for data management, backups, and system maintenance.

Learning Objectives

Identify storage devices

Understand device naming and how to find attached devices

Understand file systems

Common file system types and their characteristics

Mount file systems manually

Use the mount command to access storage devices

Unmount file systems safely

Properly disconnect devices to prevent data loss

Configure persistent mounts

Use /etc/fstab for automatic mounting at boot

We have five main learning objectives. First, you will learn to identify storage devices - understanding Linux device naming conventions and how to discover what storage is attached to your system. Second, you will understand file systems - the different formats used to organize data on storage devices and when to use each. Third, you will mount file systems manually using the mount command, making storage accessible at specific locations in the directory tree. Fourth, you will unmount file systems safely - this is critical to prevent data loss and corruption when removing devices. Fifth, you will configure persistent mounts using /etc/fstab so file systems mount automatically at boot time. These skills apply whether you are working with USB drives, external hard disks, network storage, or internal partitions.

The Mounting Concept

Mounting is the process of making a file system accessible by attaching it to an existing directory (mount point) in the file-system hierarchy.

Storage Device
/dev/sdb1

→

mount

→

Mount Point
/mnt/usb

/ (root)
├── home
├── var
├── etc
└── mnt
    └── usb ← /dev/sdb1 mounted here
        ├── documents/
        └── photos/

Key concept: After mounting, files on the device appear under the mount point directory as if they were always part of the file system.

The mounting concept is fundamental to Linux storage management. Unlike Windows where each drive gets a letter, Linux has a single unified directory tree starting at root (/). Storage devices do not automatically appear in this tree - you must mount them. When you mount a device, you attach its file system to an existing directory called the mount point. After mounting, the contents of the device appear under that directory. In the example, /dev/sdb1 (a USB drive partition) is mounted at /mnt/usb. After mounting, you access the USB drive's contents by going to /mnt/usb. Files like /mnt/usb/documents are actually stored on the USB drive, not the main system disk. The mount point directory must exist before mounting. Any files that existed in that directory before mounting become temporarily hidden - they reappear when you unmount. Common mount point locations include /mnt for temporary mounts, /media for removable media, and custom directories for specific purposes.

Device Naming

Linux represents storage devices as files in /dev. Understanding device naming helps you identify the correct device to mount.

Device Type	Naming Pattern	Example
SATA/SAS/USB drives	/dev/sdX	/dev/sda, /dev/sdb, /dev/sdc
NVMe drives	/dev/nvmeXnY	/dev/nvme0n1, /dev/nvme1n1
Virtual drives (VMs)	/dev/vdX	/dev/vda, /dev/vdb
Partitions (SATA)	/dev/sdXN	/dev/sda1, /dev/sda2, /dev/sdb1
Partitions (NVMe)	/dev/nvmeXnYpN	/dev/nvme0n1p1, /dev/nvme0n1p2
CD/DVD drives	/dev/srN	/dev/sr0, /dev/cdrom

# List block devices (storage)
[root@host ~]# lsblk
NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
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    99G  0 lvm  /
sdb           8:16   1    32G  0 disk 
└─sdb1        8:17   1    32G  0 part

Linux represents all storage devices as special files in the /dev directory. Understanding the naming convention helps you identify devices correctly. SATA, SAS, and USB drives use /dev/sd followed by a letter - sda, sdb, sdc for the first, second, third drives. Letters are assigned in the order devices are detected, which can vary between boots. NVMe drives (solid-state drives connected via PCIe) use a different pattern: /dev/nvme0n1 for the first NVMe drive's first namespace. Virtual drives in VMs often use /dev/vd naming. Partitions add a number suffix. /dev/sda1 is the first partition on the first SATA drive. /dev/sda2 is the second partition. NVMe partitions add p before the number: /dev/nvme0n1p1. The lsblk command lists block devices in a tree format, showing drives, their partitions, and where they are mounted. This is your go-to command for understanding system storage. The RM column indicates removable media.

Finding Attached Devices

# List all block devices with details
[root@host ~]# lsblk -f
NAME        FSTYPE      LABEL    UUID                                 MOUNTPOINT
sda                                                                    
├─sda1      xfs                  a1b2c3d4-...                          /boot
└─sda2      LVM2_member          e5f6g7h8-...                          
sdb                                                                    
└─sdb1      vfat        USBDISK  1234-ABCD                             

# View disk information
[root@host ~]# fdisk -l /dev/sdb
Disk /dev/sdb: 32 GiB, 34359738368 bytes
Device     Boot Start      End  Sectors Size Id Type
/dev/sdb1        2048 67108863 67106816  32G  c W95 FAT32 (LBA)

# Check USB devices specifically
[root@host ~]# lsusb
Bus 002 Device 003: ID 0781:5567 SanDisk Corp. Cruzer Blade

# Monitor for new devices (watch dmesg)
[root@host ~]# dmesg -w
# Plug in device, see messages about new device

Tip: When you plug in a USB device, run dmesg | tail to see kernel messages identifying the new device.

Several commands help identify attached devices. lsblk -f adds file system information to the block device listing. You see the file system type, volume label if set, and the UUID - a unique identifier that does not change even if device letters shift. fdisk -l shows detailed partition information including sizes and types. This helps verify you are working with the right device before mounting. lsusb lists USB devices. When you plug in a USB drive, lsusb confirms it is detected. The output includes manufacturer and model information. dmesg shows kernel messages, including hardware detection. Run dmesg -w (watch mode) and plug in a device to see real-time messages about detection. Or use dmesg | tail after plugging in to see recent messages. The kernel messages show exactly which device name was assigned, which is essential when multiple similar devices are connected.

File System Types

File systems define how data is organized on storage. Different file systems have different features, limitations, and use cases.

File System	Description	Max File Size	Use Case
XFS	Default in RHEL, high performance	8 EiB	RHEL system drives, large files
ext4	Traditional Linux filesystem	16 TiB	General Linux use, /boot
vfat (FAT32)	Windows-compatible, simple	4 GiB	USB drives, cross-platform
exFAT	Extended FAT, large file support	16 EiB	Large USB drives, SD cards
NTFS	Windows native filesystem	16 EiB	Windows drives (read/write support)
iso9660	CD/DVD filesystem	4 GiB	Optical media, ISO images

RHEL default: XFS is the default for RHEL. Use ext4 for /boot and vfat/exFAT for cross-platform USB drives.

Different file systems serve different purposes. Understanding them helps you choose correctly and troubleshoot compatibility issues. XFS is the default file system in RHEL. It offers excellent performance, especially for large files and parallel operations. It scales to enormous sizes. ext4 is the traditional Linux file system, still widely used. It is required for /boot on many systems because boot loaders understand it better. It is reliable and well-understood. vfat, also known as FAT32, provides Windows and Mac compatibility. Almost every operating system can read FAT32. However, it has a 4GB maximum file size limit - you cannot store files larger than 4GB. exFAT removes the 4GB limit while maintaining broad compatibility. Good choice for large USB drives that need to work on multiple operating systems. NTFS is Windows' native file system. Linux can read and write NTFS through the ntfs-3g driver. Useful for accessing Windows drives. iso9660 is the standard CD/DVD file system. Also used for ISO image files that you might mount for software installation.

The mount Command

mount attaches a file system to the directory tree. You specify the device and the mount point.

mount [-t fstype] [-o options] device mount_point

# Basic mount (auto-detect filesystem)
[root@host ~]# mount /dev/sdb1 /mnt/usb

# Mount with explicit filesystem type
[root@host ~]# mount -t vfat /dev/sdb1 /mnt/usb

# Mount read-only
[root@host ~]# mount -o ro /dev/sdb1 /mnt/usb

# Mount with multiple options
[root@host ~]# mount -o ro,noexec /dev/sdb1 /mnt/usb

# View currently mounted filesystems
[root@host ~]# mount | grep sdb
/dev/sdb1 on /mnt/usb type vfat (rw,relatime,fmask=0022,dmask=0022)

Prerequisite: The mount point directory must exist before mounting. Create it with mkdir if needed.

The mount command attaches file systems to directories. The basic syntax specifies the device and mount point. Linux usually auto-detects the file system type. The -t option explicitly specifies the file system type when auto-detection fails or you want to be certain. Common types include xfs, ext4, vfat, ntfs, iso9660. The -o option sets mount options. ro mounts read-only - you can read files but not modify them. noexec prevents executing programs from the mounted file system - a security measure for untrusted media. Multiple options are comma-separated. Running mount without arguments shows all currently mounted file systems. Piping through grep filters the output. The output shows device, mount point, file system type, and options. Before mounting, the mount point directory must exist. Create it with mkdir /mnt/usb or similar. The mount point can be anywhere, but /mnt and /media are conventional for temporary and removable mounts.

Mount Options

Option	Description
rw	Mount read-write (default)
ro	Mount read-only
noexec	Do not allow execution of binaries
nosuid	Ignore setuid/setgid bits
nodev	Do not interpret device files
sync	Write changes immediately (slower but safer)
async	Write changes asynchronously (faster, default)
auto	Can be mounted with mount -a
noauto	Must be mounted explicitly
user	Allow non-root users to mount
defaults	Use default options (rw, suid, dev, exec, auto, nouser, async)

# Secure mount for untrusted USB drive
[root@host ~]# mount -o ro,noexec,nosuid,nodev /dev/sdb1 /mnt/usb

# Remount with different options (without unmounting)
[root@host ~]# mount -o remount,rw /mnt/usb

Mount options control file system behavior and security. Understanding these is important for both functionality and security. rw and ro control write access. Most mounts are read-write by default. Use ro for data protection or when accessing potentially corrupted file systems. Security options are critical for untrusted media. noexec prevents running programs from the file system - even if someone puts malware on a USB drive, noexec stops it from executing. nosuid ignores setuid and setgid bits, preventing privilege escalation attacks. nodev blocks device file interpretation, another security layer. sync writes data immediately rather than caching, which is safer for removable media but slower. If power is lost, sync ensures data was written. async is faster but risks data loss on sudden removal. The defaults option applies standard options suitable for most situations. user allows non-root users to mount - useful in desktop environments. You can remount without unmounting using -o remount. This is handy for changing options on an already-mounted file system.

Mounting a USB Drive

# Step 1: Identify the USB device
[root@host ~]# lsblk
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0  100G  0 disk 
├─sda1   8:1    0    1G  0 part /boot
└─sda2   8:2    0   99G  0 part /
sdb      8:16   1   32G  0 disk       ← USB drive (RM=1 means removable)
└─sdb1   8:17   1   32G  0 part       ← Partition to mount

# Step 2: Create mount point (if it doesn't exist)
[root@host ~]# mkdir -p /mnt/usb

# Step 3: Mount the partition
[root@host ~]# mount /dev/sdb1 /mnt/usb

# Step 4: Verify mount
[root@host ~]# df -h /mnt/usb
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb1        32G  1.2G   31G   4% /mnt/usb

# Step 5: Access files
[root@host ~]# ls /mnt/usb
documents  photos  backup.tar.gz

Let me walk through the complete process of mounting a USB drive. First, identify the device. Run lsblk to see block devices. The RM column shows 1 for removable devices. In this example, sdb is the USB drive, and sdb1 is its partition. Be certain you have the right device - mounting or writing to the wrong device could destroy data. Second, create the mount point if it does not exist. mkdir -p creates the directory and any needed parents. /mnt/usb is a conventional location for temporary mounts. Third, mount the partition. Note that you mount the partition (/dev/sdb1), not the whole disk (/dev/sdb). The partition contains the file system. Fourth, verify the mount succeeded. df -h shows the mounted file system with size and usage information. You can also check with mount | grep sdb or lsblk. Fifth, access your files. cd to the mount point and use normal file commands. Everything under /mnt/usb is stored on the USB drive.

Mounting ISO Images

ISO images are file system images typically from CDs/DVDs. Mount them with the loop option to access contents without burning to disc.

# Mount an ISO file
[root@host ~]# mkdir -p /mnt/iso
[root@host ~]# mount -o loop rhel-9.3-x86_64-dvd.iso /mnt/iso

# Or with explicit options
[root@host ~]# mount -t iso9660 -o loop,ro rhel-9.3-x86_64-dvd.iso /mnt/iso

# Access ISO contents
[root@host ~]# ls /mnt/iso
AppStream  BaseOS  EFI  images  isolinux  media.repo

# Use as local repository (common use case)
[root@host ~]# cat /etc/yum.repos.d/local.repo
[local-baseos]
name=Local BaseOS
baseurl=file:///mnt/iso/BaseOS
enabled=1
gpgcheck=0

# Unmount when done
[root@host ~]# umount /mnt/iso

Loop device: The -o loop option creates a virtual block device from a file, allowing it to be mounted like physical media.

ISO images are exact copies of CD or DVD file systems stored as files. You can mount them directly without burning to physical media. The -o loop option is key. It creates a loop device - a virtual block device backed by a file rather than physical hardware. This lets the mount command treat the ISO file as if it were a block device. ISO images are always read-only since they represent read-only optical media. Adding ro explicitly is good practice but usually automatic. A common use case is creating a local package repository from a RHEL installation ISO. Mount the ISO, then configure DNF to use it as a repository source. This is useful for isolated systems without internet access. The loop option is also useful for examining disk images, mounting virtual machine disk files, and working with any file that contains a file system. When finished, unmount with umount like any other file system.

Unmounting File Systems

umount (note: not "unmount") detaches a file system from the directory tree. Always unmount before physically removing media!

# Unmount by mount point
[root@host ~]# umount /mnt/usb

# Unmount by device
[root@host ~]# umount /dev/sdb1

# If busy: find what's using it
[root@host ~]# umount /mnt/usb
umount: /mnt/usb: target is busy.

[root@host ~]# lsof /mnt/usb
COMMAND  PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
bash    1234 root  cwd    DIR   8,17     4096    2 /mnt/usb

# Solution: cd out of the directory or close the process
[root@host ~]# cd /
[root@host ~]# umount /mnt/usb

# Force unmount (use with caution - may cause data loss)
[root@host ~]# umount -f /mnt/usb

# Lazy unmount - detach now, actually unmount when not busy
[root@host ~]# umount -l /mnt/usb

Unmounting is crucial for data integrity. The command is umount - note the spelling without the 'n'. When you work with a file system, data may be cached in memory and not yet written to disk. Unmounting flushes these caches and ensures everything is safely written. Always unmount before removing physical media. You can specify either the device or the mount point - both work. Often you will get "target is busy" errors. This means something is using the file system. Use lsof to find what processes have files open or directories as their working directory. In the example, a bash shell has /mnt/usb as its current directory. Simply changing to another directory (cd /) releases the mount point. Force unmount with -f can cause data loss if processes were writing. Use only when necessary and accept that data might be lost. Lazy unmount with -l detaches the file system from the tree immediately but waits until it is no longer busy to fully unmount. Safer than -f but the mount lingers until truly free.

Safe Media Removal

Removing media without unmounting can cause data loss and file system corruption. Always follow the safe removal procedure.

# Safe removal procedure:

# 1. Ensure no processes are using the mount
[root@host ~]# cd /
[root@host ~]# lsof /mnt/usb

# 2. Sync to force write cached data
[root@host ~]# sync

# 3. Unmount the file system
[root@host ~]# umount /mnt/usb

# 4. Verify unmount
[root@host ~]# mount | grep usb
# (no output = successfully unmounted)

# 5. Now safe to physically remove the device

# For extra safety with USB drives
[root@host ~]# udisksctl power-off -b /dev/sdb
# Spins down drive before removal

Remember: sync → umount → verify → remove. Following this order protects your data.

Safe media removal prevents data loss and file system corruption. Linux caches writes for performance, so data you think is saved might still be in memory. The procedure is straightforward but critical. First, ensure nothing is using the mount. Change your working directory away from the mount point. Check with lsof. Second, run sync to force all cached writes to disk. This ensures pending data reaches the media. Third, unmount with umount. This flushes remaining buffers and updates file system metadata. Fourth, verify the unmount completed. Check with mount or lsblk that the device no longer shows a mount point. Fifth, physically remove the device. It is now safe. The udisksctl power-off command goes further by telling USB drives to spin down and power off. This is the equivalent of "safely remove hardware" in Windows. Skipping these steps risks losing recent changes or corrupting the entire file system, potentially making all data unreadable.

Understanding /etc/fstab

/etc/fstab (file system table) defines file systems to mount automatically at boot. Each line specifies a device and how to mount it.

[root@host ~]# cat /etc/fstab
# device                                  mount point  type  options        dump fsck
UUID=a1b2c3d4-5678-90ab-cdef-1234567890ab /            xfs   defaults       0    0
UUID=12345678-90ab-cdef-1234-567890abcdef /boot        ext4  defaults       0    0
/dev/mapper/rhel-swap                     none         swap  defaults       0    0

Field	Description	Example
1. Device	Device name, UUID, or LABEL	UUID=..., /dev/sdb1, LABEL=DATA
2. Mount Point	Where to mount	/, /boot, /mnt/data
3. Type	File system type	xfs, ext4, vfat, swap
4. Options	Mount options	defaults, ro, noexec
5. Dump	Backup flag (usually 0)	0 or 1
6. Fsck	Check order at boot	0, 1, or 2

/etc/fstab is one of the most important system configuration files. It defines what file systems are mounted at boot and how. Each line has six space-separated fields. The device field specifies what to mount. Using UUID is preferred because it does not change even if device letters shift. LABEL uses volume labels. Device paths like /dev/sdb1 work but can change between boots. The mount point is where the file system attaches. Root uses /, boot partition uses /boot, and so on. Custom mount points must exist as directories. The type specifies the file system format. The kernel needs to know how to interpret the data. Options set mount parameters - defaults is common, but you might add noexec, nosuid, or other restrictions. The dump field indicates whether the dump backup utility should back up this file system. Usually 0 for no. The fsck field sets the order for file system checks at boot. Root should be 1, other file systems 2, and file systems that should not be checked get 0.

Using UUIDs

UUIDs (Universally Unique Identifiers) uniquely identify file systems. They do not change when device order changes, making them more reliable than device names.

# Find UUID of a device
[root@host ~]# blkid /dev/sdb1
/dev/sdb1: LABEL="USBDATA" UUID="1234-ABCD" TYPE="vfat"

# List all UUIDs
[root@host ~]# blkid
/dev/sda1: UUID="a1b2c3d4-..." TYPE="xfs"
/dev/sda2: UUID="e5f6g7h8-..." TYPE="LVM2_member"
/dev/sdb1: UUID="1234-ABCD" TYPE="vfat" LABEL="USBDATA"

# lsblk also shows UUIDs
[root@host ~]# lsblk -f

# Using UUID in fstab
UUID=1234-ABCD  /mnt/usb  vfat  defaults  0  0

# Using LABEL in fstab
LABEL=USBDATA  /mnt/usb  vfat  defaults  0  0

Best practice: Use UUID= or LABEL= in /etc/fstab instead of device names like /dev/sdb1. This prevents boot issues when device order changes.

UUIDs solve an important problem. Device names like /dev/sdb can change between boots. If you add or remove hardware, what was sdb might become sdc. If fstab refers to /dev/sdb1 and it becomes /dev/sdc1, the system fails to mount correctly. UUIDs are generated when a file system is created and do not change. The same file system always has the same UUID regardless of how it is connected. The blkid command shows UUIDs for block devices. You can query a specific device or list all. The output includes UUID, file system type, and label if set. In fstab, use UUID=followed by the UUID string. Note the format - no quotes, no spaces around the equals sign. For FAT file systems, UUIDs are short like 1234-ABCD. For ext4 and xfs, they are longer standard UUID format. Labels are another option - LABEL=followed by the label. Labels are human-readable but must be unique. You set labels when creating or with tools like e2label or xfs_admin. Either UUID or LABEL is better than device names for persistent configuration.

Adding Persistent Mounts

# Step 1: Get the UUID
[root@host ~]# blkid /dev/sdb1
/dev/sdb1: UUID="1234-ABCD" TYPE="vfat" LABEL="BACKUP"

# Step 2: Create mount point
[root@host ~]# mkdir -p /mnt/backup

# Step 3: Add entry to /etc/fstab
[root@host ~]# vim /etc/fstab
# Add this line:
UUID=1234-ABCD  /mnt/backup  vfat  defaults,noexec  0  0

# Step 4: Test the fstab entry (IMPORTANT!)
[root@host ~]# mount -a
# Mounts all fstab entries not yet mounted

# Step 5: Verify
[root@host ~]# mount | grep backup
/dev/sdb1 on /mnt/backup type vfat (rw,noexec,relatime)

# The filesystem will now mount automatically at boot

Critical: Always test with mount -a before rebooting! Errors in fstab can prevent system boot.

Adding persistent mounts requires care - mistakes can prevent boot. Follow this process systematically. First, get the UUID with blkid. Copy it exactly - a typo means the mount fails. Second, create the mount point directory. It must exist or mounting fails. Third, edit /etc/fstab and add a new line. Use the UUID format. Specify the mount point, file system type, and appropriate options. Set dump and fsck to 0 for removable media. Fourth - and this is critical - test with mount -a. This command mounts everything in fstab that is not already mounted. If there is an error in your new entry, you see it now rather than at boot. If mount -a fails, fix the fstab entry before rebooting. A bad fstab entry can drop you into emergency mode at boot, requiring manual intervention. Fifth, verify the mount worked with mount or df. If everything looks good, the entry will work at next boot. For removable media, consider using the noauto option so it does not fail at boot if disconnected.

Options for Removable Media

# Removable media: use noauto and user options
UUID=1234-ABCD  /mnt/usb  vfat  noauto,user,noexec  0  0

# noauto: Don't mount at boot (device might not be present)
# user: Allow regular users to mount/unmount

# Regular user can now mount
[user@host ~]$ mount /mnt/usb
[user@host ~]$ umount /mnt/usb

# For network file systems (nfs): use _netdev
server:/export  /mnt/nfs  nfs  _netdev,defaults  0  0
# _netdev: Wait for network before mounting

# For SSDs: add discard for TRIM support
UUID=xxxx  /data  xfs  defaults,discard  0  0

# For data integrity: add sync (slower but safer)
UUID=xxxx  /mnt/usb  vfat  sync,noauto,user  0  0

Key options for removable media: noauto (no boot mount), user (users can mount), noexec (security), sync (immediate writes).

Removable media needs special fstab options. noauto prevents mounting at boot. Without this, if the USB drive is not connected at boot, the system may fail to start or delay significantly. With noauto, the fstab entry still simplifies mounting - users only need to type the mount point, not the full command. user allows non-root users to mount and unmount. They can only mount file systems listed in fstab with this option. This is useful on workstations where users need to access USB drives. For network file systems, _netdev tells systemd to wait for network availability before mounting. Without it, NFS mounts fail because the network is not ready yet. For SSDs, discard enables TRIM commands, which maintain SSD performance and longevity by informing the drive which blocks are no longer in use. sync writes data immediately rather than caching. This is slower but safer for removable media that might be removed unexpectedly. It reduces the chance of data loss if someone removes a drive without unmounting.

Systemd Mount Units

systemd can also manage mounts using .mount unit files. These are automatically generated from fstab but can also be created manually.

# View mount units
[root@host ~]# systemctl list-units --type=mount
UNIT                  LOAD   ACTIVE SUB     DESCRIPTION
-.mount               loaded active mounted Root Mount
boot.mount            loaded active mounted /boot
mnt-usb.mount         loaded active mounted /mnt/usb

# Check status of specific mount
[root@host ~]# systemctl status mnt-usb.mount

# Mount/unmount using systemctl
[root@host ~]# systemctl start mnt-usb.mount
[root@host ~]# systemctl stop mnt-usb.mount

# Example manual mount unit: /etc/systemd/system/mnt-data.mount
[Unit]
Description=Data Drive Mount

[Mount]
What=/dev/disk/by-uuid/1234-ABCD
Where=/mnt/data
Type=vfat
Options=defaults,noexec

[Install]
WantedBy=multi-user.target

systemd integrates with the mounting system through mount units. When the system boots, systemd reads fstab and generates corresponding mount units automatically. You can interact with these using systemctl. systemctl list-units --type=mount shows all mount units and their status. The unit names are derived from the mount point path - /mnt/usb becomes mnt-usb.mount. Dashes in paths become dashes, slashes become dashes. systemctl status shows detailed information about a mount including when it was mounted and any issues. You can use systemctl start and stop to mount and unmount. This is equivalent to mount and umount commands but integrates with systemd's dependency system. For advanced use cases, you can create manual mount units in /etc/systemd/system/. The unit file has sections for description, what to mount, where, and options. This approach offers more control over dependencies and ordering than fstab alone. Most administrators use fstab for simplicity, but mount units are useful for complex scenarios.

Viewing Mount Information

# View all mounted filesystems
[root@host ~]# mount
/dev/sda2 on / type xfs (rw,relatime,seclabel,attr2)
/dev/sda1 on /boot type ext4 (rw,relatime,seclabel)
/dev/sdb1 on /mnt/usb type vfat (rw,relatime,fmask=0022)

# View with disk space usage
[root@host ~]# df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda2        99G   15G   84G  15% /
/dev/sda1       1.0G  200M  800M  20% /boot
/dev/sdb1        32G  1.2G   31G   4% /mnt/usb

# View specific filesystem types only
[root@host ~]# df -h -t xfs

# View filesystem type
[root@host ~]# df -T
Filesystem     Type  1K-blocks    Used Available Use% Mounted on
/dev/sda2      xfs   103080448 15728640  87351808  16% /

# findmnt - modern mount listing
[root@host ~]# findmnt
[root@host ~]# findmnt /mnt/usb
[root@host ~]# findmnt -t vfat

Several commands provide mount information from different perspectives. mount without arguments lists all mounted file systems with their options. The output includes device, mount point, file system type, and mount options in parentheses. df (disk free) shows space usage for mounted file systems. The -h flag makes sizes human-readable. You see total size, used space, available space, and usage percentage. This is how you check if a file system is running out of space. df -T adds the file system type column. df -t filters to show only specific types - useful when you have many mounts and want to see just xfs or just nfs file systems. findmnt is a more modern command that shows mounts in a tree format, reflecting the hierarchy of the file system. You can filter by mount point, device, or type. findmnt also reads fstab and can compare what should be mounted versus what actually is. These commands together give you complete visibility into your system's mounted file systems.

Troubleshooting Mounts

# Problem: "mount: wrong fs type, bad option, bad superblock"
# Solution: Check filesystem type and install drivers
[root@host ~]# blkid /dev/sdb1     # Check actual type
[root@host ~]# dnf install ntfs-3g # Install NTFS support if needed

# Problem: "mount: /mnt/usb: mount point does not exist"
# Solution: Create the directory
[root@host ~]# mkdir -p /mnt/usb

# Problem: "target is busy"
# Solution: Find and close what's using it
[root@host ~]# lsof /mnt/usb
[root@host ~]# fuser -mv /mnt/usb

# Problem: "only root can mount"
# Solution: Add user option to fstab, or use udisksctl
[user@host ~]$ udisksctl mount -b /dev/sdb1

# Problem: Boot fails due to fstab error
# Solution: Boot to emergency mode, fix fstab
# Add nofail option to non-critical mounts to prevent boot failure
UUID=xxxx  /mnt/data  xfs  defaults,nofail  0  0

Let me cover common mount problems and solutions. Wrong fs type errors usually mean you specified the wrong type or the kernel does not support that file system. Use blkid to check the actual type. For NTFS, install the ntfs-3g package. The mount point must exist - create it with mkdir if missing. Target is busy means processes have files open or directories as their current working directory. lsof shows what processes and files. fuser -mv gives similar information. Either close those processes or change directories. Permission denied for regular users means the file system is not configured for user mounting. Either add user option in fstab, or use udisksctl which handles permissions through polkit. If boot fails due to fstab errors, you will get an emergency shell. Mount root read-write and fix fstab. To prevent non-critical mounts from breaking boot, add the nofail option - the system will continue booting even if that mount fails.

Best Practices

Do

Use UUID or LABEL in fstab
Always unmount before removing media
Test fstab changes with mount -a
Use noauto for removable media
Apply security options (noexec, nosuid)
Add nofail for non-critical mounts
Verify with df or mount after mounting
Document custom mount configurations

Do Not

Use device names in fstab (can change)
Remove media without unmounting
Reboot without testing fstab
Force unmount without cause
Mount untrusted media with exec
Ignore "target is busy" errors
Skip backup before fstab changes
Assume mount succeeded without checking

Golden rule: Always unmount before physical removal, always test fstab before reboot.

Let me summarize best practices for mounting. Use UUID or LABEL in fstab instead of device names - device names can change between boots, causing mount failures. Always unmount before physically removing media - this prevents data loss and corruption from unflushed caches. Test fstab changes with mount -a before rebooting - an error in fstab can prevent boot, and testing catches problems early. Use noauto for removable media so boot does not fail if the device is absent. Apply security options like noexec and nosuid for untrusted media - this prevents running malicious code from USB drives. Add nofail for non-essential mounts so a failure does not break boot. Verify mounts succeeded - do not assume, check with df or mount. Do not use device names like /dev/sdb1 in fstab. Do not yank out USB drives without unmounting. Never reboot after fstab changes without testing. Do not force unmount unless you understand the data loss risk. Mount untrusted media read-only with noexec for safety.

Key Takeaways

Devices: Storage appears as /dev/sdX, /dev/nvmeXnY. Use lsblk and blkid to identify devices and UUIDs.

Mount: mount device mountpoint attaches file systems. Create mount point first. Use options for security and behavior.

Unmount: umount before removing media. Check for busy processes with lsof. Never skip this step!

Persistence: Use /etc/fstab with UUID for automatic mounts. Test with mount -a before rebooting.

LAB EXERCISES

Identify attached storage devices with lsblk and blkid
Mount a USB drive manually to /mnt/usb
Create files, sync, and safely unmount the drive
Mount an ISO image using the loop option
Add a persistent mount to /etc/fstab using UUID
Test the fstab entry with mount -a

Next: Monitoring and Managing Linux Processes

Let me summarize the key points about mounting file systems. Devices are represented in /dev with naming that indicates device type - sd for SATA/USB, nvme for NVMe SSDs. Use lsblk to see devices and their mount status, blkid to find UUIDs and file system types. Mounting attaches a file system to a directory in the hierarchy. The basic command is mount device mountpoint. The mount point directory must exist. Use options like ro, noexec, and nosuid for security and behavior control. Unmounting with umount is essential before removing media. Linux caches writes, so removing without unmounting risks data loss. Check for busy processes with lsof if unmount fails. Never skip the unmount step. For persistent mounts that survive reboot, add entries to /etc/fstab. Use UUID instead of device names for reliability. Always test with mount -a before rebooting - fstab errors can prevent boot. Your lab exercises provide hands-on practice with the complete mounting workflow. These skills are essential for working with removable media, external storage, and managing file systems in production environments.