Hands-on Lab·CompTIA Linux+

A disk, a filesystem, and a mount that survives a reboot

Domain 1 is 23% of XK0-006 and most of it is storage. This guide builds a block device out of a file, partitions it, puts a filesystem on it, mounts it by UUID and writes the fstab line - then checks that line before anything reboots, and does the same work on the RPM family, which defaults to a different filesystem.

System Management Guide 4 of 28 Intermediate

PlatformsUbuntu 26.04 LTS + AlmaLinux 10.2
Mandatory access controlAppArmor on Ubuntu, SELinux enforcing on Alma
Firewallufw / nftables 1.1.6
TimeAbout 26 min

One host from each package family. The storage work is identical on both; the filesystem each family reaches for by default is not.
Server Name	IP Address	OS	Roles	CPU	RAM	HDD
LPLUS-A01	192.168.0.73	Ubuntu 26.04 LTS	Debian-family host - apt, ufw, netplan, AppArmor	2 Core	4 GB	50 GB
LPLUS-B01	192.168.0.74	AlmaLinux 10.2	RPM-family host - dnf, firewalld, NetworkManager, SELinux	2 Core	4 GB	50 GB

This guide includes

Use this when you are asked to add storage to a machine, or before you trust a hand-written fstab line to a reboot. This matters because a wrong line in that file stops the machine booting, and the two commands that catch it take seconds.

reading what a machine already has, and finding there is no spare disk to practise on
making a real block device out of a sparse file, and seeing what sparse means
partitioning it, putting ext4 on it, and mounting it by UUID rather than device name
writing the fstab line and verifying it, including the warning that only findmnt --verify gives you
doing the same on the RPM family, whose default filesystem costs 35 MB before you write anything

Before you start

the-lab-and-the-two-package-families

What this machine has, and what it has not
Before adding storage, look at what is there.
bash Example session
```
$lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS | head -7; echo "--- one 50 GB disk, and every byte of it already in use"NAME                       SIZE TYPE MOUNTPOINTSfd0                          4K disksda                         50G disk├─sda1                       1M part├─sda2                       2G part /boot└─sda3                      48G part  └─ubuntu--vg-ubuntu--lv   48G lvm  /--- one 50 GB disk, and every byte of it already in use$df -hT / /boot | awk '{printf "%-28s %-6s %-5s %s\n", $1, $2, $3, $7}'Filesystem                   Type   Size  Mounted/dev/mapper/ubuntu--vg-ubuntu--lv ext4   48G   //dev/sda2                    ext4   2.0G  /boot
```
Note
lsblk is the first storage command on any unfamiliar machine. It shows the tree - disk, partitions, LVM, mount points - without touching anything. The exam asks about it directly and it is what you would type first in a performance-based question about a disk that is not mounted.

Every byte of this disk is already in use, which is the normal state of a real server and the reason the rest of this page uses a loop device. If your machine has a genuinely spare disk, use it and skip the next step - every command after that is identical.

df -hT adds the TYPE column, which plain df -h leaves out. Knowing a filesystem is ext4 rather than xfs decides whether you can shrink it later, and it is one letter of difference in the command you type.

fd0 in that listing is a floppy drive that does not exist - an artefact of the virtual machine's emulated hardware. Real listings have noise in them, and recognising which lines to ignore is part of reading one.

Expected resultOne 50 GB sda with /boot on sda2 and the rest in an LVM volume, and a root filesystem of type ext4.

Success conditionYou can describe a machine's storage layout in one command.
A block device made out of a file
512 MB that costs nothing until it is used.
bash Example session
```
$sudo truncate -s 512M /var/tmp/xk0.img && ls -lh /var/tmp/xk0.img | awk '{print $5, $9}'; du -h --apparent-size /var/tmp/xk0.img | cut -f1; du -h /var/tmp/xk0.img | cut -f1512M /var/tmp/xk0.img512M0$sudo losetup -fP --show /var/tmp/xk0.img/dev/loop0$lsblk /dev/loop0 -o NAME,SIZE,TYPE; echo "--- the kernel treats it as a disk, which is the only thing that matters here"NAME   SIZE TYPEloop0  512M loop--- the kernel treats it as a disk, which is the only thing that matters here
```
Note
du said 0 and du --apparent-size said 512M for the same file. truncate creates a SPARSE file: the size is recorded, the blocks are not allocated until something writes to them. That is why this exercise costs no real disk space up front, and why "the image is 512 MB" and "the disk lost 512 MB" are different statements. Sparse files are also how virtual machine disks are usually stored, which is where you will meet this again.

losetup -f --show picks the first free loop device and prints it, which is what makes this scriptable - never hard-code /dev/loop0, because on a machine already using loop devices it will be taken.

The -P matters and the next step is about it. It tells the kernel to scan the attached image for a partition table and create device nodes for what it finds.

To the kernel this is a disk. It has a block device node, it takes a partition table, filesystems mount from it, and lsblk lists it. Nothing later on this page knows or cares that it is a file.

Expected result512M from ls -lh and from du --apparent-size, but 0 from plain du. Then /dev/loop0, which lsblk reports as a 512M device of type loop.

Success conditionYou can produce a block device to practise on wherever you are.
A partition table, and the partition the kernel could not see
GPT, one partition, and the reason it appeared immediately.
bash Example session
```
$sudo parted -s /dev/loop0 mklabel gpt mkpart primary ext4 1MiB 100%; sudo parted -s /dev/loop0 print | tail -4 Number  Start   End    Size   File system  Name     Flags 1      1049kB  536MB  535MB               primary$lsblk /dev/loop0 -o NAME,SIZE,TYPE; echo "--- losetup -P asked the kernel to scan the table, so loop0p1 is already here"NAME       SIZE TYPEloop0      512M loop└─loop0p1  510M part--- losetup -P asked the kernel to scan the table, so loop0p1 is already here
```
Note
parted -s is the scriptable form. No prompts, no confirmation, which is what you want in an exam and what you must be careful with everywhere else - mklabel destroys the existing table without asking.

GPT rather than MBR, and the exam expects you to know why. MBR is limited to 2 TB and four primary partitions; GPT has neither limit and keeps a backup table at the end of the device. Modern installs are GPT and UEFI firmware requires it.

Normally the kernel does NOT see a new partition straight away - the table on disk changed, the kernel's idea of it did not, and partprobe or partx -a is what closes the gap. It appeared here because the device was attached with -P in the previous step, which asks for exactly that scan. This is the single commonest "I made the partition and it is not there" on a real machine.

535 MB requested, 510 MB usable. The partition starts at 1 MiB for alignment and GPT keeps a header and a backup, so a partition is always a little smaller than the device. That gap grows into a real number on a large disk, and it is why capacity planning uses the partition's size rather than the disk's.

Expected resultA GPT table with one 535 MB primary partition, then loop0p1 at 510M underneath loop0 in the tree.

Success conditionYou can partition a device non-interactively and confirm the kernel sees the result.
A filesystem, and the name it will be mounted by
ext4, a label, and the identifier that does not change.
bash Example session
```
$sudo mkfs.ext4 -q -L XK0DATA /dev/loop0p1 && sudo blkid /dev/loop0p1/dev/loop0p1: LABEL="XK0DATA" UUID="0ad80a25-dfff-4792-97d7-063e30b88aa2" BLOCK_SIZE="4096" TYPE="ext4" PARTLABEL="primary" PARTUUID="c4fa73b3-41ac-4c0a-bd27-6567cffca396"$sudo tune2fs -l /dev/loop0p1 | grep -E "Filesystem volume name|Filesystem UUID|Block count|Reserved block count"Filesystem volume name:   XK0DATAFilesystem UUID:          0ad80a25-dfff-4792-97d7-063e30b88aa2Block count:              130560Reserved block count:     6528
```
Note
A partition is not a filesystem. parted divided the device; mkfs puts a filesystem inside one of those divisions. Two separate ideas that the same exam question will use interchangeably to see whether you notice.

The UUID is generated by mkfs and belongs to the FILESYSTEM. Reformat and it changes. /dev/loop0p1 and /dev/sdb1 are names the kernel assigns in the order it finds things, which is why a second disk can silently become the first after a reboot - and why fstab uses the UUID.

6,528 blocks of 130,560 are reserved, which is 5%. They are for root, so that a filesystem filled by an ordinary user still leaves room for the system to log and recover. On a small data volume that is wasted space and tune2fs -m 1 reduces it; on the root filesystem, leave it alone.

A LABEL is the human-friendly alternative to a UUID and works the same way in fstab as LABEL=XK0DATA. It is easier to read and easier to collide with - two disks with the same label is a fault you can create yourself.

Expected resultblkid reporting LABEL="XK0DATA", a UUID, TYPE="ext4", and tune2fs showing 130560 blocks with 6528 reserved.

Success conditionYou can create a filesystem and read back the identifiers it will be mounted by.
Mounting it, by UUID rather than by device name
One mount, one file written, and the proof it is really there.
bash Example session
```
$sudo mkdir -p /mnt/xk0 && sudo mount UUID=$(sudo blkid -s UUID -o value /dev/loop0p1) /mnt/xk0 && findmnt /mnt/xk0 -o TARGET,SOURCE,FSTYPE,OPTIONSTARGET   SOURCE       FSTYPE OPTIONS/mnt/xk0 /dev/loop0p1 ext4   rw,relatime$echo "domain 1 is 23 per cent" | sudo tee /mnt/xk0/note.txt > /dev/null; sudo df -hT /mnt/xk0 | tail -1; cat /mnt/xk0/note.txt/dev/loop0p1   ext4  462M  156K  426M   1% /mnt/xk0domain 1 is 23 per cent
```
Note
$(blkid -s UUID -o value ...) is the shape to remember, because it turns a UUID from something you copy by hand into something a script produces. -s selects one tag and -o value strips everything except its value.

findmnt is better than mount | grep for exactly this question: it takes a target, prints the source, the type and the options in columns, and exits non-zero when the target is not a mount point - which makes it usable in a script or a health check.

512M became 462M usable. Between the partition alignment, the ext4 metadata and the 5% reserve, a tenth of the device is gone before a single file exists. Sizing storage from the raw number is how you end up 5% short.

Writing a file is the only real proof. A mount that succeeded and a filesystem you can write to are different claims - a read-only mount, a full filesystem or a permission problem all leave the mount in place. tee was used here because the redirect in sudo echo > file is performed by YOUR shell, not by sudo, and fails on a directory you cannot write to.

Expected resultfindmnt showing /mnt/xk0 from /dev/loop0p1, type ext4 - then a 462M filesystem with 156K used, and the file read back.

Success conditionYou can mount a filesystem by a name that survives a reboot, and prove it is writable.
The fstab line, checked before anything reboots
The file that stops a machine booting, and the two commands that check it.
bash Example session
```
$sudo cp /etc/fstab /var/tmp/fstab.bak && printf 'UUID=%s /mnt/xk0 ext4 defaults,nofail 0 2\n' $(sudo blkid -s UUID -o value /dev/loop0p1) | sudo tee -a /etc/fstab | catUUID=0ad80a25-dfff-4792-97d7-063e30b88aa2 /mnt/xk0 ext4 defaults,nofail 0 2$sudo umount /mnt/xk0 && sudo mount -a && findmnt /mnt/xk0 -o TARGET,SOURCE,FSTYPE,OPTIONS; echo "mount -a exit $?"TARGET   SOURCE       FSTYPE OPTIONS/mnt/xk0 /dev/loop0p1 ext4   rw,relatimemount -a exit 0$sudo findmnt --verify --verbose 2>&1 | tail -4   [ ] source /dev/loop0p1 exists   [ ] FS type is ext4   [W] your fstab has been modified, but systemd still uses the old version;       use 'systemctl daemon-reload' to reload
```
Note
Back the file up first, in the same command that edits it. A bad line in /etc/fstab can stop the machine reaching a login prompt, and the recovery is a rescue shell. One cp is cheaper than that every time.

nofail is the option that turns a fatal mistake into a missing mount. Without it, a device that is absent at boot - an unplugged disk, a loop image that no longer exists - can hold the boot up or drop it into emergency mode. On anything that is not the root filesystem, nofail is the safer default.

umount then mount -a is the real test. It replays every line in fstab exactly as the boot would, while you still have a shell to fix it from. Adding a line and NOT testing it is the mistake this step exists to prevent.

findmnt --verify warned that systemd was still using the old fstab and told us to run systemctl daemon-reload. systemd generates a mount unit from each fstab line at boot and caches it; until the reload, the running system and the file disagree. mount -a works regardless, which is what makes this worth knowing - the mount succeeding is not evidence that a boot would behave the same way.

The last two fields are dump and fsck order. 0 2 means "not backed up by dump" and "checked after the root filesystem". Root is 1, everything else is 2, and 0 disables the check - which the exam asks about directly.

Expected resultThe appended line, then mount -a exit 0 with the filesystem mounted again - and findmnt --verify confirming the source and type, then warning that systemd is still using the old fstab.

Success conditionYou can add a persistent mount and prove the line is good without rebooting.
The RPM family, and the filesystem it defaults to
The same work on the other host, and the difference that matters.
bash Example session
```
$sudo truncate -s 512M /var/tmp/xk0.img && sudo losetup -fP --show /var/tmp/xk0.img && sudo mkfs.xfs -q -L XK0DATA /dev/loop0 && sudo blkid /dev/loop0/dev/loop0/dev/loop0: LABEL="XK0DATA" UUID="8a78801d-ca1e-4abd-adcd-383c939b8d49" BLOCK_SIZE="512" TYPE="xfs"$sudo mkdir -p /mnt/xk0 && sudo mount /dev/loop0 /mnt/xk0 && df -hT /mnt/xk0 | tail -1; echo "--- xfs, which is what this family ships as its default"/dev/loop0     xfs   448M   35M  414M   8% /mnt/xk0--- xfs, which is what this family ships as its default$df -hT / | tail -1; echo "--- and the root filesystem is xfs too, where Ubuntu's was ext4"/dev/mapper/almalinux-root xfs    44G  5.1G   39G  12% /--- and the root filesystem is xfs too, where Ubuntu's was ext4
```
Note
Every command is the same except mkfs. lsblk, losetup, parted, blkid, mount, findmnt and fstab do not care which family they are on. XK0-006 is family-neutral, and this is what that actually means in practice.

35 MB used on an empty filesystem, against ext4's 156 KB. xfs allocates its log and metadata up front, which costs more on a small volume and costs nothing noticeable on a large one - xfs is built for large filesystems and parallel workloads.

The asymmetry worth carrying into the exam: xfs cannot be shrunk. It grows online with xfs_growfs and there is no shrink command at all. ext4 shrinks with resize2fs while unmounted. If you are asked to choose, that is usually the deciding fact.

Both root filesystems match their family's default - ext4 on Ubuntu, xfs on AlmaLinux - which is a one-command way to tell which kind of machine you have landed on.

No partition table was used here. The filesystem went straight onto /dev/loop0. That is legal, common for a whole disk given to one filesystem, and worth seeing once so that the partition step reads as a choice rather than a requirement.

Expected resultTYPE="xfs" on the loop device, a mounted filesystem showing 35M used of 448M while empty, and a root filesystem that is also xfs.

Success conditionYou can do this work on either family and know what each one gives you by default.
Putting both machines back
Unmount, restore, detach, delete - then count what is left.
bash Example session
```
$sudo umount /mnt/xk0; sudo cp /var/tmp/fstab.bak /etc/fstab && sudo rm -f /var/tmp/fstab.bak; sudo losetup -d /dev/loop0; sudo rm -f /var/tmp/xk0.img; sudo rmdir /mnt/xk0; grep -c xk0 /etc/fstab; echo "fstab lines mentioning xk0"0fstab lines mentioning xk0$losetup -a | wc -l; echo "loop devices left"; ls /var/tmp/xk0.img 2>&1 | tail -10loop devices leftls: cannot access '/var/tmp/xk0.img': No such file or directory$sudo umount /mnt/xk0; sudo losetup -d /dev/loop0; sudo rm -f /var/tmp/xk0.img; sudo rmdir /mnt/xk0; losetup -a | wc -l; echo "loop devices left on the RPM host"0loop devices left on the RPM host
```
Note
Order matters when unwinding storage. Unmount before detaching the loop device, and take the fstab line out before you remove what it points at - reverse either and you get a busy device or a line referring to something that is gone.

The fstab was restored from the backup, not edited back by hand with sed. Restoring a known-good copy cannot leave a half-removed line behind, which an in-place edit can.

Counting is the point. grep -c on fstab, losetup -a | wc -l and an ls that is expected to fail - three cheap checks that turn "I cleaned up" into evidence. This is the same habit the Troubleshooting domain rewards, applied to your own work.

Expected result0 fstab lines mentioning xk0, 0 loop devices on either host, and No such file or directory for the image.

Success conditionBoth machines are exactly as they were before this page.

Troubleshooting

A new partition does not appear under /dev after parted or fdisk.

Why: The partition table on disk changed but the kernel is still using the copy it read earlier.

Fix:sudo partprobe /dev/sdX or sudo partx -a /dev/sdX. For a loop device, attach it with losetup -P so the scan happens automatically.
The machine drops to emergency mode after a reboot and the console mentions a mount.

Why: A line in /etc/fstab names a device or UUID that is not present, and without nofail systemd treats the failure as fatal.

Fix:From the rescue shell, mount -o remount,rw /, comment the line out, and reboot. Prevent it next time with nofail and by running umount then mount -a before you ever reboot.
A filesystem mounted from /dev/sdb1 comes back on the wrong disk after a reboot.

Why: Kernel device names are assigned in discovery order and are not stable across reboots or hardware changes.

Fix:Mount by UUID= or LABEL=. blkid prints both, and lsblk -o NAME,UUID,LABEL shows them for every device at once.
df shows space free but writes fail for an ordinary user.

Why: ext4 reserves 5% of blocks for root by default - 6,528 of 130,560 on the filesystem built here.

Fix:tune2fs -m 1 /dev/sdX1 lowers the reserve on a data volume, or -m 0 removes it. Leave the reserve alone on the root filesystem, where it is what lets a full machine still boot and log.

Official sources

← All Linux+ guides

A disk, a filesystem, and a mount that survives a reboot

This guide includes

Before you start

What this machine has, and what it has not

A block device made out of a file

A partition table, and the partition the kernel could not see

A filesystem, and the name it will be mounted by

Mounting it, by UUID rather than by device name

The fstab line, checked before anything reboots

The RPM family, and the filesystem it defaults to

Putting both machines back

Troubleshooting

Official sources