Efficient Management of Non-Direct-Mapped Pages: Insights from the 2026 Linux Storage Summit

Introduction

The 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit brought together kernel developers to tackle some of the most pressing challenges in system memory management. Among the sessions, one originally proposed as a deep dive into a pagetable library for the kernel took an unexpected turn. Presenter Brendan Jackman announced that the initial concept had "fizzled" — but the alternative discussion that emerged proved just as critical: how to efficiently manage pages that reside outside the kernel's direct map. This article explores the motivations, challenges, and potential approaches highlighted during that session.

Understanding the Direct Map

The kernel's direct map is a contiguous virtual address region that maps most of physical memory. It provides a simple, linear translation: physical address X corresponds to virtual address X + offset. This mapping is essential for many kernel operations, such as page allocation, I/O, and interrupt handling. However, not all memory pages fit neatly into this direct map. Pages used by device drivers, special hardware, or certain memory types (e.g., non-volatile memory, GPU memory) often require separate, non-contiguous mappings. These are the non-direct-mapped pages that Brendan Jackman's session addressed.

Why Non-Direct-Mapped Pages Are a Challenge

When a page is not part of the direct map, the kernel cannot access it using the standard linear address translation. This leads to performance overhead, increased TLB pressure, and complex memory management code. The session outlined several real‑world scenarios where this becomes problematic:

• Device‑memory mappings – Many hardware accelerators (GPUs, FPGAs, AI chips) have their own dedicated memory that must be mapped into kernel space temporarily.
• Memory‑hotplug regions – Dynamically added or removed memory may create gaps in the direct map.
• Large‑page configurations – Huge pages (e.g., 1 GiB) sometimes cannot be fully represented in the direct map due to alignment constraints.

In each case, the kernel must resort to vmalloc or other non‑linear mappings, which incur extra costs during page table walks.

The Shift from a Pagetable Library to Practical Solutions

Brendan Jackman had originally proposed a generic pagetable library that would unify how the kernel creates and manages page tables across architectures. This idea, while elegant, faced significant architectural, performance, and maintenance hurdles. As he noted in the session, the library concept "fizzled" because of the difficulty of abstracting over the large number of memory management units (MMUs) in use today.

Instead, the discussion pivoted to more pragmatic approaches for handling pages outside the direct map. Three main strategies were debated:

1. Improving the Existing Vmalloc Infrastructure

The kernel already provides vmalloc as a way to allocate non‑contiguous virtual memory, but it is often too slow for high‑frequency operations. Ideas included:

• Pre‑allocating shadow page tables for common non‑direct‑mapped regions to reduce TLB misses.
• Introducing a lazy remapping mechanism that defers page modifications until necessary.

2. Extending the Direct Map with Sparse Segments

Rather than abandoning the direct map, some participants suggested using sparse segments or a second direct map for specific address ranges, such as device memory. This would keep the simplicity of linear mapping while covering more of the physical address space.

3. Hardware‑Assisted Translations

Modern CPU features like IOMMU and nested page tables (used in virtualization) could be leveraged to offload some of the mapping work. For example, an IOMMU can translate device‑side addresses without polluting the kernel's own page tables.

Key Takeaways and Future Directions

The session ended with a consensus that no single solution fits all cases. The kernel will likely need a hybrid approach: improving vmalloc for dynamic mappings, adding limited direct‑map expansion for predictable regions, and utilizing hardware features where available. Brendan Jackman emphasized that understanding the direct map's limitations is the critical first step.

Looking ahead, the community plans to explore a lightweight page‑table cache for frequently accessed non‑direct‑mapped pages, and to revisit the pagetable library concept only after the simpler solutions are evaluated. The full recording and slides from the 2026 Summit are available for those who want to dive deeper into the technical details.

Conclusion

While the original proposal for a pagetable library did not materialize, the discussion on managing pages outside the kernel's direct map proved equally valuable. It highlighted the real‑world performance bottlenecks and sparked a collaborative effort to find incremental, practical improvements. For kernel developers and system architects, these insights are essential for building faster and more efficient memory management in Linux.