numa: report real topology from getcpu and get_mempolicy

With NUMA topology now discovered (numa:: module), make the topology-query
syscalls report it instead of a hardcoded single node:

- sys_getcpu() now fills the node-out argument with numa::node_of_cpu() for the
  calling CPU rather than always 0.
- get_mempolicy():
  - MPOL_F_NODE returns the calling CPU's node.
  - MPOL_F_NODE | MPOL_F_ADDR returns the node backing the given address,
    resolved via a page-table walk (virt_to_phys_pt) and numa::node_of_phys().
  - the allowed-nodes mask now sets a bit for every discovered node (not just
    node 0), and rejects a maxnode smaller than the node count with EINVAL.

set_mempolicy() stays a no-op: the topology is known but the physical allocator
is not yet node-aware, so a placement policy cannot be enforced. Its comment is
updated to say so; enforcement will come with the node-aware allocator.

Adds numa::node_of_phys() to map a physical address to its node.

On a machine with no SRAT everything degrades to the previous single-node-0
behavior.

Add tests/tst-numa-mempolicy.cc checking getcpu's node is in range and matches
numa::node_of_cpu, get_mempolicy's MPOL_F_NODE and allowed-mask (bit count ==
node count, maxnode-too-small EINVAL), and the MPOL_F_ADDR path. Verified on OSv
under KVM single-node and with a QEMU 2-node -numa config.

Depends on the "numa: discover NUMA topology from ACPI SRAT/SLIT" change.

Author: gburd

core/numa.cc

@@ -44,6 +44,16 @@ unsigned node_of_cpu(unsigned cpu_id)
     return it == s_cpu_to_node.end() ? 0 : it->second;
 }
 
+int node_of_phys(uint64_t phys)
+{
+    for (auto& r : s_mem_ranges) {
+        if (phys >= r.base && phys < r.base + r.length) {
+            return (int)r.node;
+        }
+    }
+    return -1;
+}
+
 unsigned distance(unsigned from, unsigned to)
 {
     if (from == to) {

include/osv/numa.hh

@@ -50,6 +50,10 @@ bool available();
 // The node a CPU (by sched cpu id) belongs to, or 0 if unknown.
 unsigned node_of_cpu(unsigned cpu_id);
 
+// The node that owns a physical address, or -1 if it falls in no known range.
+// Only meaningful when available() is true.
+int node_of_phys(uint64_t phys);
+
 // The SLIT distance from node `from` to node `to`.  Linux/ACPI convention:
 // 10 == local (same node), higher == farther.  Returns 10 for the diagonal and
 // a default (10 local / 20 remote) when no SLIT is present.

linux.cc

@@ -10,6 +10,8 @@
 
 #include <osv/debug.hh>
 #include <osv/sched.hh>
+#include <osv/numa.hh>
+#include <osv/mmu.hh>
 #include <osv/mutex.h>
 #include <osv/waitqueue.hh>
 #include <osv/stubbing.hh>
@@ -177,23 +179,44 @@ int futex(int *uaddr, int op, int val, const struct timespec *timeout,
 static long get_mempolicy(int *policy, unsigned long *nmask,
         unsigned long maxnode, void *addr, int flags)
 {
-    // As OSv has no support for NUMA nodes, we do here the minimum possible,
-    // which is basically to return the same policy (MPOL_DEFAULT) and list
-    // of nodes (just node 0) no matter if the caller asked for the default
-    // policy, the allowed policy, or the policy for a specific address.
+    // Report the topology discovered from ACPI SRAT/SLIT (numa::).  When NUMA is
+    // not available (no SRAT, the common single-node VM) this degrades to the
+    // old single-node-0 behavior.  We still apply MPOL_DEFAULT everywhere: the
+    // allocator is not yet node-aware, so we cannot honor a real policy, but we
+    // can at least answer topology queries truthfully.
     if ((flags & MPOL_F_NODE)) {
-        *policy = 0; // in this case, store a node id, not a policy
+        // Store a node id in *policy, not a policy value.
+        if (!policy) {
+            errno = EINVAL;
+            return -1;
+        }
+        if (flags & MPOL_F_ADDR) {
+            // The node backing the given address, if we can resolve it.
+            int node = -1;
+            if (numa::available() && addr) {
+                auto phys = mmu::virt_to_phys_pt(addr);
+                node = numa::node_of_phys(phys);
+            }
+            *policy = node < 0 ? 0 : node;
+        } else {
+            // The node the calling CPU runs on.
+            *policy = numa::node_of_cpu(sched::cpu::current()->id);
+        }
         return 0;
     }
     if (policy) {
         *policy = MPOL_DEFAULT;
     }
     if (nmask) {
-        if (maxnode < 1) {
+        if (maxnode < numa::nr_nodes()) {
             errno = EINVAL;
             return -1;
         }
-        nmask[0] |= 1;
+        // Set a bit for every node that exists.
+        for (unsigned n = 0; n < numa::nr_nodes(); n++) {
+            nmask[n / (8 * sizeof(unsigned long))] |=
+                1UL << (n % (8 * sizeof(unsigned long)));
+        }
     }
     return 0;
 }
@@ -203,9 +226,11 @@ static long get_mempolicy(int *policy, unsigned long *nmask,
 static long set_mempolicy(int policy, unsigned long *nmask,
         unsigned long maxnode)
 {
-    // OSv has very minimal support for NUMA - merely exposes
-    // all cpus as a single node0 and cannot really apply any meaningful policy
-    // Therefore we implement this as noop, ignore all arguments and return success
+    // The topology is now discovered (numa::), but the physical allocator is
+    // not yet node-aware, so we cannot actually enforce a placement policy.
+    // Accept the call as a no-op (ignoring the requested policy) rather than
+    // failing, so NUMA-aware programs run unmodified.  Enforcement will come
+    // when the allocator learns about nodes.
     return 0;
 }
 #endif
@@ -445,12 +470,13 @@ static long sys_getcwd(char *buf, unsigned long size)
 #define __NR_sys_getcpu __NR_getcpu
 static long sys_getcpu(unsigned int *cpu, unsigned int *node, void *tcache)
 {
+    auto *c = sched::cpu::current();
     if (cpu) {
-        *cpu = sched::cpu::current()->id;
+        *cpu = c->id;
     }
 
     if (node) {
-       *node = 0;
+       *node = numa::node_of_cpu(c->id);
     }
 
     return 0;

modules/tests/Makefile

@@ -125,6 +125,7 @@ tests := tst-pthread.so misc-ramdisk.so tst-vblk.so tst-bsd-evh.so \
 	tst-prctl.so \
 	tst-mmap-file-cow.so \
 	tst-numa.so \
+	tst-numa.so tst-numa-mempolicy.so \
 	tst-elf-permissions.so misc-mutex.so misc-sockets.so tst-condvar.so \
 	tst-queue-mpsc.so tst-af-local.so tst-pipe.so tst-yield.so \
 	misc-ctxsw.so tst-read.so tst-symlink.so tst-openat.so \

tests/tst-numa-mempolicy.cc

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2026 Waldemar Kozaczuk
+ *
+ * This work is open source software, licensed under the terms of the
+ * BSD license as described in the LICENSE file in the top-level directory.
+ */
+
+// Verifies that getcpu and get_mempolicy report the NUMA topology discovered by
+// the numa:: module (rather than a hardcoded single node).  Boot with QEMU's
+// -numa options to exercise more than one node.  Built and run as part of the
+// OSv test image.
+
+#include <osv/numa.hh>
+
+#include <sched.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include <cassert>
+#include <iostream>
+
+#define MPOL_F_NODE (1 << 0)
+#define MPOL_F_ADDR (1 << 1)
+
+static long get_mempolicy_(int *policy, unsigned long *nmask,
+        unsigned long maxnode, void *addr, int flags)
+{
+    return syscall(SYS_get_mempolicy, policy, nmask, maxnode, addr, flags);
+}
+
+int main()
+{
+    std::cerr << "Running numa-mempolicy tests\n";
+    unsigned nodes = numa::nr_nodes();
+
+    // getcpu (via sched_getcpu, which passes a node-out pointer) must report a
+    // node within range and consistent with numa::node_of_cpu.
+    unsigned cpu = 0, node = 0;
+    long r = syscall(SYS_getcpu, &cpu, &node, nullptr);
+    assert(r == 0);
+    assert(node < nodes);
+    assert(node == numa::node_of_cpu(cpu));
+
+    // get_mempolicy with MPOL_F_NODE reports the current CPU's node.
+    int cur_node = -1;
+    assert(get_mempolicy_(&cur_node, nullptr, 0, nullptr, MPOL_F_NODE) == 0);
+    assert(cur_node >= 0 && (unsigned)cur_node < nodes);
+
+    // The allowed-nodes mask must have exactly `nodes` bits set at minimum, and
+    // maxnode too small must fail with EINVAL.
+    unsigned long mask[16] = {};
+    int policy = -1;
+    assert(get_mempolicy_(&policy, mask, sizeof(mask) * 8, nullptr, 0) == 0);
+    int bits = 0;
+    for (unsigned i = 0; i < sizeof(mask) * 8; i++) {
+        if (mask[i / (8 * sizeof(unsigned long))] &
+            (1UL << (i % (8 * sizeof(unsigned long))))) {
+            bits++;
+        }
+    }
+    assert((unsigned)bits == nodes);
+
+    if (nodes > 1) {
+        errno = 0;
+        assert(get_mempolicy_(&policy, mask, 1, nullptr, 0) == -1 &&
+               errno == EINVAL);
+    }
+
+    // MPOL_F_NODE|MPOL_F_ADDR reports the node backing a given address.  On a
+    // real NUMA machine this must be a valid node; the value depends on
+    // placement so we only check the range.
+    void *buf = malloc(4096);
+    assert(buf);
+    *(volatile char *)buf = 1;  // fault it in
+    int addr_node = -1;
+    assert(get_mempolicy_(&addr_node, nullptr, 0, buf, MPOL_F_NODE | MPOL_F_ADDR) == 0);
+    assert(addr_node >= 0 && (unsigned)addr_node < nodes);
+    free(buf);
+
+    std::cerr << "  nodes=" << nodes << " current_node=" << cur_node << "\n";
+    std::cerr << "numa-mempolicy tests PASSED\n";
+    return 0;
+}