Unraveling Anonymous Reverse Mapping: The COW Context Solution

In the Linux kernel, reverse mapping is a critical mechanism that locates all page-table entries pointing to a specific memory page. This is essential for operations like page reclaim, swapping, and copy-on-write (COW). However, managing reverse mapping for anonymous pages—memory not backed by a file—is notoriously complex and bug-prone. Lorenzo Stoakes, in a proposal at the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit, described the current implementation as "a very broken abstraction" and introduced a new approach called a "COW context" to replace the existing anonymous reverse mapping. This article explores the challenges and the proposed solution through a series of detailed Q&A responses.

1. What is reverse mapping in the Linux kernel, and why is it important?

Reverse mapping is the kernel’s ability to find all page-table entries (PTEs) that reference a given physical page. Unlike forward mapping, which goes from a virtual address to a page, reverse mapping starts with the page and traces back to every process mapping it. This is crucial for tasks such as page reclaim (when the kernel needs to free memory), swap (moving pages to disk), and handling copy-on-write (COW) correctly. Without reverse mapping, the kernel would have to scan all page tables to find references—a hugely expensive operation. The efficiency of reverse mapping directly impacts system performance, especially under memory pressure.

Unraveling Anonymous Reverse Mapping: The COW Context Solution

2. How does reverse mapping differ between anonymous pages and file-backed pages?

File-backed pages have a clear relationship to a file on disk, so the kernel can use the file’s address space to locate PTEs via radix trees or XArrays. This is relatively straightforward. Anonymous pages, however, are not tied to any file; they originate from heap allocations, stack, or mmap with MAP_ANONYMOUS. Because their mappings are transient and can be shared across processes (e.g., after fork()), the kernel must maintain a separate reverse mapping structure. Currently, this is done through linked lists of anonymous memory areas (VMAs) and a set of anon_vma objects, which become increasingly complex as processes fork and share memory.

3. What are the main problems with the current anonymous reverse mapping implementation?

As Lorenzo Stoakes pointed out, the current abstraction is "very broken" due to its complexity. Key issues include:

Performance bottlenecks: The anon_vma chain can grow very long, especially with many forked processes, making reverse mapping lookups slow.
Locking overhead: To walk the anon_vma chain, the kernel must acquire multiple locks, leading to contention and scalability problems on multi-core systems.
Abstraction leaks: The implementation mixes multiple concepts (COW tracking, page migration, and reverse mapping) into one structure, making it hard to maintain and reason about.
Inefficiencies in COW handling: When a page is shared via fork and then a write occurs, the current system often needs to scan entire anon_vma chains to find all mappings, which is wasteful.

These problems are why a new approach is needed.

4. Who is proposing the new approach, and what is the "COW context"?

Lorenzo Stoakes, a kernel developer active in memory management, proposed the COW context in a session at the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit. A COW context is a redesigned abstraction that tightly couples the reverse mapping information with the copy-on-write semantics of anonymous pages. Instead of maintaining separate anon_vma structures and PTE chains, the COW context would be a per-page structure that tracks all mappings in a more efficient, lock-friendly way. This simplifies the logic—each anonymous page knows exactly which processes map it and how they use it, especially regarding write sharing. The goal is to replace the current "broken abstraction" with a clean, performant design.

5. How could a COW context improve performance and fix the abstraction issues?

The COW context addresses both performance and correctness:

Reduced lookup time: By storing reverse mapping data directly in a per-page context, the kernel can find all PTEs without walking long anon_vma chains. This is especially beneficial for workloads with many processes sharing anonymous memory.
Better cache locality: The data is compact and accessed together, reducing cache misses.
Simpler locking: The COW context can use a single lock per page (or per context) instead of multiple locks from anon_vma and VMAs, reducing contention.
Clearer semantics: It separates the concerns of COW handling from general reverse mapping, making the code easier to understand and less error-prone.
Scalability: The design is more NUMA-aware and can better handle modern multi-threaded applications.

Overall, the COW context promises to make anonymous reverse mapping both faster and more maintainable.

6. What does the current naming "anonymous reverse mapping" imply about its complexity?

The term "anonymous" reflects that these pages have no permanent backing store, which makes their tracking inherently more complex than file-backed pages. However, the current implementation adds unnecessary intricacy by shoehorning COW tracking, page migration, and reverse mapping into a single tangled structure. Stoakes argued that the abstraction is "very broken" because it fails to isolate these concerns gracefully. The COW context renames and restructures this area, focusing on the core purpose—tracking who shares a page and what happens when it is written to—thus reducing confusion and improving modularity.

7. When and where was this proposal presented?

Lorenzo Stoakes submitted his proposal for a memory-management-track session at the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit (often abbreviated as LSFMM+BPF). This summit is an annual gathering of core kernel developers who discuss and design improvements to storage, filesystems, memory management, and BPF subsystems. The proposal was part of the memory management track, indicating it addresses a fundamental kernel infrastructure issue. The summit is known for in-depth technical discussions that often lead to upstream kernel changes.

8. What might be the implications for the Linux memory management subsystem?

If the COW context is adopted, it would be a significant change to the memory management (MM) subsystem. Current code that relies on anon_vma structures (e.g., page reclaim, migration, and fork handling) would need to be rewritten to use the new mechanism. This could:

Improve fork performance: Fork already triggers COW setup; a per-page context could make page sharing more efficient.
Simplify page migration: When pages move (e.g., for NUMA balancing), the reverse mapping update would be cheaper.
Enable new features: A cleaner abstraction could allow better handling of huge pages, compressed swapping, or even new memory models like CXL.
Risk of regressions: Any major rewrite carries the risk of introducing bugs, so the patch series would need extensive testing.

Overall, the COW context represents a promising evolution of the kernel’s memory management, addressing long-standing pain points.