feat: support bootloader option for ISO

Support selecting bootloader option for ISO.

Signed-off-by: Noel Georgi <git@frezbo.dev>

Author: frezbo

internal/app/machined/pkg/runtime/v1alpha1/bootloader/bootloader.go

@@ -83,14 +83,14 @@ func NewAuto() Bootloader {
 // New returns a new bootloader based on the secureboot flag and architecture.
 func New(bootloader, talosVersion, arch string) (Bootloader, error) {
 	switch bootloader {
-	case profile.DiskImageBootloaderGrub.String():
+	case profile.BootLoaderKindGrub.String():
 		g := grub.NewConfig()
 		g.AddResetOption = quirks.New(talosVersion).SupportsResetGRUBOption()
 
 		return g, nil
-	case profile.DiskImageBootloaderSDBoot.String():
+	case profile.BootLoaderKindSDBoot.String():
 		return sdboot.New(), nil
-	case profile.DiskImageBootloaderDualBoot.String():
+	case profile.BootLoaderKindDualBoot.String():
 		return dual.New(), nil
 	default:
 		return nil, fmt.Errorf("unsupported bootloader %q", bootloader)

internal/app/machined/pkg/runtime/v1alpha1/v1alpha1_sequencer.go

@@ -104,7 +104,7 @@ func (*Sequencer) Initialize(r runtime.Runtime) []runtime.Phase {
 					return false
 				}
 
-				return r.State().Machine().Installed() && val == profile.DiskImageBootloaderDualBoot.String()
+				return r.State().Machine().Installed() && val == profile.BootLoaderKindDualBoot.String()
 			},
 			"cleanupBootloader",
 			CleanupBootloader,

pkg/imager/iso/uefi.go

@@ -20,29 +20,6 @@ import (
 	"github.com/siderolabs/talos/pkg/makefs"
 )
 
-// UEFIOptions describe the input for the CreateUEFI function.
-type UEFIOptions struct {
-	UKIPath    string
-	SDBootPath string
-
-	// A value in loader.conf secure-boot-enroll: off, manual, if-safe, force.
-	SDBootSecureBootEnrollKeys string
-
-	// UKISigningCertDer is the DER encoded UKI signing certificate.
-	UKISigningCertDerPath string
-
-	// optional, for auto-enrolling secureboot keys
-	PlatformKeyPath    string
-	KeyExchangeKeyPath string
-	SignatureKeyPath   string
-
-	Arch    string
-	Version string
-
-	ScratchDir string
-	OutPath    string
-}
-
 const (
 	// mib is the size of a megabyte.
 	mib = 1024 * 1024

pkg/imager/out.go

@@ -188,6 +188,43 @@ func (i *Imager) outISO(ctx context.Context, path string, report *reporter.Repor
 		if err != nil {
 			return err
 		}
+	case quirks.New(i.prof.Version).ISOSupportsSettingBootloader():
+		options := iso.Options{
+			KernelPath:    i.prof.Input.Kernel.Path,
+			InitramfsPath: i.initramfsPath,
+			Cmdline:       i.cmdline,
+
+			UKIPath:    i.ukiPath,
+			SDBootPath: i.sdBootPath,
+
+			SDBootSecureBootEnrollKeys: "off",
+
+			Arch:    i.prof.Arch,
+			Version: i.prof.Version,
+
+			ScratchDir: scratchSpace,
+			OutPath:    path,
+		}
+
+		switch i.prof.Output.ISOOptions.Bootloader {
+		case profile.BootLoaderKindDualBoot:
+			generator, err = options.CreateHybrid(printf)
+			if err != nil {
+				return err
+			}
+		case profile.BootLoaderKindSDBoot:
+			generator, err = options.CreateUEFI(printf)
+			if err != nil {
+				return err
+			}
+		case profile.BootLoaderKindGrub:
+			generator, err = options.CreateGRUB(printf)
+			if err != nil {
+				return err
+			}
+		case profile.BootLoaderKindNone:
+			return fmt.Errorf("cannot create ISO with no bootloader")
+		}
 	case quirks.New(i.prof.Version).UseSDBootForUEFI():
 		options := iso.Options{
 			KernelPath:    i.prof.Input.Kernel.Path,
@@ -324,10 +361,10 @@ func (i *Imager) buildImage(ctx context.Context, path string, printf func(string
 
 	if i.prof.Arch == "amd64" && !i.prof.SecureBootEnabled() && quirks.New(i.prof.Version).UseSDBootForUEFI() {
 		// allow overriding the bootloader if provided
-		if i.prof.Output.ImageOptions.Bootloader == profile.DiskImageBootloaderDualBoot {
+		if i.prof.Output.ImageOptions.Bootloader == profile.BootLoaderKindDualBoot {
 			metaContents = append(metaContents, meta.Value{
 				Key:   meta.DiskImageBootloader,
-				Value: profile.DiskImageBootloaderDualBoot.String(),
+				Value: profile.BootLoaderKindDualBoot.String(),
 			})
 		}
 	}

pkg/imager/profile/output.go

@@ -43,7 +43,7 @@ type ImageOptions struct {
 	DiskFormatOptions string `yaml:"diskFormatOptions,omitempty"`
 	// Bootloader is the bootloader to use for the disk image.
 	// If not set, it defaults to dual-boot.
-	Bootloader DiskImageBootloader `yaml:"bootloader"`
+	Bootloader BootloaderKind `yaml:"bootloader,omitempty"`
 }
 
 // ISOOptions describes options for the 'iso' output.
@@ -52,6 +52,9 @@ type ISOOptions struct {
 	//
 	// If not set, it defaults to if-safe.
 	SDBootEnrollKeys SDBootEnrollKeys `yaml:"sdBootEnrollKeys"`
+	// Bootloader is the bootloader to use for the iso image.
+	// If not set, it defaults to dual-boot.
+	Bootloader BootloaderKind `yaml:"bootloader,omitempty"`
 }
 
 // OutputKind is output specification.
@@ -105,53 +108,73 @@ const (
 	SDBootEnrollKeysOff                            // off
 )
 
-// DiskImageBootloader is a bootloader for the disk image.
-type DiskImageBootloader int
+// BootloaderKind is a bootloader for the disk image.
+type BootloaderKind int
 
 const (
-	// DiskImageBootloaderDualBoot is the dual-boot bootloader
+	// BootLoaderKindNone is the zero value.
+	BootLoaderKindNone BootloaderKind = iota // none
+	// BootLoaderKindDualBoot is the dual-boot bootloader.
 	// using sd-boot for UEFI and GRUB for BIOS.
-	DiskImageBootloaderDualBoot DiskImageBootloader = iota // dual-boot
-	// DiskImageBootloaderSDBoot is the sd-boot bootloader.
-	DiskImageBootloaderSDBoot // sd-boot
-	// DiskImageBootloaderGrub is the GRUB bootloader.
-	DiskImageBootloaderGrub // grub
+	BootLoaderKindDualBoot // dual-boot
+	// BootLoaderKindSDBoot is the sd-boot bootloader.
+	BootLoaderKindSDBoot // sd-boot
+	// BootLoaderKindGrub is the GRUB bootloader.
+	BootLoaderKindGrub // grub
 )
 
 // FillDefaults fills default values for the output.
 func (o *Output) FillDefaults(arch, version string, secureboot bool) {
-	if o.Kind == OutKindImage {
+	switch o.Kind { //nolint:exhaustive
+	case OutKindImage:
 		if o.ImageOptions == nil {
 			o.ImageOptions = &ImageOptions{}
 		}
 
-		useSDBoot := quirks.New(version).UseSDBootForUEFI()
-
-		switch {
-		case o.ImageOptions.Bootloader != DiskImageBootloaderDualBoot:
-			// allow user to override bootloader
-		case secureboot:
-			// secureboot is always using sd-boot
-			o.ImageOptions.Bootloader = DiskImageBootloaderSDBoot
-		case arch == "arm64" && useSDBoot:
-			// arm64 always uses sd-boot for Talos >= 1.10
-			o.ImageOptions.Bootloader = DiskImageBootloaderSDBoot
-		case !useSDBoot:
-			// legacy versions of Talos use GRUB for BIOS/UEFI
-			o.ImageOptions.Bootloader = DiskImageBootloaderGrub
-		default:
-			// Default to dual-boot.
-			o.ImageOptions.Bootloader = DiskImageBootloaderDualBoot
-		}
+		o.ImageOptions.Bootloader = o.selectBootloader(o.ImageOptions.Bootloader, arch, version, secureboot)
 
 		ps := quirks.New(version).PartitionSizes()
 
 		// bump default image size for expanded boot
 		o.ImageOptions.DiskSize += int64(ps.GrubBootSize()) - 1000*1024*1024 // 1000 MiB
 
-		if o.ImageOptions.Bootloader == DiskImageBootloaderDualBoot {
+		if o.ImageOptions.Bootloader == BootLoaderKindDualBoot {
 			// add extra space for BIOS and BOOT partitions
 			o.ImageOptions.DiskSize += int64(ps.GrubBIOSSize()) + int64(ps.GrubBootSize())
 		}
+
+	case OutKindISO:
+		if !quirks.New(version).ISOSupportsSettingBootloader() {
+			return
+		}
+
+		if o.ISOOptions == nil {
+			o.ISOOptions = &ISOOptions{}
+		}
+
+		o.ISOOptions.Bootloader = o.selectBootloader(o.ISOOptions.Bootloader, arch, version, secureboot)
+	}
+}
+
+func (o *Output) selectBootloader(current BootloaderKind, arch, version string, secureboot bool) BootloaderKind {
+	useSDBoot := quirks.New(version).UseSDBootForUEFI()
+
+	switch {
+	case secureboot:
+		// secureboot is always using sd-boot
+		return BootLoaderKindSDBoot
+	case arch == "arm64" && useSDBoot:
+		// arm64 always uses sd-boot for Talos >= 1.10
+		return BootLoaderKindSDBoot
+	case !useSDBoot:
+		// legacy versions of Talos use GRUB for BIOS/UEFI
+		return BootLoaderKindGrub
+	default:
+		// Default to dual-boot if not overridden.
+		if current == BootLoaderKindNone {
+			return BootLoaderKindDualBoot
+		}
+
+		return current
 	}
 }