Operating Systems, Kernel & Hardware Sympathy

Introduction: Thinking Like a Mechanic

The Great Lie: Memory is Fast

The Latency Hierarchy (The Desk Analogy)

Cache Lines and Spatial Locality

False Sharing (The Noisy Neighbor Problem)

Branch Prediction and Speculation

Spectre and Meltdown: When Speculation Becomes a Security Hole

NUMA (Non-Uniform Memory Access)

Putting It All Together: Hardware Sympathy in Practice

Introduction: "Everything is a File

The Filesystem Hierarchy Standard (FHS)

Inodes: The Metadata Beneath the Surface

Hard Links vs. Soft (Symbolic) Links

File Descriptors: The Universal Connectors

Virtual Filesystems: /proc and /sys

Mount Points: Attaching Filesystems

Introduction: The Security Gatekeeper

The "rwx" Triad: Read, Write, Execute

Viewing Permissions: The `ls -l` Command

Changing Permissions: `chmod` (Symbolic Mode)

Changing Permissions: `chmod` (Octal Mode)

Changing Ownership: `chown` and `chgrp`

Default Permissions: `umask`

Special Permissions: The Sticky Bit

Special Permissions: SUID (Set User ID)

Special Permissions: SGID (Set Group ID)

Combining Special Bits: The Four-Digit Octal

Access Control Lists (ACLs): Beyond Basic Permissions

Introduction: What is a Process Really?

The Lifecycle Part 1: Birth by Cloning (`fork`)

The Lifecycle Part 2: Transformation (`exec`)

The Lifecycle Part 3: Death and Reporting (`exit` & `wait`)

Process States: Running and Sleeping

Process States: The Zombie (Z)

Process States: The Deep Sleep (D-state)

Understanding Load Average

Signals: Communicating with Processes

The "Polite" Signals: SIGTERM and SIGHUP

The Nuclear Option: SIGKILL

Introduction: The Orchestra Conductor

Unit Files: The Instructions Systemd Reads

Best Practice: Overrides and Drop-In Files

Types of Units: Services, Timers, Mounts, and More

Dependency Management: Wants, Requires, and After

The Nuclear Option: Masking Services

Targets: Grouping Units Together

The Journal: Centralized Logging with journalctl

Introduction: From Dead Metal to Live System

Stage 1: The Hardware Handshake (BIOS vs. UEFI)

Stage 2: The Bootloader (GRUB)

Stage 3: The Kernel Initializes

Stage 4: The Initramfs Trick

Stage 5: PID 1 and systemd

Introduction: The Noisy Neighbor Problem

ulimit: The Personal Quota

War Story: The Silent TCP Drop

Cgroups: The Group Budget

Cgroups v1 vs. v2: Clearing the Mess

Namespaces: The Illusion of Isolation

Putting It Together: How Docker Uses All Three

Introduction: The Grand Illusion

Paging and Page Tables: The Map

Page Faults: When the Map Fails

Memory Overcommitment: The Calculated Gamble

Swap: The Overflow Parking Lot

Swappiness: Controlling the Trigger

The OOM Killer: The Grim Reaper

Influencing the OOM Killer

Memory Visibility Tools: Reading the System's Mind

Introduction: The CPU's Traffic Cop

Scheduling Classes: A Hierarchy of Priorities

The Default: Completely Fair Scheduler (CFS)

How CFS Works: Virtual Runtime (vruntime)

Context Switching: The Cost of Multitasking

Preemption Models

Real-Time Scheduling: Cutting the Line

RT Policies: SCHED_FIFO vs. SCHED_RR vs. SCHED_DEADLINE

CPU Affinity and NUMA Awareness

Introduction: Seeing Inside the Black Box

The Old Guard: System Call Tracing with `strace`

The Network Sniffer: `tcpdump`

The Revolution: Introduction to eBPF

eBPF Architecture & Safety: The Verifier

Modern eBPF Tools I: BCC (BPF Compiler Collection)

Modern eBPF Tools II: bpftrace

The Broader Observability Ecosystem: perf and Flame Graphs

Introduction: The Journey of a Write

The Virtual Filesystem (VFS): One API to Rule Them All

Buffered I/O vs. Direct I/O

The Block Layer and the `bio` Struct

I/O Schedulers: The Elevator Algorithm

Synchronous vs. Asynchronous I/O

Generation 1: Select and Poll

Generation 2: Epoll (The Event List)

Generation 3: io_uring (The New King)

The Single Core Bottleneck

Hardware Scaling: RSS (Receive Side Scaling)

Software Scaling: RPS (Receive Packet Steering)

Locality Scaling: RFS (Receive Flow Steering)

Transmit-Side Scaling: XPS (Transmit Packet Steering)

Introduction: Why Processes Need to Talk

Pipes and Named Pipes (FIFOs)

Unix Domain Sockets (UDS) vs. TCP Loopback

Shared Memory — The Zero-Copy Fast Path

mmap — Files Masquerading as Memory

Signals — The Lightweight Notification Channel

Introduction: Hardware vs. System Time

Wall Clock vs. Monotonic Clock

NTP and Clock Discipline

Leap Seconds and Leap Smearing

Time Namespaces

Introduction: The Linux Security Module Framework

DAC vs. MAC: The Problem LSM Solves

SELinux: Labels and Contexts

SELinux Modes: Enforcing, Permissive, and Disabled

AppArmor: The Path-Based Alternative

Audit Logs: Reading AVC Denials

Fixing SELinux: restorecon, semanage, and audit2allow

Introduction: The Hypervisor

Paravirtualization and VirtIO

CPU Steal Time (`%st`)

Memory Virtualization and Ballooning

Storage Virtualization and the Thin Provisioning Trap

Introduction: Runtime Kernel Tuning

Essential Tunables: VM Swappiness

Essential Tunables: Network Buffers

The Magic SysRq Key

Load Average: The Most Misinterpreted Metric

CPU Bound vs. I/O Bound

Introduction: Beyond `top` and `htop`

CPU Topology: `lscpu` and `lstopo`

Kernel Memory: `slabtop`

Process Memory Analysis: `/proc/[pid]/smaps`

Introduction: What is a "Binary"?

Anatomy of ELF Sections (.text, .data, .bss, .rodata)

Object Files and the Linking Process

Static vs. Dynamic Linking

The Loader: ld.so

vDSO: The Virtual Library

LD_PRELOAD — The Ultimate Hook

Introduction: The Doorbell Problem

Top Half vs. Bottom Half: The Two-Phase Design

NAPI: Switching from Interrupts to Polling Under Load

`ksoftirqd`: The Kernel's Cleanup Crew

CPU Affinity and IRQ Pinning (`smp_affinity`)

Introduction: The Power Failure Nightmare

Journaling: The Write-Ahead Log

Write Barriers: Preventing Disk Lies

Overwrite vs. Copy-on-Write

Snapshots: The Time Machine

Bit Rot and Checksums

Introduction: The Conversation

The Core Four: Navigation and Inspection

SSH Keys: The Digital Handshake

Shell Config: .bashrc, .zshrc, and the Login Shell

Terminal Multiplexers: tmux

Redirection and Output Control

Process Management: ps, kill, and Signals

Introduction: The Hybrid Reality

Active Directory (AD): The Kingdom

The Registry vs. /etc

NTFS vs. Linux Filesystems

PowerShell: Objects, Not Text

Managing IIS and RDP

Introduction: The Amnesia Patient

User Data vs. Cloud Config

The Boot Stages (Timing is Everything)

Cloud-Config Syntax Essentials

Debugging: Reading the Logs

Debugging: The Black Box (Can't SSH In)

Introduction: The Computer Inside Your Computer

The Driver Stack: Kernel vs. User Space

PCIe Topology and NUMA Affinity

Unified Memory and GPU Page Faults

NVLink vs. PCIe for Multi-GPU Communication

GPUDirect RDMA — Bypassing the CPU Entirely

Debugging with nvidia-smi — Basic Monitoring

Debugging with nvidia-smi — Topology and Affinity

Xid Errors — When Hardware Fails

Introduction: The Limitation of "Load Average

The Interface: `/proc/pressure/`

Some" vs. "Full" Pressure

Interpreting CPU Pressure

Interpreting Memory Pressure

Interpreting I/O Pressure

PSI in cgroup v2

Introduction: The Precursor to eBPF

Architecture: The Translation Loop

Syntax: The `probe` Language

Tapsets: The Standard Library

Safety: The "Guru Mode

Introduction: The 4KB Problem

The TLB: Why Page Size Determines CPU Speed

Transparent HugePages (THP)

Explicit HugePages (HugeTLB)

Calculating the Right `vm.nr_hugepages` Value

Configuring Postgres for HugePages

Configuring Java (JVM) for HugePages

One Gigabyte Pages (1GB HugePages)