[STACKED on #1441] mm: per-NUMA-node L2 page pools

[gburd]

Note

Stacked on #1441 (node-preferring page allocation). This branch builds on
alloc_page_on_node/alloc_page_from_node from #1441, so the diff is
cumulative until #1441 merges; then it reduces to the single core/mempool.cc
commit. Review #1441 first.

Extends the node-preferring allocator into the hot page-pool path. Previously a
single global L2 pool fed every CPU's per-CPU L1 cache and refilled from the
global free_page_ranges with no node awareness, so on a multi-socket machine
a CPU routinely ran on pages from a remote NUMA node.

Now, when the system has more than one NUMA node, each node gets its own L2 pool
whose refill() prefers pages physically local to that node
(alloc_page_from_node), and each CPU draws from its own node's L2 via
get_l2() (keyed on numa::node_of_cpu). A drained node falls back to any page
so allocation always makes progress. Single-node / non-NUMA systems keep the
original single global_l2 with zero behavior change.

Validation

• Single-node boot: unchanged (fallback path), tst-numa-alloc passes.
• Real 2-socket NUMA metal (AWS m5.metal, node0 193 GB / node1 193 GB, 96
  cores), OSv under KVM with two NUMA nodes bound to the real host nodes:

  NUMA: 2 node(s), 8 CPU(s) mapped, 4 memory range(s)
  node 0: 32 on-node, 0 fell back
  node 1: 32 on-node, 0 fell back
  

  100% node-local allocation on both nodes.
• QEMU-emulated NUMA (no host-node binding) shows a higher node falling back,
  because emulated memory is concentrated on node 0 — an emulation artifact;
  real hardware with genuinely node-distributed memory allocates locally.

tst-numa-alloc reports per-node on-node/fell-back counts as a regression
signal.

Known follow-up (separate): OSv's early memory init can still concentrate
free_page_ranges on lower nodes on some configs; this PR is the allocator-side
half and is correct on real hardware. Boot-time physical-range balancing across
nodes would be a further step if a workload needs it.

[gburd]

Follow-up commit 425c77c on this branch closes the emulated-NUMA node-fallback that the earlier version had (real 2-socket hardware was already 32/32 on both nodes; this fixes the emulated case and any config where the boot allocator coalesces across node boundaries).

Root cause: arch_setup_free_memory() frees all E820 ranges into free_page_ranges at .init priority mempool, before acpi::init()/numa::init() run — so NUMA topology is unknown when memory is registered. The page-range allocator then coalesces physically-adjacent free memory, and since node N and N+1 are adjacent in physical space the whole machine's RAM collapses into essentially one giant free range whose page_range header sits at its low base. alloc_page_from_node() classified a range solely by node_of_phys(base), so a higher node's memory living inside a low-node-based range was invisible and every allocation for it fell back. It was never a draining problem (L2 caps at ~8 MB/node) — it was range classification.

Fix: alloc_page_from_node is now boundary-aware — for each free range it finds the first page-aligned offset intersecting the requested node's SRAT range and carves there, splitting into up-to-three pieces (prefix / carved page / suffix), mirroring the existing alloc_aligned 3-way split. Base-on-node reduces to the old front-carve. Only mutates after the scan completes (no iterator invalidation); single-node is unaffected (alloc_page_from_node is unreachable when nr_nodes<=1).

Emulated QEMU NUMA: 2-node node-1 went 0/32→32/32; 4-node all four nodes 32/32. Single-node regression + tst-mmap still pass.