Efficiently Managing Pages Outside the Kernel's Direct Map: Insights from the 2026 LSMM Summit

At the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit (LSMM), developer Brendan Jackman originally proposed a session titled "a pagetable library for the kernel." However, during the actual memory-management track, he noted that the idea had "fizzled" and shifted focus to related challenges. Instead, the session explored techniques for efficiently handling memory pages that lie outside the kernel's direct mapping region—a critical area for performance and scalability. Below, we dive into the key questions and answers from that discussion.

What was Brendan Jackman's original proposal for the 2026 LSMM Summit?

Jackman's initial concept was to create a dedicated pagetable library within the Linux kernel. This library would provide a standardized, reusable abstraction for manipulating page tables—structures that map virtual addresses to physical memory. The goal was to simplify kernel code that needs to modify page tables, reducing duplication and potential bugs. However, as he prepared the session, Jackman realized that the library idea had not gained enough traction or community consensus to proceed. Instead of abandoning the topic entirely, he pivoted to a set of closely related issues that were more pressing for the kernel's memory management subsystem.

Why did Jackman's original idea "fizzle" and what did he cover instead?

Jackman stated that the pagetable library proposal had "fizzled" primarily due to lack of sustained interest and the complexity of designing a unified API that could serve all kernel subsystems. Rather than pushing an incomplete solution, he chose to address specific pain points that arise when page tables must be updated for pages not in the kernel's direct map. This direct map is a large, contiguous virtual address region that maps most of physical memory with a simple linear offset. Pages outside this region—such as those used for I/O, persistent memory, or special hardware buffers—require extra handling. The session thus focused on efficient management strategies for these non-direct-map pages.

What does "managing pages outside the direct map" mean?

In the Linux kernel, the direct map is a virtual address space that maps almost all physical memory to a fixed, linear range. Most kernel operations access memory through this map. However, certain memory regions—like those used for device drivers, specific memory-mapped I/O, or memory with non-standard attributes (e.g., uncacheable or write-combining)—are mapped through separate page table entries. Managing these pages involves ensuring that their page table mappings are correctly set up, invalidated, or updated without interfering with other subsystems. This can be complex because updates may require flushing TLBs (Translation Lookaside Buffers) and coordinating with multiple CPUs.

What challenges arise when managing pages not in the direct map?

The primary challenge is that page table operations for non-direct-map pages are more expensive and less straightforward than for pages within the direct map. For direct-map pages, the kernel can quickly compute the virtual address from a physical address, and there is often a handy kmap mechanism. Outside the direct map, however, the kernel must allocate and manage temporary mappings (e.g., via kmap_atomic) or use specialized functions. Furthermore, because these pages may be shared across different domains (device memory, huge pages, etc.), any change to their mapping can trigger a flurry of inter-processor interrupts for TLB shootdowns. The overhead accumulates, especially in high-throughput systems with many such pages.

How might a pagetable library have helped with this management?

A pagetable library could have provided a consistent set of primitives for common operations—like mapping, unmapping, and updating access permissions—across all types of page tables. For pages outside the direct map, such a library would encapsulate the complexities of TLB flushing, memory barrier ordering, and synchronization. Ideally, it would also optimize sequences where multiple page table updates are batched. Although the library idea did not materialize, the session explored alternative approaches, such as refining existing kernel APIs (e.g., set_pte_at()) and reducing the number of explicit cache and TLB operations by using more intelligent change notifications.

What are the potential benefits of efficiently managing these pages?

Efficient management of non-direct-map pages can significantly improve system performance, particularly in scenarios involving:

• High-speed networking where packet buffers are mapped into device memory.
• Persistent memory (pmem) that may have different caching policies.
• Virtualization where guest memory can be mapped with different attributes.
• Large NUMA machines with complex memory layouts.

By reducing the overhead of page table modifications, the kernel can handle more concurrent I/O operations, lower latency for memory accesses, and improve overall scalability. The session's discussions aimed to identify incremental improvements that could be implemented without a complete pagetable library overhaul.

What was the key takeaway from the session?

The key takeaway was that while a comprehensive pagetable library remains an elusive goal, the Linux kernel community can still make meaningful progress by focusing on the specific pain points of managing pages outside the direct map. Attendees agreed that a set of targeted patches—such as better batching of TLB shootdowns, more efficient page table allocation for non-direct-map regions, and clearer documentation—would yield immediate benefits. The session also highlighted the need for more collaboration among memory management, device driver, and architecture maintainers to tackle these cross-cutting concerns. No concrete code was finalized, but the groundwork was laid for future improvements.