Unit5 - Subjective Questions

The vi/vim editor operates in three main modes:

1. Command Mode (Normal Mode):

   • This is the default mode when vi starts.
   • Keys pressed in this mode are interpreted as editor commands (e.g., copying lines, deleting text, moving the cursor).
   • You cannot type text directly into the file in this mode.

2. Insert Mode:

   • This mode is used for modifying text and typing content.
   • To enter: Press i (insert before cursor), a (append after cursor), o (open new line below), etc.
   • To exit: Press Esc to return to Command Mode.

3. Last Line Mode (Ex Mode):

   • Used for file management operations like saving, quitting, and search/replace.
   • To enter: Press : while in Command Mode.
   • Examples: :w (save), :q (quit), :wq (save and quit), :%s/old/new/g (replace).

Differences between Hard Links and Soft Links:

Commands:

• Hard Link: ln target_file link_name
• Soft Link: ln -s target_file link_name

Linux permissions are defined for three categories: User (u), Group (g), and Others (o). In the Octal method, permissions are assigned numeric values:

• Read (r): 4
• Write (w): 2
• Execute (x): 1
• No permission (-): 0

To set permissions, the values are summed for each category.

Calculation for -rwxr-x--x:

1. User (rwx):
2. Group (r-x):
3. Others (--x):

The resulting octal permission code is 751.

Command example:
chmod 751 filename

The find command searches the directory tree rooted at a given starting point.

General Syntax: find [path] [expression]

Examples:

1. Search by Name:

   • Find files ending in .conf inside /etc:
   • find /etc -name "*.conf"

2. Search by Size:

   • Find files larger than 100MB:
   • find / -size +100M
   • Find files exactly 10KB:
   • find . -size 10k

3. Search by Modification Time:

   • Find files modified in the last 7 days:
   • find /home -mtime -7
   • Find files accessed more than 30 days ago:
   • find /var/log -atime +30

I/O Redirection:
Linux allows changing the source of standard input (stdin) and destinations of standard output (stdout) and standard error (stderr).

• Output Redirection (> and >>):
  • >: Overwrites the file. E.g., ls > filelist.txt saves the directory list to filelist.txt.
  • >>: Appends to the file. E.g., date >> log.txt adds the date to the end of log.txt.
• Input Redirection (<):
  • Feeds a file content as input to a command. E.g., wc -l < file.txt counts lines in file.txt.
• Error Redirection (2>):
  • Redirects error messages. E.g., find / -name "test" 2> errors.txt.

Piping (|):
The pipe operator takes the standard output of the command on the left and passes it as standard input to the command on the right.

• Example: cat /etc/passwd | sort | head -n 5
  • This reads the password file, sorts the lines alphabetically, and then displays only the first 5 lines.

grep (Global Regular Expression Print) is a command-line utility used to search for specific text patterns within files.

Common Options:

1. -i (Ignore Case): Searches case-insensitively.
   • grep -i "error" logfile.txt
2. -r (Recursive): Searches files in the specified directory and all subdirectories.
   • grep -r "config" /etc/
3. -v (Invert Match): Displays lines that do not match the pattern.
   • grep -v "#" config.txt (Hides comments starting with #)

Regular Expression Example:
To find lines starting with 'root' in /etc/passwd:
grep "^root" /etc/passwd
( indicates the start of a line).

These commands are essential for text processing pipelines:

1. cut:

   • Used to extract specific sections (columns or character positions) from each line of a file.
   • Example: Extract the first column (usernames) from /etc/passwd where fields are delimited by a colon:
   • cut -d ":" -f 1 /etc/passwd

2. sort:

   • Arranges lines of text files in a specified order (alphabetical by default).
   • Options: -n for numeric sort, -r for reverse order.
   • Example: sort -r names.txt

3. uniq:

   • Filters out adjacent duplicate lines. It is often used after sort because it only detects duplicates if they are next to each other.
   • Example: Count occurrences of unique lines:
   • sort access.log | uniq -c

sed (Stream Editor) is a non-interactive text editor used to perform basic text transformations on an input stream (a file or input from a pipeline).

Role:

• It reads input line by line, applies a specified operation, and outputs the result.
• It is widely used for find-and-replace operations, deletion, and insertion without opening the file in an interactive editor.

Substitution Example:
The most common usage is the substitute command s.

• Syntax: sed 's/search_pattern/replacement_string/flags' filename
• Command: Replace the first occurrence of "linux" with "Linux" in each line:
  • sed 's/linux/Linux/' file.txt
• Global Replacement: To replace all occurrences in the file, use the g flag:
  • sed 's/linux/Linux/g' file.txt

The Linux boot process involves the following sequential stages:

1. BIOS/UEFI (Basic Input/Output System):

   • Performs the POST (Power-On Self-Test) to check hardware.
   • Identifies the bootable device (HDD, USB, etc.) and searches for the Master Boot Record (MBR) or EFI partition.

2. MBR (Master Boot Record):

   • The first sector of the disk (512 bytes). It contains the primary bootloader code and the partition table. It loads the bootloader into memory.

3. GRUB2 (Grand Unified Bootloader):

   • The bootloader allows the user to select an Operating System or kernel version.
   • It loads the selected Linux Kernel and the initramfs (Initial RAM Filesystem) into memory.

4. Kernel:

   • The kernel initializes hardware drivers, mounts the initramfs, and eventually mounts the actual root filesystem (/) in read-only mode.
   • It starts the first process, usually systemd (or init), with Process ID (PID) 1.

5. Init / Systemd:

   • PID 1 is the parent of all processes.
   • It reads configuration files (targets for systemd or runlevels for SysVinit) to start necessary services (network, GUI, background daemons).

6. Runlevel/Target:

   • The system reaches the target state (e.g., multi-user.target or graphical.target), presenting the login screen to the user.

Kernel Modules are pieces of code (usually device drivers or filesystem drivers) that can be loaded and unloaded into the kernel upon demand. They usually have the .ko extension.

Preference for Modular Approach:

1. Dynamic Loading: Modules can be loaded only when the hardware is detected or the feature is needed, rather than being compiled permanently into the kernel.
2. Memory Efficiency: By not loading unused drivers, the system saves RAM (Physical Memory).
3. Flexibility: Adding support for new hardware does not require recompiling the entire kernel and rebooting the system. You simply compile the module and load it.
4. Smaller Kernel Size: The core kernel image (vmlinuz) remains small and fast to boot.

insmod (Insert Module):

• It inserts a single module into the kernel.
• It requires the full path to the .ko file.
• Crucial Limitation: It does not resolve dependencies. If module A relies on module B, insmod A will fail if B is not already loaded.

modprobe:

• It intelligently loads a module and all its dependencies.
• It uses the modules.dep file (created by depmod) to understand relationships.
• It does not require the full file path, just the module name.

Recommendation:
modprobe is highly recommended because it handles dependency resolution automatically, reducing errors and manual effort in loading prerequisite drivers.

Significance of /proc:
The /proc directory is a virtual filesystem (pseudo-filesystem) that provides an interface to kernel data structures. It does not contain real files stored on the hard disk; instead, it contains runtime system information.

Key Characteristics:

1. Kernel Window: It allows users and applications to view the state of the kernel and running processes (e.g., /proc/cpuinfo, /proc/meminfo).
2. Process Information: Every running process has a directory named after its PID (e.g., /proc/1234/) containing details about that process.
3. Kernel Tuning: Files in /proc/sys are writable and can be used to modify kernel parameters on the fly (e.g., enabling IP forwarding) without rebooting.
4. Volatility: Since it resides in memory, all contents of /proc disappear when the system shuts down.

1. List loaded modules:

   • Command: lsmod
   • (This reads from /proc/modules and formats the output nicely).

2. Remove a module:

   • Command: rmmod [module_name]
   • Alternatively: modprobe -r [module_name] (which also removes unused dependent modules).

3. Display module information:

   • Command: modinfo [module_name]
   • This displays details such as the author, description, license, parameter types, and dependencies.

GRUB2 Configuration:

1. /boot/grub2/grub.cfg:

   • This is the main configuration file read by GRUB at boot time.
   • Important: You should not edit this file manually as it is automatically generated and changes will be overwritten.

2. /etc/default/grub:

   • This is the user-editable file containing global settings like the boot timeout (GRUB_TIMEOUT), default kernel (GRUB_DEFAULT), and kernel command line arguments (GRUB_CMDLINE_LINUX).

3. /etc/grub.d/:

   • A directory containing scripts (e.g., 40_custom) that are executed to build the final config.

Regenerating Configuration:
After editing /etc/default/grub, you must apply the changes by running:

• BIOS Systems: grub2-mkconfig -o /boot/grub2/grub.cfg
• UEFI Systems: grub2-mkconfig -o /boot/efi/EFI/[distro]/grub.cfg

initramfs (Initial RAM Filesystem) is a compressed cpio archive that is loaded into memory by the bootloader (GRUB) alongside the Linux kernel.

Why it is required:

1. Chicken-and-Egg Problem: The real root filesystem (where the OS lives) is often on a storage device (like LVM, RAID, or encrypted disk) that requires specific drivers to be accessed.
2. Driver Availability: These drivers are located on the root filesystem. The kernel cannot read the root filesystem without the drivers, but the drivers are inside the root filesystem.
3. Solution: initramfs contains a minimal filesystem with just enough modules and scripts to mount the real root filesystem. Once the real root is mounted, the kernel pivots to it and executes the init process.

Comparison:

• SysVinit uses Runlevels (numbered 0-6) to define the state of the machine (e.g., single-user, multi-user). It processes scripts sequentially.
• Systemd uses Targets (files ending in .target) to group units. Targets are more flexible and can handle dependencies and parallel execution of services.

Equivalents:

awk is a powerful programming language designed for text processing and data extraction. It operates on a record (line) and field (column) basis.

Key Concepts:

• $0: Represents the whole line.
• 2, ...: Represent the first, second, etc., fields.
• FS: Field Separator (default is whitespace).

Syntax Example:
Assume a file data.txt with content: Name Age Dept.

1. Print specific columns:

   • awk '{print $1, $3}' data.txt
   • (Prints the Name and Dept).

2. Condition-based printing:

   • Print the line only if the Age (2nd column) is greater than 30:
   • awk '0}' data.txt

3. Custom Delimiter:

   • Processing /etc/passwd (colon-separated):
   • awk -F ":" '{print $1}' /etc/passwd

Blacklisting a module prevents it from loading automatically during the boot process.

Steps:

1. Identify the module: Use lsmod to find the exact name of the module you wish to block.
2. Create/Edit configuration file:
   • Navigate to /etc/modprobe.d/.
   • Create a new file ending in .conf, e.g., blacklist.conf.
3. Add the blacklist directive:
   • Open the file and add the line:
   • blacklist [module_name]
   • Example: blacklist nouveau (often done when installing NVIDIA drivers).
4. Update initramfs (Optional but recommended):
   • If the module is included in the initial ramdisk, you must regenerate it (e.g., using dracut or update-initramfs) to ensure the module is blocked during the early boot stage.
5. Reboot: Restart the system to apply changes.

Usage of locate:
locate searches for files by name. It is very fast and simple to use.

• Example: locate myfile.txt

Difference from find:

1. Mechanism:

   • find: Searches the actual directory tree in real-time. It is slower but provides current results.
   • locate: Searches a pre-built database (mlocate.db). It does not scour the hard drive during the search.

2. Performance:

   • locate is significantly faster than find because it queries an indexed database.

3. Accuracy/Freshness:

   • locate relies on the database being up-to-date. If a file was created recently (after the last database update), locate will not find it until the database is updated (usually via the updatedb command). find always sees the current state of the file system.

Kernel Parameters:
These are arguments passed to the Linux kernel at boot time to customize system behavior (e.g., disabling quiet mode, forcing a specific runlevel, or disabling hardware drivers).

Modifying via GRUB (Temporary):

1. Reboot the system.
2. When the GRUB menu appears, use arrow keys to highlight the desired kernel entry.
3. Press the e key to edit the entry.
4. Locate the line starting with linux, linux16, or linuxefi.
5. Append the desired parameter to the end of this line.
   • Example: Append rd.break to stop boot at initramfs, or systemd.unit=rescue.target to boot into rescue mode.
6. Press Ctrl + x or F10 to boot with the modified parameters.

Note: These changes are not saved permanently.