OS Notes
HubFunctions of Operating SystemsHistory of Operating SystemsObjectives of Operating SystemsTypes of Operating Systems — Operating SystemsWhat is an Operating SystemThe Booting ProcessThe KernelOperating System ServicesOperating System StructureSystem CallsUser Mode vs Kernel ModeContext SwitchingInterprocess Communication (IPC)MultithreadingProcess Control Block (PCB)Introduction to ProcessesProcess SchedulingProcess StatesThreadsCritical Section ProblemDining Philosophers ProblemMonitorsMutex LocksProducer-Consumer ProblemReaders-Writers ProblemSemaphoresIntroduction to Process SynchronizationBanker\Deadlock AvoidanceDeadlock DetectionIntroduction to DeadlocksDeadlock PreventionDeadlock RecoveryNecessary Conditions for DeadlockResource Allocation GraphContiguous Memory AllocationDemand PagingMemory Management IntroductionPage Replacement AlgorithmsPagingSegmentationThrashingVirtual Memory — Operating SystemsDisk Scheduling - I/O OptimizationDisk Structure - Physical OrganizationRAID - Redundant Array of Independent DisksSecondary Storage - Persistent StorageStorage Virtualization - Abstract StorageSwap Space Management - Virtual MemoryDirectory StructureFile Allocation MethodsFile ConceptsFile ProtectionFile System ImplementationFile System IntroductionFree Space ManagementDevice DriversDisk Scheduling AlgorithmsDMA - Direct Memory AccessInterruptsI/O HardwareI/O SoftwareCPU Scheduling Interview QuestionsLinux Interview QuestionsMemory Management Interview QuestionsOperating System CheatsheetOperating System Interview Questions — Operating SystemsAndroid Operating System — Operating SystemsEmbedded OS Case StudyiOS Operating System — Operating SystemsLinux ArchitectureWindows ArchitectureGlossary of Terms — Operating SystemsImportant Formulas — Operating SystemsQuick Revision Notes — Operating SystemsRecommended Books — Operating SystemsFCFS Scheduling - First Come First ServedMultilevel Feedback Queue SchedulingMultilevel Queue SchedulingPriority SchedulingRound Robin SchedulingScheduling Algorithm ComparisonCPU Scheduling ConceptsSJF Scheduling - Shortest Job FirstCloud Operating Systems - Architecture and ImplementationDistributed Operating Systems - Design and ConceptsEmbedded Operating Systems - Real-time and Resource-ConstrainedMobile Operating Systems - Android, iOS, and WindowsNetwork Operating Systems - NOS ArchitectureReal-Time Operating SystemsVirtualization - Containers and Virtual MachinesAdvanced Virtualization - Full and Para-virtualizationBasic Linux Commands - Command Line UsageLinux File System - ext4 and othersLinux Introduction - OS OverviewPermissions and Security - Linux SecurityProcess Management in Linux - Process ControlShell Scripting - Bash ProgrammingUser Management - Users and GroupsBankerCPU Scheduling Simulator ProjectMini Operating System ProjectPage Replacement SimulatorShell Scripting ProjectsAccess Control - Permission ModelsAuthentication - User VerificationAuthorization - Access ControlMalware and Threats - Security ThreatsOS Security Basics - Threats and ControlsProtection Mechanisms - Security ImplementationSecurity Best Practices - OS Hardening
Shell scripting fundamentals — Bash syntax, variables, control structures, functions, command substitution, text processing, and practical automation scripts for Linux administration.
Introduction
Shell scripting is the art of writing programs for the command-line interpreter. A shell script is simply a text file containing a sequence of commands that the shell executes in order. What makes shell scripting powerful is that any command you can type manually at the terminal can be automated in a script — combining hundreds of existing Unix utilities into custom workflows without writing a single line of C or Python.
Every system administrator, DevOps engineer, and backend developer writes shell scripts regularly. They automate deployments, process log files, manage backups, monitor systems, and glue together complex pipelines. If you can work efficiently in a shell, you can be productive on any Linux system in the world.
Your First Script
bash example
#!/bin/bash
# This is a comment
echo "Hello, World!"
echo "Today is $(date)"
echo "You are logged in as: $USER"
echo "Current directory: $PWD"The first line (#!/bin/bash) is the shebang — it tells the OS which interpreter to use. Make the script executable with chmod +x script.sh, then run it with ./script.sh.
Variables
bash example
# Variable assignment (NO spaces around =)
name="Alice"
age=25
directory="/home/alice/documents"
# Using variables (dollar sign)
echo "Hello, $name! You are $age years old."
echo "Files in $directory:"
ls "$directory" # Always quote variables to handle spaces
# Read-only variable
readonly PI=3.14159
# Command substitution — store command output in variable
current_date=$(date +%Y-%m-%d)
file_count=$(ls | wc -l)
echo "Found $file_count files on $current_date"Special Variables
| Variable | Meaning |
|---|---|
$0 | Script name |
$1, $2, ...$9 | Positional parameters (arguments) |
$# | Number of arguments |
$@ | All arguments (separately quoted) |
$? | Exit status of last command (0 = success) |
$$ | Current process PID |
$! | PID of last background process |
Control Structures
Conditionals (if/elif/else)
Example
#!/bin/bash
file="$1"
if [ -z "$file" ]; then
echo "Usage: $0 <filename>"
exit 1
elif [ -f "$file" ]; then
echo "$file is a regular file ($(wc -l < "$file") lines)"
elif [ -d "$file" ]; then
echo "$file is a directory ($(ls "$file" | wc -l) items)"
else
echo "$file does not exist"
exit 1
fi
Test Operators
Example
# File tests
[ -f file ] # True if file exists and is regular
[ -d dir ] # True if directory exists
[ -r file ] # True if readable
[ -w file ] # True if writable
[ -x file ] # True if executable
[ -s file ] # True if file size > 0
# String tests
[ -z "$str" ] # True if string is empty
[ -n "$str" ] # True if string is not empty
[ "$a" = "$b" ] # String equality
[ "$a" != "$b" ] # String inequality
# Numeric comparisons
[ "$a" -eq "$b" ] # Equal
[ "$a" -ne "$b" ] # Not equal
[ "$a" -lt "$b" ] # Less than
[ "$a" -gt "$b" ] # Greater than
Loops
Example
# For loop — iterate over list
for fruit in apple banana cherry; do
echo "I like $fruit"
done
# For loop — iterate over files
for file in /var/log/*.log; do
echo "Processing: $file ($(du -h "$file" | cut -f1))"
done
# For loop — C-style
for ((i=1; i<=10; i++)); do
echo "Iteration $i"
done
# While loop
count=0
while [ $count -lt 5 ]; do
echo "Count: $count"
((count++))
done
# While loop — read file line by line
while IFS= read -r line; do
echo "Line: $line"
done < input.txt
Functions
Example
# Function definition
greet() {
local name="$1" # local variable (not visible outside function)
local time_of_day
hour=$(date +%H)
if [ "$hour" -lt 12 ]; then
time_of_day="morning"
elif [ "$hour" -lt 18 ]; then
time_of_day="afternoon"
else
time_of_day="evening"
fi
echo "Good $time_of_day, $name!"
}
# Function call
greet "Alice"
greet "Bob"
# Function with return value (via echo + command substitution)
get_file_size() {
local file="$1"
stat -c %s "$file" 2>/dev/null || echo "0"
}
size=$(get_file_size "/etc/passwd")
echo "File size: $size bytes"
Text Processing
Shell scripting excels at text manipulation using Unix tools:
bash example
# grep — search for patterns
grep "ERROR" /var/log/syslog # Lines containing ERROR
grep -c "404" access.log # Count matching lines
grep -r "TODO" ./src/ # Recursive search
# awk — column extraction and processing
awk '{print $1, $9}' access.log # Print columns 1 and 9
awk -F: '{print $1}' /etc/passwd # Use colon as delimiter
awk '$3 > 1000' /etc/passwd # Filter by condition
# sed — stream editing
sed 's/old/new/g' file.txt # Replace all occurrences
sed -n '5,10p' file.txt # Print lines 5-10
sed '/^#/d' config.txt # Delete comment lines
# cut — extract fields
cut -d: -f1,3 /etc/passwd # Fields 1 and 3, colon delimiter
# sort + uniq — frequency analysis
sort file.txt | uniq -c | sort -rn # Count unique lines, most common firstPractical Patterns
Error Handling
bash example
#!/bin/bash
set -e # Exit immediately on any error
set -u # Treat unset variables as error
set -o pipefail # Pipeline fails if any command fails
# Trap errors for cleanup
cleanup() {
echo "Cleaning up temporary files..."
rm -f /tmp/myapp_*
}
trap cleanup EXIT # Run cleanup on script exit (normal or error)Input Validation
Example
# Validate number of arguments
if [ $# -ne 2 ]; then
echo "Usage: $0 <source> <destination>"
exit 1
fi
# Validate file exists
if [ ! -f "$1" ]; then
echo "Error: Source file '$1' not found"
exit 1
fi
Logging
Example
LOG_FILE="/var/log/myscript.log"
log() {
echo "$(date '+%Y-%m-%d %H:%M:%S') [$1] $2" | tee -a "$LOG_FILE"
}
log "INFO" "Script started"
log "ERROR" "Something went wrong"
Real-World Example: Deployment Script
Example
#!/bin/bash
set -eo pipefail
APP_DIR="/var/www/myapp"
BACKUP_DIR="/var/backups/myapp"
REPO_URL="https://github.com/user/myapp.git"
log() { echo "[$(date '+%H:%M:%S')] $1"; }
log "Starting deployment..."
# Backup current version
timestamp=$(date +%Y%m%d_%H%M%S)
cp -r "$APP_DIR" "$BACKUP_DIR/backup_$timestamp"
log "Backup created"
# Pull latest code
cd "$APP_DIR"
git pull origin main || { log "Git pull failed!"; exit 1; }
log "Code updated"
# Install dependencies and restart
npm install --production
systemctl restart myapp
log "Application restarted"
# Health check
sleep 3
if curl -sf http://localhost:3000/health > /dev/null; then
log "Deployment successful! Application is healthy."
else
log "Health check failed! Rolling back..."
rm -rf "$APP_DIR"
cp -r "$BACKUP_DIR/backup_$timestamp" "$APP_DIR"
systemctl restart myapp
log "Rollback complete"
exit 1
fi
Key Takeaways
- Shell scripts automate any sequence of commands you would type manually
- Always quote variables (
"$var") to prevent word splitting - Use
set -euo pipefailfor robust error handling - Functions with
localvariables keep scripts organized - Combine grep, awk, sed, and sort for powerful text processing
- Scripts should validate inputs, handle errors, and provide meaningful output
- Practice by automating tasks you do repeatedly on the command line
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Shell Scripting - Bash Programming.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Operating Systems topic.
Search Terms
operating-systems, operating systems, operating, systems, linux, and, unix, shell
Related Operating Systems Topics
Continue learning this concept
Linux And UnixBasic Linux Commands - Command Line UsageEssential Linux commands — file management, navigation, text processing, system information, process control, and networking commands with practical examples for beginners.Linux And UnixLinux File System - ext4 and othersLinux file systems — ext4 architecture, inodes, journaling, directory hierarchy (FHS), other file systems (XFS, Btrfs, ZFS), mounting, and file system management commands.Linux And UnixLinux Introduction - OS OverviewIntroduction to Linux — history, philosophy, kernel architecture, distributions, why Linux dominates servers and embedded systems, and getting started with Linux.Linux And UnixPermissions and Security - Linux SecurityLinux file permissions and security — rwx permissions, ownership, special permissions (setuid, setgid, sticky bit), umask, sudo, SELinux basics, and hardening Linux systems.Linux And UnixProcess Management in Linux - Process ControlLinux process management — process creation (fork/exec), process states, signals, job control, /proc filesystem, process monitoring tools, and managing daemons with systemd.Linux And UnixUser Management - Users and GroupsLinux user management — creating and managing users, groups, authentication files (/etc/passwd, /etc/shadow), user environment configuration, and account administration commands.