RFC mm: dual-bitmap page allocator consistency checker
Get series with b4
b4 am [email protected]Versions newest first
- v1 RFC Latest7 patches 21 repliesIn review
Patches in v1 No applies recorded yet
| # | Subject and files | Size | Replies | Applied |
|---|---|---|---|---|
| 1/7 | mm: add generic dual-bitmap consistency primitivesMAINTAINERS include/ | +226 | 0 replies | |
| 2/7 | mm: add page consistency checker headerinclude/ | +84 | 0 replies | |
| 3/7 | mm: add Kconfig options for page consistency checkermm/ | +59 | 0 replies | |
| 4/7 | mm: add page consistency checker implementationmm/ mm/ | +361 | 15 replies | |
| 5/7 | mm/page_alloc: integrate page consistency hooksmm/ mm/ | +13 | 0 replies | |
| 6/7 | Documentation/mm: add page consistency checker documentationDocumentation/ Documentation/ | +212 | 0 replies | |
| 7/7 | mm/page_consistency: add KUnit tests for dual-bitmap primitivesmm/ mm/ | +275 | 0 replies |
Reviews trailers per patch
None of the 7 patches has a Reviewed-by or Acked-by.
| Patch | Sanif Veeras |
|---|---|
| 1/7 | Based-on-patch-by |
| 2/7 | Based-on-patch-by |
| 3/7 | Based-on-patch-by |
| 4/7 | Based-on-patch-by |
| 5/7 | Based-on-patch-by |
| 6/7 | Based-on-patch-by |
| 7/7 | Based-on-patch-by |
Trailers given in replies are filled; those carried in the patches from earlier versions are outlined with dashes.
Cover letter [RFC 0/7] mm: dual-bitmap page allocator consistency checker
Existing memory debugging tools - KASAN, KFENCE, page_poisoning - detect access violations and content corruption, but none of them can detect silent corruption in the page allocator's own metadata. If a hardware bit flip corrupts an allocation bitmap, the allocator hands out a page that is already in use (or fails to hand out a free one), and nothing in the kernel notices. This series adds a dual-bitmap consistency checker that maintains the invariant primary == ~secondary across two independently allocated bitmaps, so that any single-bit corruption in either bitmap is immediately detectable. The approach is based on NVIDIA safety research.
Field studies consistently show that DRAM errors at scale are far more common than textbook assumptions suggest, even with ECC. Schroeder et al. (SIGMETRICS 2009) found 8% of DIMMs experienced errors per year in Google's fleet; Sridharan and Liberty (SC 2012) reported similar rates at LANL; Meta's 2021-2022 work documented silent data corruption at scale, including memory-related faults. The critical property of allocator metadata corruption is that it doesn't trigger an invalid memory access - the corrupted data is structurally valid, just wrong. KASAN instruments accesses, not metadata integrity, so it cannot see this class of fault.
Functional safety is a different discipline from security that aims to reduce the risk of hardware and software misbehaving to an acceptable level. Security hardens against adversaries; safety hardens against random hardware failures (cosmic rays, cell wear-out, thermal noise) and systematic software failures (bugs). ISO 26262 (automotive functional safety) defines four Automotive Safety Integrity Levels, ASIL A through D. ASIL-D, the most stringent, is derived from the severity of the hazard in case of failure. IEC 61508 defines similar levels (SIL-1 through SIL-4) for industrial systems, and there are equivalent standards for avionics and medical devices. ISO 26262 requires Freedom From Interference (FFI): a safety element must not be corrupted by faults in other elements. For an OS kernel, this means the memory allocator's metadata must either be immune to corruption or corruption must be detected before it propagates. The dual-bitmap implements a way to protect from corruption coming from hardware or software - two complementary representations of page allocation state, allocated independently via memblock, where any single-bit fault in either bitmap is immediately detectable. Performance is secondary to correctness in this context. A safety mechanism must be simple enough to audit and certify, must fail deterministically (panic, not log-and-hope), and its correctness matters more than its throughput. The dual-bitmap adds two atomic bitops per alloc/free, but for safety-critical deployments this cost is acceptable because the alternative - undetected corruption propagating silently - violates the system's safety case. The static key ensures zero cost for kernels that don't need it.
The natural question is why not use page_ext. The key objection from a safety perspective is that page_ext stores per-page metadata in memory that is itself subject to the same hardware faults we're trying to detect. The dual-bitmap approach works because the two bitmaps are independent allocations - corruption in one is caught by comparison with the other. Embedding both in page_ext means a single fault could corrupt both the tracking data and its redundant copy in the same allocation region. ISO 26262 recommends this approach for protecting against hardware faults, but it also helps against software faults - co-locating both bitmaps in page_ext violates this principle. Beyond the safety argument, there are practical issues: page_ext adds 8-100+ bytes per page depending on enabled features while the dual-bitmap uses 2 bits per page total, and page_ext initializes after the buddy allocator while the checker must be active before memblock_free_all() hands pages to buddy.
Sasha Levin (7):
mm: add generic dual-bitmap consistency primitives
mm: add page consistency checker header
mm: add Kconfig options for page consistency checker
mm: add page consistency checker implementation mm/page_alloc: integrate page consistency hooks Documentation/mm: add page consistency checker documentation mm/page_consistency: add KUnit tests for dual-bitmap primitives
Documentation/mm/index.rst | 1 + Documentation/mm/page_consistency.rst | 211 +++++++++++++++ MAINTAINERS | 10 + include/linux/dual_bitmap.h | 216 ++++++++++++++++ include/linux/page_consistency.h | 84 ++++++ mm/Kconfig.debug | 59 +++++ mm/Makefile | 2 + mm/mm_init.c | 9 + mm/page_alloc.c | 4 + mm/page_consistency.c | 360 ++++++++++++++++++++++++++ mm/page_consistency_test.c | 274 ++++++++++++++++++++ 11 files changed, 1230 insertions(+) create mode 100644 Documentation/mm/page_consistency.rst create mode 100644 include/linux/dual_bitmap.h create mode 100644 include/linux/page_consistency.h create mode 100644 mm/page_consistency.c create mode 100644 mm/page_consistency_test.c
Signature · 1 line
2.53.0