Unit 1: Introduction to Operating Systems

1.1 What is an Operating System?

📌 Definition: An Operating System (OS) is a system software that acts as an intermediary between the user and the computer hardware. It manages hardware resources and provides services for application programs.

Goals of an Operating System

Convenience — Make the computer system convenient to use
Efficiency — Use computer hardware in an efficient manner
Ability to Evolve — Permit effective development, testing, and introduction of new system functions

Functions of an Operating System

┌─────────────────────────────────────────────────────────┐
│                    USER PROGRAMS                         │
├─────────────────────────────────────────────────────────┤
│                  OPERATING SYSTEM                        │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐   │
│  │ Process  │ │ Memory   │ │  File    │ │   I/O    │   │
│  │ Mgmt     │ │ Mgmt     │ │ System   │ │  Mgmt    │   │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘   │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────────┐    │
│  │  Device  │ │ Security │ │   Network Management │    │
│  │ Drivers  │ │ & Protect│ │                      │    │
│  └──────────┘ └──────────┘ └──────────────────────┘    │
├─────────────────────────────────────────────────────────┤
│                  COMPUTER HARDWARE                       │
│           CPU    Memory    I/O Devices                   │
└─────────────────────────────────────────────────────────┘

1.2 Evolution of Operating Systems

1.2.1 Batch Operating Systems

📌 Definition: A Batch OS collects similar jobs into batches and processes them one at a time without user interaction. A resident monitor program automatically transfers control from one job to the next.

┌─────────────────────────────────────────┐
│        Batch Processing Flow            │
│                                         │
│  ┌───────┐    ┌──────────┐    ┌──────┐  │
│  │ Job 1 │───▶│ Resident │───▶│ CPU  │  │
│  │ Job 2 │    │ Monitor  │    │      │  │
│  │ Job 3 │    │(Scheduler)│   │      │  │
│  │  ...  │    └──────────┘    └──────┘  │
│  └───────┘    Selects jobs    Executes  │
│   Job Pool    from pool       one by    │
│   (on Tape)                   one       │
└─────────────────────────────────────────┘

Characteristics:

Jobs are collected and grouped into batches
No direct interaction between user and computer
Jobs are processed in FIFO (First In, First Out) order
Turnaround time can be very long

Advantages:

Reduced idle time of CPU
Simple to implement
Efficient for repetitive jobs

Disadvantages:

No user interaction during execution
Long turnaround time
Difficult to debug
One job failure can stall the entire batch
CPU often idle during I/O operations

1.2.2 Multiprogramming (Iterative) Systems

📌 Definition: Multiprogramming increases CPU utilization by organizing jobs so that the CPU always has one to execute. Multiple jobs are kept in main memory simultaneously, and the OS picks and begins to execute one. When the job has to wait (e.g., for I/O), the OS switches to another job.

┌──────────────────────────────────────────────────────┐
│           Multiprogramming Memory Layout              │
│                                                      │
│  ┌────────────────────────────────────────────┐      │
│  │          Operating System                  │      │
│  ├────────────────────────────────────────────┤      │
│  │          Job 1 (Running)        ◄── CPU    │      │
│  ├────────────────────────────────────────────┤      │
│  │          Job 2 (Waiting for I/O)           │      │
│  ├────────────────────────────────────────────┤      │
│  │          Job 3 (Ready)                     │      │
│  ├────────────────────────────────────────────┤      │
│  │          Job 4 (Ready)                     │      │
│  ├────────────────────────────────────────────┤      │
│  │          Free Memory                       │      │
│  └────────────────────────────────────────────┘      │
└──────────────────────────────────────────────────────┘

Key Concepts:

Job Pool: All jobs are stored on disk; a subset is kept in memory
Job Scheduling: OS selects which jobs to load into memory
CPU Scheduling: OS decides which job to run when current job waits

Advantages:

High CPU utilization
Less idle time
Multiple jobs can share resources

Disadvantages:

Complex memory management required
No user interaction
CPU scheduling required
More complex than batch systems

📌 Definition: Time-sharing is a logical extension of multiprogramming where the CPU executes multiple jobs by switching among them so frequently that the users can interact with each program while it is running. Each user gets a small portion of CPU time called a time quantum or time slice.

┌─────────────────────────────────────────────────┐
│          Time-Sharing System                     │
│                                                  │
│   User 1 ──┐                                    │
│   User 2 ──┤     ┌──────────┐     ┌─────┐      │
│   User 3 ──┼────▶│ CPU Time │────▶│ CPU │      │
│   User 4 ──┤     │ Scheduler│     │     │      │
│   User N ──┘     └──────────┘     └─────┘      │
│                                                  │
│   Time Quantum = 10-100 milliseconds (typical)   │
│                                                  │
│   ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐    │
│   │ U1│ U2│ U3│ U4│ U1│ U2│ U3│ U4│ U1│...│    │
│   └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘    │
│   ◄──────── CPU Time Distribution ──────────▶   │
└─────────────────────────────────────────────────┘

Characteristics:

Response time is usually < 1 second
Each user feels they have their own CPU
Uses CPU scheduling and multiprogramming
Requires memory management (swapping/virtual memory)
Uses interactive I/O (keyboard, display)

Advantages:

Quick response time
Reduces CPU idle time
Multiple users can work simultaneously
Provides interactive computing environment

Disadvantages:

Complex scheduling algorithms needed
High overhead due to context switching
Security concerns (multiple users share resources)
Reliability issues (system crash affects all users)

| Feature | Batch System | Multiprogramming | Time-Sharing | |---------|-------------|------------------|--------------| | User Interaction | None | None | Interactive | | Response Time | Hours/Days | Minutes/Hours | Seconds | | CPU Utilization | Low to Medium | High | High | | Number of Users | Single | Single | Multiple | | Job Switching | Sequential | When I/O wait | Time quantum | | Main Objective | Maximize throughput | CPU utilization | Response time | | Memory Mgmt | Simple | Moderate | Complex | | Context Switching | Minimal | On I/O wait | Frequent | | Example OS | Early IBM OS | IBM OS/360 | Multics, UNIX |

1.2.4 Multiprocessor Systems (Parallel Systems)

📌 Definition: Systems with two or more CPUs in close communication, sharing the computer bus, clock, memory, and peripheral devices. Also called parallel systems or tightly-coupled systems.

Types of Multiprocessor Systems

┌─────────────────────────────────────────────────────┐
│      Symmetric Multiprocessing (SMP)                 │
│                                                      │
│   ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐           │
│   │ CPU 1│  │ CPU 2│  │ CPU 3│  │ CPU N│           │
│   └──┬───┘  └──┬───┘  └──┬───┘  └──┬───┘           │
│      │         │         │         │                 │
│   ┌──┴─────────┴─────────┴─────────┴──┐             │
│   │         SHARED MEMORY              │             │
│   │      (Common Bus / Interconnect)   │             │
│   └───────────────────────────────────┘             │
│                                                      │
│   • All processors are peers (no master-slave)       │
│   • Each processor runs an identical copy of OS      │
│   • Many processes can run simultaneously            │
│   • Example: Windows, Linux, macOS                   │
└─────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│     Asymmetric Multiprocessing (AMP)                 │
│                                                      │
│   ┌──────────┐                                       │
│   │ Master   │──── Controls scheduling & I/O         │
│   │ CPU      │                                       │
│   └────┬─────┘                                       │
│        │ Assigns tasks                               │
│   ┌────┴──────────────────────┐                      │
│   │  ┌──────┐  ┌──────┐  ┌──────┐                   │
│   │  │Slave │  │Slave │  │Slave │                   │
│   │  │CPU 1 │  │CPU 2 │  │CPU 3 │                   │
│   │  └──────┘  └──────┘  └──────┘                   │
│   └───────────────────────────┘                      │
│                                                      │
│   • Master processor controls the system             │
│   • Slave processors execute assigned tasks          │
│   • Master can become bottleneck                     │
└─────────────────────────────────────────────────────┘

Advantages of Multiprocessor Systems:

Increased Throughput — More processes completed in less time
Economy of Scale — Share peripherals, storage, power supply
Increased Reliability — Failure of one CPU doesn't halt system (graceful degradation / fault tolerance)

1.2.5 Distributed Systems

📌 Definition: A distributed system consists of a collection of physically separate, possibly heterogeneous computer systems that are networked together to provide users with access to shared resources. Also called loosely-coupled systems.

┌──────────────────────────────────────────────────────────┐
│                   Distributed System                      │
│                                                          │
│   ┌──────────┐        Network         ┌──────────┐      │
│   │ Node A   │◄──────────────────────▶│ Node B   │      │
│   │ (CPU +   │    (LAN/WAN/Internet)  │ (CPU +   │      │
│   │  Memory) │                        │  Memory) │      │
│   └────┬─────┘                        └────┬─────┘      │
│        │                                   │             │
│        │         ┌──────────┐              │             │
│        └────────▶│ Node C   │◄─────────────┘             │
│                  │ (CPU +   │                            │
│                  │  Memory) │                            │
│                  └──────────┘                            │
│                                                          │
│   Each node has its OWN memory and OS                    │
│   Communication via message passing                      │
└──────────────────────────────────────────────────────────┘

Advantages:

Resource Sharing — Share files, printers, data across nodes
Computation Speed-up — Distribute tasks across nodes (load sharing)
Reliability — If one site fails, others continue operating
Communication — Users can exchange information (email, file transfer)

Types of Distributed OS:

Client-Server Model: Server provides services; client consumes them
Peer-to-Peer Model: All nodes are equal; both provide and consume services

┌───────────────────────────────────┐  ┌───────────────────────────────────┐
│      Client-Server Model          │  │       Peer-to-Peer Model          │
│                                   │  │                                   │
│   ┌────────┐     ┌────────┐      │  │   ┌────────┐ ◄──▶ ┌────────┐    │
│   │Client 1│────▶│        │      │  │   │ Peer 1 │      │ Peer 2 │    │
│   └────────┘     │ SERVER │      │  │   └────────┘      └────────┘    │
│   ┌────────┐     │        │      │  │       ▲                ▲         │
│   │Client 2│────▶│        │      │  │       │    ┌────────┐  │         │
│   └────────┘     └────────┘      │  │       └───▶│ Peer 3 │◄─┘         │
│                                   │  │            └────────┘            │
└───────────────────────────────────┘  └───────────────────────────────────┘

1.2.6 Cluster Systems

📌 Definition: Cluster systems gather together multiple CPUs (or complete computer systems) to accomplish computational work. They differ from multiprocessor systems in that they are composed of two or more individual systems (nodes) joined together, often sharing storage.

┌──────────────────────────────────────────────────────────┐
│                    Cluster System                         │
│                                                          │
│   ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│   │ Node 1   │  │ Node 2   │  │ Node 3   │              │
│   │(Complete │  │(Complete │  │(Complete │              │
│   │ System)  │  │ System)  │  │ System)  │              │
│   └────┬─────┘  └────┬─────┘  └────┬─────┘              │
│        │              │              │                    │
│   ┌────┴──────────────┴──────────────┴────┐              │
│   │      High-Speed Interconnect (SAN)     │              │
│   └───────────────────┬───────────────────┘              │
│                       │                                   │
│              ┌────────┴────────┐                          │
│              │  Shared Storage │                          │
│              │   (SAN/NAS)    │                          │
│              └─────────────────┘                          │
└──────────────────────────────────────────────────────────┘

Types of Clustering:

| Type | Description | Example | |------|------------|---------| | Asymmetric Clustering | One node is on standby (hot-standby mode), monitoring the active server. Takes over if the active server fails | Database failover | | Symmetric Clustering | All nodes actively run applications and monitor each other. More efficient use of hardware | Web server farm | | Parallel Clustering | Multiple nodes access shared data simultaneously using DLM (Distributed Lock Manager) | Scientific computing |

Advantages:

High availability (fault tolerance)
High scalability (add more nodes)
High performance (parallel processing)
Load balancing across nodes

1.2.7 Real-Time Systems

📌 Definition: A real-time system is one where the correctness of the system depends not only on the logical result of computation but also on the time at which the results are produced. There are well-defined, fixed time constraints.

Types of Real-Time Systems

┌─────────────────────────────────────────────────────────────┐
│                  Real-Time Systems                           │
│                                                             │
│   ┌──────────────────────┐    ┌──────────────────────┐      │
│   │  Hard Real-Time      │    │  Soft Real-Time      │      │
│   │                      │    │                      │      │
│   │  • Deadline MUST be  │    │  • Deadline SHOULD   │      │
│   │    met — failure is  │    │    be met — missing   │      │
│   │    catastrophic      │    │    is undesirable but │      │
│   │  • No virtual memory │    │    tolerable          │      │
│   │  • No time-sharing   │    │  • Virtual memory OK  │      │
│   │                      │    │  • Time-sharing OK    │      │
│   │  Examples:           │    │  Examples:            │      │
│   │  • Air traffic ctrl  │    │  • Video streaming    │      │
│   │  • Medical devices   │    │  • Online gaming      │      │
│   │  • Nuclear reactors  │    │  • VoIP calls         │      │
│   │  • ABS brakes        │    │  • Multimedia apps    │      │
│   │  • Pacemakers        │    │                      │      │
│   └──────────────────────┘    └──────────────────────┘      │
└─────────────────────────────────────────────────────────────┘

📊 Comparison: Hard vs Soft Real-Time Systems

| Feature | Hard Real-Time | Soft Real-Time | |---------|---------------|---------------| | Deadline | Must be met absolutely | Preferred but not critical | | Failure Impact | Catastrophic | Degraded quality | | Virtual Memory | Not used | Can be used | | Secondary Storage | Limited or none | Allowed | | Time-Sharing | Not supported | Supported | | Latency | Deterministic | Best-effort | | Examples | Missile systems, pacemakers | Video players, online games |

📊 Master Comparison: All Types of Operating Systems

| Feature | Batch | Time-Sharing | Multiprocessor | Distributed | Real-Time | Cluster | |---------|-------|-------------|----------------|-------------|-----------|---------| | User Interaction | None | Interactive | Interactive | Interactive | Limited | Interactive | | Response Time | Long | Short | Short | Variable | Guaranteed | Short | | CPU Count | 1 | 1 | Multiple | Multiple (across nodes) | 1+ | Multiple nodes | | Memory Sharing | N/A | Shared | Shared | Distributed | Dedicated | Shared storage | | Reliability | Low | Medium | High | High | Very High | Very High | | Complexity | Low | Medium | High | Very High | High | High | | Primary Goal | Throughput | Responsiveness | Parallelism | Resource sharing | Deadline meeting | Availability |

1.3 UNIX System Introduction

1.3.1 History of UNIX

📌 UNIX was developed in 1969 at AT&T Bell Laboratories by Ken Thompson and Dennis Ritchie. Originally written in assembly language, it was rewritten in C (1973), making it the first OS largely written in a high-level language.

1.3.2 UNIX Architecture

┌─────────────────────────────────────────────────────────┐
│                    UNIX Architecture                     │
│                                                         │
│  ┌───────────────────────────────────────────────────┐  │
│  │                   USERS                            │  │
│  │          (Application Programs)                    │  │
│  ├───────────────────────────────────────────────────┤  │
│  │                   SHELL                            │  │
│  │     (Command Interpreter: bash, sh, csh, ksh)      │  │
│  ├───────────────────────────────────────────────────┤  │
│  │              SYSTEM CALLS                          │  │
│  │    (Interface between user space and kernel)        │  │
│  ├───────────────────────────────────────────────────┤  │
│  │                  KERNEL                            │  │
│  │  ┌──────────┐ ┌──────────┐ ┌───────────────┐     │  │
│  │  │ Process  │ │ Memory   │ │ File System   │     │  │
│  │  │ Mgmt     │ │ Mgmt     │ │ Management    │     │  │
│  │  └──────────┘ └──────────┘ └───────────────┘     │  │
│  │  ┌──────────┐ ┌──────────┐ ┌───────────────┐     │  │
│  │  │ Device   │ │ I/O      │ │ Network       │     │  │
│  │  │ Drivers  │ │ Subsystem│ │ Management    │     │  │
│  │  └──────────┘ └──────────┘ └───────────────┘     │  │
│  ├───────────────────────────────────────────────────┤  │
│  │                 HARDWARE                           │  │
│  │       CPU, Memory, Disks, Network, Terminals      │  │
│  └───────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────┘

1.3.3 Features of UNIX

Multi-user — Multiple users can log in simultaneously
Multi-tasking — Multiple processes can run concurrently
Portability — Written in C, easily ported to different hardware
Hierarchical File System — Tree-structured directory system
Shell — Powerful command interpreter with scripting capability
Security — File permissions, user authentication
Piping and Redirection — Combine commands, redirect I/O
Networking — Built-in networking support (TCP/IP)

1.4 UNIX Commands

1.4.1 File and Directory Commands

| Command | Description | Example | |---------|------------|---------| | ls | List directory contents | ls -la (detailed listing with hidden files) | | cd | Change directory | cd /home/user/docs | | pwd | Print working directory | pwd → /home/user | | mkdir | Create a directory | mkdir projects | | rmdir | Remove empty directory | rmdir old_folder | | cp | Copy files/directories | cp file1.txt file2.txt | | mv | Move/rename files | mv old.txt new.txt | | rm | Remove files | rm -rf folder/ (recursive + force) | | touch | Create empty file / update timestamp | touch newfile.txt | | cat | Display file contents | cat file.txt | | more / less | View file page by page | less largefile.txt | | head | Display first N lines | head -20 file.txt | | tail | Display last N lines | tail -f logfile.txt (live follow) | | find | Search for files | find / -name "*.txt" | | locate | Quick file search (uses database) | locate passwd | | ln | Create links | ln -s target link_name (symbolic link) |

1.4.2 File Permission Commands

File Permission Format:
┌────┬────────┬────────┬────────┐
│Type│ Owner  │ Group  │ Others │
│    │ r w x  │ r w x  │ r w x  │
└────┴────────┴────────┴────────┘
  d    rwx      r-x      r--
  
  r = read (4)    w = write (2)    x = execute (1)
  
  Example: chmod 755 file.txt
           Owner: 7 (rwx)  Group: 5 (r-x)  Others: 5 (r-x)

| Command | Description | Example | |---------|------------|---------| | chmod | Change file permissions | chmod 644 file.txt | | chown | Change file owner | chown user:group file.txt | | chgrp | Change group ownership | chgrp developers file.txt | | umask | Set default permissions | umask 022 |

1.4.3 Process Commands

| Command | Description | Example | |---------|------------|---------| | ps | Display running processes | ps aux (all users, detailed) | | top | Real-time process monitoring | top | | kill | Send signal to a process | kill -9 1234 (force kill PID 1234) | | bg | Move process to background | bg %1 | | fg | Move process to foreground | fg %1 | | nice | Run process with modified priority | nice -n 10 command | | nohup | Run process immune to hangups | nohup long_script.sh & | | jobs | List background jobs | jobs -l | | wait | Wait for process to complete | wait 1234 |

1.4.4 System Information Commands

| Command | Description | Example | |---------|------------|---------| | uname | System information | uname -a (all info) | | hostname | Display/set hostname | hostname | | uptime | System uptime | uptime | | who | Show logged-in users | who | | whoami | Current username | whoami | | df | Disk space usage | df -h (human-readable) | | du | Directory space usage | du -sh folder/ | | free | Memory usage | free -m (in megabytes) | | date | Current date and time | date | | cal | Calendar | cal 2026 |

1.4.5 Text Processing Commands

| Command | Description | Example | |---------|------------|---------| | grep | Search text patterns | grep -r "error" /var/log/ | | sed | Stream editor | sed 's/old/new/g' file.txt | | awk | Pattern scanning & processing | awk '{print $1}' file.txt | | sort | Sort lines | sort -n numbers.txt | | uniq | Remove duplicate lines | sort file.txt \| uniq | | wc | Word/line/character count | wc -l file.txt | | cut | Extract fields | cut -d: -f1 /etc/passwd | | tr | Translate characters | echo "hello" \| tr 'a-z' 'A-Z' | | diff | Compare files | diff file1.txt file2.txt |

1.4.6 I/O Redirection & Piping

Standard I/O Streams:
┌─────────┐     stdin (0)     ┌─────────┐     stdout (1)    ┌─────────┐
│ Keyboard│───────────────────▶│ Process │───────────────────▶│ Screen  │
│         │                   │         │                    │         │
└─────────┘                   │         │──── stderr (2) ──▶│         │
                              └─────────┘                    └─────────┘

Redirection Operators:
  >    Redirect stdout to file (overwrite)
  >>   Redirect stdout to file (append)
  <    Redirect stdin from file
  2>   Redirect stderr to file
  2>&1 Redirect stderr to stdout
  |    Pipe — send stdout of one command as stdin to another

Examples:

# Output redirection
ls -l > filelist.txt          # Save listing to file
echo "Hello" >> greetings.txt # Append to file
 
# Input redirection
sort < unsorted.txt           # Sort content from file
 
# Error redirection
find / -name "*.conf" 2>/dev/null  # Suppress errors
 
# Piping
ps aux | grep nginx | wc -l   # Count nginx processes
cat access.log | sort | uniq -c | sort -rn | head -10

1.4.7 Networking Commands

| Command | Description | Example | |---------|------------|---------| | ping | Test network connectivity | ping google.com | | ifconfig/ip | Network interface config | ip addr show | | netstat/ss | Network statistics | ss -tulpn | | ssh | Secure remote login | ssh user@server.com | | scp | Secure copy over network | scp file.txt user@host:/path/ | | wget/curl | Download files from web | wget https://example.com/file | | ftp | File Transfer Protocol | ftp server.com | | traceroute | Trace packet route | traceroute google.com | | nslookup/dig | DNS lookup | nslookup google.com |

1.4.8 Compression & Archive Commands

| Command | Description | Example | |---------|------------|---------| | tar | Archive files | tar -czvf archive.tar.gz folder/ | | gzip | Compress file | gzip file.txt → file.txt.gz | | gunzip | Decompress | gunzip file.txt.gz | | zip | Create zip archive | zip -r archive.zip folder/ | | unzip | Extract zip archive | unzip archive.zip |

1.5 UNIX File System Structure

/                         ← Root directory
├── bin/                  ← Essential user command binaries (ls, cp, mv)
├── boot/                 ← Boot loader files (kernel, grub)
├── dev/                  ← Device files (disk, terminal, etc.)
├── etc/                  ← System configuration files
│   ├── passwd            ← User account info
│   ├── shadow            ← Encrypted passwords
│   ├── fstab             ← File system mount table
│   └── hosts             ← Hostname-to-IP mappings
├── home/                 ← User home directories
│   ├── user1/
│   └── user2/
├── lib/                  ← Shared libraries
├── mnt/                  ← Mount point for temporary mounts
├── opt/                  ← Optional software packages
├── proc/                 ← Virtual filesystem (process info)
├── root/                 ← Root user's home directory
├── sbin/                 ← System admin binaries (fdisk, ifconfig)
├── tmp/                  ← Temporary files
├── usr/                  ← User programs and data
│   ├── bin/              ← User commands
│   ├── lib/              ← Libraries
│   ├── local/            ← Locally installed software
│   └── share/            ← Shared data (docs, man pages)
└── var/                  ← Variable data (logs, mail, spool)
    ├── log/              ← Log files
    ├── mail/             ← Mail spool
    └── tmp/              ← Temporary files preserved between reboots

1.6 Key Definitions for Quick Revision

| Term | Definition | |------|-----------| | Kernel | Core of OS that manages hardware resources and provides essential services | | Shell | Command-line interpreter that accepts user commands and executes them | | Process | A program in execution | | Multiprogramming | Multiple programs loaded in memory; CPU switches when one waits | | Time-sharing | CPU time divided among users/programs in time slices | | Throughput | Number of processes completed per unit time | | Turnaround Time | Total time from submission to completion of a job | | Response Time | Time from submission to first response | | Spooling | Simultaneous Peripheral Operations On-Line — buffering I/O data | | Daemon | Background process providing system services (e.g., cron, sshd) |

⚡ Exam Tips:

Difference between Batch, Multiprogramming, and Time-sharing is a frequently asked question
Know the types and examples of Real-Time Systems
Practice basic UNIX commands — often asked in labs/exams
Understand SMP vs AMP in multiprocessor systems
Know the difference between Distributed and Cluster systems

End of Unit 1