Add the S21 Pro-class Amlogic A113D/AXG control board to the .afw producer and the CI brick-prevention gate, matching the Zynq-7010 treatment. - ci/afw_boards.py: a113d producer profile (arm64, preserve, buildable). Maps the 7-mtd layout, names nvdata (mtd6) the only image-bearing partition, and stages three images vmlinux.bin/devicetree.dtb/uramdisk.image.gz (arm64-image/fdt/uimage) into it. - ci/afw_manifest.py: validate_a113d enforces exactly those three images, the formats, per-image ceilings, total <= nvdata usable, and that no bootloader/spl/fip/tpl member is present and no non-nvdata partition carries an image. - ci/check-afw.py: the independent checker re-validates the produced bundle (arm64, preserve, no FIP member, three named images with formats/ceilings, total <= nvdata, mtd0-5 carry no image) and knows the arm64 Image magic. - ci/test-afw.py: a113d bundle passes and installs all three into nvdata; non-arm64 kernel, oversize kernel, an added FIP member, and a preserved mtd made to carry an image are each refused. All 37 afw tests pass. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
657 lines
29 KiB
Python
Executable File
657 lines
29 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# SPDX-License-Identifier: MIT
|
|
"""Generate an .afw manifest and stage its payload members.
|
|
|
|
The output is a full OS install bundle for exactly one board family: the
|
|
manifest names every image, its size and SHA-256, the partition plan, the
|
|
bootloader policy, the network recovery path and a liveness marker. Payload
|
|
members are staged under <staging>/payload/ in manifest order.
|
|
|
|
This script does not create the tar. ci/make-afw.sh packs the staged members
|
|
in the fixed order manifest.json, optional manifest.json.sig, then payload.
|
|
ci/check-afw.py verifies the finished bundle before it is published.
|
|
"""
|
|
|
|
import argparse
|
|
import datetime
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
|
|
import afw_boards
|
|
|
|
SCHEMA = 2
|
|
P1_LOAD = 0x100200000
|
|
GOLDEN_LBA_BYTES = 0x300000 * 512
|
|
REVISION = 40
|
|
|
|
AM335X_MAP = {
|
|
"mtd0": (0x0000000, 0x20000, True, True, 0, None),
|
|
"mtd1": (0x0020000, 0x20000, True, True, 0, None),
|
|
"mtd2": (0x0040000, 0x20000, True, True, 0, None),
|
|
"mtd3": (0x0060000, 0x20000, True, True, 0, None),
|
|
"mtd4": (0x0080000, 0x1C0000, True, True, 0, None),
|
|
"mtd5": (0x0240000, 0x20000, True, True, 0, None),
|
|
"mtd6": (0x0260000, 0x20000, False, True, 2, "dtb"),
|
|
"mtd7": (0x0280000, 0x500000, False, True, 3, "kernel"),
|
|
"mtd8": (0x0800000, 0x1400000, False, True, 1, "rootfs"),
|
|
"mtd9": (0x1C00000, 0x200000, True, False, 0, None),
|
|
"mtd10": (0x1E00000, 0x200000, True, False, 0, None),
|
|
"mtd11": (0x2000000, 0x6000000, True, False, 0, None),
|
|
}
|
|
AM335X_HOLE = (0x780000, 0x80000)
|
|
AM335X_CHIP = 0x8000000
|
|
AM335X_TARGETS = {"kernel": "mtd7", "dtb": "mtd6", "rootfs": "mtd8"}
|
|
AM335X_FORMATS = {"kernel": "uimage", "dtb": "fdt", "rootfs": "uimage"}
|
|
AM335X_CEILINGS = {"kernel": 0x500000, "dtb": 0x20000, "rootfs": 0x1400000}
|
|
# Tier-3 from-stock: same map except mtd4 is a write target (our U-Boot).
|
|
AM335X_STOCK_MAP = dict(AM335X_MAP)
|
|
AM335X_STOCK_MAP["mtd4"] = (0x0080000, 0x1C0000, False, True, 3, "u-boot")
|
|
AM335X_STOCK_MAP["mtd7"] = (0x0280000, 0x500000, False, True, 4, "kernel")
|
|
AM335X_STOCK_TARGETS = {"u-boot": "mtd4", "kernel": "mtd7", "dtb": "mtd6", "rootfs": "mtd8"}
|
|
AM335X_STOCK_FORMATS = {"u-boot": "uimage", "kernel": "uimage", "dtb": "fdt", "rootfs": "uimage"}
|
|
AM335X_STOCK_CEILINGS = {"u-boot": 0x1C0000, "kernel": 0x500000, "dtb": 0x20000, "rootfs": 0x1400000}
|
|
# SPL copies (mtd0-3) and bootenv (mtd5) must never be written on either tier.
|
|
AM335X_NEVER_WRITE = {"mtd0", "mtd1", "mtd2", "mtd3", "mtd5"}
|
|
|
|
# Zynq-7010 (tier 2, preserve): kernel into the mtd0 kernel slot, dtb, rootfs
|
|
# into mtd1; BOOT.bin (FSBL + FPGA bitstream + stock U-Boot) preserved.
|
|
ZYNQ_FORMATS = {"kernel": "zimage", "dtb": "fdt", "rootfs": "cpio-gzip"}
|
|
ZYNQ_CEILINGS = {"kernel": 0x500000, "dtb": 0x20000, "rootfs": 0x2000000}
|
|
|
|
# Amlogic A113D/AXG (tier 2, preserve): kernel (arm64 Image), dtb and a uImage
|
|
# ramdisk are staged as FILES in the nvdata UBI (mtd6); the FIP bootloader and
|
|
# the stock boot partition (mtd0-5) are preserved. Ceilings keep the three well
|
|
# within the ~185 MiB usable nvdata UBI.
|
|
A113D_FORMATS = {"kernel": "arm64-image", "dtb": "fdt", "rootfs": "uimage"}
|
|
A113D_CEILINGS = {"kernel": 0x4000000, "dtb": 0x100000, "rootfs": 0x6000000}
|
|
A113D_NVDATA_USABLE = 0xB900000 # mtd6 nvdata size; the three images must fit
|
|
|
|
|
|
def die(message):
|
|
print(f"afw_manifest: error: {message}", file=sys.stderr)
|
|
raise SystemExit(1)
|
|
|
|
|
|
def sha256_bytes(data):
|
|
return hashlib.sha256(data).hexdigest()
|
|
|
|
|
|
def sha256_file(path):
|
|
digest = hashlib.sha256()
|
|
with path.open("rb") as source:
|
|
for chunk in iter(lambda: source.read(1024 * 1024), b""):
|
|
digest.update(chunk)
|
|
return digest.hexdigest()
|
|
|
|
|
|
def git_revision(path):
|
|
try:
|
|
return subprocess.check_output(
|
|
["git", "-C", str(path), "rev-parse", "HEAD"],
|
|
text=True,
|
|
stderr=subprocess.DEVNULL,
|
|
).strip()
|
|
except (OSError, subprocess.CalledProcessError):
|
|
return None
|
|
|
|
|
|
def check_revision(name, value):
|
|
if value is None or len(value) != REVISION:
|
|
die(f"{name} must be a 40-character git revision, got {value!r}")
|
|
if any(character not in "0123456789abcdef" for character in value):
|
|
die(f"{name} must be lowercase hexadecimal")
|
|
return value
|
|
|
|
|
|
def build_date(value):
|
|
if value is None:
|
|
return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
try:
|
|
moment = datetime.datetime.fromtimestamp(int(value), datetime.timezone.utc)
|
|
except (ValueError, OSError):
|
|
die("SOURCE_DATE_EPOCH must be an integer Unix timestamp")
|
|
return moment.strftime("%Y-%m-%dT%H:%M:%SZ")
|
|
|
|
|
|
def magic_ok(fmt, path):
|
|
with path.open("rb") as source:
|
|
data = source.read() if fmt == "fit" else source.read(4096)
|
|
if fmt == "fit":
|
|
if not data.startswith(b"\xd0\x0d\xfe\xed"):
|
|
return "does not start with the FIT/FDT magic d00dfeed"
|
|
if b"config@cv1835_miner_emmc" not in data:
|
|
return "FIT is missing config@cv1835_miner_emmc"
|
|
if b"signature@" in data:
|
|
return "FIT carries signature@ nodes, which this board cannot boot"
|
|
elif fmt == "fdt":
|
|
if not data.startswith(b"\xd0\x0d\xfe\xed"):
|
|
return "does not start with the FDT magic d00dfeed"
|
|
elif fmt == "arm64-image":
|
|
if len(data) < 64 or data[0x38:0x3C] != b"ARMd":
|
|
return "does not carry the arm64 Image ARMd header magic"
|
|
elif fmt == "cpio-gzip":
|
|
if not data.startswith(b"\x1f\x8b"):
|
|
return "is not gzip-compressed"
|
|
elif fmt == "uimage":
|
|
if not data.startswith(b"\x27\x05\x19\x56"):
|
|
return "is not a legacy uImage"
|
|
return None
|
|
|
|
|
|
def pad_to(source, destination, exact_bytes):
|
|
size = source.stat().st_size
|
|
if size > exact_bytes:
|
|
die(f"{source.name} is {size} bytes, larger than its {exact_bytes}-byte partition")
|
|
destination.parent.mkdir(parents=True, exist_ok=True)
|
|
with source.open("rb") as reader, destination.open("wb") as writer:
|
|
shutil.copyfileobj(reader, writer)
|
|
if size < exact_bytes:
|
|
writer.write(b"\0" * (exact_bytes - size))
|
|
if destination.stat().st_size != exact_bytes:
|
|
die(f"{destination.name} did not reach the exact {exact_bytes}-byte size")
|
|
|
|
|
|
def load_plan(path, profile, board):
|
|
plan = json.loads(Path(path).read_text())
|
|
if plan.get("board") != board:
|
|
die(f"plan board {plan.get('board')!r} does not match --board {board!r}")
|
|
if plan.get("arch") != profile["arch"]:
|
|
die(f"plan arch {plan.get('arch')!r} does not match {profile['arch']!r}")
|
|
policy = plan.get("bootloader_policy", profile["bootloader_policy"])
|
|
if policy != profile["bootloader_policy"]:
|
|
die(f"plan bootloader_policy {policy!r} does not match {profile['bootloader_policy']!r}")
|
|
partitions = plan.get("partitions")
|
|
images = plan.get("images")
|
|
if not isinstance(partitions, list) or not isinstance(images, list):
|
|
die("plan must contain partitions and images lists")
|
|
return partitions, images
|
|
|
|
|
|
def signing_key(path):
|
|
raw = Path(path).read_bytes()
|
|
if len(raw) == 64:
|
|
try:
|
|
raw = bytes.fromhex(raw.decode("ascii").strip())
|
|
except (ValueError, UnicodeDecodeError):
|
|
die("signing key file must be 32 raw bytes or 64 hexadecimal characters")
|
|
if len(raw) != 32:
|
|
die("signing key file must be 32 raw bytes or 64 hexadecimal characters")
|
|
try:
|
|
from cryptography.hazmat.primitives import serialization
|
|
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
|
|
except ImportError:
|
|
die("Ed25519 signing needs the Python cryptography package")
|
|
private = Ed25519PrivateKey.from_private_bytes(raw)
|
|
public = private.public_key().public_bytes(
|
|
serialization.Encoding.Raw, serialization.PublicFormat.Raw
|
|
)
|
|
return private, public.hex()
|
|
|
|
|
|
def validate_am335x(partitions, images):
|
|
"""Reject the AM335x brick paths before a bundle is packed."""
|
|
installs = [image for image in images if image["install"]]
|
|
if len(installs) != 3:
|
|
die("am335x must install exactly kernel, dtb and rootfs")
|
|
if {image["name"] for image in installs} != set(AM335X_TARGETS):
|
|
die("am335x install images must be named kernel, dtb and rootfs")
|
|
for image in images:
|
|
lowered = f"{image['name']} {image['file']}".lower()
|
|
if "spl" in lowered or "u-boot" in lowered or "uboot" in lowered:
|
|
die(f"am335x bundle carries an spl/u-boot member: {image['file']!r}")
|
|
for image in installs:
|
|
name = image["name"]
|
|
if image["format"] != AM335X_FORMATS[name]:
|
|
die(f"am335x {name} format must be {AM335X_FORMATS[name]}")
|
|
if image["partition"] != AM335X_TARGETS[name]:
|
|
die(f"am335x {name} must target {AM335X_TARGETS[name]}")
|
|
if image["size"] > AM335X_CEILINGS[name]:
|
|
die(
|
|
f"am335x {name} is {image['size']} bytes, over the "
|
|
f"0x{AM335X_CEILINGS[name]:x}-byte ceiling"
|
|
)
|
|
seen = {}
|
|
for partition in partitions:
|
|
name = partition["name"]
|
|
if name not in AM335X_MAP:
|
|
die(f"unknown am335x partition {name!r}")
|
|
seen[name] = partition
|
|
offset, size, secure, boot_critical, write_order, image_name = AM335X_MAP[name]
|
|
if int(partition["offset"]) != offset:
|
|
die(f"am335x {name} offset must be 0x{offset:x}")
|
|
if int(partition["size"]) != size:
|
|
die(f"am335x {name} size must be 0x{size:x}")
|
|
if bool(partition["secure"]) is not secure:
|
|
die(f"am335x {name} secure flag is wrong")
|
|
if bool(partition["boot_critical"]) is not boot_critical:
|
|
die(f"am335x {name} boot_critical flag is wrong")
|
|
if int(partition.get("write_order", 0)) != write_order:
|
|
die(f"am335x {name} write_order must be {write_order}")
|
|
if partition.get("image") != image_name:
|
|
die(f"am335x {name} image must be {image_name!r}")
|
|
start = int(partition["offset"])
|
|
end = start + int(partition["size"])
|
|
hole_start, hole_size = AM335X_HOLE
|
|
if start < hole_start + hole_size and end > hole_start:
|
|
die(f"am335x {name} overlaps the 0x780000-0x800000 hole")
|
|
if name in {f"mtd{index}" for index in range(0, 6)} and write_order != 0:
|
|
die(f"am335x {name} is preserved and must not be written")
|
|
if set(seen) != set(AM335X_MAP):
|
|
die("am335x manifest partition map is incomplete")
|
|
if int(seen["mtd7"]["offset"]) + int(seen["mtd7"]["size"]) != AM335X_HOLE[0]:
|
|
die("am335x mtd7 must end at the 0x780000 hole")
|
|
if int(seen["mtd8"]["offset"]) != AM335X_HOLE[0] + AM335X_HOLE[1]:
|
|
die("am335x mtd8 must start at 0x800000 after the hole")
|
|
total = sum(int(part["size"]) for part in partitions)
|
|
if total != AM335X_CHIP - AM335X_HOLE[1]:
|
|
die("am335x partition sizes must sum to 0x7F80000")
|
|
|
|
|
|
def validate_am335x_stock(partitions, images):
|
|
"""Reject the AM335x tier-3 (from-stock) brick paths before packing.
|
|
|
|
This bundle DOES write mtd4 (our non-RSA U-Boot), so unlike the tier-2
|
|
validator it permits a u-boot member - but it still guards every brick
|
|
path: the four install images are exactly u-boot/kernel/dtb/rootfs, mtd4
|
|
carries the u-boot and no SPL copy is ever a write target, the 0x780000
|
|
hole and the 12-partition geometry are exact, and no mtd0-3/mtd5 may hold
|
|
an image.
|
|
"""
|
|
installs = [image for image in images if image["install"]]
|
|
if len(installs) != 4:
|
|
die("am335x-stock must install exactly u-boot, kernel, dtb and rootfs")
|
|
if {image["name"] for image in installs} != set(AM335X_STOCK_TARGETS):
|
|
die("am335x-stock install images must be named u-boot, kernel, dtb and rootfs")
|
|
# The U-Boot member is expected here; a loose 'spl' member never is.
|
|
for image in images:
|
|
lowered = f"{image['name']} {image['file']}".lower()
|
|
if "spl" in lowered:
|
|
die(f"am335x-stock bundle carries an spl member: {image['file']!r}")
|
|
for image in installs:
|
|
name = image["name"]
|
|
if image["format"] != AM335X_STOCK_FORMATS[name]:
|
|
die(f"am335x-stock {name} format must be {AM335X_STOCK_FORMATS[name]}")
|
|
if image["partition"] != AM335X_STOCK_TARGETS[name]:
|
|
die(f"am335x-stock {name} must target {AM335X_STOCK_TARGETS[name]}")
|
|
if image["size"] > AM335X_STOCK_CEILINGS[name]:
|
|
die(
|
|
f"am335x-stock {name} is {image['size']} bytes, over the "
|
|
f"0x{AM335X_STOCK_CEILINGS[name]:x}-byte ceiling"
|
|
)
|
|
if installs[[img["name"] for img in installs].index("u-boot")]["role"] != "bootloader":
|
|
die("am335x-stock u-boot image must have role bootloader")
|
|
seen = {}
|
|
for partition in partitions:
|
|
name = partition["name"]
|
|
if name not in AM335X_STOCK_MAP:
|
|
die(f"unknown am335x-stock partition {name!r}")
|
|
seen[name] = partition
|
|
offset, size, secure, boot_critical, write_order, image_name = AM335X_STOCK_MAP[name]
|
|
if int(partition["offset"]) != offset:
|
|
die(f"am335x-stock {name} offset must be 0x{offset:x}")
|
|
if int(partition["size"]) != size:
|
|
die(f"am335x-stock {name} size must be 0x{size:x}")
|
|
if bool(partition["secure"]) is not secure:
|
|
die(f"am335x-stock {name} secure flag is wrong")
|
|
if bool(partition["boot_critical"]) is not boot_critical:
|
|
die(f"am335x-stock {name} boot_critical flag is wrong")
|
|
if int(partition.get("write_order", 0)) != write_order:
|
|
die(f"am335x-stock {name} write_order must be {write_order}")
|
|
if partition.get("image") != image_name:
|
|
die(f"am335x-stock {name} image must be {image_name!r}")
|
|
start = int(partition["offset"])
|
|
end = start + int(partition["size"])
|
|
hole_start, hole_size = AM335X_HOLE
|
|
if start < hole_start + hole_size and end > hole_start:
|
|
die(f"am335x-stock {name} overlaps the 0x780000-0x800000 hole")
|
|
if name in AM335X_NEVER_WRITE and (write_order != 0 or partition.get("image") is not None):
|
|
die(f"am335x-stock {name} is preserved and must not be written")
|
|
if set(seen) != set(AM335X_STOCK_MAP):
|
|
die("am335x-stock manifest partition map is incomplete")
|
|
if int(seen["mtd7"]["offset"]) + int(seen["mtd7"]["size"]) != AM335X_HOLE[0]:
|
|
die("am335x-stock mtd7 must end at the 0x780000 hole")
|
|
if int(seen["mtd8"]["offset"]) != AM335X_HOLE[0] + AM335X_HOLE[1]:
|
|
die("am335x-stock mtd8 must start at 0x800000 after the hole")
|
|
total = sum(int(part["size"]) for part in partitions)
|
|
if total != AM335X_CHIP - AM335X_HOLE[1]:
|
|
die("am335x-stock partition sizes must sum to 0x7F80000")
|
|
|
|
|
|
def validate_zynq(partitions, images):
|
|
"""Reject the Zynq-7010 brick paths before packing (tier 2, preserve).
|
|
|
|
The board reuses the stock BOOT.bin (FSBL + FPGA bitstream + stock U-Boot),
|
|
so the bundle must carry NO bootloader/spl/BOOT.bin member; it installs our
|
|
kernel (zImage) into the mtd0 kernel slot, the dtb, and the rootfs
|
|
(gzip cpio) into mtd1. The exact kernel-slot offset is placed per-unit by the
|
|
install method, so this gate enforces the image set, formats and the
|
|
size ceilings (so an oversize image cannot overrun the slot) - not a fixed
|
|
offset map.
|
|
"""
|
|
installs = [image for image in images if image["install"]]
|
|
if len(installs) != 3:
|
|
die("zynq-7010 must install exactly kernel, dtb and rootfs")
|
|
if {image["name"] for image in installs} != set(ZYNQ_FORMATS):
|
|
die("zynq-7010 install images must be named kernel, dtb and rootfs")
|
|
for image in images:
|
|
lowered = f"{image['name']} {image['file']} {image.get('role','')}".lower()
|
|
if "spl" in lowered or "u-boot" in lowered or "uboot" in lowered \
|
|
or "boot.bin" in lowered or image.get("role") == "bootloader":
|
|
die(f"zynq-7010 bundle carries a bootloader/spl member: {image['file']!r}")
|
|
for image in installs:
|
|
name = image["name"]
|
|
if image["format"] != ZYNQ_FORMATS[name]:
|
|
die(f"zynq-7010 {name} format must be {ZYNQ_FORMATS[name]}")
|
|
if image["size"] > ZYNQ_CEILINGS[name]:
|
|
die(
|
|
f"zynq-7010 {name} is {image['size']} bytes, over the "
|
|
f"0x{ZYNQ_CEILINGS[name]:x}-byte ceiling"
|
|
)
|
|
# BOOT.bin lives at the front of mtd0 and is never a write target here.
|
|
for partition in partitions:
|
|
if partition.get("image") in (None, "kernel", "rootfs"):
|
|
continue
|
|
die(f"zynq-7010 partition {partition['name']!r} has an unexpected image target")
|
|
|
|
|
|
def validate_a113d(partitions, images):
|
|
"""Reject the Amlogic A113D/AXG brick paths before packing (tier 2, preserve).
|
|
|
|
Our OS is staged as files in the nvdata UBI; the signed FIP bootloader and the
|
|
stock boot partition (mtd0-5) are preserved, so the bundle must carry NO
|
|
bootloader/spl/tpl/fip member. The kernel (arm64 Image), dtb and uImage
|
|
ramdisk must fit the nvdata UBI both individually (ceilings) and together.
|
|
"""
|
|
installs = [image for image in images if image["install"]]
|
|
if len(installs) != 3:
|
|
die("a113d must install exactly kernel, dtb and rootfs")
|
|
if {image["name"] for image in installs} != set(A113D_FORMATS):
|
|
die("a113d install images must be named kernel, dtb and rootfs")
|
|
for image in images:
|
|
lowered = f"{image['name']} {image['file']} {image.get('role','')}".lower()
|
|
if "spl" in lowered or "u-boot" in lowered or "uboot" in lowered \
|
|
or "fip" in lowered or "tpl" in lowered or image.get("role") == "bootloader":
|
|
die(f"a113d bundle carries a bootloader/spl/fip member: {image['file']!r}")
|
|
total = 0
|
|
for image in installs:
|
|
name = image["name"]
|
|
if image["format"] != A113D_FORMATS[name]:
|
|
die(f"a113d {name} format must be {A113D_FORMATS[name]}")
|
|
if image["size"] > A113D_CEILINGS[name]:
|
|
die(f"a113d {name} is {image['size']} bytes, over the 0x{A113D_CEILINGS[name]:x}-byte ceiling")
|
|
total += image["size"]
|
|
if total > A113D_NVDATA_USABLE:
|
|
die(f"a113d images total {total} bytes, over the 0x{A113D_NVDATA_USABLE:x}-byte nvdata UBI")
|
|
# mtd0-5 (FIP + stock boot) are never a write target.
|
|
for partition in partitions:
|
|
if partition["name"] != "nvdata" and partition.get("image") is not None:
|
|
die(f"a113d partition {partition['name']!r} is preserved and must not carry an image")
|
|
|
|
|
|
def build(args):
|
|
board = args.board
|
|
if not afw_boards.known_board(board):
|
|
die(f"unknown board family {board!r}")
|
|
profile = afw_boards.board(board)
|
|
if not profile["buildable"]:
|
|
die(f"board {board!r} has no buildable .afw profile in this release")
|
|
|
|
input_dir = Path(args.input)
|
|
if not input_dir.is_dir():
|
|
die(f"input directory does not exist: {input_dir}")
|
|
|
|
plan_document = None
|
|
if args.plan:
|
|
plan_document = json.loads(Path(args.plan).read_text())
|
|
partitions, image_specs = load_plan(args.plan, profile, board)
|
|
else:
|
|
partitions = profile["partitions"]
|
|
image_specs = profile["images"]
|
|
|
|
staging = Path(args.staging) if args.staging else Path(tempfile.mkdtemp(prefix="afw-manifest."))
|
|
payload_dir = staging / "payload"
|
|
payload_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
images = []
|
|
for spec in image_specs:
|
|
source_name = spec.get("source", spec.get("file"))
|
|
if not source_name:
|
|
die(f"image {spec.get('name')!r} has no source file")
|
|
source = input_dir / source_name
|
|
if not source.is_file():
|
|
die(f"required image is missing: {source}")
|
|
name = spec["name"]
|
|
fmt = spec.get("format", "raw")
|
|
if fmt not in afw_boards.SAFE_IMAGE_FORMATS:
|
|
die(f"image {name!r} has unsupported format {fmt!r}")
|
|
role = spec.get("role", "component")
|
|
if role not in afw_boards.SAFE_IMAGE_ROLES:
|
|
die(f"image {name!r} has unsupported role {role!r}")
|
|
target = payload_dir / source.name
|
|
exact = spec.get("exact_bytes")
|
|
if exact is not None:
|
|
pad_to(source, target, int(exact))
|
|
else:
|
|
shutil.copyfile(source, target)
|
|
problem = magic_ok(fmt, target)
|
|
if problem:
|
|
die(f"image {name!r} ({target.name}) {problem}")
|
|
size = target.stat().st_size
|
|
images.append(
|
|
{
|
|
"name": name,
|
|
"file": f"payload/{target.name}",
|
|
"role": role,
|
|
"format": fmt,
|
|
"size": size,
|
|
"sha256": sha256_file(target),
|
|
"partition": spec.get("partition"),
|
|
"install": bool(spec.get("install", False)),
|
|
}
|
|
)
|
|
|
|
names = {image["name"] for image in images}
|
|
for partition in partitions:
|
|
image_name = partition.get("image")
|
|
if image_name is not None and image_name not in names:
|
|
die(f"partition {partition.get('name')!r} references missing image {image_name!r}")
|
|
if not partition.get("secure", False):
|
|
size = int(partition.get("size", 0))
|
|
if size <= 0:
|
|
die(f"partition {partition.get('name')!r} has no positive size")
|
|
if partition.get("write_order", 0) > 0 and image_name is None:
|
|
die(f"installable partition {partition.get('name')!r} has no image")
|
|
device = partition.get("device", "")
|
|
if not device.startswith("/dev/"):
|
|
die(f"partition {partition.get('name')!r} has an invalid device path")
|
|
if "boot0" in device and not partition.get("secure", False):
|
|
die("boot0 must be declared secure and must never be a write target")
|
|
if "boot0" in device and partition.get("write_order", 0) > 0:
|
|
die("boot0 must not be in the write order")
|
|
|
|
for image in images:
|
|
partition_name = image.get("partition")
|
|
if partition_name is None:
|
|
continue
|
|
matches = [item for item in partitions if item.get("name") == partition_name]
|
|
if len(matches) != 1:
|
|
die(f"image {image['name']!r} targets unknown partition {partition_name!r}")
|
|
partition = matches[0]
|
|
if partition.get("secure", False):
|
|
die(f"image {image['name']!r} targets secure partition {partition_name!r}")
|
|
if image["size"] > int(partition["size"]):
|
|
die(
|
|
f"image {image['name']!r} is {image['size']} bytes, larger than "
|
|
f"partition {partition_name!r} ({partition['size']} bytes)"
|
|
)
|
|
exact = image.get("exact_bytes", partition.get("exact_bytes"))
|
|
if exact is not None and image["size"] != int(exact):
|
|
die(f"image {image['name']!r} must be exactly {exact} bytes")
|
|
|
|
installs = [image for image in images if image["install"]]
|
|
if not installs:
|
|
die("bundle has no installable image")
|
|
if board == "cv1835":
|
|
if len(installs) != 1 or installs[0]["name"] != "p1":
|
|
die("cv1835 must install exactly one image, p1")
|
|
if installs[0]["size"] != 16 * 1024 * 1024:
|
|
die("cv1835 p1 must be the 16 MiB padded FIT")
|
|
elif board == "am335x":
|
|
validate_am335x(partitions, images)
|
|
elif board == "am335x-stock":
|
|
validate_am335x_stock(partitions, images)
|
|
elif board == "zynq-7010":
|
|
validate_zynq(partitions, images)
|
|
elif board == "a113d":
|
|
validate_a113d(partitions, images)
|
|
|
|
policy = profile["bootloader_policy"]
|
|
if policy == "preserve" and any(image["role"] == "bootloader" for image in images):
|
|
die("bootloader_policy is preserve but the bundle carries a bootloader image")
|
|
if policy == "include" and not any(image["role"] == "bootloader" for image in images):
|
|
die("bootloader_policy is include but the bundle has no bootloader image")
|
|
|
|
sdk_revision = check_revision(
|
|
"sdk_revision", args.sdk_revision or (git_revision(args.sdk_dir) if args.sdk_dir else None)
|
|
)
|
|
os_revision = check_revision(
|
|
"os_revision", args.os_revision or (git_revision(args.os_dir) if args.os_dir else None)
|
|
)
|
|
|
|
signature = {
|
|
"type": "unsigned",
|
|
"member": None,
|
|
"public_key_hex": None,
|
|
}
|
|
signer = None
|
|
if args.signing_key:
|
|
signer, public_hex = signing_key(args.signing_key)
|
|
signature = {
|
|
"type": "ed25519",
|
|
"member": "manifest.json.sig",
|
|
"public_key_hex": public_hex,
|
|
}
|
|
|
|
if board == "am335x":
|
|
boot_switch = {
|
|
"method": "preserved-u-boot-go",
|
|
"detail": "mtd0-5 (SPL and our non-RSA U-Boot) are preserved and never "
|
|
"written. The update writes mtd8 root, mtd6 dtb and mtd7 kernel as "
|
|
"legacy ARM uImages, and the existing boot command loads them.",
|
|
}
|
|
preflight = {
|
|
"required_commands": ["flash_erase", "nandwrite", "nanddump", "md5sum", "sync"],
|
|
"forbidden_devices": [f"/dev/mtd{index}" for index in range(0, 6)],
|
|
"min_free_bytes": 32 * 1024 * 1024,
|
|
"source_os": ["alkane", "ouros", "braiins"],
|
|
"held_partitions": ["mtd8", "mtd6", "mtd7"],
|
|
"preserve_partitions": [f"mtd{index}" for index in range(0, 6)],
|
|
}
|
|
recovery = {
|
|
"network": "afw restore --host <ip> --held-backup <mtd8.img> --confirm FLASH",
|
|
"held_partition": "mtd8",
|
|
"held_partitions": ["mtd8", "mtd6", "mtd7"],
|
|
}
|
|
else:
|
|
boot_switch = {
|
|
"method": "partition-overwrite",
|
|
"detail": "Writing /dev/mmcblk0p1 replaces the FIT. The vendor boot0, "
|
|
"BL2, BL31 and U-Boot chain is preserved and never written.",
|
|
}
|
|
preflight = {
|
|
"required_commands": ["dd", "md5sum", "sync"],
|
|
"forbidden_devices": ["/dev/mmcblk0", "/dev/mmcblk0boot0", "/dev/mmcblk0boot1"],
|
|
"min_free_bytes": 32 * 1024 * 1024,
|
|
"source_os": ["stock-bitmain", "vnish", "braiins", "ouros", "alkane"],
|
|
}
|
|
recovery = {
|
|
"network": "afw restore --host <ip> --held-backup <file>",
|
|
"held_partition": "p1",
|
|
"golden_lba_bytes": GOLDEN_LBA_BYTES,
|
|
}
|
|
|
|
manifest = {
|
|
"schema": SCHEMA,
|
|
"format": "afw",
|
|
"board": board,
|
|
"arch": profile["arch"],
|
|
"version": args.version,
|
|
"build_date": build_date(os.environ.get("SOURCE_DATE_EPOCH")),
|
|
"sdk_revision": sdk_revision,
|
|
"os_revision": os_revision,
|
|
"payload_type": "os",
|
|
"bootloader_policy": policy,
|
|
"signature": signature,
|
|
"partitions": [
|
|
{
|
|
"name": item["name"],
|
|
"device": item["device"],
|
|
"offset": int(item.get("offset", 0)),
|
|
"size": int(item["size"]),
|
|
"secure": bool(item.get("secure", False)),
|
|
"boot_critical": bool(item.get("boot_critical", False)),
|
|
"write_order": int(item.get("write_order", 0)),
|
|
"image": item.get("image"),
|
|
}
|
|
for item in partitions
|
|
],
|
|
"images": images,
|
|
"boot_switch": boot_switch,
|
|
"preflight": preflight,
|
|
"recovery": recovery,
|
|
"marker": (plan_document or {}).get("marker")
|
|
or args.marker
|
|
or ("Alkane" if board == "am335x" else "ALKANE"),
|
|
"kernel_version": (plan_document or {}).get("kernel_version")
|
|
or args.kernel_version
|
|
or "6.18.48",
|
|
}
|
|
if args.notes:
|
|
manifest["notes"] = args.notes
|
|
|
|
manifest_path = staging / "manifest.json"
|
|
manifest_bytes = (json.dumps(manifest, indent=2) + "\n").encode()
|
|
manifest_path.write_bytes(manifest_bytes)
|
|
|
|
if signer is not None:
|
|
signature_bytes = signer.sign(manifest_bytes)
|
|
(staging / "manifest.json.sig").write_bytes(signature_bytes)
|
|
(staging / "manifest.pub").write_text(signature["public_key_hex"] + "\n")
|
|
|
|
print(str(manifest_path))
|
|
return staging, manifest_path
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--board", required=True)
|
|
parser.add_argument("--version", required=True)
|
|
parser.add_argument("--input", required=True, help="SDK board output directory")
|
|
parser.add_argument("--staging", help="staging directory for manifest.json and payload/")
|
|
parser.add_argument("--plan", help="plan JSON emitted by alkane-sdk ci/check-plans.py")
|
|
parser.add_argument("--sdk-revision")
|
|
parser.add_argument("--os-revision")
|
|
parser.add_argument("--sdk-dir")
|
|
parser.add_argument("--os-dir", default=".")
|
|
parser.add_argument("--signing-key", help="raw 32-byte or 64-hex Ed25519 seed file")
|
|
parser.add_argument("--kernel-version")
|
|
parser.add_argument("--marker")
|
|
parser.add_argument("--notes")
|
|
args = parser.parse_args()
|
|
try:
|
|
build(args)
|
|
except SystemExit:
|
|
raise
|
|
except (OSError, ValueError, KeyError) as error:
|
|
die(str(error))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|