Mastering Linux: A Comprehensive Guide to Mounting Drives

Mounting drives in Linux is a fundamental skill for any user, whether you’re a seasoned system administrator or a newcomer exploring the power of the command line. It allows you to access the files and directories stored on various storage devices, such as hard drives, SSDs, USB drives, network shares, and more. Unlike Windows or macOS where drives are often automatically mounted, Linux typically requires manual intervention, giving you greater control and flexibility. This comprehensive guide will walk you through everything you need to know about mounting drives in Linux, from basic concepts to advanced techniques.

Understanding the Basics of Mounting

Before diving into the practical steps, let’s clarify some key concepts:

• File System Hierarchy: Linux organizes files and directories in a hierarchical structure, starting from the root directory (`/`). All other directories and files are located under this root.
• Mount Point: A mount point is a directory in the file system hierarchy where you attach (mount) the file system of a storage device. Think of it as a doorway through which you access the contents of the drive. It is just an empty directory which is an entry point for the new device you are about to mount.
• Device Files: In Linux, storage devices are represented as special files, typically located in the `/dev` directory. For instance, `/dev/sda` usually refers to the first hard drive, `/dev/sdb` to the second, and so on. Partitions within these drives are denoted by a number suffix, like `/dev/sda1`, `/dev/sda2`, etc. USB drives are typically assigned `/dev/sdb`, `/dev/sdc`, and so on.
• File System Type: Each partition on a storage device is formatted with a specific file system, such as ext4 (common for Linux), NTFS (used by Windows), FAT32 (common for USB drives), or XFS. Linux needs to know the file system type to correctly interpret the data on the drive.
• Mounting: The process of attaching a device’s file system to a mount point in the file system hierarchy is known as mounting. After mounting, you can access the drive’s contents through the specified mount point.
• Unmounting: Once you’re done using the drive, you must unmount it. This detaches the file system from the mount point, allowing you to safely disconnect the storage device if necessary.

Step-by-Step Guide to Mounting a Drive

Here’s a detailed breakdown of the process involved in mounting a drive in Linux:

1. Identify the Drive and Partition

The first step is to identify the device file and the partition you want to mount. You can use the `lsblk` or `fdisk` commands to achieve this.

Using `lsblk`

The `lsblk` (list block devices) command provides a clear overview of connected storage devices and their partitions. Open a terminal and type:

lsblk

This command will output something like this:

NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:0    0   256G  0 disk
├─sda1   8:1    0    10G  0 part /boot
├─sda2   8:2    0   230G  0 part /
sdb      8:16   1   100G  0 disk
└─sdb1   8:17   1    100G 0 part 
sdc      8:32   0   120G  0 disk
└─sdc1   8:33   0   120G 0 part 
sdd     6:0     0    5G    0 disk
└─sdd1  6:1     0   5G    0 part

Let’s decipher this:

• `NAME`: The device file (e.g., `sda`, `sdb`, `sdc`, `sdd`).
• `MAJ:MIN`: Major and minor numbers (used internally by the kernel).
• `RM`: Removable (1 for removable devices, 0 for fixed).
• `SIZE`: Size of the device.
• `RO`: Read-only (1 if read-only, 0 if read-write).
• `TYPE`: Device type (e.g., `disk`, `part`).
• `MOUNTPOINT`: The mount point, if the partition is mounted.

In this example, `sda` is the primary hard drive with two partitions: `sda1` mounted at `/boot`, and `sda2` mounted at `/`. We are going to work with sdb1, sdc1 and sdd1. Suppose that sdb1 is an external USB drive, sdc1 is an internal drive and sdd1 is also a external USB drive that we want to mount.

From this output, you should identify the device file and partition (e.g., `/dev/sdb1`, `/dev/sdc1`, `/dev/sdd1`).

Using `fdisk`

The `fdisk` command is another powerful tool for partitioning, but it can also be used to view device information. To view a specific drive, run `fdisk` with the device file as an argument:

sudo fdisk -l /dev/sdb
sudo fdisk -l /dev/sdc
sudo fdisk -l /dev/sdd

The output will give you more details about the drive and its partitions. In general, lsblk is easier to read for basic mounting purposes, while fdisk can be used for more advanced management. It is generally recommended to use lsblk unless you are doing low-level partitioning and disk management.

2. Create a Mount Point

Next, you need to create a directory that will serve as the mount point. You can choose any directory that is empty and that you have permission to access to.

For example, to create a mount point for the usb drive `sdb1` and `sdd1` under `/mnt`, you can use:

sudo mkdir /mnt/usb1
sudo mkdir /mnt/usb2

And a mount point for the internal drive at /media. This is the directory used by Linux distributions to mount removable media in most cases, however, it does not mean that it cannot be used for internal drives. We can also use this directory for the same purpose with the internal drive sdc1:

sudo mkdir /media/internal

You can create a mount point with any name and location that you like, but using a name related to the mount function is a common and helpful practice, specially if you have many different drives.

3. Mount the Drive

Now you’re ready to mount the drive. Use the `mount` command with the device file, mount point, and file system type as arguments:

For example, to mount the usb drive at `/dev/sdb1` on the mount point `/mnt/usb1` we use the following command. Since usb drives are usually FAT32 format, we indicate so in the command:

sudo mount -t vfat /dev/sdb1 /mnt/usb1

Similarly, we can mount the other usb drive at `/dev/sdd1` on `/mnt/usb2`. If the system determines that the disk is formatted in FAT32 we do not need to specify the -t option. It will automount it to the right format, although this may cause errors if the format is something different:

sudo mount /dev/sdd1 /mnt/usb2

Finally, to mount the internal drive at `/dev/sdc1` to `/media/internal`, we use the command below. Because the hard drive will almost certainly be formatted with `ext4` (Linux’s default) we must specify so with the -t option:

sudo mount -t ext4 /dev/sdc1 /media/internal

If the file system type is unknown, you can often let Linux detect it automatically:

sudo mount /dev/sdb1 /mnt/usb1

However, specifying the type is always a good practice to avoid unexpected errors. Common file system types include `ext4`, `ntfs`, `vfat` (FAT32), and `xfs`. If the mounting operation was successful, you will see no output. If the output returns an error, then the file system type is likely wrong or the partition does not exist.

4. Verify the Mount

After mounting the drive, verify that it’s correctly mounted. You can use the `df` command to see a list of all mounted file systems:

df -h

The `-h` option makes the output human-readable. The results will be similar to these, although yours will vary according to your drive configuration:

Filesystem      Size  Used Avail Use% Mounted on
udev            1.9G     0  1.9G   0% /dev
tmpfs           396M  1.6M  394M   1% /run
/dev/sda2       227G  114G  102G  53% /
tmpfs           2.0G     0  2.0G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           2.0G     0  2.0G   0% /sys/fs/cgroup
/dev/sda1       976M  157M  755M  18% /boot
tmpfs           396M   52K  396M   1% /run/user/1000
/dev/sdb1        100G   56G   44G  56% /mnt/usb1
/dev/sdc1       120G   30G  90G   25% /media/internal
/dev/sdd1        5G    3G    2G   60% /mnt/usb2

Look for the device file and mount point. If they are present in this list, you have correctly mounted the drive.

Alternatively, you can check the contents of the mount point using `ls`:

ls /mnt/usb1
ls /media/internal
ls /mnt/usb2

If you see the files and directories present on the drive, the mounting process was successful.

5. Accessing the Drive

Now that the drive is mounted, you can access its contents using the specified mount point like any other directory. You can use the command line or any GUI file manager to browse the files and directories on the mounted drive.

6. Unmounting the Drive

When you are finished using the drive, unmount it before disconnecting the storage device. This ensures that all write operations are completed and prevent data corruption. Use the `umount` command followed by either the device file or the mount point.

To unmount the usb drive at `/mnt/usb1` and `/mnt/usb2`, or internal drive at `/media/internal` use:

sudo umount /mnt/usb1
sudo umount /media/internal
sudo umount /mnt/usb2

Or, you can use the device file:

sudo umount /dev/sdb1
sudo umount /dev/sdc1
sudo umount /dev/sdd1

After unmounting the drive, verify that it no longer appears on the `df` output.

Mounting Drives Automatically on Boot

Manually mounting drives every time you boot your system can be inconvenient. To automatically mount drives during startup, you need to edit the `/etc/fstab` file. This file lists the file systems to be mounted at boot time. Proceed with caution because incorrect entries in this file can lead to boot failures.

Editing `/etc/fstab`

Open `/etc/fstab` with a text editor (e.g., `nano` or `vim`). You must use `sudo` to edit the file because it requires root permissions:

sudo nano /etc/fstab

Add the following line to the end of the file. Note that the device may vary for your system. You must write the proper device location:

/dev/sdb1       /mnt/usb1   vfat    defaults,uid=1000,gid=1000   0       0
/dev/sdc1       /media/internal  ext4    defaults        0       0
/dev/sdd1       /mnt/usb2   vfat    defaults,uid=1000,gid=1000   0       0

Here’s a breakdown of each column:

• Device File: The device file to mount (e.g., `/dev/sdb1`, `/dev/sdc1`, `/dev/sdd1`).
• Mount Point: The directory where to mount the file system (e.g., `/mnt/usb1`, `/media/internal`, `/mnt/usb2`).
• File System Type: The file system type of the drive (e.g., `ext4`, `vfat`).
• Options: Mount options. `defaults` provide standard mount options. `uid` and `gid` set the user ID and group ID for the mount point ownership for usb drives, which prevents permissions errors. These are normally used for removable drives.
• Dump: Whether to dump the file system. Set to `0` in most cases.
• Pass: The order in which `fsck` should check file systems at boot. Use `0` for most cases.

Save the file and exit the editor. After saving, test the `/etc/fstab` settings without having to reboot, by running `mount -a`.

sudo mount -a

If no errors are returned, your settings are correct, and the drives will now be automatically mounted at startup.

Important Considerations for `/etc/fstab`

• UUID: Instead of using the device file `/dev/sdb1` , it is strongly recommended to use the UUID (Universally Unique Identifier). UUIDs are unique for each drive and partition, and this ensures that the drives are mounted to the correct locations if the system for some reason changes the device order. You can find the UUID using the `blkid` command:

sudo blkid

The output will provide the UUIDs of each drive in the system. For example:

/dev/sda1: UUID="4334fd2c-3a8d-4b24-9484-4c9944586766" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="b75e8312-301a-41a8-8607-879a0f673960"
/dev/sda2: UUID="9df61393-0f33-4893-b91a-b971ef6f1050" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="a019e3aa-64c7-4915-83a4-293e32615957"
/dev/sdb1: LABEL="usb1" UUID="6B63-0569" BLOCK_SIZE="512" TYPE="vfat" PARTUUID="00004552-01"
/dev/sdc1: LABEL="internal" UUID="55f134a3-114d-494a-a7a1-212d7e2220a3" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="0004306a-01"
/dev/sdd1: LABEL="usb2" UUID="6806-7883" BLOCK_SIZE="512" TYPE="vfat" PARTUUID="00004552-02"

Use the UUID instead of the device path in the `/etc/fstab` file. For example:

UUID=6B63-0569    /mnt/usb1   vfat    defaults,uid=1000,gid=1000   0       0
UUID=55f134a3-114d-494a-a7a1-212d7e2220a3       /media/internal  ext4    defaults        0       0
UUID=6806-7883    /mnt/usb2   vfat    defaults,uid=1000,gid=1000   0       0

• Backup: Always back up the `/etc/fstab` file before making changes.

sudo cp /etc/fstab /etc/fstab.backup

• Permissions: Ensure the mount point has the necessary permissions for users to access the drive.
• Removable Drives: For USB drives, consider using the `noauto` option in `/etc/fstab` and use a system like `udisks` to handle automatic mounts on connect to avoid long boot times if the disk is not connected.

Troubleshooting Common Issues

If you encounter issues while mounting drives, here are some common troubleshooting tips:

• Permission denied: Make sure you have the necessary permissions to mount the drive and write to the mount point directory. You need to use `sudo` in most cases to have root privileges for these operations. If the drive is already mounted but the permissions are not correct, you may need to change the ownership using the `chown` command and the mount options in /etc/fstab.
• Incorrect file system type: Double-check the file system type of the drive using `lsblk -f` or `blkid` and ensure that the `-t` argument of the mount command is correct.
• Device busy: If the device is already mounted or being used by another process, you won’t be able to unmount it. You may need to kill the process that is using it. You can use the `lsof` command to identify which processes are using a particular device.
• Mount point doesn’t exist: Make sure the mount point directory exists before mounting the drive.
• Errors in `/etc/fstab`: Incorrect entries in `/etc/fstab` can prevent the system from booting. If this happens, boot into recovery mode and correct the errors.

Conclusion

Mounting drives in Linux is a powerful and essential skill. By following the detailed steps outlined in this guide, you’ll be able to effectively manage storage devices on your Linux system. From understanding fundamental concepts to mastering automatic mounting, you now have the knowledge to confidently handle file system management on Linux. Remember to always double-check your configurations and experiment with different options to gain more experience and master the different options for mounting your drives.