CCNA Create and configure file systems Questions

75 of 80 questions · Page 1/2 · Create and configure file systems · Answers revealed

1
Multi-Selectmedium

Which THREE of the following commands can be used to display information about file systems?

Select 3 answers
A.df
B.blkid
C.lsblk
D.fdisk
E.du
AnswersA, B, C

df displays mounted file system usage including size, used space, and mount points.

Why this answer

The `df` command displays information about mounted file systems, including total size, used space, available space, and mount points. It reads the /proc/mounts file to show file system usage statistics, making it a primary tool for file system information.

Exam trap

Red Hat often tests the distinction between disk partitioning tools (fdisk) and file system information commands, so candidates mistakenly select fdisk because it lists partitions, but it does not display file system details like type or usage.

2
MCQeasy

What is the default filesystem type in Red Hat Enterprise Linux 8?

A.btrfs
B.ZFS
C.ext4
D.XFS
AnswerD

Correct: XFS is the default filesystem in RHEL 8.

Why this answer

In Red Hat Enterprise Linux 8, the default filesystem type is XFS. XFS is a high-performance 64-bit journaling filesystem that supports large files and filesystems, and it has been the default since RHEL 7. The Anaconda installer selects XFS by default for the root filesystem during a standard installation.

Exam trap

The trap here is that candidates may confuse the default filesystem in RHEL 8 with ext4, which was the default in RHEL 6 and earlier, or mistakenly think btrfs is the default due to its prominence in other distributions like openSUSE.

How to eliminate wrong answers

Option A is wrong because btrfs is not the default filesystem in RHEL 8; it is available as a technology preview but is not the default choice. Option B is wrong because ZFS is not included in RHEL 8 due to licensing incompatibilities (CDDL vs GPL) and is not a supported filesystem. Option C is wrong because ext4, while supported and commonly used in older RHEL versions, is not the default in RHEL 8; XFS replaced ext4 as the default starting in RHEL 7.

3
MCQmedium

To enable per-user quotas on an XFS file system, which mount option should be used?

A.uquota
B.quota
C.usrquota
D.user_quota
AnswerA

uquota is the correct mount option for per-user quotas on XFS.

Why this answer

On XFS file systems, the correct mount option to enable per-user quotas is `uquota`. This is the XFS-specific shorthand that activates user quota accounting and enforcement. While other options like `usrquota` work on ext4, XFS requires `uquota` or the longer `usrquota` is also accepted in modern kernels, but the official Red Hat documentation and EX200 exam focus on `uquota` as the correct XFS mount option.

Exam trap

The trap here is that candidates familiar with ext4 often choose `usrquota` (option C), not realizing that XFS uses its own distinct mount option `uquota`, and the exam specifically tests this file-system-specific syntax.

How to eliminate wrong answers

Option B (quota) is wrong because it is a generic term, not a valid mount option; XFS requires specific options like `uquota` or `gquota` to enable quota enforcement. Option C (usrquota) is wrong because while it is a valid mount option for ext4 file systems, XFS uses `uquota` as its native option; `usrquota` is not recognized by XFS in older kernels and is not the standard Red Hat recommendation for XFS. Option D (user_quota) is wrong because this is not a valid Linux mount option for any common file system; it is a fictitious option that might confuse candidates unfamiliar with XFS syntax.

4
MCQeasy

In /etc/fstab, which values in the dump and pass fields enable automatic file system checking at boot?

A.dump=1, pass=0
B.dump=0, pass=0
C.dump=0, pass=1
D.dump=1, pass=1
AnswerC

pass=1 enables automatic fsck at boot (root file system).

Why this answer

Option C is correct because the `pass` field in `/etc/fstab` controls the order of file system checks at boot. A value of 1 means the root file system is checked first, and a value of 2 or higher means other file systems are checked after root. The `dump` field is for backup utility (dump) and is not related to boot-time checking; it must be 0 to disable dump.

Thus, `dump=0, pass=1` enables automatic file system checking (fsck) at boot for the root file system.

Exam trap

Red Hat often tests the misconception that `dump=1` is required for boot-time file system checks, but the `dump` field is unrelated to fsck; the trap is confusing the `dump` field with the `pass` field's role in enabling automatic checks.

How to eliminate wrong answers

Option A is wrong because `dump=1` enables dump backups (not boot-time checking), and `pass=0` disables fsck entirely, so no automatic checking occurs. Option B is wrong because `dump=0` and `pass=0` both disable dump and fsck, meaning no file system check at boot. Option D is wrong because `dump=1` enables dump (unnecessary for boot checking) and `pass=1` enables fsck, but the combination is not required; the correct minimal setting for enabling fsck is `dump=0, pass=1`.

5
MCQhard

You are managing a Red Hat Enterprise Linux 9 server that hosts a critical database application. The database stores its data on an XFS filesystem mounted on /data, backed by a logical volume in a volume group named vg_db. Recently, the database team reported that write operations are failing with 'Disk quota exceeded' errors, but the filesystem still shows 40% free space. You check the filesystem quota configuration and find that no user or group quotas are set on /data. The database runs as user 'dbadmin' with group 'dba'. Which of the following is the most likely cause of the 'Disk quota exceeded' error?

A.The logical volume is thin provisioned and the data pool is full.
B.An XFS project quota is configured on the /data directory, limiting the space used by the database files.
C.SELinux is blocking the database writes due to a denial.
D.The filesystem has run out of inodes.
AnswerB

Project quotas can limit directory usage.

Why this answer

Option B is correct because XFS project quotas can limit the total space used by a directory tree, regardless of the user or group that owns the files. Even though no user or group quotas are set, a project quota on /data restricts the database files, causing 'Disk quota exceeded' errors despite 40% free space on the filesystem.

Exam trap

The trap here is that candidates assume 'Disk quota exceeded' always implies user or group quotas are configured, overlooking XFS project quotas which operate on directory trees and are invisible to standard 'quota' or 'repquota' commands without the '-p' flag.

How to eliminate wrong answers

Option A is wrong because a thin-provisioned logical volume with a full data pool would cause 'No space left on device' errors, not 'Disk quota exceeded', and the filesystem would show 0% free space, not 40%. Option C is wrong because SELinux denials produce 'Permission denied' or AVC denial messages, not 'Disk quota exceeded' errors. Option D is wrong because running out of inodes would cause 'No space left on device' errors when creating files, and the filesystem would still show free space, but the error message would be different and the 'df -i' command would show 100% inode usage.

6
MCQmedium

A partition /dev/sdc1 is formatted as ext4. The administrator needs to check the file system for errors without making any repairs. Which command should be used?

A.xfs_repair -n /dev/sdc1
B.fsck -n /dev/sdc1
C.fsck -y /dev/sdc1
D.e2fsck -p /dev/sdc1
AnswerB

fsck -n performs a non-destructive, read-only check without repairs.

Why this answer

The `fsck -n` command checks the file system for errors without making any repairs, as the `-n` flag forces a non-interactive, read-only check. Since /dev/sdc1 is formatted as ext4, `fsck` automatically calls the appropriate ext4-specific tool (e2fsck) with the no-repair option. This matches the requirement to only check for errors without fixing them.

Exam trap

Red Hat often tests the distinction between checking and repairing file systems, and the trap here is that candidates may confuse `-n` (no repair) with `-y` (auto-repair) or assume `xfs_repair -n` works on ext4, not recognizing that file system-specific tools must match the file system type.

How to eliminate wrong answers

Option A is wrong because `xfs_repair -n` is used for XFS file systems, not ext4; /dev/sdc1 is formatted as ext4, so this command is incompatible and would fail. Option C is wrong because `fsck -y` automatically answers 'yes' to all repair prompts, which would make repairs, contradicting the requirement to check without making repairs. Option D is wrong because `e2fsck -p` runs in 'preen' mode, which automatically repairs minor file system issues without prompting, thus performing repairs rather than just checking.

7
MCQeasy

Which command can be used to display a list of all currently mounted filesystems on a Linux system?

A.fdisk -l
B.lsblk -m
C.cat /proc/filesystems
D.df -a
E.mount
AnswerE

Correct: lists all mounted filesystems.

Why this answer

The `mount` command with no arguments displays a list of all currently mounted filesystems, showing the device, mount point, filesystem type, and mount options. This is the standard and most direct way to view active mounts on a Linux system.

Exam trap

The trap here is that candidates confuse commands that list block devices or filesystem types with the command that shows actual mounted filesystems, leading them to pick `lsblk` or `cat /proc/filesystems` instead of `mount`.

How to eliminate wrong answers

Option A is wrong because `fdisk -l` lists partition tables on block devices, not currently mounted filesystems. Option B is wrong because `lsblk -m` lists block devices with their permissions and owners, but does not show mount status or filesystem type details. Option C is wrong because `cat /proc/filesystems` shows which filesystem types are supported by the kernel, not which are currently mounted.

Option D is wrong because `df -a` reports disk space usage for mounted filesystems, but it does not display all mount details such as mount options or device paths for pseudo-filesystems.

8
MCQhard

A system administrator at a company is configuring a new storage array for a file server. The server uses LVM on top of a hardware RAID5 array. The administrator has created a volume group "vg_data" and a logical volume "lv_docs" intended for an XFS filesystem. After formatting with mkfs.xfs and mounting to /docs, the system works. However, after a reboot, the mount point is empty and the logical volume is not mounted. The administrator checks /etc/fstab and finds an entry using the device path /dev/vg_data/lv_docs. What is the most likely cause?

A.The mount point /docs was deleted during reboot
B.The XFS filesystem was corrupted during reboot
C.The logical volume name is misspelled in /etc/fstab
D.The volume group is not activated during boot because the LVM service is not enabled
AnswerD

The LVM service must be enabled for automatic activation.

Why this answer

Option D is correct because LVM volume groups are not automatically activated during boot unless the lvm2-lvmetad service (or equivalent LVM service) is enabled. Without this service, the system does not scan for and activate volume groups, so logical volumes like /dev/vg_data/lv_docs are not available for mounting. The /etc/fstab entry using the device path fails silently, leaving /docs empty.

Exam trap

The trap here is that candidates assume a valid /etc/fstab entry with the correct device path guarantees mounting after reboot, overlooking the prerequisite that LVM volume groups must be activated by a system service before the device is accessible.

How to eliminate wrong answers

Option A is wrong because mount points are directories in the filesystem and are not deleted during a reboot; the /docs directory persists unless explicitly removed. Option B is wrong because XFS filesystem corruption is not a typical side effect of a reboot, and if corruption occurred, the mount would likely fail with an error message, not silently leave the mount point empty. Option C is wrong because the question states the administrator checked /etc/fstab and found an entry using /dev/vg_data/lv_docs, implying the name is correct; a misspelling would cause a 'no such device' error, but the scenario describes a silent failure after reboot.

9
Multi-Selecthard

Which THREE of the following mount options are commonly used to enhance security on a filesystem?

Select 3 answers
A.nosuid
B.nodev
C.suid
D.defaults
E.noexec
AnswersA, B, E

Correct: blocks setuid/setgid bits.

Why this answer

The `nosuid` option prevents the set-user-identifier (setuid) and set-group-identifier (setgid) bits from taking effect on the filesystem. This blocks unprivileged users from executing binaries with elevated privileges, a common vector for privilege escalation attacks.

Exam trap

The trap here is that candidates often confuse `defaults` with a secure baseline, not realizing it includes `suid`, `dev`, and `exec` — the very options that security hardening aims to disable.

10
Multi-Selecteasy

Which TWO of the following commands can be used to create an XFS filesystem on a block device?

Select 2 answers
A.mkfs.ext4 /dev/sdb1
B.mkfs.xfs /dev/sdb1
C.xfs_admin /dev/sdb1
D.mke2fs /dev/sdb1
E.mkfs -t xfs /dev/sdb1
AnswersB, E

Correct: directly creates XFS.

Why this answer

The `mkfs.xfs` command (option B) directly creates an XFS filesystem on a block device. The `mkfs -t xfs` command (option E) is the generic front-end that calls the same XFS-specific tool, making both valid. These are the standard methods for formatting a partition with the XFS filesystem in Red Hat Enterprise Linux.

Exam trap

The trap here is that candidates confuse filesystem creation commands with management commands (like `xfs_admin`) or assume `mke2fs` is a generic tool that can create any filesystem type, when it is strictly for ext2/3/4 families.

11
MCQmedium

Refer to the exhibit. An administrator runs xfs_growfs on /dev/sdc1. What is the most likely reason the command succeeded without prior partition resizing?

A.The partition was automatically resized by xfs_growfs
B.The underlying block device (partition or logical volume) was extended before the command
C.The filesystem was already using the full partition size and the command had no effect
D.The filesystem was mounted with the 'grow' option allowing online growth
AnswerB

Correct. xfs_growfs grows the filesystem to fill the device; the device must already be larger.

Why this answer

The output shows data blocks changed from 2621440 to 5242880, doubling the size. This suggests the underlying block device (partition or LVM) was already extended. xfs_growfs only grows the filesystem to match the device size; it does not resize the device itself.

12
Multi-Selecteasy

Which TWO commands are needed to set up a swap partition on /dev/sdd1 for immediate use?

Select 2 answers
A.swapon /dev/sdd1
B.parted /dev/sdd mkswap
C.mkswap /dev/sdd1
D.swapon -a
E.mkfs.swap /dev/sdd1
AnswersA, C

Correct: Activates the swap partition.

Why this answer

Option A is correct because the `swapon /dev/sdd1` command activates the swap partition immediately, making it available for the kernel to use as virtual memory. Option C is correct because `mkswap /dev/sdd1` writes the swap signature (UUID and swap superblock) to the partition, which is a prerequisite for any swap device to be recognized by the kernel. Together, these two commands first prepare the partition as a swap area and then enable it for immediate use.

Exam trap

Red Hat often tests the distinction between preparing a swap device (`mkswap`) and activating it (`swapon`), and the trap here is that candidates might think `swapon -a` or a single command like `mkfs.swap` is sufficient, when in fact both steps are required and the correct command names are specific.

13
MCQhard

Refer to the exhibit. A storage administrator needs to create a new filesystem of size 1.5 GiB on the available free space in volume group vg_data. Which command should be used?

A.lvcreate -L 1.5G -n lv_new vg_data
B.lvcreate -l 1.5G -n lv_new vg_data
C.lvcreate --size 1.5G --name lv_new vg_data
D.lvcreate -L 1500M -n lv_new vg_data
AnswerA

Correct. This creates a 1.5 GiB logical volume named lv_new in vg_data.

Why this answer

The volume group vg_data has 1.99 GiB free space. To create a 1.5 GiB logical volume, use lvcreate with -L 1.5G -n lv_new vg_data. The -L option specifies size, -n specifies name.

14
MCQeasy

A system administrator receives alerts that the /var/log partition is 100% full. The partition is on /dev/mapper/vg_log-lv_var_log, formatted with XFS, and is mounted at /var/log. The volume group vg_log has 10GB of free space available. The administrator runs the command `lvextend -L +10G /dev/mapper/vg_log-lv_var_log` successfully, but then `df -h` still shows 100% full. What is the next step the administrator should take to use the newly added space?

A.Run resize2fs /dev/mapper/vg_log-lv_var_log
B.Run xfs_growfs /var/log
C.Reboot the system to remount the filesystem
D.Run fsck /dev/mapper/vg_log-lv_var_log
AnswerB

xfs_growfs expands the XFS filesystem to use the newly available space in the logical volume.

Why this answer

After extending the logical volume with `lvextend`, the underlying block device has more space, but the XFS filesystem does not automatically recognize it. The correct next step is to run `xfs_growfs /var/log` to expand the filesystem to fill the newly available space. Unlike ext4, XFS cannot be resized while mounted with `resize2fs`; it requires the XFS-specific `xfs_growfs` command, which can operate on a mounted filesystem.

Exam trap

The trap here is that candidates familiar with ext4 may instinctively choose `resize2fs`, not realizing that XFS requires its own grow command (`xfs_growfs`) and that the filesystem must be explicitly resized after the logical volume extension.

How to eliminate wrong answers

Option A is wrong because `resize2fs` is used for ext2/ext3/ext4 filesystems, not XFS; using it on an XFS filesystem would fail. Option C is wrong because rebooting is unnecessary and would not cause the filesystem to automatically grow; the filesystem must be explicitly resized with `xfs_growfs`. Option D is wrong because `fsck` checks and repairs filesystem metadata, but the filesystem is healthy and simply needs to be grown; running `fsck` would not add the new space.

15
MCQhard

A Red Hat Enterprise Linux 8 server is used as a file server. It has a 1 TB disk /dev/sdc formatted as XFS and mounted at /srv/files. The /etc/fstab entry uses the device name /dev/sdc. After a hardware replacement, the new disk is detected as /dev/sdd, and the server fails to boot because /srv/files cannot be mounted. The administrator used 'blkid' and found the new disk's filesystem UUID is 'abc-123'. What is the best course of action to ensure reliable mounting after future reboots?

A.Add the 'nofail' option to the /etc/fstab entry and reboot
B.Change the /etc/fstab entry to use UUID=abc-123 and run mount -a
C.Create a symbolic link /dev/sdc pointing to /dev/sdd
D.Use PARTUUID instead of UUID in /etc/fstab
AnswerB

Correct: UUID is persistent and device-independent.

Why this answer

Option B is correct because using the filesystem UUID in /etc/fstab provides a persistent identifier that remains constant regardless of the device name assigned by the kernel. After the hardware replacement, the disk is detected as /dev/sdd, but its UUID ('abc-123') is unchanged. Changing the fstab entry to UUID=abc-123 ensures the system can reliably mount the filesystem on every boot, as the UUID is tied to the filesystem itself, not the kernel's device enumeration order.

Exam trap

The trap here is that candidates may think using the device name is sufficient because it worked before, or they may overcomplicate the fix with symlinks or PARTUUID, failing to recognize that the filesystem UUID is the simplest and most robust persistent identifier for mounting filesystems in Red Hat Enterprise Linux 8.

How to eliminate wrong answers

Option A is wrong because adding 'nofail' would allow the system to boot even if the mount fails, but it does not fix the root cause—the fstab entry still references the wrong device name (/dev/sdc), so the filesystem would not be mounted at all. Option C is wrong because creating a symbolic link /dev/sdc pointing to /dev/sdd is not persistent across reboots; device names can change again, and udev rules would be needed for a permanent symlink, which is more complex and not the standard best practice. Option D is wrong because PARTUUID identifies the partition table entry, not the filesystem; if the disk is replaced with a different partition layout, the PARTUUID may change, whereas the filesystem UUID remains stable as long as the filesystem is intact.

16
Matchingmedium

Match each command to its function in managing storage.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts
Matches

Partition table manipulator for MBR and GPT

Create a volume group in LVM

Create an ext4 file system on a partition

Attach a file system to a directory

Why these pairings

These commands are essential for storage management in RHEL.

17
MCQmedium

Based on the exhibit, which device is used for swap?

A./dev/mapper/vg00-home
B./dev/sda2
C.The UUID deadbeef-cafe-babe-0000-000000000000
D.The UUID abcdef01-2345-6789-abcd-ef0123456789
E.The UUID 12345678-1234-1234-1234-123456789abc
AnswerC

Correct: swap entry.

Why this answer

Option C is correct because the exhibit shows a swap partition with the UUID deadbeef-cafe-babe-0000-000000000000. In Red Hat Enterprise Linux, swap devices are identified by their UUID in /etc/fstab, and the 'sw' or 'swap' keyword in the mount options column confirms this. The other UUIDs correspond to non-swap filesystems or are not present in the exhibit.

Exam trap

Red Hat often tests the distinction between device names (like /dev/sda2) and UUIDs, and candidates may mistakenly choose a device name or a UUID from a non-swap filesystem because they overlook the 'swap' keyword in the fstab options column.

How to eliminate wrong answers

Option A is wrong because /dev/mapper/vg00-home is a logical volume typically used for the /home filesystem, not swap; it would have a filesystem type like xfs or ext4, not swap. Option B is wrong because /dev/sda2 is a device name, not a UUID, and the exhibit explicitly shows UUIDs for swap identification; using a device name would be less reliable and not match the exhibit's format. Option D is wrong because the UUID abcdef01-2345-6789-abcd-ef0123456789 is not listed in the exhibit as a swap device; it likely belongs to another filesystem.

Option E is wrong because the UUID 12345678-1234-1234-1234-123456789abc is not present in the exhibit and does not correspond to any swap entry.

18
MCQeasy

Which command creates an XFS filesystem on /dev/nvme0n1p1 and sets the label to 'data'?

A.mkfs.xfs -l data /dev/nvme0n1p1
B.mkfs.xfs -f /dev/nvme0n1p1
C.mkfs.xfs -L data /dev/nvme0n1p1
D.mkfs.xfs -n data /dev/nvme0n1p1
AnswerC

Correct.

Why this answer

Option C is correct because the `-L` flag in `mkfs.xfs` is used to set the filesystem label. The command `mkfs.xfs -L data /dev/nvme0n1p1` creates an XFS filesystem on the specified partition and assigns it the label 'data'.

Exam trap

The trap here is confusing the `-L` (label) flag with the `-l` (log) flag, as they look similar but have completely different functions in XFS, and candidates often misremember the option letter from other filesystem tools.

How to eliminate wrong answers

Option A is wrong because the `-l` flag in `mkfs.xfs` is used to specify log device or log parameters, not the label; using `-l data` would attempt to set a log parameter named 'data', which is invalid. Option B is wrong because the `-f` flag forces overwrite of an existing filesystem but does not set a label; it would create an unlabeled filesystem. Option D is wrong because the `-n` flag in `mkfs.xfs` is used to specify naming (directory) parameters, not the filesystem label; `-n data` would attempt to set a naming option, not the label.

19
MCQmedium

A filesystem is reported as 'read-only' after a system crash. The admin runs fsck and sees 'clean' status. What is the most likely reason it remains read-only?

A.fsck cannot fix errors on ext4 filesystems.
B.The filesystem is still mounted; fsck cannot fix it while mounted.
C.The filesystem is XFS, and fsck does not repair XFS.
D.fsck detected errors but did not fix them automatically.
AnswerD

fsck -y or manual repair needed.

Why this answer

Option D is correct because when fsck reports a filesystem as 'clean' but the system still shows it as read-only, it typically means fsck detected errors during the check but did not automatically repair them. By default, fsck runs in non-interactive mode on boot and may require the '-y' flag or manual intervention to apply fixes. The 'clean' status can be misleading if the journal indicates no corruption, but underlying metadata inconsistencies remain unaddressed.

Exam trap

The trap here is that candidates assume 'clean' means no errors exist, but fsck can report 'clean' while still leaving unaddressed errors that force the filesystem to remain read-only for safety.

How to eliminate wrong answers

Option A is wrong because fsck can fix errors on ext4 filesystems; it is specifically designed to check and repair ext2/3/4 filesystems. Option B is wrong because the question states the admin runs fsck after a system crash, implying the filesystem is not mounted (or fsck would refuse to run with a warning); even if mounted read-only, fsck can still check it, but the issue here is that fsck did not apply repairs. Option C is wrong because the filesystem is reported as ext4 (fsck is run and shows 'clean'), not XFS; XFS uses xfs_repair, not fsck, and the question explicitly mentions fsck.

20
MCQmedium

After extending the logical volume to 500G, why does df still show 250G?

A.The mount point is incorrect.
B.The physical volume is full.
C.The filesystem was not resized after extending the LV.
D.The logical volume extension failed.
AnswerC

Need to run resize2fs or xfs_growfs.

Why this answer

Option C is correct because extending a logical volume (LV) with `lvextend` only increases the block device size; the filesystem on top must be resized separately using `resize2fs` (for ext4) or `xfs_growfs` (for XFS). Without this step, the filesystem still sees the original size, so `df` reports 250G instead of 500G.

Exam trap

Red Hat often tests the misconception that extending the logical volume automatically resizes the filesystem, leading candidates to think the extension itself is sufficient.

How to eliminate wrong answers

Option A is wrong because the mount point is irrelevant; `df` reports the filesystem size regardless of the mount point path. Option B is wrong because a full physical volume (PV) would prevent extending the LV, but the question states the extension was performed to 500G, implying sufficient PV space. Option D is wrong because the LV extension succeeded (the LV now has 500G capacity), but the filesystem was not resized to match.

21
MCQhard

A system has two logical volumes in the same volume group: 'lv_prod' (100% used) and 'lv_backup' (20% used). The administrator wants to allocate 5 GiB from 'lv_backup' to 'lv_prod' without unmounting any filesystems. Is this possible and why?

A.Yes, use lvreduce and lvextend while mounted; ext4 supports online shrinking.
B.No, because LVM does not allow freeing extents from an LV while it is active.
C.No, because ext4 filesystems cannot be shrunk online; they must be unmounted.
D.Yes, use lvresize to move extents between LVs directly.
AnswerC

Correct: ext4 requires unmount for shrink.

Why this answer

Option C is correct because ext4 filesystems do not support online shrinking; they must be unmounted before reducing the logical volume. Since the administrator wants to shrink lv_backup (which is only 20% used) to free 5 GiB, the ext4 filesystem on that LV must be unmounted first. Without unmounting, the lvreduce operation would fail, making the scenario impossible as described.

Exam trap

The trap here is that candidates confuse LVM's ability to resize logical volumes online (which is true for both growth and reduction at the LVM layer) with the filesystem's ability to shrink online, forgetting that ext4 requires unmounting for shrink operations.

How to eliminate wrong answers

Option A is wrong because ext4 does not support online shrinking; lvreduce on an ext4 filesystem requires the filesystem to be unmounted first, so the statement that ext4 supports online shrinking is false. Option B is wrong because LVM does allow freeing extents from an LV while it is active (the LV can be reduced online), but the filesystem on top (ext4) does not support online shrinking, so the limitation is at the filesystem level, not LVM. Option D is wrong because lvresize cannot move extents directly between LVs; it can only resize individual LVs, and extents must be freed from one LV and then allocated to another using separate lvreduce and lvextend steps, and the filesystem must be unmounted for the shrink.

22
MCQhard

A server has an LVM volume group 'vg_data' with a logical volume 'lv_data' formatted as ext4. The administrator needs to increase the filesystem size by 2 GB without unmounting. Which set of commands should be used?

A.lvresize -L +2G /dev/vg_data/lv_data && xfs_growfs /mountpoint
B.lvextend -L +2G /dev/vg_data/lv_data
C.umount /dev/vg_data/lv_data && lvextend -L +2G /dev/vg_data/lv_data && mount /dev/vg_data/lv_data /mountpoint
D.lvextend -L +2G /dev/vg_data/lv_data && resize2fs /dev/vg_data/lv_data
AnswerD

Correct: lvextend extends the LV, then resize2fs grows the filesystem online.

Why this answer

Option D is correct because the filesystem is ext4, which supports online resizing. The `lvextend` command first expands the logical volume by 2 GB, and then `resize2fs` grows the ext4 filesystem to fill the newly allocated space—all without unmounting.

Exam trap

The trap here is that candidates often confuse the filesystem-specific resize commands—using `xfs_growfs` for ext4 or forgetting to run any filesystem resize command after extending the logical volume.

How to eliminate wrong answers

Option A is wrong because `xfs_growfs` is used for XFS filesystems, not ext4; using it on an ext4 filesystem would fail. Option B is wrong because it only extends the logical volume but does not resize the filesystem, leaving the extra space unusable. Option C is wrong because it unnecessarily unmounts and remounts the filesystem; ext4 supports online resizing, so unmounting is not required and adds downtime.

23
MCQeasy

Which command displays the UUID of a filesystem on /dev/sda1?

A.blkid /dev/sda1
B.df -h
C.mount
D.fdisk -l /dev/sda
AnswerA

Correct: blkid reports UUID and other attributes.

Why this answer

The `blkid` command is specifically designed to locate and print block device attributes, including the UUID (Universally Unique Identifier) of a filesystem. Running `blkid /dev/sda1` queries the device's superblock and outputs the UUID, filesystem type, and other metadata, making it the correct tool for this task.

Exam trap

The trap here is that candidates confuse `blkid` with `fdisk` or `df`, assuming partition tools or mount commands can reveal filesystem UUIDs, when in fact only `blkid` (or `lsblk -f`) directly queries the filesystem superblock for this attribute.

How to eliminate wrong answers

Option B is wrong because `df -h` displays disk space usage for mounted filesystems (human-readable sizes), not UUIDs or low-level device attributes. Option C is wrong because `mount` shows currently mounted filesystems and their mount options, but it does not display the UUID of a device unless the device was mounted by UUID (and even then, it shows the mount source, not a direct UUID query). Option D is wrong because `fdisk -l /dev/sda` lists partition tables (sectors, sizes, types) for the entire disk, but it does not show filesystem UUIDs; it only shows partition UUIDs (PTUUID) and partition type GUIDs on GPT disks, not the filesystem UUID stored in the superblock.

24
Multi-Selectmedium

Which TWO commands can be used to check the UUID of a filesystem on /dev/sda1?

Select 2 answers
A.e2label /dev/sda1
B.findmnt /dev/sda1
C.lsblk -o UUID /dev/sda1
D.blkid /dev/sda1
E.file -s /dev/sda1
AnswersC, D

Displays UUID.

Why this answer

The `blkid` command directly queries the UUID of a block device from the libblkid cache or by reading the filesystem superblock, and `lsblk -o UUID` filters the lsblk output to show only the UUID column for the specified device. Both commands reliably retrieve the UUID of /dev/sda1.

Exam trap

The trap here is that candidates confuse `e2label` (which only handles labels) with UUID retrieval, or assume `findmnt` shows UUIDs by default when it actually requires explicit column selection.

25
MCQmedium

A system administrator runs 'mount -a' and receives an error: 'mount: /mnt/nfs: mount point does not exist'. The /etc/fstab entry is: server:/export /mnt/nfs nfs defaults 0 0. What is the most likely cause?

A.The directory /mnt/nfs does not exist
B.The 'defaults' option does not include '_netdev'
C.The filesystem type should be 'nfs4'
D.The NFS server is unreachable
AnswerA

Correct: The mount point must exist before mounting.

Why this answer

The error message 'mount: /mnt/nfs: mount point does not exist' explicitly indicates that the directory /mnt/nfs is missing. The 'mount -a' command processes all entries in /etc/fstab, and for each filesystem, it requires the mount point directory to exist before the mount can succeed. Since the directory is absent, the mount fails immediately, regardless of the NFS server status or filesystem type.

Exam trap

Red Hat often tests the distinction between mount point existence errors and network connectivity errors, trapping candidates who assume the issue is with NFS configuration or server reachability when the error message clearly points to a missing local directory.

How to eliminate wrong answers

Option B is wrong because the '_netdev' option is used to indicate that the filesystem requires network access, which is relevant for systemd ordering but does not affect the mount point existence check; the error is about a missing directory, not network dependency. Option C is wrong because 'nfs' is a valid filesystem type that auto-negotiates the NFS version (including NFSv4) with the server; specifying 'nfs4' is not required and would not resolve a missing mount point. Option D is wrong because an unreachable NFS server would produce a different error, such as 'mount.nfs: Connection timed out' or 'No route to host', not a 'mount point does not exist' error.

26
Multi-Selectmedium

An administrator is configuring a new filesystem for a database server that requires high performance and reliability. Which two features should be considered when choosing between ext4 and XFS? (Choose two.)

Select 2 answers
A.Ext4 supports larger files than XFS
B.XFS is optimized for parallel I/O
C.Ext4 has better online resizing capabilities
D.Ext4 supports subvolume snapshots
E.XFS has robust metadata integrity features
AnswersB, E

XFS is designed for high performance with parallel I/O workloads.

Why this answer

B is correct because XFS is designed for high-performance, parallel I/O workloads, using allocation groups that allow concurrent operations, making it ideal for database servers. E is correct because XFS employs checksums in its metadata (since RHEL 7) and self-healing capabilities via the reflink feature, providing robust integrity against corruption.

Exam trap

Red Hat often tests the misconception that ext4 is superior for all general-purpose workloads, but the trap here is that candidates overlook XFS's parallel I/O optimization and metadata integrity features, which are specifically required for high-performance database servers.

27
MCQmedium

A technician runs 'mkfs.xfs /dev/sdb1' and later mounts it. The file system is reported as having a block size of 1024 bytes. What is the most likely reason?

A.The administrator used the -b size=1024 option.
B.The block size setting was ignored due to a kernel limitation.
C.The default block size for XFS is 1024 bytes.
D.The partition size is less than 1GB, so mkfs.xfs automatically used a 1024-byte block size.
AnswerD

XFS reduces block size for small file systems to improve space efficiency.

Why this answer

Option D is correct because mkfs.xfs automatically selects a 1024-byte block size when the underlying partition is smaller than 1 GB. This is a built-in heuristic in the XFS filesystem to optimize metadata overhead and space utilization on small volumes. The technician did not specify a block size, so the tool applied this default behavior based on partition size.

Exam trap

Red Hat often tests the misconception that XFS always uses a 4096-byte block size, leading candidates to overlook the automatic block size reduction on small partitions.

How to eliminate wrong answers

Option A is wrong because the technician did not use the -b size=1024 option; the question states the command was run without any block size argument. Option B is wrong because there is no kernel limitation that ignores or overrides the block size setting; the kernel fully supports the specified block size. Option C is wrong because the default block size for XFS is 4096 bytes, not 1024 bytes; the 1024-byte block size is only used automatically for partitions smaller than 1 GB.

28
MCQeasy

A system administrator needs to create a file system on a new 10GB partition /dev/sdb1 for use with a database that requires high reliability and supports snapshots. Which file system type should be chosen?

A.xfs
B.ext4
C.vfat
D.btrfs
AnswerA

XFS is the default file system in RHEL 9, supports snapshots via LVM, and is optimized for large files.

Why this answer

XFS is the correct choice because it is a high-performance, 64-bit journaling file system that supports snapshots via LVM or external tools, and is designed for large files and partitions. For a database requiring high reliability and snapshot capabilities, XFS provides robust data integrity features and is the default file system in Red Hat Enterprise Linux 8 and later, making it the recommended option for this scenario.

Exam trap

The trap here is that candidates may choose btrfs because it natively supports snapshots, but the EX200 exam expects XFS as the default RHEL file system for high-reliability production use, and btrfs is not covered as a standard option in the exam objectives.

How to eliminate wrong answers

Option B (ext4) is wrong because while ext4 is a reliable journaling file system, it does not natively support snapshots; snapshots require LVM or other external mechanisms, and ext4 is less optimized for very large partitions and high-concurrency database workloads compared to XFS. Option C (vfat) is wrong because vfat is a simple, non-journaling file system designed for compatibility with legacy systems and removable media; it lacks journaling, reliability features, and snapshot support, making it unsuitable for a database. Option D (btrfs) is wrong because although btrfs supports snapshots and checksumming, it is not the default file system in RHEL and is considered less mature for production database use; the EX200 exam focuses on XFS as the standard choice for high-reliability scenarios.

29
Multi-Selecteasy

Which TWO commands can be used to create a new directory that will serve as a mount point?

Select 2 answers
A.install -d /mnt/newmount
B.touch /mnt/newmount
C.ln -s /mnt /mnt/newmount
D.mkdir /mnt/newmount
E.ln /mnt /mnt/newmount
AnswersA, D

Creates directory.

Why this answer

Option A is correct because `install -d /mnt/newmount` creates the directory `/mnt/newmount` if it does not already exist, setting it up as a mount point. Option D is correct because `mkdir /mnt/newmount` is the standard command to create a directory, which can then be used as a mount point for a filesystem.

Exam trap

Red Hat often tests the distinction between creating a file (`touch`) and creating a directory (`mkdir` or `install -d`), leading candidates to mistakenly think any new filesystem object can serve as a mount point.

30
MCQmedium

The administrator wants to mount a new filesystem on /dev/sdb1 with the label 'backup' and mount it at /mnt/backup. Which commands achieve this?

A.parted /dev/sdb mkpart primary xfs 0% 100% && mkfs.xfs -L backup /dev/sdb1
B.mkfs.xfs /dev/sdb1 && xfs_admin -L backup /dev/sdb1 && mount -L backup /mnt/backup
C.mkfs.xfs -L backup /dev/sdb1 && mount /dev/sdb1 /mnt/backup
D.mkfs.ext4 -L backup /dev/sdb1 && echo '/dev/sdb1 /mnt/backup ext4 defaults 0 0' >> /etc/fstab
AnswerC

Correct: Creates XFS with label and mounts.

Why this answer

Option C is correct because it first creates an XFS filesystem with the label 'backup' on /dev/sdb1 using mkfs.xfs -L backup, then mounts the device directly to /mnt/backup with mount /dev/sdb1 /mnt/backup. This sequence properly formats the partition and mounts it without requiring additional steps or incorrect commands.

Exam trap

The trap here is that candidates may confuse the need to create a partition first (Option A) or use ext4 (Option D), or they may think that setting a label after mkfs and mounting by label (Option B) is valid, but the correct sequence is to create the filesystem with the label and then mount by device path.

How to eliminate wrong answers

Option A is wrong because parted does not create a filesystem; it only creates a partition, and the mkpart command syntax is incomplete (missing filesystem type and partition type). Option B is wrong because xfs_admin -L backup cannot change the label of an XFS filesystem that is already mounted or without the filesystem being unmounted first, and mount -L backup uses the label but the label hasn't been set correctly before mounting. Option D is wrong because it creates an ext4 filesystem instead of XFS, and while it adds an fstab entry, it does not actually mount the filesystem immediately, failing the requirement to mount it at /mnt/backup.

31
MCQeasy

During boot, a custom application fails because the /data file system is not mounted. Upon investigation, the administrator sees an error 'UUID=abc123 not found' in the logs. Which command should the administrator use to correct the /etc/fstab entry?

A.blkid /dev/sdb1
B.mount -a
C.xfs_info /dev/sdb1
D.fdisk -l /dev/sdb1
E.lsblk -f /dev/sdb1
AnswerA

Correct: displays UUID for use in fstab.

Why this answer

The error 'UUID=abc123 not found' indicates that the /etc/fstab entry for /data references a UUID that does not match any block device. The administrator needs to find the correct UUID of the actual partition (e.g., /dev/sdb1) and update the fstab entry. The `blkid /dev/sdb1` command displays the UUID (and filesystem type) of that specific device, allowing the administrator to copy the correct UUID into /etc/fstab.

Exam trap

Red Hat often tests the distinction between commands that display partition table information (fdisk) versus those that display filesystem metadata (blkid, lsblk -f), and candidates mistakenly choose `fdisk -l` or `lsblk -f` because they see 'UUID' in the output, but `blkid` is the direct, intended tool for retrieving a UUID to fix an fstab entry.

How to eliminate wrong answers

Option B is wrong because `mount -a` attempts to mount all filesystems listed in /etc/fstab, but if the UUID is incorrect, it will fail again — it does not fix the UUID mismatch. Option C is wrong because `xfs_info /dev/sdb1` displays XFS filesystem geometry and superblock details, not the UUID; it is used for tuning or checking XFS metadata, not for retrieving a UUID. Option D is wrong because `fdisk -l /dev/sdb1` shows partition table information (start/end sectors, type) for a specific partition, but it does not display the filesystem UUID; it is a partitioning tool, not a filesystem UUID tool.

Option E is wrong because `lsblk -f /dev/sdb1` lists filesystem information including UUID for all block devices, but it is a listing command; while it could show the UUID, the question asks for the command to 'correct the /etc/fstab entry' — `blkid` is the standard, precise tool for retrieving the UUID of a specific device to use in fstab, whereas `lsblk -f` is more for overview and does not output in a format as directly usable for fstab editing.

32
MCQmedium

An administrator has an XFS filesystem on a logical volume /dev/vg_data/lv_data mounted at /data. To extend the filesystem by 10GB, which sequence of commands is correct?

A.lvextend -L +10G /dev/vg_data/lv_data; resize2fs /dev/vg_data/lv_data
B.xfs_growfs /data; lvextend -L +10G /dev/vg_data/lv_data
C.resize2fs /dev/vg_data/lv_data; lvextend -L +10G /dev/vg_data/lv_data
D.lvextend -L +10G /dev/vg_data/lv_data; xfs_growfs /data
AnswerD

First extend the logical volume, then grow the XFS filesystem.

Why this answer

Option D is correct because for XFS filesystems, the logical volume must be extended first with `lvextend`, then the filesystem must be grown online using `xfs_growfs` with the mount point as the argument. XFS does not support shrinking and requires this specific order; `resize2fs` is only for ext2/3/4 filesystems.

Exam trap

Red Hat often tests the misconception that `resize2fs` works for all filesystem types, or that the order of operations (extend LV vs. grow filesystem) is interchangeable, leading candidates to choose options that use the wrong tool or reverse the sequence.

How to eliminate wrong answers

Option A is wrong because `resize2fs` is used for ext2/3/4 filesystems, not XFS; using it on an XFS filesystem will fail. Option B is wrong because `xfs_growfs` must be run after extending the logical volume, not before; running it first will have no effect since the underlying block device hasn't been enlarged. Option C is wrong because `resize2fs` is incorrect for XFS, and the logical volume must be extended before the filesystem resize operation.

33
MCQmedium

Based on the exhibit, which mount point is mounted with the 'noexec' option?

A./data
B./
C./var
D./tmp
E./boot
AnswerD

Correct: shown as ext4,noexec.

Why this answer

The /tmp mount point is configured with the 'noexec' option, as shown in the exhibit (e.g., in /etc/fstab or the output of mount or findmnt). This prevents execution of binaries directly from the /tmp filesystem, which is a common security hardening practice to mitigate the risk of attackers running malicious scripts or binaries from a world-writable directory.

Exam trap

Red Hat often tests the 'noexec' option on /tmp because candidates may overlook that /tmp is a separate mount point in many Red Hat Enterprise Linux installations, and they might incorrectly assume it inherits the root filesystem's mount options.

How to eliminate wrong answers

Option A is wrong because /data is not listed in the exhibit as having 'noexec'; it likely uses default exec permissions. Option B is wrong because / (root) typically does not have 'noexec' set, as it would break system binaries and scripts. Option C is wrong because /var is usually mounted with default exec permissions to allow services to run scripts or binaries from /var.

Option E is wrong because /boot is mounted without 'noexec' to allow kernel and bootloader updates that require execution of binaries.

34
MCQhard

A technician attempts to mount an XFS filesystem from /dev/sdc1 to /mnt/backup but receives: 'mount: /mnt/backup: mount point does not exist.' The directory /mnt/backup does exist. What is the most likely cause?

A.SELinux context of /mnt/backup prevents mounting.
B.The directory /mnt/backup is not empty.
C.The device /dev/sdc1 does not exist.
D.The filesystem on /dev/sdc1 is not XFS.
AnswerA

SELinux can block mount if context is wrong.

Why this answer

The error message 'mount: /mnt/backup: mount point does not exist' is misleading because the directory does exist. The most likely cause is that SELinux is blocking the mount due to a missing or incorrect context on the mount point. SELinux requires the mount point directory to have a specific context (e.g., `default_t` or a context matching the filesystem type) for the mount to succeed; if the context is wrong or missing, the kernel may treat the directory as nonexistent for the mount operation.

Exam trap

Red Hat often tests the misconception that a mount point must be empty, but the real trap here is that SELinux can cause a 'does not exist' error even when the directory is present, leading candidates to overlook SELinux as the root cause.

How to eliminate wrong answers

Option B is wrong because a non-empty directory can still be used as a mount point; the existing contents are simply hidden while the filesystem is mounted. Option C is wrong because if /dev/sdc1 did not exist, the error would be 'mount: /dev/sdc1: special device does not exist' or similar, not a mount point error. Option D is wrong because if the filesystem were not XFS, the mount command would fail with a 'wrong fs type' or 'superblock invalid' error, not a mount point error.

35
MCQmedium

A system administrator needs to create a file system on /dev/sdb1 with a size of 10 GB and mount it persistently at /data. The file system should support extended attributes and be suitable for large files. Which command sequence achieves this?

A.mkfs.xfs /dev/sda1 && mkdir /data && echo '/dev/sda1 /data xfs defaults 0 0' >> /etc/fstab
B.mkfs.xfs /dev/sdb1 && mkdir /data && mount /dev/sdb1 /data && echo '/dev/sdb1 /data xfs defaults 0 0' >> /etc/fstab
C.mkfs.ext4 /dev/sdb1 && mkdir /data && mount /dev/sdb1 /data && echo '/dev/sdb1 /data ext4 defaults 0 0' >> /etc/fstab
D.mkswap /dev/sdb1 && mkdir /data && swapon /dev/sdb1 && echo '/dev/sdb1 /data swap defaults 0 0' >> /etc/fstab
AnswerB

Correct sequence: creates XFS, mounts, and adds persistent mount.

Why this answer

Option B is correct because it uses mkfs.xfs to create an XFS file system on /dev/sdb1, which supports extended attributes and is optimized for large files. It then creates the mount point /data, mounts the file system, and adds an entry to /etc/fstab for persistent mounting with the correct device, mount point, and file system type.

Exam trap

Red Hat often tests the requirement to mount the file system immediately after creation, not just add it to fstab, and the specific file system type (XFS vs. ext4) based on suitability for large files and extended attributes.

How to eliminate wrong answers

Option A is wrong because it uses /dev/sda1 instead of /dev/sdb1, and it does not mount the file system before adding the fstab entry, which means the mount point will not be active until a reboot. Option C is wrong because it uses mkfs.ext4 to create an ext4 file system; while ext4 supports extended attributes, it is not as suitable for very large files as XFS, and the question specifies a file system suitable for large files. Option D is wrong because mkswap creates a swap area, not a file system, and the fstab entry uses 'swap' as the file system type, which is incorrect for mounting a data directory.

36
Multi-Selecthard

Which TWO LVM commands can be used to reduce the size of a logical volume?

Select 2 answers
A.lvresize
B.lvchange
C.lvreduce
D.lvdisplay
E.lvextend
AnswersA, C

Correct: can reduce or extend.

Why this answer

Both `lvresize` and `lvreduce` can reduce the size of a logical volume. `lvresize` is the general-purpose command for resizing LVs, and when used with the `-L` or `--size` option to specify a smaller size, it shrinks the volume. `lvreduce` is a dedicated command that specifically reduces the size of a logical volume, offering the same functionality as `lvresize --size` but with a more explicit name. Both commands require the filesystem to be shrunk first (if it contains data) using tools like `resize2fs` or `xfs_growfs` (though XFS cannot be shrunk).

Exam trap

The trap here is that candidates often assume only `lvreduce` can shrink a volume, forgetting that `lvresize` is a universal tool that can both increase and decrease size, making both correct answers.

37
MCQmedium

A system administrator needs to extend an existing logical volume 'lv_data' in volume group 'vg_data'. The administrator has already added a new physical volume /dev/sdd1 to the volume group. Which sequence of commands should be used to complete the extension and ensure the filesystem is usable?

A.lvextend -L +10G /dev/vg_data/lv_data; mount /dev/vg_data/lv_data; resize2fs /dev/vg_data/lv_data
B.lvextend -L +10G /dev/vg_data/lv_data; resize2fs /dev/vg_data/lv_data
C.lvextend -L +10G /dev/vg_data/lv_data; mkfs.ext4 /dev/vg_data/lv_data
D.lvresize -L +10G /dev/vg_data/lv_data; fsck /dev/vg_data/lv_data
E.vgextend vg_data /dev/sdd1; lvextend -L +10G /dev/vg_data/lv_data; resize2fs /dev/vg_data/lv_data
AnswerB

Correct: extends the LV and resizes the filesystem.

Why this answer

Option B is correct because after adding a physical volume to the volume group, the logical volume must be extended with `lvextend`, and then the filesystem must be resized with `resize2fs` to use the new space. The filesystem remains mounted and usable throughout; no remount or filesystem recreation is needed.

Exam trap

The trap here is that candidates may think they need to remount the filesystem (Option A) or recreate it (Option C) after extending the logical volume, but in Red Hat Enterprise Linux, `resize2fs` can grow an ext4 filesystem online without unmounting.

How to eliminate wrong answers

Option A is wrong because `mount` is unnecessary and incorrect here — the filesystem is already mounted and does not need to be remounted after extension. Option C is wrong because `mkfs.ext4` would destroy the existing filesystem, not extend it. Option D is wrong because `fsck` checks filesystem integrity but does not resize the filesystem; also `lvresize` alone without `resize2fs` leaves the filesystem unaware of the new space.

Option E is wrong because `vgextend` has already been performed (as stated in the question), so repeating it is redundant and not part of the required sequence.

38
MCQhard

A server has an LVM volume group vg01 with a physical volume /dev/sdb. The administrator wants to move all physical extents from /dev/sdb to /dev/sdd which is also in the same volume group. Which command sequence is correct?

A.pvmove /dev/sdb; vgreduce vg01 /dev/sdb
B.vgreduce vg01 /dev/sdb; pvmove
C.pvmove /dev/sdb; pvremove /dev/sdb
D.pvmove /dev/sdb /dev/sdd
AnswerA

pvmove moves all data off /dev/sdb, then vgreduce removes the PV from the VG.

Why this answer

The correct sequence is to first use `pvmove /dev/sdb` to relocate all physical extents from /dev/sdb to other physical volumes in the same volume group (vg01), and then use `vgreduce vg01 /dev/sdb` to remove the now-empty physical volume from the volume group. This ensures no data loss and that the volume group metadata is properly updated.

Exam trap

The trap here is that candidates often think `pvmove` requires a target PV or that `pvremove` can be used directly after moving extents, but they forget that the PV must first be removed from the VG with `vgreduce` before it can be fully decommissioned.

How to eliminate wrong answers

Option B is wrong because `vgreduce` before `pvmove` would attempt to remove /dev/sdb from the volume group while it still contains data, causing an error or data loss. Option C is wrong because after `pvmove`, the physical volume /dev/sdb is empty but still part of the volume group; `pvremove` would fail because the PV is still in a VG, and it does not remove the PV from the VG metadata. Option D is wrong because `pvmove /dev/sdb /dev/sdd` attempts to move extents directly to a specific target PV, but if /dev/sdd does not have enough free extents, the command will fail; the correct approach is to use `pvmove` without a target to let LVM distribute extents across all available PVs in the VG.

39
MCQhard

Refer to the exhibit. A system administrator wants to add an additional mount option 'noexec' to the /boot filesystem permanently. Which step is necessary before remounting?

A.Run mount -o remount,noexec /boot without editing /etc/fstab
B.Edit /etc/fstab to add 'noexec' to the /boot entry, then run mount -o remount /boot
C.Run umount /boot, edit /etc/fstab to add 'noexec', then mount /boot
D.Edit /etc/fstab to add 'noexec' to the /boot entry, then run mount -a
AnswerB

Correct. This makes the change permanent and applies it.

Why this answer

To add 'noexec' permanently, edit /etc/fstab and add 'noexec' to the options field of the /boot entry (e.g., defaults,noexec). Then remount with 'mount -o remount /boot'.

40
MCQmedium

An admin needs to mount an NFS export from server nfs.example.com:/exports/app to /mnt/app with options for read-only and no root squash. Which command is correct?

A.mount -t nfs -o ro,no_root_squash nfs.example.com:/exports/app /mnt/app
B.mount -t nfs -o ro,root_squash nfs.example.com:/exports/app /mnt/app
C.mount -t nfs -o ro,no_root_squash,nosuid nfs.example.com:/exports/app /mnt/app
D.mount -t nfs -o rw,no_root_squash nfs.example.com:/exports/app /mnt/app
AnswerA

Correct options.

Why this answer

Option A is correct because the `mount -t nfs -o ro,no_root_squash` command mounts the NFS export from `nfs.example.com:/exports/app` to `/mnt/app` as read-only (`ro`) and disables root squash (`no_root_squash`), which allows the root user on the client to retain root privileges when accessing files on the NFS server. The `-t nfs` specifies the NFS filesystem type, and the mount point `/mnt/app` must exist prior to execution.

Exam trap

Red Hat often tests the exact combination of mount options, where candidates mistakenly choose an option with extra flags like `nosuid` or confuse `root_squash` with `no_root_squash`, or select `rw` instead of `ro` when the question explicitly requires read-only.

How to eliminate wrong answers

Option B is wrong because it uses `root_squash` instead of `no_root_squash`, which maps the root user on the client to an anonymous user (typically `nobody`), violating the requirement to disable root squash. Option C is wrong because it includes the `nosuid` option, which is not requested in the question and would block set-user-ID and set-group-ID bits, potentially altering security behavior beyond the specified requirements. Option D is wrong because it uses `rw` (read-write) instead of `ro` (read-only), which directly contradicts the requirement to mount the export as read-only.

41
MCQeasy

A system administrator needs to create an XFS filesystem on /dev/sdb1 with the label 'data'. Which command should be used?

A.mkfs.ext4 -L data /dev/sdb1
B.mkfs.xfs -l data /dev/sdb1
C.xfs_admin -L data /dev/sdb1
D.mkfs.xfs -L data /dev/sdb1
AnswerD

Correct: mkfs.xfs -L sets the label during filesystem creation.

Why this answer

Option D is correct because the `mkfs.xfs` command creates an XFS filesystem, and the `-L` flag assigns a label to the filesystem during creation. The command `mkfs.xfs -L data /dev/sdb1` correctly creates an XFS filesystem on the specified partition with the label 'data'.

Exam trap

The trap here is confusing the lowercase `-l` (used for log parameters in mkfs.xfs) with the uppercase `-L` (used for labels), or thinking that `xfs_admin` can create a filesystem when it only modifies existing ones.

How to eliminate wrong answers

Option A is wrong because `mkfs.ext4` creates an ext4 filesystem, not XFS, and the `-L` flag is used for labels on ext4, but the question specifically requires an XFS filesystem. Option B is wrong because `mkfs.xfs -l data /dev/sdb1` uses a lowercase `-l`, which in mkfs.xfs is used to specify the log section parameters (e.g., log size or device), not the filesystem label; the correct flag for a label is uppercase `-L`. Option C is wrong because `xfs_admin` is used to change parameters of an existing XFS filesystem (like the label or UUID), not to create a new one; it cannot be used to create a filesystem.

42
MCQhard

An administrator wants to enable user disk quotas on an XFS filesystem mounted at /home. Which steps are required?

A.Add 'usrquota' to /etc/fstab, remount, then run quotacheck and edquota
B.Quotas are not supported on XFS filesystems
C.Use mount -o uquota /home, then setquota -u user1 500M 1G /home
D.Add 'uquota' to /etc/fstab, remount, then run xfs_quota -x -c 'limit -u bsoft=500m bhard=1g user1' /home
AnswerD

Correct: XFS uses uquota option and xfs_quota command.

Why this answer

Option D is correct because XFS uses its own quota management tools, not the traditional `quotacheck`/`edquota` tools used by ext4. The correct procedure is to add the `uquota` mount option to `/etc/fstab`, remount the filesystem, and then use `xfs_quota` to set limits. The `xfs_quota` command with the `-x` (expert) flag and `-c` (command) flag allows setting user quotas directly, and the path `/home` specifies the filesystem.

Exam trap

The trap here is that candidates familiar with ext4 quotas assume the same `quotacheck`/`edquota` workflow applies to XFS, but Red Hat EX200 expects knowledge of XFS-specific tools like `xfs_quota` and the `uquota` mount option.

How to eliminate wrong answers

Option A is wrong because `quotacheck` and `edquota` are tools for ext2/ext3/ext4 filesystems, not XFS; XFS manages quotas internally and does not require a separate `quotacheck` step. Option B is wrong because XFS fully supports user and group quotas via the `uquota`/`gquota` mount options and the `xfs_quota` utility. Option C is wrong because `mount -o uquota /home` only enables quota accounting but does not set any limits; additionally, `setquota` is an ext4 command and is not used with XFS.

43
MCQmedium

An IT department runs a web server that stores user uploads on an ext4 filesystem on /dev/sdb1 mounted at /uploads. Recently, the partition has run out of space. The administrator checks with df -h and sees 100% usage. However, du -sh /uploads shows only 2GB used. The administrator suspects deleted files still held open by processes. Which command should be used to identify and resolve the issue?

A.rm -rf /uploads/* to clean all files
B.fsck /dev/sdb1 to repair filesystem
C.resize2fs /dev/sdb1 to shrink filesystem
D.lsof +L1 /uploads to find deleted open files, then kill processes
AnswerD

Identifies deleted files still in use; killing processes releases space.

Why this answer

Option D is correct because the discrepancy between `df -h` showing 100% usage and `du -sh /uploads` showing only 2GB indicates that deleted files are still held open by running processes. The `lsof +L1 /uploads` command lists files with a link count of zero (deleted but still open), and killing the associated processes releases the disk space. This is a classic scenario on ext4 filesystems where file descriptors prevent space reclamation until the process closes the file.

Exam trap

Red Hat often tests the misconception that `rm` or filesystem repair tools can recover space from deleted-but-open files, when in fact only closing the file descriptor (by killing the process) releases the blocks.

How to eliminate wrong answers

Option A is wrong because `rm -rf /uploads/*` would attempt to remove files that are already deleted (unlinked) and thus cannot free the space held by open file descriptors; it may also delete active uploads. Option B is wrong because `fsck` checks and repairs filesystem metadata, but the filesystem is not corrupted—the issue is with in-use file handles, not structural damage. Option C is wrong because `resize2fs` resizes the filesystem, but shrinking it would not recover space from deleted-but-open files and could cause data loss if the filesystem is full.

44
MCQmedium

The administrator wants to remount /mnt/data with the noexec option. Which command is correct?

A.Edit /etc/fstab to add noexec and reboot
B.mount -o remount,noexec /dev/sdb1 /mnt/data
C.umount /mnt/data && mount -o noexec /dev/sdb1 /mnt/data
D.mount -o remount,noexec /mnt/data
AnswerD

Correct: remounts with additional option noexec.

Why this answer

Option D is correct because the `mount -o remount,noexec /mnt/data` command changes the mount options of an already mounted filesystem without needing to unmount it first. The `remount` option applies the new `noexec` flag to the existing mount point, preventing execution of binaries on that filesystem. This is the standard and safest way to modify mount options on a live system.

Exam trap

Red Hat often tests the distinction between `remount` (which modifies options on a live mount) and the incorrect habit of specifying the device name with `remount`, leading candidates to choose Option B because they think the device must be included.

How to eliminate wrong answers

Option A is wrong because editing `/etc/fstab` and rebooting is unnecessarily disruptive; the `remount` option exists to apply changes without a reboot. Option B is wrong because the syntax `mount -o remount,noexec /dev/sdb1 /mnt/data` includes the device name, which is not required with `remount` and can cause the command to fail if the device is busy or if the mount point is not uniquely associated with that device; the correct syntax omits the device. Option C is wrong because unmounting and remounting is an extra step that can fail if the filesystem is in use, whereas `remount` avoids this risk by modifying options in place.

45
MCQeasy

An administrator is configuring an NFS mount in /etc/fstab to mount from server:/export to /mnt/data. The mount must use the 'hard' and 'nosuid' options. Which line is correct?

A.server:/export /mnt/data nfs defaults,noexec,nodev 0 0
B.server:/export /mnt/data nfs nosuid,hard,defaults 0 0
C.server:/export /mnt/data ext4 defaults 0 0
D.server:/export /mnt/data nfs suid,soft 0 0
E.server:/export /mnt/data nfs nosuid,hard 0 0
AnswerE

Correct: specifies required options.

Why this answer

Option E is correct because it specifies the NFS filesystem type and includes both required mount options: 'nosuid' (disallows set-user-identifier/set-group-identifier bits) and 'hard' (retries NFS requests indefinitely until the server responds). The syntax follows the correct /etc/fstab format: <server>:/<export> <mountpoint> <fstype> <options> <dump> <pass>.

Exam trap

Red Hat often tests the misconception that 'defaults' can be combined with other options without conflict, but in reality 'defaults' includes 'suid', which directly contradicts the required 'nosuid' option.

How to eliminate wrong answers

Option A is wrong because it uses 'noexec' and 'nodev' instead of the required 'nosuid' and 'hard' options, and it omits 'hard' entirely. Option B is wrong because it includes 'defaults' after 'nosuid,hard', which is redundant and may cause unexpected behavior (defaults includes 'suid', conflicting with 'nosuid'). Option C is wrong because it specifies 'ext4' as the filesystem type, which is incorrect for an NFS mount.

Option D is wrong because it uses 'suid' (the opposite of the required 'nosuid') and 'soft' (which can cause silent data corruption on NFS timeouts) instead of 'hard'.

46
MCQhard

Refer to the exhibit. The filesystem /var/www/html is mounted, but after a reboot, the directory is empty. What is the most likely cause?

A.The filesystem type is incorrectly specified as ext4 in fstab
B.The mount point /var/www/html does not exist after reboot
C.The device path /dev/vg_data/lv_web is not persistent across reboots
D.The logical volume is not activated at boot because the volume group is not set to auto-activate
AnswerD

Correct. If the VG is not auto-activated, the LV device is not available, causing mount to fail at boot.

Why this answer

The /etc/fstab entry uses /dev/vg_data/lv_web, which is a device mapper path. If the logical volume is not activated before the mount, it may not be available. However, the most common issue is that the filesystem is mounted but the content is missing because the mount point is overlaid by another filesystem or the content is on a different logical volume.

Actually, the exhibit shows a fresh filesystem with no data. If after reboot it's empty, it means the filesystem is mounted correctly but the data is not persistent? Wait, the filesystem was just created, so it's empty. The question might be that the administrator expected data to be there? Let me adjust: The exhibit shows creating and mounting, then fstab entry.

After reboot, the directory is empty. The most likely cause is that the logical volume is not activated at boot because the volume group is not automatically activated. In Red Hat, by default, volume groups are activated at boot.

But if the VG is on a remote storage or if there is a delay, it might not be available. However, a common issue is that the fstab entry uses the device mapper path but the system may use different names. Actually, the correct answer is that the filesystem is not mounted at boot because the mount point is not created? No, /var/www/html exists.

Another possibility: the fstab entry uses the device path but the device is not available at the time of mounting. The most likely cause is that the logical volume is not activated before the mount. In systemd, there is a dependency.

But perhaps the simpler answer is that the filesystem type is ext4 but the kernel module is not loaded? Unlikely. Let me think of a typical EX200 scenario: After creating a filesystem and adding to fstab, the system may not mount it at boot if the mount point is used by another filesystem or if there is a UUID conflict. However, the exhibit uses device path, not UUID.

The issue might be that the mount point /var/www/html is a directory that already contains files from a previous mount? But the filesystem is new, so empty. After reboot, the directory is empty because the new filesystem is mounted, but the old data (if any) is hidden. But the question says "the directory is empty", implying it should have data.

Perhaps the administrator expected data from a previous filesystem? The exhibit only shows creation of a new filesystem. So the most likely cause is that the filesystem was created but no data was copied. That seems too trivial.

Let me change the stem: After reboot, the mount fails and the directory is empty. The most likely cause is that the logical volume is not activated. But the exhibit shows the mount command worked.

After reboot, if the LV is not activated, the mount fails, and the directory would be empty (since it's a regular directory). So the correct answer is that the volume group is not auto-activated. However, in Red Hat, by default, volume groups are activated.

To make it not activate, you would set auto_activation_volume_list. But that's advanced. Perhaps the answer is that the fstab entry uses the wrong device path because the LV name changed? LVM names are persistent.

Another common issue: the fstab entry uses /dev/vg_data/lv_web but the system may use /dev/mapper/vg_data-lv_web. Both are acceptable. I think the most plausible is that the volume group is not activated at boot.

Let me craft options accordingly.

47
Multi-Selecthard

Which THREE of the following are valid options for mounting an ext4 filesystem with specific mount options in /etc/fstab?

Select 3 answers
A.noexec
B.relatime
C.noatime
D.suid
E.nodev
AnswersA, C, E

Valid mount option.

Why this answer

The `noexec` option prevents execution of binaries on the mounted filesystem, which is a common security hardening measure. It is a valid mount option for ext4 and can be specified in /etc/fstab.

Exam trap

Red Hat often tests the distinction between options that enable a feature (like suid) versus those that disable it (like nosuid), and candidates may confuse valid options with the ones that are actually correct in a multi-select question.

48
MCQeasy

An administrator needs to enable swap on a newly created partition /dev/sdc1. Which two commands should be executed in order?

A.mkswap /dev/sdc1; mount /dev/sdc1
B.swapon /dev/sdc1; mkswap /dev/sdc1
C.swapon /dev/sdc1; mount /dev/sdc1
D.mkfs.swap /dev/sdc1; swapon /dev/sdc1
E.mkswap /dev/sdc1; swapon /dev/sdc1
AnswerE

Correct: formats then activates swap.

Why this answer

Option E is correct because enabling swap on a new partition requires first formatting it as swap space with `mkswap`, then activating it with `swapon`. The `mkswap` command writes a swap signature to the partition, and `swapon` enables the kernel to use it as swap. Without `mkswap`, the partition lacks the proper swap filesystem structure and cannot be used for swapping.

Exam trap

The trap here is that candidates confuse the order of operations or mistakenly think `mount` can be used for swap, or that `mkfs.swap` is a valid command, when in fact swap requires `mkswap` followed by `swapon` and never uses `mount`.

How to eliminate wrong answers

Option A is wrong because `mount` cannot mount a swap partition; swap is not a regular filesystem and must be activated with `swapon`, not mounted. Option B is wrong because `swapon` is executed before `mkswap`, which fails since the partition has no swap signature yet; the order must be reversed. Option C is wrong because `swapon` on an unformatted partition fails, and `mount` is invalid for swap.

Option D is wrong because `mkfs.swap` is not a valid command; the correct command to create a swap filesystem is `mkswap`.

49
Multi-Selecteasy

Which TWO commands can mount an ISO file /tmp/rhel.iso to /mnt/iso?

Select 2 answers
A.mount -o loop /tmp/rhel.iso /mnt/iso
B.isomount /tmp/rhel.iso /mnt/iso
C.mount -t iso9660 -o loop /tmp/rhel.iso /mnt/iso
D.losetup /tmp/rhel.iso && mount /dev/loop0 /mnt/iso
E.mount /tmp/rhel.iso /mnt/iso
AnswersA, C

Correct: mount with -o loop automatically sets up a loop device.

Why this answer

Option A is correct because the `mount -o loop` command creates a loop device to access the ISO file as a block device, allowing it to be mounted to /mnt/iso. This is the standard method for mounting ISO files without specifying a filesystem type, as the kernel auto-detects iso9660.

Exam trap

The trap here is that candidates may think `mount` can directly handle a file without the loop option (Option E), or they may confuse `losetup` syntax (Option D) with the correct procedure, leading to errors in a real exam scenario.

50
Multi-Selecthard

Which TWO commands are valid for resizing an XFS file system? (Choose exactly two.)

Select 2 answers
A.xfs_admin -L /mnt
B.xfs_growfs /mnt
C.resize2fs /dev/sda1
D.xfs_growfs -D 10g /mnt
E.xfs_repair /dev/sda1
AnswersB, D

Grows the file system to the maximum available space.

Why this answer

Option B is correct because `xfs_growfs` is the dedicated command for resizing (growing) an XFS file system while it is mounted. It expands the file system to fill the available space in the underlying device or logical volume, making it the primary tool for XFS resizing operations.

Exam trap

Red Hat often tests the distinction between file system-specific tools, so the trap here is that candidates confuse `resize2fs` (for ext4) with `xfs_growfs` (for XFS), or mistakenly think `xfs_admin` can resize the file system when it only manages labels and UUIDs.

51
Multi-Selectmedium

Which TWO of the following are required to create an XFS file system on LVM?

Select 2 answers
A.Create a volume group
B.Create a physical volume
C.Run xfs_admin on the LV
D.Run mkfs.xfs on the LV
E.Create a logical volume
AnswersD, E

mkfs.xfs creates the file system on the LV.

Why this answer

D is correct because the `mkfs.xfs` command is used to create an XFS file system on a block device, such as a logical volume (LV). After the LV is created from a volume group, you must format it with a file system before it can be mounted and used. Without running `mkfs.xfs`, the LV has no file system structure.

Exam trap

Red Hat often tests the distinction between file system creation (`mkfs.xfs`) and file system administration (`xfs_admin`), trapping candidates who confuse the two commands or think that creating the LV alone is sufficient for mounting.

52
MCQhard

The administrator attempts to run 'xfs_growfs /dev/vg00/lvol1' but receives an error. What is the most likely cause?

A.The file system is not XFS
B.Unmet dependencies
C.The volume group is full
D.The logical volume is not mounted
AnswerD

xfs_growfs requires the file system to be mounted. The attribute for lvol1 does not include 'o', indicating it is not open (mounted).

Why this answer

The `xfs_growfs` command requires the XFS filesystem to be mounted in order to resize it. If the logical volume `/dev/vg00/lvol1` is not mounted, the kernel cannot access the filesystem's superblock and allocation group information, causing the command to fail with an error such as 'XFS filesystem not mounted' or 'No such file or directory'.

Exam trap

The trap here is that candidates often assume `xfs_growfs` works like `resize2fs` for ext4, which can resize unmounted filesystems, but XFS requires the filesystem to be mounted for online growth, and the error message may be misinterpreted as a missing package or wrong filesystem type.

How to eliminate wrong answers

Option A is wrong because the command `xfs_growfs` is specifically designed for XFS filesystems; if the filesystem were not XFS, the error would typically be 'wrong fs type' or the command would not be found, but the question states the command runs and receives an error, implying the filesystem is XFS. Option B is wrong because `xfs_growfs` is a standalone utility from the `xfsprogs` package and does not have runtime dependencies that would cause a failure during execution; unmet dependencies would prevent installation, not command execution. Option C is wrong because a full volume group would prevent extending the logical volume, but `xfs_growfs` only resizes the filesystem to match the already-extended logical volume; the error occurs before any resize attempt, and the volume group's free space is irrelevant if the logical volume itself is not mounted.

53
MCQhard

After adding the last line to /etc/fstab, the system fails to boot with an error. What is the most likely cause?

A.The UUID for /boot is invalid
B.The mount point /mydata does not exist
C.The device /dev/sdb1 is not formatted
D.The filesystem type ext4 is incorrect for /dev/sdb1
AnswerB

The exhibit shows the mount point /mydata, and it is explicitly stated that this directory does not exist. Systemd will fail to mount.

Why this answer

When a mount point directory specified in /etc/fstab does not exist, the systemd mount unit will fail during boot because the mount operation cannot find the target directory. This is a common misconfiguration: the fstab entry references /mydata, but the directory has not been created with mkdir. The boot process halts with an error indicating the mount point is missing, not that the device or filesystem is invalid.

Exam trap

The trap here is that candidates often focus on device or filesystem issues (UUID, formatting, type) and overlook the simple prerequisite that the mount point directory must exist, which is a fundamental step tested in the EX200.

How to eliminate wrong answers

Option A is wrong because an invalid UUID for /boot would cause a different error (e.g., 'UUID=... does not exist') and would prevent the root filesystem from mounting, not specifically a missing mount point error. Option C is wrong because an unformatted device would produce a 'wrong fs type, bad option, bad superblock' error, not a 'mount point does not exist' error. Option D is wrong because an incorrect filesystem type (e.g., ext4 on an XFS partition) would also yield a 'wrong fs type' error, not a missing directory error.

54
MCQhard

A system has two 500GB disks in a RAID1 (mirror) using mdadm. One disk fails. After replacement, what is the correct procedure to restore redundancy?

A.Run 'mdadm --manage /dev/md0 --add /dev/sdb'
B.Remove the failed disk with 'mdadm /dev/md0 --fail /dev/sdb1' then add new.
C.Run 'mdadm --assemble --scan' to rebuild the array automatically.
D.Use sfdisk to copy partition table from /dev/sda to /dev/sdb, then 'mdadm --manage /dev/md0 --add /dev/sdb1'
AnswerD

Correct steps.

Why this answer

Option D is correct because when replacing a failed disk in a RAID1 array managed by mdadm, the new disk must have a partition table that matches the surviving disk. Using sfdisk to copy the partition table from /dev/sda to /dev/sdb ensures that the partition layout (e.g., partition type 0xFD for Linux RAID autodetect) is identical, which is required before adding the partition (e.g., /dev/sdb1) to the array with mdadm --manage --add. Simply adding the raw disk without a proper partition table would fail because mdadm expects a partition with the correct RAID superblock and partition type.

Exam trap

The trap here is that candidates assume adding a new disk directly with 'mdadm --add' is sufficient, overlooking the critical prerequisite of having an identical partition table on the replacement disk, which is a common oversight in RAID recovery procedures.

How to eliminate wrong answers

Option A is wrong because 'mdadm --manage /dev/md0 --add /dev/sdb' attempts to add the entire disk device, but mdadm requires a partition (e.g., /dev/sdb1) that has a valid partition table and RAID superblock; adding a raw disk without a partition table will not work and may corrupt the array. Option B is wrong because 'mdadm /dev/md0 --fail /dev/sdb1' is used to mark an existing device as failed, but the question states the disk has already failed; the failed device should be removed with 'mdadm --remove' after marking it failed, and the new disk still needs a partition table before adding, which this option omits. Option C is wrong because 'mdadm --assemble --scan' is used to reassemble an existing array from its components after a system reboot or if the array is stopped, not to add a replacement disk to an already active array; it does not handle the partition table requirement for a new disk.

55
MCQeasy

A system administrator needs to create a new ext4 filesystem on /dev/sdb1 and mount it persistently at /data. Which set of commands should be used?

A.mkfs -t ext4 /dev/sdb1 && mkdir /data && mount /dev/sdb1 /data && echo '/dev/sdb1 /data ext4 defaults 0 0' >> /etc/fstab
B.mkfs.ext4 /dev/sdb1 && mount /dev/sdb1 /data
C.mkfs -t ext4 /dev/sdb1 && echo '/dev/sdb1 /data ext4 defaults 0 0' >> /etc/fstab && mount /data
D.mkfs.ext4 /dev/sdb1 && mkdir /data && mount /dev/sdb1 /data && blkid /dev/sdb1 >> /etc/fstab
AnswerA

Complete sequence.

Why this answer

Option A is correct because it creates the ext4 filesystem with `mkfs -t ext4 /dev/sdb1`, creates the mount point directory with `mkdir /data`, mounts the filesystem immediately with `mount /dev/sdb1 /data`, and then adds an entry to `/etc/fstab` using the correct format (device, mount point, filesystem type, options, dump, pass) to ensure the mount persists across reboots. The `&&` operator ensures each command only runs if the previous one succeeds, which is a safe practice for scripting this task.

Exam trap

The trap here is that candidates often forget to create the mount point directory or attempt to use `blkid` output directly in fstab, assuming it will work, when in fact the fstab file requires a specific columnar format with the device, mount point, filesystem type, options, dump, and pass fields.

How to eliminate wrong answers

Option B is wrong because it does not create the mount point directory (`/data`) before mounting, which will cause the mount command to fail if `/data` does not already exist, and it does not add an entry to `/etc/fstab`, so the mount is not persistent. Option C is wrong because it attempts to mount using `mount /data` without specifying the device, which is invalid syntax; the mount command requires either a device or an existing fstab entry to reference, and the fstab entry is added after the mount command in this sequence, so the mount would fail. Option D is wrong because it uses `blkid /dev/sdb1 >> /etc/fstab` to append the output of blkid (which includes the UUID and filesystem type in a non-fstab format) instead of a properly formatted fstab line; this would corrupt /etc/fstab and not result in a persistent mount.

56
Multi-Selecthard

Which THREE commands are required to create a logical volume named lv_data of size 10G in volume group vg_data, format it as XFS, and mount it at /mnt/data?

Select 3 answers
A.vgcreate vg_data /dev/sde1
B.lvcreate -L 10G -n lv_data vg_data
C.mount /dev/vg_data/lv_data /mnt/data
D.pvcreate /dev/sde1
E.mkfs.xfs /dev/vg_data/lv_data
AnswersB, C, E

Correct: Creates the logical volume.

Why this answer

Option B is correct because the `lvcreate -L 10G -n lv_data vg_data` command creates a logical volume named lv_data with a size of 10 GB within the volume group vg_data. This is the standard LVM command for creating logical volumes, where `-L` specifies the size and `-n` specifies the name.

Exam trap

The trap here is that candidates often include `pvcreate` and `vgcreate` as required steps, but the question specifies that the volume group vg_data already exists, so only the LV creation, formatting, and mounting commands are needed.

57
MCQeasy

The administrator wants to create a new ext4 file system on /dev/sdb1 with a block size of 1024 bytes. Which command should be used?

A.mkfs.ext4 -b 1024 /dev/sdb1
B.mkfs.ext4 -B 1024 /dev/sdb1
C.mkfs.ext4 -s 1024 /dev/sdb1
D.mkfs.ext4 --block-size 1024 /dev/sdb1
AnswerA

The -b option sets the block size to 1024 bytes.

Why this answer

Option A is correct because the `-b` flag in `mkfs.ext4` specifies the block size in bytes. To create an ext4 filesystem with 1024-byte blocks on /dev/sdb1, the command `mkfs.ext4 -b 1024 /dev/sdb1` is used. This is the standard syntax for setting the logical block size when formatting an ext4 filesystem.

Exam trap

The trap here is that candidates confuse the `-b` flag with other common flags like `-B` (used by XFS) or `-s` (used for stride), or assume GNU-style long options like `--block-size` are supported by `mkfs.ext4` when they are not.

How to eliminate wrong answers

Option B is wrong because `-B` is not a valid flag for `mkfs.ext4`; it is used by `mkfs.xfs` to specify block size, but for ext4 the correct flag is lowercase `-b`. Option C is wrong because `-s` in `mkfs.ext4` is used to specify the number of bytes per inode (stride), not the block size. Option D is wrong because `--block-size` is not a recognized long option for `mkfs.ext4`; the utility does not support GNU-style long options for block size, only the short `-b` flag.

58
MCQhard

A logical volume 'lv_share' in volume group 'vg_share' has no free extents. The administrator needs to increase the size of '/dev/vg_share/lv_share' by 5 GB. There is another logical volume 'lv_archive' in the same volume group that has 10 GB free space within its filesystem. What must the administrator do to allocate space from 'lv_archive' to 'lv_share'?

A.Reduce the filesystem on 'lv_archive' with resize2fs, then reduce the logical volume with lvreduce, then extend 'lv_share'.
B.Shrink the filesystem on 'lv_archive' to free space, then use vgsplit to move the space to 'lv_share'.
C.Use lvreduce directly on 'lv_archive' without changing the filesystem, then lvextend on 'lv_share'.
D.Use lvresize to reduce 'lv_archive' and extend 'lv_share' in one command.
E.Add a new physical volume to the volume group instead.
AnswerA

Correct: shrinks filesystem and LV, then extends target LV.

Why this answer

Option A is correct because you must first shrink the filesystem on 'lv_archive' using resize2fs (or e2fsck -f / resize2fs) to free space within the filesystem, then reduce the logical volume with lvreduce to release the underlying physical extents back to the volume group. Only after those steps can you extend 'lv_share' with lvextend and then resize its filesystem. This sequence ensures data integrity and avoids filesystem corruption.

Exam trap

Red Hat often tests the misconception that you can reduce a logical volume without first shrinking the filesystem, leading candidates to choose option C, but the correct sequence always requires filesystem resizing before LV reduction to prevent corruption.

How to eliminate wrong answers

Option B is wrong because vgsplit is used to move entire physical volumes between volume groups, not to reallocate free space within the same volume group; it would break the volume group structure. Option C is wrong because using lvreduce directly on 'lv_archive' without first shrinking the filesystem will corrupt the filesystem, as the logical volume shrink truncates the block device before the filesystem is aware. Option D is wrong because lvresize cannot simultaneously reduce one LV and extend another in a single command; it operates on one logical volume at a time.

Option E is wrong because adding a new physical volume does not utilize the existing free space within 'lv_archive' and is unnecessary when space can be reclaimed from the same volume group.

59
MCQeasy

An administrator wants to ensure that a file system is automatically mounted at boot. Which file should be edited?

A./etc/rc.local
B./etc/fstab
C./boot/grub2/grub.cfg
D./etc/mtab
AnswerB

/etc/fstab is the file system table that defines how and where file systems are mounted at boot.

Why this answer

The /etc/fstab file is the standard configuration file that defines how disk partitions, block devices, and remote filesystems should be mounted into the filesystem tree, including options for automatic mounting at boot time. The system reads this file during the boot process (via systemd or the traditional mount -a command) to mount all filesystems listed with the 'auto' or nofail option.

Exam trap

Red Hat often tests the distinction between configuration files (/etc/fstab) and runtime or bootloader files, leading candidates to mistakenly choose /etc/rc.local or /boot/grub2/grub.cfg because they associate 'boot' with bootloader or startup scripts.

How to eliminate wrong answers

Option A is wrong because /etc/rc.local is a legacy script executed at the end of the boot process, not a configuration file for automatic filesystem mounting; it is not designed for managing mount points and is often empty or disabled on modern Red Hat systems. Option C is wrong because /boot/grub2/grub.cfg is the GRUB2 bootloader configuration file that controls the kernel and initramfs selection, not filesystem mounting; editing it would not affect mount behavior. Option D is wrong because /etc/mtab is a dynamically updated file that lists currently mounted filesystems, maintained by the kernel or mount command; it is not a configuration file and changes to it are not persistent across reboots.

60
MCQmedium

Refer to the exhibit. An administrator extends an XFS filesystem on /data. Which prerequisite step is missing from the output?

A.The filesystem must be mounted before xfs_growfs
B.The filesystem must be checked with xfs_repair before growing
C.The filesystem must be unmounted before xfs_growfs
D.The logical volume must be deactivated before xfs_growfs
AnswerA

Correct. xfs_growfs requires the filesystem to be mounted (or at least the device to be accessible, but typically mounted).

Why this answer

The output shows vgextend and lvextend, then xfs_growfs. However, after lvextend, the filesystem must be notified. For XFS, xfs_growfs is the correct tool, but the output does not show that the underlying block device (the LV) was resized first (which it was via lvextend).

Actually, lvextend resizes the LV, and xfs_growfs resizes the filesystem. The missing step is resizing the filesystem? No, xfs_growfs is present. The question likely expects that the filesystem must be mounted for xfs_growfs to work.

But the output shows it worked. Alternatively, the prerequisite is that the LV must be extended before xfs_growfs, which is shown. Perhaps the missing step is that the filesystem should be unmounted? No, xfs_growfs can be run on a mounted filesystem.

Actually, the exhibit is complete; maybe the missing step is that the partition (sdb3) must be added to the VG, which is done via vgextend. The question might be misaligned. Let me adjust: The exhibit shows extending the LV and then growing the filesystem.

The missing step is that the filesystem must be mounted? But it is mounted at /data. The output shows xfs_growfs /data, which works on mounted. So perhaps the missing step is that the partition (sdb3) must be created first? The exhibit shows vgextend /dev/sdb3, implying sdb3 already exists.

Actually, the question should be about resizing an XFS filesystem after extending the LV. The prerequisite is that the filesystem must be mounted (or at least the device must be accessible). But the output shows it's mounted.

Let me rephrase the stem to be more specific.

61
MCQmedium

After adding a new disk /dev/sdc, a system administrator wants to mount it persistently at /mnt/backup. Which entry in /etc/fstab is most reliable?

A.LABEL=data /mnt/backup xfs defaults 0 0
B.PARTUUID=def456... /mnt/backup xfs defaults 0 0
C./dev/sdc /mnt/backup xfs defaults 0 0
D.UUID=abc123... /mnt/backup xfs defaults 0 0
AnswerD

Correct: UUID uniquely identifies the filesystem.

Why this answer

Option D is correct because using the UUID (Universally Unique Identifier) ensures the filesystem is mounted persistently regardless of device name changes (e.g., /dev/sdc could become /dev/sdd after a reboot or disk addition). The UUID is generated when the filesystem is created and remains constant, making it the most reliable method for persistent mounts in /etc/fstab.

Exam trap

Red Hat often tests the misconception that device names like /dev/sdc are stable, but the trap here is that device names can change after reboots or hardware changes, while UUIDs remain constant and are the recommended method for persistent mounts in /etc/fstab.

How to eliminate wrong answers

Option A is wrong because it uses a LABEL, which is not set by default on a new disk; if the label 'data' does not exist on /dev/sdc, the mount will fail, and labels can be accidentally duplicated or changed. Option B is wrong because PARTUUID identifies the partition table entry, not the filesystem itself; it is used for partition identification (e.g., with GPT) and does not guarantee the filesystem is present or consistent. Option C is wrong because /dev/sdc is a device name that can change dynamically (e.g., after a reboot or adding other disks), leading to mount failures or mounting the wrong device.

62
Drag & Dropmedium

Put the steps to configure a cron job that runs a script every day at 2:30 AM in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order

Why this order

Cron jobs are added by editing crontab and specifying the schedule and command.

63
MCQhard

What is the most likely cause of the mount error?

A.The entry in /etc/fstab is malformed.
B.The NFS server IP address is unreachable or the nfs-utils package is not installed.
C.The filesystem type 'nfs4' is incorrect; should be 'nfs'.
D.The mount point /mnt/data does not exist.
AnswerB

Most common cause of mount failure.

Why this answer

The mount error is most likely caused by the NFS server being unreachable or the nfs-utils package not being installed. Without the nfs-utils package, the system lacks the necessary NFS client tools (e.g., mount.nfs, rpcbind) to mount NFS shares. If the server IP is unreachable, the mount command will fail with a timeout or 'No route to host' error, which is a common issue when network connectivity or NFS services are not properly configured.

Exam trap

Red Hat often tests the misconception that a mount error is always due to a syntax error in /etc/fstab or a missing mount point, when in fact the root cause is often a missing client package or network connectivity issue.

How to eliminate wrong answers

Option A is wrong because a malformed /etc/fstab entry would typically cause a mount failure at boot or with 'mount -a', but the question describes a mount error that is most likely due to a missing package or network issue, not a syntax problem in fstab. Option C is wrong because 'nfs4' is a valid filesystem type for NFSv4 mounts; using 'nfs' instead would default to NFSv3, but both are acceptable and would not cause a mount error by themselves. Option D is wrong because if the mount point /mnt/data did not exist, the error message would explicitly state 'mount point does not exist', which is a different and less likely scenario than the one described.

64
Multi-Selecthard

Which three of the following actions are required when adding a new swap device to the system? (Choose three.)

Select 3 answers
A.Mount the device to a swap directory
B.Create a filesystem using mkfs
C.Use mkswap to set up the swap signature
D.Use swapon to activate swap
E.Add an entry in /etc/fstab with the swap option
AnswersC, D, E

mkswap initializes the device for use as swap.

Why this answer

Option C is correct because `mkswap` writes a swap signature (UUID and label) to the device, which is required before the kernel can use it as swap space. Without this signature, the device is not recognized as a swap area.

Exam trap

Red Hat often tests the misconception that swap devices must be mounted or formatted with a filesystem, leading candidates to incorrectly select options A or B.

65
Multi-Selecthard

Which TWO of the following are valid mount options for enabling quotas on an ext4 file system?

Select 2 answers
A.grpquota
B.quota
C.userquota
D.noquota
E.usrquota
AnswersA, E

grpquota enables per-group quotas on ext4.

Why this answer

Option A is correct because `grpquota` is a valid mount option for enabling group quotas on an ext4 file system. Option E is correct because `usrquota` is the valid mount option for enabling user quotas. Both options are recognized by the `mount` command and the ext4 driver to activate quota tracking at mount time.

Exam trap

The trap here is that candidates confuse the generic `quota` command with a mount option, or misremember the exact option names (e.g., `userquota` instead of `usrquota`), leading them to select incorrect options like `quota` or `userquota`.

66
MCQeasy

A system administrator needs to verify that the filesystem on /dev/sdb1 is ext4 before adding it to /etc/fstab. Which command provides this information?

A.mount -a
B.df -Th /dev/sdb1
C.fdisk -l /dev/sdb1
D.lsblk -f /dev/sdb1
AnswerD

lsblk -f displays filesystem type, UUID, and mount point.

Why this answer

The `lsblk -f /dev/sdb1` command displays the filesystem type (FSTYPE) for the specified block device, such as ext4. This is the most direct and reliable way to verify the filesystem on a specific partition before adding it to /etc/fstab.

Exam trap

The trap here is that candidates often choose `df -Th` because it shows filesystem type, but they forget that it only works on mounted filesystems, whereas `lsblk -f` works on unmounted devices as well.

How to eliminate wrong answers

Option A is wrong because `mount -a` mounts all filesystems listed in /etc/fstab that are not already mounted; it does not display filesystem type information. Option B is wrong because `df -Th /dev/sdb1` shows the filesystem type of mounted filesystems, but if /dev/sdb1 is not mounted, it will not show the type or may produce an error. Option C is wrong because `fdisk -l /dev/sdb1` displays partition table information (size, type, start/end sectors) but does not show the filesystem type (e.g., ext4) — it only shows the partition type ID (e.g., 83 for Linux).

67
MCQmedium

A file server is experiencing slow write performance. The admin suspects the filesystem is nearly full. Which command should be used to check disk usage per partition?

A.df -h
B.df -i
C.du -h --max-depth=1 /
D.du -sh /
AnswerA

Shows filesystem disk space usage.

Why this answer

The `df -h` command displays disk space usage for all mounted filesystems in human-readable format (e.g., GB, MB). This directly answers the admin's need to check per-partition usage and identify if a filesystem is nearly full, which can cause slow write performance due to lack of free space.

Exam trap

The trap here is that candidates confuse `df` (disk free, per-partition) with `du` (disk usage, per-directory), or they mistake inode usage (`df -i`) for space usage, leading them to pick a command that does not show partition-level free space.

How to eliminate wrong answers

Option B is wrong because `df -i` shows inode usage, not disk space usage; a filesystem can have free space but run out of inodes, which is a different issue. Option C is wrong because `du -h --max-depth=1 /` shows disk usage of directories under the root, not per-partition usage, and it does not report free space or partition boundaries. Option D is wrong because `du -sh /` shows the total disk usage of the root directory only, not per-partition breakdown, and it cannot identify which partition is nearly full.

68
MCQhard

A company policy requires that all new logical volumes be created with a physical extent size of 16 MiB to optimize performance for large sequential I/O. During the creation of a new volume group, what parameter should be used?

A.vgcreate -p 16M vg_data /dev/sdc1
B.vgcreate -L 16M vg_data /dev/sdc1
C.vgcreate -e 16M vg_data /dev/sdc1
D.vgcreate -c 16M vg_data /dev/sdc1
E.vgcreate -s 16M vg_data /dev/sdc1
AnswerE

Correct: -s sets extent size.

Why this answer

Option E is correct because the `-s` parameter in `vgcreate` sets the physical extent (PE) size for the volume group. A PE size of 16 MiB is specified with `-s 16M`, which ensures all subsequent logical volumes in that VG use 16 MiB extents, optimizing performance for large sequential I/O by reducing metadata overhead.

Exam trap

The trap here is confusing the `-s` (extent size) option with other common LVM parameters like `-L` (size) or `-p` (max PVs), leading candidates to select a wrong option that sets a different attribute entirely.

How to eliminate wrong answers

Option A is wrong because `-p` sets the maximum number of physical volumes allowed in the volume group, not the extent size. Option B is wrong because `-L` sets the maximum logical volume size, not the extent size. Option C is wrong because `-e` is not a valid parameter for `vgcreate`; it is used with `pvcreate` to set the PE start offset.

Option D is wrong because `-c` sets the cluster mode for the volume group, not the extent size.

69
MCQhard

A server running RHEL 9 has an LVM logical volume /dev/vg00/lvol0 formatted with XFS, mounted at /data. The administrator needs to increase the file system size from 100GB to 150GB. Which command sequence should be used?

A.xfs_info /data; lvextend -L 150G /dev/vg00/lvol0
B.umount /data; lvextend -L +50G /dev/vg00/lvol0; mount /data; xfs_growfs /data
C.resize2fs /dev/vg00/lvol0
D.lvextend -L +50G /dev/vg00/lvol0; xfs_growfs /data
AnswerD

First extend the LV by 50GB, then grow the file system with xfs_growfs while it is mounted.

Why this answer

Option D is correct because it first extends the logical volume by the exact amount needed (+50G) using lvextend, then grows the XFS filesystem to match using xfs_growfs. XFS filesystems can be grown online (no unmount required), and xfs_growfs expands the filesystem to fill the available space in the logical volume.

Exam trap

The trap here is that candidates may assume all filesystems require unmounting before resizing (as with some older tools), or they may confuse XFS with ext4 and try to use resize2fs, or they may think xfs_info is a growth command instead of an info command.

How to eliminate wrong answers

Option A is wrong because xfs_info only displays filesystem information and does not perform any growth operation; the sequence lacks the actual grow command. Option B is wrong because unmounting the XFS filesystem is unnecessary and disruptive; xfs_growfs works on a mounted filesystem, and the -L +50G syntax is correct but the umount/mount steps are redundant and incorrect. Option C is wrong because resize2fs is the tool for ext2/3/4 filesystems, not XFS; using it on an XFS filesystem would fail or cause corruption.

70
MCQhard

The root filesystem is at 90% capacity. Which command increases available space without unmounting?

A.fstrim /
B.lvextend -L +5G /dev/mapper/vg_root-lv_root && xfs_growfs /
C.resize2fs /dev/mapper/vg_root-lv_root
D.lvextend -L +5G /dev/mapper/vg_root-lv_root
AnswerB

Correct: Extends the LV and grows the XFS filesystem.

Why this answer

Option B is correct because it first extends the logical volume with `lvextend -L +5G`, then grows the XFS filesystem online with `xfs_growfs /` to utilize the new space without unmounting. This is the proper procedure for XFS filesystems, which require `xfs_growfs` (not `resize2fs`) to expand while mounted.

Exam trap

Red Hat often tests the distinction between filesystem-specific resizing tools (xfs_growfs vs. resize2fs) and the need to run both the LVM extension and the filesystem grow command; the trap here is that candidates may think `lvextend` alone is sufficient or that `resize2fs` works on all filesystems.

How to eliminate wrong answers

Option A is wrong because `fstrim /` only discards unused blocks on SSD-backed filesystems to reclaim free space from the storage device, but it does not increase the actual capacity of the filesystem; it only optimizes existing free space. Option C is wrong because `resize2fs` is used for ext2/ext3/ext4 filesystems, not XFS; running it on an XFS filesystem will fail or cause corruption. Option D is wrong because `lvextend` alone extends the logical volume but does not resize the filesystem; without `xfs_growfs`, the additional space remains invisible to the filesystem and the root filesystem remains at 90% capacity.

71
Multi-Selectmedium

A system administrator has added a new disk /dev/sdb to a Red Hat Enterprise Linux 9 server. The directory /data already exists. Which two steps must be performed to prepare the disk for mounting as an XFS file system at /data?

Select 2 answers
A.Run mkfs.xfs on the partition (e.g., mkfs.xfs /dev/sdb1)
B.Mount the partition to /data (mount /dev/sdb1 /data)
C.Create a partition on /dev/sdb (e.g., fdisk /dev/sdb)
D.Create the /data directory (mkdir -p /data)
E.Add an entry to /etc/fstab for the new mount
AnswersA, C

The filesystem must be created on the partition before mounting.

Why this answer

Option A is correct because after creating a partition on /dev/sdb, you must format it with the XFS file system using mkfs.xfs. This writes the XFS superblock and metadata structures to the partition, making it ready for mounting. Without this step, the partition has no file system and cannot be mounted.

Exam trap

The trap here is that candidates often think mounting or adding an fstab entry is a preparatory step, but the question specifically asks for steps to prepare the disk for mounting, which are partitioning and creating the file system.

72
MCQeasy

A junior administrator needs to create a new Ext4 file system on the device /dev/sdb1. Which command should be used?

A.fdisk /dev/sdb1
B.parted /dev/sdb1
C.tune2fs /dev/sdb1
D.mkfs.ext4 /dev/sdb1
E.fsck /dev/sdb1
AnswerD

Correct: creates an ext4 filesystem.

Why this answer

The `mkfs.ext4` command is the standard utility for creating an ext4 filesystem on a block device. It formats the partition with the ext4 journaling filesystem, writing the superblock, inode table, and journal metadata. Option D is correct because it directly invokes the mke2fs program with the ext4 filesystem type.

Exam trap

The trap here is that candidates confuse partition management tools (fdisk, parted) with filesystem creation tools, or mistake maintenance utilities (tune2fs, fsck) for creation commands, leading them to select a wrong option that operates on a different layer of storage management.

How to eliminate wrong answers

Option A is wrong because `fdisk` is a partition table manipulation tool (MBR/GPT) and cannot create a filesystem; it only manages partitions on a disk, not on a partition like /dev/sdb1. Option B is wrong because `parted` is also a partition table editor, not a filesystem creation tool; it can resize or create partitions but not format them with a filesystem. Option C is wrong because `tune2fs` is used to adjust tunable filesystem parameters on an existing ext2/ext3/ext4 filesystem, not to create a new one.

Option E is wrong because `fsck` is a filesystem consistency check and repair tool, not a creation utility; it operates on an already-formatted filesystem.

73
MCQeasy

An administrator needs to add a 1GB swap partition on /dev/sdd1. Which series of commands accomplishes this?

A.mkswap /dev/sdd1 && echo '/dev/sdd1 swap swap defaults 0 0' >> /etc/fstab
B.mkfs.swap /dev/sdd1 && swapon /dev/sdd1
C.mkswap /dev/sdd1 && swapon /dev/sdd1
D.fdisk /dev/sdd, create partition, then mkswap /dev/sdd1, swapon /dev/sdd1, and add to /etc/fstab.
AnswerD

Correct procedure.

Why this answer

Option D is correct because it includes all necessary steps: first create the partition with fdisk (since /dev/sdd1 does not exist yet), then format it as swap with mkswap, activate it with swapon, and finally add an entry to /etc/fstab to ensure persistence across reboots. The other options omit the critical partition creation step or fail to make the swap permanent.

Exam trap

Red Hat often tests the requirement to create the partition first before formatting it as swap, leading candidates to mistakenly choose options that assume the partition already exists or skip the fstab entry for persistence.

How to eliminate wrong answers

Option A is wrong because it runs mkswap on /dev/sdd1 without first creating the partition, so the device node does not exist and the command will fail; also, while it adds an fstab entry, it does not activate the swap with swapon. Option B is wrong because mkfs.swap is not a valid command (the correct command is mkswap), and it lacks both partition creation and fstab persistence. Option C is wrong because it assumes /dev/sdd1 already exists and does not create the partition, nor does it add an entry to /etc/fstab, so the swap would not survive a reboot.

74
MCQeasy

Which command displays the UUID of all file systems on the system?

A.blkid
B.dumpe2fs -h
C.lsblk
D.fdisk -l
AnswerA

blkid shows UUID, file system type, and other attributes for all block devices.

Why this answer

The `blkid` command is the correct choice because it is specifically designed to locate and display block device attributes, including the UUID, filesystem type, and label, for all filesystems on the system. It reads data from the `/dev/disk/by-uuid/` directory and the `udev` database, making it the most direct and reliable tool for querying UUIDs without requiring root privileges for basic output.

Exam trap

Red Hat often tests the distinction between partition-level identifiers (shown by `fdisk -l` for GPT partition UUIDs) and filesystem-level UUIDs (shown by `blkid`), leading candidates to mistakenly choose `fdisk -l` when the question specifically asks for filesystem UUIDs.

How to eliminate wrong answers

Option B is wrong because `dumpe2fs -h` only displays filesystem information for ext2/ext3/ext4 filesystems, not for all filesystem types (e.g., XFS, Btrfs, or swap), and it requires a specific device argument rather than showing all filesystems system-wide. Option C is wrong because `lsblk` lists block devices and their mount points, but it does not display UUIDs by default; while it can show UUIDs with the `-f` or `-o UUID` options, the plain `lsblk` command omits UUIDs, making it incorrect for this specific requirement. Option D is wrong because `fdisk -l` is a partitioning tool that displays partition tables (e.g., MBR or GPT), not filesystem UUIDs; it shows partition UUIDs (for GPT) or partition types, but not the filesystem-level UUID that `blkid` reports.

75
MCQmedium

Based on the exhibit, how much free space is available in the volume group vg00?

A.19.98 GiB
B.10235 MiB
C.20.00 GiB
D.19.99 GiB
E.5115 MiB
AnswerA

Correct: matches Free PE size in vgdisplay.

Why this answer

The correct answer is A because the exhibit shows the Physical Volume (PV) size as 20.00 GiB, but the Volume Group (VG) vg00 has a Physical Extent (PE) size of 4.00 MiB, and the total PE count is 5115. The total usable capacity is 5115 PE × 4 MiB = 20460 MiB = 19.98 GiB (since 20460 ÷ 1024 = 19.98046875 GiB). This is the free space available in vg00, as no Logical Volumes (LVs) are allocated.

Exam trap

Red Hat often tests the distinction between raw PV size and usable VG space, trapping candidates who assume the PV size equals the VG free space without accounting for PE size and rounding.

How to eliminate wrong answers

Option B is wrong because 10235 MiB is exactly half of the total usable space (20460 MiB / 2), which might be a miscalculation if one mistakenly divides by 2 or confuses with a different metric. Option C is wrong because 20.00 GiB is the raw PV size, but the VG uses a PE size of 4 MiB, which introduces rounding and metadata overhead, so the actual free space is slightly less (19.98 GiB). Option D is wrong because 19.99 GiB is a rounding error; the precise calculation yields 19.98 GiB (20460 MiB / 1024 = 19.98046875 GiB).

Option E is wrong because 5115 MiB is the total number of PEs, not the free space in MiB; the free space in MiB is 20460 MiB (5115 PE × 4 MiB/PE).

Page 1 of 2 · 80 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Create and configure file systems questions.