feat: run the steps of another architecture through the host's qemu-user-static (#52)

* feat: register an emulator under its own name

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: karo <karolin.kostial@gmail.com>

* feat: run the steps of another architecture through the host's qemu-user-static

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: karo <karolin.kostial@gmail.com>

* build: recommend qemu-user-static

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: karo <karolin.kostial@gmail.com>

* feat: refuse an emulator the builder VM cannot run, naming where it is from

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: karo <karolin.kostial@gmail.com>

---------

Signed-off-by: karo <karolin.kostial@gmail.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: The127

.goreleaser.yaml

@@ -48,11 +48,13 @@ nfpms:
           - qemu-system-x86
         recommends:
           - qemu-system-arm
+          - qemu-user-static
       rpm:
         dependencies:
           - qemu-system-x86-core
         recommends:
           - qemu-system-aarch64-core
+          - qemu-user-static-aarch64
   - id: arm64
     ids: [arm64]
     package_name: miso
@@ -72,11 +74,13 @@ nfpms:
           - qemu-system-arm
         recommends:
           - qemu-system-x86
+          - qemu-user-static
       rpm:
         dependencies:
           - qemu-system-aarch64-core
         recommends:
           - qemu-system-x86-core
+          - qemu-user-static-x86
 
 checksum:
   name_template: checksums.txt

arch-go.yml

@@ -452,16 +452,14 @@ dependenciesRules:
         - os/exec
         - net
         - syscall
-  # the emulator takes miso's pinned qemu-user package apart into what runs
-  # the programs of an image of another architecture. It has the download
-  # fetch the package, and never starts a process, opens a connection or
-  # touches the kernel
+  # the emulator finds the host's QEMU that runs the programs of an image of
+  # another architecture. It knows nothing of ours, and never starts a
+  # process, opens a connection or touches the kernel
   - package: '**.internal.emulator$'
-    shouldOnlyDependsOn:
-      internal:
-        - '**.internal.deb$'
-        - '**.internal.download$'
     shouldNotDependsOn:
+      internal:
+        - '**.internal.**'
+        - '**.cmd.**'
       standard:
         - os/exec
         - net

cmd/miso/arch_test.go

@@ -1,16 +1,12 @@
 package main_test
 
 import (
-	"context"
-	"errors"
-	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	main "github.com/The127/miso/cmd/miso"
-	"github.com/The127/miso/internal/download"
 )
 
 func TestAHostMisoDoesNotBuildOnIsRefusedNamingItAndWhereMisoBuilds(t *testing.T) {
@@ -23,24 +19,14 @@ func TestAHostMisoDoesNotBuildOnIsRefusedNamingItAndWhereMisoBuilds(t *testing.T
 	assert.ErrorContains(t, err, "amd64 and arm64")
 }
 
-func TestABuildForTheBuildersOwnArchitectureFetchesNoEmulator(t *testing.T) {
+func TestABuildForTheBuildersOwnArchitectureNeedsNoEmulator(t *testing.T) {
 	// arrange
-	offline := &http.Client{Transport: roundTrip(func(*http.Request) (*http.Response, error) {
-		return nil, errors.New("offline")
-	})}
-	store := download.Open(t.TempDir(), offline)
+	t.Setenv("PATH", t.TempDir())
 
 	// act
-	emulators, err := main.EmulatorsFor(context.Background(), store, main.BuilderArch)
+	emulators, err := main.EmulatorsFor(main.BuilderArch)
 
 	// assert
 	require.NoError(t, err)
 	assert.Empty(t, emulators)
 }
-
-// roundTrip is an HTTP transport that is a function.
-type roundTrip func(*http.Request) (*http.Response, error)
-
-func (f roundTrip) RoundTrip(request *http.Request) (*http.Response, error) {
-	return f(request)
-}

cmd/miso/vm.go

@@ -38,17 +38,17 @@ func hostRefusal(host string) error {
 
 // emulatorsFor are what the builder VM needs to run the programs of a build
 // for target, nothing for a build of its own architecture.
-func emulatorsFor(ctx context.Context, blobs *download.Store, target string) ([]initramfs.Emulator, error) {
+func emulatorsFor(target string) ([]initramfs.Emulator, error) {
 	if target == builderArch {
 		return nil, nil
 	}
 
-	program, err := emulator.Ready(ctx, blobs, builderArch, target)
+	from, program, err := emulator.Host(target)
 	if err != nil {
 		return nil, err
 	}
 
-	return []initramfs.Emulator{{Arch: target, Program: program}}, nil
+	return []initramfs.Emulator{{Arch: target, From: from, Program: program}}, nil
 }
 
 // bootFiles writes the builder kernel and an initramfs with this very miso
@@ -60,7 +60,7 @@ func bootFiles(ctx context.Context, blobs *download.Store, target string) (build
 		return builder.Boot{}, err
 	}
 
-	emulators, err := emulatorsFor(ctx, blobs, target)
+	emulators, err := emulatorsFor(target)
 	if err != nil {
 		return builder.Boot{}, err
 	}

internal/boot/emulators.go

@@ -9,8 +9,7 @@ import (
 )
 
 // magics are what the header of a program of an architecture looks like to
-// binfmt_misc, and the mask it is compared under, as Debian's qemu-user
-// registers them.
+// binfmt_misc, and the mask it is compared under, as QEMU registers them.
 var magics = map[string]struct{ magic, mask string }{
 	"amd64": {
 		magic: `\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x3e\x00`,
@@ -55,9 +54,8 @@ const binfmtMisc = "/proc/sys/fs/binfmt_misc"
 
 // register has each emulator in dir, named by its architecture, run the
 // programs of that architecture, through a write of its binfmt_misc entry.
-// Debian's QEMU keeps a program's argv[0] only when its own name ends in
-// -binfmt-P, so it is registered through a link of that name. F opens it
-// right away, so it runs in the root of a run too.
+// P has the kernel tell QEMU to keep a program's argv[0]. F opens it right
+// away, so it runs in the root of a run too.
 func register(dir string, write func(entry string) error) error {
 	found, err := os.ReadDir(dir)
 	if err != nil {
@@ -71,12 +69,8 @@ func register(dir string, write func(entry string) error) error {
 			return fmt.Errorf("no binfmt_misc entry for an emulator of %s", arch)
 		}
 
-		link := filepath.Join(dir, arch+"-binfmt-P")
-		if err := os.Symlink(arch, link); err != nil {
-			return err
-		}
-
-		if err := write(fmt.Sprintf(":%s:M::%s:%s:%s:OPF", arch, magic.magic, magic.mask, link)); err != nil {
+		program := filepath.Join(dir, arch)
+		if err := write(fmt.Sprintf(":%s:M::%s:%s:%s:OPF", arch, magic.magic, magic.mask, program)); err != nil {
 			return err
 		}
 	}

internal/boot/emulators_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/The127/miso/internal/boot"
 )
 
-func TestAnArm64EmulatorIsRegisteredAsDebianRegistersQEMUForAArch64(t *testing.T) {
+func TestAnArm64EmulatorIsRegisteredToKeepTheNameOfTheProgramItRuns(t *testing.T) {
 	// arrange
 	dir := t.TempDir()
 	require.NoError(t, os.WriteFile(filepath.Join(dir, "arm64"), []byte("qemu"), 0o600))
@@ -27,11 +27,11 @@ func TestAnArm64EmulatorIsRegisteredAsDebianRegistersQEMUForAArch64(t *testing.T
 	// assert
 	require.NoError(t, err)
 	assert.Equal(t, []string{
-		`:arm64:M::\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\xb7\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:` + filepath.Join(dir, "arm64-binfmt-P") + `:OPF`,
+		`:arm64:M::\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\xb7\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:` + filepath.Join(dir, "arm64") + `:OPF`,
 	}, written)
 }
 
-func TestAnAmd64EmulatorIsRegisteredAsDebianRegistersQEMUForX86_64(t *testing.T) {
+func TestAnAmd64EmulatorIsRegisteredToKeepTheNameOfTheProgramItRuns(t *testing.T) {
 	// arrange
 	dir := t.TempDir()
 	require.NoError(t, os.WriteFile(filepath.Join(dir, "amd64"), []byte("qemu"), 0o600))
@@ -47,7 +47,7 @@ func TestAnAmd64EmulatorIsRegisteredAsDebianRegistersQEMUForX86_64(t *testing.T)
 	// assert
 	require.NoError(t, err)
 	assert.Equal(t, []string{
-		`:amd64:M::\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x3e\x00:\xff\xff\xff\xff\xff\xfe\xfe\xfc\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:` + filepath.Join(dir, "amd64-binfmt-P") + `:OPF`,
+		`:amd64:M::\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x3e\x00:\xff\xff\xff\xff\xff\xfe\xfe\xfc\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:` + filepath.Join(dir, "amd64") + `:OPF`,
 	}, written)
 }
 

internal/builder/boot_test.go

@@ -51,7 +51,7 @@ func TestTheBootFilesHoldTheEmulatorOfTheArchitectureTheBuildIsFor(t *testing.T)
 	// arrange
 	kernel := builderkernel.Kernel{Image: []byte("the kernel")}
 	init := static(t)
-	emulator := initramfs.Emulator{Arch: "arm64", Program: []byte("qemu")}
+	emulator := initramfs.Emulator{Arch: "arm64", From: "/usr/bin/qemu-aarch64-static", Program: static(t)}
 	var want bytes.Buffer
 	require.NoError(t, initramfs.Write(&want, "amd64", init, nil, emulator))
 

internal/emulator/doc.go

@@ -1,4 +1,4 @@
-// Package emulator readies the QEMU that runs the programs of an image of
-// another architecture than the builder VM's: it takes the pinned Debian
-// qemu-user package of the builder's architecture apart.
+// Package emulator finds the host's QEMU that runs the programs of an image
+// of another architecture than the builder VM's. The package manager keeps
+// it up to date, not miso.
 package emulator

internal/emulator/export_test.go

@@ -0,0 +1,32 @@
+package emulator
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// statics are what qemu-user-static calls the program that runs the
+// programs of an architecture, on Debian, Fedora and Arch alike.
+var statics = map[string]string{
+	"amd64": "qemu-x86_64-static",
+	"arm64": "qemu-aarch64-static",
+}
+
+// Host is the host's QEMU that runs the programs of target, found on PATH,
+// and where it was found.
+func Host(target string) (string, []byte, error) {
+	name, known := statics[target]
+	if !known {
+		return "", nil, fmt.Errorf("miso has no QEMU that runs programs of %s", target)
+	}
+
+	for _, dir := range filepath.SplitList(os.Getenv("PATH")) {
+		path := filepath.Join(dir, name)
+		if found, err := os.ReadFile(path); err == nil { //nolint:gosec // the user's PATH is where their QEMU is
+			return path, found, nil
+		}
+	}
+
+	return "", nil, fmt.Errorf("a build for %s runs its steps through %s, which the qemu-user-static package installs", target, name)
+}