Skip to content
My Docs

Operating System Overview and Architecture

Category: Operating System Fundamentals
Type: Operating System Concept
Generated on: 2025-07-10 02:58:30
For: System Administration, Development & Technical Interviews

Operating System Overview and Architecture - Cheat Sheet

Section titled “Operating System Overview and Architecture - Cheat Sheet”

1. Quick Overview

  • What is it? The Operating System (OS) is the software that manages computer hardware and software resources and provides common services for computer programs. It acts as an intermediary between the user and the hardware.
  • Why is it important? Without an OS, applications cannot interact with the hardware. The OS provides a platform for applications to run efficiently and securely, managing resources like CPU, memory, and I/O devices. It abstracts away the complexities of hardware, allowing developers to focus on application logic.

2. Key Concepts

ConceptDefinition
KernelThe core of the OS; responsible for managing system resources, especially CPU, memory, and I/O.
ProcessAn instance of a program in execution. It includes the program code, data, and execution context (e.g., program counter, registers).
ThreadA lightweight process; a unit of execution within a process. Multiple threads can run concurrently within a single process, sharing the same memory space.
Memory ManagementAllocation and deallocation of memory to processes. Includes techniques like virtual memory, paging, segmentation.
File SystemOrganizes data on storage devices (e.g., hard drives, SSDs). Provides a hierarchical structure (directories, files) and methods for accessing and managing files.
I/O ManagementManages communication between the OS and I/O devices (e.g., keyboard, mouse, printer). Uses device drivers to interact with specific hardware.
System CallsThe interface between user-level applications and the OS kernel. Applications use system calls to request services from the OS (e.g., file I/O, process creation).
ShellA command-line interpreter that allows users to interact with the OS. It interprets commands and executes them. (e.g., bash, zsh, PowerShell)
InterruptsSignals that interrupt the normal execution of the CPU, typically triggered by hardware or software events. Used to handle I/O requests, errors, and other asynchronous events.
SchedulerA component of the OS that determines which process or thread should be executed at any given time. It uses scheduling algorithms to optimize CPU utilization and fairness.
VirtualizationCreating a virtual (rather than actual) version of something, such as a hardware platform, operating system, storage device, or network resources.
ContainerizationA form of operating system virtualization. Containers virtualize the OS, allowing multiple applications to run on the same OS kernel.

3. How It Works

a) Process Management

+---------------------+
|      Process A      |  <-- User Application
+---------------------+
| System Call (e.g., |
|   read from file)   |
+---------------------+
        |
        V
+---------------------+
|    OS Kernel        |
|  (System Call      |
|  Handler)          |
+---------------------+
        |
        V
+---------------------+
|   Hardware          |
| (Disk Controller)   |
+---------------------+
  1. Process Creation: When you run a program, the OS creates a process.
  2. Process Execution: The process executes instructions.
  3. System Calls: When a process needs to access resources (e.g., read a file), it makes a system call to the kernel.
  4. Kernel Handling: The kernel handles the system call, interacting with hardware if necessary.
  5. Context Switching: The OS switches between processes, giving each a time slice to execute.

b) Memory Management (Virtual Memory)

+---------------------+      +---------------------+
| Logical Address     | ---> | Physical Address    |
| (Process's View)   |      | (Actual RAM)       |
+---------------------+      +---------------------+
        |                  |
        V                  |
+---------------------+      |
| Page Table          | ---->|
+---------------------+      |
        |                  |
        V                  |
+---------------------+      |
| MMU (Memory        |      |
| Management Unit)    |      |
+---------------------+      |
        |                  |
        V                  |
+---------------------+      |
| RAM                 | <----|
+---------------------+
  1. Logical Address: Processes use logical addresses (virtual addresses).
  2. MMU: The Memory Management Unit (MMU) translates logical addresses to physical addresses.
  3. Page Table: The page table maps logical pages to physical frames in RAM.
  4. Paging: Divides both logical and physical memory into fixed-size blocks (pages/frames).
  5. Swapping: If memory is full, less frequently used pages can be moved to disk (swap space).

c) File System

+---------------------+
|  Root Directory (/) |
+---------------------+
        |
        V
+---------------------+      +---------------------+
| User Directory     | ---> | File Metadata        |
| (e.g., /home/user) |      | (permissions, size) |
+---------------------+      +---------------------+
        |                  |
        V                  |
+---------------------+      |
| File (e.g.,         |      |
|  document.txt)     |      |
+---------------------+      |
        |                  |
        V                  |
+---------------------+      |
| Data Blocks         | <----|
+---------------------+
  1. Hierarchical Structure: Files are organized in a tree-like structure of directories.
  2. Metadata: Each file has metadata (permissions, size, modification date).
  3. Data Blocks: The actual file data is stored in data blocks on the storage device.
  4. File Operations: The OS provides system calls for creating, reading, writing, and deleting files.

4. Real-World Examples

  • Windows, macOS, Linux: General-purpose operating systems for desktops and laptops.
  • Android, iOS: Mobile operating systems for smartphones and tablets.
  • Real-time Operating Systems (RTOS): Used in embedded systems (e.g., car engine control, medical devices) where timing is critical. Examples: FreeRTOS, VxWorks.
  • Server Operating Systems: Optimized for server workloads (e.g., Windows Server, Linux). Focus on stability, security, and scalability.
  • Virtual Machines (VMs): Virtualization enables running multiple OS instances on a single physical machine (e.g., using VMware, VirtualBox).
  • Containers (Docker, Kubernetes): Containers provide a lightweight virtualization approach, packaging applications and their dependencies (e.g., for microservices architecture).

Example Code (System Call - Python):

import os


# Example: Opening a file using a system call
try:
    fd = os.open("my_file.txt", os.O_RDONLY)  # OS.O_RDONLY - read only mode
    print(f"File descriptor: {fd}")


    # Read some data (requires more setup - simplified here for demonstration)
    # os.read(fd, 1024) # Read 1024 bytes


    os.close(fd)  # Close the file
except FileNotFoundError:
    print("File not found.")
except OSError as e:
    print(f"Error opening file: {e}")

5. Common Issues

IssueDescriptionTroubleshooting Tips
High CPU UsageA process or system service is consuming a large amount of CPU time.Identify the process using task manager (Windows) or top/htop (Linux/macOS). Investigate the process’s behavior. Check for infinite loops or inefficient algorithms. Consider upgrading hardware.
Memory LeakA process is allocating memory but not releasing it, leading to memory exhaustion.Use memory profiling tools to identify the source of the leak. Review code for improper memory management (e.g., missing free() calls in C/C++). Restart the process to reclaim memory.
Disk FullThe storage device is running out of space.Identify large files and directories using `du -sh *
Slow I/ORead/write operations to disk are slow.Check disk health using SMART monitoring tools. Defragment the disk (if necessary). Consider upgrading to a faster storage device (e.g., SSD). Optimize file access patterns.
DeadlockTwo or more processes are blocked indefinitely, waiting for each other to release resources.Analyze the resource allocation graph to identify the deadlock. Implement deadlock prevention or avoidance techniques (e.g., resource ordering, timeout mechanisms). Restart the affected processes.
Kernel Panic (BSOD)A critical error has occurred in the OS kernel, causing the system to crash. (Blue Screen of Death on Windows, kernel panic on macOS/Linux).Analyze the crash dump to identify the cause of the error. Update device drivers. Check for hardware issues. Reinstall the OS if necessary.
Process StarvationA process is repeatedly denied access to the CPU, even though it is ready to run.Examine the scheduling algorithm. Adjust process priorities to ensure fairness. Reduce the number of competing processes.
Race ConditionThe behavior of a program depends on the unpredictable order in which different parts of the program execute, especially when accessing shared resources.Use synchronization primitives (e.g., mutexes, semaphores) to protect shared resources. Carefully review multi-threaded or multi-process code for potential race conditions. Use static analysis tools to detect potential issues.

6. Interview Questions

  • What is the difference between a process and a thread?
    • A process is an instance of a program in execution, with its own memory space. A thread is a lightweight process within a process, sharing the same memory space.
  • What is virtual memory? How does it work?
    • Virtual memory allows processes to access more memory than is physically available. It uses paging to map logical addresses to physical addresses and swapping to move less frequently used pages to disk.
  • Explain the concept of context switching.
    • Context switching is the process of saving the state of one process and restoring the state of another process, allowing the OS to switch between processes.
  • What are system calls? Give some examples.
    • System calls are the interface between user-level applications and the OS kernel. Examples include open(), read(), write(), fork(), exec().
  • What is the role of the kernel in an operating system?
    • The kernel is the core of the OS, responsible for managing system resources, especially CPU, memory, and I/O.
  • Explain the difference between preemptive and non-preemptive scheduling.
    • In preemptive scheduling, the OS can interrupt a running process and switch to another process. In non-preemptive scheduling, a process runs until it voluntarily relinquishes the CPU.
  • What is a deadlock? How can it be prevented?
    • A deadlock occurs when two or more processes are blocked indefinitely, waiting for each other to release resources. Prevention techniques include resource ordering, timeout mechanisms, and avoiding circular wait conditions.
  • What are the advantages and disadvantages of using threads?
    • Advantages: Increased responsiveness, resource sharing, and improved performance. Disadvantages: Increased complexity, synchronization issues (race conditions, deadlocks), and potential for security vulnerabilities.
  • Explain the difference between monolithic and microkernel architectures.
    • In a monolithic kernel, most OS services run in kernel space. In a microkernel, only essential services run in kernel space, and other services run in user space.
  • What is the difference between virtualization and containerization?
    • Virtualization uses a hypervisor to create virtual machines, each with its own OS. Containerization uses OS-level virtualization to isolate applications and their dependencies, sharing the same OS kernel. Containers are more lightweight and efficient than VMs.
  • Describe common scheduling algorithms (e.g., FIFO, SJF, Round Robin, Priority Scheduling).
    • FIFO (First-In, First-Out): Processes are executed in the order they arrive. Simple but can lead to long wait times for shorter processes.
    • SJF (Shortest Job First): Processes with the shortest execution time are executed first. Minimizes average waiting time but requires knowing the execution time in advance.
    • Round Robin: Each process is given a fixed time slice (quantum) to execute. Provides fair CPU allocation but can have higher overhead due to context switching.
    • Priority Scheduling: Processes are assigned priorities, and higher-priority processes are executed first. Can lead to starvation for lower-priority processes.

7. Further Reading

  • Operating System Concepts by Abraham Silberschatz, Peter Baer Galvin, and Greg Gagne
  • Modern Operating Systems by Andrew S. Tanenbaum
  • The Linux Programming Interface by Michael Kerrisk
  • Online documentation for your specific OS (e.g., Linux man pages, Windows documentation, macOS developer documentation)
  • Operating system-related blogs and forums

This cheat sheet provides a comprehensive overview of operating system fundamentals. Remember to practice and apply these concepts to gain a deeper understanding. Good luck!