Unit 4 - Practice Quiz

A fundamental concept in Linux is that nearly everything, including hardware devices, sockets, and directories, can be treated as a file, which simplifies interaction and programming.

The ls command is the standard utility in Linux for listing files and directories.

The man command displays the system's reference manual pages (man pages) for a given command, providing detailed information on its usage and options.

sudo (superuser do) allows a permitted user to execute a command as the superuser or another user, without having to permanently switch to that user's shell.

The useradd command is the standard low-level utility for creating a new user account. adduser is a higher-level, more user-friendly script often available on Debian-based systems.

The groupadd command is the standard utility for creating a new user group on a Linux system.

The id command provides detailed identity information for a specified user, including their UID, primary GID, and all supplementary groups they belong to.

The ~/.profile or ~/.bash_profile file is a user-specific script that runs upon login to set up the user's shell environment, such as aliases and environment variables.

The chmod (change mode) command is used to modify the access permissions (read, write, execute) of files and directories.

The chown (change owner) command is specifically used to change the user and/or group ownership of files and directories.

The sticky bit is most commonly used on world-writable directories like /tmp. It ensures that while anyone can create a file, only the owner of that file can delete or rename it.

To run a script directly, it must have the execute (x) permission bit set. The permissions -rw-r--r-- indicate read and write for the owner, but not execute.

fdisk is a classic and powerful menu-driven command-line tool for creating, deleting, and modifying partitions on a storage device.

The LVM structure is: Physical Volumes (disks/partitions) are combined into Volume Groups (storage pools), and then Logical Volumes (usable volumes) are carved out from the Volume Groups.

The /etc/fstab (file systems table) file contains descriptive information about the various file systems and their mount points, which the system uses to mount them automatically on startup.

The mkfs (make filesystem) family of commands is used to create filesystems. mkfs.ext4 is the specific utility for creating an ext4 filesystem.

The tilde (~) character is a shortcut that represents the path to the current user's home directory. cd ~ is equivalent to just typing cd with no arguments.

The /etc directory is the standard location for hosting configuration files for the operating system and installed applications.

For security, user passwords are not stored in the world-readable /etc/passwd file. Instead, their encrypted hashes are kept in /etc/shadow, which is only readable by the root user.

A mount point is simply a directory that serves as the access point for a mounted filesystem. For example, a USB drive might be mounted on the /media/usb_drive directory.

The permissions are calculated using octal notation:

• Owner: Read (4) + Write (2) + Execute (1) = 7
• Group: Read (4) + Execute (1) = 5
• Other: No permissions = 0

Combining these gives the octal value 750. The execute permission on a directory is required to enter (cd) into it.

Extending a logical volume is a two-step process. First, you must extend the logical volume itself using lvextend (the -l +100%FREE flag tells it to use all available free extents in the volume group). Second, you must resize the filesystem living on that logical volume to recognize and use the new space. For ext2/3/4 filesystems, resize2fs is the correct command for this.

This scenario describes the exact purpose of the 'sticky bit' (+t or 1000 in octal). When set on a directory, it restricts file deletion so that only the file's owner (or root) can delete the file, regardless of who has write permission on the directory.

The permissions string -rwxr-----x is interpreted as follows:

• Owner (admin): rwx (read, write, execute)
• Group (analysts): r-- (read only)
• Others: --x (execute only)

Since sara is a member of the analysts group, the group permissions (r--) apply to her. These permissions do not include the execute (x) bit, which is why she is denied permission to run the script.

su - (or su -l, su --login) starts a login shell for the target user (root by default). This means it fully simulates a new login, sourcing the user's profile scripts (/root/.bash_profile, etc.) and setting environment variables like HOME and PATH accordingly. su alone switches the user but keeps the original user's environment. sudo -s and sudo bash start a shell as root but do not typically source the login-specific profile files.

The usermod command is used to modify user accounts. The -G flag sets the supplementary groups. Crucially, the -a (append) flag must be used with -G to add the user to the new groups without removing them from their current ones. Without -a, the command would replace the user's entire list of supplementary groups with the new list.

The noauto option in /etc/fstab explicitly tells the system not to mount the filesystem automatically at boot time (e.g., via mount -a). The filesystem can still be mounted manually later. The nofail option is a good alternative, as it allows the boot process to continue without error if the device is not present, but noauto is the direct answer to preventing the automatic mount attempt.

This pipeline is a classic example of the Unix/Linux philosophy. ps, grep, and wc are all small, specialized programs that do one thing well. They are chained together using pipes, which work because each program is designed to operate on simple text streams (standard input and standard output). This makes them composable and extremely powerful.

While chown root:www-data or chown .www-data would also work, the chgrp (change group) command is specifically designed for changing only the group ownership of a file or directory. It is the most direct and explicit command for the requested task. chmod changes permissions, not ownership.

The chattr (change attribute) command manipulates file attributes on an ext2/3/4 filesystem. The +i flag sets the 'immutable' attribute. An immutable file cannot be modified, deleted, renamed, or linked to, even by the root user. Standard permissions (chmod 000) can be easily overridden by root.

The tilde (~) is a shell expansion that represents the current user's home directory (e.g., /home/username). Therefore, ~/bin/mytool provides a direct, unambiguous path to the executable from any location in the filesystem. ./bin/mytool would look for a bin subdirectory in the current directory (/usr/share/doc), which is incorrect. The last option incorrectly changes the current directory.

This pipeline is a standard administrative technique. du -sh /var/* calculates the disk usage (du) in a summary (s), human-readable format (h) for each item in /var. This output is then piped to sort -rh, which sorts the lines in reverse (r), human-numeric (h) order, placing the largest directories at the top. head -n 10 then displays the top 10 results. df -h shows usage for the whole filesystem, not individual directories.

This command is a robust way to find users by their primary GID. First, getent group interns | cut -d: -f3 gets the Group ID (GID) for the interns group. This GID is then used in a grep command to search /etc/passwd. The pattern looks for lines where the fourth field (the primary GID), which is surrounded by colons, matches the GID of the interns group.

The man (manual) pages are the standard, comprehensive source of documentation for most Linux commands. Running man mkdir will open the full manual page, where you can read about all its options, including -p (which creates parent directories as needed). mkdir --help provides a brief usage summary, info is an alternative documentation system (often more verbose), and apropos searches for man pages related to a keyword.

The getent (get entries) command queries databases configured in /etc/nsswitch.conf, which can include local files (/etc/passwd), LDAP, NIS, and other services. This makes it the most reliable method for checking for a user's existence in a networked environment. grep only checks the local file. id will also work, but getent is specifically for querying these name service databases. Checking for a home directory is unreliable as not all users have one.

The ~/.bashrc file is specifically intended for configurations that apply to interactive, non-login shells. This is the standard place for defining aliases and shell functions that you want available every time you open a new terminal window. ~/.bash_profile is for login shells, and files in /etc are for system-wide settings, not user-specific preferences.

The nohup (no hang up) command prevents a process from being terminated when its controlling terminal is closed. The ampersand (&) at the end of the command line places the process into the background, immediately returning your shell prompt. The combination nohup long_command & is the classic method for running a process that will survive your logout.

To access any file or subdirectory, a user must have execute (x) permission on all parent directories in the path leading to it. Even if /var/www/html/cache has correct permissions, if /var/www/html is, for example, drwxr-x--- and owned by root:root, the www-data user (as 'other') cannot traverse it to reach the cache directory. This is a common and often overlooked permissions issue.

The MBR partitioning scheme has a fundamental limitation: it can only hold a maximum of four primary partitions. To create more than four, you must use one of the four available slots for an 'extended partition'. This extended partition acts as a container within which you can create multiple logical partitions. Therefore, creating 3 primary and 1 extended (which holds the other 2 as logical) is a valid way to create 5 total partitions.

Shrinking a logical volume is a high-risk operation that must be done in a specific order. The filesystem must be shrunk first, because reducing the underlying block device (the logical volume) before the filesystem is aware of the change will lead to immediate and severe data corruption. The correct, safe procedure is: 1) umount, 2) e2fsck to check for errors, 3) resize2fs to shrink the filesystem (e.g., to 80G), and then 4) lvreduce to shrink the containing logical volume.

Shrinking a filesystem is a high-risk operation that must be done in a specific order to avoid data loss. The filesystem must be shrunk before the logical volume that contains it. Furthermore, ext4 filesystems must be unmounted and checked before being resized. The correct sequence is: 1. Unmount the filesystem. 2. Run a filesystem check (fsck) to ensure it's in a consistent state. 3. Shrink the filesystem (resize2fs) to the new, smaller size. 4. Shrink the logical volume (lvreduce) to a size equal to or slightly larger than the new filesystem size. Shrinking the LV first would cut off the end of the filesystem, causing catastrophic data loss.

To traverse a directory (i.e., access any files or subdirectories within it), a user must have execute (x) permission on that directory. In this scenario, the /project directory has permissions rwxr-x--x. The owner is root and the group is root. Since 'dev1' is neither root nor a member of the root group, their access is determined by the 'others' category, which has r-x permissions. However, the next directory, /project/app, has permissions rwxr-x---, which denies all access to 'others'. Because 'dev1' is not root, they cannot traverse /project to get to /project/app because they do not belong to the root group. The listed permissions show that the root group on /project lacks execute permissions. The correct permissions on /project should likely be drwxr-xr-x to allow others to traverse it. The file's permissions are irrelevant if the user cannot reach its containing directory.

Modern Linux kernels deliberately ignore the SUID (and SGID) bit on scripts. This is a crucial security feature. If the kernel were to honor the SUID bit on a script, it would introduce a race condition: the kernel would open the script, and then another process could modify the script's contents before the interpreter (e.g., /bin/bash) is loaded and executed. This would allow an attacker to execute arbitrary code with elevated privileges. Therefore, to run a script with root privileges, one must use a tool like sudo or a compiled SUID wrapper program.

This scenario involves two stages. The graphical login is a login shell, which sources /etc/profile and then one of ~/.bash_profile, ~/.bash_login, or ~/.profile. However, the question asks about the terminal window opened after the graphical login. This terminal is a non-login, interactive shell. Non-login interactive shells do not source the profile files. Instead, they typically source /etc/bash.bashrc (on Debian-based systems) or a similar system-wide file, and then the user's ~/.bashrc. Most graphical environments are set up so that the initial login shell sources files which set up the environment, but each subsequent terminal window is a non-login shell that sources the .bashrc files for its specific configuration.

This is a classic issue when LVM snapshots are in use. When a file is deleted from the origin volume, the blocks it occupied are not freed on the physical device because the snapshot volume still needs them to maintain the point-in-time view of the filesystem. The filesystem (XFS in this case) correctly marks the space as free internally, but from the LVM perspective, the blocks are still allocated to the snapshot. The only way to reclaim the space is to delete the LVM snapshot (lvremove). xfs_fsr is for defragmentation, and while corruption is possible, it's less likely than the snapshot scenario given the symptoms.

The key difference is in how the commands are constructed. The -exec ... {} + syntax is a feature of find itself. It gathers as many filenames as possible to fit into a single command line (respecting ARG_MAX limit) and executes grep only once for that large batch of files. xargs does something very similar, but it is a separate program. The find ... | xargs pipeline has more overhead (a pipe, an extra process). More importantly, the default xargs can be unsafe with filenames containing whitespace. While find ... -print0 | xargs -0 solves the filename safety issue, the find ... -exec ... + form is generally considered the more modern and often more efficient method, as it's built directly into find and avoids the pipe overhead and potential for multiple xargs invocations if the input is very large. Option C describes -exec ... {} ; (with a semicolon), not +.

The umask is subtracted from the system's default permissions for new files and directories. The default for directories is 777 (rwxrwxrwx) and for files is 666 (rw-rw-rw-).

For the directory (testdir):
Default: 777 (111 111 111)
umask: 027 (000 010 111)
The umask acts as a bitmask of permissions to remove. So the calculation is default & ~umask.
777 & ~027 = 111 111 111 & ~(000 010 111) = 111 111 111 & 111 101 000 = 111 101 000, which is 750 (rwxr-x---).

For the file (testfile):
Default: 666 (110 110 110)
umask: 027 (000 010 111)
666 & ~027 = 110 110 110 & ~(000 010 111) = 110 110 110 & 111 101 000 = 110 100 000, which is 640 (rw-r-----).

This question hinges on understanding how shell redirection and pipelines interact with sudo. In Option A, sudo only applies to the log_dumper command. The pipe (|) and the redirection (>) are handled by the current user's shell, not the root shell. Therefore, the current user would need permission to write to /opt/backups/, which they likely do not have. Option B is syntactically incorrect. Option C is closer, but the redirection is still handled by the user's shell. The correct method is Option D. It starts a new shell (sh -c) with sudo. The entire pipeline, including the redirection, is passed as a single string argument to that new root shell, ensuring every part of the command is executed with the necessary privileges.

By default, when chown -R (recursive) encounters a symbolic link, it changes the ownership of the symbolic link itself, not the file or directory it points to. To change the ownership of the target, you would need to use the -h option (chown -hR), which is not used here. Therefore, the recursive chown will descend into the /data/app directory, change the ownership of the /data/app/logs directory, and change the ownership of the symbolic link /data/app/config. It will not follow the link to change the ownership of /etc/app/config.conf.

This is a quintessential example of the Unix/Linux philosophy.

1. Write programs that do one thing well: tar handles archiving, ssh handles secure remote connections. Neither program tries to do the other's job.
2. Write programs to work together: The pipe (|) is the mechanism that connects the output of tar to the input of ssh, making them work together seamlessly.
3. Write programs to handle text streams...: In this case, it's a binary stream, but the principle of using standard input and standard output (- is used to represent stdout/stdin for tar) as the connection medium is the key concept. This makes the tools composable. Option C is close, but this is a single command, not a script, so the 'shell scripts' principle is less directly demonstrated than the other three.

The key is the SGID (Set Group ID) bit, represented by the 's' in the group execute permission slot (rws). When the SGID bit is set on a directory:

1. Any new file or directory created within it will inherit the group ownership of the parent directory, not the primary group of the creating user.
2. If the new item is a directory, it will also have the SGID bit set automatically.

The permission calculation is done by applying the umask to the default directory permissions (777).
Default: 777
umask: 002
Result: 775 (rwxrwxr-x).
Because the parent directory (/var/www/shared) has the SGID bit set, the newly created assets directory will also have the SGID bit set. Therefore, the final permissions are 2775 (drwxrwsr-x).

The Master Boot Record (MBR) partitioning scheme has two major limitations that make it unsuitable here: it cannot address disks larger than 2TB, and it only supports 4 primary partitions. Since the disk is 6TB, MBR is not an option. The GUID Partition Table (GPT) scheme is required. GPT supports disks up to many zettabytes and allows for 128 partitions by default. UEFI firmware specifically boots from a special partition type called an EFI System Partition (ESP), which is a feature of the GPT standard. Tools like gdisk and parted are designed to work with GPT labels. fdisk in older versions only supported MBR, though modern versions support GPT.

A bind mount is the correct mechanism to make a directory tree appear in another location without copying or using a symlink. The ro option makes it read-only. For a secure chroot jail, it's critical to also add nodev (do not interpret character or block special devices on the filesystem), nosuid (do not allow set-user-identifier or set-group-identifier bits to take effect), and noexec (do not allow execution of any binaries on the mounted filesystem). While the question only explicitly mentioned read-only and no device nodes, a hardened solution would include noexec and nosuid as well, making option C the most comprehensive and secure choice that meets all stated requirements.

The most robust and portable command here is id -gn testuser. The id command is designed to query the user database through the system's Name Service Switch (NSS) configuration (/etc/nsswitch.conf). This means it will correctly query local files, LDAP, NIS, or whatever backend is configured, without the script needing to know the details. The -g flag gets the primary GID, and the -n flag resolves it to a name. Option A only queries local files (/etc/passwd and /etc/group). Option C uses getent, which is good, but is overly complex. Option D is unreliable because groups shows all groups, and the primary group is not guaranteed to be in the third position.

The FHS provides clear guidance on this. /opt is reserved for add-on application software packages. A key characteristic of software in /opt is that it's often self-contained in a single directory, for example /opt/google-chrome or /opt/oracle-client. This prevents its files from mixing with the rest of the system, making it easy to install and remove. In contrast, /usr/local is for use by the system administrator when installing software locally from source. It has its own hierarchy (/usr/local/bin, /usr/local/lib, etc.) that mirrors the main /usr hierarchy. This keeps locally compiled software separate from the software managed by the distribution's package manager, but still integrates it into the system's standard path.

The userdel command with the -r (--remove) flag is designed to perform a comprehensive cleanup. It removes the user's entry from /etc/passwd and /etc/shadow. Critically, -r also removes the user's home directory and mail spool. Most modern implementations of userdel (as part of the shadow-utils package) are configured by default (via /etc/login.defs with USERGROUPS_ENAB) to also remove the user's private group if it has the same name as the user and no other members. Therefore, the command will remove the user, their home directory, and their associated private group.

The default pager for man is almost always less. The command less has powerful built-in search functionality. Typing / followed by a pattern initiates a forward search. Typing ? initiates a backward search. After a search is initiated, the n key repeats the search in the same direction, and the N key repeats the search in the opposite direction. This is far more efficient than exiting and piping to grep, as it allows the user to see the search term in context within the full man page and easily navigate between matches.

The standard Discretionary Access Control (DAC) permissions (rwx) appear to be correct. The www-data user is in the www-data group, and that group has write permission (w) on the file (664) and the directory (775). When standard permissions seem correct but access is still denied, the next place to look is Mandatory Access Control (MAC) systems like SELinux (on RHEL/CentOS) or AppArmor (on Debian/Ubuntu). These systems provide an additional layer of security. It's very common for the default web server policy to restrict write access to only specific, labeled directories (e.g., /var/www/html, /tmp), and deny writes to other locations like /var/log/ regardless of the DAC permissions. The solution would involve using commands like chcon (SELinux) or modifying AppArmor profiles to grant the necessary permissions.

LVM snapshots work using a copy-on-write (CoW) mechanism. When the snapshot is first created, it uses almost no space. However, when a block on the origin volume (lv_data) is about to be changed (written to), LVM first copies the original content of that block into the space allocated for the snapshot volume. The new data is then written to the origin volume. This means the snapshot stores the old data, preserving the point-in-time view. This consumed space comes from the free extents within the volume group (vg_main), not from within the origin LV itself. Therefore, writing 5GB of new data to the origin will consume approximately 5GB of space from the VG's free pool for the snapshot's use.

The groupmod -g 2005 developers command correctly updates the group database (e.g., /etc/group). However, this change does not automatically propagate to the filesystem. Files and directories on the filesystem store ownership information as numeric UID and GID values, not names. After the groupmod command, all files previously owned by GID 1005 will now appear to be owned by a non-existent group (or a different group, if another group happens to have GID 1005). The critical follow-up step is to find all files that still have the old numeric GID (1005) and update their group ownership to the new GID, which can be done by referencing the group name developers. The find command is the standard tool for this task.