At the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit, Pratyush Yadav led a session exploring how to preserve hugetlbfs-provided memory during the live update process. Live updates, powered by kexec handover and an orchestrator, allow a running kernel to be replaced without full reboot—but large pages allocated via hugetlbfs (HugeTLB) can be lost during the handover, hurting performance. This Q&A breaks down the challenges, proposed solutions, and current progress discussed in that session.
What is HugeTLB memory and why does it matter for live updates?
HugeTLB (or hugetlbfs) provides large memory pages (e.g., 2MB or 1GB) to reduce TLB misses and improve performance for memory‑intensive workloads like databases or virtual machines. When a live update swaps the running kernel via kexec, the new kernel typically reloads its page tables and memory metadata. Without special handling, HugeTLB pages allocated by the old kernel can be freed and must be reallocated—a slow, disruptive process. Preserving them avoids this overhead, ensuring minimal service interruption and maintaining application performance during the update.
Why is preserving HugeTLB memory during live update challenging?
The core difficulty is that the new kernel starts with a fresh view of physical memory. It knows nothing about the old kernel’s HugeTLB pool or which pages were allocated to which processes. Simply retaining the physical pages is not enough: the new kernel must rebuild the metadata (e.g., the hugetlbfs inode and page descriptors) and ensure that the virtual-to-physical mappings remain consistent. Moreover, the kexec handover is often designed to be quick and simple, so adding complex preservation logic can increase the risk of bugs or security issues if memory regions are not properly reclaimed.
What approach did Pratyush Yadav propose for preserving HugeTLB memory?
Yadav’s solution involves sharing a memory map between the old and new kernels via a reserved region that survives the handover. This map describes all HugeTLB pages, their allocation status, and the corresponding process information. The new kernel reads this map early in boot, validates it, and then uses the data to reconstruct the hugetlbfs state without freeing the pages. Special care is taken to handle partially allocated pools and to ensure that any pages still in use are remapped correctly. The proposal also includes a cleanup mechanism to release memory from processes that no longer exist after the update.
What were the main concerns or objections raised during the session?
Several developers worried about security and complexity: the shared memory map could be a vector for information leaks if not properly sanitized. Others questioned whether the performance benefit justifies the maintenance burden—many workloads already survive live update without HugeTLB preservation by simply letting the new kernel reclaim and reallocate pages. There was also debate about portability: the approach relies on internal kernel structures that differ across architectures and kernel versions. Ensuring forward compatibility would require careful versioning and validation code.
What is the current status of this work and what are the next steps?
As of the 2026 summit, Yadav’s proposal is still in the design phase. A prototype exists for x86_64, but it has not been submitted for review. The next steps include: (1) writing a formal patch set with documentation, (2) addressing security by adding integrity checks and clearing sensitive data from the shared map, and (3) testing on other architectures like ARM64. The community expressed interest but emphasized that the solution must be opt‑in and configurable, so that users who do not need HugeTLB preservation can avoid the added complexity.
How does this compare to existing live update mechanisms like kpatch and livepatch?
Kpatch and livepatch work at the function level: they replace individual kernel functions without a full kernel restart. They do not affect memory management; HugeTLB pages remain untouched because the kernel instance never changes. In contrast, kexec‑based live update replaces the entire kernel image, which is why preservation becomes an issue. Yadav’s work targets the kexec path, aiming to make it as seamless as live patching for scenarios that require a full kernel upgrade (e.g., major version changes or hardware enablement).
What are the potential benefits for users who enable HugeTLB preservation?
For users running latency‑sensitive or high‑throughput applications that rely on HugeTLB (e.g., large‑scale databases, HPC, or virtualized environments), preserving these pages means zero‑downtime updates without the performance penalty of rebuilding huge pages. It also avoids the risk of memory fragmentation that can occur when a new kernel tries to satisfy large page requests from scratch. Ultimately, this brings live updating closer to the ideal of a fully transparent, non‑disruptive maintenance operation for the most demanding workloads.