Exploring Mshare: Linux's Approach to Sharing Page Tables for Memory

When multiple processes share large memory regions, the page tables each process maintains can collectively consume more memory than the shared data itself. This overhead becomes significant in environments like containerized systems or virtual machines. To address this, Linux developers have been exploring mshare, a mechanism that allows unrelated processes to share page tables for shared memory. At the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit (LSFMM+BPF), Anthony Yznaga presented the current status of this work. Below, we answer common questions about mshare and its implications.

What problem does mshare aim to solve?

In Linux, each process almost always maintains its own set of page tables, even when multiple processes map the same physical memory. If hundreds or thousands of processes share a memory region—common in large-scale deployments—the combined page table footprint can exceed the size of the shared memory itself. This wastes memory and can degrade performance due to increased TLB cache pressure. Mshare seeks to eliminate this redundancy by enabling processes that share the same memory to also share the corresponding page tables. This reduces memory consumption and improves cache locality, making it particularly beneficial for workloads with very large shared memory areas, such as database caches or shared libraries in containerized environments.

How does typical shared memory work in Linux, and why does it cause large page tables?

Linux supports shared memory through mechanisms like System V shared memory, mmap with MAP_SHARED, and memfd_create. When two or more processes map the same physical pages, each process creates its own independent page table entries. The kernel must also maintain metadata (e.g., struct page) for each mapping. While the physical memory is shared, the page tables are not. For a shared memory region of, say, 1 GB used by 1000 processes, each process needs page tables covering that 1 GB. On x86-64 with 4 KB pages, a 1 GB mapping requires roughly 2 million page table entries per process, leading to a total page table memory of several gigabytes—far more than the shared data itself. This overhead is the primary motivation for mshare.

What is mshare and how does it differ from existing shared memory mechanisms?

Mshare is a proposed kernel feature that allows unrelated processes to share not just the physical memory but also the page tables that map that memory. Unlike existing mechanisms like MAP_SHARED where each process builds its own translation structures, mshare would let a group of processes reference a single set of page tables for a shared region. This is conceptually similar to how the kernel handles anonymous huge pages or KSM (Kernel Same-page Merging), but mshare targets the page table level directly. It is also different from copy-on-write or fork-based sharing, because it works across unrelated processes that do not share an ancestry. Mshare is designed to be transparent to userspace—applications use standard shared memory APIs, and the kernel decides internally to share page tables when appropriate.

Who is leading the mshare development and what was discussed at LSFMM+BPF 2026?

Anthony Yznaga is the latest developer driving the mshare effort. During the memory-management track at the 2026 LSFMM+BPF Summit, he presented the current status, challenges, and next steps. The discussion covered the implementation approach, which builds on earlier ideas from developers like Andrea Arcangeli and Hugh Dickins. Yznaga explained that mshare uses a reference-counted page table structure that multiple processes can attach to. He also highlighted unresolved issues, such as handling page faults and dirty tracking when page tables are shared. The summit attendees provided feedback on performance implications, scalability, and integration with existing memory management code. The session concluded with a consensus that mshare is a promising direction but requires further refinement to handle corner cases like huge pages and memory hotplug.

What are the potential benefits of mshare for system performance and memory usage?

The primary benefit of mshare is reduced memory overhead from page tables, which can free up gigabytes of RAM in large-scale deployments. For example, a container host running thousands of similar containers each mapping the same shared library can save a significant amount of memory. Additionally, sharing page tables improves TLB (Translation Lookaside Buffer) efficiency because fewer unique page table entries need to be cached. This can lead to lower TLB miss rates and faster address translation. Another benefit is faster context switches or process creation (e.g., via clone()) because the kernel can reuse existing page tables instead of constructing new ones from scratch. Overall, mshare targets environments where memory density and performance are critical, such as cloud data centers and high-performance computing clusters.

Are there any challenges or concerns with implementing mshare?

Yes, several challenges remain. One major concern is page fault handling—when a shared page table is present, a write fault by one process might need to trigger a copy-on-write or update permissions without affecting others. Another issue is dirty page tracking for swap or migration; the kernel must correctly account for which processes have modified pages. Huge pages also complicate mshare because their page table structures differ from regular pages. Additionally, concurrency control becomes more complex: multiple processes may try to modify the shared page tables simultaneously, requiring fine-grained locking. Memory hotplug and NUMA balancing also need careful handling. Finally, security is a concern—shared page tables must not leak information between processes or allow unauthorized access. The kernel community is debating these issues, and mshare is still experimental.

How does mshare relate to earlier attempts at page table sharing?

The idea of sharing page tables has been explored for years. Early work by Andrea Arcangeli (e.g., in the context of transparent huge pages) touched on sharing page table metadata. Hugh Dickins also contributed to KSM, which merges anonymous pages but not page tables. More recently, “userfaultfd” and “shared virtual memory” (SVM) for GPUs have driven interest in efficient mapping sharing. Yznaga’s mshare builds on these foundations but aims for a generic kernel mechanism that works for any shared memory, not just specific use cases. It is more ambitious than previous attempts because it tries to share the entire page table hierarchy, not just leaf entries. The LSFMM+BPF 2026 discussion confirmed that while earlier prototypes existed, Yznaga’s approach addresses many of the previous limitations and has garnered community support for further development.