Check qemu version in hostagent so not too old

This is mostly to give better error messages, when failing.
The old error would just say that it exited unexpectedly...

If the version can't be parsed, show a warning and continue.
We only want to warn about the versions known not to work.

Signed-off-by: Anders F Björklund <[email protected]>

Author: afbjorklund

pkg/qemu/qemu.go

@@ -9,6 +9,7 @@ import (
 	"os/exec"
 	"os/user"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strconv"
 	"strings"
@@ -36,6 +37,9 @@ type Config struct {
 	SSHLocalPort int
 }
 
+// MinimumQemuVersion is the minimum supported QEMU version
+const MinimumQemuVersion = "4.0.0"
+
 // EnsureDisk also ensures the kernel and the initrd
 func EnsureDisk(cfg Config) error {
 	diffDisk := filepath.Join(cfg.InstanceDir, filenames.DiffDisk)
@@ -341,6 +345,16 @@ func Cmdline(cfg Config) (string, []string, error) {
 		return "", nil, err
 	}
 
+	version, err := getQemuVersion(exe)
+	if err != nil {
+		logrus.WithError(err).Warning("Failed to detect QEMU version")
+	} else {
+		logrus.Debugf("QEMU version %s detected", version.String())
+		if version.LessThan(*semver.New(MinimumQemuVersion)) {
+			logrus.Fatalf("QEMU %v is too old, %v or later required", version, MinimumQemuVersion)
+		}
+	}
+
 	// Architecture
 	accel := getAccel(*y.Arch)
 	if !strings.Contains(string(features.AccelHelp), accel) {
@@ -717,6 +731,31 @@ func getAccel(arch limayaml.Arch) string {
 	return "tcg"
 }
 
+func parseQemuVersion(output string) (*semver.Version, error) {
+	lines := strings.Split(output, "\n")
+	regex := regexp.MustCompile(`^QEMU emulator version (\d+\.\d+\.\d+)`)
+	matches := regex.FindStringSubmatch(lines[0])
+	if len(matches) == 2 {
+		return semver.New(matches[1]), nil
+	}
+	return &semver.Version{}, fmt.Errorf("failed to parse %v", output)
+}
+
+func getQemuVersion(qemuExe string) (*semver.Version, error) {
+	var (
+		stdout bytes.Buffer
+		stderr bytes.Buffer
+	)
+	cmd := exec.Command(qemuExe, "--version")
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("failed to run %v: stdout=%q, stderr=%q", cmd.Args, stdout.String(), stderr.String())
+	}
+
+	return parseQemuVersion(stdout.String())
+}
+
 func getFirmware(qemuExe string, arch limayaml.Arch) (string, error) {
 	switch arch {
 	case limayaml.X8664, limayaml.AARCH64:

pkg/qemu/qemu_test.go

@@ -47,3 +47,42 @@ func TestArgValue(t *testing.T) {
 		assert.Equal(t, tc.expectedOK, ok)
 	}
 }
+
+func TestParseQemuVersion(t *testing.T) {
+	type testCase struct {
+		versionOutput string
+		expectedValue string
+		expectedError string
+	}
+	testCases := []testCase{
+		{
+			// old one line version
+			versionOutput: "QEMU emulator version 1.5.3 (qemu-kvm-1.5.3-175.el7_9.6), " +
+				"Copyright (c) 2003-2008 Fabrice Bellard\n",
+			expectedValue: "1.5.3",
+			expectedError: "",
+		},
+		{
+			// new two line version
+			versionOutput: "QEMU emulator version 8.0.0 (v8.0.0)\n" +
+				"Copyright (c) 2003-2022 Fabrice Bellard and the QEMU Project developers\n",
+			expectedValue: "8.0.0",
+			expectedError: "",
+		},
+		{
+			versionOutput: "foobar",
+			expectedValue: "0.0.0",
+			expectedError: "failed to parse",
+		},
+	}
+
+	for _, tc := range testCases {
+		v, err := parseQemuVersion(tc.versionOutput)
+		if tc.expectedError == "" {
+			assert.NilError(t, err)
+		} else {
+			assert.ErrorContains(t, err, tc.expectedError)
+		}
+		assert.Equal(t, tc.expectedValue, v.String())
+	}
+}