The Linux Podcast with Fexingo: Open Source Operating Systems, Distros, and Server Stack

Lucas and Luna dive into Linux kernel 6.12's landmark change: the BPF-based scheduler (sched_ext) replacing the classic Completely Fair Scheduler. They unpack how BPF allows scheduling policies to be written as safe, loadable programs — enabling experiments like Google's scx_layered for latency-sensitive workloads, and Meta's scx_rustland in production. The episode explains why this matters for cl...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into Linux namespaces, the kernel feature that forms the backbone of container isolation. They explain how namespaces give each container its own view of the system—separate process trees, network stacks, mount points, and more—without the overhead of a full virtual machine. Lucas breaks down the seven namespace types (PID, net...

Most Linux security conversations focus on external attacks—firewalls, SELinux, AppArmor. But what about the threat already inside your network? Episode 102 of The Linux Podcast digs into auditd, the Linux Audit Framework that's been quietly logging every system call, file access, and privilege escalation since kernel 2.6. Lucas walks through a real-world scenario: a developer with legitimate sudo...

Lucas and Luna dive into the Linux Kernel Crypto API, the subsystem that offloads encryption, decryption, and hashing to hardware accelerators like Intel QAT, AMD CCP, and ARM CryptoCell. They unpack how the API abstracts vendor-specific drivers behind a unified interface, enabling applications like dm-crypt (LUKS disks), IPsec, and TLS termination in the kernel to transparently use hardware crypt...

In this 100th episode, Lucas and Luna explore Kernel Same-page Merging (KSM), a memory-saving feature in Linux that deduplicates identical memory pages across virtual machines and applications. They break down how KSM works under the hood—scanning pages, merging them into a single copy-on-write page, and managing the trade-offs with CPU overhead. The hosts discuss real-world use cases like running...

Luke and Luna crack open the system call layer to explain how tools like strace, seccomp, and Falco intercept kernel calls for debugging, security, and container sandboxing. Using real examples—from tracing a Python web server's reads and writes to how Docker uses seccomp profiles by default—they demystify the mechanism behind system call interposition. They also discuss performance tradeoffs and...

Lucas and Luna dive into netfilter, the kernel framework that powers Linux firewalls — from iptables to nftables. They walk through the five Netfilter hooks that intercept packets at key points in the network stack, explain how connection tracking reassembles flows, and explore why modern tools like nftables and eBPF are replacing legacy iptables. Along the way they break down a concrete example:...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into Kernel Same-page Merging (KSM) — a memory-saving technique that deduplicates identical pages across virtual machines and containers. They break down how KSM works, its performance trade-offs, and real-world use cases like large-scale server consolidation. Using concrete examples like a hosting provider running 200 VMs on a...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the evolution of Logical Volume Manager (LVM) in Linux, focusing on a specific concrete case: how LVM thin provisioning and snapshots are being used by a mid-size SaaS company to cut storage costs by 40% while maintaining production performance. They break down the difference between traditional partitions and logical volu...

In episode 95, Lucas and Luna explore the quiet but powerful evolution of Linux NFS (Network File System) from a 1980s file-sharing protocol into a modern cloud-native storage backbone. They focus on the recent NFSv4.2 specification and how features like server-side copy offload, sparse file awareness, and label-based access control are making NFS relevant again in containerized and multi-cloud en...

Episode 94 of The Linux Podcast with Fexingo dives into eBPF (extended Berkeley Packet Filter), the technology that lets you run sandboxed programs in the Linux kernel without modifying kernel source or loading risky modules. Lucas and Luna break down why eBPF is a game-changer for observability, security, and networking—using real-world examples like Cilium and Falco. They explain how the eBPF ve...

In this episode, Lucas and Luna dive into io_uring, the Linux kernel's revolutionary asynchronous I/O framework that's reshaping how databases, web servers, and storage systems handle high-throughput operations. They trace its origin from Jens Axboe's 2019 kernel patch, explain how it eliminates syscall overhead by using shared ring buffers between user and kernel space, and compare it to traditio...

When the Linux kernel panics, critical diagnostic data usually vanishes with the reboot. This episode digs into pstore — a little-known subsystem that preserves kernel crash logs, console output, and oops messages across power cycles by writing them to persistent storage like RAM, EFI, or AER. Lucas explains how pstore works under the hood, why it's a lifesaver for embedded systems and cloud serve...

Kernel Same-page Merging (KSM) is a Linux kernel feature that deduplicates identical memory pages across processes and virtual machines. In this episode, Lucas and Luna explore how KSM works under the hood, why it's critical for virtualized and containerized workloads, and where it falls short. They walk through a real-world example: a KVM host running 20 Ubuntu VMs that saved over 40 percent of R...

In episode 90 of The Linux Podcast, Lucas and Luna dive into systemd - the init system that has become the backbone of modern Linux distributions. They explore why systemd sparked the great Linux civil war, how it unifies service management, logging, and timers into one framework, and what systemd 256 brings with run0 and the new service manager. Specific numbers: nearly 70% of Linux servers now u...

In this episode, Lucas and Luna dive into Linux uprobes — user-space probes that let engineers trace application code at runtime without recompiling. They explore how uprobes work alongside kprobes, why companies like Netflix use them to debug latency in production microservices, and a concrete example using bpftrace to trace malloc calls in a containerized app. By the end, you'll understand why u...

Episode 88 of The Linux Podcast dives into Btrfs, the copy-on-write filesystem that's been a controversial part of the Linux kernel for over a decade. Lucas and Luna explore how Btrfs has quietly evolved from a risky experimental option into a mature, feature-rich choice for both desktops and servers. They discuss its native compression, snapshot capabilities, and self-healing via checksums, and c...

Episode 87 of The Linux Podcast explores Cilium, the open-source CNI plugin that uses eBPF to replace legacy kube-proxy and iptables-based networking. Lucas and Luna break down how Cilium attaches eBPF programs directly to the network interface to enforce security policies, load-balance service traffic, and provide observability without sidecars. They discuss a real-world migration at a mid-sized...

In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the overlay filesystem — the unsung hero behind Docker and container image layers. They break down how overlayfs merges multiple directories into a single view, enabling efficient copy-on-write, small image sizes, and instant container startup. Lucas explains the mechanics of lowerdir, upperdir, and mergerdir, using a conc...

Lucas and Luna dive into one of the most underappreciated yet critical subsystems in modern Linux: control groups, version 2. They explore how cgroupsv2 is being used by companies like Google and Meta to limit memory usage inside containers, preventing noisy-neighbor problems in multi-tenant environments. Lucas explains the difference between cgroupsv1 and v2, the role of the cgroup memory control...

Episode 84 of The Linux Podcast with Fexingo dives into ZRAM — the Linux kernel module that compresses memory pages in RAM itself, reducing swap disk I/O and boosting performance, especially on systems with limited memory. Lucas and Luna explore how ZRAM works, its trade-offs compared to traditional swap, and a real-world case: Google's Chrome OS, which has used ZRAM by default since 2013. They ex...

Lucas and Luna dive into Linux's most transformative networking technology: BPF (Berkeley Packet Filter). They explain how BPF allows custom programs to run inside the kernel safely, boosting network performance by 10x in some scenarios. The episode breaks down real-world use cases like DDoS mitigation at Cloudflare, packet filtering with XDP, and observability with Cilium. Lucas walks through the...

Lucas and Luna dive into Linux namespaces, the kernel feature that isolates processes and enables containers like Docker. They explore the eight namespace types, how they create separate views of the system, and why this matters for security and efficiency. With concrete examples from server deployments and a look at the recent Landlock LSM integration, this episode demystifies the core technology...

Episode 81 of The Linux Podcast with Fexingo dives into eXpress Data Path (XDP), a kernel technology that processes network packets before they reach the main network stack. Lucas and Luna walk through how XDP bypasses huge chunks of overhead by hooking into the network driver’s own receive ring, achieving up to 24 million packets per second on a single core. The conversation contrasts XDP with co...

Episode 80 of The Linux Podcast dives into how eBPF is revolutionizing network performance beyond just replacing kernel modules. Lucas and Luna explore a specific case: Cloudflare using eBPF to handle DDoS mitigation at line rate, processing millions of packets per second without touching userspace. They break down the BPF virtual machine, its verifier safety guarantees, and why companies like Net...