Courseiva

CCNA System Architecture Questions

75 of 90 questions · Page 1/2 · System Architecture · Answers revealed

Practice these questionsDomain overviewAll questions
1
MCQmedium

Refer to the exhibit. How many physical disks are detected by the kernel, and what are their sizes?

A.Two disks: sda 10.0 GiB, sdb 2.00 GiB
B.Two disks: sda 10.7 GB, sdb 2.15 GB
C.Three disks: sda, sdb, and an unknown device
D.One disk: sda 10.7 GB
AnswerA

Correctly matches the output sizes in GiB.

Why this answer

The kernel has detected two physical disks: /dev/sda with a capacity of 10.0 GiB and /dev/sdb with a capacity of 2.00 GiB. This is evident from the output of `fdisk -l`, which lists disk devices and their sizes in gibibytes (GiB), a binary-based unit where 1 GiB = 1024^3 bytes. The kernel enumerates SCSI/SATA disks as /dev/sdX, and the output shows exactly two such devices.

Exam trap

The trap here is that candidates often confuse binary units (GiB) with decimal units (GB) and incorrectly convert the displayed sizes, or they overlook the second disk (sdb) because they focus only on the first line of output.

How to eliminate wrong answers

Option B is wrong because it incorrectly reports sizes in gigabytes (GB, decimal) instead of gibibytes (GiB, binary); the `fdisk -l` output explicitly shows '10.0 GiB' and '2.00 GiB', not '10.7 GB' and '2.15 GB' (which would be the decimal equivalents). Option C is wrong because there is no evidence of a third disk; the output lists only sda and sdb, and any 'unknown device' would still appear as a /dev/sdX entry if detected by the kernel. Option D is wrong because it claims only one disk (sda) exists, ignoring the clearly listed sdb device with its size.

Practice this question →
2
MCQeasy

A small office server running Ubuntu 20.04 experiences a gradual time drift. The system clock loses about 2 minutes per week. The hardware clock (RTC) is maintained by the motherboard battery and appears accurate when checked manually. The sysadmin wants to ensure the system clock stays synchronized automatically. Which single action should be taken? Options: A) Run 'timedatectl set-ntp true' to enable systemd-timesyncd, B) Add 'hwclock --hctosys' to /etc/rc.local, C) Install and configure the ntp package with a pool server, D) Use 'cron' to run ntpdate every minute.

A.Run 'timedatectl set-ntp true' to enable systemd-timesyncd
B.Add 'hwclock --hctosys' to /etc/rc.local
C.Install and configure the ntp package with a pool server
D.Use 'cron' to run ntpdate every minute
AnswerA

On Ubuntu 20.04, systemd-timesyncd is the default NTP client. Running 'timedatectl set-ntp true' activates it, which automatically synchronizes the system clock with NTP servers, correcting the gradual drift without needing additional packages or manual cron jobs. This is the simplest and most appropriate single action for automatic time sync on a modern systemd-based distribution.

Why this answer

On Ubuntu 20.04, systemd-timesyncd is the default NTP client. Running 'timedatectl set-ntp true' (option A) activates it, which automatically synchronizes the system clock with NTP servers, correcting the gradual drift without needing additional packages or manual cron jobs. This is the simplest and most appropriate single action for automatic time sync on a modern systemd-based distribution.

Exam trap

The trap here is that candidates may assume the full ntp package is always required for time synchronization, overlooking that systemd-timesyncd is the default and sufficient for basic NTP sync on modern Ubuntu systems.

How to eliminate wrong answers

Option A is wrong because installing and configuring the full ntp package is overkill for a small office server; systemd-timesyncd is already present and sufficient for basic NTP synchronization. Option B is wrong because adding 'hwclock --hctosys' to /etc/rc.local only sets the system clock from the hardware clock at boot, which does not correct ongoing time drift during operation. Option C is wrong because using cron to run ntpdate every minute is inefficient, can cause abrupt time jumps, and ntpdate is deprecated in favor of more gradual synchronization methods like systemd-timesyncd or ntpd.

Practice this question →
3
MCQeasy

Which hardware component uses a unique address to identify itself on the network at the data link layer?

A.IP address
B.MAC address
C.Hostname
D.Port number
AnswerB

MAC addresses are used for communication within a local network segment.

Why this answer

The MAC address (Media Access Control) is a unique 48-bit identifier burned into the network interface controller (NIC) by the manufacturer. It operates at Layer 2 (data link layer) of the OSI model, enabling devices on the same local network segment to communicate directly using protocols like Ethernet or Wi-Fi.

Exam trap

The trap here is that candidates often confuse the MAC address with the IP address because both are used for network identification, but the question specifically asks for the data link layer, where only the MAC address (not the IP address) operates.

How to eliminate wrong answers

Option A is wrong because an IP address operates at Layer 3 (network layer) and is used for logical addressing and routing across networks, not for hardware identification at the data link layer. Option C is wrong because a hostname is a human-readable alias resolved to an IP address via DNS or local hosts files, and it has no role in data link layer addressing. Option D is wrong because a port number is a Layer 4 (transport layer) identifier used by TCP or UDP to distinguish application services on a host, not for hardware-level network identification.

Practice this question →
4
MCQmedium

On a systemd-based system, which file is NOT used for system initialization?

A./etc/fstab
B./etc/systemd/system/default.target
C./etc/inittab
D./lib/systemd/system/sysinit.target
AnswerC

Inittab is for SysV init, not systemd.

Why this answer

/etc/inittab is the configuration file used by the traditional SysV init system to define runlevels and control terminal getty processes. On a systemd-based system, systemd does not read /etc/inittab; instead, it uses unit files and targets to manage system initialization, making this file unused for that purpose.

Exam trap

The trap here is that candidates familiar with SysV init assume /etc/inittab is still relevant on modern Linux systems, but LPIC-1 tests the distinction between legacy and systemd initialization files.

How to eliminate wrong answers

Option A is wrong because /etc/fstab is still used by systemd (via systemd-fstab-generator) to mount filesystems during boot, so it is involved in system initialization. Option B is wrong because /etc/systemd/system/default.target is a symlink that defines the default boot target (e.g., multi-user.target or graphical.target) and is actively used by systemd to determine the initial system state. Option D is wrong because /lib/systemd/system/sysinit.target is a special target unit that systemd uses to synchronize early boot services and is a core part of the initialization process.

Practice this question →
5
MCQhard

After a system upgrade, the server fails to boot with the error: 'ERROR: Failed to mount the real root device.' The root filesystem is on an LVM logical volume. Which recovery step is most appropriate?

A.Boot from a live CD, chroot, and run 'update-initramfs -u -k all' to regenerate the initramfs with lvm2 support
B.Run 'lvchange -ay' to activate all LVs
C.Reinstall GRUB to the MBR
D.Use 'fsck' on the root LV
AnswerA

This rebuilds the initramfs including necessary LVM modules.

Why this answer

The error 'Failed to mount the real root device' after a system upgrade indicates the initramfs lacks the necessary LVM modules (e.g., lvm2) to activate and mount the root logical volume. Regenerating the initramfs with 'update-initramfs -u -k all' rebuilds it to include LVM support, ensuring the kernel can locate and mount the root filesystem during boot.

Exam trap

The trap here is that candidates confuse a missing initramfs module issue with a logical volume activation problem (Option B), but 'lvchange -ay' is only effective after the initramfs has loaded LVM support; without it, the kernel cannot even see the LVs to activate them.

How to eliminate wrong answers

Option B is wrong because 'lvchange -ay' activates all logical volumes, but this command must be run from a rescue environment (e.g., live CD) and does not address the missing LVM support in the initramfs; the kernel still cannot mount the root LV without proper modules. Option C is wrong because reinstalling GRUB to the MBR only fixes bootloader issues (e.g., missing or corrupted stage files), not the kernel's inability to mount the root filesystem due to missing LVM drivers. Option D is wrong because 'fsck' checks and repairs filesystem integrity, but the error occurs before the filesystem is even mounted; the root cause is the initramfs lacking LVM support, not filesystem corruption.

Practice this question →
6
MCQhard

A sysadmin wants to ensure a specific kernel module is automatically loaded at boot. Which method is considered best practice?

A.Use systemd-modules-load.service
B.All of the above are valid methods
C.Add module name to /etc/modules
D.Add a line to /etc/modprobe.d/
AnswerC

Adding the module name to /etc/modules is the traditional and standard method, and works across distributions. This is best practice.

Why this answer

The best practice to automatically load a kernel module at boot is to add the module name to /etc/modules or a file in /etc/modules-load.d/. This method works on both sysvinit and systemd systems, as systemd-modules-load.service reads these configuration files. Directly using the service or adding lines to /etc/modprobe.d/ is not standard; /etc/modprobe.d/ is for module options, not auto-loading.

Exam trap

The trap is assuming that /etc/modprobe.d/ or the service itself is used for auto-loading. In reality, /etc/modprobe.d/ is for options and aliases, and the service reads configuration files like /etc/modules or /etc/modules-load.d/*.conf.

How to eliminate wrong answers

Option A is wrong because it is not incorrect—systemd-modules-load.service is a valid mechanism that reads configuration files to load modules at boot, so it is a correct method, not a wrong one. Option C is wrong because it is not incorrect—adding the module name to /etc/modules is a traditional method still supported by systemd-modules-load.service on many distributions. Option D is wrong because it is not incorrect—adding a line to /etc/modprobe.d/ (e.g., with the 'install' or 'alias' directive) can also cause the module to be loaded at boot, making it a valid method.

Practice this question →
7
MCQeasy

A system administrator is troubleshooting a Linux server that fails to boot. The server has a software RAID 1 configuration using mdadm, with the root filesystem located on /dev/md0. During boot, the system halts with the following error: 'VFS: Unable to mount root fs on unknown-block(0,0)'. The admin verifies that the BIOS recognizes all disks and that the RAID array was properly assembled prior to the last shutdown. The system was working after a recent kernel update, but now fails. Which of the following actions is the most likely solution?

A.Use a live CD to run fsck on /dev/md0.
B.Rebuild the initramfs to include the mdadm module and the RAID metadata.
C.Check the /etc/fstab file for incorrect root device.
D.Reinstall the bootloader on the MBR.
AnswerB

Rebuilding the initramfs adds the necessary RAID support, allowing the kernel to assemble and mount /dev/md0.

Why this answer

After a kernel update, the new kernel may lack the necessary mdadm module or RAID metadata support in the initramfs. The error 'unknown-block(0,0)' indicates the kernel cannot find the root device because the initramfs does not contain the required RAID drivers or assembly instructions. Rebuilding the initramfs with the correct mdadm configuration ensures the kernel can assemble and mount /dev/md0 during boot.

Exam trap

The trap here is that candidates often confuse a root filesystem mount failure with filesystem corruption (fsck) or bootloader issues, but the specific 'unknown-block(0,0)' error points to a missing kernel module or initramfs problem after a kernel update.

How to eliminate wrong answers

Option A is wrong because fsck repairs filesystem corruption, but the error 'unknown-block(0,0)' indicates the kernel cannot locate the block device at all, not that the filesystem is damaged. Option C is wrong because /etc/fstab is read after the root filesystem is mounted; if the root device cannot be found, the system never reaches the point of parsing fstab. Option D is wrong because reinstalling the bootloader on the MBR addresses bootloader issues (e.g., GRUB stage 1), but the error occurs after the kernel is loaded and fails to mount root, indicating a missing driver or module in the initramfs.

Practice this question →
8
MCQeasy

A system administrator notices that after updating the kernel, the system fails to boot. The administrator wants to boot the previous kernel. Which GRUB menu option should be selected?

A.Memory test
B.Advanced options for Ubuntu
C.Recovery mode
D.Boot from first hard disk
AnswerB

This option often lists previous kernel versions.

Why this answer

The 'Advanced options for Ubuntu' GRUB menu entry provides access to a submenu listing all installed kernel versions, allowing the administrator to select and boot the previous kernel. This is the standard method to revert to a known-good kernel after a failed update, as GRUB dynamically generates entries for each kernel found in /boot.

Exam trap

The trap here is that candidates may confuse 'Recovery mode' with a kernel version selector, but Recovery mode is a single-kernel boot option for troubleshooting, not a menu for choosing among multiple kernels.

How to eliminate wrong answers

Option A is wrong because 'Memory test' runs a diagnostic memory check (e.g., Memtest86+) and does not allow selecting a different kernel version. Option C is wrong because 'Recovery mode' boots a specific kernel with minimal services and a root shell, but it does not offer a choice of kernel versions; it is used for system repair, not kernel selection. Option D is wrong because 'Boot from first hard disk' bypasses the GRUB menu entirely and boots the default boot loader on the first disk, which would likely load the same problematic kernel.

Practice this question →
9
MCQhard

A kernel module fails to load with the error 'modprobe: FATAL: Module xyz not found in directory /lib/modules/$(uname -r)'. What is the most likely cause?

A.The module is blacklisted in /etc/modprobe.d/.
B.The kernel version has changed and modules need to be rebuilt.
C.The module has dependencies that are missing.
D.The module is not installed on the system.
AnswerB

After a kernel update, modules for the new kernel may not be present; they need to be rebuilt or reinstalled.

Why this answer

The error message references the specific kernel version from `uname -r`. If the kernel has been updated (e.g., via a package upgrade), the modules directory for the new kernel version will not contain the previously built modules. The module must be rebuilt against the new kernel's source or headers, which is why option B is correct.

Exam trap

The trap here is that candidates often confuse a 'not found' error with the module simply being missing from the filesystem, but the specific inclusion of the kernel version directory (e.g., /lib/modules/5.10.0-9-amd64) in the error message points directly to a kernel version mismatch. This is common after a kernel update in Linux distributions like Debian or Ubuntu, where modules must be rebuilt or re-installed for the new kernel version.

How to eliminate wrong answers

Option A is wrong because a blacklisted module would produce a different error (e.g., 'Module xyz is blacklisted') or simply be skipped, not a 'not found' error. Option C is wrong because missing dependencies typically produce an error like 'Required key not available' or 'Unknown symbol', not a 'not found' error for the module itself. Option D is wrong because if the module were simply not installed, the error would be 'modprobe: FATAL: Module xyz not found.' — the inclusion of the specific directory path in the error indicates the system is looking in the correct location for the running kernel, but the module is absent there, which is consistent with a kernel version mismatch.

Practice this question →
10
Multi-Selecteasy

Which THREE of the following are valid runlevels in a traditional SysV init system? (Choose three.)

Select 3 answers
A.9
B.6
C.7
D.1
E.0
AnswersB, D, E

Runlevel 6 is reboot.

Why this answer

In a traditional SysV init system, runlevels are predefined system states numbered from 0 to 6. Runlevel 6 is the standard runlevel for system reboot, where the init process terminates all processes, unmounts filesystems, and restarts the system.

Exam trap

A common misconception is that runlevels can be any number from 0 to 9, but the SysV init standard strictly limits valid runlevels to 0 through 6, with 7–9 being reserved or invalid. The LPI LPIC-1 exam expects you to know the standard runlevels and their purposes.

Practice this question →
11
MCQhard

A production server running CentOS 7 has multiple SCSI disks (sda, sdb, sdc) configured in a RAID5 array managed by mdadm (md0). The root filesystem is on md0. After a power failure, the server boots but drops into a rescue shell with the error: 'md: md0: cannot run array. Not enough devices online.' The admin checks with 'cat /proc/mdstat' and sees that only sda and sdb are spares (marked as (S)), sdc is missing. Which sequence of commands should the admin use to attempt recovery and bring the system to a functional state? Options: A) First run 'mdadm --manage /dev/md0 --add /dev/sdc', then 'mdadm --run /dev/md0'. B) Boot from a live CD, then run 'mdadm --assemble --scan' to reassemble. C) Run 'mdadm --stop /dev/md0', then 'mdadm --assemble /dev/md0 /dev/sda /dev/sdb /dev/sdc'. D) Run 'mdadm --run /dev/md0' to force start the array in degraded mode, then add sdc with 'mdadm --add' after system is up.

A.First run 'mdadm --manage /dev/md0 --add /dev/sdc', then 'mdadm --run /dev/md0'
B.Boot from a live CD, then run 'mdadm --assemble --scan' to reassemble
C.Run 'mdadm --stop /dev/md0', then 'mdadm --assemble /dev/md0 /dev/sda /dev/sdb /dev/sdc'
D.Run 'mdadm --run /dev/md0' to force start the array in degraded mode, then add sdc with 'mdadm --add' after system is up
AnswerD

Correct. Use --run to start the array in degraded mode despite the missing disk, then add the disk to begin recovery. This allows the system to boot.

Why this answer

Since the RAID5 array has only two of three disks available, it can still operate in degraded mode. The command 'mdadm --run /dev/md0' forces the array to start despite the missing device, allowing the system to boot from the root filesystem on md0. Once the system is operational, the admin can add the missing disk with 'mdadm --add /dev/md0 /dev/sdc' to initiate recovery and rebuild the array.

Option A is incorrect because you cannot add a disk to an inactive array; you must first force the array to run. Option B is unnecessary; the system can be recovered without a live CD. Option C fails because stopping the array is impossible while the root filesystem is mounted, and reassembling without the missing disk will not succeed.

Exam trap

The trap here is that candidates mistakenly think they must stop and reassemble the array or use a live CD, when in fact the correct recovery is to force the array to run degraded with '--run' and then add the missing disk.

How to eliminate wrong answers

Option B is wrong because booting from a live CD is unnecessary and overly disruptive; the system can be recovered without external media by forcing the array to run degraded. Option C is wrong because 'mdadm --manage --add' cannot add a device to a stopped or non-running array, and the command sequence is reversed; the array must be running first. Option D is wrong because stopping the array with 'mdadm --stop' and then reassembling with explicit device list is risky and may fail if the superblock on sdc is stale or inconsistent; the simpler approach is to force start degraded.

Practice this question →
12
Multi-Selectmedium

Which TWO commands can be used to display information about the CPU(s) in a Linux system? (Choose two.)

Select 2 answers
A.uname -m
B.lsusb
C.cpufreq-info
D.cat /proc/cpuinfo
E.lscpu
AnswersD, E

cat /proc/cpuinfo shows detailed per-CPU information.

Why this answer

Options D and E are both correct. `cat /proc/cpuinfo` reads the virtual file /proc/cpuinfo which the kernel populates with detailed CPU information for each core, such as model name, cache size, and flags. `lscpu` is a utility that collects CPU information from /proc/cpuinfo and sysfs, presenting it in a human-readable tabular format. Both commands are standard on Linux for displaying CPU details.

Exam trap

The trap here is that candidates may confuse uname -m (which shows architecture) with a command that provides full CPU details, or assume cpufreq-info is a standard CPU info command when it is actually a specialized frequency tool.

Practice this question →
13
MCQhard

A server configured with UEFI firmware and GPT partitioning fails to boot after a GRUB package update. The administrator suspects the bootloader is not correctly installed. Which command should be used to reinstall GRUB to the EFI system partition?

A.grub2-install /dev/sda1
B.grub-mkconfig -o /boot/grub/grub.cfg
C.grub-install /dev/sda
D.grub-install --target=x86_64-efi --efi-directory=/boot/efi
AnswerD

Correctly installs GRUB for UEFI, targeting the EFI system partition mounted at /boot/efi.

Why this answer

On a UEFI-based system with GPT partitioning, GRUB must be installed as an EFI application to the EFI System Partition (ESP). The `--target=x86_64-efi` flag specifies the EFI firmware target, and `--efi-directory=/boot/efi` points to the mount point of the ESP, ensuring the bootloader files (e.g., `grubx64.efi`) are placed in the correct EFI directory (e.g., `/boot/efi/EFI/GRUB/`).

Exam trap

The trap here is that candidates confuse `grub-install /dev/sda` (which works for BIOS/MBR systems) with the UEFI-specific command, or they mistakenly think regenerating the config file with `grub-mkconfig` reinstalls the bootloader.

How to eliminate wrong answers

Option A is wrong because `grub2-install /dev/sda1` targets a partition (e.g., `/dev/sda1`) rather than the disk device; GRUB installation for BIOS or EFI requires the whole disk (e.g., `/dev/sda`) or specific EFI parameters, and using a partition number is invalid. Option B is wrong because `grub-mkconfig -o /boot/grub/grub.cfg` only regenerates the GRUB configuration file from templates and does not install the bootloader to the disk or ESP; it cannot fix a missing or corrupted bootloader installation. Option C is wrong because `grub-install /dev/sda` without the `--target` and `--efi-directory` flags defaults to installing for BIOS/legacy boot (i386-pc), which writes to the Master Boot Record (MBR) and is incompatible with UEFI firmware that expects an EFI executable on the ESP.

Practice this question →
14
MCQmedium

A Linux system using systemd fails to reach the default target after a recent change. The administrator wants to boot into a minimal environment to troubleshoot. Which kernel parameter should be added at the GRUB prompt?

A.single
B.systemd.unit=rescue.target
C.init=/bin/bash
D.systemd.unit=emergency.target
AnswerB

Rescue target provides a minimal environment with root read-write and basic services.

Why this answer

Systemd uses `systemd.unit=rescue.target` to boot into a minimal single-user environment with essential services, which is ideal for troubleshooting boot failures. This parameter overrides the default target at the GRUB prompt, allowing the administrator to diagnose and fix the issue without loading the full graphical or multi-user target.

Exam trap

The trap here is that candidates confuse 'rescue.target' with 'emergency.target' or legacy SysVinit parameters like 'single', not realizing that systemd (as used in LPI Linux) requires explicit unit names and that 'emergency.target' is even more stripped down, often lacking a writable root filesystem or networking.

How to eliminate wrong answers

Option A is wrong because `single` is a legacy SysVinit parameter; systemd ignores it unless a compatibility symlink is present, and it does not reliably set the unit to rescue.target. Option C is wrong because `init=/bin/bash` bypasses systemd entirely, starting only a bare shell without mounting filesystems or starting services, which is too minimal for most troubleshooting and can cause data loss. Option D is wrong because `systemd.unit=emergency.target` boots into an even more minimal environment than rescue.target, starting only a shell on the console without networking or multi-user support, which is typically too restrictive for general troubleshooting.

Practice this question →
15
MCQmedium

A Linux system administrator is tasked with setting up a new server that will host multiple virtual machines using KVM. The server has 64 GB of RAM and two physical CPUs, each with 8 cores (16 threads). The administrator needs to allocate resources efficiently. The VMs will have varying workloads. The administrator wants to ensure that the host system has enough resources for itself and that VMs can use all available CPU cores. Which approach should the administrator take to configure CPU allocation for the host and VMs?

A.Use QEMU emulation instead of KVM to reduce CPU overhead.
B.Pin all physical CPU cores to the VMs using virsh vcpupin, and leave no cores for the host.
C.Use CPU pinning to reserve two physical cores for the host and distribute the remaining cores among VMs using host-passthrough mode.
D.Overcommit CPU resources by assigning 32 vCPUs to each VM, relying on the hypervisor to schedule.
AnswerC

This ensures host responsiveness and allows VMs to use all available CPU features.

Why this answer

It reserves two physical cores for the host system to ensure its stability and performance, while distributing the remaining cores among VMs using CPU pinning and host-passthrough mode. This approach allows VMs to access the full CPU feature set and all available cores efficiently, balancing host overhead with VM resource needs in a KVM environment.

Exam trap

The trap here is that candidates may assume overcommitting CPU resources is always safe (Option D) or that QEMU emulation is a performance improvement (Option A), when in fact KVM's hardware acceleration and proper pinning are critical for efficient virtualization.

How to eliminate wrong answers

Option A is wrong because QEMU emulation adds significant CPU overhead compared to KVM's hardware-assisted virtualization, which would degrade performance rather than reduce it. Option B is wrong because pinning all physical cores to VMs leaves no CPU resources for the host, causing the host to starve and potentially crash or become unresponsive. Option D is wrong because overcommitting CPU resources by assigning 32 vCPUs per VM (exceeding the total 32 threads) can lead to severe contention and performance degradation, as the hypervisor cannot efficiently schedule such an extreme overcommitment without proper resource limits.

Practice this question →
16
MCQhard

After modifying the /etc/fstab file, an administrator runs the command mount -a and receives the error 'mount: /data: special device /dev/sdb1 does not exist'. What is the most likely issue?

A.There is a typo in the device path in /etc/fstab.
B.The /dev/sdb1 device file is missing or corrupted.
C.The entry in /etc/fstab has an incorrect filesystem type.
D.The filesystem on /dev/sdb1 is not formatted.
AnswerA

A typo would cause the kernel to not find the device at the specified path, resulting in the 'does not exist' error.

Why this answer

The `mount -a` command reads all entries in /etc/fstab and attempts to mount them. The error 'special device /dev/sdb1 does not exist' indicates that the kernel cannot find the block device file at that path. The most likely cause is a typographical error in the device path within /etc/fstab, such as a misspelling (e.g., /dev/sdb1 vs /dev/sdb1) or an incorrect partition number, because the device file itself is created by udev and would exist if the hardware were properly detected.

Exam trap

The trap here is that candidates may assume the device file is missing due to a hardware or driver issue (Option B), but the error specifically points to a path mismatch in fstab, which is a common administrative mistake when editing configuration files.

How to eliminate wrong answers

Option B is wrong because if /dev/sdb1 were missing or corrupted, it would typically indicate a hardware detection issue or a missing driver, but the error message explicitly says 'does not exist', which is more commonly caused by a path mismatch in fstab rather than a missing device file (which udev would recreate on reboot). Option C is wrong because an incorrect filesystem type would produce a different error, such as 'wrong fs type, bad option, bad superblock', not a missing device error. Option D is wrong because an unformatted filesystem would cause a 'mount: /data: wrong fs type, bad option, bad superblock' error when mount tries to read the superblock, not a 'does not exist' error.

Practice this question →
17
MCQhard

Refer to the exhibit. The system has multiple SAS drives attached to this controller, but one of them is not detected during boot. Which command is most likely to provide information about the device detection order?

A.cat /proc/scsi/scsi
B.lsblk
C.dmesg | grep -i scsi
D.lsscsi
AnswerC

dmesg displays kernel messages with timestamps, revealing the order of SCSI device detection.

Why this answer

The `dmesg` command displays kernel ring buffer messages, which include hardware detection and initialization logs during boot. By piping to `grep -i scsi`, you filter for SCSI-related messages, revealing the order in which devices were discovered and any errors for undetected drives. This is the most direct way to see why a specific SAS drive failed to appear.

Exam trap

The trap here is that candidates often pick `lsscsi` or `cat /proc/scsi/scsi` because they show SCSI devices, but they fail to realize those commands only show the final state, not the boot-time detection order or failure messages that `dmesg` provides.

How to eliminate wrong answers

Option A is wrong because `cat /proc/scsi/scsi` shows a static list of currently detected SCSI devices, not the boot-time detection order or failure details. Option B is wrong because `lsblk` lists block devices that are already recognized by the kernel, providing no information about the detection sequence or why a drive was missed. Option D is wrong because `lsscsi` displays a snapshot of SCSI devices currently visible to the system, similar to `/proc/scsi/scsi`, and does not reveal the boot-time probe order or errors.

Practice this question →
18
Multi-Selectmedium

Which TWO of the following are valid methods to view kernel messages on a systemd-based system?

Select 2 answers
A.lsmod
B.journalctl -k
C.cat /var/log/syslog
D.grub-mkconfig
E.dmesg
AnswersB, E

Shows kernel messages from the systemd journal for the current boot.

Why this answer

On systemd-based systems, the `journalctl -k` command displays kernel messages from the systemd journal, which is the default logging system. The `-k` flag specifically filters for kernel messages, making it a direct and valid method to view kernel logs.

Exam trap

The trap here is that candidates may think `dmesg` is the only valid method for kernel messages, overlooking that `journalctl -k` is equally valid on systemd-based systems, or they may confuse `lsmod` with kernel message viewing due to its association with kernel information.

Practice this question →
19
Multi-Selectmedium

Which TWO commands can be used to set the default boot target (runlevel) in systemd?

Select 2 answers
A.ln -sf /lib/systemd/system/multi-user.target /etc/systemd/system/default.target
B.systemctl isolate multi-user.target
C.systemctl default multi-user.target
D.systemctl enable multi-user.target
E.systemctl set-default multi-user.target
AnswersA, E

Manually creates the symlink for default target.

Why this answer

Creating a symbolic link from `/lib/systemd/system/multi-user.target` to `/etc/systemd/system/default.target` directly sets the default boot target in systemd. This is the traditional method that overrides the default target by pointing the `default.target` symlink to the desired target unit, which systemd reads at boot to determine the runlevel.

Exam trap

The trap here is that candidates confuse `systemctl isolate` (which changes the current runlevel immediately) with `systemctl set-default` (which sets the persistent default), or they mistakenly think `systemctl enable` sets the default target when it only enables a unit for automatic startup.

Practice this question →
20
MCQeasy

A system administrator runs the command `fdisk -l` and sees the following line: Disk /dev/sda: 1000 GB, 1000204886016 bytes, 1953525168 sectors Based on this output, which statement is true?

A.The disk has write protection enabled
B.The disk has 5 partitions
C.The disk is 1 TB
D.The disk uses GPT partitioning
AnswerC

The log explicitly states 1.00 TB.

Why this answer

The output from `fdisk -l` shows the total disk size as 1000 GB, which is 1 TB. Thus, option C is correct. The output does not provide information about write protection, partition count, or partition table type.

Exam trap

The trap here is that candidates might assume the disk has a specific partition table type (like GPT) or partition count based on common defaults, but the output only provides disk size and geometry, not partition details, leading to overinterpretation of the data.

How to eliminate wrong answers

Option A is wrong because write protection is typically indicated by a read-only flag or specific error messages (e.g., 'Read-only file system'), not by the disk size or partition table type shown in the exhibit. Option B is wrong because the exhibit does not list any partitions; it only shows the disk size, so claiming 5 partitions is unsupported by the evidence. Option D is wrong because GPT partitioning is identified by a protective MBR or a 'gpt' label in partition table output, and the exhibit does not provide any partition table information to confirm GPT usage.

Practice this question →
21
MCQeasy

A junior admin is tasked with configuring network bonding on a Debian server with two Ethernet interfaces, eth0 and eth1. The goal is to provide link redundancy using active-backup mode. The admin edits /etc/network/interfaces and adds configuration for bond0 with slaves eth0 eth1, then runs 'ifup bond0'. However, the bond interface fails to come up and the error message indicates that the 'bond' kernel module is not loaded. The admin checks with 'lsmod | grep bonding' and finds no output. Which additional step is required to successfully bring up the bond interface? Options: A) Run 'modprobe bonding' before ifup, B) Use ifenslave directly after ifup, C) Reboot the system to load the module, D) Add 'auto bond0' in /etc/network/interfaces.

A.Run 'modprobe bonding' before ifup
B.Use ifenslave directly after ifup
C.Reboot the system to load the module
D.Add 'auto bond0' in /etc/network/interfaces
AnswerA

Loads the bonding kernel module, enabling bond interface creation.

Why this answer

The 'bond' kernel module must be loaded before the bonding interface can be created. Running 'modprobe bonding' loads the module into the kernel, making the bonding functionality available. Without this step, 'ifup bond0' fails because the kernel does not recognize the bonding driver.

Exam trap

The trap here is that candidates may think adding 'auto bond0' or rebooting will solve the module loading issue, but the kernel module must be explicitly loaded before the bonding interface can be created.

How to eliminate wrong answers

Option B is wrong because adding 'auto bond0' only configures the interface to start automatically at boot, but does not load the kernel module; the module must be loaded first. Option C is wrong because 'ifenslave' is a tool to attach slaves to an already existing bond interface, but the bond interface itself cannot be created without the bonding module. Option D is wrong because rebooting is unnecessary and inefficient; the module can be loaded dynamically with 'modprobe' without a reboot.

Practice this question →
22
MCQhard

After connecting a USB device, the system does not create a device node in /dev. Which command can be used to trigger udev to re-evaluate the device?

A.modprobe
B.udevadm control --reload
C.udevadm settle
D.udevadm trigger
AnswerD

This command generates uevents for existing devices, causing udev to process them again.

Why this answer

The correct command is `udevadm trigger`. This command causes udev to re-evaluate all devices by simulating kernel uevents, which forces udev to process rules and create device nodes in /dev for devices that were missed or not properly initialized.

Exam trap

The trap here is confusing `udevadm trigger` with `udevadm control --reload`; candidates often think reloading rules alone will fix missing device nodes, but without re-triggering uevents, udev does not re-evaluate already-connected devices.

How to eliminate wrong answers

Option A is wrong because `modprobe` is used to load or unload kernel modules, not to trigger udev rule processing or device node creation. Option B is wrong because `udevadm control --reload` reloads the udev rules and configuration files but does not re-trigger uevents for existing devices. Option C is wrong because `udevadm settle` waits for the udev event queue to finish processing; it does not initiate new uevents or force device node creation.

Practice this question →
23
Multi-Selecthard

Which THREE of the following are valid sources to configure GRUB?

Select 3 answers
A./boot/grub/menu.lst
B./etc/grub.conf
C./boot/grub/grub.cfg
D./etc/default/grub
E./etc/grub.d/
AnswersC, D, E

The actual boot configuration file read by GRUB.

Why this answer

C is correct because `/boot/grub/grub.cfg` is the primary configuration file generated by GRUB 2 (the default bootloader on modern Linux distributions). It is automatically created by running `update-grub` or `grub-mkconfig`, which reads settings from `/etc/default/grub` and scripts in `/etc/grub.d/`. This file contains the actual menu entries and boot directives used at boot time.

Exam trap

The trap here is that candidates confuse GRUB Legacy files (`menu.lst` or `grub.conf`) with GRUB 2 files, or think `/etc/grub.conf` is a standard GRUB 2 configuration file, when in fact GRUB 2 uses `/etc/default/grub` and `/etc/grub.d/` as sources, with the generated output in `/boot/grub/grub.cfg`.

Practice this question →
24
MCQeasy

Which file is used by GRUB to load the kernel at boot time?

A./etc/grub.d/
B./etc/default/grub
C./boot/vmlinuz
D./boot/grub/grub.cfg
AnswerD

This is the generated configuration file used by GRUB at boot.

Why this answer

GRUB (GRand Unified Bootloader) reads its main configuration file, /boot/grub/grub.cfg, to determine which kernel to load and with what parameters. This file contains the menu entries, kernel paths, and initrd directives that GRUB uses at boot time. It is automatically generated by update-grub or grub-mkconfig based on scripts in /etc/grub.d/ and settings in /etc/default/grub.

Exam trap

The trap here is that candidates confuse the configuration file that GRUB reads at boot (/boot/grub/grub.cfg) with the files used to generate it (/etc/default/grub and /etc/grub.d/), leading them to pick a wrong answer that is part of the generation process rather than the runtime configuration.

How to eliminate wrong answers

Option A is wrong because /etc/grub.d/ is a directory containing shell scripts that generate parts of the GRUB configuration, not the file GRUB reads to load the kernel. Option B is wrong because /etc/default/grub is a configuration file that sets default boot options (like timeout and kernel parameters) for the grub-mkconfig tool, but it is not read directly by GRUB at boot. Option C is wrong because /boot/vmlinuz is the actual kernel image file, not a configuration file; GRUB loads the kernel from this path after reading its configuration.

Practice this question →
25
MCQmedium

A Linux administrator manages a server that runs a custom application requiring a specific kernel module to be loaded at boot. The server uses SysV init and has the module listed in /etc/modules. However, after a recent kernel update, the module fails to load automatically at boot. The administrator can manually load the module with 'modprobe <module>' after the system is running. The application depends on this module being loaded before any network services start. Which of the following actions should the administrator take to ensure the module loads automatically at the correct time during boot?

A.Create a SysV init script that loads the module and place it in /etc/init.d/ with appropriate symlinks in /etc/rc?.d/ to ensure it runs before network services.
B.Add the module name to /etc/modules-load.d/ directory.
C.Add an install directive in /etc/modprobe.d/ for the module.
D.Add a blacklist entry for the module in /etc/modprobe.d/blacklist.conf.
AnswerA

This ensures the module is loaded early in the boot process, before network services that depend on it.

Why this answer

SysV init systems use init scripts in /etc/init.d/ with symlinks in /etc/rc?.d/ to control the order of service startup. By creating a custom init script that loads the module via modprobe and placing it with a symlink that has a lower number (e.g., S01module) than network services (e.g., S10network), the module will be loaded before network services start, satisfying the application's dependency.

Exam trap

The trap here is that candidates confuse the systemd-based /etc/modules-load.d/ mechanism with SysV init's /etc/modules file, assuming both are equivalent, when in fact SysV init requires explicit init scripts to control boot order.

How to eliminate wrong answers

Option B is wrong because /etc/modules-load.d/ is used by systemd's modules-load service, not by SysV init; on a SysV init system, this directory is ignored. Option C is wrong because an install directive in /etc/modprobe.d/ controls how modprobe handles module dependencies or custom commands when the module is requested, but it does not trigger automatic loading at boot; it only modifies modprobe behavior when the module is explicitly loaded. Option D is wrong because adding a blacklist entry would prevent the module from loading automatically, which is the opposite of what the administrator needs.

Practice this question →
26
Multi-Selecthard

Which TWO files are used to configure kernel boot parameters in GRUB?

Select 2 answers
A./sys/kernel/cmdline
B./etc/default/grub
C./etc/grub.d/
D./proc/cmdline
E./boot/grub/grub.cfg
AnswersB, C

Correct. /etc/default/grub is the main configuration file where users define kernel boot parameters.

Why this answer

The correct answers are B and C. /etc/default/grub (B) is the primary configuration file for GRUB 2 where users set kernel boot parameters such as GRUB_CMDLINE_LINUX. /etc/grub.d/ (C) is a directory containing scripts that are executed by grub-mkconfig to generate the final /boot/grub/grub.cfg file; these scripts can be modified to add or change kernel boot parameters. Option E (/boot/grub/grub.cfg) is a generated file, not used for direct configuration. Options A (/sys/kernel/cmdline) and D (/proc/cmdline) display the current kernel command line but are not configuration files.

Practice this question →
27
MCQmedium

A Linux system has two network interfaces: eth0 and eth1. The administrator wants to bond them for increased throughput. Which kernel module is required for bonding?

A.aggregation
B.bonding
C.team
D.bond
AnswerB

The bonding kernel module provides network interface bonding.

Why this answer

The bonding driver in Linux allows multiple network interfaces to be aggregated into a single logical interface for increased throughput or redundancy. The correct kernel module is named 'bonding' (loaded via modprobe bonding or compiled into the kernel), which implements the IEEE 802.3ad Link Aggregation standard and other bonding modes. Option B is correct because 'bonding' is the exact module name used in the Linux kernel.

Exam trap

The trap here is that candidates confuse the interface name (bond0) with the kernel module name (bonding), or think 'team' is a synonym for bonding, when in fact they are separate technologies with different kernel modules.

How to eliminate wrong answers

Option A is wrong because 'aggregation' is a generic term for combining links, not a specific Linux kernel module; the actual module is 'bonding'. Option C is wrong because 'team' refers to the libteam project, which is a separate user-space-based teaming solution that uses the 'team' kernel module, not the standard bonding driver. Option D is wrong because 'bond' is a common abbreviation but not the exact kernel module name; the module is loaded as 'bonding' (e.g., modprobe bonding), and the resulting interface is named bond0, bond1, etc.

Practice this question →
28
MCQmedium

The system administrator wants to use the entire sdb disk as a single partition. Which command will partition sdb with a single partition occupying the whole disk?

A.fdisk /dev/sdb, then create a new primary partition accepting all defaults
B.dd if=/dev/zero of=/dev/sdb bs=1M count=1
C.mkfs.ext4 /dev/sdb
D.parted /dev/sdb mklabel gpt && parted /dev/sdb mkpart primary 0% 100%
AnswerD

Correctly creates a GPT label and a partition spanning the entire disk.

Why this answer

It uses parted to first create a GPT partition table on /dev/sdb (mklabel gpt) and then creates a single primary partition spanning the entire disk (mkpart primary 0% 100%). This is the proper method to partition the whole disk as one partition, ensuring the disk has a valid partition table and a defined partition that can later be formatted.

Exam trap

The trap here is that candidates may think fdisk with default options creates a full-disk partition, but fdisk defaults to a small partition size unless the user explicitly specifies the end sector, leading to an incomplete partition.

How to eliminate wrong answers

Option A is wrong because fdisk with all defaults does not automatically create a partition that uses the entire disk; it typically creates a partition of a default size (e.g., 2048 sectors) unless the user manually specifies the end sector. Option B is wrong because dd if=/dev/zero of=/dev/sdb bs=1M count=1 only wipes the first 1 MB of the disk (overwriting the boot sector and partition table), but does not create any partition. Option C is wrong because mkfs.ext4 /dev/sdb attempts to create a filesystem directly on the raw block device without a partition table, which is not a standard partitioning method and will fail or produce an unpartitioned filesystem that cannot be used as a partitioned disk.

Practice this question →
29
MCQmedium

An administrator wants to add a kernel parameter 'quiet splash' to the default boot entry. Which file should be edited?

A./etc/default/grub
B./etc/grub.d/00_header
C./etc/grub.conf
D./boot/grub/grub.cfg
AnswerA

This is the configuration file where kernel parameters are set and then applied by running update-grub.

Why this answer

The correct file to edit is /etc/default/grub because it is the main configuration file for GRUB 2 where kernel boot parameters like 'quiet splash' are defined in the GRUB_CMDLINE_LINUX_DEFAULT variable. After editing this file, the administrator must run update-grub (or grub-mkconfig) to regenerate the actual boot configuration file /boot/grub/grub.cfg.

Exam trap

The trap here is that candidates often confuse the auto-generated /boot/grub/grub.cfg (option D) with the source configuration file, or mistakenly think the legacy /etc/grub.conf (option C) is still used in GRUB 2 environments.

How to eliminate wrong answers

Option B is wrong because /etc/grub.d/00_header is a script that generates part of the GRUB 2 configuration, not a file where kernel parameters are directly set; editing it would be overwritten on updates and is not the intended method. Option C is wrong because /etc/grub.conf is a legacy file used by GRUB Legacy (version 0.97) and is not the standard location for GRUB 2 on modern Linux distributions. Option D is wrong because /boot/grub/grub.cfg is the auto-generated boot configuration file; editing it directly is discouraged as changes are overwritten by update-grub and it is not the source of truth for kernel parameters.

Practice this question →
30
MCQmedium

The system administrator wants to add a new swap partition on /dev/sdb2. After creating the partition, which command should be used to initialize it as swap?

A.mkfs.ext4 /dev/sdb2
B.fsck /dev/sdb2
C.mkswap /dev/sdb2
D.swapon /dev/sdb2
AnswerC

mkswap sets up a Linux swap area.

Why this answer

The `mkswap` command is specifically designed to initialize a partition or file as a swap area by writing a swap signature (UUID and swap superblock) to the device. After creating the partition, you must run `mkswap /dev/sdb2` to set it up for use as swap before activating it with `swapon`.

Exam trap

The trap here is that candidates often confuse `swapon` (which activates swap) with `mkswap` (which initializes it), mistakenly thinking `swapon` can both prepare and enable the swap area.

How to eliminate wrong answers

Option A is wrong because `mkfs.ext4` creates an ext4 filesystem, which is a standard data filesystem, not a swap area; using it would overwrite the partition with filesystem metadata, making it unusable as swap. Option B is wrong because `fsck` checks and repairs an existing filesystem, but it cannot initialize a partition as swap and would fail on a partition without a recognized filesystem. Option D is wrong because `swapon` activates an already-initialized swap area; it cannot initialize a partition that has not been set up with `mkswap` first.

Practice this question →
31
MCQmedium

A technician is troubleshooting a system that fails to boot with the error 'Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)'. What is the most likely cause?

A.The init binary is missing or corrupted.
B.The root filesystem is corrupted and needs fsck.
C.The kernel lacks the necessary driver for the storage controller.
D.The boot loader is not installed correctly.
AnswerC

Kernel cannot access the root device due to missing storage driver.

Why this answer

The error 'VFS: Unable to mount root fs on unknown-block(0,0)' indicates that the kernel cannot locate or access the root filesystem. This typically occurs because the kernel lacks the necessary driver (module) for the storage controller (e.g., SATA, SCSI, NVMe) that the root device is connected to, so it cannot read the partition table or mount the root filesystem.

Exam trap

The trap here is that candidates often confuse a root filesystem corruption error with a missing storage driver error, because both can prevent booting, but the specific 'unknown-block(0,0)' message uniquely points to the kernel's inability to identify the block device, not a filesystem issue.

How to eliminate wrong answers

Option A is wrong because a missing or corrupted init binary would cause a different error, such as 'Kernel panic - not syncing: No init found' or 'Failed to execute /sbin/init', not a VFS mount failure on unknown-block(0,0). Option B is wrong because a corrupted root filesystem would typically produce filesystem-specific errors (e.g., 'EXT4-fs error') or a kernel panic with a different message, not the unknown-block(0,0) error which indicates the device itself is unrecognized. Option D is wrong because an incorrectly installed boot loader would prevent the kernel from being loaded at all (e.g., 'Missing operating system' or 'GRUB error'), not cause the kernel to fail mounting the root filesystem after it has already started executing.

Practice this question →
32
MCQeasy

Which directory contains information about hardware devices in a hierarchical structure, such as PCI devices and USB devices?

A./sys
B./dev
C./etc
D./proc
AnswerA

/sys (sysfs) provides detailed device hierarchy and attributes.

Why this answer

The /sys directory (sysfs) is a virtual filesystem that exports information about hardware devices, drivers, and kernel objects in a hierarchical structure. It organizes devices by their bus type (e.g., PCI, USB) and provides detailed attributes such as vendor IDs, device IDs, and power management states, making it the correct location for querying hardware topology.

Exam trap

The trap here is that candidates confuse /proc (which also contains some hardware info like /proc/cpuinfo) with /sys, but /proc lacks the structured, hierarchical device topology that sysfs provides for buses like PCI and USB.

How to eliminate wrong answers

Option B (/dev) is wrong because it contains device special files (e.g., /dev/sda, /dev/ttyUSB0) for accessing hardware via block or character I/O, not a hierarchical representation of device relationships. Option C (/etc) is wrong because it stores system configuration files (e.g., /etc/fstab, /etc/ssh/sshd_config), not dynamic hardware information. Option D (/proc) is wrong because it primarily exposes process and kernel runtime data (e.g., /proc/cpuinfo, /proc/meminfo) in a flat or process-centric structure, not a hierarchical device tree.

Practice this question →
33
MCQeasy

The administrator wants the sshd service to start automatically at boot. Which command should be used?

A.systemctl start sshd.service
B.systemctl daemon-reload
C.systemctl set-default multi-user.target
D.systemctl enable sshd.service
AnswerD

Enables the service to start automatically at boot.

Why this answer

The `systemctl enable sshd.service` command creates the necessary symlinks in the systemd unit configuration directories (e.g., `/etc/systemd/system/multi-user.target.wants/`) so that the sshd service is automatically started when the system boots into its default target. This is the correct way to enable a service to start at boot in a systemd-based Linux distribution.

Exam trap

The trap here is confusing `systemctl start` (immediate, one-time activation) with `systemctl enable` (persistent boot-time activation), leading candidates to choose option A when the question asks for automatic startup at boot.

How to eliminate wrong answers

Option A is wrong because `systemctl start sshd.service` only starts the service immediately in the current session; it does not configure it to start automatically at boot. Option B is wrong because `systemctl daemon-reload` reloads the systemd manager configuration after unit files have been changed, but it does not enable or disable any service for boot-time startup. Option C is wrong because `systemctl set-default multi-user.target` changes the default systemd target (runlevel) that the system boots into, but it does not enable a specific service like sshd to start at boot.

Practice this question →
34
MCQmedium

Which command can be used to check whether a specific kernel module is currently loaded?

A.modinfo <module>
B.lsmod | grep <module>
C.depmod -a
D.insmod <module>
AnswerB

lsmod lists loaded modules; grep filters.

Why this answer

`lsmod` lists all currently loaded kernel modules by reading the `/proc/modules` file, and piping its output through `grep` filters for the specific module name. This directly shows whether the module is loaded in the running kernel, which is the exact requirement of the question.

Exam trap

The trap here is that candidates confuse `modinfo` (which shows module information from disk) with `lsmod` (which shows runtime load status), leading them to incorrectly select option A.

How to eliminate wrong answers

Option A is wrong because `modinfo` displays metadata about a kernel module (such as description, author, and parameters) from the module file itself, but it does not check whether the module is currently loaded into the kernel. Option C is wrong because `depmod -a` generates dependency files (modules.dep) for all modules in the kernel tree, but it does not report on the current load status of any module. Option D is wrong because `insmod` is used to insert (load) a module into the kernel, not to check if it is already loaded; attempting to load an already-loaded module will typically fail with an error like 'File exists'.

Practice this question →
35
Multi-Selectmedium

Which TWO commands can display the UUID of block devices?

Select 2 answers
A.blkid
B.lsblk -f
C.df -T
D.fdisk -l
E.parted /dev/sda print
AnswersA, B

blkid displays block device attributes including UUID.

Why this answer

The `blkid` command directly queries the libblkid library to locate and display block device attributes, including the UUID, from the device's superblock. `lsblk -f` lists block devices and their filesystem information, which includes the UUID, by reading sysfs and udev databases. Both commands reliably output the UUID for block devices.

Exam trap

The trap here is that candidates confuse commands that display partition table information (like `fdisk` and `parted`) with commands that display filesystem metadata (like `blkid` and `lsblk -f`), leading them to select options that show partition layout but not UUIDs.

Practice this question →
36
MCQeasy

Which command displays information about currently loaded kernel modules?

A.insmod
B.modinfo
C.lsmod
D.modprobe -l
AnswerC

Lsmod shows currently loaded kernel modules from /proc/modules.

Why this answer

The `lsmod` command reads the `/proc/modules` file to display a list of all currently loaded kernel modules, showing their name, size, usage count, and dependent modules. This is the standard tool for querying the current module state in the Linux kernel.

Exam trap

The trap here is that candidates confuse `lsmod` (list loaded modules) with `modinfo` (show module metadata) or `modprobe -l` (list available modules), because all three commands relate to kernel modules but serve distinct purposes.

How to eliminate wrong answers

Option A is wrong because `insmod` is used to insert a kernel module into the running kernel, not to display information about loaded modules. Option B is wrong because `modinfo` displays metadata (such as description, author, and parameters) from a module file, not a list of currently loaded modules. Option D is wrong because `modprobe -l` is a deprecated option that listed available module files in the module tree, not currently loaded modules; modern `modprobe` does not support `-l` and it was never used to show loaded modules.

Practice this question →
37
MCQmedium

Refer to the exhibit. The system has a single disk with three partitions. Which partition contains the root filesystem?

A.sda
B.sda1
C.sda2
D.sda3
AnswerD

sda3 is mounted at / (root).

Why this answer

The root filesystem is mounted from the partition that contains the / (root) directory. In Linux, partitions are numbered starting from 1 (e.g., sda1, sda2, sda3). The device sda itself refers to the entire disk, not a partition.

Since the system has three partitions and the correct answer is sda3, partition sda3 must be the one designated as the root filesystem, typically identified by the mount point '/' in /etc/fstab or by the kernel boot parameter root=.

Exam trap

The trap here is that candidates often confuse the entire disk device (sda) with a partition (sda1, sda2, sda3), or assume the root filesystem is always on the first partition (sda1), ignoring that it can be on any numbered partition based on system design.

How to eliminate wrong answers

Option A is wrong because sda refers to the entire disk device, not a partition; the root filesystem must reside on a partition, not the raw disk. Option B is wrong because sda1 is a partition, but it is typically used for /boot or swap, not the root filesystem, unless explicitly configured; the question indicates sda3 is correct, so sda1 is not the root. Option C is wrong because sda2 is a partition, but it is often used for swap or extended partitions, and the correct answer is sda3, meaning sda2 does not contain the root filesystem in this scenario.

Practice this question →
38
MCQmedium

An administrator is migrating a legacy service from a SysV init system to a systemd unit. The service is a long-running daemon that forks once. The admin writes a unit file of Type=forking, sets PIDFile correctly, and enables the service. On the next reboot, the service starts but systemd reports that the service entered 'failed' state shortly after start, even though the process is running. The log shows: 'PID file /var/run/myservice.pid not readable (yet?) after start.' What is the most likely cause? Options: A) The service does not write its PID file quickly enough, B) The PIDFile path is wrong, C) The unit file should use Type=simple instead, D) The service needs a TimeoutStartSec increase.

A.The PIDFile path is wrong
B.The service does not write its PID file quickly enough
C.The service needs a TimeoutStartSec increase
D.The unit file should use Type=simple instead
AnswerB

Systemd expects the PID file shortly after the forking process exits; a delay causes failure.

Why this answer

The error message 'PID file /var/run/myservice.pid not readable (yet?) after start' indicates that systemd started the service and is waiting for the PID file to appear, but the file was not created within the default timeout (5 seconds for Type=forking). Since the service forks once, systemd expects the parent to exit and the child to write its PID to the file. If the daemon takes longer than TimeoutStartSec to write the PID file, systemd marks the unit as failed even though the process is still running.

Option B, "The service does not write its PID file quickly enough," correctly identifies this timing issue. Option A, "The PIDFile path is wrong," is incorrect because the log message explicitly says the PID file is not readable *yet*, implying the path is correct but the file has not been written. Option C, "The service needs a TimeoutStartSec increase," is incorrect because TimeoutStartSec is not about the PID file creation; it's about the time systemd waits for the start operation to complete.

Option D, "The unit file should use Type=simple instead," is incorrect because Type=simple would not wait for a PID file at all, but the service is designed to fork (which Type=simple cannot handle properly), and the error indicates systemd is expecting a PID file.

Exam trap

The trap here is that candidates often assume a 'failed' state means the process crashed, when in fact systemd's failure can be due to a timing mismatch between the daemon's startup behavior and the default timeout for PID file creation.

How to eliminate wrong answers

Option A is wrong because the PIDFile path is correctly set and the error message confirms systemd is looking for it at the right location; a wrong path would produce a different error like 'PID file not found' or 'does not exist'. Option C is wrong because increasing TimeoutStartSec would only extend the wait period, but the core issue is that the PID file is not being written quickly enough relative to the default timeout; however, the question asks for the 'most likely cause', and the log message directly points to the file not being readable yet, not a timeout expiration. Option D is wrong because using Type=simple would make systemd assume the main process is the one started by ExecStart, which would not match the forking behavior and could cause systemd to lose track of the daemon, leading to incorrect state tracking or inability to stop the service properly.

Practice this question →
39
MCQeasy

Which directory contains the kernel modules for the currently running kernel?

A./boot
B./etc/modprobe.d
C./usr/src
D./lib/modules/$(uname -r)
AnswerD

Standard location for kernel modules.

Why this answer

The kernel modules for the currently running kernel are stored in /lib/modules/$(uname -r). The uname -r command returns the exact kernel release version, and the corresponding directory contains all loadable kernel modules (.ko files) compiled for that specific kernel. This is the standard location used by the kernel and tools like modprobe and insmod to locate and load modules.

Exam trap

The trap here is that candidates confuse the location of kernel modules with the kernel image itself (/boot) or with configuration files (/etc/modprobe.d), failing to recognize that modules are version-specific and stored under /lib/modules.

How to eliminate wrong answers

Option A is wrong because /boot contains the kernel image (vmlinuz), initramfs, and bootloader configuration files, not the kernel modules. Option B is wrong because /etc/modprobe.d contains configuration files for modprobe (e.g., aliases, blacklists, options), not the actual module binaries. Option C is wrong because /usr/src typically contains kernel source code or headers, not compiled modules; modules are built from source but stored separately in /lib/modules.

Practice this question →
40
MCQhard

An administrator needs to ensure that a specific kernel module is loaded automatically at boot. Which file should be used to permanently load the module?

A./etc/modprobe.d/modules.conf
B./etc/sysconfig/modules
C./etc/modules
D./etc/conf.modules
AnswerC

Modules listed in /etc/modules are loaded at boot.

Why this answer

On modern Linux systems using a standard init system, the file /etc/modules (or /etc/modules-load.d/*.conf on systemd-based distributions) is read at boot to load specified kernel modules automatically. This file lists module names one per line, and the kernel's module loading mechanism processes it early in the boot sequence to ensure the module is available before services that depend on it start.

Exam trap

The trap here is that candidates confuse the configuration file for module options (/etc/modprobe.d/*.conf) with the file that lists modules to load at boot (/etc/modules), or they mistakenly recall the obsolete /etc/conf.modules from older Linux distributions.

How to eliminate wrong answers

Option A is wrong because /etc/modprobe.d/modules.conf is not a standard file; the correct directory is /etc/modprobe.d/ where files like *.conf are used for modprobe configuration (e.g., aliases, options, blacklists), not for specifying modules to load at boot. Option B is wrong because /etc/sysconfig/modules is not a standard path; on Red Hat-based systems, /etc/sysconfig/modules/ is a directory for custom module-loading scripts, but the primary mechanism for permanent module loading is /etc/modules or /etc/modules-load.d/. Option D is wrong because /etc/conf.modules is an obsolete file from older kernel versions (pre-2.6) and is not used by modern modprobe or systemd; it has been replaced by /etc/modprobe.d/ and /etc/modules.

Practice this question →
41
MCQeasy

A technician needs to output only the kernel release number. Which command should be used?

A.cat /proc/version
B.uname -r
C.dmesg | head -1
D.lsmod
AnswerB

uname -r outputs the exact kernel release number.

Why this answer

The `uname -r` command specifically prints the kernel release number (e.g., '5.10.0-28-amd64') by querying the `utsname` system call. This is the standard, portable way to retrieve only the kernel release string without additional system information.

Exam trap

The trap here is that candidates confuse `/proc/version` (which shows the full version string) with a command that outputs only the release number, or they assume `dmesg` output is consistent across all systems.

How to eliminate wrong answers

Option A is wrong because `cat /proc/version` outputs the full version string including the kernel release, compiler version, and build timestamp, not just the release number. Option C is wrong because `dmesg | head -1` shows the first line of the kernel ring buffer, which typically includes the kernel version and build info but is not guaranteed to be just the release number and may vary by system or boot. Option D is wrong because `lsmod` lists loaded kernel modules, not the kernel release number.

Practice this question →
42
MCQmedium

A server with a udev rule fails to consistently assign a persistent network interface name. What is the most likely cause?

A.The rule uses an incorrect operator.
B.The BIOS device name is configured incorrectly.
C.The kernel module for the NIC is not loaded.
D.The network interface's MAC address is not unique or changes.
AnswerD

If the MAC address changes, a rule matching by MAC will fail.

Why this answer

Persistent network interface names in Linux rely on udev rules that match attributes like MAC address. If the MAC address is not unique (e.g., due to a virtual machine or cloned NIC) or changes (e.g., after hardware replacement or driver update), the rule will fail to consistently identify the interface, causing the name assignment to be unpredictable.

Exam trap

The trap here is that candidates assume udev rules always work if the syntax is correct, overlooking that dynamic or non-unique MAC addresses undermine the stability of the matching attribute.

How to eliminate wrong answers

Option A is wrong because an incorrect operator (e.g., using '==' instead of '!=') would cause a syntax error or mis-match, but the question describes inconsistent assignment, not a complete failure; the rule still runs but the matching attribute is unreliable. Option B is wrong because BIOS device names (like 'eno1') are a naming scheme, not a cause of udev rule failure; incorrect BIOS configuration might affect the name format but does not prevent consistent assignment if the rule uses a stable attribute. Option C is wrong because if the kernel module for the NIC were not loaded, the interface would not appear at all, leading to a persistent failure rather than inconsistent naming.

Practice this question →
43
MCQmedium

An administrator runs 'lsmod' and sees a module with a usage count of 1. What does this indicate?

A.The module is loaded but not used by any process
B.The module is being used by one other module
C.One process is holding a reference to the module
D.The module has one dependency
AnswerC

The usage count indicates the number of active references.

Why this answer

The usage count in lsmod indicates how many processes or kernel subsystems currently hold a reference to the module. A count of 1 means exactly one process has opened the module (e.g., via a file descriptor or ioctl) or the module is in use by a single kernel component. This is the standard interpretation per the Linux kernel module loader (kmod) and is reflected in the /proc/modules file.

Exam trap

The trap here is that candidates confuse the usage count with the number of dependent modules or think it counts processes that have loaded the module, when in fact it counts active references (e.g., open file handles, mounted filesystems, or kernel subsystems) that prevent the module from being unloaded.

How to eliminate wrong answers

Option A is wrong because a usage count of 0 means the module is loaded but not used by any process; a count of 1 indicates active use. Option B is wrong because the usage count does not track inter-module dependencies; dependencies are shown separately in the 'Used by' column of lsmod, and a module used by another module would show that other module's name, not a numeric count. Option D is wrong because the usage count is unrelated to the number of dependencies; dependencies are listed in the 'Depends' column of lsmod, and a module can have many dependencies while still having a usage count of 1.

Practice this question →
44
Multi-Selectmedium

Which THREE of the following are valid systemd targets?

Select 3 answers
A.poweroff.target
B.rescue.target
C.reboot.target
D.halt.target
E.shutdown.target
AnswersA, C, D

Poweroff.target is a standard systemd target that shuts down and powers off the system. It is correct.

Why this answer

The correct answers are poweroff.target (A), reboot.target (C), and halt.target (D). These are standard systemd targets: poweroff.target initiates a clean shutdown and power-off, reboot.target triggers a reboot, and halt.target halts the system without powering off. While rescue.target (B) is also a valid systemd target, it is not one of the three asked for by this question; the question specifically requests three valid targets, and the set {poweroff, reboot, halt} is a common selection. shutdown.target (E) is not a standard systemd target; the equivalent is poweroff.target.

Exam trap

Candidates may assume that halt.target is not a valid target because it is less commonly used, but it is valid. Alternatively, they may include rescue.target instead of halt.target because rescue is also valid, but the question expects three specific targets.

Practice this question →
45
MCQeasy

During boot, the kernel must mount the root filesystem. Which of the following is responsible for providing the kernel with the location of the root filesystem?

A.udev
B.initramfs
C.init
D.boot loader
AnswerD

The boot loader passes root= parameter to the kernel.

Why this answer

The boot loader (e.g., GRUB) is responsible for loading the kernel into memory and passing it the location of the root filesystem via kernel command-line parameters such as `root=`. Without this parameter, the kernel would not know which block device or partition to mount as `/`. The boot loader reads configuration files (e.g., `grub.cfg`) that specify this parameter, making it the direct provider of the root filesystem location.

Exam trap

The trap here is that candidates often confuse initramfs as the provider of the root filesystem location, when in fact initramfs is a tool that uses the location provided by the boot loader to mount the real root filesystem.

How to eliminate wrong answers

Option A is wrong because udev is a device manager that runs in userspace after the root filesystem is mounted; it handles device node creation and hotplug events, not kernel boot parameters. Option B is wrong because initramfs is a temporary root filesystem loaded by the boot loader that contains tools and drivers to mount the real root filesystem, but it does not itself provide the location; it relies on the `root=` parameter passed by the boot loader. Option C is wrong because init is the first userspace process (PID 1) started after the root filesystem is mounted; it manages services and system initialization, not the kernel's boot-time root filesystem location.

Practice this question →
46
Multi-Selecteasy

Which TWO commands can be used to obtain information about the CPU architecture of a Linux system?

Select 2 answers
A.uname -m
B.lscpu
C.dmidecode -t processor
D.cat /proc/cpuinfo
E.lspci
AnswersB, D

Displays CPU architecture details including cores, threads, model name, etc.

Why this answer

B is correct because `lscpu` is a dedicated command that reads and aggregates CPU architecture information from `/sys` and `/proc/cpuinfo`, presenting it in a clean, human-readable format. It provides details such as CPU model, cores, threads, architecture type, and cache sizes, making it a standard tool for CPU architecture queries on Linux.

Exam trap

The trap here is that candidates often pick `uname -m` (option A) thinking it provides full CPU architecture details, but it only outputs a single string like 'x86_64', whereas the question asks for 'information about the CPU architecture' in a broader sense, which `lscpu` and `/proc/cpuinfo` satisfy.

Practice this question →
47
MCQhard

A system has multiple CPUs but only one is being used. Which file under /sys/ can be checked to verify CPU online status?

A./sys/devices/system/cpu/online
B./proc/cpuinfo
C./sys/class/cpu
D./sys/devices/system/cpu/cpu0/online
AnswerD

Contains a 1 if online, 0 if offline for CPU0.

Why this answer

/sys/devices/system/cpu/cpu0/online is the sysfs file that directly shows the online status of CPU 0. Reading this file returns '1' if the CPU is online and '0' if it is offline, allowing per-CPU verification. The question specifies checking a file under /sys/, and this path is the standard sysfs interface for CPU hotplug status.

Exam trap

The trap here is that candidates confuse the summary file /sys/devices/system/cpu/online (which shows a range) with the per-CPU online file, or incorrectly assume /proc/cpuinfo is under /sys, leading them to choose Option A or B instead of the correct per-CPU path.

How to eliminate wrong answers

Option A is wrong because /sys/devices/system/cpu/online lists the ranges of CPUs that are currently online (e.g., '0-3'), but it does not provide per-CPU online status for a single CPU; it is a summary file, not a per-CPU check. Option B is wrong because /proc/cpuinfo is under /proc, not /sys, and while it shows CPU information, it does not reflect dynamic online/offline status via sysfs; it is a static snapshot of detected CPUs. Option C is wrong because /sys/class/cpu does not exist; the correct sysfs class for CPUs is /sys/devices/system/cpu, and /sys/class/ contains device classes like 'net' or 'block', not 'cpu'.

Practice this question →
48
MCQmedium

A system administrator needs to create a new Logical Volume (LV) in an existing LVM setup. Which sequence of commands is correct?

A.vgcreate, pvcreate, lvcreate
B.pvcreate, vgcreate, lvcreate
C.pvcreate, lvcreate, vgcreate
D.lvcreate, vgcreate, pvcreate
AnswerB

Correct order: PV first, then VG, then LV.

Why this answer

The correct sequence is pvcreate, vgcreate, lvcreate because in LVM, you must first initialize physical volumes (PVs) with pvcreate, then combine them into a volume group (VG) with vgcreate, and finally create the logical volume (LV) from the VG's free space with lvcreate. This order reflects the dependency chain: a VG requires PVs, and an LV requires a VG.

Exam trap

The trap here is that candidates may confuse the order of LVM setup steps, often thinking vgcreate comes first because it 'groups' volumes, but the physical volume initialization must always precede volume group creation.

How to eliminate wrong answers

Option A is wrong because vgcreate cannot run before pvcreate — a volume group requires initialized physical volumes (PVs) to exist. Option C is wrong because lvcreate cannot run before vgcreate — a logical volume must be created from an existing volume group. Option D is wrong because lvcreate, vgcreate, and pvcreate are all out of order; you cannot create a logical volume without a volume group, nor a volume group without physical volumes.

Practice this question →
49
MCQhard

Refer to the exhibit. A Linux system fails to boot with a kernel panic. The dmesg output shows the disk is detected and partitions are recognized. Which of the following is the most likely cause of the kernel panic?

A.The root filesystem cannot be mounted because the root= kernel parameter points to a non-existent or incorrect device.
B.The kernel module for the SATA controller is missing from the initramfs.
C.The SATA controller is not supported by the kernel.
D.The disk has bad sectors causing read errors during boot.
AnswerA

The kernel detects the disk and partitions but then panics, likely because it cannot mount the root filesystem, often due to an incorrect root= parameter.

Why this answer

A is correct because the kernel panic occurs after the disk and partitions are detected, indicating the kernel can see the hardware but cannot mount the root filesystem. The most common cause is an incorrect or missing `root=` kernel parameter in the bootloader configuration (e.g., GRUB), which specifies the root device (e.g., `/dev/sda1` or `UUID=...`). If this parameter points to a non-existent or wrong partition, the kernel cannot pivot to the root filesystem, leading to a panic.

Exam trap

The trap here is that candidates see the disk is detected and assume hardware is fine, then incorrectly blame the SATA controller or initramfs, missing the subtle point that the kernel panic occurs specifically because the root filesystem cannot be mounted due to a misconfigured `root=` parameter.

How to eliminate wrong answers

Option B is wrong because if the SATA controller module were missing from the initramfs, the disk would not be detected at all, but the dmesg output shows the disk is detected and partitions are recognized. Option C is wrong because the SATA controller is clearly supported by the kernel, as the disk is detected and partitions are recognized, contradicting a lack of support. Option D is wrong because bad sectors causing read errors would typically produce I/O errors or filesystem corruption messages, not a kernel panic at the stage where the root filesystem cannot be mounted; the panic occurs before any filesystem read attempts.

Practice this question →
50
MCQeasy

A Linux system fails to boot after installing a new kernel. Which step should be taken first to recover the system?

A.Edit GRUB configuration at boot to select the old kernel
B.Reinstall the original kernel using a live CD
C.Boot into single-user mode to fix the kernel
D.Use the rescue mode from installation media
AnswerA

At GRUB menu, press 'e' to edit and change the kernel line to the old kernel.

Why this answer

When a new kernel fails to boot, the quickest recovery method is to select the previous working kernel from the GRUB boot menu. GRUB typically retains the old kernel entry in its menu (e.g., 'Advanced options for Ubuntu' or a similar submenu), allowing you to boot the system without any external media or reinstallation. This approach avoids the overhead of using a live CD or rescue mode and directly restores functionality.

Exam trap

The trap here is that candidates often assume a failed kernel boot requires external recovery media (live CD or rescue mode) or single-user mode, forgetting that GRUB’s boot menu already provides direct access to the old kernel without any additional tools.

How to eliminate wrong answers

Option B is wrong because reinstalling the original kernel using a live CD is unnecessary and time-consuming; the old kernel is already present on the disk and accessible via GRUB. Option C is wrong because single-user mode still requires a bootable kernel; if the new kernel fails to load, you cannot reach single-user mode without first selecting a working kernel. Option D is wrong because rescue mode from installation media is a valid recovery method but is a more drastic step that should only be used if the GRUB menu itself is corrupted or the old kernel entry is missing.

Practice this question →
51
MCQeasy

What is stored in the first sector of a hard disk (Master Boot Record)?

A.The Master Boot Record (boot loader and partition table)
B.The partition table only
C.The Linux kernel
D.The root filesystem
AnswerA

The MBR contains boot loader code and partition table.

Why this answer

The Master Boot Record (MBR) occupies the first sector (sector 0, 512 bytes) of a hard disk and contains both the boot loader code (first 446 bytes) and the partition table (next 64 bytes), plus a 2-byte signature (0x55AA). This structure is essential for BIOS-based booting, as the BIOS loads the MBR into memory and executes the boot loader, which then uses the partition table to locate the active partition and load the operating system.

Exam trap

The trap here is that candidates often confuse the MBR with the entire boot process, mistakenly thinking the kernel or root filesystem is directly stored in the first sector, when in reality the MBR only contains minimal boot code and partition metadata.

How to eliminate wrong answers

Option B is wrong because the partition table alone is only part of the MBR; the MBR also includes the boot loader code and the signature, so the partition table is not stored in isolation. Option C is wrong because the Linux kernel is never stored in the MBR; it resides on a filesystem (e.g., /boot) and is loaded later by a boot loader like GRUB. Option D is wrong because the root filesystem is a mounted filesystem (e.g., ext4) containing system directories and files, not a 512-byte sector; it is stored on a partition, not in the MBR.

Practice this question →
52
MCQhard

A system takes a long time to boot due to a service that fails to start. Which systemd command can be used to identify the service causing the delay?

A.journalctl -u service
B.systemctl status
C.systemd-analyze critical-chain
D.systemd-analyze blame
AnswerD

Lists services with their initialization time, sorted by longest.

Why this answer

The `systemd-analyze blame` command prints a list of all running units, sorted by the time they took to initialize, making it the direct tool to identify which service is causing a boot delay. Unlike other options, it specifically measures and displays the initialization time of each unit, allowing you to pinpoint the slowest service.

Exam trap

The trap here is that candidates confuse `systemd-analyze critical-chain` (which shows the longest dependency chain) with `systemd-analyze blame` (which shows the actual time each unit took to start), leading them to choose C when D is the correct tool for identifying the specific slow service.

How to eliminate wrong answers

Option A is wrong because `journalctl -u service` shows the log entries for a specific service, but it does not provide a summary of boot-time durations or identify which service is slow; it requires you already know the service name. Option B is wrong because `systemctl status` shows the current status and recent logs of a service, but it does not display boot-time analysis or comparative initialization times. Option C is wrong because `systemd-analyze critical-chain` prints the critical chain of units that took the longest to boot, but it focuses on the chain of dependencies rather than listing all services sorted by their individual initialization time, so it may not directly show the single slowest service if it is not on the critical path.

Practice this question →
53
MCQeasy

Which command displays information about the CPU, including model name, cache size, and flags?

A.uname -a
B.lscpu
C.cat /proc/cpuinfo
D.dmidecode
AnswerB

lscpu displays CPU architecture information from /proc/cpuinfo.

Why this answer

The `lscpu` command is the correct choice because it is specifically designed to display CPU architecture information, including model name, cache sizes, and flags (such as SSE, AES, etc.), by reading data from sysfs and /proc/cpuinfo in a human-readable format. It provides a concise summary without requiring root privileges, making it the most appropriate tool for this task.

Exam trap

The trap here is that candidates often choose `cat /proc/cpuinfo` because it contains all the raw data, but the exam expects the command that is specifically designed to present CPU information in a readable summary, which is `lscpu`.

How to eliminate wrong answers

Option A is wrong because `uname -a` displays system kernel information (e.g., kernel name, hostname, kernel release, architecture), but it does not show CPU model name, cache size, or flags. Option C is wrong because while `cat /proc/cpuinfo` does contain all the requested CPU details, it outputs raw, verbose data that is not formatted for quick reading; the question asks for a command that 'displays information' in a practical sense, and `lscpu` is the standard utility for this purpose. Option D is wrong because `dmidecode` reads DMI/SMBIOS tables to provide hardware information (e.g., BIOS, motherboard, memory), but it requires root privileges and does not directly output CPU flags or cache details in a straightforward manner.

Practice this question →
54
MCQhard

A Linux system with a custom kernel fails to boot after a new kernel is compiled and installed. The boot process stops at a prompt: 'Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)'. The root filesystem is on /dev/sda2 with ext4. The system has an initramfs generated with dracut. The admin can boot from a previous kernel. Which is the most appropriate next step to troubleshoot and fix the issue? Options: A) Rebuild the initramfs using 'dracut --force --kver' with the correct kernel version, B) Add 'root=/dev/sda2' to the kernel command line, C) Use 'mkinitrd' with the '--preload' option for ext4 module, D) Run 'ldd /sbin/init' to check for missing libraries.

A.Run 'ldd /sbin/init' to check for missing libraries
B.Rebuild the initramfs using 'dracut --force --kver' with the correct kernel version
C.Use 'mkinitrd' with the '--preload' option for ext4 module
D.Add 'root=/dev/sda2' to the kernel command line
AnswerB

Regenerates the initramfs ensuring all necessary modules are included.

Why this answer

The 'Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)' error indicates the kernel cannot find or mount the root filesystem, often because the initramfs lacks the necessary drivers (e.g., ext4 module) for the new kernel. Rebuilding the initramfs with 'dracut --force --kver' ensures it includes the correct kernel modules for the newly compiled kernel, resolving the mismatch.

Exam trap

The trap here is that candidates may confuse a missing root parameter with a missing initramfs driver, or mistakenly think checking init dependencies (ldd) or using legacy tools (mkinitrd) will fix a kernel module mismatch.

How to eliminate wrong answers

Option A is wrong because 'ldd /sbin/init' checks for shared library dependencies of the init process, which is unrelated to the kernel's inability to mount the root filesystem due to missing drivers in the initramfs. Option C is wrong because 'mkinitrd' is a legacy tool (used on older distributions like RHEL 5) and not applicable to modern systems using dracut; also, '--preload' does not address the need to rebuild the initramfs for the new kernel version. Option D is wrong because adding 'root=/dev/sda2' to the kernel command line is unnecessary if the root device is already correctly specified; the error 'unknown-block(0,0)' suggests the initramfs lacks the storage driver (e.g., ext4 or SCSI), not that the root parameter is missing.

Practice this question →
55
MCQhard

A company runs a critical database server on Linux. The server has a hardware RAID controller with two logical volumes: one for the operating system (LV1) and one for the database data (LV2). The server uses LVM on top of the RAID volumes. Recently, the database performance has degraded. The administrator suspects that the file system on LV2 is heavily fragmented. The server uses the ext4 filesystem. The administrator wants to check the fragmentation level and, if necessary, defragment the filesystem without unmounting it or causing downtime. What should the administrator do to minimize fragmentation impact while maintaining availability?

A.Create a new filesystem on LV2, copy data back, and symlink the old mount point to the new one.
B.Use tune2fs to set the reserved block percentage to 0 and increase the inode size.
C.Schedule a maintenance window, unmount LV2, run e2fsck -fn, then run e2fsck -D to defragment.
D.Use the e4defrag command with the -v option on the mount point to check and defragment files online.
AnswerD

e4defrag can defragment files on a mounted ext4 filesystem, reducing fragmentation without downtime.

Why this answer

e4defrag is a userspace tool that provides online defragmentation for ext4 filesystems. It can check fragmentation levels and defragment files without unmounting the filesystem, thus avoiding downtime. This allows the administrator to minimize fragmentation impact while maintaining availability.

Exam trap

The trap here is that candidates may assume ext4 has no online defragmentation support at all, but e4defrag provides a limited online capability, or they may confuse e4defrag with e2fsck, which requires unmounting.

How to eliminate wrong answers

Option A is wrong because creating a new filesystem and copying data back requires unmounting LV2 or at least remounting it, causing downtime, and symlinking does not solve fragmentation on the original filesystem. Option B is wrong because tune2fs adjusts filesystem parameters like reserved blocks and inode size, but it does not perform defragmentation or check fragmentation levels. Option C is wrong because while e2fsck -D can defragment directories, it requires the filesystem to be unmounted, causing downtime, and the -fn option is for a read-only check, not defragmentation.

Practice this question →
56
MCQhard

A system administrator is responsible for a Linux server running a critical application. The server recently experienced an unplanned power outage. Upon rebooting, the system fails to reach the default target and drops into an emergency shell. The administrator notices that the root filesystem (/) is mounted read-only. The /etc/fstab file contains the following lines: UUID=abc123 / ext4 errors=remount-ro 0 1 UUID=def456 /home ext4 defaults 0 2 UUID=ghi789 none swap sw 0 0 The administrator suspects that the /home filesystem has a corrupt superblock and is causing the boot failure. The administrator needs to check and repair the /home filesystem without causing data loss. Which of the following is the correct course of action?

A.Reinstall the system from backup because the superblock corruption is fatal.
B.Boot from a live USB, run 'fsck /dev/sdb1' on the unmounted filesystem, then reboot.
C.Run 'fsck /dev/sdb1' from the emergency shell after remounting /home read-write.
D.Run 'fsck -y /dev/sdb1' from the emergency shell, but first run 'mount -o remount,rw /home' to make the filesystem writable.
AnswerB

Using a live environment ensures the filesystem is unmounted, allowing safe repair.

Why this answer

The /home filesystem is suspected to have a corrupt superblock, and running fsck on an unmounted filesystem from a live USB is the safest way to check and repair it without risking further damage. The emergency shell mounts the root filesystem read-only, and /home cannot be reliably checked while mounted or without proper access to its device node. Booting from a live USB ensures the filesystem is not in use, allowing fsck to safely repair the superblock or use an alternate superblock if needed.

Exam trap

The trap here is that candidates assume fsck can be run safely from the emergency shell on a mounted filesystem, but LPIC-1 emphasizes that fsck must only be run on unmounted filesystems to prevent data corruption.

How to eliminate wrong answers

Option A is wrong because superblock corruption is not automatically fatal; fsck can often repair it using an alternate superblock, and reinstalling from backup is an unnecessary and drastic measure. Option C is wrong because running fsck on a mounted filesystem (even if remounted read-write) can cause data corruption or further damage, as fsck requires the filesystem to be unmounted for safe operation. Option D is wrong because while remounting /home read-write is possible, running fsck on a mounted filesystem is still unsafe; additionally, the emergency shell may not have the device node name correct (e.g., /dev/sdb1) without verifying the actual device mapping.

Practice this question →
57
Multi-Selectmedium

Which TWO of the following are required for a system to boot using UEFI?

Select 2 answers
A.The bootloader installed in the ESP
B.An EFI System Partition (ESP) formatted with FAT32
C.The bootloader installed in the Master Boot Record (MBR)
D.A BIOS boot partition
E.A kernel with EFI stub support
AnswersA, B

The bootloader (e.g., GRUB) must be installed in the ESP for UEFI to find it.

Why this answer

In UEFI boot, the bootloader must reside in the EFI System Partition (ESP) as a file (e.g., /EFI/BOOT/BOOTX64.EFI) that the UEFI firmware can directly load. Option B is correct because the ESP must be formatted with FAT32 (or FAT16 for older systems) as per the UEFI specification, which requires a specific partition type (GUID C12A7328-F81F-11D2-BA4B-00A0C93EC93F for GPT) to store bootloaders and drivers.

Exam trap

The trap here is that candidates often confuse UEFI requirements with legacy BIOS requirements, mistakenly thinking the MBR or a BIOS boot partition is needed, or assuming EFI stub support is mandatory when it is only an optional feature for direct kernel booting.

Practice this question →
58
Multi-Selectmedium

Which TWO statements about GRUB 2 are correct?

Select 2 answers
A.After modifying /etc/default/grub, the command update-grub must be run to regenerate grub.cfg.
B.The GRUB configuration file read at boot is /boot/grub/grub.cfg.
C.GRUB 2 uses a configuration file named menu.lst.
D.The GRUB prompt can be accessed by pressing the 'e' key during boot.
E.The /etc/default/grub file is directly read by GRUB during boot.
AnswersA, B

update-grub (or grub-mkconfig) regenerates grub.cfg based on settings in /etc/default/grub.

Why this answer

After modifying /etc/default/grub, the update-grub command (which is a wrapper for grub-mkconfig) must be run to regenerate the /boot/grub/grub.cfg file. This ensures that changes to boot parameters, such as default timeout or kernel command-line options, are written into the actual configuration file that GRUB 2 reads at boot time.

Exam trap

The trap here is that candidates often confuse the GRUB 2 configuration workflow with GRUB Legacy, mistakenly thinking menu.lst is still used, or that pressing 'e' opens the GRUB prompt instead of the entry editor.

Practice this question →
59
MCQhard

The system is unable to mount a filesystem that should be identified by UUID 1234-5678. The administrator checks /etc/fstab and finds the entry: UUID=1234-5678 /data ext4 defaults 0 2. What is the most likely cause of the mount failure?

A.The /data mount point does not exist.
B.The device /dev/sda1 is not formatted with ext4.
C.The UUID in the fstab entry is incorrect.
D.The symlink for UUID 1234-5678 is broken.
AnswerD

The symlink exists but the target /dev/sda1 may not exist, causing a broken link and mount failure.

Why this answer

The most likely cause is that the symbolic link for UUID 1234-5678 is broken. In Linux, UUID-based mounts in /etc/fstab rely on symlinks in /dev/disk/by-uuid/ that point to the actual block device. If the symlink is missing or points to a non-existent device (e.g., after a disk reorder or hardware change), the system cannot resolve the UUID to a device, causing the mount to fail even if the filesystem itself is intact.

Exam trap

A common misconception is that mount failures are always due to a UUID mismatch in fstab, but the trap here is that the symlink in /dev/disk/by-uuid/ can be broken even when the UUID in fstab and on the filesystem match. This can happen after disk reordering or hardware changes.

How to eliminate wrong answers

Option A is wrong because if the mount point /data did not exist, the mount command would typically create it (with the 'defaults' option) or fail with a clear 'mount point does not exist' error, but the question implies a UUID resolution issue, not a missing directory. Option B is wrong because the filesystem type is specified as ext4 in fstab; if the device were not formatted with ext4, the mount would fail with a 'wrong fs type' error, not a UUID resolution failure. Option C is wrong because the UUID in the fstab entry is given as 1234-5678, and the question states the system is unable to mount a filesystem that should be identified by that UUID, implying the UUID is correct but the link to the device is broken.

Practice this question →
60
Multi-Selectmedium

Which THREE of the following are valid systemd service unit types?

Select 3 answers
A.oneshot
B.simple
C.runtime
D.exec
E.forking
AnswersA, B, E

A service that runs a command and exits; often used for setup scripts.

Why this answer

(oneshot) is correct because it is a valid systemd service unit type that defines a service where the main process runs once and exits, after which systemd considers the service as active. This is commonly used for tasks like filesystem checks or one-time initialization scripts.

Exam trap

The trap is that 'exec' might seem plausible, but it is not a valid systemd service unit type in the context of the LPIC-1 exam. The standard recognized types are simple, forking, oneshot, dbus, notify, and idle. 'Exec' is not included, and 'runtime' is invalid. The question expects exactly three correct answers: oneshot, simple, and forking.

Practice this question →
61
MCQeasy

Which systemd target corresponds to the traditional runlevel 3?

A.multi-user.target
B.graphical.target
C.emergency.target
D.rescue.target
AnswerA

Multi-user.target is the standard text mode, equivalent to runlevel 3.

Why this answer

In systemd, the 'multi-user.target' corresponds to the traditional SysV runlevel 3, which provides a multi-user, non-graphical environment with networking enabled. This target is the default for headless servers and is equivalent to the old /etc/inittab runlevel 3.

Exam trap

The trap here is that candidates often confuse 'rescue.target' with runlevel 3, when in fact rescue.target is the systemd equivalent of single-user mode (runlevel 1), while multi-user.target is the correct match for runlevel 3.

How to eliminate wrong answers

Option B (graphical.target) is wrong because it corresponds to runlevel 5, which adds a display manager (e.g., GDM, LightDM) on top of multi-user.target, not runlevel 3. Option C (emergency.target) is wrong because it is the most minimal target, starting only a single root shell on the console without networking or multi-user support, analogous to runlevel 1 or S. Option D (rescue.target) is wrong because it corresponds to runlevel 1 (single-user mode), pulling in basic system services but not a full multi-user environment.

Practice this question →
62
MCQmedium

A system administrator wants to disable the graphical target and boot to the text mode multi-user.target permanently. Which command should they run?

A.systemctl enable multi-user.target
B.systemctl isolate multi-user.target
C.systemctl set-default multi-user.target
D.systemctl default multi-user.target
AnswerC

This sets the default target for future boots.

Why this answer

`systemctl set-default multi-user.target` permanently changes the default systemd target to multi-user.target, ensuring the system boots into text mode (runlevel 3 equivalent) on every subsequent boot. This persists across reboots, unlike temporary switches.

Exam trap

The trap here is confusing runtime isolation (`isolate`) with persistent default setting (`set-default`), leading candidates to choose option B for a permanent change when it only affects the current session.

How to eliminate wrong answers

Option A is wrong because `systemctl enable multi-user.target` enables the target as a unit but does not set it as the default boot target; it only ensures the target is started if something requires it, not that the system boots into it. Option B is wrong because `systemctl isolate multi-user.target` immediately switches the current running target to multi-user.target but does not persist across reboots; it is a runtime change only. Option D is wrong because `systemctl default multi-user.target` is not a valid systemctl command; the correct syntax for resetting to the compiled-in default is `systemctl default` without arguments, and it does not accept a target name.

Practice this question →
63
MCQmedium

A Linux system fails to boot with the error: 'Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)'. What is the most likely cause?

A.Missing root filesystem
B.Corrupt kernel image
C.Damaged bootloader
D.Missing or incorrect initrd
AnswerD

Initrd contains drivers needed to mount root filesystem.

Why this answer

The error 'VFS: Unable to mount root fs on unknown-block(0,0)' indicates the kernel cannot locate or access the root filesystem during boot. The most common cause is a missing or incorrect initrd (initial RAM disk) that contains the necessary drivers (e.g., for SCSI, SATA, or filesystem modules) to mount the root partition. Without a proper initrd, the kernel lacks the modules to access the storage device, resulting in this panic.

Exam trap

The LPIC-1 exam often tests the distinction between a missing root filesystem and a missing initrd, trapping candidates who assume the error means the root partition itself is absent, when in fact the kernel cannot access it due to missing drivers in the initrd.

How to eliminate wrong answers

Option A is wrong because a missing root filesystem would typically produce a different error, such as 'No such device' or 'fsck' failures, not a kernel panic referencing 'unknown-block(0,0)', which specifically points to the kernel's inability to find the block device. Option B is wrong because a corrupt kernel image usually causes a panic earlier in the boot process (e.g., 'Kernel panic: Attempted to kill init!' or a crash during decompression), not a VFS mount failure with a block device number. Option C is wrong because a damaged bootloader (e.g., GRUB) would prevent the kernel from being loaded at all, resulting in a blank screen or 'No bootable device' error, not a kernel panic after the kernel has started executing.

Practice this question →
64
MCQhard

A system has a software RAID1 array (/dev/md0) with two disks: /dev/sda and /dev/sdb. Disk /dev/sda fails. Which command sequence will replace the failed disk with a new /dev/sdc without stopping the array?

A.mdadm --stop /dev/md0; replace disk; mdadm --assemble /dev/md0 /dev/sdb /dev/sdc
B.mdadm --manage /dev/md0 --fail /dev/sda --remove /dev/sda && mdadm --manage /dev/md0 --add /dev/sdc
C.Shutdown system, physically replace disk, reboot
D.dd if=/dev/sdb of=/dev/sdc bs=64K
AnswerB

Correct sequence: fail, remove, then add new disk.

Why this answer

Mdadm's --manage mode allows hot-replacement of a failed disk in a RAID1 array without stopping it. The --fail flag marks /dev/sda as faulty, --remove detaches it, and --add incorporates the new /dev/sdc, triggering an automatic rebuild of the mirror.

Exam trap

The trap here is that candidates assume a failed disk requires array shutdown or physical replacement before software reconfiguration, but mdadm's --manage subcommand allows all steps (fail, remove, add) while the array remains active.

How to eliminate wrong answers

Option A is wrong because stopping the array with --stop is unnecessary and disruptive; RAID1 supports online replacement, and reassembling requires all members, risking data loss if the array is degraded. Option C is wrong because shutting down the system is not required; hot-swap capable hardware and mdadm's online management allow disk replacement without downtime. Option D is wrong because dd directly copies /dev/sdb to /dev/sdc, which overwrites the new disk's partition table and metadata, and does not integrate the disk into the RAID array; mdadm --add must be used to incorporate the new disk.

Practice this question →
65
MCQmedium

A system administrator needs to ensure that the httpd service starts automatically when the system enters the multi-user.target. Which command should be used?

A.systemctl add-wants multi-user.target httpd.service
B.systemctl enable httpd
C.systemctl start httpd
D.systemctl set-default multi-user.target
AnswerB

Enables the service to start automatically on boot for the current default target.

Why this answer

The `systemctl enable httpd` command creates the necessary symlinks in the systemd unit configuration to ensure the httpd service starts automatically when the system enters the multi-user.target. This is the correct method to enable a service to start at boot in a systemd-based Linux system.

Exam trap

The trap here is confusing `systemctl start` (which only runs the service now) with `systemctl enable` (which configures it to start at boot), leading candidates to pick option C.

How to eliminate wrong answers

Option A is wrong because `systemctl add-wants` is not a valid systemd command; the correct command to add a dependency is `systemctl add-wants` (with a hyphen) but it is rarely used directly, and it does not enable the service for automatic start at boot. Option C is wrong because `systemctl start httpd` only starts the service immediately in the current session, but does not configure it to start automatically on subsequent boots. Option D is wrong because `systemctl set-default multi-user.target` sets the default target for the system (e.g., booting into multi-user mode), but does not enable any specific service to start automatically.

Practice this question →
66
MCQmedium

A system administrator notices that the server's clock is consistently off by several minutes. Which service should be used to synchronize the time with an external time source?

A.ntpd
B.timed
C.chronyd
D.systemd-timesyncd
AnswerA

ntpd is the standard NTP daemon for time synchronization.

Why this answer

The Network Time Protocol (NTP) daemon (ntpd) is the traditional and widely used service for synchronizing a server's clock with an external time source. It continuously adjusts the system time by communicating with NTP servers, compensating for clock drift and network delays to maintain accurate time. This makes ntpd the correct choice for resolving a consistent clock offset of several minutes.

Exam trap

The trap here is that candidates may confuse chronyd (a modern alternative) with ntpd, but LPIC-1 traditionally expects ntpd as the standard answer for time synchronization, even though chronyd is also correct in practice—the exam tests knowledge of the classic service name.

How to eliminate wrong answers

Option B (timed) is wrong because 'timed' is not a standard Linux time synchronization service; it is a legacy BSD tool for time synchronization and is not used in modern Linux distributions. Option C (chronyd) is wrong because although chronyd is a valid NTP client and server (part of the chrony suite) and can synchronize time, it is not the service named in the question's context—the question specifically asks for the service that should be used, and ntpd is the classic, expected answer for LPIC-1. Option D (systemd-timesyncd) is wrong because it is a lightweight SNTP client that only performs periodic time corrections and lacks the full NTP protocol capabilities (e.g., it cannot act as a time server or handle large clock offsets as effectively as ntpd), making it unsuitable for consistently correcting a several-minute offset.

Practice this question →
67
Multi-Selecteasy

Which TWO of the following are valid methods to change the default runlevel on a SysV init-based system?

Select 2 answers
A.Use the 'runlevel' command to set the default runlevel.
B.Edit /etc/inittab to set the initdefault line.
C.Pass the desired runlevel as a kernel parameter at boot time.
D.Use 'systemctl set-default' to set the default runlevel.
E.Use the 'telinit' command to change the default runlevel.
AnswersB, C

The initdefault line in /etc/inittab defines the default runlevel.

Why this answer

In SysV init-based systems, the default runlevel is defined in the /etc/inittab file by the 'initdefault' line, which specifies the runlevel the system should enter after boot. Editing this line is the standard method to permanently change the default runlevel. Option B correctly identifies this mechanism.

Exam trap

The trap here is that candidates confuse the 'runlevel' command (which only displays) with a command that can set the default, or they mistakenly apply systemd commands like 'systemctl set-default' to SysV init systems.

Practice this question →
68
Matchingmedium

Match each ACL term to its meaning.

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

Concepts
Matches

Permissions for a specific user

Permissions for a specific group

Maximum permissions for named users and groups

Permissions for everyone else

Inherited ACL for new files/directories

Why these pairings

The correct matches: Access ACL applies to files and directories; Default ACL applies to new objects; Mask limits permissions for named users/groups. Common confusions include applying ACLs only to directories or misinterpreting mask as owner permissions.

Practice this question →
69
MCQmedium

To add a kernel parameter temporarily to the kernel command line at boot, what key should be pressed in the GRUB menu?

A.e
B.b
C.r
D.c
AnswerA

Press 'e' to edit the selected boot entry.

Why this answer

Pressing 'e' in the GRUB menu enters the edit mode for the selected boot entry, allowing you to temporarily modify kernel parameters on the command line (e.g., adding 'single' for single-user mode or 'nomodeset' for graphics issues). These changes apply only to the current boot and are not saved to the GRUB configuration file.

Exam trap

The trap here is that candidates confuse the 'e' (edit) key with 'c' (command line) or 'b' (boot), assuming they can add parameters via the GRUB shell or by simply booting, but only 'e' provides direct access to modify the kernel command line for a single boot.

How to eliminate wrong answers

Option B is wrong because pressing 'b' in GRUB Legacy boots the selected entry immediately without any editing capability; it does not allow adding kernel parameters. Option C is wrong because pressing 'r' is not a standard GRUB key; it has no function in the GRUB menu for editing kernel parameters. Option D is wrong because pressing 'c' opens the GRUB command-line interface (a shell-like environment), not an editor for the kernel command line of a specific boot entry.

Practice this question →
70
MCQmedium

A system administrator needs to see the boot messages recorded by systemd-journald from the current boot. Which command is most appropriate?

A.journalctl -b
B.dmesg
C.tail -n 50 /var/log/syslog
D.cat /var/log/messages
AnswerA

Correctly shows all log entries from the current boot, including boot-time messages.

Why this answer

The `journalctl -b` command is the most appropriate because it specifically queries the systemd journal for messages from the current boot. Systemd-journald is the default logging daemon on modern Linux distributions, and `journalctl -b` filters the binary journal to show only entries with a boot ID matching the current boot, which includes kernel messages, service logs, and boot-time events.

Exam trap

The trap here is that candidates often confuse `dmesg` (which shows kernel messages) with the full boot log, or assume traditional syslog files like `/var/log/messages` are still the primary source on systemd-based systems, leading them to overlook the journal-specific `journalctl -b` command.

How to eliminate wrong answers

Option B is wrong because `dmesg` shows only kernel ring buffer messages, not the full set of boot messages recorded by systemd-journald (e.g., service startup logs). Option C is wrong because `tail -n 50 /var/log/syslog` reads a traditional text log file that may not exist on systems using journald, and it shows only the last 50 lines of general system logs, not specifically boot messages from the current boot. Option D is wrong because `/var/log/messages` is a legacy log file used by syslog, not by systemd-journald; on modern systems, this file may be absent or incomplete, and it does not provide a boot-specific filter.

Practice this question →
71
Drag & Dropmedium

Arrange the steps to configure a firewall rule using iptables to allow SSH.

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

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

iptables rules are added, then saved to a file, and persistence ensures they survive reboot.

Practice this question →
72
MCQhard

During boot, a sysadmin sees the message 'Buffer I/O error on device sda1, logical block 0'. What does this most likely indicate?

A.Incorrect partition table
B.Filesystem corruption
C.Bad sector on the disk
D.Missing kernel module for the device
AnswerC

I/O error on a specific block suggests hardware failure.

Why this answer

The 'Buffer I/O error on device sda1, logical block 0' message indicates that the kernel's block layer failed to read or write the first logical block (LBA 0) of the partition. This is a classic symptom of a physical bad sector on the disk surface, as the storage medium itself cannot reliably store or retrieve data at that location. Filesystem corruption or partition table issues would typically produce different error messages, such as 'invalid superblock' or 'partition table invalid'.

Exam trap

The trap here is that candidates often confuse a low-level block I/O error with filesystem corruption (Option B), but the error originates from the disk hardware layer, not the filesystem layer, and the specific mention of 'logical block 0' points to a physical sector issue rather than a logical structure problem.

How to eliminate wrong answers

Option A is wrong because an incorrect partition table would typically cause errors like 'invalid partition table' or 'unable to read partition table', not a buffer I/O error on a specific logical block of an existing partition. Option B is wrong because filesystem corruption usually manifests as 'superblock read error', 'fsck errors', or 'mount: wrong fs type', not a raw block-level I/O failure at logical block 0. Option D is wrong because a missing kernel module would prevent the device from being detected entirely, resulting in 'device not found' or 'unknown device' errors, not a buffer I/O error on an already recognized partition.

Practice this question →
73
MCQmedium

A system administrator notices that a server with a freshly installed Linux system fails to boot with the error 'No bootable device found'. The server has a single SATA hard disk connected to the motherboard's SATA controller. Which of the following is the most likely cause of this issue?

A.The root filesystem is formatted with an unsupported filesystem type.
B.The kernel module for the SATA controller is not included in the initramfs.
C.The GRUB bootloader configuration file is missing or corrupted.
D.The BIOS boot order is set to a device that does not contain a bootable operating system.
AnswerD

The BIOS attempts to boot from a device that lacks a bootloader, resulting in the error.

Why this answer

The error 'No bootable device found' occurs during the BIOS/UEFI POST phase, before any bootloader is loaded. This indicates that the system firmware cannot find a valid boot sector on any device in its boot order. Since the server has a single SATA hard disk, the most likely cause is that the BIOS boot order is set to a different device (e.g., a network boot or removable media) that does not contain a bootable operating system, or the hard disk itself is not listed first in the boot priority.

Exam trap

The trap here is that candidates often confuse a pre-boot firmware error with a bootloader or kernel issue, leading them to incorrectly select options related to GRUB configuration or initramfs modules, when the actual problem is a simple BIOS boot order misconfiguration.

How to eliminate wrong answers

Option A is wrong because an unsupported root filesystem type would cause a kernel panic or mount failure during the boot process, not a 'No bootable device found' error, which occurs before the kernel is loaded. Option B is wrong because a missing SATA controller kernel module in the initramfs would result in a kernel panic or inability to mount the root filesystem after the bootloader loads, not a pre-boot firmware error. Option C is wrong because a missing or corrupted GRUB configuration file would cause GRUB to drop to a rescue shell or display a GRUB-specific error, not a 'No bootable device found' message, which is issued by the BIOS/UEFI before any bootloader is executed.

Practice this question →
74
Multi-Selecthard

Which THREE of the following are characteristics of UEFI firmware compared to legacy BIOS? (Select exactly 3.)

Select 3 answers
A.Supports booting from disks larger than 2 TB.
B.Provides a graphical user interface during firmware setup.
C.Supports Secure Boot to prevent unauthorized operating systems from loading.
D.Uses the Master Boot Record partition table.
E.Requires a boot loader stored in the Master Boot Record.
AnswersA, B, C

UEFI uses GPT which supports large disks.

Why this answer

UEFI firmware uses the GUID Partition Table (GPT) instead of MBR, which supports 64-bit logical block addressing (LBA). This allows addressing disks larger than 2 TB, as the MBR scheme is limited to 32-bit LBA and a maximum addressable size of approximately 2.2 TB. Therefore, option A is correct.

Exam trap

The trap here is that candidates often confuse UEFI's support for GPT with MBR, incorrectly assuming UEFI still uses MBR for partition tables or boot loaders, leading them to select D or E as correct.

Practice this question →
75
MCQeasy

During the boot process, the system stops at a GRUB prompt. Which command should be typed to continue booting?

A.quit
B.start
C.exit
D.boot
AnswerD

'boot' boots the selected kernel image.

Why this answer

The 'boot' command at the GRUB prompt instructs the bootloader to load the selected kernel and initramfs, then transfer control to the kernel to continue the boot process. This is the standard way to proceed from the GRUB command-line interface when the system halts at a GRUB prompt.

Exam trap

A common misconception is that typing 'exit' or 'quit' will resume the boot process, but in GRUB, only 'boot' triggers the actual kernel execution.

How to eliminate wrong answers

Option A is wrong because 'quit' is not a valid GRUB command; it would be ignored or cause an error. Option B is wrong because 'start' is not a GRUB command; GRUB uses 'boot' to initiate the boot process. Option C is wrong because 'exit' is not a valid GRUB command; in GRUB, you use 'boot' to continue booting, not 'exit'.

Practice this question →
Page 1 of 2 · 90 questions totalNext →

Ready to test yourself?

Try a timed practice session using only System Architecture questions.

Start 20-question session