Adding Support for building Ubuntu24, eLx12 and AZL3 OS images targeting ARM64 architecture

Author: srmungar

config/osv/edge-microvisor-toolkit/emt3/config.yml

@@ -6,4 +6,11 @@ x86_64:
   arch: x86_64                                      # Target architecture
   pkgType: rpm                                      # Package management system
   chrootenvConfigFile: chrootenvconfigs/chrootenv_x86_64.yml  # Path to chrootenv config
-  releaseVersion: "3.0"                             # Distribution release version
+  releaseVersion: "3.0"                             # Distribution release version
+
+aarch64:
+  dist: emt3                                        # Distribution identifier
+  arch: aarch64                                      # Target architecture
+  pkgType: rpm                                      # Package management system
+  chrootenvConfigFile: chrootenvconfigs/chrootenv_aarch64.yml  # Path to chrootenv config
+  releaseVersion: "3.0"                             # Distribution release version

image-templates/ubuntu24-aarch64-minimal-raw.yml

@@ -56,7 +56,7 @@ disk:
       type: xbootldr
       start: 101MiB
       end: 1024MiB 
-      fsType: vfat
+      fsType: ext4
       mountPoint: /boot
       mountOptions: defaults
 

internal/chroot/chrootenv.go

@@ -572,7 +572,7 @@ func CleanDebName(packageName string) string {
 
 func (chrootEnv *ChrootEnv) AptInstallPackage(packageName, installRoot string, repoSrcList []string) error {
 	packageName = CleanDebName(packageName)
-	installCmd := fmt.Sprintf("apt-get install -y %s", packageName)
+	installCmd := fmt.Sprintf("apt-get install -y --no-install-recommends %s", packageName)
 
 	if len(repoSrcList) > 0 {
 		for _, repoSrc := range repoSrcList {
@@ -587,8 +587,11 @@ func (chrootEnv *ChrootEnv) AptInstallPackage(packageName, installRoot string, r
 		"DEBCONF_NOWARNINGS=yes",
 	}
 
-	if _, err := shell.ExecCmdWithStream(installCmd, true, installRoot, envVars); err != nil {
-		return fmt.Errorf("failed to install package %s: %w", packageName, err)
+	output, err := shell.ExecCmdWithStream(installCmd, true, installRoot, envVars)
+	if err != nil {
+		log.Errorf("Failed to install package %s: %v", packageName, err)
+		log.Errorf("Full apt-get output for %s:\n%s", packageName, output)
+		return fmt.Errorf("failed to install package %s: %w\napt output:\n%s", packageName, err, output)
 	}
 
 	return nil

internal/chroot/deb/installer.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/open-edge-platform/os-image-composer/internal/utils/logger"
@@ -19,12 +20,56 @@ type DebInstallerInterface interface {
 }
 
 type DebInstaller struct {
+	targetArch string
 }
 
 func NewDebInstaller() *DebInstaller {
 	return &DebInstaller{}
 }
 
+func normalizeDebArch(targetArch string) (string, error) {
+	switch targetArch {
+	case "amd64", "x86_64":
+		return "amd64", nil
+	case "arm64", "aarch64":
+		return "arm64", nil
+	default:
+		return "", fmt.Errorf("unsupported architecture: %s", targetArch)
+	}
+}
+
+func normalizeRuntimeArch(goArch string) (string, error) {
+	switch goArch {
+	case "amd64":
+		return "amd64", nil
+	case "arm64":
+		return "arm64", nil
+	default:
+		return "", fmt.Errorf("unsupported host architecture: %s", goArch)
+	}
+}
+
+func (debInstaller *DebInstaller) validateCrossArchDeps(targetArch string) error {
+	hostArch, err := normalizeRuntimeArch(runtime.GOARCH)
+	if err != nil {
+		return err
+	}
+
+	if hostArch == targetArch {
+		return nil
+	}
+
+	hasArchTest, err := shell.IsCommandExist("arch-test", shell.HostPath)
+	if err != nil {
+		return fmt.Errorf("failed to check host dependency 'arch-test' for cross-architecture build (host=%s target=%s): %w", hostArch, targetArch, err)
+	}
+	if !hasArchTest {
+		return fmt.Errorf("cross-architecture build requested (host=%s target=%s) but required host dependency 'arch-test' is missing; install it with: sudo apt-get install -y arch-test", hostArch, targetArch)
+	}
+
+	return nil
+}
+
 func (debInstaller *DebInstaller) cleanupOnSuccess(repoPath string, err *error) {
 	if umountErr := mount.UmountPath(repoPath); umountErr != nil {
 		log.Errorf("Failed to unmount debian local repository: %v", umountErr)
@@ -50,14 +95,12 @@ func (debInstaller *DebInstaller) UpdateLocalDebRepo(repoPath, targetArch string
 		return fmt.Errorf("repository path cannot be empty")
 	}
 
-	switch targetArch {
-	case "amd64", "x86_64":
-		targetArch = "amd64"
-	case "arm64", "aarch64":
-		targetArch = "arm64"
-	default:
-		return fmt.Errorf("unsupported architecture: %s", targetArch)
+	normalizedArch, err := normalizeDebArch(targetArch)
+	if err != nil {
+		return err
 	}
+	targetArch = normalizedArch
+	debInstaller.targetArch = normalizedArch
 
 	metaDataPath := filepath.Join(repoPath,
 		fmt.Sprintf("dists/stable/main/binary-%s", targetArch), "Packages.gz")
@@ -92,6 +135,13 @@ func (debInstaller *DebInstaller) InstallDebPkg(targetOsConfigDir, chrootEnvPath
 		return fmt.Errorf("invalid parameters: chrootEnvPath, chrootPkgCacheDir, and pkgsList cannot be empty")
 	}
 
+	// Prefer the normalized architecture set by UpdateLocalDebRepo.
+	// Fall back to amd64 for defensive compatibility in unit tests.
+	debArch := debInstaller.targetArch
+	if debArch == "" {
+		debArch = "amd64"
+	}
+
 	// from local.list
 	repoPath := "/cdrom/cache-repo"
 	pkgListStr := strings.Join(pkgsList, ",")
@@ -101,6 +151,12 @@ func (debInstaller *DebInstaller) InstallDebPkg(targetOsConfigDir, chrootEnvPath
 		log.Errorf("Local repository config file does not exist: %s", localRepoConfigPath)
 		return fmt.Errorf("local repository config file does not exist: %s", localRepoConfigPath)
 	}
+	suite := detectDebSuiteFromSourcesList(localRepoConfigPath)
+
+	if err := debInstaller.validateCrossArchDeps(debArch); err != nil {
+		log.Errorf("Missing host dependencies for cross-architecture chroot build: %v", err)
+		return err
+	}
 
 	if err := mount.MountPath(chrootPkgCacheDir, repoPath, "--bind"); err != nil {
 		log.Errorf("Failed to mount debian local repository: %v", err)
@@ -129,11 +185,12 @@ func (debInstaller *DebInstaller) InstallDebPkg(targetOsConfigDir, chrootEnvPath
 		"--aptopt=Dpkg::Options::=--force-confdef "+
 		"--aptopt=Dpkg::Options::=--force-confold "+
 		"--aptopt=APT::Get::Assume-Yes=true "+
+		"--architectures=%s "+
 		"--hook-dir=/usr/share/mmdebstrap/hooks/file-mirror-automount "+
 		"--include=%s "+
 		"--verbose --debug "+
-		"-- bookworm %s %s",
-		pkgListStr, chrootEnvPath, localRepoConfigPath)
+		"-- %s %s %s",
+		debArch, pkgListStr, suite, chrootEnvPath, localRepoConfigPath)
 
 	// Set environment variables to ensure non-interactive installation
 	envVars := []string{
@@ -149,3 +206,40 @@ func (debInstaller *DebInstaller) InstallDebPkg(targetOsConfigDir, chrootEnvPath
 
 	return nil
 }
+
+func detectDebSuiteFromSourcesList(sourcesListPath string) string {
+	const defaultSuite = "stable"
+
+	content, err := os.ReadFile(sourcesListPath)
+	if err != nil {
+		log.Warnf("Failed to read local sources list %s, defaulting suite to %s: %v", sourcesListPath, defaultSuite, err)
+		return defaultSuite
+	}
+
+	for _, rawLine := range strings.Split(string(content), "\n") {
+		line := strings.TrimSpace(rawLine)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		fields := strings.Fields(line)
+		if len(fields) < 3 || fields[0] != "deb" {
+			continue
+		}
+
+		idx := 1
+		if strings.HasPrefix(fields[idx], "[") {
+			for idx < len(fields) && !strings.HasSuffix(fields[idx], "]") {
+				idx++
+			}
+			idx++
+		}
+
+		if idx+1 < len(fields) {
+			return fields[idx+1]
+		}
+	}
+
+	log.Warnf("Could not determine suite from %s, defaulting to %s", sourcesListPath, defaultSuite)
+	return defaultSuite
+}

internal/chroot/deb/installer_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 
@@ -419,3 +420,53 @@ func TestInstallDebPkg_RepoPathConstant(t *testing.T) {
 		t.Logf("Got error (expected): %v", err)
 	}
 }
+
+func TestInstallDebPkg_CrossArchMissingArchTest(t *testing.T) {
+	installer := deb.NewDebInstaller()
+	tempDir := t.TempDir()
+
+	configDir := filepath.Join(tempDir, "chrootenvconfigs")
+	if err := os.MkdirAll(configDir, 0700); err != nil {
+		t.Fatalf("Failed to create config directory: %v", err)
+	}
+
+	localListPath := filepath.Join(configDir, "local.list")
+	if err := os.WriteFile(localListPath, []byte("deb file:///cdrom/cache-repo ./"), 0644); err != nil {
+		t.Fatalf("Failed to create local.list file: %v", err)
+	}
+
+	chrootPkgCacheDir := filepath.Join(tempDir, "cache")
+	if err := os.MkdirAll(chrootPkgCacheDir, 0700); err != nil {
+		t.Fatalf("Failed to create cache directory: %v", err)
+	}
+
+	// Pick a target architecture that is different from the runtime architecture.
+	targetArch := "arm64"
+	if runtime.GOARCH == "arm64" {
+		targetArch = "amd64"
+	}
+
+	originalExecutor := shell.Default
+	defer func() { shell.Default = originalExecutor }()
+	mockExpectedOutput := []shell.MockCommand{
+		{Pattern: "dpkg-scanpackages", Output: "override-test\n", Error: nil},
+		{Pattern: "command -v arch-test", Output: "", Error: nil},
+	}
+	shell.Default = shell.NewMockExecutor(mockExpectedOutput)
+
+	if err := installer.UpdateLocalDebRepo(tempDir, targetArch, false); err != nil {
+		t.Fatalf("Failed to set target architecture via UpdateLocalDebRepo: %v", err)
+	}
+
+	err := installer.InstallDebPkg(tempDir, filepath.Join(tempDir, "chroot"), chrootPkgCacheDir, []string{"test-package"})
+	if err == nil {
+		t.Fatal("Expected cross-architecture preflight error for missing arch-test")
+	}
+
+	if !strings.Contains(err.Error(), "arch-test") {
+		t.Fatalf("Expected error to mention arch-test, got: %v", err)
+	}
+	if !strings.Contains(err.Error(), "cross-architecture") {
+		t.Fatalf("Expected cross-architecture error context, got: %v", err)
+	}
+}

internal/chroot/rpm/installer.go

@@ -83,7 +83,7 @@ func (rpmInstaller *RpmInstaller) InstallRpmPkg(targetOs, chrootEnvPath, chrootP
 			return fmt.Errorf("package %s does not exist in cache directory: %w", pkg, err)
 		}
 		log.Infof("Installing package %s in chroot environment", pkg)
-		cmdStr := fmt.Sprintf("rpm -i -v --nodeps --force --root %s --define '_dbpath /var/lib/rpm' %s",
+		cmdStr := fmt.Sprintf("rpm -i -v --nodeps --force --ignorearch --root %s --define '_dbpath /var/lib/rpm' %s",
 			chrootEnvPath, pkgPath)
 		var output string
 		output, err = shell.ExecCmd(cmdStr, true, shell.HostPath, nil)
@@ -157,7 +157,7 @@ func (rpmInstaller *RpmInstaller) updateRpmDB(chrootEnvBuildPath, chrootPkgCache
 
 	for _, rpm := range rpmList {
 		rpmChrootPath := filepath.Join("/packages", rpm)
-		cmdStr := "rpm -i -v --nodeps --force --justdb " + rpmChrootPath
+		cmdStr := "rpm -i -v --nodeps --force --ignorearch --justdb " + rpmChrootPath
 		if _, err := shell.ExecCmdWithStream(cmdStr, true, chrootEnvBuildPath, nil); err != nil {
 			log.Errorf("Failed to update RPM Database for %s in chroot environment: %v", rpm, err)
 			return fmt.Errorf("failed to update RPM Database for %s in chroot environment: %w", rpm, err)