Episodes
How Linux Cgroups Solve Server Cost Chaos
Cloud bills are spiraling because teams treat server resources like an open bar. This episode dissects how Linux Control Groups, or cgroups, turn that chaos into precise budgeting. We look at the mechanics of CPU shares and memory limits using a real-world e-commerce platform case where isolating traffic spikes saved tens of thousands monthly. Lucas and Luna break down the difference between hard caps and soft limits, showing why your microservices architecture is likely leaking money due to…
How Linux Kernel Page Cache Cuts Cloud Bills
Most cloud cost-cutting guides focus on instance sizing or reserved capacity. But the real savings often hide in the Linux kernel's page cache, where redundant disk reads inflate I/O costs and latency. This episode examines how the page cache acts as a memory-backed buffer for block devices, effectively turning slow storage into fast RAM-like access. We look at specific tuning parameters like dirty ratio limits and writeback behavior that determine when data is flushed to disk. By understanding…
How Linux Filesystems Manage Disk I/O Efficiency
In this episode, we drill into the specific mechanics of how Linux handles disk input and output through its filesystem layer. Lucas breaks down the role of the VFS in abstracting storage devices, while Luna explores how modern journaling filesystems like ext4 and Btrfs handle write operations to prevent data corruption during power failures. We look at a concrete example of how mount options affect performance and why understanding block layer interactions matters for server reliability. This…
How Linux Cgroups Control Server Costs
In this episode, Lucas and Luna break down the often-overlooked economics of Linux resource management. They explore how CPU shares and memory limits in cgroups directly impact cloud infrastructure bills, using a specific case study of a misconfigured web server that bled resources during peak traffic. The discussion covers practical strategies for setting realistic quotas, avoiding OOM kills, and aligning technical configurations with financial accountability. Listeners will learn one concrete…
How Linux Cgroups Control Server Costs
We drill into how Linux cgroup v2 transforms cloud spending by isolating resource pressure. Using a specific case study of a runaway database query, we show how hierarchical CPU shares and memory limits prevent one noisy tenant from crashing the entire host. This is practical infrastructure economics for sysadmins and finance leaders who need to predict true server costs. #FexingoBusiness #BusinessPodcast #LinuxSysAdmin #CloudCosts #CgroupV2 #ServerStack #TechEconomics #ResourceIsolation…
How Linux Kernel BPF Transformed Network Performance
We dig into eBPF, the technology that lets you run sandboxed programs in the kernel without changing source code or loading modules. Lucas and Luna break down how companies like Cloudflare use eBPF to drop millions of malicious packets before they hit application logic, cutting latency and CPU costs. This isn't just about security; it's about observability and traffic management at line speed. We look at the specific mechanics of attaching probes to network stack hooks and why this has replaced…
Linux Kernel Cgroup V2 Hierarchical CPU Shares
On today’s episode, we drill into how Linux cgroup v2 hierarchical CPU shares actually work in production. Lucas and Luna break down the specific mechanics of fair scheduling when you have mixed workloads—like a database and a web server—competing for cores on the same node. We look at why the old cgroup v1 hierarchy broke under load and how the new unified controller solves it with simple weight ratios. If you are managing server costs or optimizing container orchestration, understanding this…
How Linux Cgroups Control Server Costs
We break down how Linux cgroup v2 lets teams enforce strict CPU and memory limits on individual containers. Using a specific example from a mid-sized SaaS provider, we show how this kernel feature prevents noisy neighbors from crashing production systems while keeping cloud bills predictable. This is practical infrastructure management for engineers who are tired of surprise overages. #LinuxKernel #CgroupV2 #CloudCostOptimization #ServerManagement #Containerization #TechInfrastructure…
How Linux Kernel Live Patching Keeps Servers Running
Lucas and Luna explore the mechanics of live patching in the Linux kernel, a technique that allows security updates to be applied without rebooting production servers. They break down how kpatch and kgraft work, the role of function graph hooks, and why this capability is critical for high-availability infrastructure. With specific examples from Red Hat and Canonical, they discuss the technical trade-offs between memory overhead and uptime, offering sysadmins a clear view of how modern…
How Linux Cgroups Manage Server Costs
We examine how Linux control groups, or cgroups, transform abstract resource limits into tangible financial savings for cloud infrastructure. Using a specific case of a containerized web service that reduced its monthly bill by twenty-two percent after implementing strict memory and CPU quotas, we explore the mechanics of cgroup v2. Lucas breaks down the configuration files while Luna challenges the common misconception that hardware upgrades always solve performance bottlenecks. This episode…
How Linux Kernel BPF Transforms Network Security
We look at how eBPF has moved from a niche debugging tool to the backbone of modern cloud networking, using Cilium and Envoy as primary examples. With over two hundred thousand contributors now interacting with the kernel through this interface, we examine why enterprises are rewriting their security policies in userspace rather than waiting for kernel updates. This shift allows for near-zero-latency packet inspection, fundamentally changing how companies like Google and Netflix handle traffic…
How Linux Containers Solve the Dependency Nightmare
Most developers treat containerization as a deployment tool, but the real value lies in dependency isolation. We explore how modern distroless images and build-time pinning eliminate the 'it works on my machine' problem. Using Ubuntu Jammy and Alpine as case studies, we break down why stripping away unnecessary libraries reduces attack surfaces by up to sixty percent. This is a deep dive into the operational reality of shipping reliable software stacks. #LinuxContainers #DockerImages…
Linux Kernel Watchdog: How OOM Killer Saves Systems
We dig into the Linux Out-Of-Memory killer, the kernel feature that makes hard decisions when RAM runs dry. Lucas and Luna break down how the OOM score works, why it sometimes targets the wrong process, and what system administrators can do to protect critical databases from premature termination. We look at specific tuning parameters like oom_score_adj and real-world scenarios where letting a service crash is better than freezing the entire server. #LinuxKernel #OOMKiller #SystemAdministration…
How Linux Kernel Lockdown Hardens Enterprise Security
We examine the practical implications of Linux kernel lockdown mode for enterprise security. With modern deployments increasingly reliant on immutable infrastructure, understanding how this feature restricts user-space access to kernel memory and device files is critical. We break down the three levels of lockdown, analyze why organizations like Red Hat enable it by default in Fedora Server, and discuss the trade-offs between strict security controls and legitimate administrative tasks like…
Linux Kernel Cgroup v2 Memory Pressure Explained
We break down how Linux cgroup v2 memory pressure controls work in practice, using a real-world scenario where a misconfigured container triggers throttling before OOM kills. Lucas and Luna explore the difference between soft limits and hard limits, why reclaim paths matter for latency-sensitive apps, and how to read memory.stat to catch issues early. This episode covers concrete metrics, kernel behavior under load, and practical debugging steps for DevOps engineers managing server stacks in…
How Linux Kernel Selftests Prevent Broken Deployments
We explore the often-overlooked world of Linux kernel selftests, specifically focusing on how tools like Kselftest and LTP prevent regressions in modern server stacks. With the September 2026 release cycle bringing significant changes to memory management and networking subsystems, understanding these automated checks is crucial for sysadmins and developers who rely on stability over bleeding-edge features. We break down a specific case where a subtle change in page reclaim logic was caught by…
Linux Kernel Live Patching in Production
We examine how Linux kernel live patching actually works in high-uptime environments, using Canonical’s Ksplice and Red Hat’s kpatch as primary case studies. Lucas breaks down the technical mechanism of hot-patching memory while processes run, and Luna questions the security trade-offs of injecting code into a running kernel. We look at real-world deployment stats from Fortune 500 infrastructure teams who rely on this to avoid maintenance windows. The episode covers the limitations of what can…
How Linux Kernel Live Patching Keeps Servers Running
We dive into kpatch and kGraft, the technologies that let system administrators apply critical security fixes to a running Linux kernel without a single reboot. In an era where uptime is currency and maintenance windows are vanishing, understanding how live patching works—by hot-swapping compiled code in memory—is essential for modern infrastructure teams. We explore the mechanics of function graph trampoline, the safety checks involved, and why this capability has become a standard expectation…
Linux Kernel Security Through Lockdown Mode
We explore how the Linux kernel's lockdown feature protects system integrity against root-level attacks. Lucas and Luna break down the three security levels, the role of Secure Boot in enabling this protection, and why modern enterprise servers should have it enabled by default. We look at real-world implications for sysadmins, the trade-offs with debugging tools, and how this simple toggle has become a critical line of defense in today's threat landscape. This episode focuses on practical…
How Linux BPF Iterators Make Kernel Data Accessible
In this episode of The Linux Podcast with Fexingo, Lucas and Luna explore how Linux BPF iterators simplify kernel data access. They trace a concrete example: using BPF iterators to dump all open files across the system, something that traditionally required writing kernel modules or parsing procfs. The conversation covers how iterators differ from classic BPF programs, the role of the iterator context, and why they matter for observability and security tooling. They also discuss the performance…
How Linux Namespaces Isolate Processes Beyond Containers
In episode 170 of The Linux Podcast, Lucas and Luna drill into Linux namespaces — the kernel feature that underpins containers but also powering systemd services, user sessions, and even Flatpak apps. They walk through the seven main namespace types, from mount to user namespaces, and explain how a single process can be isolated without a container runtime. With a concrete example of running a shell in its own namespace, they show how this technology shapes everything from security to systemd…
How Linux SLUB Allocator Reduces Memory Fragmentation
In this episode, Lucas and Luna dive into the SLUB allocator, the default memory allocator in the Linux kernel since 2.6.23. They explain how SLUB reduces fragmentation compared to its predecessor SLAB, using the concept of per-CPU partial lists and object caching. With a concrete example of a web server handling many small requests, they show how SLUB's design keeps memory allocation fast and efficient, reducing overhead and improving system stability. They also discuss real-world tuning…
How Linux Swap Space Evolved Into Modern Memory Management
Lucas and Luna explore the unsung journey of Linux swap space from its early days as a simple disk extension to today's sophisticated memory management tool. They dig into the mechanics of swap, how the kernel decides what to swap out, and why modern systems like zram and zswap are changing the game for laptops and servers alike. With concrete examples from a typical desktop to a busy web server, they explain when swap is your friend and when it's a performance trap. By the end, you'll…
How Linux BPF Ring Buffers Deliver High-Throughput Data
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the BPF ring buffer, a high-performance data structure introduced in Linux kernel 5.8 that lets eBPF programs pass events to user space with minimal overhead. They explain how it works, why it beats the old perf buffer under heavy load, and where it matters — from real-time monitoring to packet capture. Using examples like a network observability tool that drops zero events during a 10 Gbps traffic spike, they compare…
How Linux BPF Iterators Make Kernel Data Accessible
Lucas and Luna explore BPF iterators, the Linux kernel feature that lets you traverse kernel data structures safely from user space. They unpack how iterators differ from traditional BPF programs, why they were introduced, and how tools like bpftool use them to expose everything from task lists to TCP sockets. With a concrete example of dumping open files per process, they show how BPF iterators turn kernel internals into readable streams without dangerous module hacks. The episode also touches…
How Linux Kernel Samepage Merging Cuts Memory Waste in Containers
In this episode, Lucas and Luna dig into Linux Kernel Samepage Merging (KSM) — the memory-saving technique that deduplicates identical pages across processes and containers. With KSM, a host running hundreds of duplicate container images can cut memory usage dramatically, letting you pack more workloads onto fewer servers. But KSM isn't a free lunch: it adds CPU overhead and can introduce security risks if not configured carefully. Lucas walks through how KSM works, from the kernel's…
How Linux Memory Hotplug Adds RAM While Running
Memory hotplug lets you add or remove RAM from a running Linux system without a reboot. It’s a niche but powerful capability used in cloud fleets, big databases, and high-availability setups. Lucas and Luna dig into the mechanism — from sysfs entries to the kernel’s memory block layer — and walk through a real-world example of resizing a VM’s memory on the fly. They also touch on the risks, the hardware requirements, and why most desktop users will never need it. If you’ve ever wondered how…
How Linux Perf Traces Performance Without Heavy Overhead
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into the Linux 'perf' tool, the built-in profiler that many sysadmins overlook. They explore how perf uses hardware counters and kernel tracepoints to pinpoint CPU bottlenecks, cache misses, and syscall stalls with minimal overhead. The conversation centers on a real-world scenario: a web server experiencing mysterious latency spikes. Lucas explains how to read a 'perf top' output, while Luna shares a tip about using 'perf…
How Linux Btrfs Snapshots Save Your Data
In this episode, Lucas and Luna dive into Btrfs snapshots, a feature that lets you roll back your system or files in seconds. They explain the copy-on-write magic behind snapshots, how to create and manage them with btrfs subvolume snapshot, and why they're a game-changer for home labs and production servers alike. Using the example of a botched system update that nearly wrecked a server, they show how a simple snapshot can be a lifesaver. They also cover snapshot management — automating them…
How Linux Kernel Memory Reclaim Keeps Servers Stable
In Episode 161, Lucas and Luna dive into Linux kernel memory reclaim — the behind-the-scenes mechanism that keeps servers from falling over when memory runs out. They explore how the kernel's reclaim algorithms decide which pages to evict, the role of cgroups and memory limits, and why tuning swappiness and vfs_cache_pressure matters for real-world workloads. Using a concrete example of a busy web server under memory pressure, they explain the difference between anonymous and file-backed pages…
How Linux F2FS Optimises Flash Storage for Modern Devices
In this episode, Lucas and Luna explore F2FS, the flash-friendly file system designed by Samsung for NAND storage. They explain why traditional file systems like ext4 struggle with SSDs, how F2FS uses a log-structured design to reduce write amplification, and the role of multi-head logging and adaptive algorithms in improving performance and longevity. They also discuss real-world adoption, from Android smartphones to enterprise SSDs, and weigh the trade-offs of using F2FS for your own…
How Linux Kernel Samepage Merging Reduces Memory Waste
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dig into Kernel Samepage Merging (KSM) — the Linux kernel feature that deduplicates identical memory pages across processes. They explain how KSM works, why it matters for virtualization and container workloads, and where it can actually hurt performance. Using the classic example of multiple virtual machines running the same guest OS, they break down the trade-offs between memory savings and CPU overhead. They also touch on…
How Linux io_uring and eBPF Transform Network Performance
In episode 158 of The Linux Podcast with Fexingo, Lucas and Luna dig into the real-world impact of combining io_uring with eBPF for high-speed networking. They unpack how these two kernel technologies work together to slash latency and boost throughput, using the example of a hypothetical CDN edge server handling millions of requests. The conversation covers the mechanics of both systems, the challenges of integration, and practical advice for developers looking to experiment. They also touch…
How Linux eBPF Observes Every Packet in Real Time
Lucas and Luna dive into eBPF, the kernel technology that lets you trace network packets and system calls without adding any overhead. They start with a concrete example: using bpftrace to answer a question that would normally take hours of digging through tcpdump logs. Along the way, they explain what eBPF is, why it's a game-changer for observability, how it compares to older tools like tcpdump and strace, and why the Linux kernel can run these programs safely. They also touch on how…
How Linux io_uring and XDP Combine for High-Speed Networking
Episode 156 of Fexingo's Linux podcast dives into the rare but powerful pairing of io_uring and XDP for high-speed networking. Lucas and Luna explain how io_uring's asynchronous I/O model meets eXpress Data Path's early packet processing, cutting latency and CPU overhead in demanding server workloads. They use a concrete example from a typical cloud gateway, walk through the mechanics of both technologies, and discuss where the combination shines—and where it doesn't. If you've wondered how…
How Linux Bcache Caches Block Devices for Speed
Episode 155 of The Linux Podcast dives into Bcache, the Linux kernel block-layer caching that lets you put a fast SSD in front of slow spinning disks. Lucas and Luna walk through how Bcache works at the block level, why it's different from filesystem-level caching, and where it shines—like speeding up database storage or home lab NAS builds without ripping out existing drives. They break down the key concepts: caching modes (writeback, writethrough, writearound), the bucket and priority cache…
How Linux Control Groups Handle Thousands of Containers
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dig into the inner workings of Linux Control Groups, or cgroups, and how they keep modern containerized systems stable. Using a real-world example of a platform running ten thousand containers on a single host, they explain how cgroups manage CPU, memory, and I/O resources to prevent one runaway process from taking down the whole system. They walk through the difference between cgroups version one and version two, and why version…
How Linux Control Groups Manage Container Resources
In this episode, Lucas and Luna dive into cgroups v2, the kernel feature that underpins container resource management. They explain how cgroups limit CPU, memory, and I/O for individual processes, and how systemd integrates with cgroups to manage services. The conversation covers the shift from cgroups v1 to v2, the role of cgroups in container runtimes like Docker and Kubernetes, and a practical example of setting memory limits. They also touch on why cgroups matter for security and…
How Linux User Mode Helps You Build a Home Lab
In this episode, Lucas and Luna explore User Mode Linux (UML), a technology that lets you run Linux as a regular user-space process on an existing Linux host. They explain how UML differs from containers and virtual machines, dive into its performance trade-offs, and share practical use cases like kernel development, security testing, and teaching. They also discuss the recent revival of UML in the context of modern kernel development and why it remains relevant in 2026. If you've ever wanted…
How Linux FUSE Lets User Space Build File Systems
In this episode of The Linux Podcast, Lucas and Luna explore how FUSE (Filesystem in Userspace) lets ordinary programs implement file systems without touching kernel code. They trace the journey of an SSHFS mount, showing how a read request travels from the virtual file system layer through the kernel's FUSE module and into a user-space daemon, then back again. They discuss the performance overhead of passing data through /dev/fuse, the role of the kernel's page cache in mitigating that cost…
How Linux Kernel Samepage Merging Reduces Memory Waste
In this episode of The Linux Podcast, Lucas and Luna dive into Kernel Samepage Merging (KSM), a memory-saving feature that deduplicates identical pages across processes. They explore how KSM works, why it's a game-changer for virtualized environments like QEMU/KVM, and how it can significantly cut memory costs in cloud data centers. Using the example of a large-scale deployment running hundreds of identical VMs, they walk through the mechanics of KSM's scan and merge process, the trade-offs in…
How Linux io_uring Powers High-Performance Databases
In this episode, Lucas and Luna explore io_uring's role in modern database performance, focusing on how PostgreSQL and MySQL benefit from asynchronous I/O. They break down the syscall overhead problem, the role of SQEs and CQEs, and real-world results from benchmarks on NVMe storage. They also discuss the trade-offs of using io_uring with native AIO, and how it integrates with popular database engines. By the end, you'll understand why io_uring is a game-changer for high-throughput workloads…
How Linux Landlock Restricts Apps Without Root
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into Landlock, the Linux security module that lets unprivileged processes sandbox themselves. They explain how Landlock differs from traditional access control and container isolation, using a practical example of running a browser or a server with restricted filesystem access. They discuss the origins of the project, its current status in the kernel, and how it complements other security features like seccomp and…
How Systemd Automounts Lazy-Mount Network Filesystems
Lucas and Luna dig into systemd's automount units, explaining how Linux can defer mounting network filesystems until they're actually accessed. They walk through a real-world scenario: a large NFS share on a laptop that only mounts when you open the directory, saving boot time and battery. The episode covers the underlying autofs mechanism, the systemd .mount and .automount unit pairing, how systemd's automount differs from traditional autofs, and how it handles network filesystem failures…
How Linux User Namespaces Restrict Container Privileges
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive into user namespaces, the Linux kernel feature that gives containers their security backbone. They explain how user namespaces let unprivileged users run containers safely by mapping container root to a regular user on the host, and why this feature is central to modern container security. The conversation covers the mechanics of uid and gid mapping, the security implications of nested user namespaces, and recent kernel…
How Linux Systemd Journald Replaces Traditional Logging
In episode 145 of The Linux Podcast, Lucas and Luna dive into systemd-journald, the logging system that's quietly replaced syslog on most modern Linux distributions. They explain why journald's structured, binary log format is a game-changer for troubleshooting—no more grepping through plain-text files. Lucas breaks down how journald uses the kernel's audit subsystem to capture metadata like PID, UID, and timestamps automatically, and why that makes debugging faster and more secure. They also…
How Linux io_uring Speeds Up Storage and Networking
In this episode, Lucas and Luna unpack the recent io_uring improvements that are reshaping how Linux handles storage and networking I/O. They open with a specific benchmark from a cloud provider that shows a 40 percent drop in latency for database workloads after switching from the classic syscall path to io_uring. They walk through what io_uring actually is — a submission queue and completion queue that let applications submit hundreds of operations without a syscall per I/O — and explain why…
How Linux Control Groups Manage Container Resources
Lucas and Luna unpack the mechanics behind control groups, the kernel feature that keeps containers from hogging a host's CPU, memory, and I/O. With a focus on cgroup v2, they explain how the unified hierarchy simplifies resource management and why it matters for modern cloud-native workloads. The conversation covers real-world scenarios like noisy-neighbor problems in multi-tenant clusters and how cgroups help enforce fairness. Tune in to learn how a simple kernel concept underpins the…
How Linux Systemd Hardens Container Orchestration
In this episode, Lucas and Luna dive into systemd's role as the init system that also secures container workloads. They unpack the concept of cgroups v2, how socket activation reduces attack surface, and why systemd's service sandboxing options — like ProtectSystem, PrivateTmp, and NoNewPrivileges — are a practical way to lock down containers without adding another layer of complexity. They also pit systemd against the Docker daemon, not in a flame war, but in a grounded look at where each fits…
How Linux io_uring Accelerates Databases and File Systems
In this episode of The Linux Podcast with Fexingo, Lucas and Luna dive deep into io_uring, the asynchronous I/O interface that's reshaping how Linux handles storage and network operations. They explore a concrete example: how a PostgreSQL database can cut query latency by 30% using io_uring's submission queue and completion queue, reducing syscall overhead and enabling true async I/O. The conversation covers the mechanics — from ring buffers to registered files — and the real-world impact on…
Showing the latest 50 episodes. The full archive of 190 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.