kerf: Compute pool availability from /proc/iomem in kerf show

The baseline device tree only snapshots the memory pool at init time,
so kerf show kept printing the full pool size even after instances
allocated memory from it. With lazy_cma the pool and every allocation
carved out of it are registered in /proc/iomem, so use that as the
single source of truth.

Centralize /proc/iomem parsing in resources.py with a shared line
parser, a canonical pool lookup keyed on MULTIKERNEL_POOL_NAME, and a
new get_pool_allocated_bytes() that sums all regions nested inside the
pool range, merging overlapping and nested intervals to avoid double
counting. Replace the duplicated pool-lookup copies in init and the
dtc validator with the canonical helper; the validator's old copy
matched any line containing "multikernel" and could grab the wrong
region.

kerf show now prints Pool Allocated and Pool Available lines derived
from /proc/iomem, falling back to the baseline snapshot when the pool
is not registered.

Signed-off-by: Cong Wang <cwang@multikernel.io>

Author: congwang-mk

src/kerf/dtc/validator.py

@@ -18,8 +18,9 @@
 
 import re
 from pathlib import Path
-from typing import List, Dict, Tuple, Optional
+from typing import List, Dict, Optional
 from ..models import GlobalDeviceTree, ValidationResult, ResourceUsage
+from ..resources import get_memory_pool_from_iomem
 
 
 class MultikernelValidator:
@@ -188,32 +189,6 @@ def _get_system_physical_memory(self) -> Optional[int]:
 
         return None
 
-    def _get_multikernel_memory_pool_from_iomem(self) -> Optional[Tuple[int, int]]:
-        """
-        Get multikernel memory pool region from /proc/iomem.
-        Returns (base_address, size_bytes) or None if not found.
-
-        Expected format: "40000000-7fefffff : Multikernel Memory Pool"
-        """
-        try:
-            iomem_path = Path("/proc/iomem")
-            if not iomem_path.exists():
-                return None
-            with open(iomem_path, "r", encoding="utf-8") as f:
-                for line in f:
-                    if "multikernel" in line.lower():
-                        match = re.search(r"([0-9a-fA-F]+)-([0-9a-fA-F]+)", line)
-                        if match:
-                            base = int(match.group(1), 16)
-                            end = int(match.group(2), 16)
-                            # Size is end - start + 1 (inclusive range)
-                            size = end - base + 1
-                            return (base, size)
-        except (OSError, IOError, ValueError):
-            pass
-
-        return None
-
     def _validate_hardware_inventory(self, tree: GlobalDeviceTree):
         """Validate hardware inventory consistency and against running system."""
         cpus = tree.hardware.cpus
@@ -285,7 +260,7 @@ def _validate_hardware_inventory(self, tree: GlobalDeviceTree):
         if memory.memory_pool_bytes <= 0:
             self.errors.append("Hardware inventory: Spawn pool size must be positive")
 
-        iomem_pool = self._get_multikernel_memory_pool_from_iomem()
+        iomem_pool = get_memory_pool_from_iomem()
         if iomem_pool is None or (
             memory.memory_pool_base != iomem_pool[0] or memory.memory_pool_bytes != iomem_pool[1]
         ):

src/kerf/init/main.py

@@ -25,7 +25,7 @@
 import re
 import sys
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Optional
 
 import click
 import libfdt
@@ -39,6 +39,7 @@
 from ..create.main import parse_cpu_spec, parse_device_list, parse_memory_spec
 from ..dtc.parser import DeviceTreeParser
 from ..lazy_cma import LAZY_CMA_DEVICE, allocate_multikernel_pool
+from ..resources import get_memory_pool_from_iomem
 from ..dtc.reporter import ValidationReporter
 from ..dtc.validator import MultikernelValidator
 from ..exceptions import KernelInterfaceError, ParseError, ValidationError
@@ -121,30 +122,6 @@ def mount_multikernel_fs(verbose: bool = False) -> None:
         click.echo("✓ Successfully mounted multikernel filesystem")
 
 
-def get_multikernel_memory_pool_from_iomem() -> Optional[Tuple[int, int]]:
-    """
-    Get multikernel memory pool region from /proc/iomem.
-    Returns (base_address, size_bytes) or None if not found.
-    """
-    try:
-        iomem_path = Path('/proc/iomem')
-        if not iomem_path.exists():
-            return None
-        with open(iomem_path, 'r', encoding='utf-8') as f:
-            for line in f:
-                if 'Multikernel Memory Pool' in line:
-                    match = re.search(r'([0-9a-fA-F]+)-([0-9a-fA-F]+)', line)
-                    if match:
-                        base = int(match.group(1), 16)
-                        end = int(match.group(2), 16)
-                        size = end - base + 1
-                        return (base, size)
-    except (OSError, IOError, ValueError):
-        pass
-
-    return None
-
-
 def get_total_memory_from_system() -> Optional[int]:
     """
     Get total system memory from /proc/meminfo.
@@ -433,7 +410,7 @@ def build_baseline_from_cmdline(
         host_reserved_cpus = [0]
         cpu_list = sorted(list(available_cpus))
 
-    memory_pool = get_multikernel_memory_pool_from_iomem()
+    memory_pool = get_memory_pool_from_iomem()
     if memory_pool is None:
         if not memory:
             raise KernelInterfaceError(
@@ -451,7 +428,7 @@ def build_baseline_from_cmdline(
 
         # Re-read /proc/iomem so the baseline reflects exactly what the
         # kernel registered for the allocation.
-        memory_pool = get_multikernel_memory_pool_from_iomem() or (pool_base, pool_bytes)
+        memory_pool = get_memory_pool_from_iomem() or (pool_base, pool_bytes)
     elif memory:
         click.echo(
             "Note: multikernel memory pool already exists in /proc/iomem; "

src/kerf/resources.py

@@ -20,10 +20,91 @@
 creating or updating kernel instances.
 """
 
-from typing import List, Set, Optional
+import re
+from pathlib import Path
+from typing import List, Set, Optional, Tuple
+
+from .lazy_cma import MULTIKERNEL_POOL_NAME
 from .models import GlobalDeviceTree
 from .exceptions import ResourceError
 
+IOMEM_PATH = "/proc/iomem"
+
+_IOMEM_RANGE_RE = re.compile(r"([0-9a-fA-F]+)-([0-9a-fA-F]+)\s*:\s*(.*)")
+
+
+def _parse_iomem_regions(iomem_path: str) -> List[Tuple[int, int, str]]:
+    """Return (base, end, name) tuples for every range line in /proc/iomem."""
+    regions = []
+    try:
+        path = Path(iomem_path)
+        if not path.exists():
+            return regions
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                match = _IOMEM_RANGE_RE.search(line)
+                if match:
+                    base = int(match.group(1), 16)
+                    end = int(match.group(2), 16)
+                    regions.append((base, end, match.group(3).strip()))
+    except (OSError, IOError, ValueError):
+        pass
+    return regions
+
+
+def get_memory_pool_from_iomem(iomem_path: str = IOMEM_PATH) -> Optional[Tuple[int, int]]:
+    """
+    Get the multikernel memory pool region from /proc/iomem.
+
+    Returns:
+        (base_address, size_bytes) or None if the pool is not registered
+    """
+    for base, end, name in _parse_iomem_regions(iomem_path):
+        if MULTIKERNEL_POOL_NAME in name:
+            return (base, end - base + 1)
+    return None
+
+
+def get_pool_allocated_bytes(iomem_path: str = IOMEM_PATH) -> Optional[Tuple[int, int, int]]:
+    """
+    Compute pool usage from /proc/iomem, the single source of truth.
+
+    Every region nested inside the pool range (instance memory, daxfs
+    heaps, ...) counts as allocated. Overlapping and nested child regions
+    are merged so nothing is double counted.
+
+    Returns:
+        (pool_base, pool_bytes, allocated_bytes), or None if the pool is
+        not registered in /proc/iomem
+    """
+    pool = get_memory_pool_from_iomem(iomem_path)
+    if pool is None:
+        return None
+    pool_base, pool_bytes = pool
+    pool_end = pool_base + pool_bytes - 1
+
+    children = []
+    for base, end, name in _parse_iomem_regions(iomem_path):
+        if MULTIKERNEL_POOL_NAME in name:
+            continue
+        if base >= pool_base and end <= pool_end:
+            children.append((base, end))
+
+    allocated = 0
+    current_base = current_end = None
+    for base, end in sorted(children):
+        if current_base is None:
+            current_base, current_end = base, end
+        elif base <= current_end + 1:
+            current_end = max(current_end, end)
+        else:
+            allocated += current_end - current_base + 1
+            current_base, current_end = base, end
+    if current_base is not None:
+        allocated += current_end - current_base + 1
+
+    return (pool_base, pool_bytes, allocated)
+
 
 def get_available_cpus(tree: GlobalDeviceTree) -> Set[int]:
     """
@@ -62,7 +143,9 @@ def get_allocated_cpus(tree: GlobalDeviceTree) -> Set[int]:
     return allocated
 
 
-def get_allocated_memory_regions_from_iomem() -> List[tuple[int, int]]:
+def get_allocated_memory_regions_from_iomem(
+    iomem_path: str = IOMEM_PATH,
+) -> List[tuple[int, int]]:
     """
     Get list of allocated memory regions from /proc/iomem.
 
@@ -72,28 +155,11 @@ def get_allocated_memory_regions_from_iomem() -> List[tuple[int, int]]:
     Returns:
         List of (base_address, size_bytes) tuples
     """
-    regions = []
-    try:
-        from pathlib import Path
-        import re
-
-        iomem_path = Path("/proc/iomem")
-        if not iomem_path.exists():
-            return regions
-
-        with open(iomem_path, "r", encoding="utf-8") as f:
-            for line in f:
-                if "mk-instance-" in line:
-                    match = re.search(r"([0-9a-fA-F]+)-([0-9a-fA-F]+)", line)
-                    if match:
-                        base = int(match.group(1), 16)
-                        end = int(match.group(2), 16)
-                        size = end - base + 1  # Inclusive range
-                        regions.append((base, size))
-    except (OSError, IOError, ValueError):
-        pass
-
-    return regions
+    return [
+        (base, end - base + 1)
+        for base, end, name in _parse_iomem_regions(iomem_path)
+        if "mk-instance-" in name
+    ]
 
 
 def get_allocated_memory_regions(tree: GlobalDeviceTree) -> List[tuple[int, int]]:

src/kerf/show/main.py

@@ -33,6 +33,7 @@
 from ..exceptions import KernelInterfaceError, ParseError
 from ..metadata import load_instance_metadata
 from ..models import GlobalDeviceTree
+from ..resources import get_pool_allocated_bytes
 from ..utils import get_instance_id_from_name, get_instance_status
 
 
@@ -295,14 +296,32 @@ def display_baseline_info(tree: GlobalDeviceTree, verbose: bool = False):
     click.echo("\n  Memory:")
     total_gb = hardware.memory.total_bytes / (1024**3)
     reserved_gb = hardware.memory.host_reserved_bytes / (1024**3)
-    pool_gb = hardware.memory.memory_pool_bytes / (1024**3)
     click.echo(f"    Total:           {total_gb:.2f} GB ({hardware.memory.total_bytes} bytes)")
     click.echo(
         f"    Host Reserved:   {reserved_gb:.2f} GB ({hardware.memory.host_reserved_bytes} bytes)"
     )
-    click.echo(f"    Pool Base:       0x{hardware.memory.memory_pool_base:x}")
-    click.echo(f"    Pool Size:       {pool_gb:.2f} GB ({hardware.memory.memory_pool_bytes} bytes)")
-    click.echo(f"    Pool End:        0x{hardware.memory.memory_pool_end:x}")
+
+    # /proc/iomem is the source of truth for the lazy_cma pool and the
+    # instance allocations carved out of it; the baseline tree only
+    # snapshots the pool at init time.
+    usage = get_pool_allocated_bytes()
+    if usage is not None:
+        pool_base, pool_bytes, allocated_bytes = usage
+    else:
+        pool_base = hardware.memory.memory_pool_base
+        pool_bytes = hardware.memory.memory_pool_bytes
+        allocated_bytes = None
+
+    pool_gb = pool_bytes / (1024**3)
+    click.echo(f"    Pool Base:       0x{pool_base:x}")
+    click.echo(f"    Pool Size:       {pool_gb:.2f} GB ({pool_bytes} bytes)")
+    click.echo(f"    Pool End:        0x{pool_base + pool_bytes:x}")
+    if allocated_bytes is not None:
+        available_bytes = pool_bytes - allocated_bytes
+        allocated_gb = allocated_bytes / (1024**3)
+        available_gb = available_bytes / (1024**3)
+        click.echo(f"    Pool Allocated:  {allocated_gb:.2f} GB ({allocated_bytes} bytes)")
+        click.echo(f"    Pool Available:  {available_gb:.2f} GB ({available_bytes} bytes)")
 
     # NUMA Topology
     if hardware.topology and hardware.topology.numa_nodes:

tests/test_resources.py

@@ -21,6 +21,9 @@
     get_available_cpus,
     get_allocated_cpus,
     get_allocated_memory_regions,
+    get_allocated_memory_regions_from_iomem,
+    get_memory_pool_from_iomem,
+    get_pool_allocated_bytes,
     find_available_memory_base,
     validate_cpu_allocation,
     validate_memory_allocation,
@@ -228,3 +231,75 @@ def test_find_next_instance_id_full(self, sample_hardware):
 
         with pytest.raises(ResourceError, match="No available instance IDs"):
             find_next_instance_id(tree)
+
+
+class TestIomemPoolAccounting:
+    """Test /proc/iomem based pool accounting."""
+
+    SAMPLE_IOMEM = "\n".join(
+        [
+            "00001000-0009ffff : System RAM",
+            "40000000-7fffffff : Multikernel Memory Pool",
+            "  40000000-43ffffff : mk-instance-1-web-server-region-0",
+            "  44000000-4bffffff : mk-instance-2-database-region-0",
+            "  4c000000-4fffffff : daxfs",
+            "80000000-8fffffff : PCI Bus 0000:00",
+        ]
+    )
+
+    @pytest.fixture
+    def iomem_file(self, tmp_path):
+        path = tmp_path / "iomem"
+        path.write_text(self.SAMPLE_IOMEM + "\n", encoding="utf-8")
+        return str(path)
+
+    def test_get_memory_pool_from_iomem(self, iomem_file):
+        pool = get_memory_pool_from_iomem(iomem_file)
+        assert pool == (0x40000000, 0x40000000)
+
+    def test_get_memory_pool_from_iomem_missing(self, tmp_path):
+        path = tmp_path / "iomem"
+        path.write_text("00001000-0009ffff : System RAM\n", encoding="utf-8")
+        assert get_memory_pool_from_iomem(str(path)) is None
+        assert get_memory_pool_from_iomem(str(tmp_path / "absent")) is None
+
+    def test_get_allocated_memory_regions_from_iomem(self, iomem_file):
+        regions = get_allocated_memory_regions_from_iomem(iomem_file)
+        assert regions == [
+            (0x40000000, 0x4000000),
+            (0x44000000, 0x8000000),
+        ]
+
+    def test_get_pool_allocated_bytes(self, iomem_file):
+        usage = get_pool_allocated_bytes(iomem_file)
+        # Instance regions plus the daxfs region nested in the pool
+        assert usage == (0x40000000, 0x40000000, 0x10000000)
+
+    def test_get_pool_allocated_bytes_empty_pool(self, tmp_path):
+        path = tmp_path / "iomem"
+        path.write_text(
+            "40000000-7fffffff : Multikernel Memory Pool\n", encoding="utf-8"
+        )
+        assert get_pool_allocated_bytes(str(path)) == (0x40000000, 0x40000000, 0)
+
+    def test_get_pool_allocated_bytes_no_pool(self, tmp_path):
+        path = tmp_path / "iomem"
+        path.write_text("00001000-0009ffff : System RAM\n", encoding="utf-8")
+        assert get_pool_allocated_bytes(str(path)) is None
+
+    def test_get_pool_allocated_bytes_merges_nested_regions(self, tmp_path):
+        path = tmp_path / "iomem"
+        path.write_text(
+            "\n".join(
+                [
+                    "40000000-7fffffff : Multikernel Memory Pool",
+                    "  40000000-43ffffff : mk-instance-1-a-region-0",
+                    "    40000000-40ffffff : mk-instance-1-a-subregion",
+                    "  44000000-47ffffff : mk-instance-2-b-region-0",
+                ]
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+        usage = get_pool_allocated_bytes(str(path))
+        assert usage == (0x40000000, 0x40000000, 0x8000000)