LFCS #5: How to Mount (Samba and NFS) Filesystems in Linux

The Linux Foundation launched the LFCS certification (Linux Foundation Certified Sysadmin), a brand new program whose purpose is to allow individuals from all corners of the globe to get certified in basic to intermediate system administration tasks for Linux systems, which includes supporting running systems and services, along with overall monitoring and analysis, plus smart decision-making when it comes to raising issues to upper support teams.

The series will be titled Preparation for the LFCS (Linux Foundation Certified Sysadmin) Parts 1 through 33 and cover the following topics:

No.	Title
Part 1	How to Use ‘Sed’ Command to Manipulate Files in Linux
Part 2	How to Install and Use Vi/Vim in Linux
Part 3	How to Compress Files & Directoires and Finding Files in Linux
Part 4	How to Partition Storage Devices in Linux
Part 5	How to Mount (Samba and NFS) Filesystems in Linux
Part 6	Assembling Partitions as RAID Devices – Creating & Managing System Backups
Part 7	Managing System Startup Processes and Services (SysVinit, Systemd, and Upstart
Part 8	How to Manage User & Groups, File Permissions, and Sudo Access
Part 9	Linux Package Management with Yum, RPM, Apt, Dpkg, Aptitude, and Zypper
Part 10	Learning Basic Shell Scripting and Filesystem Troubleshooting
Part 11	How to Manage and Create LVM Using vgcreate, lvcreate, and lvextend Commands
Part 12	How to Explore Linux with Installed Help Documentations and Tools
Part 13	How to Configure and Troubleshoot Grand Unified Bootloader (GRUB)
Part 14	Monitor Linux Processes Resource Usage and Set Process Limits on a Per-User Basis
Part 15	How to Set or Modify Kernel Runtime Parameters in Linux Systems
Part 16	Implementing Mandatory Access Control with SELinux or AppArmor in Linux
Part 17	How to Set Access Control Lists (ACLs) and Disk Quotas for Users and Groups
Part 18	Installing Network Services and Configuring Automatic Startup at Boot
Part 19	An Ultimate Guide to Setting Up FTP Server to Allow Anonymous Logins
Part 20	Setup a Basic Recursive Caching DNS Server and Configure Zones for Domain
Part 21	How to Install, Secure, and Performance Tuning of MariaDB Database Server
Part 22	How to Install and Configure NFS Server for File System Sharing
Part 23	How to Setup Apache with Name-Based Virtual Hosting with SSL Certificate
Part 24	How To Setup an Iptables Firewall to Enable Remote Access to Services in Linux
Part 25	How to Turn a Linux into a Router to Handle Traffic Statically and Dynamically
Part 26	How to Setup Encrypted Filesystems and Swap Using Cryptsetup Tool
Part 27	How to Monitor System Usage, Outages, and Troubleshoot Linux Servers
Part 28	How to Setup a Network Repository to Install or Update Packages
Part 29	How to Audit Network Performance, Security, and Troubleshooting
Part 30	How to Install and Manage Virtual Machines and Containers
Part 31	Learn the Basics of Git to Manage Projects Efficiently
Part 32	A Beginner’s Guide to Configuring IPv4 and IPv6 Addresses in Linux
Part 33	A Beginner’s Guide to Creating Network Bonding and Bridging in Ubuntu

This post is Part 5 of a 33-tutorial series, here in this part, we will explain how to mount/unmount local and network filesystems in linux, that are required for the LFCS certification exam.

Mounting and Unmounting File Systems in Linux

Once a disk has been partitioned, Linux needs some way to access the data on the partitions. Unlike DOS or Windows (where this is done by assigning a drive letter to each partition), Linux uses a unified directory tree where each partition is mounted at a mount point in that tree.

A mount point is a directory that is used as a way to access the filesystem on the partition, and mounting the filesystem is the process of associating a certain filesystem (a partition, for example) with a specific directory in the directory tree.

In other words, the first step in managing a storage device is attaching the device to the file system tree. This task can be accomplished on a one-time basis by using tools such as mount (and then unmounted with umount) or persistently across reboots by editing the /etc/fstab file.

Mounting File Systems in Linux

The mount command (without any options or arguments) shows the currently mounted filesystems.

# mount

In addition, mount is used to mount filesystems into the filesystem tree. Its standard syntax is as follows.

# mount -t type device dir -o options

This command instructs the kernel to mount the filesystem found on the device (a partition, for example, that has been formatted with a filesystem type) at the directory dir, using all options. In this form, mount does not look in /etc/fstab for instructions.

If only a directory or device is specified, for example.

# mount /dir -o options
or
# mount device -o options

The mount command tries to find a mount point and if it can’t find any, then searches for a device (both cases in the /etc/fstab file), and finally attempts to complete the mount operation (which usually succeeds, except for the case when either the directory or the device is already being used, or when the user invoking mount is not root).

You will notice that every line in the output of the mount has the following format.

device on directory type (options)

For example,

/dev/mapper/debian-home on /home type ext4 (rw,relatime,user_xattr,barrier=1,data=ordered)

Reads:

The /dev/mapper/debian-home is mounted on /home, which has been formatted as ext4, with the following options: rw,relatime,user_xattr,barrier=1,data=ordered

Mount Command Options

The most frequently used mount command options include.

• async: allows asynchronous I/O operations on the file system being mounted.
• auto: marks the file system as enabled to be mounted automatically using mount -a, which is the opposite of noauto.
• defaults: This option is an alias for async,auto,dev,exec,nouser,rw,suid. Note that multiple options must be separated by a comma without any spaces. If by accident you type a space between options, the mount will interpret the subsequent text string as another argument.
• loop: Mounts an image (an .iso file, for example) as a loop device. This option can be used to simulate the presence of the disk’s contents in an optical media reader.
• noexec: prevents the execution of executable files on the particular filesystem. It is the opposite of exec.
• nouser: prevents any users (other than root) to mount and unmount the filesystem. It is the opposite of the user.
• remount: mounts the filesystem again in case it is already mounted.
• ro: mounts the filesystem as read-only.
• rw: mounts the file system with read and write capabilities.
• relatime: makes access time to files be updated only if atime is earlier than mtime.
• user_xattr: allows users to set and remote extended filesystem attributes.

Mounting a Device with ro and noexec Options

# mount -t ext4 /dev/sdg1 /mnt -o ro,noexec

In this case, we can see that attempts to write a file to or to run a binary file located inside our mounting point fail with corresponding error messages.

# touch /mnt/myfile
# /mnt/bin/echo “Hi there”

Mounting a Device with Default Options

In the following scenario, we will try to write a file to our newly mounted device and run an executable file located within its filesystem tree using the same commands as in the previous example.

# mount -t ext4 /dev/sdg1 /mnt -o defaults

In this last case, it works perfectly.

Unmounting File Systems in Linux

Unmounting a device (with the umount command) means finishing writing all the remaining “on transit” data so that it can be safely removed. Note that if you try to remove a mounted device without properly unmounting it first, you run the risk of damaging the device itself or causing data loss.

That being said, in order to unmount a device, you must be “standing outside” its block device descriptor or mount point. In other words, your current working directory must be something else other than the mounting point. Otherwise, you will get a message saying that the device is busy.

An easy way to “leave” the mounting point is typing the cd command which, in lack of arguments, will take us to our current user’s home directory, as shown above.

Mounting Samba and NFS Networked Filesystems

The two most frequently used network file systems are SMB (which stands for “Server Message Block”) and NFS (“Network File System”). Chances are you will use NFS if you need to set up a share for Unix-like clients only, and will opt for Samba if you need to share files with Windows-based clients and perhaps other Unix-like clients as well.

The following steps assume that Samba and NFS shares have already been set up in the server with IP 192.168.0.10 (please note that setting up an NFS share is one of the competencies required for the LFCE exam, which we will cover after the present series).

Mounting a Samba Share on Linux

1. First, install the samba-client samba-common and cifs-utils packages on Red Hat and Debian based distributions.

# yum update && yum install samba-client samba-common cifs-utils
# apt update && apt install samba-client samba-common cifs-utils

Then run the following command to look for available samba shares in the server.

# smbclient -L 192.168.0.10

And enter the password for the root account in the remote machine.

In the above image, we have highlighted the share that is ready for mounting on our local system. You will need a valid Samba username and password on the remote server in order to access it.

2. When mounting a password-protected network share, it is not a good idea to write your credentials in the /etc/fstab file. Instead, you can store them in a hidden file somewhere with permissions set to 600, like so.

# mkdir /media/samba
# echo “username=samba_username” > /media/samba/.smbcredentials
# echo “password=samba_password” >> /media/samba/.smbcredentials
# chmod 600 /media/samba/.smbcredentials

3. Then add the following line to /etc/fstab file.

# //192.168.0.10/gacanepa /media/samba cifs credentials=/media/samba/.smbcredentials,defaults 0 0

4. You can now mount your samba share, either manually (mount //192.168.0.10/gacanepa) or by rebooting your machine so as to apply the changes made in /etc/fstab permanently.

# mount -a

Mounting an NFS Share on Linux

1. First, install the nfs-common and portmap packages on Red Hat and Debian-based distributions.

# yum update && yum install nfs-utils nfs-utils-lib
# apt update && apt install nfs-common

2. Create a mounting point for the NFS share.

# mkdir /media/nfs

3. Add the following line to /etc/fstab file.

192.168.0.10:/NFS-SHARE /media/nfs nfs defaults 0 0

4. You can now mount your nfs share, either manually (mount 192.168.0.10:/NFS-SHARE) or by rebooting your machine so as to apply the changes made in /etc/fstab permanently.

Mounting Filesystems Permanently in Linux

As shown in the previous two examples, the /etc/fstab file controls how Linux provides access to disk partitions and removable media devices and consists of a series of lines that contain six fields each; the fields are separated by one or more spaces or tabs. A line that begins with a hash mark (#) is a comment and is ignored.

Each line has the following format.

<file system> <mount point> <type> <options> <dump> <pass>

Where:

• <file system>: The first column specifies the mount device. Most distributions now specify partitions by their labels or UUIDs. This practice can help reduce problems if partition numbers change.
• <mount point>: The second column specifies the mount point.
• <type>: The file system type code is the same as the type code used to mount a filesystem with the mount command. A file system type code of auto lets the kernel auto-detect the filesystem type, which can be a convenient option for removable media devices. Note that this option may not be available for all filesystems out there.
• <options>: One (or more) mount option(s).
• <dump>: You will most likely leave this to 0 (otherwise set it to 1) to disable the dump utility to backup the filesystem upon boot (The dump program was once a common backup tool, but it is much less popular today.)
• <pass>: This column specifies whether the integrity of the filesystem should be checked at boot time with fsck. A 0 means that fsck should not check a filesystem. The higher the number, the lowest the priority. Thus, the root partition will most likely have a value of 1, while all others that should be checked should have a value of 2.

Mount Examples

1. To mount a partition with the label TECMINT at boot time with rw and noexec attributes, you should add the following line in /etc/fstab file.

LABEL=TECMINT /mnt ext4 rw,noexec 0 0

2. If you want the contents of a disk in your DVD drive to be available at boot time.

/dev/sr0 /media/cdrom0 iso9660 ro,user,noauto 0 0

Where /dev/sr0 is your DVD drive.

Summary

You can rest assured that mounting and unmounting local and network filesystems from the command line will be part of your day-to-day responsibilities as a sysadmin. You will also need to master /etc/fstab.

I hope that you have found this article useful to help you with those tasks. Feel free to add your comments (or ask questions) below and share this article through your network social profiles.

The LFCS eBook is available now for purchase. Order your copy today and start your journey to becoming a certified Linux system administrator!

Product Name	Price	Buy
The Linux Foundation’s LFCS Certification Preparation Guide	$19.99	[Buy Now]

Last, but not least, please consider buying your exam voucher using the following links to earn us a small commission, which will help us keep this book updated.