Raj's Notes

Low-level infrastructure

Linux boundaries, scheduling, memory, I/O, networking, containers, debugging, virtual machines, and assigned devices.

Scope#

What sits below an application process: the Linux kernel, CPU scheduling, memory, storage, networking, containers, debugging, and virtual machines. The sequence starts with ordinary process behavior, defines each hardware or kernel term when it first matters, then follows failures through the same layers.

Reading path#

  1. The kernel boundary separates programs, processes, threads, system calls, descriptors, credentials, and kernel policy.
  2. CPU scheduling and locality follows a runnable task onto a CPU and then to cache and NUMA-resident data. Its final concurrency sections are optional.
  3. Virtual memory explains the address translation and page-fault path previewed by LL2, then follows allocation, reclaim, and memory pressure.
  4. Linux storage and I/O follows bytes through filesystems, the page cache, block devices, durability barriers, and asynchronous I/O.
  5. Linux networking follows a socket through DNS, routing, TCP, namespaces, Netfilter, and optional eBPF hooks.
  6. Containers and cgroups assembles the earlier process, filesystem, network, and resource controls into a container runtime path.
  7. Observing and debugging a Linux workload is the synthesis checkpoint for LL1–LL6. It turns process identity, clocks, counters, profiles, traces, pressure, and crash state into one diagnostic method.
  8. KVM, QEMU, and virtio starts the advanced virtualization track by adding a guest kernel, second-stage memory translation, and virtual devices.
  9. MicroVMs and Kata compares smaller VMMs and follows Kata's container-to-guest path after the general VM model is established.
  10. Devices and nested virtualization contains two independent capstones: direct device and GPU assignment, then an L1 hypervisor running an L2 guest. Either half can be read first after LL8.

Cloud notes can be read before this collection because they define their service-level contracts locally. Use this collection as the under-the-hood path: LL5 deepens cloud networking, LL4 deepens cloud storage, LL6 deepens Kubernetes resource enforcement, and LL7 deepens observability and incident diagnosis.

Useful background#

Notes

  1. The kernel boundary Build a usable map of user space, syscalls, processes, file descriptors, and the privilege checks that sit beneath every service.
  2. CPU scheduling, caches, and lock-free code Connect CPU topology, run queues, power states, caches, NUMA, and memory ordering to the progress of runnable code.
  3. Virtual memory and page faults Trace an address through page tables and the page cache, then decide when huge pages or user-space fault handling solve a real problem.
  4. Linux storage and I/O Separate block devices, filesystems, caches, and completion APIs so storage latency stops looking like one opaque number.
  5. Linux networking, Netfilter, and eBPF Walk a packet through namespaces, virtual links, routing, connection tracking, filtering, and application-layer proxies.
  6. Containers and cgroups Assemble a Linux container from namespaces, cgroups, filesystems, credentials, and an OCI runtime contract.
  7. Observing and debugging a Linux workload Turn a service symptom into a bounded Linux experiment using stable identity, counters, profiles, traces, pressure data, and crash evidence.
  8. KVM, QEMU, hypercalls, and virtio Separate the kernel virtualization API, virtual machine monitor, guest kernel, and device path behind a Linux virtual machine.
  9. Firecracker, Cloud Hypervisor, and Kata Compare a general virtual machine, a reduced cloud VMM, and a container runtime backed by a guest kernel.
  10. PCIe assignment, GPUs, and nested virtualization Follow DMA through an IOMMU, compare GPU-sharing boundaries, and reason about a guest hypervisor running another guest.