CCNA System Management Questions

The rescue.target is a systemd target that provides a single-user environment with basic system services, but does not start network services. It is equivalent to the traditional runlevel 1 (single-user mode). This target is designed for maintenance and allows only the root user to log in on the console.

The -i flag edits config.cfg in place, satisfying the requirement to save changes, and the g flag replaces every occurrence of oldstring on each line with newstring. Omitting g would substitute only the first match per line, leaving later instances unchanged.

`renice -n 10 -p 1234` adjusts the nice value of an already-running process, satisfying the stem's requirement to alter priority without restarting it. The `-p` flag targets PID 1234 directly, and a positive nice value of 10 lowers scheduling priority, unlike `nice`, which only sets priority when launching a new process.

The bootctl command is the systemd-boot manager. With the list subcommand, it enumerates all boot loader entries found in the EFI system partition and shows their order, including the default entry. This directly fulfills the requirement to verify the current entries and their order on a system using systemd-boot.

Using `journalctl -u` filters the systemd journal by unit name, satisfying the requirement to display entries for one specific unit. The `-u` flag accepts a unit such as `sshd.service`, restricting output to that unit's messages rather than the entire journal.

This crontab entry specifies minute 0, hour 2, any day of month, any month, and day of week 1 (Monday). It correctly runs the backup script at 2:00 AM every Monday. The fields are in the order: minute, hour, day of month, month, day of week, command.

The `-mtime -2` predicate filters files modified within the last two days, satisfying the recency constraint, while `-exec grep -li 'error' {} \;` runs a case-insensitive search on each match. The `-l` flag lists only filenames rather than matching lines, and `-i` handles the case-insensitivity requirement.

`ln -s` creates a symbolic link, with the target path first and the link path second, satisfying the requirement to point /usr/local/bin/start.sh at /opt/myapp/bin/start.sh. Write permission on /usr/local/bin is sufficient; no elevated privileges are needed since the technician already holds them.

top reads /proc to render a live, refreshing table of processes with per-process CPU and memory figures, satisfying the real-time monitoring requirement. Its interactive sort and kill functions let the administrator act on what they observe without leaving the terminal.

SIGKILL (signal 9) cannot be caught, blocked, or ignored by the process, so the kernel terminates PID 1234 immediately. This satisfies the stem's constraint that the process is unresponsive to normal termination, unlike SIGTERM (15), which the process may handle or defer.

/var holds variable data — logs, spool queues and persistent temporary files — which change in size and content during normal operation. The FHS reserves it precisely for data that must survive reboots, unlike /tmp, which is typically cleared. This satisfies the stem's requirement for variable files persisting across restarts.

`cut -f3` extracts the third tab-delimited field, satisfying the column-selection requirement. Its default delimiter is TAB, matching the tab-separated file, so no `-d` flag is needed. Piped into `sort` and `uniq`, it produces the uniquely sorted output the technician wants.

`systemctl enable myapp` creates the symlinks that pull the unit into the boot target's dependency tree, so systemd starts it automatically at each reboot. This directly satisfies the requirement that the service start at boot, unlike `start`, which only launches it for the current session.

The +7 argument to -mtime matches files whose modification time is greater than seven 24-hour periods ago, exactly the age threshold the stem specifies. The minus form would instead select files modified within the last seven days.

The rpm -i command installs a local package file directly without contacting repositories or resolving dependencies, matching the requirement to skip automatic dependency resolution. Tools like dnf or yum would instead fetch and resolve dependencies.

tail -n 10 extracts the final ten lines, and piping into tee writes them to output.txt while also displaying them on stdout. Redirection with > would suppress terminal output, and tee -a would append rather than create, so this pipeline satisfies both viewing and saving.

Filtering with `-u service` isolates that unit's entries, `-b` restricts output to the current boot, and `-n 50` returns only the last 50 lines — satisfying every constraint in the stem simultaneously. Omitting any flag would show other units, previous boots, or the entire journal.

lsusb enumerates USB buses and connected devices, showing vendor and product IDs, device class, and bus/device numbers. It directly answers the need to list currently connected USB devices with detailed identification information without requiring root privileges.

The -h flag converts df's default 1K-block output into human-readable units such as GB and MB, while df itself reports used and available space per mounted filesystem. This satisfies the requirement for human-readable capacity figures.

hostnamectl is the systemd utility for managing hostnames. The set-hostname subcommand sets the static hostname to the specified value. This change is persistent across reboots and updates /etc/hostname. It is the recommended method on modern Linux distributions using systemd.

The -m flag modifies the ACL by adding or replacing only the specified entry, leaving jane's existing full-control entry untouched. Using u:john:rw grants john read and write, satisfying the stem's requirement to avoid altering existing entries.

`chmod u+x script.sh` adds execute permission solely for the file's owner, satisfying the stem's requirement to grant execute to the owner only. The `u` symbol targets user/owner, `+x` adds execute, and it leaves group and other permissions at their existing 644 values unchanged.

SIGKILL (signal 9) cannot be caught, blocked or ignored by the process, so the kernel terminates PID 2345 immediately. This satisfies the requirement to force stop an unresponsive process, unlike the default SIGTERM sent by plain kill.

grep -n prints line numbers, and -E enables extended regular expressions so the alternation ERROR|FATAL matches either pattern. This satisfies the requirement to find lines containing either term while displaying their line numbers in the log file.

top renders a continuously refreshing view of CPU, memory and per-process usage, letting an administrator spot resource-hungry processes in real time. This satisfies the requirement to monitor live system resource usage for identifying performance bottlenecks.

ln with two arguments creates a hard link by default, so 'ln original linkfile' makes linkfile an additional directory entry pointing to original's inode. This satisfies the requirement without the -s flag, which would create a symbolic link instead.

The `-i` flag edits /etc/hosts in place, satisfying the requirement to replace content within that file directly. The `g` suffix applies the substitution to every occurrence per line, not merely the first, matching "all occurrences". Without `g`, only the initial match on each line would change.

The -user predicate filters by owner, -type f restricts matches to regular files, and /home scopes the search to the required directory. This combination returns exactly the files owned by jane, satisfying the stem's ownership constraint without listing directories.

The -mtime -7 predicate matches files whose data was modified less than seven days ago, and find recurses through /var/log automatically. This directly satisfies the constraint of locating all files in that directory modified within the last 7 days.

journald collects service output when a unit uses StandardOutput=journal, and entries are tagged with the unit's identifier so journalctl -u can filter them. Setting SystemMaxUse in journald.conf caps the persistent journal's disk consumption, preventing it from filling the root filesystem. Together these satisfy both the tagging and size-limit requirements.

The rpm query-file option maps an installed file path back to the package that owns it, reading the local RPM database. On CentOS 8 this directly answers which package provides /usr/bin/foo, satisfying the stem's requirement without needing repository metadata.

`du -h --max-depth=1 /home` satisfies both constraints: `-h` converts block counts to human-readable units (K, M, G), while `--max-depth=1` limits recursion to the immediate children of /home, excluding deeper subdirectories. This matches the requirement for per-file and per-directory usage at exactly one level.

zcat streams the contents of gzip-compressed files straight to standard output, decompressing on the fly in memory. This satisfies the requirement to read the log without first running gunzip and creating an uncompressed copy on disk.

Running `umask` with no arguments prints the current file-mode creation mask for the invoking shell, expressed in octal (for example 0022). This directly satisfies the stem's requirement to display the default umask value, since the command reads and reports the setting without modifying it.

The du command estimates file space usage. The -s flag summarizes each argument (here, each subdirectory via the glob), and -h prints sizes in human-readable units. Piping to sort -h orders the output numerically by human-readable size, so the largest directories appear last. This directly answers the need to find which user directories consume the most space.

The /etc/fstab file is the standard configuration file for static filesystem mounts, including network filesystems like NFS. Adding an entry such as '192.168.1.100:/export/data /mnt/data nfs defaults 0 0' ensures the share is mounted automatically at boot. The systemd mount units generated from fstab handle the actual mounting, making this the correct and persistent method.

/var holds variable data that changes during normal operation, including system logs under /var/log and print spool files under /var/spool. This directly satisfies the stem's requirement for the FHS directory designated for variable data, distinguishing it from static directories such as /usr and /etc.

Editing /etc/fstab defines a persistent mount entry, satisfying the requirement that the ext4 filesystem on /dev/sdb1 survives reboots. Each line specifies the device, mount point (/data), filesystem type and options, which the system reads at boot to mount automatically, unlike temporary mounts made with the mount command.

resize2fs is the correct utility to resize ext2, ext3, and ext4 filesystems. After extending the logical volume with lvextend, running resize2fs on the device path resizes the filesystem to use the additional space. It can be run without unmounting if the filesystem supports online resizing.

`kill 1234` sends SIGTERM (signal 15) by default, which requests graceful termination and lets the process run cleanup handlers before exiting. This satisfies the stem's requirement to terminate PID 1234 gracefully, unlike `kill -9`, which sends SIGKILL and terminates immediately without cleanup.

chmod 640 sets the owner bits to read and write (4+2=6), the group bits to read only (4), and others to none (0), exactly matching the required permission set. The three-digit octal notation maps each digit to user, group, and other classes respectively, satisfying the stem's constraint.

`df -h` reports free and used space for every mounted file system, satisfying the "all mounted file systems" constraint. The `-h` flag converts block counts into human-readable units such as gigabytes, meeting the formatting requirement. Unlike `du`, which measures directory consumption, `df` queries file system statistics directly.

`wc file.txt` outputs newline, word, and byte counts in a single pass, directly satisfying the stem's requirement for all three metrics. Unlike `cat`, `grep -c`, or `sed`, which report only lines or content, `wc` is purpose-built for counting, so it returns the exact line, word, and character totals requested.

`chmod 750` encodes owner read/write/execute (7), group read/execute (5), and others no access (0), matching the requested permission set exactly. The three octal digits map directly to user, group, and other classes, so this single command satisfies every constraint in the scenario.

chown changes file owner and group. The syntax user:group sets both simultaneously. Using apache:apache sets the owner to apache and the group to apache, exactly as required. This is the standard way to change both ownership attributes in one command, and it requires appropriate privileges (usually root).

The `s` in the owner execute position of `-rwsr-xr-x` denotes SUID (Set User ID). When executed, the file runs with the owner's privileges rather than the invoking user's, satisfying the stem's requirement to identify the special permission set on this file.

The -f flag makes tail follow the file descriptor, printing appended lines as they are written rather than exiting after the last 10. This satisfies both requirements: the default last-10-lines display plus continuous live output.

Correct: 777 - 027 = 750.

systemctl daemon-reload reloads systemd manager configuration, including all unit files. After editing a unit file, this command is necessary so systemd picks up changes. Without it, systemd continues using the cached version, causing the service to run with old settings.

`dmesg` reads the kernel ring buffer directly, satisfying the requirement to view kernel-related messages. It exposes boot-time hardware detection, driver initialisation and runtime kernel warnings, and supports filtering by facility or severity. Unlike journal-based tools, it needs no persistent logging daemon, so it works even when systemd-journald is unavailable.

Systemd takes over as PID 1 once the kernel hands off from initramfs, mounting remaining filesystems and activating units in dependency order to reach the requested target. It satisfies the stem's requirement for the component that starts user-space services and manages system state after initramfs execution.

The du command estimates disk usage, the -s flag summarizes each argument into a single total, and -h produces human-readable sizes. Expanding /var/* passes each immediate subdirectory to du, yielding one summarized line per subdirectory. This directly identifies the largest consumers under /var, which is exactly what the administrator needs before deleting files.

-mtime -2 matches files whose modification time is less than two days ago, covering the last 48 hours. The negative argument is the axis that matters: -mtime +2 would instead return files older than two days.

/bin holds essential user command binaries required for single-user mode and system repair, such as ls, cp and cat. It is distinct from /sbin, which holds system administration binaries, and /usr/bin, which holds non-essential user commands.

ext4 is a journaling filesystem: it maintains a journal recording pending metadata changes, so it is commonly used on Linux and satisfies the requirement to identify journaling filesystems. Its predecessor ext3 also journals, but ext4 adds extents and larger volume support.

/bin holds essential user command binaries required for single-user mode, such as ls, cp and sh. The FHS reserves it precisely for binaries needed before /usr is mounted, satisfying the single-user availability constraint. Other directories like /usr/bin hold non-essential binaries that may depend on separate mounts.

ncdu is an interactive disk usage analyzer that scans a directory and displays sizes in a navigable interface. Running ncdu / will analyze the entire root filesystem and allow the administrator to drill down into large directories, making it an excellent tool for this scenario.

The `-mtime -7` predicate matches files modified within the last seven days, while `-size +100M` filters those exceeding 100MB, both applied to the `/var/log` path. Combining these tests with implicit AND logic satisfies the stem's dual constraints of recent modification and large size in a single traversal.

systemctl is the control interface for systemd units, and its status subcommand reports whether the named service is active, inactive or failed, plus recent log lines. This directly satisfies the requirement to query a systemd-managed service's current state.

SIGKILL (signal 9) cannot be caught, blocked, or ignored by the process, so the kernel terminates PID 4582 immediately without waiting for cleanup. This satisfies the stem's requirement to stop the runaway process at once, unlike SIGTERM, which the process may handle or defer.

User-specific shell initialization files like ~/.bashrc or ~/.profile are sourced after /etc/profile and can override the umask. If the user's file contains a umask command, it will take precedence. This is the most common reason a system-wide umask in /etc/profile appears ineffective, as the user's environment resets the value during login.

`systemctl enable service` creates the symlinks that pull the unit into the boot transaction, so the service starts automatically at every boot on a systemd-based host. It satisfies the stem's requirement directly; `start` only launches it for the current session and does not persist across reboots.

useradd -m creates the user's home directory if it does not exist, and -s /bin/bash sets the login shell. This command creates the account with the specified home directory and shell. It is the standard low-level utility for adding users on most Linux distributions and meets all requirements in the scenario.

The `-mtime -2` test matches files modified less than two days ago, satisfying the recency constraint, while `-name "*.log"` filters by extension and `-type f` excludes directories. Combining these predicates with `find` in `/var/log` returns exactly the required set in one pass.

The -s flag creates a symbolic link rather than a hard link, and the syntax places the target (original) before the link name (link). This produces a symlink named 'link' pointing to 'original' as required.

setfacl -m u:jdoe:rw adds a named user entry to the file's access control list, granting jdoe read and write access. This satisfies the constraint of not altering the file's owner or group, which chmod and chown would change.

Hard links share the same inode, so deleting the original filename only removes one directory entry; the inode's link count drops but data persists. The remaining hard link still resolves to that inode and remains fully readable.

A cron job with the schedule '30 2 * * *' will run the command every day at 2:30 AM. The fields represent minute, hour, day of month, month, and day of week. This is a standard and reliable method for scheduling recurring tasks on Linux. It is directly supported by the cron daemon and is easy to set up.

The df command reports filesystem disk space usage, and the -h flag displays sizes in human-readable units such as GB and MB. This directly answers the need to view available space on all mounted filesystems in an easily readable format. It is the standard tool for this task and is available on virtually all Linux distributions.

The useradd command with -m creates the home directory, -s sets the login shell, and -G adds the user to the supplementary group 'research'. This single command fulfills all requirements without additional steps, making it the correct choice.

nohup makes the process immune to SIGHUP, so it survives terminal closure and logout, while the trailing & backgrounds it immediately. This satisfies the requirement that the script keeps running after the session ends, unlike a plain background job.

renice alters the nice value of an already-running process identified by PID, so renice 10 -p 1234 raises niceness from 0 to 10, lowering scheduling priority. The -p flag specifies the target PID, satisfying the requirement to change a running process rather than launch a new one.

The -mmin -30 predicate matches files modified within the last 30 minutes, and -size +10M selects those larger than 10MB. Combining both in one find invocation over /var returns exactly the files meeting both constraints simultaneously.

-mtime 0 matches files modified within the last 24 hours, and -not -user root excludes root-owned files, meeting both stem constraints in one pass. The -mtime test counts whole 24-hour periods, so 0 covers the current day.

Hard links are directory entries pointing to the same inode, and inode numbers are unique only within a single filesystem. Cross-filesystem linking is therefore impossible, so source and link must reside on the same mounted filesystem.