tan-cli 0.7.0__py3-none-any.whl

tan/planner/cli.py

@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: Apache-2.0
+"""The planner CLI: argparse + main(), over one mode->text dispatch.
+
+Kept in-package (imported by __init__ for the public `main` re-export, and by
+__main__ as the `python -m tan.planner` entry) so nothing has to import
+__main__ -- importing __main__ re-enters the package under runpy and warns.
+
+RELOCATED (was alp-sdk `scripts/alp_orchestrate/cli.py`). The mode dispatch was
+lifted out of `main()` into `emit_artefact()` so the in-process caller
+(`tan.planner_root.emit`, which is how `tan build` gets its plan) and this argv
+path render through the SAME branch table. Two copies of an eight-way `--emit`
+switch is how one surface silently starts emitting differently from the other.
+
+`--emit` also accepts `alp_project.py`'s OWN modes (`zephyr-conf`,
+`carrier-netlist`, ...), rendered through `tan.planner_emit` -- the same
+in-process engine `tan generate` uses, so a mode still has exactly one renderer
+whichever front door reached it. They print RAW ARTEFACT BYTES, undecorated,
+because alp-sdk's `scripts/check_emit_snapshots.py` diffs this stdout against a
+committed golden; a trailing newline of our own would fail it.
+
+`--emit scaffold` is the third family, and the one mode that takes NO board.yaml
+-- it materialises a NEW project, so it is dispatched before `--input` is read,
+the same order `alp_project.main()` dispatches it in. It renders through
+`tan.planner.template` (relocated from `scripts/alp_template.py`) against the
+LIVE catalog of the bound SDK checkout. `tan init` does NOT come this way and
+must not: it serves a customer with no SDK at all, from tan's own vendored
+capture (`tan.core.scaffold`, invariant I-32).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Iterable, Optional
+
+from tan import planner_emit
+
+from . import (
+    OrchestratorError,
+    emit_build_plan,
+    emit_kconfig,
+    emit_storage_mounts_c,
+    emit_system_manifest,
+    load_board_yaml,
+)
+from .buildplan import _shared_artefact, _shared_tfm_conf
+from .paths import REPO
+from .template import (
+    TemplateError,
+    emit_scaffold,
+    find_template_by_cores,
+    load_catalog,
+)
+
+if False:  # typing-only; keeps the runtime import graph unchanged
+    from .models import BoardProject
+
+#: The eight modes alp-sdk's `alp_orchestrate` CLI exposed, every one of them
+#: served by `emit_artefact`.
+ORCHESTRATOR_MODES = (
+    "system-manifest", "ipc-contract-h", "dts-reservations", "dts-partitions",
+    "storage-mounts-c", "tfm-sysbuild-conf", "build-plan", "kconfig",
+)
+
+#: The rest of `--emit`: `alp_project.py`'s modes, served by `tan.planner_emit`.
+#: DERIVED from `IN_PROCESS_MODES` rather than listed again -- a second list is
+#: how `tan generate` and this entry would drift apart on which modes exist.
+#: `ipc-contract-h` is in both sets and stays with `emit_artefact`; sorted, so
+#: `--help` does not reorder itself between interpreters.
+PROJECT_MODES = tuple(
+    sorted(planner_emit.IN_PROCESS_MODES.difference(ORCHESTRATOR_MODES)))
+
+#: The modes served by `tan.planner.template`, which take `--template`/`--sku`
+#: instead of a board.yaml. Deliberately NOT folded into `IN_PROCESS_MODES`:
+#: that set is `tan generate`'s target list, and `tan generate --output` writes
+#: ONE artefact, where a scaffold is a whole project's worth of files. The
+#: customer surface is frozen (`tan init` scaffolds); this entry is the gate's.
+TEMPLATE_MODES = ("scaffold",)
+
+
+def emit_artefact(project: "BoardProject", mode: str, *, board_yaml: Path,
+                  build_root: Path = Path("build"),
+                  core: Optional[str] = None) -> str:
+    """Render one `--emit` mode for an already-loaded project.
+
+    `core` is honoured by `kconfig` alone; every other mode ignores it -- the
+    same asymmetry the flag's own help text records.
+    """
+    if mode == "system-manifest":
+        return emit_system_manifest(project)
+    if mode == "ipc-contract-h":
+        return _shared_artefact(project, "generated/alp/system_ipc.h")
+    if mode == "dts-reservations":
+        return _shared_artefact(project, "generated/dts-reservations.dtsi")
+    if mode == "dts-partitions":
+        return _shared_artefact(project, "generated/dts-partitions.dtsi")
+    if mode == "storage-mounts-c":
+        # The plan carries the table only when a partition is mountable
+        # (alp-sdk#2820); "" here means "none", and the standalone emit has
+        # always printed the empty table in that case, so keep it byte-identical.
+        return (_shared_artefact(project, "generated/storage_mount_table.c")
+                or emit_storage_mounts_c(project))
+    if mode == "tfm-sysbuild-conf":
+        return _shared_tfm_conf(project)
+    if mode == "build-plan":
+        return emit_build_plan(project, board_yaml=board_yaml,
+                               build_root=build_root)
+    if mode == "kconfig":
+        return emit_kconfig(project, core)
+    raise OrchestratorError(f"unknown emit mode '{mode}'")
+
+
+def _parse_cores_arg(raw: str) -> dict[str, str]:
+    """`--cores` (alp-sdk#1652): `core_id:os[,core_id:os...]` -- the
+    topology an IDE wizard already knows (which cores it's targeting and
+    which OS each runs), NOT a directory. RELOCATED verbatim from
+    `alp_project._parse_cores_arg`. `--cores` is a SELECTOR over the
+    catalog's existing templates (see `find_template_by_cores`'s
+    docstring for why this stops short of an arbitrary core -> app-dir
+    renderer): the directory each core lands in is whatever the matched
+    template already uses, same as picking that template by `--template`
+    would give.
+    """
+    cores: dict[str, str] = {}
+    for entry in raw.split(","):
+        entry = entry.strip()
+        if not entry:
+            continue
+        if ":" not in entry:
+            raise ValueError(
+                f"--cores entry {entry!r} must be core_id:os (e.g. "
+                f"m55_hp:zephyr)")
+        core_id, _, os_name = entry.partition(":")
+        core_id, os_name = core_id.strip(), os_name.strip()
+        if not core_id or not os_name:
+            raise ValueError(
+                f"--cores entry {entry!r} must be core_id:os (e.g. "
+                f"m55_hp:zephyr)")
+        if core_id in cores:
+            raise ValueError(f"--cores names {core_id!r} more than once")
+        cores[core_id] = os_name
+    if not cores:
+        raise ValueError("--cores must name at least one core_id:os pair")
+    return cores
+
+
+def _emit_scaffold(
+    template: Optional[str], sku: Optional[str], cores: Optional[str] = None,
+) -> int:
+    """`--emit scaffold --template <id> --sku <SKU>`, or `--emit scaffold
+    --cores <core_id:os,...> --sku <SKU>` (alp-sdk#1652), straight to
+    stdout.
+
+    `--template`/`--cores` are mutually exclusive alternative ways to pick
+    the template -- `--cores` resolves to a `template_id` via
+    `find_template_by_cores`, then falls into the exact same
+    `emit_scaffold()` call `--template` would reach, exactly as
+    `alp_project._run_scaffold_emit` refuses/resolves them. `--sku` is
+    still required either way and refused ONE AT A TIME, in that order,
+    so a caller that omitted both still learns about `--template`/
+    `--cores` first. `argparse` cannot express "required only for this
+    `--emit`", which is why this is a hand-check.
+    """
+    if template and cores:
+        print("alp-orchestrate: --emit scaffold takes --template OR "
+              "--cores, not both", file=sys.stderr)
+        return 1
+    if not template and not cores:
+        print("alp-orchestrate: --emit scaffold requires --template <id> "
+              "or --cores <core_id:os,...>", file=sys.stderr)
+        return 1
+    if not sku:
+        print("alp-orchestrate: --emit scaffold requires --sku <SKU>",
+              file=sys.stderr)
+        return 1
+    if cores:
+        try:
+            cores_topology = _parse_cores_arg(cores)
+        except ValueError as e:
+            print(f"alp-orchestrate: {e}", file=sys.stderr)
+            return 1
+        try:
+            record = find_template_by_cores(load_catalog(), cores_topology)
+        except TemplateError as e:
+            print(f"alp-orchestrate: {e}", file=sys.stderr)
+            return 1
+        template = record["id"]
+    try:
+        sys.stdout.write(emit_scaffold(template, sku))
+    except TemplateError as e:
+        print(f"alp-orchestrate: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def main(argv: Optional[Iterable[str]] = None) -> int:
+    import argparse
+    parser = argparse.ArgumentParser(
+        description="Planner/emit CLI for board.yaml (the executor was "
+                     "retired -- ADR-0020 Phase 4).")
+    parser.add_argument("--input", type=Path, default=Path("board.yaml"),
+                        help="Path to the project's board.yaml.")
+    parser.add_argument("--build-root", type=Path,
+                        default=Path("build"),
+                        help="Build root directory (used by --emit build-plan).")
+    parser.add_argument("--core", default=None,
+                        help="Core id to scope a per-core emit mode to "
+                             "(required by --emit kconfig; every other "
+                             "mode ignores it).")
+    parser.add_argument("--template", default=None,
+                        help="metadata/templates/catalog-v1.json template id; "
+                             "required for --emit scaffold (unless --cores is "
+                             "given instead).")
+    parser.add_argument("--cores", default=None,
+                        help="core_id:os[,core_id:os...] topology (e.g. "
+                             "'m55_hp:zephyr,m55_he:zephyr'); an alternative "
+                             "to --template for --emit scaffold -- selects "
+                             "whichever catalog template's own cores: "
+                             "topology matches exactly (alp-sdk#1652). "
+                             "Mutually exclusive with --template.")
+    parser.add_argument("--sku", default=None,
+                        help="Target SoM SKU (e.g. the one a scaffold is "
+                             "retargeted onto); required for --emit scaffold, "
+                             "and must be one of the template's declared "
+                             "supported.som_skus.")
+    parser.add_argument("--emit", default=None,
+                        choices=[*ORCHESTRATOR_MODES, *PROJECT_MODES,
+                                 *TEMPLATE_MODES],
+                        help="Skip the build; just emit one of the "
+                             "generated artefacts to stdout.")
+    args = parser.parse_args(list(argv) if argv is not None else None)
+
+    if args.emit in TEMPLATE_MODES:
+        # Before `--input` is touched: a scaffold IS the new project, so there
+        # is no board.yaml to load yet.
+        return _emit_scaffold(args.template, args.sku, args.cores)
+
+    if args.emit in PROJECT_MODES:
+        # Straight to the relocated renderers, deliberately WITHOUT the
+        # `load_board_yaml` below: `carrier-netlist` / `composed-route-table`
+        # read the raw board.yaml dict (mirroring `alp_project.main()`, which
+        # dispatches them before its per-core machinery), so loading here would
+        # refuse a board the SDK's own front door serves.
+        try:
+            sys.stdout.write(planner_emit.render(
+                args.emit, sdk_root=REPO, board_yaml=args.input,
+                core=args.core))
+        except (OrchestratorError, planner_emit.PlannerEmitError) as e:
+            print(f"alp-orchestrate: {e}", file=sys.stderr)
+            return 1
+        return 0
+
+    try:
+        project = load_board_yaml(args.input)
+    except OrchestratorError as e:
+        print(f"alp-orchestrate: {e}", file=sys.stderr)
+        return 1
+
+    if args.emit:
+        try:
+            sys.stdout.write(emit_artefact(
+                project, args.emit, board_yaml=args.input,
+                build_root=args.build_root, core=args.core))
+        except OrchestratorError as e:
+            print(f"alp-orchestrate: {e}", file=sys.stderr)
+            return 1
+        return 0
+
+    # ADR-0020 Phase 4 (preview): the SDK-side executor was retired --
+    # this module only plans/emits now.  Building is an external
+    # consumer's job (against `--emit build-plan`'s JSON contract).
+    print("alp-orchestrate: no executor -- pass --emit to print a "
+          "generated artefact (e.g. --emit build-plan)", file=sys.stderr)
+    return 2

tan/planner/headers.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Header / DTS / mount-table emitters from the resolved model.
+
+Pure renderers off the parsed BoardProject + the resolved carve-outs / storage
+partitions: the IPC contract header (ipc-contract-h), the DTS reserved-memory
+overlay (dts-reservations), the DTS fixed-partitions overlay (dts-partitions),
+and the static C mount table (storage-mounts-c). Each is a leaf emit -- it calls
+only the carve-out / partition resolvers, never the loader/validator. Extracted
+as the #285 headers emit seam.
+"""
+
+from __future__ import annotations
+
+from .carveout import resolve_carve_outs
+from .models import BoardProject, ResolvedPartition
+from .partition import resolve_storage_partitions
+
+
+def emit_ipc_contract_h(project: BoardProject) -> str:
+    """Generate alp_system_ipc.h per spec §6.3."""
+    carve_outs = resolve_carve_outs(project)
+
+    lines: list[str] = [
+        "/*",
+        " * Auto-generated by scripts/alp_orchestrate.py -- do not edit.",
+        " * Regenerate after changes to board.yaml `ipc:` or the SoM's",
+        " * memory_map / mailbox blocks.",
+        " */",
+        "",
+        "#ifndef ALP_SYSTEM_IPC_H",
+        "#define ALP_SYSTEM_IPC_H",
+        "",
+        f'#define ALP_IPC_SKU "{project.sku}"',
+        "",
+    ]
+    if not carve_outs:
+        lines += [
+            "/* No ipc[] entries declared in board.yaml; nothing to emit. */",
+            "",
+            "#endif /* ALP_SYSTEM_IPC_H */",
+            "",
+        ]
+        return "\n".join(lines)
+
+    for c in carve_outs:
+        upper = c.name.upper()
+        lines.append(f"/* {c.kind} channel '{c.name}' -- endpoints "
+                     f"{', '.join(c.endpoints)} */")
+        if c.status == "blocked":
+            # Blocked entries still need the SRC_EPT / DST_EPT / MBOX_CH /
+            # ADDR / SIZE macros so consumer source compiles: the
+            # canonical pattern (see examples/rpmsg-*/m*/src/main.c) is a
+            # static struct initialiser that references every field at
+            # compile time.  Omitting the macros made every rpmsg
+            # consumer fail with `<macro> undeclared` long before the
+            # NOSUPPORT runtime check could even fire.  Emit safe-zero
+            # stubs + a #warning so the build is green and the gap is
+            # surfaced via the alp_rpc_open() ALP_ERR_NOSUPPORT path
+            # the backend already returns when it sees a zero
+            # mailbox_channel or empty mailbox controller.
+            lines.append(f"/* BLOCKED: {c.reason or 'unknown reason'} */")
+            # Surface the gap as a structured comment block rather than
+            # a `#warning` (the slice builds under -Werror=cpp and an
+            # actual warning would trip it).  The same reason text is
+            # also written into the build manifest by the orchestrator's
+            # fan-out step so reviewers see it.
+            lines.append(f"/* IPC channel '{c.name}' is blocked; "
+                         "fix the SoM metadata before depending on this "
+                         "channel at runtime. */")
+            lines.append(f'#define ALP_IPC_{upper}_NAME       "{c.name}"')
+            lines.append(f"#define ALP_IPC_{upper}_ADDR       0x0u  /* stub: blocked */")
+            lines.append(f"#define ALP_IPC_{upper}_SIZE       0x0u  /* stub: blocked */")
+            lines.append(f"#define ALP_IPC_{upper}_SRC_EPT    0x0u  /* stub: blocked */")
+            lines.append(f"#define ALP_IPC_{upper}_DST_EPT    0x0u  /* stub: blocked */")
+            lines.append(f"#define ALP_IPC_{upper}_MBOX_CH    0u    /* stub: blocked */")
+            lines.append("")
+            continue
+        lines.append(f'#define ALP_IPC_{upper}_NAME       "{c.name}"')
+        lines.append(f'#define ALP_IPC_{upper}_ADDR       0x{c.base:08x}u')
+        lines.append(f'#define ALP_IPC_{upper}_SIZE       0x{c.size:08x}u')
+        lines.append(f'#define ALP_IPC_{upper}_SRC_EPT    0x{c.src_ept:08x}u')
+        lines.append(f'#define ALP_IPC_{upper}_DST_EPT    0x{c.dst_ept:08x}u')
+        lines.append(f'#define ALP_IPC_{upper}_MBOX_CH    {c.mailbox_channel}u')
+        lines.append("")
+
+    lines.append("#endif /* ALP_SYSTEM_IPC_H */")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def emit_dts_reservations(project: BoardProject) -> str:
+    """Generate dts-reservations.dtsi per spec §6.2."""
+    carve_outs = resolve_carve_outs(project)
+    lines: list[str] = [
+        "/*",
+        " * Auto-generated by scripts/alp_orchestrate.py -- do not edit.",
+        " * Regenerate after changes to board.yaml `ipc:` or the SoM's",
+        " * memory_map block.  #include this file from your kernel /",
+        " * Zephyr DT.",
+        " */",
+        "",
+        "/ {",
+        "    reserved-memory {",
+        "        #address-cells = <2>;",
+        "        #size-cells = <2>;",
+        "",
+    ]
+    if not carve_outs:
+        lines.append("        /* No ipc[] carve-outs declared. */")
+    else:
+        for c in carve_outs:
+            if c.status == "blocked":
+                # Blocked carve-outs land as a comment so reviewers see
+                # the gap; the slice build trips elsewhere (the C
+                # header carries an #error directive).
+                lines.append(f"        /* BLOCKED: {c.name} -- "
+                             f"{c.reason or 'unknown reason'} */")
+                lines.append("")
+                continue
+            # Split base / size into two 32-bit halves for the
+            # #address-cells = <2>; #size-cells = <2>; addressing.
+            base_hi = (c.base >> 32) & 0xFFFFFFFF
+            base_lo = c.base & 0xFFFFFFFF
+            size_hi = (c.size >> 32) & 0xFFFFFFFF
+            size_lo = c.size & 0xFFFFFFFF
+            lines.append(
+                f"        {c.name}: {c.name}@{c.base:x} {{")
+            lines.append(
+                '            compatible = "shared-dma-pool";')
+            lines.append(
+                f"            reg = <0x{base_hi:x} 0x{base_lo:08x} "
+                f"0x{size_hi:x} 0x{size_lo:08x}>;")
+            lines.append("            no-map;")
+            lines.append(f'            label = "{c.name}";')
+            lines.append("        };")
+            lines.append("")
+
+    lines.append("    };")
+    lines.append("};")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def emit_dts_partitions(project: BoardProject) -> str:
+    """Generate dts-partitions.dtsi from board.yaml `storage:`.
+
+    The overlay decorates each referenced flash device with a
+    `partitions { ... }` child node carrying every resolved
+    partition for that device.  Zephyr's `fixed-partitions` binding
+    consumes the result; downstream Kconfig (CONFIG_FILE_SYSTEM_LITTLEFS
+    etc., emitted by `_slice_alp_conf()`) wires the filesystem driver.
+
+    Blocked partitions appear as bare comments so reviewers see the
+    gap; the slice build trips elsewhere (the per-fs Kconfig will not
+    have a backing partition and Zephyr's link-time fs-table assembly
+    surfaces the error).
+    """
+    partitions = resolve_storage_partitions(project)
+    lines: list[str] = [
+        "/*",
+        " * Auto-generated by scripts/alp_orchestrate.py -- do not edit.",
+        " * Regenerate after changes to board.yaml `storage:` or the SoM's",
+        " * memory_map / on_module.ospi_memories blocks.  #include this file",
+        " * from your Zephyr DT.",
+        " */",
+        "",
+    ]
+    if not partitions:
+        lines += [
+            "/* No `storage:` entries declared in board.yaml; nothing to emit. */",
+            "",
+        ]
+        return "\n".join(lines)
+
+    # Group resolved partitions by dt_label; blocked entries get a
+    # standalone comment block so reviewers see the gap.
+    by_label: dict[str, list[ResolvedPartition]] = {}
+    blocked: list[ResolvedPartition] = []
+    for p in partitions:
+        if p.status == "blocked":
+            blocked.append(p)
+            continue
+        by_label.setdefault(p.dt_label, []).append(p)
+
+    for label in sorted(by_label.keys()):
+        lines.append(f"&{label} {{")
+        lines.append("    partitions {")
+        lines.append('        compatible = "fixed-partitions";')
+        lines.append("        #address-cells = <1>;")
+        lines.append("        #size-cells = <1>;")
+        lines.append("")
+        # Sort by base offset for human readability + DT-binding
+        # convention (low-address first).
+        for p in sorted(by_label[label], key=lambda x: x.base_kib):
+            base_bytes = p.base_kib * 1024
+            size_bytes = p.size_kib * 1024
+            lines.append(
+                f"        {p.name}_partition: partition@{base_bytes:x} {{")
+            lines.append(f'            label = "{p.name}";')
+            lines.append(
+                f"            reg = <0x{base_bytes:x} 0x{size_bytes:x}>;")
+            lines.append("        };")
+            lines.append("")
+        lines.append("    };")
+        lines.append("};")
+        lines.append("")
+
+    if blocked:
+        lines.append(
+            "/* Blocked storage entries -- see system-manifest.yaml for details. */")
+        for p in blocked:
+            lines.append(f"/* BLOCKED: {p.name} -- "
+                         f"{p.reason or 'unknown reason'} */")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def _mountable_partitions(project: BoardProject):
+    """Resolved storage partitions that get a row in the mount table."""
+    return [p for p in resolve_storage_partitions(project)
+            if p.status == "ok" and p.mount and p.fs != "raw"]
+
+
+def has_storage_mounts(project: BoardProject) -> bool:
+    """True when `emit_storage_mounts_c` would emit a non-empty table."""
+    return bool(_mountable_partitions(project))
+
+
+def emit_storage_mounts_c(project: BoardProject) -> str:
+    """Generate storage_mount_table.c -- a static fs_mount_t[] array.
+
+    Optional companion to emit_dts_partitions.  Apps that want
+    deterministic boot-time mounting include this file and call
+    `alp_storage_mount_all()` (or iterate the table manually).
+    Partitions with no `mount:` declared are omitted from the table.
+    """
+    mountable = _mountable_partitions(project)
+
+    lines: list[str] = [
+        "/*",
+        " * Auto-generated by scripts/alp_orchestrate.py -- do not edit.",
+        " * Regenerate after changes to board.yaml `storage:`.",
+        " */",
+        "/* clang-format off */",
+        "",
+        "#include <zephyr/fs/fs.h>",
+        "#include <zephyr/storage/flash_map.h>",
+        "",
+    ]
+    if not mountable:
+        lines += [
+            "/* No mountable storage[] entries declared; emitting empty table. */",
+            "",
+            "const struct fs_mount_t *alp_storage_mounts[] = { 0 };",
+            "const size_t alp_storage_mount_count = 0;",
+            "/* clang-format on */",
+            "",
+        ]
+        return "\n".join(lines)
+
+    # Per-fs includes + per-partition fs_<name>_data + fs_mount_t.
+    fs_seen: set[str] = set()
+    for p in mountable:
+        if p.fs in fs_seen:
+            continue
+        fs_seen.add(p.fs)
+        if p.fs == "littlefs":
+            lines.append("#include <zephyr/fs/littlefs.h>")
+        elif p.fs == "fat":
+            lines.append("#include <ff.h>")
+        elif p.fs == "ext4":
+            lines.append("#include <zephyr/fs/ext2.h>")
+    lines.append("")
+
+    for p in mountable:
+        upper = p.name.upper()
+        if p.fs == "littlefs":
+            lines.append(f"FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(alp_lfs_{p.name});")
+            lines.append(f"static struct fs_mount_t alp_mnt_{p.name} = {{")
+            lines.append("    .type = FS_LITTLEFS,")
+            lines.append(f"    .fs_data = &alp_lfs_{p.name},")
+            lines.append(f"    .storage_dev = (void *)FIXED_PARTITION_ID({p.name}_partition),")
+            lines.append(f'    .mnt_point = "{p.mount}",')
+            lines.append("};")
+        elif p.fs == "fat":
+            lines.append(f"static FATFS alp_fat_{p.name};")
+            lines.append(f"static struct fs_mount_t alp_mnt_{p.name} = {{")
+            lines.append("    .type = FS_FATFS,")
+            lines.append(f"    .fs_data = &alp_fat_{p.name},")
+            lines.append(f"    .storage_dev = (void *)FIXED_PARTITION_ID({p.name}_partition),")
+            lines.append(f'    .mnt_point = "{p.mount}",')
+            lines.append("};")
+        elif p.fs == "ext4":
+            lines.append(f"static struct fs_mount_t alp_mnt_{p.name} = {{")
+            lines.append("    .type = FS_EXT2,")
+            lines.append(f"    .storage_dev = (void *)FIXED_PARTITION_ID({p.name}_partition),")
+            lines.append(f'    .mnt_point = "{p.mount}",')
+            lines.append("};")
+        lines.append("")
+        # Silence -Wunused on the per-partition mount when the app
+        # iterates only via alp_storage_mounts[]; the explicit symbol
+        # lets test fixtures reach a specific mount by name.
+        _ = upper
+
+    lines.append("const struct fs_mount_t *alp_storage_mounts[] = {")
+    for p in mountable:
+        lines.append(f"    &alp_mnt_{p.name},")
+    lines.append("};")
+    lines.append("const size_t alp_storage_mount_count = "
+                 f"{len(mountable)};")
+    lines.append("/* clang-format on */")
+    lines.append("")
+    return "\n".join(lines)