At the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit, Brendan Jackman originally planned to present a session on a pagetable library for the kernel. However, during the actual memory-management track, he acknowledged that the idea had fizzled out and instead chose to cover related topics. The resulting discussion focused on efficiently managing memory pages that are not mapped in the kernel's direct map—a critical area for performance and stability in modern Linux systems. Below, we explore the key questions and insights from that session.
What is the kernel's direct map, and why are some pages excluded from it?
The kernel's direct map is a large virtual address range that maps physical memory linearly, allowing the kernel to access any physical page quickly. However, not all pages can be included in this map. Pages used for certain purposes—like those belonging to devices with non-cacheable memory, or pages requiring special caching attributes—must be handled outside the direct map. Additionally, to reduce memory waste and improve TLB efficiency, the kernel may choose to leave some regions unmapped. Excluded pages include those allocated for I/O, persistent memory, and some dynamic kernel allocations. Managing these pages efficiently requires bespoke mechanisms to avoid performance bottlenecks and ensure correct caching behavior.
What challenges does managing pages outside the direct map present?
When a page is not in the direct map, the kernel cannot access it using simple virtual-to-physical translations. Instead, developers must create temporary mappings, which adds overhead and complexity. Common challenges include increased TLB pressure, because temporary mappings consume limited TLB entries; risk of cache coherency issues, especially on non-uniform memory access (NUMA) systems; and the need for careful synchronization to prevent mapping conflicts. Moreover, debugging such code becomes harder because these pages are not easily inspected via standard tools. The session highlighted that as systems grow larger and more heterogeneous, these problems become more pronounced, calling for a systematic approach to manage these special pages efficiently.
How did Brendan Jackman's session evolve from a pagetable library to managing pages outside the direct map?
Originally, Jackman proposed a session on creating a comprehensive pagetable library to centralize page-table manipulation in the kernel. However, during the summit, he revealed that the idea had fizzled—partly due to the complexity of designing a unified library that wouldn't harm performance. In its place, he pivoted to a more focused problem: the management of pages not covered by the direct map. This shift allowed him to address a tangible pain point affecting real-world workloads, such as persistent memory and device memory. The session thus became a deep dive into the strategies and trade-offs for handling these special pages, drawing interest from developers working on memory management and hardware enablement.
What methods were discussed for efficiently handling pages outside the direct map?
Several approaches were considered during the session. One proposed method is to use a dedicated address space for temporary mappings, limiting the overhead by batching mapping operations. Another is to extend the existing vmalloc mechanism to support non-mappable pages with optimal alignment. Participants also discussed using huge pages to reduce TLB misses when accessing these regions, and employing per-CPU caches of pre-allocated page table entries. A key takeaway was that no single solution fits all—best practices depend on the nature of the memory (e.g., persistent vs. device) and the access pattern. The session emphasized the need for a library of helper functions to abstract common operations, thereby reducing code duplication and potential errors across subsystems.
How does this topic affect overall Linux memory management performance?
Pages outside the direct map are often performance-critical—they include memory-mapped I/O, DMA buffers, and persistent storage regions. Inefficient management can lead to significant slowdowns due to excessive page table modifications, TLB flushes, and cache misses. As Linux scales to larger memory sizes and more diverse hardware, the overhead of handling these pages grows. The session highlighted that optimizing this aspect can yield noticeable improvements in throughput for data-intensive applications, especially those using persistent memory or accelerators. By developing better primitives, the kernel can reduce latency and increase consistency, making the system more predictable for latency-sensitive workloads.
What future directions were identified for managing these special pages?
The session concluded with several ideas for future work. One is to standardize a kernel API for temporary mapping that balances flexibility with performance. Another is to investigate hardware support for direct-mapped temporary regions, possibly using new CPU instructions. Participants also expressed interest in automated tools to detect suboptimal use of non-direct-map pages. Longer-term, there is a desire to integrate these techniques into a more general framework that could be used across different architectures. Jackman noted that collaboration with the BPF community might yield insights, as eBPF programs sometimes need to access special memory regions. Overall, the session set a clear agenda for the memory-management community: improve the efficiency and maintainability of code dealing with pages outside the direct map.