Every operating system concept in one video…

The operating system is a crucial, underappreciated software that enables computers to function. The video explains the complex process from powering on a computer to shutting it down, detailing the roles of various OS components. **Stage 1: The Bootloader** Upon pressing the power button, the CPU, in its most basic state, executes firmware (UEFI or BIOS). This firmware initializes minimal hardware and locates a bootloader (like Grub, IBO, or Bootmagger) on a disk. The bootloader's sole purpose is to load the operating system's kernel into RAM. Once loaded, the CPU executes kernel code with full hardware privileges. **Stage 2: Privilege Rings** To prevent programs from interfering with each other or the system, CPUs implement privilege levels. On x86 processors, there are four, but essentially two are critical: Ring 0 for the kernel (unrestricted access) and Ring 3 for user space (applications, requiring permission for most actions). This separation is vital for system stability; a faulty application in Ring 3 typically only crashes itself. **Stage 3: Virtual Memory** The kernel establishes virtual memory, a deceptive system where programs access fake virtual addresses. The Memory Management Unit (MMU), using page tables managed by the kernel, translates these virtual addresses into real physical addresses. Memory is divided into pages, and each process has its own page table, preventing them from accessing each other's memory. The Translation Lookaside Buffer (TLB) caches these translations. If a program accesses a page not in RAM, a page fault occurs, triggering the kernel to load the page from disk. **Stage 4: The File System** The file system software masks the raw block structure of disks, presenting files and folders. Files are stored as index nodes (inodes), which contain metadata and pointers to data blocks, but not the file name. File names are stored in directories, which are special files mapping names to inode numbers. Modern file systems use journaling, writing intentions before data to prevent corruption during power loss. **Stage 5: Device Drivers and Interrupts** The kernel loads device drivers, specialized code that translates generic requests into hardware-specific instructions for devices like GPUs and keyboards. Drivers run in kernel mode, meaning a faulty driver can crash the system. Interrupts are electrical signals from hardware indicating an event. Instead of constantly polling, the CPU is "interrupted" by these signals, allowing it to react instantly to input and events, like mouse movements or network data arrival. **Stage 6: PID1, The First Process** The kernel then creates PID1, the first user-space process (often systemd on Linux). This process is the ancestor of all others; its termination causes a system panic. PID1 runs in user space, meaning all subsequent operations require kernel permission. **Stage 7: System Calls** When a process needs to perform privileged operations, like reading a file, it makes a system call. This triggers a switch from user space (Ring 3) to kernel mode (Ring 0), ensuring security. Functions like `print` in C often translate to system calls like `write`. `fork` and `exec` are key system calls for creating new processes. **Stage 8: The Scheduler** With many processes running on fewer CPU cores, the scheduler manages CPU time. It acts like an air traffic controller, deciding which process gets access to the CPU. Modern Linux uses algorithms like Earliest Eligible Virtual Deadline First to ensure fair CPU allocation. **Stage 9: Threads** Threads allow a single program to perform multiple tasks concurrently by sharing memory and file descriptors but having separate stacks and program counters. However, shared memory can lead to race conditions, which modern languages attempt to mitigate. **Stage 10: Interprocess Communication (IPC)** When separate processes need to communicate, they use IPC mechanisms like pipes, sockets, or message queues. Pipes, for example, allow the output of one process to become the input of another, facilitating safe communication without shared memory. **Shutdown Process:** During shutdown, PID1 sends a polite `SIGTERM` signal to all processes. If they don't quit, a forceful `SIGKILL` signal is sent. The file system is flushed, drivers are released, memory is synced, interrupts are disabled, and the CPU halts, followed by power being cut.