CCNA Storage Management Questions

It uses the proper mdadm syntax to create a RAID 10 array with six disks. The --level=10 specifies RAID 10 (a striped mirror set), and --raid-devices=6 matches the number of disks provided via the /dev/sd[abcdef] glob, which expands to /dev/sda through /dev/sdf. This command correctly creates a RAID 10 array that combines striping and mirroring across all six devices.

To replace a disk in a RAID1 array, the failed disk must first be marked failed and removed from the array. Then the new disk, partitioned identically, is added with mdadm --add, which triggers a rebuild. These two steps maintain data integrity and restore redundancy without recreating or resizing the array.

Extending an ext4 filesystem on LVM requires enlarging the logical volume first with lvextend, then expanding the filesystem with resize2fs. The volume group already has free extents, so no additional physical volume is needed. The filesystem can be resized online while /home remains mounted.

To prepare the disks and create the volume group, the administrator must first initialize the disks as physical volumes with pvcreate, then create the volume group with vgcreate, adding both physical volumes. lvcreate is a later step for creating the logical volume, mkfs.ext4 would destroy LVM metadata, and vgextend applies only to existing volume groups. The two required commands are pvcreate and vgcreate.

GFS2 (Global File System 2) is a shared-disk cluster filesystem designed for high-availability environments where multiple nodes require simultaneous read-write access to the same filesystem. It uses a distributed lock manager (DLM) to coordinate access across nodes, ensuring data consistency without requiring a single metadata server. This makes it ideal for active-active cluster configurations with shared block storage.

The correct procedure is to extend the logical volume to use all remaining free space in the volume group with lvextend -l +100%FREE, then resize the ext4 filesystem online with resize2fs. Since ext4 supports online resizing, unmounting is not required.

It first initializes the disk as a physical volume using `pvcreate`, which writes LVM metadata to /dev/sdb, and then extends the existing volume group 'vg_data' with `vgextend`, adding the new PV to the VG. This is the standard two-step process for adding a new disk to an existing LVM volume group.

The `blkid` command is specifically designed to locate and display block device attributes, including the UUID and filesystem type. Running `blkid /dev/sdb1` queries the device's superblock and outputs its UUID, making it the correct tool for this task.

After extending an LV that hosts an XFS filesystem, the filesystem itself must be grown separately. The XFS-specific tool is xfs_growfs, which is invoked with the mount point and can be run while the filesystem is mounted. This expands the filesystem to use the additional space, after which df will show the new size.

It uses the `--spare-devices=1` flag to designate `/dev/sdd` as a hot spare, while `--raid-devices=3` specifies that only three disks form the active RAID 5 array. The spare disk is listed after the active disks, which is the correct syntax for `mdadm --create`.

The `lsblk` command lists all block devices recognized by the kernel, including those without a filesystem or partition table. Since the disk is new and not yet partitioned, `lsblk` will show it if the kernel has detected it, making it the correct first diagnostic step.

Mounting an ISO file requires the loop option so the kernel can treat the file as a block device and read its ISO9660 filesystem. The mount -o loop command is the simplest and most common way to achieve this. Alternatives like specifying only the filesystem type or using a bind mount do not correctly expose the ISO's contents.

lvextend allocates physical extents from the volume group's free pool. With only 50 GB free, a 150 GB growth request cannot be met, so the command exits with an error before touching the logical volume. The fix is to add capacity to vg_data, for example by creating a physical volume on a new disk and running vgextend, then repeating the lvextend.

Extending an LVM logical volume with lvextend changes only the block device mapping; the ext4 filesystem inside keeps its original size until resized. Running resize2fs against the LV path grows the filesystem online to fill the new extents, after which df reflects the additional capacity. The XFS-only grow tool, a consistency checker, and a PV-level resize command all fail to accomplish this here.

It first extends the logical volume using `lvextend -L +10G` to allocate additional physical extents from the volume group, then resizes the ext4 filesystem online with `resize2fs` to utilize the new space. Both operations can be performed without unmounting the filesystem, as ext4 supports online resizing and LVM allows live extension of logical volumes.

On Debian-based systems, the initramfs is managed with update-initramfs. Running update-initramfs -u regenerates the image for the current kernel, incorporating any needed modules such as LVM. Other tools like dracut or mkinitrd are used on different distributions and are not the default on Debian, and grub-mkconfig only updates the bootloader configuration.

When an LVM snapshot runs out of space, it becomes invalid and cannot track changes made to the original logical volume during the backup. The snapshot is automatically dropped by the device-mapper, and any attempt to mount or read it will fail. The original logical volume remains fully functional and unaffected, but the snapshot must be recreated to perform a new backup.

RAID 1 (mirroring) requires exactly two devices to provide redundancy by duplicating data across both disks. The `--level=1` parameter specifies RAID 1, and `--raid-devices=2` matches the two partitions /dev/sdb1 and /dev/sdc1.

Package managers are tied to specific distribution families: apt (Debian/Ubuntu), yum (RHEL/CentOS 7), dnf (Fedora/RHEL 8+), pacman (Arch), and zypper (openSUSE). Common confusions arise from mixing these tools across distributions.

The `du -sh /var/log` command calculates the total disk space used by the specified directory. The `-s` flag summarizes the total size, `-h` provides human-readable output (e.g., in KB, MB, GB), and the path `/var/log` targets the directory in question. This is the standard Linux command for determining directory disk usage.

Pvmove relocates physical extents from /dev/sda to another physical volume in the same volume group while the filesystem remains online and accessible. This allows the failing disk to be removed from vg_system without any downtime, preserving LVM metadata and data integrity.

The `mount -o noatime,errors=remount-ro /dev/sda1 /mnt` command uses a single `-o` flag with a comma-separated list of mount options, which is the proper syntax for specifying multiple options. The `noatime` option disables updating the access time on reads, and `errors=remount-ro` tells the kernel to remount the filesystem as read-only if an I/O error is encountered, both of which are valid ext4 mount options.

blkid probes the device and reports the filesystem UUID stored in the ext4 superblock, which is exactly the value needed for an fstab entry like UUID=xxxx-... /data ext4 defaults 0 2. It works whether or not the filesystem is mounted. The other commands either display partition-table metadata or require mounting and still do not print the UUID.

The default inode size for XFS on a typical Linux system is 256 bytes. This is set at filesystem creation time and provides a balance between supporting extended attributes (like ACLs and SELinux contexts) and minimizing metadata overhead. The `xfs_info` command confirms the default settings, which include this 256-byte inode size.

To set up DM-Multipath for iSCSI LUNs, you must install and configure multipathd and its configuration file, and you must create multiple iSCSI sessions to the same LUNs via different network interfaces. This ensures that the multipath layer can detect and manage multiple paths. Bonding or authentication are not substitutes for multipath configuration.

To safely remove a physical volume from an active volume group, the allocated extents must first be moved to other PVs. pvmove performs this online migration without unmounting filesystems. Only after the PV reports zero used extents can vgreduce detach it and pvremove clear its label. Attempting vgreduce or pvremove beforehand fails because LVM protects allocated data.

RAID1 (mirroring) writes identical data to all disks in the array, so the usable capacity is limited by the smallest disk. With /dev/sdb at 500GB and /dev/sdc at 1TB, the maximum usable capacity is 500GB. The remaining space on /dev/sdc (500GB) is unusable in the RAID1 array because it cannot be mirrored.

After extending the logical volume with lvextend, the ext4 filesystem must be grown to use the new space. resize2fs performs this online for ext4, keeping /srv/app mounted. xfs_growfs targets XFS, e2fsck checks but does not resize, and lvresize would further change the logical volume without touching the filesystem. The correct sequence is lvextend then resize2fs.

The correct procedure is to mark the failed disk as failed (if not already), remove it from the array, then add the spare disk /dev/sdd. This allows mdadm to rebuild the RAID 5 array onto the new disk, restoring redundancy. The commands 'mdadm --manage /dev/md0 --fail /dev/sda --remove /dev/sda' followed by 'mdadm --manage /dev/md0 --add /dev/sdd' accomplish this safely.

The correct order to configure a cron job is: open the crontab file with 'crontab -e', add the cron expression with the correct time fields (minute, hour, day, month, weekday) and the script path, save the file, and then verify with 'crontab -l'. Common mistakes include adding the line before opening the editor, saving before adding, or verifying before editing.

`cryptsetup luksFormat /dev/sdc` initializes the block device with a LUKS header, setting up an encrypted container that can later be opened with a passphrase or key file. This is the standard command for creating a new LUKS partition, as it writes the LUKS metadata and prepares the device for encryption.

The `lvcreate` command for thin logical volumes requires the `-V` flag to specify the virtual size of the thin volume and the `-T` flag to reference the thin pool. The syntax `-V 100G -T vg1/pool1 --name thinvol` correctly creates a thin logical volume named 'thinvol' with a virtual size of 100GB from the thin pool 'pool1' in volume group 'vg1'.

To extend an ext4 filesystem on LVM online, you first increase the logical volume with lvextend, then expand the filesystem with resize2fs. ext4 supports online growth, so the application can continue running. Using xfs_growfs on ext4 or running a filesystem check instead of resize2fs will not achieve the desired result.

The blkid command is specifically designed to locate and print block device attributes, including the UUID and filesystem type. When run against a device like /dev/sdb1, it queries the kernel's device mapper and reads the filesystem superblock to extract the universally unique identifier (UUID). This is the most direct and reliable method for displaying a filesystem's UUID.

XFS filesystems cannot be shrunk. To reduce the size of an XFS logical volume, the administrator must back up the data, remove the logical volume, create a new smaller logical volume, format it with XFS, and restore the data. Any attempt to use lvreduce with -r or xfs_growfs to shrink will fail because XFS only supports growing.

Mounting an ISO file requires the loop option so that the kernel treats the file as a block device. The command mount -o loop /opt/install.iso /mnt/iso creates a loop device automatically and mounts the ISO9660 filesystem, making the contents accessible. This is the standard method for accessing ISO images without burning them.

The `df -hT` command displays disk space usage for all mounted filesystems, with the `-h` flag providing human-readable sizes (e.g., GB, MB) and the `-T` flag showing the filesystem type (e.g., ext4). This directly meets the requirement to show total, used, and available space for all mounted ext4 filesystems.

Creating an XFS filesystem on a raw block device is done with mkfs.xfs followed by the device path. Because the new 4 TB disk has no partition table and the requirement is a single filesystem spanning the entire device, targeting /dev/sdb directly is correct. Partitioning is optional when the whole disk is dedicated to one filesystem.

The `-m` flag in `mkfs.ext4` sets the reserved block percentage for the superuser, and specifying `-m 2` overrides the default of 5% to reserve only 2% of the blocks on the new ext4 filesystem on /dev/sdb1.

The `tune2fs -m` command sets the reserved block percentage for an ext4 filesystem, and `-m 1` sets it to exactly 1%. This is the standard way to adjust reserved space on a non-root ext4 filesystem, as root filesystems typically have a default of 5% reserved for system processes.

The `noatime` mount option disables updates to the inode access time (atime) on every file read. For database workloads, this eliminates a significant source of metadata write I/O, reducing disk contention and improving overall performance by avoiding unnecessary journal updates on XFS.

XFS filesystems are extended with the xfs_growfs command, which operates on a mounted filesystem using its mount point. Because the block device already reports the larger size, the only remaining step is to grow the XFS filesystem into that free space. Tools such as resize2fs target ext-family filesystems, while xfs_repair and growpart address different problems, so they cannot satisfy this requirement.

It first creates the new PV on /dev/sde, extends the VG to include it, then uses pvmove to migrate data from the failing PV (/dev/sdb) to the new PV while the VG is active, and finally removes the faulty PV from the VG with vgreduce. This sequence ensures no data loss and maintains VG availability throughout the replacement process.

`lvextend` only increases the size of the logical volume at the block device level. The filesystem (e.g., ext4, XFS) still sees the original size until it is explicitly resized with a command like `resize2fs` (for ext4) or `xfs_growfs` (for XFS). The `df` command reports filesystem usage, not the underlying block device size, so the filesystem must be grown to match the LV.

The missing step is activating quotas with `quotaon`. Even after configuring `/etc/fstab` with `usrquota,grpquota`, remounting the filesystem, and running `quotacheck -cug` to create the quota database files (`aquota.user` and `aquota.group`), quotas remain inactive until explicitly enabled with `quotaon`. Without this command, the kernel does not enforce quota limits, allowing users to exceed soft limits without warning.

A swap file is activated in the running system with swapon and made persistent by adding an fstab entry whose filesystem type is swap and whose dump and pass fields are both zero. Using mount instead of swapon, inventing a mkswap activation flag, or supplying a nonzero pass field all fail to produce a correctly activated and persistent swap area.

Creating a usable software RAID 1 array requires two actions: mdadm --create to build the array from the member disks, and a filesystem creation command such as mkfs.ext4 on the resulting /dev/md0 device. Assembly is only for reactivating existing arrays, and pvcreate belongs to LVM. Verification with mdadm --detail is optional.

When a new SCSI disk is detected by the kernel, the kernel creates the device node (e.g., /dev/sdb), but the symbolic links under /dev/disk/by-id/ are generated by udev based on the device's WWID or other identifiers. If udev has not yet processed the uevent for the new disk, those persistent by-id links will not exist. Running 'udevadm trigger' forces udev to reprocess all pending or missed uevents, which creates the missing links.

To create a GPT partition table and a full-disk partition on /dev/sdc, gdisk is the dedicated interactive tool. It supports GPT natively and handles large disks. fdisk may work but is traditionally MBR-oriented, mkfs.gpt is nonexistent, and the parted command shown creates an MBR label instead of GPT. gdisk is the correct choice.

When an LVM thin pool is completely full, the kernel cannot allocate new blocks for any thin volume, so all thin volumes in that pool are automatically switched to read-only mode to prevent data corruption. The immediate fix is to add physical storage to the volume group (e.g., vgextend) and then extend the thin pool (lvextend) so that new blocks can be allocated. This restores write capability without data loss because the volumes were never corrupted—they were simply protected by the read-only state.

A one-off mount for the current session is performed with the mount command, specifying the device, the existing mount point, and optionally the filesystem type via -t. No fstab entry is created, so the mount does not survive a reboot. Formatting tools, shell redirection into fstab, and starting nonexistent systemd units do not mount a filesystem for the current session.

The correct /etc/fstab entry must use the UUID for stable identification, specify the mount point, filesystem type, include defaults and noatime in the options, and set the dump and pass fields appropriately (0 and 2 for a non-root filesystem). The entry with UUID, defaults,noatime, 0, and 2 meets all these criteria.

The `du -sh /var` command is correct because `du` (disk usage) estimates file and directory space usage, and the `-s` flag summarizes the total for `/var` while `-h` provides human-readable output (e.g., KiB, MiB, GiB). This directly shows the disk space consumed by the `/var` directory and its contents.

Creating an XFS filesystem on a whole block device is done with the mkfs.xfs command followed by the device path. XFS is commonly used for data volumes and supports being placed directly on an unpartitioned disk. The other commands either grow or repair an existing XFS filesystem and cannot initialize a new one.

Software RAID arrays are reassembled at boot from configuration stored in /etc/mdadm.conf and embedded in the initramfs. After adding a replacement disk, the administrator must regenerate that configuration and rebuild the initramfs so the new member is recognized. Growing the array, adding the component to fstab, or relying on a manual assemble command does not provide persistent boot-time assembly.

The error indicates that the initramfs is not activating the volume group during early boot. This usually happens when the initramfs was built without the necessary LVM modules or configuration, or after a kernel update that did not include LVM support. Rebuilding the initramfs with the correct LVM configuration ensures the volume group is found and activated, allowing the system to boot.

Persistent identifiers such as UUIDs or by-path symlinks decouple the mount configuration from the kernel's enumeration order, and nofail prevents a temporarily missing iSCSI LUN from delaying or blocking boot. Together they make the fstab entry resilient to device renumbering. Changing to a device-mapper path, adding _netdev, or forcing a udev rename do not address enumeration stability and can introduce new problems.

blkid reads filesystem superblocks and reports the type without mounting or altering the device, making it the safest and most direct way to identify the filesystem on /dev/nvme0n1p2. fdisk shows partition-table type codes rather than real filesystem metadata, mounting is unnecessarily invasive, and lsblk -f is a broader listing that is less targeted for a single-device query.

To activate a new swap partition immediately, you must first initialize it with mkswap, then enable it with swapon. These two commands prepare and activate the swap space without requiring a reboot. Adding an fstab entry is for persistence across reboots, and swapoff or mount are not appropriate for enabling swap.

The correct procedure is to create the logical volume with lvcreate -L 8G -n lv_swap vg_sys, initialize it with mkswap, and activate it with swapon. The -L option specifies an absolute size in gigabytes, which matches the 8 GB requirement. Persistent activation requires an /etc/fstab entry, but the immediate creation and activation sequence is as shown.

exFAT was designed for flash and removable media and is supported out of the box by modern Linux, Windows, and macOS. It also has no 4 GB per-file ceiling, unlike FAT32, so it satisfies both the cross-platform and large-file requirements. The other filesystems either impose a size limit or lack native support on one of the required operating systems.

Persistent mounting in /etc/fstab should use a stable identifier such as UUID= or LABEL= rather than a kernel device name. The entry must also specify the correct filesystem type and avoid options like noauto that prevent boot-time mounting. The UUID form with ext4 and a pass value of 2 satisfies all requirements.

The correct export entry must specify the exact client, grant read-write access, and enable root squashing. The entry /srv/data 192.168.10.25(rw,root_squash) accomplishes all three requirements. root_squash is the default, but explicitly including it ensures the security policy is applied even if defaults change.