feat: add support for locating systemd-boot files in source (#381)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: Itxaka

internal/cmd/build-uki.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"log/slog"
 	"math"
 	"os"
@@ -145,6 +146,11 @@ var BuildUKICmd = cli.Command{
 			Value: false,
 			Usage: "Use the new cmdline v2 format to generate a multiprofile efi with all the extra cmdlines. This requires systemd-boot 257 or newer.",
 		},
+		&cli.BoolFlag{
+			Name:  "sdboot-in-source",
+			Value: false,
+			Usage: "Try to find systemd-boot files in the source rootfs instead of using the bundled ones.",
+		},
 	},
 	Before: func(ctx *cli.Context) error {
 		// // Mark flags as mutually exclusive
@@ -238,6 +244,7 @@ var BuildUKICmd = cli.Command{
 		if ctx.Bool("debug") {
 			logLevel = "debug"
 		}
+
 		logger := sdkTypes.NewKairosLogger("auroraboot", logLevel, false)
 
 		// TODO: Get rid of "configs".
@@ -337,37 +344,64 @@ var BuildUKICmd = cli.Command{
 			GetUkiCmdline(extendCmdline, boodBranding, extraCmdlines, cmdLinesV2),
 			GetUkiSingleCmdlines(boodBranding, singleEfiCmdlines, logger)...)
 
-		for _, entry := range entries {
-			logger.Info(fmt.Sprintf("Running ukify for cmdline: %s: %s", entry.Title, entry.Cmdline))
-
-			logger.Infof("Generating: %s.efi", entry.FileName)
-
-			// New ukifier !!
-			// Create Builder instance
-			stub, err := getEfiStub(config.Arch)
+		var stub, systemdBoot, outputSystemdBootEfi string
+		// Get sdboot files from source if requested
+		if ctx.Bool("sdboot-in-source") {
+			if utils.IsAmd64(config.Arch) {
+				// Find the stub and systemd-boot in source dir
+				stub, err = FindFirstFileInDir(sourceDir, constants.UkiSystemdBootStubx86Name)
+				if err != nil {
+					return fmt.Errorf("finding systemd-boot stub in source: %w", err)
+				}
+				systemdBoot, err = FindFirstFileInDir(sourceDir, constants.UkiSystemdBootx86Name)
+				if err != nil {
+					return fmt.Errorf("finding systemd-boot in source: %w", err)
+				}
+				outputSystemdBootEfi = constants.EfiFallbackNamex86
+			} else if utils.IsArm64(config.Arch) {
+				// Find the stub and systemd-boot in source dir
+				stub, err = FindFirstFileInDir(sourceDir, constants.UkiSystemdBootStubArmName)
+				if err != nil {
+					return fmt.Errorf("finding systemd-boot stub in source: %w", err)
+				}
+				systemdBoot, err = FindFirstFileInDir(sourceDir, constants.UkiSystemdBootArmName)
+				if err != nil {
+					return fmt.Errorf("finding systemd-boot in source: %w", err)
+				}
+				outputSystemdBootEfi = constants.EfiFallbackNameArm
+			}
+		} else {
+			// Fallback to bundled files
+			stub, err = getEfiStub(config.Arch)
 			if err != nil {
 				return err
 			}
 			// Get systemd-boot info (we can sign it at the same time)
-			var systemdBoot string
-			var outputSystemdBootEfi string
 			if utils.IsAmd64(config.Arch) {
-				systemdBoot = constants.UkiSystemdBootx86
+				systemdBoot = constants.UkiSystemdBootx86Path
 				outputSystemdBootEfi = constants.EfiFallbackNamex86
 			} else if utils.IsArm64(config.Arch) {
-				systemdBoot = constants.UkiSystemdBootArm
+				systemdBoot = constants.UkiSystemdBootArmPath
 				outputSystemdBootEfi = constants.EfiFallbackNameArm
 			} else {
 				return fmt.Errorf("unsupported arch: %s", config.Arch)
 			}
+		}
+
+		for _, entry := range entries {
+			logger.Info(fmt.Sprintf("Running ukify for cmdline: %s: %s", entry.Title, entry.Cmdline))
+
+			logger.Infof("Generating: %s.efi", entry.FileName)
+
+			// New ukifier !!
+			// Create Builder instance
 
 			if logger.GetLevel().String() == "debug" {
 				slog.SetLogLoggerLevel(slog.LevelDebug)
 			}
 			builder := &uki.Builder{
 				Arch:          config.Arch,
 				Version:       kairosVersion,
-				SdStubPath:    stub,
 				KernelPath:    filepath.Join(artifactsTempDir, "vmlinuz"),
 				InitrdPath:    filepath.Join(artifactsTempDir, "initrd"),
 				Cmdline:       entry.Cmdline,
@@ -377,6 +411,7 @@ var BuildUKICmd = cli.Command{
 				SBKey:         ctx.String("sb-key"),
 				SBCert:        ctx.String("sb-cert"),
 				SdBootPath:    systemdBoot,
+				SdStubPath:    stub,
 				OutSdBootPath: outputSystemdBootEfi,
 				Splash:        ctx.String("splash"),
 			}
@@ -501,13 +536,13 @@ func checkBuildUKIDeps(arch string) error {
 func getEfiNeededFiles(arch string) ([]string, error) {
 	if utils.IsAmd64(arch) {
 		return []string{
-			constants.UkiSystemdBootStubx86,
-			constants.UkiSystemdBootx86,
+			constants.UkiSystemdBootStubx86Path,
+			constants.UkiSystemdBootx86Path,
 		}, nil
 	} else if utils.IsArm64(arch) {
 		return []string{
-			constants.UkiSystemdBootStubArm,
-			constants.UkiSystemdBootArm,
+			constants.UkiSystemdBootStubArmPath,
+			constants.UkiSystemdBootArmPath,
 		}, nil
 	} else {
 		return nil, fmt.Errorf("unsupported arch: %s", arch)
@@ -559,9 +594,17 @@ func setupDirectoriesAndFiles(workDir string) error {
 }
 
 func copyKernel(sourceDir, targetDir string) error {
-	linkTarget, err := os.Readlink(filepath.Join(sourceDir, "boot", "vmlinuz"))
-	if err != nil {
-		return err
+	// Check if its a symlink or a file
+	kernel := filepath.Join(sourceDir, "boot", "vmlinuz")
+
+	var linkTarget string
+	var err error
+
+	if linkTarget, err = os.Readlink(kernel); err == nil {
+		// It's a symlink, linkTarget now contains the symlink target
+	} else {
+		// It's not a symlink, use the kernel file directly
+		linkTarget = kernel
 	}
 
 	kernelFile := filepath.Base(linkTarget)
@@ -702,9 +745,9 @@ func ZstdFile(sourcePath, targetPath string) error {
 
 func getEfiStub(arch string) (string, error) {
 	if utils.IsAmd64(arch) {
-		return constants.UkiSystemdBootStubx86, nil
+		return constants.UkiSystemdBootStubx86Path, nil
 	} else if utils.IsArm64(arch) {
-		return constants.UkiSystemdBootStubArm, nil
+		return constants.UkiSystemdBootStubArmPath, nil
 	} else {
 		return "", nil
 	}
@@ -1128,3 +1171,35 @@ func NameFromCmdline(basename, cmdline string) string {
 
 	return finalName
 }
+
+// FindFirstFileInDir finds the first file matching the pattern in the given directory.
+// It walks over any subdirectories as well.
+// It returns as soon as it finds the first match.
+// It returns the full path to the file if found, or an error if not found or any other error occurs.
+func FindFirstFileInDir(dir, pattern string) (string, error) {
+	var foundFile string
+	err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if !d.IsDir() {
+			matched, err := filepath.Match(pattern, d.Name())
+			if err != nil {
+				return err
+			}
+			if matched {
+				foundFile = path
+				return filepath.SkipAll // Stop walking once we found the file
+			}
+
+		}
+		return nil
+	})
+	if err != nil {
+		return "", err
+	}
+	if foundFile == "" {
+		return "", fmt.Errorf("no file matching pattern %s found in directory %s", pattern, dir)
+	}
+	return foundFile, nil
+}

pkg/constants/constants.go

@@ -80,12 +80,16 @@ const (
 	ArchAmd64   = "amd64"
 	Archaarch64 = "aarch64"
 
-	UkiCmdline            = "console=ttyS0 console=tty1 net.ifnames=1 rd.immucore.oemlabel=COS_OEM rd.immucore.oemtimeout=2 rd.immucore.uki selinux=0 panic=5 rd.shell=0 systemd.crash_reboot=yes"
-	UkiCmdlineInstall     = "install-mode"
-	UkiSystemdBootx86     = "/amd/systemd-boot/systemd-bootx64.efi"
-	UkiSystemdBootStubx86 = "/amd/systemd-boot/linuxx64.efi.stub"
-	UkiSystemdBootArm     = "/arm/systemd-boot/systemd-bootaa64.efi"
-	UkiSystemdBootStubArm = "/arm/systemd-boot/linuxaa64.efi.stub"
+	UkiCmdline                = "console=ttyS0 console=tty1 net.ifnames=1 rd.immucore.oemlabel=COS_OEM rd.immucore.oemtimeout=2 rd.immucore.uki selinux=0 panic=5 rd.shell=0 systemd.crash_reboot=yes"
+	UkiCmdlineInstall         = "install-mode"
+	UkiSystemdBootx86Name     = "systemd-bootx64.efi"
+	UkiSystemdBootx86Path     = "/amd/systemd-boot/" + UkiSystemdBootx86Name
+	UkiSystemdBootStubx86Name = "linuxx64.efi.stub"
+	UkiSystemdBootStubx86Path = "/amd/systemd-boot/" + UkiSystemdBootStubx86Name
+	UkiSystemdBootArmName     = "systemd-bootaa64.efi"
+	UkiSystemdBootArmPath     = "/arm/systemd-boot/" + UkiSystemdBootArmName
+	UkiSystemdBootStubArmName = "linuxaa64.efi.stub"
+	UkiSystemdBootStubArmPath = "/arm/systemd-boot/" + UkiSystemdBootStubArmName
 
 	EfiFallbackNamex86 = "BOOTX64.EFI"
 	EfiFallbackNameArm = "BOOTAA64.EFI"