Linux OS

A comprehensive question and answer guide for Linux Operating System — from the very basics to advanced topics. Use it to study, review, or prepare for interviews.

Beginner

Q1: What is Linux?

Linux is a free, open-source operating system kernel created by Linus Torvalds in 1991. It manages hardware resources and allows software applications to run on a computer. Linux is Unix-like and forms the core of many operating systems called Linux distributions (Ubuntu, CentOS, Fedora, etc.).

Q2: What is the difference between Linux and other operating systems?

Free and Open Source — Source code is publicly available
Multi-user — Multiple users can use system simultaneously
Multitasking — Multiple programs run at the same time
Portable — Runs on various hardware platforms
Secure — User accounts, file permissions, encryption
Stable — Can run for years without restart
Flexible — Can be customized for various purposes

Q3: What is a Linux distribution?

A Linux distribution is a complete operating system built around the Linux kernel, including:

Linux kernel
GNU tools and utilities
Package manager
Pre-installed software
Init system
Desktop environment (optional)

Popular distributions: Ubuntu, Debian, CentOS, Fedora, Red Hat Enterprise Linux (RHEL), Arch Linux, Slackware, openSUSE

Q4: What is a terminal or shell?

A terminal is a text-based interface where you interact with the operating system. A shell is a command-line interpreter that processes your commands. Common shells include Bash (Bourne Again Shell), Zsh, Fish, and Ksh.

Q5: What are the basic Linux commands?

Essential commands include:

Command	Purpose
ls	list directory contents
pwd	print working directory
cd	change directory
mkdir	create a directory
rmdir	remove empty directory
touch	create an empty file
cat	display file contents
cp	copy files
mv	move/rename files
rm	remove files
sudo	execute as superuser
man	display manual pages
which	locate a command
alias	create command shortcuts

Q6: How do I get help on a command?

Multiple ways:

man command_name              # Full manual page
command_name --help           # Quick help
command_name -h               # Quick help (alternative)
info command_name             # Info page (more detailed)
whatis command_name           # One-line description
apropos keyword               # Search by keyword

Q7: What is the Linux file system hierarchy?

Linux follows the Filesystem Hierarchy Standard (FHS):

Directory	Purpose
/bin	Essential command binaries
/sbin	System administration binaries
/boot	Boot files and kernel image
/dev	Device files
/etc	System configuration files
/home	User home directories
/lib	Essential shared libraries
/lib64	64-bit shared libraries
/media	Mount points for removable media
/mnt	Mount points for temporary filesystems
/opt	Optional third-party software
/proc	Virtual filesystem with process info
/root	Root user's home directory
/run	Runtime data (PID files, sockets)
/srv	Service data
/sys	Virtual filesystem for hardware info
/tmp	Temporary files (cleared on reboot)
/usr	User programs and data
/var	Variable data (logs, caches, mail)

Q8: What is the difference between relative and absolute paths?

Absolute paths start with / and specify the complete path from root
```
/home/user/documents/file.txt
```
Always work regardless of current directory
Relative paths are relative to the current directory
```
documents/file.txt
../documents/file.txt
```
Depend on current working directory . represents current directory, .. represents parent directory

Q9: How do I check file permissions?

Use ls -l to view detailed file information:

-rw-r--r-- 1 user group 1024 Jan 15 10:30 file.txt

Breaking down permissions:

First character: file type (- for file, d for directory, l for symlink)
Next 3 characters: owner permissions (read, write, execute)
Next 3 characters: group permissions
Last 3 characters: others permissions

Each set uses: r (read=4), w (write=2), x (execute=1)

Q10: What file types exist in Linux?

Regular files — Contain data (documents, images, etc.)
Directories — Containers for files
Symbolic links — References to other files
Character devices — Devices like terminals (/dev/tty)
Block devices — Storage devices like hard drives (/dev/sda)
Named pipes (FIFO) — Inter-process communication
Sockets — Network communication endpoints

Check file type: file filename or ls -l (first character)

Q11: What is the difference between a user and root?

Regular user — Limited permissions, can only access own files, cannot install system software
Root (superuser) — Unlimited permissions, can access/modify any file or system setting, UID is 0

Running as root is dangerous; use sudo for specific tasks.

Q12: How do I change file permissions?

Use the chmod command with symbolic or numeric notation:

Symbolic notation:

chmod u+x file.txt              # Add execute for owner
chmod g-w file.txt              # Remove write for group
chmod o=r file.txt              # Set read-only for others
chmod a-rwx file.txt            # Remove all permissions

Numeric notation (sum rwx values):

chmod 755 file.txt              # rwxr-xr-x (7+5+5)
chmod 644 file.txt              # rw-r--r-- (6+4+4)
chmod 700 file.txt              # rwx------ (7+0+0)

Q13: How do I change file ownership?

Use chown and chgrp:

chown newuser file.txt              # Change owner
chown newuser:newgroup file.txt      # Change owner and group
chgrp newgroup file.txt             # Change group only
chown -R user:group directory/      # Recursive change

Q14: What is sudo and how do I use it?

sudo (superuser do) allows permitted users to execute commands as another user (usually root):

sudo apt update                     # Run with root privileges
sudo -u username command            # Run as specific user
sudo -l                             # List permitted commands
sudo !!                             # Repeat last command with sudo

The user is prompted for their password. Configuration in /etc/sudoers.

Q15: What is a user group?

A group is a collection of users with shared permissions. Benefits:

Share files and directories with multiple users
Assign permissions to groups instead of individuals
Easier permission management

Common groups:

sudo — Users allowed to use sudo
wheel — Alternative to sudo group
docker — Users allowed to use Docker
audio, video — Multimedia device access

Intermediate

Q16: What is a package manager?

A package manager automates the installation, removal, updating, and configuration of software packages. It:

Resolves dependencies automatically
Maintains package database
Enables easy software discovery
Simplifies system maintenance

Different distributions use different package managers:

Distribution	Package Manager
Debian/Ubuntu	apt, apt-get
Red Hat/CentOS	yum, dnf, rpm
Arch Linux	pacman
openSUSE	zypper

Q17: What's the difference between apt and apt-get?

apt is a newer, user-friendly interface introduced to simplify package management tasks:

apt — High-level, user-friendly commands
apt-get — Lower-level tool with more options
apt-cache — Separate tool for searching packages

apt combines functionality from apt-get and apt-cache with better user experience, colorized output, and simplified syntax.

For most users, apt is recommended; apt-get remains available for scripts.

Q18: How do I install, update, and remove packages?

Common commands (using apt as example):

sudo apt update              # Update package list
sudo apt upgrade             # Upgrade all packages
sudo apt full-upgrade        # Upgrade with dependency resolution
sudo apt install package     # Install package
sudo apt remove package      # Remove package (keep config)
sudo apt purge package       # Remove package and config
sudo apt autoremove          # Remove unused dependencies
sudo apt search keyword      # Search for package
sudo apt show package        # Show package information

Q19: What is the difference between update, upgrade, and dist-upgrade?

apt update — Refreshes package list (doesn't install anything)
apt upgrade — Installs available updates (safe)
apt dist-upgrade / apt full-upgrade — Upgrades with dependency resolution (may remove packages)

Q20: What is a process?

A process is a running instance of a program. Each process has:

Process ID (PID) — Unique identifier
Parent Process ID (PPID) — PID of parent process
Process state (running, sleeping, zombie, etc.)
Memory usage and allocation
CPU usage and scheduling information
File descriptors (open files)
Environment variables

Q21: What is a background and foreground process?

Foreground process — Runs in foreground, takes terminal input/output, blocks terminal until completion
Background process — Runs in background, doesn't use terminal, allows other commands
- Start with &: command &
- Move running to background: Press Ctrl+Z then bg

Q22: How do I view running processes?

Common tools:

ps                          # Current shell processes
ps aux                      # All processes detailed
ps -ef                      # All processes in different format
ps -ef --forest             # Process tree
top                         # Real-time process monitor
htop                        # Interactive process viewer
pgrep process_name          # Find PID by name
pidof program_name          # Get PID of program
lsof                        # List open files

Q23: What do the columns in ps aux mean?

ps aux output columns:

Column	Meaning
USER	Process owner
PID	Process ID
%CPU	CPU usage percentage
%MEM	Memory usage percentage
VSZ	Virtual memory size in KB
RSS	Resident set size (physical) in KB
TTY	Terminal (? = no terminal)
STAT	Process state
START	Start time
TIME	CPU time used
COMMAND	Command line

Q24: How do I stop or kill a process?

Use the kill command with different signals:

kill PID                    # Terminate gracefully (SIGTERM=15)
kill -9 PID                 # Force kill (SIGKILL=9)
kill -STOP PID              # Pause process
kill -CONT PID              # Resume process
killall process_name        # Kill by name
pkill pattern               # Kill by pattern

Signal reference:

1 (HUP) — Hang up
2 (INT) — Interrupt (Ctrl+C)
9 (KILL) — Force kill
15 (TERM) — Terminate (default)
19 (STOP) — Stop
18 (CONT) — Continue

Q25: What are the different process states?

Process states visible in ps output:

State	Meaning
R	Running
S	Sleeping (interruptible)
D	Disk sleep (uninterruptible)
Z	Zombie
T	Stopped
W	Paging
X	Dead

Q26: What is a zombie process?

A zombie (defunct) process is a process that has terminated but whose parent hasn't called wait() to collect its status.

Characteristics:

Appears in ps output with <defunct> label
No resources consumed except PID table entry
Cannot be killed with normal signals

Solutions:

Wait for parent to call wait() and reap zombie
Kill the parent process (parent's death causes init to reap)

Q27: What is a daemon?

A daemon is a background process that runs continuously, typically without a controlling terminal. Characteristics:

Runs in background continuously
No standard input/output
Often started at boot
Performs system or network tasks
Named with 'd' suffix (sshd, httpd, mysqld, etc.)

Common daemons:

sshd — SSH server
httpd / nginx — Web server
mysqld — MySQL database
cron — Task scheduler
syslog — System logging

Q28: How do I check system information?

Useful commands:

uname -a                    # Complete system information
uname -r                    # Kernel version
hostnamectl                 # Hostname and OS info
lsb_release -a              # Linux release information
cat /etc/os-release         # OS details
cat /proc/version           # Kernel and compiler info

Q29: How do I check CPU information?

lscpu                       # CPU architecture and model
cat /proc/cpuinfo           # Detailed per-core CPU info
nproc                       # Number of processors
top -n 1 | head -n 20       # CPU usage

Q30: How do I check memory usage?

free -h                     # Memory summary (human-readable)
free -m                     # In megabytes
cat /proc/meminfo           # Detailed memory information
vmstat                      # Virtual memory statistics
top                         # Real-time memory monitoring
ps aux                      # Per-process memory usage

Memory types:

total — Total installed RAM
used — Currently used
free — Not currently used
available — Can be allocated to processes
buffers — Cache for file system buffers
cached — Page cache
swap — Disk-based virtual memory

Q31: How do I check disk usage?

df -h                       # Filesystem usage (human-readable)
df -i                       # Inode usage
du -sh *                    # Size of items in current directory
du -h directory/            # Recursive size
lsblk                       # Block devices
fdisk -l                    # Partition table
parted -l                   # Partition information

Columns in df -h:

Filesystem — Device name
Size — Total size
Used — Used space
Avail — Available space
Use% — Usage percentage
Mounted on — Mount point

Q32: How do I check system uptime and load average?

uptime                      # System uptime and load average
cat /proc/uptime            # Uptime in seconds
systemd-analyze             # Boot time analysis

Load average (in uptime output):

1-minute average
5-minute average
15-minute average

On single-core: load 1.0 = 100% CPU utilization On quad-core: load 4.0 = 100% CPU utilization

Q33: How do I check network configuration?

Common commands:

ip addr show                # IP addresses (modern)
ifconfig                    # Network interfaces (older)
ip route show               # Routing table
route -n                    # Routing table (alternative)
ip link show                # Network interfaces info

Q34: How do I test network connectivity?

ping host                   # Test ICMP connectivity
ping -c 3 host              # Ping 3 times
traceroute host             # Trace route to destination
mtr host                    # Real-time network diagnostics
telnet host port            # Test TCP connection
nc -zv host port            # Test port connectivity

Q35: How do I perform DNS lookups?

nslookup domain             # DNS lookup
dig domain                  # Detailed DNS info
host domain                 # Quick DNS lookup
getent hosts domain         # Check /etc/hosts and DNS
cat /etc/resolv.conf        # DNS servers configuration

Q36: How do I check network statistics and connections?

netstat -an                 # All connections (deprecated)
ss -an                      # Socket statistics (modern)
ss -tlnp                    # Listening TCP ports with programs
ss -ulnp                    # Listening UDP ports with programs
netstat -i                  # Network interfaces stats
netstat -r                  # Routing table

Q37: How do I download files from the internet?

wget url                    # Download file
wget -O filename url        # Download with custom name
wget -q url                 # Quiet mode
wget -r url                 # Recursive download
curl url                    # Display content
curl -O url                 # Download and save
curl -o filename url        # Download with custom name
curl -L url                 # Follow redirects

Q38: How do I use grep effectively?

grep "pattern" file.txt             # Search for pattern
grep -i "pattern" file.txt          # Case-insensitive
grep -r "pattern" directory/        # Recursive search
grep -n "pattern" file.txt          # Show line numbers
grep -E "regex" file.txt            # Extended regex
grep -v "pattern" file.txt          # Invert match
grep -c "pattern" file.txt          # Count matches
grep -l "pattern" *.txt             # List files with matches
grep -A 3 "pattern" file.txt        # Show 3 lines after match
grep -B 2 "pattern" file.txt        # Show 2 lines before match
grep -C 2 "pattern" file.txt        # Show 2 lines context

Q39: What is piping and how do I use it?

Piping connects command output to another command's input using |:

cat file.txt | grep "keyword"       # Filter file contents
cat file.txt | grep "keyword" | wc -l  # Count matches
ls -l | sort -k5 -rn               # List and sort by size
ps aux | grep process_name         # Find process
cat /var/log/syslog | tail -20     # Last 20 log lines

Related operators:

> — Redirect output to file (overwrite)
>> — Append output to file
< — Redirect input from file
2> — Redirect error output
&> — Redirect both output and error

Q40: How do I work with file input/output redirection?

Redirection operators:

command > file.txt              # Write to file (overwrite)
command >> file.txt             # Append to file
command < input.txt             # Read from file
command > output.txt 2>&1       # Redirect output and error
command 2> error.txt            # Redirect errors only
command 2> /dev/null            # Discard errors
cmd1 | cmd2                      # Pipe output to command
cmd1 | tee file.txt | cmd2       # Tee: output to file and command

File descriptors:

0 — stdin (standard input)
1 — stdout (standard output)
2 — stderr (standard error)

Q41: What are important configuration files?

Key system configuration files:

/etc/hostname               # System hostname
/etc/hosts                  # Hostname to IP mapping
/etc/fstab                  # Filesystem mount configuration
/etc/sudoers                # sudo permissions
/etc/ssh/sshd_config        # SSH server configuration
/etc/sysctl.conf            # Kernel parameters
/etc/environment            # Global environment variables
/etc/profile                # Login shell initialization
/etc/bashrc                 # Interactive shell initialization
/etc/crontab                # System-wide cron jobs

Q42: What is /etc/fstab and how do I configure it?

File system table (/etc/fstab) defines which filesystems are mounted at boot:

/dev/sda1       /           ext4    defaults            0 1
/dev/sda2       /boot       ext4    defaults            0 2
/dev/sda3       swap        swap    defaults            0 0
192.168.1.1:/nfs /mnt/nfs   nfs     defaults            0 0

Fields:

Device/UUID — Filesystem location
Mount point — Where to mount
Filesystem type — ext4, xfs, nfs, swap, etc.
Mount options — defaults, ro, noatime, etc.
Dump flag — 0=don't backup, 1=backup
Pass number — fsck order (0=skip, 1=root, 2=other)

Q43: How do I mount and unmount filesystems?

mount device mount_point            # Mount filesystem
mount -t type device mount_point    # Mount with type
mount -o remount,ro /               # Remount as read-only
mount -o bind /src /dest            # Bind mount
umount mount_point                  # Unmount
umount -l mount_point               # Lazy unmount
umount -f mount_point               # Force unmount
mount | grep ext4                   # Show mounted ext4 filesystems

Q44: What is the boot process in Linux?

Boot sequence:

BIOS/UEFI — Hardware initialization and self-test
Bootloader (GRUB/LILO) — Loads kernel and initrd/initramfs
Kernel initialization — Kernel decompresses and starts
Early userspace — initrd/initramfs mounts root filesystem
init/systemd (PID 1) — First user-space process, starts services
Runlevel/target — System reaches multi-user or graphical target
Login services — Display login prompt

View boot process:

dmesg | head -50                    # Kernel messages
journalctl -b                       # Current boot messages
systemd-analyze                     # Boot time analysis

Q45: What is GRUB and how do I edit it?

GRUB (GRand Unified Bootloader) is the bootloader. Configuration:

sudo grub-mkconfig -o /boot/grub/grub.cfg  # Generate config

Edit in:

/etc/default/grub — Main config file
/etc/grub.d/ — Configuration scripts

Common parameters in /etc/default/grub:

GRUB_DEFAULT=0 — Default menu entry
GRUB_TIMEOUT=5 — Timeout in seconds
GRUB_CMDLINE_LINUX="quiet splash" — Kernel arguments

Changes require regenerating config with grub-mkconfig.

Advanced

Q46: How do I use nice and renice?

Process scheduling and priority control:

Nice values range from -20 (highest priority) to +19 (lowest priority)
Default nice value: 0
Each increment reduces CPU priority

nice -n 10 program              # Start with nice 10 (lower priority)
renice -n 5 -p PID              # Change running process
renice -n -5 -p PID             # Increase priority (needs privileges)
ps aux | grep program           # View NI column for nice value

Q47: What are system limits and how do I configure them?

System limits in /etc/security/limits.conf:

username soft nofile 1024       # Max open files
username hard nofile 2048
@groupname soft nproc 100       # Max processes
@groupname hard nproc 200

Check limits:

ulimit -a                       # Show all limits
ulimit -n                       # Max open files
ulimit -u                       # Max user processes
ulimit -m                       # Max memory
ulimit -c                       # Core dump size

Set limits for current session:

ulimit -n 4096                  # Set max open files
ulimit -u 256                   # Set max processes

Q48: How do I configure static IP address?

Using Netplan (Ubuntu 18+):

# /etc/netplan/01-netcfg.yaml
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: false
      addresses:
        - 192.168.1.100/24
      gateway4: 192.168.1.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]

Apply: sudo netplan apply

Q49: How do I set up firewalls?

UFW (Uncomplicated Firewall):

ufw enable
ufw allow 22/tcp         # Allow SSH
ufw allow 80/tcp         # Allow HTTP
ufw deny 23/tcp          # Deny Telnet
ufw status

iptables (lower level):

iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -P INPUT DROP
iptables-save > /etc/iptables/rules.v4

Q50: How do I troubleshoot network issues?

Diagnostic tools:

ping host                       # Test ICMP connectivity
traceroute host                 # Trace route to destination
mtr host                        # Real-time network diagnostics
netstat -an | grep ESTABLISHED  # Show established connections
ss -tlnp                        # Show listening ports
tcpdump -i eth0 -n              # Capture packets
nmap host                       # Port scanning

Q51: What is umask and how do I use it?

Umask determines default permissions for new files and directories:

Default: 0022 = rw-r–r– (644) for files, rwxr-xr-x (755) for directories
Set: umask 0077 for more restrictive permissions

Calculation:

Files: 0666 (max permissions) - umask
Directories: 0777 - umask

Example: 0666 - 0022 = 0644 (rw-r–r–)

Set umask:

umask 0077                      # Current session
echo "umask 0077" >> ~/.bashrc  # Permanent

Q52: What is setuid, setgid, and sticky bit?

Special permissions on files and directories:

setuid (Set User ID) — Runs as file owner:

chmod u+s program               # Add setuid
chmod 4755 program              # Numeric form

Shows as s in owner execute position: rwsr-xr-x

setgid (Set Group ID) — Runs as group owner:

chmod g+s program
chmod 2755 program

Shows as s in group execute position: rwxr-sr-x

Sticky bit — Only owner can delete files:

chmod +t directory
chmod 1777 directory

Shows as t in others execute position: rwxrwxrwt (like /tmp)

Q53: What is Access Control Lists (ACLs)?

ACLs provide more granular permission control than traditional permissions:

getfacl file.txt                    # View ACL
setfacl -m u:username:rwx file.txt  # Give user permissions
setfacl -m g:groupname:rx file.txt  # Give group permissions
setfacl -x u:username file.txt      # Remove user ACL
setfacl -b file.txt                 # Remove all ACLs

ACL entry format: [u|g]:[name]:[permissions]

u — User
g — Group
No name — Applies to owner/owning group
Permissions: r=4, w=2, x=1

Q54: What is SELinux and how is it different from standard permissions?

SELinux (Security-Enhanced Linux) provides Mandatory Access Control (MAC):

Standard permissions: Discretionary (user can change)
SELinux: Mandatory (enforced by policy)

SELinux context: user_u:role_r:type_t:level_s

States:

Enforcing — Policies enforced
Permissive — Violations logged but not enforced
Disabled — SELinux disabled

Commands:

getenforce                          # Get current state
setenforce 0                        # Set permissive
setenforce 1                        # Set enforcing
ls -Z                               # Show SELinux context
ps -Z                               # Process context
chcon -t httpd_sys_content_t file   # Change context
restorecon -v file                  # Restore default context

Q55: How do I use sudo effectively and securely?

sudo configuration in /etc/sudoers (edit with sudo visudo):

user1 ALL=(ALL) ALL                 # Full sudo access
user1 ALL=(ALL) NOPASSWD: ALL       # No password required
%wheel ALL=(ALL) ALL                # All group members
user1 ALL=(ALL) /usr/bin/ls         # Only specific command

Logging:

sudo -l                             # List permitted commands
sudo -i                             # Login as root
sudo -u username command            # Run as specific user
cat /var/log/auth.log | grep sudo   # View sudo usage

Q56: What is the Linux kernel and how does it manage resources?

The kernel is the core managing:

Process management — Scheduling, context switching, resource allocation
Memory management — Virtual memory, paging, memory protection
I/O management — Device drivers, interrupts
Filesystem — File operations, permissions, mounting
Networking — Network protocols, packet processing
Interrupt handling — Hardware and software interrupts

Check kernel: uname -r, cat /proc/version

Q57: What are kernel modules and how do I work with them?

Loadable Kernel Modules (LKM) extend kernel without recompiling:

lsmod                               # List loaded modules
modinfo module_name                 # Module information
modprobe module_name                # Load with dependencies
modprobe -r module_name             # Remove module
insmod /path/to/module.ko           # Load directly
rmmod module_name                   # Unload directly

Locations: /lib/modules/$(uname -r)/kernel/

Q58: How do I tune kernel parameters with sysctl?

Kernel parameters in /proc/sys/:

sysctl -a                           # Show all parameters
sysctl kernel.panic                 # Show specific parameter
sysctl -w kernel.panic=10           # Change parameter
sysctl -p                           # Load from /etc/sysctl.conf

Persistent configuration in /etc/sysctl.conf:

kernel.panic = 10
net.core.somaxconn = 1024
net.ipv4.tcp_max_syn_backlog = 2048
vm.swappiness = 10

Important parameters:

kernel.panic — Seconds before reboot on panic
net.core.somaxconn — Max socket listen backlog
vm.swappiness — Swap usage preference (0-100)
fs.file-max — Max open files system-wide

Q59: What is dmesg and how do I use it?

dmesg shows kernel ring buffer (boot and system messages):

dmesg                               # Show all messages
dmesg | tail -50                    # Last 50 messages
dmesg -l err                        # Only errors
dmesg --level=warn,err              # Warnings and errors
dmesg -H                            # Human-readable timestamps
dmesg -w                            # Follow in real-time
journalctl -b                       # Alternative: systemd journal

Useful for:

Hardware detection issues
Driver problems
Kernel panics
System failures

Q60: How do I work with logical volumes (LVM)?

LVM abstracts physical disks:

# Physical volumes
pvcreate /dev/sda1 /dev/sdb1        # Create PV
pvs                                 # List PVs

# Volume groups
vgcreate vg0 /dev/sda1              # Create VG
vgs                                 # List VGs
vgextend vg0 /dev/sdb1              # Add to VG

# Logical volumes
lvcreate -L 10G -n lv0 vg0          # Create LV
lvs                                 # List LVs
lvextend -L +5G /dev/vg0/lv0        # Grow LV
resize2fs /dev/vg0/lv0              # Resize filesystem

Q61: How do I set up and manage RAID?

RAID combines multiple disks:

RAID levels:

RAID 0 — Striping only (no redundancy)
RAID 1 — Mirroring (full redundancy)
RAID 5 — Striping with parity (1 disk loss tolerance)
RAID 6 — Dual parity (2 disk loss tolerance)
RAID 10 — Mirrored stripe

Setup with mdadm:

mdadm --create /dev/md0 --level=5 --raid-devices=3 \
  /dev/sda1 /dev/sdb1 /dev/sdc1
cat /proc/mdstat                    # RAID status
mdadm --detail /dev/md0             # Detailed status

Q62: How do I encrypt filesystems with LUKS?

LUKS (Linux Unified Key Setup) full-disk encryption:

sudo cryptsetup luksFormat /dev/sdb1  # Create encrypted volume
sudo cryptsetup luksOpen /dev/sdb1 myvolume  # Open (mount)
sudo mkfs.ext4 /dev/mapper/myvolume  # Format
sudo mount /dev/mapper/myvolume /mnt/data
sudo cryptsetup luksClose myvolume    # Close (unmount)

Key management:

cryptsetup luksAddKey /dev/sdb1      # Add key
cryptsetup luksRemoveKey /dev/sdb1   # Remove key
cryptsetup luksDump /dev/sdb1        # Show info

Q63: How do I work with different filesystems?

Common filesystems:

ext4 (default):

mkfs.ext4 /dev/sda1                # Create
tune2fs -l /dev/sda1               # Get properties
e2fsck -f /dev/sda1                # Repair (unmounted)

XFS (high performance):

mkfs.xfs /dev/sda1
xfs_info /dev/sda1
xfs_repair /dev/sda1               # Repair (unmounted)

Btrfs (modern):

mkfs.btrfs /dev/sda1
btrfs filesystem show              # Show info
btrfs subvolume create /mnt/snap   # Snapshot

Q64: What is the difference between hard and soft links?

Hard link — Direct reference to inode, same file, same size
- ln file hardlink
- Survives original deletion if link exists
- Cannot link across filesystems
Soft link (symlink) — Reference to path, separate inode, shows target
- ln -s file symlink
- Breaks if original deleted
- Can link across filesystems

Check: ls -li shows inode; symlinks show target with -> and start with l

Q65: What is /proc filesystem?

Virtual filesystem providing kernel/process information:

/proc/cpuinfo                       # CPU information
/proc/meminfo                       # Memory information
/proc/uptime                        # System uptime
/proc/loadavg                       # Load average
/proc/[PID]/                        # Process-specific info
/proc/[PID]/cmdline                 # Process command line
/proc/[PID]/status                  # Process status
/proc/[PID]/maps                    # Memory map
/proc/[PID]/fd/                     # File descriptors
/proc/mounts                        # Mounted filesystems
/proc/filesystems                   # Supported filesystems
/proc/net/tcp                       # TCP connections

Q66: What is an inode and why is it important?

Inode (index node) stores file metadata:

File size
Owner UID and GID
Permissions (mode)
Timestamps (atime, mtime, ctime)
Link count (hard links)
Block pointers (data location on disk)
File type

View inode information:

ls -i file                          # Show inode number
stat file                           # Detailed inode info

Inode exhaustion:

df -i                               # Inode usage
find . -type f | wc -l              # Count files