`Architecture=`, `--architecture=`
-: The architecture to build the image for. Note that this currently
- only works for architectures compatible with the host's
+: The architecture to build the image for. A number of architectures can be specified, but which ones are
+ actually supported depends on the distribution used and whether a bootable image is requested or not. When
+ building for a foreign architecture, you'll also need to install and register a user mode emulator for that
architecture.
+ The following architectures can be specified:
+
+ - alpha
+ - arc
+ - arm
+ - arm64
+ - ia64
+ - loongarch64
+ - mips64-le
+ - mips-le
+ - parisc
+ - ppc
+ - ppc64
+ - ppc64-le
+ - riscv32
+ - riscv64
+ - s390
+ - s390x
+ - tilegx
+ - x86
+ - x86-64
+
### [Output] Section
`Format=`, `--format=`, `-t`
T = TypeVar("T")
-# EFI has its own conventions too
-EFI_ARCHITECTURES = {
- "x86_64": "x64",
- "x86": "ia32",
- "aarch64": "aa64",
- "armhfp": "arm",
- "riscv64:": "riscv64",
-}
-
-
def format_bytes(num_bytes: int) -> str:
if num_bytes >= 1024 * 1024 * 1024:
return f"{num_bytes/1024**3 :0.1f}G"
"--directory", "",
"--distribution", str(state.config.distribution),
"--release", state.config.release,
- "--architecture", state.config.architecture,
+ "--architecture", str(state.config.architecture),
*(["--mirror", state.config.mirror] if state.config.mirror else []),
"--repository-key-check", yes_no(state.config.repository_key_check),
"--repositories", ",".join(state.config.repositories),
# nul terminators in argv so let's communicate the cmdline via a file instead.
state.workspace.joinpath("cmdline").write_text(f"{' '.join(cmdline).strip()}\x00")
- stub = state.root / f"usr/lib/systemd/boot/efi/linux{EFI_ARCHITECTURES[state.config.architecture]}.efi.stub"
+ stub = state.root / f"usr/lib/systemd/boot/efi/linux{state.config.architecture.to_efi()}.efi.stub"
if not stub.exists():
die(f"sd-stub not found at /{stub.relative_to(state.root)} in the image")
"--os-release", f"@{state.root / 'usr/lib/os-release'}",
"--stub", stub,
"--output", boot_binary,
- "--efi-arch", EFI_ARCHITECTURES[state.config.architecture],
+ "--efi-arch", state.config.architecture.to_efi(),
]
for p in state.config.extra_search_paths:
dedent(
f"""\
[Partition]
- Type=root
+ Type=root-{state.config.architecture}
Format={state.installer.filesystem()}
CopyFiles=/
Minimize=guess
--- /dev/null
+# SPDX-License-Identifier: LGPL-2.1+
+
+import enum
+import platform
+
+from mkosi.log import die
+
+
+class Architecture(enum.Enum):
+ alpha = "alpha"
+ arc = "arc"
+ arm = "arm"
+ arm64 = "arm64"
+ ia64 = "ia64"
+ loongarch64 = "loongarch64"
+ mips_le = "mips-le"
+ mips64_le = "mips64-le"
+ parisc = "parisc"
+ ppc = "ppc"
+ ppc64 = "ppc64"
+ ppc64_le = "ppc64-le"
+ riscv32 = "riscv32"
+ riscv64 = "riscv64"
+ s390 = "s390"
+ s390x = "s390x"
+ tilegx = "tilegx"
+ x86 = "x86"
+ x86_64 = "x86-64"
+
+ def __str__(self) -> str:
+ return self.value
+
+ @staticmethod
+ def from_uname(s: str) -> "Architecture":
+ a = {
+ "aarch64" : Architecture.arm64,
+ "aarch64_be" : Architecture.arm64,
+ "armv8l" : Architecture.arm,
+ "armv8b" : Architecture.arm,
+ "armv7ml" : Architecture.arm,
+ "armv7mb" : Architecture.arm,
+ "armv7l" : Architecture.arm,
+ "armv7b" : Architecture.arm,
+ "armv6l" : Architecture.arm,
+ "armv6b" : Architecture.arm,
+ "armv5tl" : Architecture.arm,
+ "armv5tel" : Architecture.arm,
+ "armv5tejl" : Architecture.arm,
+ "armv5tejb" : Architecture.arm,
+ "armv5teb" : Architecture.arm,
+ "armv5tb" : Architecture.arm,
+ "armv4tl" : Architecture.arm,
+ "armv4tb" : Architecture.arm,
+ "armv4l" : Architecture.arm,
+ "armv4b" : Architecture.arm,
+ "alpha" : Architecture.alpha,
+ "arc" : Architecture.arc,
+ "arceb" : Architecture.arc,
+ "x86_64" : Architecture.x86_64,
+ "i686" : Architecture.x86,
+ "i586" : Architecture.x86,
+ "i486" : Architecture.x86,
+ "i386" : Architecture.x86,
+ "ia64" : Architecture.ia64,
+ "parisc64" : Architecture.parisc,
+ "parisc" : Architecture.parisc,
+ "loongarch64" : Architecture.loongarch64,
+ "mips64" : Architecture.mips64_le,
+ "mips" : Architecture.mips_le,
+ "ppc64le" : Architecture.ppc64_le,
+ "ppc64" : Architecture.ppc64,
+ "ppc" : Architecture.ppc,
+ "riscv64" : Architecture.riscv64,
+ "riscv32" : Architecture.riscv32,
+ "riscv" : Architecture.riscv64,
+ "s390x" : Architecture.s390x,
+ "s390" : Architecture.s390,
+ "tilegx" : Architecture.tilegx,
+ }.get(s)
+
+ if not a:
+ die(f"Architecture {a} is not supported")
+
+ return a
+
+ def to_efi(self) -> str:
+ a = {
+ Architecture.x86_64 : "x64",
+ Architecture.x86 : "ia32",
+ Architecture.arm64 : "aa64",
+ Architecture.arm : "arm",
+ Architecture.riscv64 : "riscv64",
+ Architecture.loongarch64 : "loongarch64",
+ }.get(self)
+
+ if not a:
+ die(f"Architecture {self} does not support UEFI")
+
+ return a
+
+ def to_qemu(self) -> str:
+ a = {
+ Architecture.alpha: "alpha",
+ Architecture.arm: "arm",
+ Architecture.arm64: "aarch64",
+ Architecture.loongarch64: "loongarch64",
+ Architecture.mips64_le: "mips",
+ Architecture.mips_le: "mips",
+ Architecture.parisc: "hppa",
+ Architecture.ppc: "ppc",
+ Architecture.ppc64: "ppc",
+ Architecture.ppc64_le: "ppc",
+ Architecture.riscv32: "riscv32",
+ Architecture.riscv64: "riscv64",
+ Architecture.s390x: "s390x",
+ Architecture.x86: "i386",
+ Architecture.x86_64: "x86_64",
+ }.get(self)
+
+ if not a:
+ die(f"Architecture {self} not supported by QEMU")
+
+ return a
+
+ def is_native(self) -> bool:
+ return self == self.native()
+
+ @classmethod
+ def native(cls) -> "Architecture":
+ return cls.from_uname(platform.machine())
+
from pathlib import Path
from typing import Any, Callable, Optional, Type, Union, cast
+from mkosi.architecture import Architecture
from mkosi.log import ARG_DEBUG, ARG_DEBUG_SHELL, Style, die
from mkosi.pager import page
from mkosi.run import run
if "distribution" not in namespace:
setattr(namespace, "distribution", detect_distribution()[0])
if "architecture" not in namespace:
- setattr(namespace, "architecture", platform.machine())
+ setattr(namespace, "architecture", Architecture.native())
d = getattr(namespace, "distribution")
a = getattr(namespace, "architecture")
if d == Distribution.debian:
return "http://deb.debian.org/debian"
elif d == Distribution.ubuntu:
- if a == "x86" or a == "x86_64":
+ if a == Architecture.x86 or a == Architecture.x86_64:
return "http://archive.ubuntu.com/ubuntu"
else:
return "http://ports.ubuntu.com"
elif d == Distribution.arch:
- if a == "aarch64":
+ if a == Architecture.arm64:
return "http://mirror.archlinuxarm.org"
else:
return "https://geo.mirror.pkgbuild.com"
def make_enum_parser(type: Type[enum.Enum]) -> Callable[[str], enum.Enum]:
def parse_enum(value: str) -> enum.Enum:
try:
- return type[value]
- except KeyError:
- die(f"Invalid {type.__name__} value \"{value}\"")
+ return type(value)
+ except ValueError:
+ die(f"'{value}' is not a valid {type.__name__}")
return parse_enum
repo_dirs: list[Path]
repart_dirs: list[Path]
overlay: bool
- architecture: str
+ architecture: Architecture
output_format: OutputFormat
manifest_format: list[ManifestFormat]
output: str
if k in inspect.signature(cls).parameters
})
- def architecture_is_native(self) -> bool:
- return self.architecture == platform.machine()
-
@property
def output_with_version(self) -> str:
output = self.output
MkosiConfigSetting(
dest="architecture",
section="Distribution",
- default=platform.machine(),
+ parse=config_make_enum_parser(Architecture),
+ default=Architecture.native(),
),
MkosiConfigSetting(
dest="mirror",
from pathlib import Path
from typing import TYPE_CHECKING
+from mkosi.architecture import Architecture
+
if TYPE_CHECKING:
from mkosi.state import MkosiState
class DistributionInstaller:
@classmethod
def install(cls, state: "MkosiState") -> None:
- raise NotImplementedError
+ raise NotImplementedError()
@staticmethod
- def kernel_image(kver: str, architecture: str) -> Path:
+ def kernel_image(kver: str, architecture: Architecture) -> Path:
return Path("usr/lib/modules") / kver / "vmlinuz"
@classmethod
def install_packages(cls, state: "MkosiState", packages: Sequence[str]) -> None:
- raise NotImplementedError
+ raise NotImplementedError()
@classmethod
def remove_packages(cls, state: "MkosiState", packages: Sequence[str]) -> None:
- raise NotImplementedError
+ raise NotImplementedError()
@classmethod
def filesystem(cls) -> str:
- raise NotImplementedError
+ raise NotImplementedError()
@classmethod
def filesystem_options(cls, state: "MkosiState") -> dict[str, list[str]]:
@staticmethod
def kernel_command_line(state: "MkosiState") -> list[str]:
return []
+
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ raise NotImplementedError()
from collections.abc import Sequence
from textwrap import dedent
+from mkosi.architecture import Architecture
from mkosi.config import ConfigFeature
from mkosi.distributions import DistributionInstaller
+from mkosi.log import die
from mkosi.run import bwrap
from mkosi.state import MkosiState
from mkosi.types import PathString
if state.config.local_mirror:
server = f"Server = {state.config.local_mirror}"
else:
- if state.config.architecture == "aarch64":
+ if state.config.architecture == Architecture.arm64:
server = f"Server = {state.config.mirror}/$arch/$repo"
else:
server = f"Server = {state.config.mirror}/$repo/os/$arch"
GPGDir = /etc/pacman.d/gnupg/
HookDir = {state.root}/etc/pacman.d/hooks/
HoldPkg = pacman glibc
- Architecture = {state.config.architecture}
+ Architecture = {state.installer.architecture(state.config.architecture)}
Color
CheckSpace
SigLevel = {sig_level}
return invoke_pacman(state, packages, apivfs=apivfs)
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.x86_64 : "x86_64",
+ Architecture.arm64 : "aarch64",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {a} is not supported by Arch Linux")
+
+ return a
+
def invoke_pacman(state: MkosiState, packages: Sequence[str], apivfs: bool = True) -> None:
cmdline: list[PathString] = [
from collections.abc import Sequence
from pathlib import Path
+from mkosi.architecture import Architecture
from mkosi.config import MkosiConfig
from mkosi.distributions import DistributionInstaller
from mkosi.distributions.fedora import Repo, invoke_dnf, setup_dnf
def remove_packages(cls, state: MkosiState, packages: Sequence[str]) -> None:
invoke_dnf(state, "remove", packages)
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.x86_64 : "x86_64",
+ Architecture.ppc64_le : "ppc64le",
+ Architecture.s390x : "s390x",
+ Architecture.arm64 : "aarch64",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {a} is not supported by CentOS")
+
+ return a
+
@staticmethod
def _gpgurl(release: int) -> str:
return "https://www.centos.org/keys/RPM-GPG-KEY-CentOS-Official"
from pathlib import Path
from textwrap import dedent
+from mkosi.architecture import Architecture
from mkosi.distributions import DistributionInstaller
+from mkosi.log import die
from mkosi.run import bwrap, run
from mkosi.state import MkosiState
from mkosi.types import CompletedProcess, PathString
return "ext4"
@staticmethod
- def kernel_image(name: str, architecture: str) -> Path:
+ def kernel_image(name: str, architecture: Architecture) -> Path:
return Path(f"boot/vmlinuz-{name}")
@staticmethod
"sparc" : ["lib64"],
"sparc64" : ["lib32", "lib64"],
"x32" : ["lib32", "lib64", "libx32"],
- }.get(DEBIAN_ARCHITECTURES[state.config.architecture], [])
+ }.get(state.installer.architecture(state.config.architecture), [])
state.root.joinpath("usr").mkdir(mode=0o755, exist_ok=True)
for d in subdirs:
def remove_packages(cls, state: MkosiState, packages: Sequence[str]) -> None:
invoke_apt(state, "purge", packages)
-
-# Debian calls their architectures differently, so when calling apt we will have to map to their names.
-# uname -m -> dpkg --print-architecture
-DEBIAN_ARCHITECTURES = {
- "aarch64": "arm64",
- "armhfp": "armhf",
- "armv7l": "armhf",
- "ia64": "ia64",
- "mips64": "mipsel",
- "m68k": "m68k",
- "parisc64": "hppa",
- "ppc64": "ppc64",
- "ppc64le": "ppc64el",
- "riscv64:": "riscv64",
- "s390x": "s390x",
- "x86": "i386",
- "x86_64": "amd64",
-}
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.arm64 : "arm64",
+ Architecture.arm : "armhf",
+ Architecture.alpha : "alpha",
+ Architecture.x86_64 : "amd64",
+ Architecture.x86 : "i386",
+ Architecture.ia64 : "ia64",
+ Architecture.loongarch64 : "loongarch64",
+ Architecture.mips64_le : "mips64el",
+ Architecture.mips_le : "mipsel",
+ Architecture.parisc : "hppa",
+ Architecture.ppc64_le : "ppc64el",
+ Architecture.ppc64 : "ppc64",
+ Architecture.riscv64 : "riscv64",
+ Architecture.s390x : "s390x",
+ Architecture.s390 : "s390",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {arch} is not supported by Debian")
+
+ return a
def setup_apt(state: MkosiState, repos: Sequence[str]) -> None:
state.root.joinpath("var/lib/dpkg/status").touch()
config = state.workspace / "apt/apt.conf"
- debarch = DEBIAN_ARCHITECTURES[state.config.architecture]
+ debarch = state.installer.architecture(state.config.architecture)
config.write_text(
dedent(
from textwrap import dedent
from typing import Any, NamedTuple
+from mkosi.architecture import Architecture
from mkosi.distributions import DistributionInstaller
+from mkosi.log import die
from mkosi.remove import unlink_try_hard
from mkosi.run import bwrap
from mkosi.state import MkosiState
updates_url = None
elif state.config.mirror:
baseurl = urllib.parse.urljoin(state.config.mirror, f"releases/{release}/Everything/$basearch/os/")
- media = urllib.parse.urljoin(baseurl.replace("$basearch", state.config.architecture), "media.repo")
+ media = urllib.parse.urljoin(baseurl.replace("$basearch", state.installer.architecture(state.config.architecture)), "media.repo")
if not url_exists(media):
baseurl = urllib.parse.urljoin(state.config.mirror, f"development/{release}/Everything/$basearch/os/")
def remove_packages(cls, state: MkosiState, packages: Sequence[str]) -> None:
invoke_dnf(state, "remove", packages)
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.arm64 : "aarch64",
+ Architecture.ia64 : "ia64",
+ Architecture.mips64_le : "mips64el",
+ Architecture.mips_le : "mipsel",
+ Architecture.parisc : "parisc64",
+ Architecture.ppc64_le : "ppc64le",
+ Architecture.riscv64 : "riscv64",
+ Architecture.s390x : "s390x",
+ Architecture.x86_64 : "x86_64",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {a} is not supported by Fedora")
+
+ return a
+
def parse_fedora_release(release: str) -> str:
# The release can be specified as 'rawhide-<version>'. We don't make use
if state.config.cache_only and not state.config.local_mirror:
cmdline += ["-C"]
- if not state.config.architecture_is_native():
- cmdline += [f"--forcearch={state.config.architecture}"]
+ if not state.config.architecture.is_native():
+ cmdline += [f"--forcearch={state.installer.architecture(state.config.architecture)}"]
if not state.config.with_docs:
cmdline += ["--no-docs" if dnf.endswith("dnf5") else "--nodocs"]
from pathlib import Path
from textwrap import dedent
+from mkosi.architecture import Architecture
from mkosi.distributions import DistributionInstaller
from mkosi.install import copy_path, flock
from mkosi.log import ARG_DEBUG, complete_step, die, log_step
from mkosi.run import run, run_workspace_command
from mkosi.state import MkosiState
-ARCHITECTURES = {
- "x86_64": ("amd64", "arch/x86/boot/bzImage"),
- # TODO:
- "aarch64": ("arm64", "arch/arm64/boot/Image.gz"),
- # TODO:
- "armv7l": ("arm", "arch/arm/boot/zImage"),
-}
-
def invoke_emerge(
state: MkosiState,
self.portage_cfg_dir.mkdir(parents=True, exist_ok=True)
- self.arch, _ = ARCHITECTURES[state.config.architecture or "x86_64"]
+ self.arch, _ = state.installer.architecture(state.config.architecture)
self.arch_profile = Path(f"default/linux/{self.arch}/{state.config.release}/no-multilib/systemd/merged-usr")
self.pkgs['sys'] = ["@world"]
return "ext4"
@staticmethod
- def kernel_image(name: str, architecture: str) -> Path:
- _, kimg_path = ARCHITECTURES[architecture]
+ def kernel_image(name: str, architecture: Architecture) -> Path:
+ kimg_path = {
+ Architecture.x86_64: "arch/x86/boot/bzImage",
+ Architecture.arm64: "arch/arm64/boot/Image.gz",
+ Architecture.arm: "arch/arm/boot/zImage",
+ }[architecture]
+
return Path(f"usr/src/linux-{name}") / kimg_path
@classmethod
@classmethod
def install_packages(cls, state: MkosiState, packages: Sequence[str]) -> None:
invoke_emerge(state, packages)
+
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.x86_64 : "amd64",
+ Architecture.arm64 : "arm64",
+ Architecture.arm : "arm",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {a} is not supported by Gentoo")
+
+ return a
from collections.abc import Sequence
+from mkosi.architecture import Architecture
from mkosi.distributions import DistributionInstaller
from mkosi.distributions.fedora import Repo, invoke_dnf, setup_dnf
+from mkosi.log import die
from mkosi.state import MkosiState
@classmethod
def install_packages(cls, state: MkosiState, packages: Sequence[str], apivfs: bool = True) -> None:
release = state.config.release.strip("'")
+ arch = state.installer.architecture(state.config.architecture)
if state.config.local_mirror:
release_url = f"baseurl={state.config.local_mirror}"
updates_url = None
elif state.config.mirror:
- baseurl = f"{state.config.mirror}/distrib/{release}/{state.config.architecture}/media/core/"
+ baseurl = f"{state.config.mirror}/distrib/{release}/{arch}/media/core/"
release_url = f"baseurl={baseurl}/release/"
if release == "cauldron":
updates_url = None
else:
updates_url = f"baseurl={baseurl}/updates/"
else:
- baseurl = f"https://www.mageia.org/mirrorlist/?release={release}&arch={state.config.architecture}§ion=core"
+ baseurl = f"https://www.mageia.org/mirrorlist/?release={release}&arch={arch}§ion=core"
release_url = f"mirrorlist={baseurl}&repo=release"
if release == "cauldron":
updates_url = None
else:
updates_url = f"mirrorlist={baseurl}&repo=updates"
- gpgurl = f"https://mirrors.kernel.org/mageia/distrib/{release}/{state.config.architecture}/media/core/release/media_info/pubkey"
+ gpgurl = f"https://mirrors.kernel.org/mageia/distrib/{release}/{arch}/media/core/release/media_info/pubkey"
repos = [Repo(f"mageia-{release}", release_url, [gpgurl])]
if updates_url is not None:
@classmethod
def remove_packages(cls, state: MkosiState, packages: Sequence[str]) -> None:
invoke_dnf(state, "remove", packages)
+
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.x86_64 : "x86_64",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {a} is not supported by Mageia")
+
+ return a
from collections.abc import Sequence
+from mkosi.architecture import Architecture
from mkosi.distributions import DistributionInstaller
from mkosi.distributions.fedora import Repo, invoke_dnf, setup_dnf
+from mkosi.log import die
from mkosi.state import MkosiState
@classmethod
def install_packages(cls, state: MkosiState, packages: Sequence[str], apivfs: bool = True) -> None:
release = state.config.release.strip("'")
+ arch = state.installer.architecture(state.config.architecture)
if release[0].isdigit():
release_model = "rock"
release_url = f"baseurl={state.config.local_mirror}"
updates_url = None
elif state.config.mirror:
- baseurl = f"{state.config.mirror}/{release_model}/repository/{state.config.architecture}/main"
+ baseurl = f"{state.config.mirror}/{release_model}/repository/{arch}/main"
release_url = f"baseurl={baseurl}/release/"
updates_url = f"baseurl={baseurl}/updates/"
else:
- baseurl = f"http://mirrors.openmandriva.org/mirrors.php?platform={release_model}&arch={state.config.architecture}&repo=main"
+ baseurl = f"http://mirrors.openmandriva.org/mirrors.php?platform={release_model}&arch={arch}&repo=main"
release_url = f"mirrorlist={baseurl}&release=release"
updates_url = f"mirrorlist={baseurl}&release=updates"
@classmethod
def remove_packages(cls, state: MkosiState, packages: Sequence[str]) -> None:
invoke_dnf(state, "remove", packages)
+
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.x86_64 : "x86_64",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {a} is not supported by OpenMandriva")
+
+ return a
import xml.etree.ElementTree as ElementTree
from collections.abc import Sequence
+from mkosi.architecture import Architecture
from mkosi.distributions import DistributionInstaller
from mkosi.distributions.fedora import Repo, invoke_dnf, setup_dnf
from mkosi.log import die
def remove_packages(cls, state: MkosiState, packages: Sequence[str]) -> None:
invoke_dnf(state, "remove", packages)
+ @staticmethod
+ def architecture(arch: Architecture) -> str:
+ a = {
+ Architecture.x86_64 : "x86_64",
+ }.get(arch)
+
+ if not a:
+ die(f"Architecture {a} is not supported by OpenSUSE")
+
+ return a
+
def fetch_gpgurls(repourl: str) -> list[str]:
gpgurls = [f"{repourl}/repodata/repomd.xml.key"]
# SPDX-License-Identifier: LGPL-2.1+
+from mkosi.architecture import Architecture
from mkosi.distributions.debian import DebianInstaller
from mkosi.state import MkosiState
updates = f"deb {state.config.mirror} {state.config.release}-updates {repos}"
# Security updates repos are never mirrored. But !x86 are on the ports server.
- if state.config.architecture in ["x86", "x86_64"]:
+ if state.config.architecture in [Architecture.x86, Architecture.x86_64]:
security = f"deb http://security.ubuntu.com/ubuntu/ {state.config.release}-security {repos}"
else:
security = f"deb http://ports.ubuntu.com/ {state.config.release}-security {repos}"
def as_dict(self) -> dict[str, Any]:
config = {
"name": self.config.image_id or "image",
- "distribution": self.config.distribution.name,
- "architecture": self.config.architecture,
+ "distribution": str(self.config.distribution),
+ "architecture": str(self.config.architecture),
}
if self.config.image_version is not None:
config["version"] = self.config.image_version
from pathlib import Path
from typing import Iterator, Optional
+from mkosi.architecture import Architecture
from mkosi.config import ConfigFeature, MkosiArgs, MkosiConfig
from mkosi.install import copy_path
from mkosi.log import die
def find_qemu_binary(config: MkosiConfig) -> str:
- binaries = ["qemu", "qemu-kvm", f"qemu-system-{config.architecture}"]
+ binaries = ["qemu", "qemu-kvm", f"qemu-system-{config.architecture.to_qemu()}"]
for binary in binaries:
if shutil.which(binary) is not None:
return binary
def find_qemu_firmware(config: MkosiConfig) -> tuple[Path, bool]:
FIRMWARE_LOCATIONS = {
- "x86_64": ["/usr/share/ovmf/x64/OVMF_CODE.secboot.fd"],
- "i386": [
+ Architecture.x86_64: ["/usr/share/ovmf/x64/OVMF_CODE.secboot.fd"],
+ Architecture.x86: [
"/usr/share/edk2/ovmf-ia32/OVMF_CODE.secboot.fd",
"/usr/share/OVMF/OVMF32_CODE_4M.secboot.fd"
],
return Path(firmware), True
FIRMWARE_LOCATIONS = {
- "x86_64": [
+ Architecture.x86_64: [
"/usr/share/ovmf/ovmf_code_x64.bin",
"/usr/share/ovmf/x64/OVMF_CODE.fd",
"/usr/share/qemu/ovmf-x86_64.bin",
],
- "i386": ["/usr/share/ovmf/ovmf_code_ia32.bin", "/usr/share/edk2/ovmf-ia32/OVMF_CODE.fd"],
- "aarch64": ["/usr/share/AAVMF/AAVMF_CODE.fd"],
- "armhfp": ["/usr/share/AAVMF/AAVMF32_CODE.fd"],
+ Architecture.x86: ["/usr/share/ovmf/ovmf_code_ia32.bin", "/usr/share/edk2/ovmf-ia32/OVMF_CODE.fd"],
+ Architecture.arm64: ["/usr/share/AAVMF/AAVMF_CODE.fd"],
+ Architecture.arm: ["/usr/share/AAVMF/AAVMF32_CODE.fd"],
}.get(config.architecture, [])
for firmware in FIRMWARE_LOCATIONS:
def find_ovmf_vars(config: MkosiConfig) -> Path:
OVMF_VARS_LOCATIONS = []
- if config.architecture == "x86_64":
+ if config.architecture == Architecture.x86_64:
OVMF_VARS_LOCATIONS += ["/usr/share/ovmf/x64/OVMF_VARS.fd"]
- elif config.architecture == "i386":
+ elif config.architecture == Architecture.x86:
OVMF_VARS_LOCATIONS += [
"/usr/share/edk2/ovmf-ia32/OVMF_VARS.fd",
"/usr/share/OVMF/OVMF32_VARS_4M.fd",
]
- elif config.architecture == "armhfp":
+ elif config.architecture == Architecture.arm:
OVMF_VARS_LOCATIONS += ["/usr/share/AAVMF/AAVMF32_VARS.fd"]
- elif config.architecture == "aarch64":
+ elif config.architecture == Architecture.arm64:
OVMF_VARS_LOCATIONS += ["/usr/share/AAVMF/AAVMF_VARS.fd"]
OVMF_VARS_LOCATIONS += ["/usr/share/edk2/ovmf/OVMF_VARS.fd",
firmware, fw_supports_sb = find_qemu_firmware(config)
smm = "on" if fw_supports_sb else "off"
- if config.architecture == "aarch64":
+ if config.architecture == Architecture.arm64:
machine = f"type=virt,accel={accel}"
else:
machine = f"type=q35,accel={accel},smm={smm}"
cmdline += ["-chardev", f"socket,id=chrtpm,path={swtpm_socket}",
"-tpmdev", "emulator,id=tpm0,chardev=chrtpm"]
- if config.architecture == "x86_64":
+ if config.architecture == Architecture.x86_64:
cmdline += ["-device", "tpm-tis,tpmdev=tpm0"]
- elif config.architecture == "aarch64":
+ elif config.architecture == Architecture.arm64:
cmdline += ["-device", "tpm-tis-device,tpmdev=tpm0"]
if use_vsock:
projects / thirdparty / mkosi.git / commitdiff
