Don't do EFI stuff if on unsupported architecture

diff --git a/mkosi/__init__.py b/mkosi/__init__.py
index 7f8f458bbcce7acfebf3cdc6f48dade193d8a42c..4f41ce29e9ca4d0441a181a00d8fe7501e456d32 100644 (file)
--- a/mkosi/__init__.py
+++ b/mkosi/__init__.py
@@ -464,6 +464,9 @@ def install_systemd_boot(state: MkosiState) -> None:
     if state.config.output_format == OutputFormat.cpio and state.config.bootable == ConfigFeature.auto:
         return
 
+    if state.config.architecture.to_efi() is None and state.config.bootable == ConfigFeature.auto:
+        return
+
     if not any(gen_kernel_images(state)) and state.config.bootable == ConfigFeature.auto:
         return
 
@@ -1002,7 +1005,10 @@ def build_uki(
     # nul terminators in argv so let's communicate the cmdline via a file instead.
     (state.workspace / "cmdline").write_text(f"{' '.join(cmdline).strip()}\x00")
 
-    stub = state.root / f"usr/lib/systemd/boot/efi/linux{state.config.architecture.to_efi()}.efi.stub"
+    if not (arch := state.config.architecture.to_efi()):
+        die(f"Architecture {state.config.architecture} does not support UEFI")
+
+    stub = state.root / f"usr/lib/systemd/boot/efi/linux{arch}.efi.stub"
     if not stub.exists():
         die(f"sd-stub not found at /{stub.relative_to(state.root)} in the image")
 
@@ -1012,7 +1018,7 @@ def build_uki(
         "--os-release", f"@{state.root / 'usr/lib/os-release'}",
         "--stub", stub,
         "--output", output,
-        "--efi-arch", state.config.architecture.to_efi(),
+        "--efi-arch", arch,
     ]
 
     if not state.config.tools_tree:
@@ -1081,6 +1087,9 @@ def install_uki(state: MkosiState, partitions: Sequence[Partition]) -> None:
     if state.config.output_format in (OutputFormat.cpio, OutputFormat.uki) and state.config.bootable == ConfigFeature.auto:
         return
 
+    if state.config.architecture.to_efi() is None and state.config.bootable == ConfigFeature.auto:
+        return
+
     roothash = finalize_roothash(partitions)
     initrds = []
 
@@ -1675,7 +1684,10 @@ def make_image(state: MkosiState, skip: Sequence[str] = [], split: bool = False)
         definitions = state.workspace / "repart-definitions"
         if not definitions.exists():
             definitions.mkdir()
-            bootloader = state.root / f"efi/EFI/BOOT/BOOT{state.config.architecture.to_efi().upper()}.EFI"
+            if (arch := state.config.architecture.to_efi()):
+                bootloader = state.root / f"efi/EFI/BOOT/BOOT{arch.upper()}.EFI"
+            else:
+                bootloader = None
 
             # If grub for BIOS is installed, let's add a BIOS boot partition onto which we can install grub.
             bios = (state.config.bootable != ConfigFeature.disabled and want_grub_bios(state))
@@ -1692,8 +1704,10 @@ def make_image(state: MkosiState, skip: Sequence[str] = [], split: bool = False)
                     )
                 )
 
-            esp = (state.config.bootable == ConfigFeature.enabled or
-                  (state.config.bootable == ConfigFeature.auto and bootloader.exists()))
+            esp = (
+                state.config.bootable == ConfigFeature.enabled or
+                (state.config.bootable == ConfigFeature.auto and bootloader and bootloader.exists())
+            )
 
             if esp or bios:
                 # Even if we're doing BIOS, let's still use the ESP to store the kernels, initrds and grub

diff --git a/mkosi/architecture.py b/mkosi/architecture.py
index b269160f6ab85fc368829c4cbdbee2a8c1c55d91..f4388ea35d2e0fc795b6e7ddbf5d85dc107fdfa0 100644 (file)
--- a/mkosi/architecture.py
+++ b/mkosi/architecture.py
@@ -2,6 +2,7 @@
 
 import enum
 import platform
+from typing import Optional
 
 from mkosi.log import die
 from mkosi.util import StrEnum
@@ -81,8 +82,8 @@ class Architecture(StrEnum):
 
         return a
 
-    def to_efi(self) -> str:
-        a = {
+    def to_efi(self) -> Optional[str]:
+        return {
             Architecture.x86_64      : "x64",
             Architecture.x86         : "ia32",
             Architecture.arm64       : "aa64",
@@ -91,10 +92,6 @@ class Architecture(StrEnum):
             Architecture.loongarch64 : "loongarch64",
         }.get(self)
 
-        if not a:
-            die(f"Architecture {self} does not support UEFI")
-
-        return a
 
     def to_qemu(self) -> str:
         a = {
@@ -120,6 +117,9 @@ class Architecture(StrEnum):
 
         return a
 
+    def supports_smbios(self) -> bool:
+        return self in (Architecture.x86, Architecture.x86_64, Architecture.arm, Architecture.arm64)
+
     def is_native(self) -> bool:
         return self == self.native()
 

diff --git a/mkosi/qemu.py b/mkosi/qemu.py
index d1ccd6806c492061cb7aa057061ac9b7006ab3ee..3b855db3dd610c1c9a40769ca89f0e9c6f253b1e 100644 (file)
--- a/mkosi/qemu.py
+++ b/mkosi/qemu.py
@@ -38,7 +38,8 @@ def machine_cid(config: MkosiConfig) -> int:
 
 
 def find_qemu_binary(config: MkosiConfig) -> str:
-    binaries = ["qemu", "qemu-kvm", f"qemu-system-{config.architecture.to_qemu()}"]
+    binaries = ["qemu", "qemu-kvm"] if config.architecture.is_native() else []
+    binaries += [f"qemu-system-{config.architecture.to_qemu()}"]
     for binary in binaries:
         if shutil.which(binary) is not None:
             return binary
@@ -231,7 +232,10 @@ def run_qemu(args: MkosiArgs, config: MkosiConfig) -> None:
         accel = "kvm"
 
     if config.qemu_firmware == QemuFirmware.auto:
-        firmware = QemuFirmware.linux if config.output_format == OutputFormat.cpio else QemuFirmware.uefi
+        if config.output_format == OutputFormat.cpio or config.architecture.to_efi() is None:
+            firmware = QemuFirmware.linux
+        else:
+            firmware = QemuFirmware.uefi
     else:
         firmware = config.qemu_firmware
 
@@ -272,9 +276,10 @@ def run_qemu(args: MkosiArgs, config: MkosiConfig) -> None:
             "-mon", "console",
         ]
 
-    for k, v in config.credentials.items():
-        cmdline += ["-smbios", f"type=11,value=io.systemd.credential.binary:{k}={base64.b64encode(v.encode()).decode()}"]
-    cmdline += ["-smbios", f"type=11,value=io.systemd.stub.kernel-cmdline-extra={' '.join(config.kernel_command_line_extra)}"]
+    if config.architecture.supports_smbios():
+        for k, v in config.credentials.items():
+            cmdline += ["-smbios", f"type=11,value=io.systemd.credential.binary:{k}={base64.b64encode(v.encode()).decode()}"]
+        cmdline += ["-smbios", f"type=11,value=io.systemd.stub.kernel-cmdline-extra={' '.join(config.kernel_command_line_extra)}"]
 
     # QEMU has built-in logic to look for the BIOS firmware so we don't need to do anything special for that.
     if firmware == QemuFirmware.uefi:
@@ -367,7 +372,7 @@ def run_qemu(args: MkosiArgs, config: MkosiConfig) -> None:
             elif config.architecture == Architecture.arm64:
                 cmdline += ["-device", "tpm-tis-device,tpmdev=tpm0"]
 
-        if use_vsock:
+        if use_vsock and config.architecture.supports_smbios():
             addr, notifications = stack.enter_context(vsock_notify_handler())
             cmdline += ["-smbios", f"type=11,value=io.systemd.credential:vmm.notify_socket={addr}"]