Operating System Overview¶

Overview¶

An Operating System (OS) is system software that manages computer hardware and provides services to application programs. This lesson covers the definition of operating systems, their roles, development history, and kernel architecture.

Table of Contents¶

What is an Operating System?
Roles of an Operating System
History of Operating Systems
Kernel Architecture
System Calls
Interrupt Handling
Practice Problems

1. What is an Operating System?¶

Definition¶

Operating System = Intermediary between hardware and users

┌─────────────────────────────────────────┐
│         Users/Application Programs       │
├─────────────────────────────────────────┤
│          Operating System (OS)           │
│  - Resource Manager                      │
│  - Control Program                       │
├─────────────────────────────────────────┤
│              Hardware                    │
│    CPU, Memory, Disk, I/O Devices        │
└─────────────────────────────────────────┘

Two Perspectives of OS¶

┌────────────────────────────────────────────────────┐
│              Perspective 1: Resource Manager        │
├────────────────────────────────────────────────────┤
│  - CPU time distribution                           │
│  - Memory space allocation                         │
│  - Disk/I/O device management                      │
│  - Resolve resource conflicts between programs     │
└────────────────────────────────────────────────────┘

┌────────────────────────────────────────────────────┐
│              Perspective 2: Service Provider        │
├────────────────────────────────────────────────────┤
│  - File system access                              │
│  - Process execution environment                   │
│  - User interface (CLI/GUI)                        │
│  - Network communication                           │
└────────────────────────────────────────────────────┘

2. Roles of an Operating System¶

Core Functions¶

┌───────────────────────────────────────────────────────┐
│                OS Core Functions                       │
├───────────────┬───────────────────────────────────────┤
│ Process Mgmt  │ Process creation/termination/scheduling│
├───────────────┼───────────────────────────────────────┤
│ Memory Mgmt   │ Memory allocation/deallocation, virtual│
├───────────────┼───────────────────────────────────────┤
│ File System   │ File create/delete/read/write          │
├───────────────┼───────────────────────────────────────┤
│ I/O Mgmt      │ Device drivers, buffering, spooling    │
├───────────────┼───────────────────────────────────────┤
│ Security      │ Access control, user authentication    │
├───────────────┼───────────────────────────────────────┤
│ Networking    │ Protocol stack, socket interface       │
└───────────────┴───────────────────────────────────────┘

Resource Management Example¶

// Process reading a file
// (How OS mediates)

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 1. Open file (request to OS)
    int fd = open("data.txt", O_RDONLY);

    // 2. Read file (OS handles disk I/O)
    char buffer[1024];
    ssize_t bytes = read(fd, buffer, sizeof(buffer));

    // 3. Close file (OS releases resource)
    close(fd);

    return 0;
}

/*
User Program         Operating System      Hardware
     │                    │                  │
     │── open() ──────────▶                  │
     │                    │── Disk access ───▶
     │                    │◀── Data ─────────│
     │◀── fd returned ────│                  │
*/

3. History of Operating Systems¶

Evolution by Generation¶

┌─────────────────────────────────────────────────────────────┐
│              Operating System Evolution History              │
├───────────┬─────────────────────────────────────────────────┤
│   Era      │                  Features                       │
├───────────┼─────────────────────────────────────────────────┤
│ 1st Gen    │ No OS, manual operation                         │
│ 1940-50s   │ Programmers enter machine code directly         │
├───────────┼─────────────────────────────────────────────────┤
│ 2nd Gen    │ Batch System                                    │
│ 1950-60s   │ Job automation, resident monitor                │
├───────────┼─────────────────────────────────────────────────┤
│ 3rd Gen    │ Multiprogramming, time-sharing                  │
│ 1960-70s   │ Multiple programs execute concurrently,         │
│            │ interactive usage                                │
├───────────┼─────────────────────────────────────────────────┤
│ 4th Gen    │ Distributed systems, network OS                 │
│ 1970-Now   │ GUI, multiprocessor, cloud                      │
└───────────┴─────────────────────────────────────────────────┘

Batch System¶

┌───────────────────────────────────────────────────────┐
│              Batch System Operation                    │
├───────────────────────────────────────────────────────┤
│                                                       │
│   Job1 ──▶ Job2 ──▶ Job3 ──▶ Job4 ──▶ ...           │
│                                                       │
│   • Only one job executes at a time                   │
│   • CPU idle time occurs (waiting for I/O)           │
│   • Improved efficiency with automatic job switching  │
│                                                       │
└───────────────────────────────────────────────────────┘

Timeline:
┌──────┬──────────────────┬──────┬──────────────────┐
│Job1  │   I/O wait (waste)│Job2  │   I/O wait       │
└──────┴──────────────────┴──────┴──────────────────┘
   CPU        CPU idle         CPU        CPU idle

Multiprogramming¶

┌───────────────────────────────────────────────────────┐
│            Multiprogramming Operation                  │
├───────────────────────────────────────────────────────┤
│                                                       │
│   Multiple programs loaded in memory simultaneously   │
│                                                       │
│   ┌─────────┐                                         │
│   │  OS     │                                         │
│   ├─────────┤                                         │
│   │ Program1│ ◀── CPU executing                       │
│   ├─────────┤                                         │
│   │ Program2│ ◀── Waiting for I/O                     │
│   ├─────────┤                                         │
│   │ Program3│ ◀── Ready state                         │
│   └─────────┘                                         │
│                                                       │
└───────────────────────────────────────────────────────┘

Timeline:
┌──────┬──────┬──────┬──────┬──────┬──────┐
│Job1  │Job2  │Job3  │Job1  │Job3  │Job2  │
└──────┴──────┴──────┴──────┴──────┴──────┘
   CPU continuously performs different tasks

┌───────────────────────────────────────────────────────┐
│            Time-Sharing System Operation               │
├───────────────────────────────────────────────────────┤
│                                                       │
│   Multiple users use computer simultaneously          │
│   Each user allocated short time slice                │
│                                                       │
│   UserA ──┬── 10ms ──┬── 10ms ──┬── ...              │
│   UserB ──┼── 10ms ──┼── 10ms ──┼── ...              │
│   UserC ──┴── 10ms ──┴── 10ms ──┴── ...              │
│                                                       │
│   → Each user feels like they have exclusive access   │
│   → Response time important (interactive system)      │
│                                                       │
└───────────────────────────────────────────────────────┘

4. Kernel Architecture¶

What is a Kernel?¶

Kernel = Core part of the operating system
       = Directly interacts with hardware
       = Always resident in memory

┌─────────────────────────────────────────┐
│           User Space                     │
│  ┌───────┐ ┌───────┐ ┌───────┐          │
│  │ App1  │ │ App2  │ │ App3  │          │
│  └───────┘ └───────┘ └───────┘          │
├─────────────────────────────────────────┤
│           Kernel Space                   │
│  ┌───────────────────────────────────┐  │
│  │           Kernel                   │  │
│  │  • Process management              │  │
│  │  • Memory management               │  │
│  │  • File system                     │  │
│  │  • Device drivers                  │  │
│  └───────────────────────────────────┘  │
├─────────────────────────────────────────┤
│              Hardware                    │
└─────────────────────────────────────────┘

Monolithic Kernel¶

┌───────────────────────────────────────────┐
│              Monolithic Kernel             │
├───────────────────────────────────────────┤
│                                           │
│  ┌─────────────────────────────────────┐  │
│  │             Kernel                   │  │
│  │  ┌──────┬──────┬──────┬──────────┐  │  │
│  │  │Process│Memory │File   │ Network  │  │  │
│  │  │ Mgmt  │ Mgmt  │System │          │  │  │
│  │  ├──────┴──────┴──────┴──────────┤  │  │
│  │  │      Device Drivers            │  │  │
│  │  └────────────────────────────────┘  │  │
│  └─────────────────────────────────────┘  │
│                                           │
│  Advantages: Excellent performance        │
│  Disadvantages: Hard to maintain, bugs    │
│                 have wide impact          │
│  Examples: Linux, Unix, MS-DOS            │
│                                           │
└───────────────────────────────────────────┘

Microkernel¶

┌───────────────────────────────────────────┐
│              Microkernel                   │
├───────────────────────────────────────────┤
│                                           │
│  User space:                              │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────────┐ │
│  │File   │ │Device │ │Network│ │Process   │ │
│  │Server │ │Driver │ │Server │ │Server    │ │
│  └──────┘ └──────┘ └──────┘ └──────────┘ │
│            ▲          ▲          ▲        │
│            │    IPC   │          │        │
│            ▼          ▼          ▼        │
│  ┌─────────────────────────────────────┐  │
│  │      Microkernel (minimal)          │  │
│  │   - Basic IPC                       │  │
│  │   - Basic scheduling                │  │
│  │   - Basic memory management         │  │
│  └─────────────────────────────────────┘  │
│                                           │
│  Advantages: Stability, easy maintenance  │
│  Disadvantages: Performance degradation   │
│                 due to IPC overhead       │
│  Examples: Minix, QNX, L4                 │
│                                           │
└───────────────────────────────────────────┘

Hybrid Kernel¶

┌───────────────────────────────────────────┐
│              Hybrid Kernel                 │
├───────────────────────────────────────────┤
│                                           │
│  Combines advantages of micro + monolithic│
│                                           │
│  User space:                              │
│  ┌──────┐ ┌──────┐                        │
│  │ App  │ │Subsys│                        │
│  └──────┘ └──────┘                        │
│                                           │
│  ┌─────────────────────────────────────┐  │
│  │           Hybrid Kernel              │  │
│  │  ┌──────────────────────────────┐   │  │
│  │  │ FileSystem │ Network │ Graphics│   │  │
│  │  └──────────────────────────────┘   │  │
│  │  ┌──────────────────────────────┐   │  │
│  │  │       Microkernel Core        │   │  │
│  │  └──────────────────────────────┘   │  │
│  └─────────────────────────────────────┘  │
│                                           │
│  Examples: Windows NT, macOS (XNU)        │
│                                           │
└───────────────────────────────────────────┘

Kernel Architecture Comparison¶

┌─────────────┬──────────┬──────────┬──────────┐
│  Feature     │Monolithic│Microkernel│ Hybrid   │
├─────────────┼──────────┼──────────┼──────────┤
│ Performance │ High     │ Low      │ Medium   │
│ Stability   │ Low      │ High     │ Medium   │
│ Maintenance │ Hard     │ Easy     │ Medium   │
│ Modularity  │ Low      │ High     │ High     │
│ Code Size   │ Large    │ Small    │ Medium   │
├─────────────┼──────────┼──────────┼──────────┤
│ Examples    │ Linux    │ Minix    │ Windows  │
│             │ FreeBSD  │ QNX      │ macOS    │
└─────────────┴──────────┴──────────┴──────────┘

5. System Calls¶

What is a System Call?¶

System Call = Interface for user programs to request OS services

┌───────────────────────────────────────────┐
│              User Mode                     │
│                                           │
│    ┌─────────────────────────────────┐    │
│    │      User Program                │    │
│    │                                 │    │
│    │   read(fd, buffer, size);       │    │
│    │          │                      │    │
│    │          ▼                      │    │
│    │   ┌──────────────────┐          │    │
│    │   │ System Call Interface│       │    │
│    │   │ (Library function)  │        │    │
│    │   └──────────────────┘          │    │
│    └─────────────│───────────────────┘    │
├──────────────────│────────────────────────┤
│              Kernel Mode (trap)            │
│                  ▼                        │
│    ┌─────────────────────────────────┐    │
│    │      System Call Handler         │    │
│    │                                 │    │
│    │   → Perform actual file read     │    │
│    │   → Return result to user        │    │
│    └─────────────────────────────────┘    │
└───────────────────────────────────────────┘

System Call Processing Steps¶

Steps:
1. User program calls system call
2. Library sets parameters in registers
3. Software interrupt (trap) occurs
4. User mode → Kernel mode transition
5. Find handler using system call number
6. Execute handler
7. Kernel mode → User mode return
8. Return result

┌────────────────────────────────────────────────┐
│                System Call Table                │
├────────┬───────────────────────────────────────┤
│ Number │              System Call               │
├────────┼───────────────────────────────────────┤
│   0    │ read()                                │
│   1    │ write()                               │
│   2    │ open()                                │
│   3    │ close()                               │
│   ...  │ ...                                   │
│  39    │ fork()                                │
│  60    │ exit()                                │
└────────┴───────────────────────────────────────┘

System Call Categories¶

// 1. Process Control
fork();     // Create process
exec();     // Execute program
exit();     // Terminate process
wait();     // Wait for child process

// 2. File Management
open();     // Open file
read();     // Read file
write();    // Write file
close();    // Close file

// 3. Device Management
ioctl();    // Control device
read();     // Read from device
write();    // Write to device

// 4. Information Maintenance
getpid();   // Get process ID
time();     // Get time

// 5. Communication
socket();   // Create socket
send();     // Send data
recv();     // Receive data

System Call Example¶

// File writing example in Linux
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

int main() {
    const char *msg = "Hello, OS!\n";

    // System call 1: open()
    int fd = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        // System call: write() to stderr
        write(2, "Error opening file\n", 19);
        return 1;
    }

    // System call 2: write()
    ssize_t bytes_written = write(fd, msg, strlen(msg));

    // System call 3: close()
    close(fd);

    return 0;
}

/*
Trace system calls with strace:
$ strace ./a.out

openat(AT_FDCWD, "output.txt", O_WRONLY|O_CREAT|O_TRUNC, 0644) = 3
write(3, "Hello, OS!\n", 11) = 11
close(3) = 0
*/

6. Interrupt Handling¶

What is an Interrupt?¶

Interrupt = Signal that notifies CPU of event requiring attention

┌────────────────────────────────────────────────┐
│                 Interrupt Types                 │
├──────────────────┬─────────────────────────────┤
│ Hardware Interrupt│   Software Interrupt        │
├──────────────────┼─────────────────────────────┤
│ • Timer          │ • System call (trap)        │
│ • Keyboard input │ • Exception                 │
│ • Mouse movement │   - Division by zero        │
│ • Disk I/O done  │   - Invalid memory access   │
│ • Network packet │   - Page fault              │
└──────────────────┴─────────────────────────────┘

Interrupt Handling Process¶

┌───────────────────────────────────────────────────────┐
│                  Interrupt Handling Process            │
└───────────────────────────────────────────────────────┘

1. CPU executing instructions
   │
   ▼
2. Interrupt occurs (e.g., keyboard input)
   │
   ▼
3. Save current state (PC, registers)
   │
   ▼
4. Find handler address in interrupt vector table
   │
   ▼
5. Execute Interrupt Service Routine (ISR)
   │
   ▼
6. Restore saved state
   │
   ▼
7. Resume interrupted program

┌─────────────────────────────────────────────┐
│            Interrupt Vector Table            │
├───────┬─────────────────────────────────────┤
│ Number│           Handler Address            │
├───────┼─────────────────────────────────────┤
│   0   │ 0x00001000 (Division error)         │
│   1   │ 0x00001100 (Debug)                  │
│   2   │ 0x00001200 (NMI)                    │
│  ...  │ ...                                 │
│  32   │ 0x00002000 (Timer)                  │
│  33   │ 0x00002100 (Keyboard)               │
└───────┴─────────────────────────────────────┘

Interrupt Timeline¶

Time →

Process execution: ████████░░░░░░░░████████████████████
                      ↑     ↑
                   Interrupt ISR
                   occurs   done

Details:
┌────────┬────────┬────────────────┬────────────────┐
│ Instruction│ Save   │  Interrupt     │   Instruction  │
│ execution  │ state  │  handler exec  │   resume       │
└────────┴────────┴────────────────┴────────────────┘

Interrupt Priority¶

High   ┌─────────────────────────┐
   ↑   │ Power Failure            │
   │   ├─────────────────────────┤
   │   │ Machine Check            │
   │   ├─────────────────────────┤
   │   │ External Interrupt (NMI) │
   │   ├─────────────────────────┤
   │   │ Timer Interrupt          │
   │   ├─────────────────────────┤
   │   │ I/O Interrupt            │
   │   ├─────────────────────────┤
   │   │ Software Interrupt       │
   ↓   └─────────────────────────┘
Low

Interrupt Handler Example (Conceptual)¶

// Interrupt Service Routine
// Actually written with assembly

// Timer interrupt handler (conceptual code)
void timer_interrupt_handler(void) {
    // 1. Decrease current process's time slice
    current_process->time_slice--;

    // 2. Update system time
    system_time++;

    // 3. Schedule if time slice is 0
    if (current_process->time_slice == 0) {
        schedule();  // Select next process
    }

    // 4. Signal interrupt completion
    send_EOI();  // End Of Interrupt
}

// Keyboard interrupt handler (conceptual code)
void keyboard_interrupt_handler(void) {
    // 1. Read scan code from keyboard controller
    uint8_t scancode = inb(KEYBOARD_DATA_PORT);

    // 2. Convert scan code to ASCII
    char key = scancode_to_ascii(scancode);

    // 3. Store in keyboard buffer
    keyboard_buffer_put(key);

    // 4. Wake up waiting processes
    wakeup_keyboard_waiters();

    // 5. Send EOI
    send_EOI();
}

7. Practice Problems¶

Problem 1: Basic Concepts¶

Fill in the blanks.

The two perspectives of an operating system are __ and service provider.
The goal of multiprogramming is to reduce __ to increase CPU utilization.
The kernel structure where all functions are integrated is called __.

Show Answer

1. Resource manager 2. CPU idle time 3. Monolithic kernel

Problem 2: System Call Classification¶

Classify the following system calls into appropriate categories.

fork(), open(), socket(), getpid(), ioctl()

Process Control	File Management	Device Management	Information Maintenance	Communication

Show Answer

| Process Control | File Management | Device Management | Information Maintenance | Communication | |----------------|----------------|------------------|----------------------|--------------| | fork() | open() | ioctl() | getpid() | socket() |

Problem 3: Kernel Architecture Comparison¶

Choose the matching kernel architecture for each description.

A. Monolithic Kernel B. Microkernel C. Hybrid Kernel

( ) Kernel contains only minimal functions, rest runs in user space
( ) Architecture used by Linux
( ) Architecture used by Windows NT
( ) Performance degradation due to IPC overhead is a disadvantage

Show Answer

1. (B) Microkernel 2. (A) Monolithic Kernel 3. (C) Hybrid Kernel 4. (B) Microkernel

Problem 4: Interrupt Handling¶

Arrange the interrupt handling process in the correct order.

A. Execute interrupt handler B. Save current state C. Interrupt occurs D. Restore saved state E. Find handler in interrupt vector table

Show Answer

C → B → E → A → D 1. (C) Interrupt occurs 2. (B) Save current state 3. (E) Find handler in interrupt vector table 4. (A) Execute interrupt handler 5. (D) Restore saved state

Problem 5: System Call Code Analysis¶

List the system calls that occur in the following code in order.

#include <unistd.h>
#include <fcntl.h>

int main() {
    pid_t pid = fork();

    if (pid == 0) {
        int fd = open("child.txt", O_WRONLY | O_CREAT, 0644);
        write(fd, "child", 5);
        close(fd);
    } else {
        wait(NULL);
        write(1, "parent\n", 7);
    }

    return 0;
}

Show Answer

1. fork() - Create child process Child process: 2. open() - Open file 3. write() - Write to file 4. close() - Close file 5. exit() - Terminate process (implicit) Parent process: 6. wait() - Wait for child process 7. write() - Write to standard output 8. exit() - Terminate process (implicit)

Next Steps¶

02_Process_Concepts.md - Process memory structure and state transitions

Operating System Overview¶

Overview¶

Table of Contents¶

1. What is an Operating System?¶

Definition¶

Two Perspectives of OS¶

2. Roles of an Operating System¶

Core Functions¶

Resource Management Example¶

3. History of Operating Systems¶

Evolution by Generation¶

Batch System¶

Multiprogramming¶

Time-Sharing System¶

4. Kernel Architecture¶

What is a Kernel?¶

Monolithic Kernel¶

Microkernel¶

Hybrid Kernel¶

Kernel Architecture Comparison¶

5. System Calls¶

What is a System Call?¶

System Call Processing Steps¶

System Call Categories¶

System Call Example¶

6. Interrupt Handling¶

What is an Interrupt?¶

Interrupt Handling Process¶

Interrupt Timeline¶

Interrupt Priority¶

Interrupt Handler Example (Conceptual)¶

7. Practice Problems¶

Problem 1: Basic Concepts¶

Problem 2: System Call Classification¶

Problem 3: Kernel Architecture Comparison¶

Problem 4: Interrupt Handling¶

Problem 5: System Call Code Analysis¶

Next Steps¶

References¶