RED HAT ENTERPRISE LINUX

Mounting File Systems

Accessing Removable Media and Storage Devices

CIS126RH | RHEL System Administration 1
Mesa Community College

Learning Objectives

Identify storage devices

Understand device naming and use lsblk to list block devices

Mount file systems manually

Use mount command to attach file systems to directories

Unmount file systems safely

Use umount and understand when unmounting fails

Work with removable media

Access USB drives, optical media, and understand automatic mounting

We have four main learning objectives for this module. First, we'll learn to identify storage devices in Linux. Device names like /dev/sda or /dev/nvme0n1 might seem cryptic at first, but they follow patterns you can understand. We'll use tools like lsblk to see what storage is available. Second, we'll master the mount command to manually attach file systems to directories. This is the core skill - taking a storage device and making its contents accessible at a specific location in the directory tree. Third, we'll learn to unmount file systems safely with umount. Proper unmounting ensures data is written to the device and prevents corruption. We'll understand why unmounting sometimes fails and how to handle it. Fourth, we'll work with removable media specifically - USB drives and optical media. We'll see how modern Linux systems handle these automatically and how to work with them when automatic mounting isn't available, such as on servers.

The Mounting Concept

Mounting is the process of attaching a file system to a directory in the Linux file system hierarchy, making its contents accessible at that location.

/dev/sdb1

→ mount →

/mnt/usb

Device + Mount Point = Accessible Files

Key Concept: Linux has a single directory tree starting at /. All storage devices are accessed by mounting them somewhere in this tree - there are no drive letters like C: or D:.

The mounting concept is fundamental to understanding Linux storage. Unlike Windows where each drive gets a letter (C:, D:, E:), Linux has one unified directory tree that starts at the root, represented by a forward slash. Everything in Linux lives somewhere under this root. When you want to access a storage device - your hard drive, a USB stick, a network share - you must mount it to a directory in this tree. That directory is called the mount point. Once mounted, the device's contents appear as if they're part of the directory structure. The mount point directory must exist before you mount to it. Any files that were in that directory become hidden (not deleted) while something is mounted there. They reappear when you unmount. For example, if you mount a USB drive to /mnt/usb, the files on the USB drive appear under /mnt/usb. You navigate to them with cd /mnt/usb just like any other directory. When you're done, you unmount, and the connection is severed. This unified approach is elegant - every file on the system has exactly one path, regardless of which physical device it's on.

Device Naming

Block devices in Linux are represented as files in /dev/. The naming convention indicates the device type and sequence.

/dev/sda1

Component	Meaning	Examples
sd	SCSI/SATA/USB disk	sda, sdb, sdc
a, b, c...	Disk sequence (first, second, third)	sda = first disk
1, 2, 3...	Partition number on disk	sda1 = first partition on sda
nvme0n1	NVMe SSD (controller 0, namespace 1)	nvme0n1p1 = first partition
sr0	Optical drive (CD/DVD)	sr0 = first optical drive

Linux represents storage devices as special files in the /dev directory. Understanding the naming convention helps you identify devices. Traditional SATA and USB storage uses the "sd" prefix - historically this stood for SCSI disk, but now it's used for most block devices. The letter following sd indicates the order of detection: sda is the first disk found, sdb the second, and so on. This order can change between boots if you add or remove devices, which is why we often use UUIDs for critical mounts. The number after the letter indicates the partition. sda1 is the first partition on the first disk, sda2 is the second partition, and so on. The disk itself (sda without a number) represents the whole device. NVMe SSDs use a different naming scheme: nvme followed by controller number, n for namespace, and the namespace number. Partitions get a p prefix: nvme0n1p1 is the first partition on the first NVMe drive. Optical drives use sr for SCSI ROM: sr0 is the first CD/DVD drive. Virtual devices have other names: loop devices for mounted images, dm for device mapper (LVM), and md for software RAID.

Listing Block Devices

# List all block devices
[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   1    32G  0 disk 
└─sdb1          8:17   1    32G  0 part 
sr0            11:0    1  1024M  0 rom

# Show file system type
[root@server ~]# lsblk -f
NAME          FSTYPE      LABEL  UUID                                 MOUNTPOINTS
sda                                                                    
├─sda1        xfs                 a1b2c3d4-e5f6-...                    /boot
└─sda2        LVM2_member         d4e5f6a7-b8c9-...                    
  ├─rhel-root xfs                 1a2b3c4d-5e6f-...                    /
  └─rhel-swap swap                9z8y7x6w-5v4u-...                    [SWAP]
sdb                                                                    
└─sdb1        vfat        USBDISK 1234-5678

# Show specific columns
[root@server ~]# lsblk -o NAME,SIZE,FSTYPE,MOUNTPOINT,UUID

The lsblk command is your primary tool for viewing block devices and their relationships. It shows devices in a tree structure, making it easy to see which partitions belong to which disks. In the basic output, you see the device name, major/minor numbers (used by the kernel), RM indicates if it's removable (1 means yes), SIZE is the device capacity, RO indicates read-only status, TYPE shows whether it's a disk, partition, LVM volume, or ROM drive, and MOUNTPOINTS shows where it's currently mounted. The tree structure shows relationships clearly. Here, sda has two partitions: sda1 mounted at /boot, and sda2 which is an LVM physical volume containing the root filesystem and swap. Notice sdb with one partition (sdb1) that's not mounted - this could be a USB drive we need to mount. The -f flag adds filesystem information: filesystem type (xfs, vfat, ext4), volume labels, and UUIDs. UUIDs are unique identifiers for filesystems that don't change even if device names change - they're important for reliable mounting. The -o option lets you select specific columns to display - useful for scripts or when you need particular information.

Device Information Commands

# Show all block devices with details
[root@server ~]# blkid
/dev/sda1: UUID="a1b2c3d4-..." TYPE="xfs" PARTUUID="..."
/dev/sda2: UUID="d4e5f6a7-..." TYPE="LVM2_member" PARTUUID="..."
/dev/sdb1: LABEL="USBDISK" UUID="1234-5678" TYPE="vfat" PARTUUID="..."
/dev/mapper/rhel-root: UUID="1a2b3c4d-..." TYPE="xfs"

# Query specific device
[root@server ~]# blkid /dev/sdb1
/dev/sdb1: LABEL="USBDISK" UUID="1234-5678" TYPE="vfat"

# Show partition table
[root@server ~]# fdisk -l /dev/sdb
Disk /dev/sdb: 32 GiB, 34359738368 bytes, 67108864 sectors
...
Device     Boot Start      End  Sectors Size Id Type
/dev/sdb1        2048 67108863 67106816  32G  c W95 FAT32 (LBA)

# Real-time device events
[root@server ~]# udevadm monitor
# Insert USB device to see events...

Beyond lsblk, several commands help identify and examine storage devices. The blkid command shows block device attributes including UUID, filesystem type, and labels. This is invaluable when you need to find a device's UUID for fstab configuration or when troubleshooting mounting issues. Running blkid without arguments shows all detected filesystems. You can also query a specific device for its attributes. fdisk -l displays the partition table of a device. This shows partition boundaries, sizes, and partition types. It's useful for understanding how a disk is organized, especially when working with disks from other systems. For GPT-partitioned disks, gdisk provides similar information. udevadm monitor shows device events in real-time. When you insert a USB drive or connect a disk, you can watch the kernel detect it and udev assign device names. This is helpful for troubleshooting when devices aren't appearing as expected. The /proc/partitions file lists all partitions the kernel knows about, and /sys/block/ contains detailed information about each block device in sysfs format.

The mount Command

# Basic mount syntax
mount [options] device mountpoint

# Mount a device to a directory
[root@server ~]# mount /dev/sdb1 /mnt/usb

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

# Mount by UUID (more reliable)
[root@server ~]# mount UUID="1234-5678" /mnt/usb

# Mount by label
[root@server ~]# mount LABEL="USBDISK" /mnt/usb

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

# View currently mounted filesystems
[root@server ~]# mount
[root@server ~]# mount | grep "^/dev"

Mount Point Requirements: The directory must exist before mounting. Create it with mkdir if needed.

The mount command attaches filesystems to the directory tree. The basic syntax specifies the device and the mount point - the directory where you want the contents to appear. Before mounting, the mount point directory must exist. Common practice is to use /mnt for temporary mounts or create subdirectories there like /mnt/usb or /mnt/backup. For permanent mount points, you might create directories in other locations. Usually, mount can auto-detect the filesystem type, but the -t option lets you specify it explicitly. This is sometimes necessary for ambiguous cases or less common filesystems. Mounting by UUID is more reliable than device names because UUIDs don't change when device order changes. If you boot with different USB devices connected, /dev/sdb might be different, but the UUID is always the same. Similarly, volume labels provide human-readable names for mounting. The -o option passes mount options. "ro" mounts read-only, useful for examining disks without risking changes. Many other options exist for specific needs. Running mount without arguments shows all currently mounted filesystems - a useful way to verify your mount succeeded or see what's currently attached.

Common Mount Options

ro Mount read-only

rw Mount read-write (default)

noexec Prevent program execution

nosuid Ignore setuid/setgid bits

nodev Ignore device files

sync Synchronous I/O (slower, safer)

async Asynchronous I/O (default)

auto Can be mounted with mount -a

noauto Must be mounted explicitly

user Allow non-root users to mount

defaults rw, suid, dev, exec, auto, nouser, async

remount Change options on mounted filesystem

# Combine multiple options with comma
[root@server ~]# mount -o ro,noexec,nosuid /dev/sdb1 /mnt/usb

# Remount with different options (useful for root filesystem)
[root@server ~]# mount -o remount,rw /

Mount options control how the filesystem behaves once mounted. Understanding these is important for both security and functionality. ro and rw control write access. Read-only mounting is useful for forensic examination or preventing accidental changes. noexec prevents execution of any programs on the filesystem - a security measure for data partitions or removable media where you don't want to accidentally run malware. nosuid ignores setuid and setgid permission bits, preventing privilege escalation through programs on that filesystem. Combined with noexec, these options make mounted media safer. nodev ignores device files on the filesystem. Since device files can access hardware directly, this prevents security issues from specially crafted device files on untrusted media. sync forces immediate writes to disk rather than caching - slower but safer for removable media you might remove unexpectedly. async (the default) is faster but risks data loss if media is removed without unmounting. user allows non-root users to mount the filesystem if it's listed in /etc/fstab with this option. defaults is a shorthand for common options: rw, suid, dev, exec, auto, nouser, async. remount changes options on an already-mounted filesystem without unmounting. This is especially useful for the root filesystem which can't be unmounted.

Creating Mount Points

# Standard locations for mount points
/mnt         # Temporary mounts (manual)
/media       # Removable media (automatic)
/run/media   # User-specific removable media (GNOME/systemd)

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

# Create with specific permissions
[root@server ~]# mkdir -m 755 /mnt/backup

# Create nested directories
[root@server ~]# mkdir -p /mnt/data/projects

# Mount the device
[root@server ~]# mount /dev/sdb1 /mnt/usb

# Verify mount
[root@server ~]# ls /mnt/usb
documents  photos  music

# Check mount with df
[root@server ~]# df -h /mnt/usb
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb1        32G  8.0G   24G  25% /mnt/usb

Before mounting, you need a mount point - an existing directory where the filesystem will be attached. Linux has conventions for where to create mount points. /mnt is traditionally used for temporary, manually-created mounts. System administrators create subdirectories here for specific purposes: /mnt/usb, /mnt/backup, /mnt/nfs, etc. /media is used for removable media, often managed automatically by desktop environments. Each device gets a subdirectory, often named by its label. /run/media is used by systemd and modern desktop environments for user-specific removable media. When user "student" inserts a USB drive, it might be mounted at /run/media/student/USBDISK. Creating the mount point is simple with mkdir. Use -m to set permissions if you want something other than the default. Use -p to create parent directories if they don't exist. After mounting, verify it worked by listing the directory contents - you should see the files from the device. The df command shows disk space usage and confirms where filesystems are mounted. "df -h /mnt/usb" shows information specifically about the filesystem mounted there.

Unmounting File Systems

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

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

# Common error: device is busy
[root@server ~]# umount /mnt/usb
umount: /mnt/usb: target is busy.

# Find what's using the mount point
[root@server ~]# lsof /mnt/usb
COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
bash     1234 root  cwd    DIR    8,17     4096    2 /mnt/usb
vim      1240 root    4r   REG    8,17    12288   15 /mnt/usb/file.txt

# Alternative: fuser
[root@server ~]# fuser -mv /mnt/usb
                     USER        PID ACCESS COMMAND
/mnt/usb:            root       1234 ..c.. bash
                     root       1240 F.... vim

# Force unmount (use with caution!)
[root@server ~]# umount -f /mnt/usb

# Lazy unmount - unmounts when no longer busy
[root@server ~]# umount -l /mnt/usb

Unmounting is the reverse of mounting - it detaches the filesystem from the directory tree. Note the command is "umount" not "unmount" - a historical spelling that often trips people up. You can unmount by specifying either the mount point or the device name. Both work equivalently. The most common error is "target is busy," meaning something is using the filesystem. This happens when a process has open files there, or when someone's current working directory is on that filesystem. lsof (list open files) shows what's using the mount point. You see the command, PID, user, and how they're using it. In this example, a bash shell has its current directory there (cwd), and vim has a file open. fuser provides similar information with different formatting. The -m flag is important - it checks the mount point. The ACCESS column shows how the process is using it: c for current directory, f for open file, etc. To unmount, close those programs or change directories. "cd /" from a shell that's in /mnt/usb, then save and close vim. The -f flag forces unmount, but this can cause data loss if writes are pending. The -l flag does a "lazy" unmount - it detaches the filesystem from the tree immediately but waits until it's no longer busy to actually complete the unmount. Use these options only when necessary.

Why Unmounting Matters

Data Loss Risk: Removing media without unmounting can corrupt the filesystem and lose recent writes that are still in cache.

Problems from Not Unmounting:

Cached data not written to disk
Filesystem metadata corruption
Lost files or directories
Filesystem marked as dirty/unclean
Requires fsck on next mount

Safe Removal Process:

Close all files on the device
Exit directories on the device
Run umount command
Wait for command to complete
Physically remove media

# Sync all cached writes before unmounting
[root@server ~]# sync
[root@server ~]# umount /mnt/usb

# For extra safety with removable media
[root@server ~]# sync && umount /mnt/usb && sync

Proper unmounting is critical for data integrity. Linux uses write caching - when you save a file, the data might be written to memory first and only later flushed to the actual storage device. This improves performance dramatically but means recent writes might not be on the physical media yet. If you remove a USB drive without unmounting, any cached data is lost. Worse, filesystem metadata (the internal structures tracking files and directories) might be in an inconsistent state, corrupting the entire filesystem. The device might not mount correctly next time, or files might be missing or damaged. The sync command flushes all pending writes to all storage devices. Running sync before unmounting ensures data is written. The umount command also syncs the specific filesystem being unmounted. After unmounting completes successfully, it's safe to remove the device. The shell returns to the prompt only after data is flushed and the filesystem is cleanly detached. On desktop systems, using the "Eject" or "Safely Remove" option does this automatically. On servers or command line, always umount before physically disconnecting removable storage.

Working with USB Drives

# 1. Connect USB drive and identify it
[root@server ~]# lsblk
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
sdb      8:16   1   32G  0 disk 
└─sdb1   8:17   1   32G  0 part           # New USB drive!

# 2. Check filesystem type
[root@server ~]# blkid /dev/sdb1
/dev/sdb1: LABEL="BACKUP" UUID="1234-5678" TYPE="vfat"

# 3. Create mount point
[root@server ~]# mkdir /mnt/usb

# 4. Mount the drive
[root@server ~]# mount /dev/sdb1 /mnt/usb

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

# 6. Copy files
[root@server ~]# cp /etc/passwd /mnt/usb/

# 7. Unmount when done
[root@server ~]# umount /mnt/usb

# 8. Safe to remove physically

Let's walk through the complete process of working with a USB drive on a server or system without automatic mounting. First, connect the USB drive. The kernel detects it and creates device nodes. Use lsblk to see what appeared - look for a new device, typically sdb or sdc if you already have sda. The RM column shows 1 for removable devices. Check the filesystem with blkid. USB drives commonly use vfat (FAT32) for Windows compatibility, but they might have NTFS, ext4, or other filesystems. The type matters for what options you might need. Create a mount point if one doesn't exist. /mnt/usb is conventional, but you can use any empty directory. Mount the drive using the device name, or use the UUID or label for more reliable mounting. Now you can access the drive like any directory - list files, copy, move, delete, whatever you need. The files on the USB drive appear under /mnt/usb. When finished, unmount the drive. Wait for the command to complete - don't interrupt it. Only after umount finishes successfully should you physically remove the USB drive. This workflow becomes second nature with practice.

Working with Optical Media

# Optical drives are typically sr0, sr1, etc.
[root@server ~]# lsblk
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sr0     11:0    1   4.7G  0 rom

# Mount a CD/DVD
[root@server ~]# mkdir /mnt/cdrom
[root@server ~]# mount /dev/sr0 /mnt/cdrom
mount: /mnt/cdrom: WARNING: source write-protected, mounted read-only.

# Mount an ISO image file
[root@server ~]# mount -o loop rhel-9.0.iso /mnt/iso

# List contents
[root@server ~]# ls /mnt/cdrom
BaseOS  AppStream  images  isolinux  EFI

# Eject optical media
[root@server ~]# umount /mnt/cdrom
[root@server ~]# eject

# Eject specific drive
[root@server ~]# eject /dev/sr0

ISO Files: The -o loop option mounts an ISO file as if it were a physical disc, using a loop device.

Optical drives (CD, DVD, Blu-ray) use device names starting with sr - sr0 is the first optical drive. They appear as type "rom" in lsblk. Mounting optical media is similar to other devices. The system automatically mounts read-only since you can't write to pressed CDs/DVDs (rewritable media might be different). You'll see a warning message but the mount succeeds. RHEL installation media, when mounted, shows the repository structure: BaseOS, AppStream, and various installer files. This is useful for local package installation or creating local repositories. ISO image files can be mounted directly without burning to physical media. The -o loop option tells mount to use a loop device - a virtual block device that makes a file appear as a disk. This is extremely useful for examining ISO contents or installing from downloaded images. After unmounting, the eject command opens the drive tray. On servers without physical access, this might not be meaningful, but on workstations or when working with physical media, it's the proper way to retrieve your disc. Without unmounting first, eject will fail because the media is in use.

Automatic Mounting with udisks

udisks is a daemon that provides automatic mounting of removable media on desktop systems, with mounts appearing under /run/media/username/.

# On desktop systems, USB drives mount automatically
# Mount location: /run/media/username/LABEL

# Example after inserting USB drive labeled "BACKUP"
[student@workstation ~]$ ls /run/media/student/
BACKUP

# Command-line control with udisksctl
[student@workstation ~]$ udisksctl mount -b /dev/sdb1
Mounted /dev/sdb1 at /run/media/student/BACKUP

# Unmount with udisksctl
[student@workstation ~]$ udisksctl unmount -b /dev/sdb1
Unmounted /dev/sdb1

# Power off the drive (safe removal)
[student@workstation ~]$ udisksctl power-off -b /dev/sdb

# View drive information
[student@workstation ~]$ udisksctl info -b /dev/sdb1

On desktop systems with GNOME or other desktop environments, removable media is handled automatically by udisks (or udisks2). When you insert a USB drive, it's detected, mounted, and a file manager window often opens automatically. The mount point is created dynamically under /run/media/ followed by your username and the device's label. So user "student" inserting a drive labeled "BACKUP" finds it at /run/media/student/BACKUP. This per-user mounting improves security - other users can't access your mounted media. udisksctl is the command-line interface to udisks. Regular users can use it to mount and unmount their removable media without needing root privileges. This is possible because udisks uses PolicyKit for authorization. The mount subcommand mounts a device, automatically choosing an appropriate mount point. unmount detaches the filesystem. power-off safely removes power from the device, which is important for some USB devices to ensure all writes complete. On servers without desktop environments, udisks might not be installed or running. In those cases, you use the manual mount/umount commands with root privileges as we've discussed.

Viewing Mounted Filesystems

# Show all mounts
[root@server ~]# mount | grep "^/dev"
/dev/mapper/rhel-root on / type xfs (rw,relatime,attr2,inode64,logbufs=8)
/dev/sda1 on /boot type xfs (rw,relatime,attr2,inode64,logbufs=8)
/dev/sdb1 on /mnt/usb type vfat (rw,relatime,fmask=0022,dmask=0022)

# Detailed mount info from /proc
[root@server ~]# cat /proc/mounts | grep "^/dev"

# Human-readable disk usage
[root@server ~]# df -h
Filesystem             Size  Used Avail Use% Mounted on
/dev/mapper/rhel-root   50G   12G   38G  24% /
/dev/sda1             1014M  254M  761M  26% /boot
/dev/sdb1               32G  8.0G   24G  25% /mnt/usb

# Show filesystem types
[root@server ~]# df -Th
Filesystem            Type      Size  Used Avail Use% Mounted on
/dev/mapper/rhel-root xfs        50G   12G   38G  24% /
/dev/sda1             xfs      1014M  254M  761M  26% /boot
/dev/sdb1             vfat       32G  8.0G   24G  25% /mnt/usb

# Show only specific filesystem types
[root@server ~]# df -t xfs
[root@server ~]# df -x tmpfs   # Exclude tmpfs

Multiple commands show what's currently mounted on the system. The mount command without arguments lists all mounted filesystems, including virtual filesystems. Piping through grep "^/dev" filters to show only real devices (those starting with /dev). /proc/mounts is the kernel's view of mounted filesystems. It's more accurate than mount's output in edge cases and is what the kernel actually uses. The df command (disk free) shows mounted filesystems with space usage information. This is typically more useful than mount because you see how full each filesystem is. The -h flag makes sizes human-readable (GB, MB instead of raw bytes). The -T flag adds the filesystem type column, showing whether each filesystem is xfs, vfat, ext4, etc. This is useful for identifying what kind of filesystems you're working with. You can filter df output with -t to show only specific filesystem types, or -x to exclude types. Excluding tmpfs is common because tmpfs (RAM-based filesystems) often clutters the output with many small system filesystems you don't usually care about.

Common Filesystem Types

Type	Description	Use Cases
xfs	Default RHEL filesystem, high performance	Root filesystem, data storage
ext4	Fourth extended filesystem, mature and stable	/boot, general use, compatibility
vfat	FAT32, Windows compatible	USB drives, EFI System Partition
ntfs	Windows NTFS (via ntfs-3g)	Windows data exchange
iso9660	CD/DVD filesystem	Optical media, ISO images
nfs	Network File System	Network shares (covered separately)
tmpfs	RAM-based temporary filesystem	/tmp, /run, fast scratch space

# Mount NTFS drive (requires ntfs-3g package)
[root@server ~]# mount -t ntfs-3g /dev/sdb1 /mnt/windows

Linux supports many filesystem types. Understanding common ones helps you work with different storage scenarios. XFS is RHEL's default filesystem since RHEL 7. It's a high-performance journaling filesystem that handles large files and filesystems well. It's used for the root filesystem and general data storage on RHEL systems. ext4 (fourth extended filesystem) was the previous default and remains widely used. It's extremely mature and stable. RHEL often uses ext4 for /boot because GRUB has robust ext4 support. Many other Linux distributions default to ext4. vfat (FAT32) provides Windows and Mac compatibility. Most USB drives come formatted as FAT32, and the EFI System Partition on UEFI systems uses FAT. It has limitations (4GB max file size) but universal compatibility. NTFS is Windows' modern filesystem. Linux supports it through the ntfs-3g driver, which provides full read-write access. You might need to install the ntfs-3g package if it's not present. iso9660 is the standard CD/DVD filesystem. You'll encounter it with optical media and ISO image files. nfs (Network File System) mounts remote storage over the network. It's covered in network storage modules. tmpfs creates filesystems in RAM - fast but volatile. System directories like /tmp and /run often use tmpfs.

Troubleshooting Mount Issues

# Error: wrong fs type, bad option, bad superblock
[root@server ~]# mount /dev/sdb1 /mnt/usb
mount: /mnt/usb: wrong fs type, bad option, bad superblock...

# Solution: Check filesystem type and specify it
[root@server ~]# blkid /dev/sdb1
[root@server ~]# mount -t ntfs-3g /dev/sdb1 /mnt/usb

# Error: mount point does not exist
[root@server ~]# mkdir /mnt/usb

# Error: already mounted or busy
[root@server ~]# mount | grep /dev/sdb1
[root@server ~]# umount /dev/sdb1  # then remount

# Error: read-only filesystem
[root@server ~]# dmesg | tail  # Check for hardware errors

# Filesystem needs repair
[root@server ~]# fsck /dev/sdb1  # Only on unmounted filesystems!

# NTFS marked as dirty (unclean shutdown from Windows)
[root@server ~]# ntfsfix /dev/sdb1

Mount operations sometimes fail. Understanding common errors helps you resolve them quickly. "Wrong fs type, bad option, bad superblock" usually means mount can't auto-detect the filesystem type or the type it detected is wrong. Use blkid to determine the actual type, then specify it with -t. This often happens with NTFS drives. "Mount point does not exist" is simple - create the directory with mkdir. The mount point must exist before you can mount to it. "Already mounted or busy" means the device is already mounted somewhere. Check with mount | grep to find where, then unmount if you want to mount elsewhere. "Read-only filesystem" when you expected read-write often indicates hardware errors. Check dmesg for disk errors. The kernel may have remounted read-only to prevent further damage. Hardware or cable issues, filesystem corruption, or write-protected media can cause this. If a filesystem is corrupted, fsck (filesystem check) can repair it. CRITICAL: only run fsck on unmounted filesystems! Running fsck on a mounted filesystem causes severe corruption. For NTFS drives that Windows didn't shut down cleanly (hibernation, improper shutdown), ntfsfix can clear the dirty flag. Or boot into Windows and shut down properly.

Introduction to /etc/fstab

/etc/fstab (filesystem table) defines filesystems to mount automatically at boot. It's also used by mount -a and allows simplified mount commands.

# View the filesystem table
[root@server ~]# cat /etc/fstab
# device                    mount-point   type   options        dump fsck
/dev/mapper/rhel-root       /             xfs    defaults       0    0
UUID=a1b2c3d4-e5f6-...      /boot         xfs    defaults       0    0
/dev/mapper/rhel-swap       none          swap   defaults       0    0
UUID=1234-5678              /mnt/usb      vfat   noauto,user    0    0

Field	Description	Example
1	Device (name, UUID, or LABEL)	UUID=1234-5678
2	Mount point	/mnt/usb
3	Filesystem type	vfat, xfs, ext4
4	Mount options	defaults, noauto, user
5	Dump (backup) - typically 0	0
6	fsck order (0=skip, 1=first, 2=other)	0

The /etc/fstab file is the central configuration for filesystem mounts. The system reads it at boot to mount filesystems automatically, and mount uses it for simplified commands. Each line defines one mount with six fields. The device field identifies what to mount. Using UUID= or LABEL= is more reliable than device names like /dev/sdb1, which can change if devices are added or removed. The mount point is the directory where the filesystem will be attached. For swap space, use "none" since swap doesn't mount to a directory. The filesystem type specifies what kind of filesystem it is: xfs, ext4, vfat, swap, etc. Mount options control behavior. "defaults" uses standard options. "noauto" means don't mount at boot - useful for removable media that might not be present. "user" allows non-root users to mount it. The dump field is for the backup program dump - rarely used today, typically set to 0. The fsck order determines filesystem check order at boot. 0 means don't check, 1 is for the root filesystem (checked first), 2 is for other filesystems (checked after root). Modern journaling filesystems like xfs often don't need fsck and use 0.

fstab for Removable Media

# Find UUID of USB drive
[root@server ~]# blkid /dev/sdb1
/dev/sdb1: LABEL="BACKUP" UUID="1234-5678" TYPE="vfat"

# Add entry to /etc/fstab for removable media
[root@server ~]# vim /etc/fstab
# Add this line:
UUID=1234-5678  /mnt/backup  vfat  noauto,user,uid=1000,gid=1000  0  0

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

# Now regular user can mount/unmount
[student@server ~]$ mount /mnt/backup
[student@server ~]$ ls /mnt/backup
documents  photos
[student@server ~]$ umount /mnt/backup

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

# Verify with noauto entries
[root@server ~]# mount /mnt/backup  # Simplified - only mount point needed

While fstab is typically used for permanent storage, it's also useful for removable media you use regularly. The noauto option prevents automatic mounting at boot, which would fail if the device isn't connected. The user option allows non-root users to mount and unmount this specific filesystem, which is convenient for regular users who need to access the drive. For vfat (FAT) filesystems, the uid and gid options specify which user and group should own the files. FAT doesn't store Unix ownership, so you need to specify it at mount time. Setting uid=1000 (typically the first regular user) gives them ownership. Once configured, users can mount with just "mount /mnt/backup" - they don't need to specify the device, filesystem type, or options because fstab provides all that information. "mount -a" mounts all filesystems in fstab that have the "auto" option (the default). It's useful for testing fstab entries, but it won't mount "noauto" entries. This approach provides convenience and security - you define exactly which devices can be mounted where, and users can mount specific pre-approved devices without needing root access to mount arbitrary storage.

Practical Workflow

1. Connect Device └── Physical: Insert USB drive or disc 2. Identify Device └── lsblk # Find device name (sdb1, sr0, etc.) └── blkid /dev/xxx # Check filesystem type and UUID 3. Create Mount Point └── mkdir /mnt/mydrive 4. Mount └── mount /dev/sdb1 /mnt/mydrive └── OR: mount UUID="xxx" /mnt/mydrive 5. Access & Use └── cd /mnt/mydrive └── ls, cp, etc. 6. Unmount Safely └── cd / # Exit the mount point first! └── umount /mnt/mydrive └── Physical: Remove device

Let's consolidate everything into a practical workflow you can follow whenever you need to work with removable media. Step 1: Physically connect the device. For USB drives, insert into a port. For optical media, insert into the drive. Step 2: Identify the device using lsblk. Note the device name - typically the newest entry is your device. Use blkid to see the filesystem type, UUID, and any volume label. Step 3: Create a mount point directory if one doesn't exist. Common choices are under /mnt with a descriptive name. Step 4: Mount the device. You can specify the device name or use the UUID for more reliable mounting. The mount command will usually auto-detect the filesystem type. Step 5: Access your files normally. The mount point becomes the gateway to everything on the device. Use standard file commands: ls to list, cp to copy, rm to delete, etc. Step 6: Unmount safely before removing the device. Critical: make sure you're not in that directory first (cd elsewhere). Then run umount. Wait for it to complete. Only then physically remove the device. This workflow protects your data and ensures reliable access to removable storage.

Key Takeaways

Devices: Block devices live in /dev/; use lsblk and blkid to identify