From 53c7f686d145b1d4ac98e864046b6aedbf8fa201 Mon Sep 17 00:00:00 2001 From: Colin Walters Date: Thu, 3 Nov 2022 11:45:16 -0400 Subject: [PATCH] Default to UEFI (non-SB) on x86_64 There's some momentum around e.g. UKI https://github.com/uapi-group/specifications/blob/main/specs/unified_kernel_image.md I think it's about time to flip our default to be UEFI instead of BIOS. (But, we obviously still do need to care about bios...and we should e.g. be running at least a subset of our tests acrosss that too) Also while we're here, make the implementation here have the default for firmware be the empty string `""` instead of `bios`, which doesn't really apply on e.g. ppc64le/s390x. --- mantle/cmd/kola/options.go | 12 +--------- mantle/cmd/kola/qemuexec.go | 4 +++- mantle/platform/machine/unprivqemu/cluster.go | 4 +++- mantle/platform/qemu.go | 24 +++++++++++++++---- src/cmd-kola | 2 +- 5 files changed, 28 insertions(+), 18 deletions(-) diff --git a/mantle/cmd/kola/options.go b/mantle/cmd/kola/options.go index e6b5e123eb..a3f548f8b3 100644 --- a/mantle/cmd/kola/options.go +++ b/mantle/cmd/kola/options.go @@ -202,17 +202,7 @@ func syncOptionsImpl(useCosa bool) error { // native 4k requires a UEFI bootloader if kola.QEMUOptions.Native4k && kola.QEMUOptions.Firmware == "bios" { - return fmt.Errorf("native 4k requires uefi firmware") - } - // default to BIOS, UEFI for aarch64 and x86(only for 4k) - if kola.QEMUOptions.Firmware == "" { - if kola.Options.CosaBuildArch == "aarch64" { - kola.QEMUOptions.Firmware = "uefi" - } else if kola.Options.CosaBuildArch == "x86_64" && kola.QEMUOptions.Native4k { - kola.QEMUOptions.Firmware = "uefi" - } else { - kola.QEMUOptions.Firmware = "bios" - } + kola.QEMUOptions.Firmware = platform.UefiFirmwareDefault } if err := validateOption("platform", kolaPlatform, kolaPlatforms); err != nil { diff --git a/mantle/cmd/kola/qemuexec.go b/mantle/cmd/kola/qemuexec.go index 1f20770df6..0fc1982eb3 100644 --- a/mantle/cmd/kola/qemuexec.go +++ b/mantle/cmd/kola/qemuexec.go @@ -268,7 +268,9 @@ func runQemuExec(cmd *cobra.Command, args []string) error { builder.AppendFirstbootKernelArgs = firstbootkargs } builder.AppendKernelArgs = strings.Join(kargs, " ") - builder.Firmware = kola.QEMUOptions.Firmware + if kola.QEMUOptions.Firmware != "" { + builder.Firmware = kola.QEMUOptions.Firmware + } if kola.QEMUOptions.DiskImage != "" { channel := "virtio" if kola.QEMUOptions.Nvme { diff --git a/mantle/platform/machine/unprivqemu/cluster.go b/mantle/platform/machine/unprivqemu/cluster.go index 3acd6d3f28..af38a5950e 100644 --- a/mantle/platform/machine/unprivqemu/cluster.go +++ b/mantle/platform/machine/unprivqemu/cluster.go @@ -101,7 +101,9 @@ func (qc *Cluster) NewMachineWithQemuOptions(userdata *conf.UserData, options pl builder.ConfigFile = confPath defer builder.Close() builder.UUID = qm.id - builder.Firmware = qc.flight.opts.Firmware + if qc.flight.opts.Firmware != "" { + builder.Firmware = qc.flight.opts.Firmware + } builder.Swtpm = qc.flight.opts.Swtpm builder.Hostname = fmt.Sprintf("qemu%d", qc.BaseCluster.AllocateMachineSerial()) builder.ConsoleFile = qm.consolePath diff --git a/mantle/platform/qemu.go b/mantle/platform/qemu.go index 2088160306..debf0f0cbe 100644 --- a/mantle/platform/qemu.go +++ b/mantle/platform/qemu.go @@ -55,6 +55,10 @@ import ( "golang.org/x/sys/unix" ) +// UefiFirmwareDefault is used on x86_64 and aarch64. In the future +// this may change to be e.g. uefi-secure. +const UefiFirmwareDefault = "uefi" + var ( // ErrInitramfsEmergency is the marker error returned upon node blocking in emergency mode in initramfs. ErrInitramfsEmergency = errors.New("entered emergency.target in initramfs") @@ -448,8 +452,16 @@ type QemuBuilder struct { // NewQemuBuilder creates a new build for QEMU with default settings. func NewQemuBuilder() *QemuBuilder { + var defaultFirmware string + switch coreosarch.CurrentRpmArch() { + case "x86_64", "aarch64": + // Default to UEFI (but not secure boot for now) + defaultFirmware = UefiFirmwareDefault + default: + defaultFirmware = "" + } ret := QemuBuilder{ - Firmware: "bios", + Firmware: defaultFirmware, Swtpm: true, Pdeathsig: true, Argv: []string{}, @@ -1395,8 +1407,8 @@ func (builder *QemuBuilder) Exec() (*QemuInstance, error) { argv = append(argv, "-smp", fmt.Sprintf("%d", builder.Processors)) switch builder.Firmware { - case "bios": - break + case "": + // Nothing to do, use qemu default case "uefi": if err := builder.setupUefi(false); err != nil { return nil, err @@ -1405,8 +1417,12 @@ func (builder *QemuBuilder) Exec() (*QemuInstance, error) { if err := builder.setupUefi(true); err != nil { return nil, err } + case "bios": + if coreosarch.CurrentRpmArch() != "x86_64" { + return nil, fmt.Errorf("unknown firmware: %s", builder.Firmware) + } default: - panic(fmt.Sprintf("Unknown firmware: %s", builder.Firmware)) + return nil, fmt.Errorf("unknown firmware: %s", builder.Firmware) } // We always provide a random source diff --git a/src/cmd-kola b/src/cmd-kola index b9c2bfef29..08448ce085 100755 --- a/src/cmd-kola +++ b/src/cmd-kola @@ -10,7 +10,7 @@ import sys # Just test these boot to start with. In the future we should at least # do ostree upgrades with uefi etc. But we don't really need the *full* # suite...if podman somehow broke with nvme or uefi I'd be amazed and impressed. -BASIC_SCENARIOS = ["nvme=true", "firmware=uefi"] +BASIC_SCENARIOS = ["nvme=true", "firmware=bios"] BASIC_SCENARIOS_SECURE_BOOT = ["firmware=uefi-secure"] arch = platform.machine()