chore: remove qemu kvm requirement

If KVM is not available, log a warning and proceed
without it (instead of a hard error). This is useful
for people who's machine doesn't support KVM.

Signed-off-by: Orzelius <33936483+Orzelius@users.noreply.github.com>

Author: Orzelius

pkg/provision/options.go

@@ -220,6 +220,7 @@ type Options struct {
 	JSONLogsEndpoint string
 
 	SiderolinkEnabled bool
+	UseKvm            bool
 }
 
 // DefaultOptions returns default options.

pkg/provision/providers/factory.go

@@ -12,14 +12,34 @@ import (
 	"github.com/siderolabs/talos/pkg/provision/providers/docker"
 )
 
+const (
+	// QemuProviderName is the name of the qemu provider.
+	QemuProviderName = "qemu"
+	// DockerProviderName is the name of the docker provider.
+	DockerProviderName = "docker"
+)
+
 // Factory instantiates provision provider by name.
 func Factory(ctx context.Context, name string) (provision.Provisioner, error) {
+	if err := IsValidProvider(name); err != nil {
+		return nil, err
+	}
+
 	switch name {
-	case "docker":
+	case DockerProviderName:
 		return docker.NewProvisioner(ctx)
-	case "qemu":
+	case QemuProviderName:
 		return newQemu(ctx)
-	default:
-		return nil, fmt.Errorf("unsupported provisioner %q", name)
 	}
+
+	return nil, nil
+}
+
+// IsValidProvider returns an error if the passed provider doesn't exist.
+func IsValidProvider(name string) error {
+	if name != QemuProviderName && name != DockerProviderName {
+		return fmt.Errorf("unsupported provisioner %q", name)
+	}
+
+	return nil
 }

pkg/provision/providers/qemu/arch.go

@@ -237,27 +237,19 @@ func (arch Arch) TPMDeviceArgs(socketPath string) []string {
 }
 
 // KVMArgs returns arguments for qemu to enable KVM.
-func (arch Arch) KVMArgs(kvmEnabled bool, iommu bool) []string {
-	if !kvmEnabled {
-		return []string{"-machine", arch.QemuMachine()}
+func (arch Arch) getMachineArgs(kvmEnabled bool, iommu bool) []string {
+	args := []string{"-machine", arch.QemuMachine()}
+	if kvmEnabled {
+		args = append(args, ",accel=kvm")
 	}
-
-	machineArg := arch.QemuMachine() + ",accel=kvm"
-
 	// ref: https://wiki.qemu.org/Features/VT-d
 	if iommu {
-		machineArg += ",kernel-irqchip=split"
+		args = append(args, ",kernel-irqchip=split")
 	}
 
-	switch arch {
-	case ArchAmd64:
-		machineArg += ",smm=on"
-
-		return []string{"-machine", machineArg}
-	case ArchArm64:
-		// smm is not supported on aarch64
-		return []string{"-machine", machineArg}
-	default:
-		panic("unsupported architecture")
+	if arch == ArchAmd64 {
+		args = append(args, ",smm=on")
 	}
+
+	return args
 }

pkg/provision/providers/qemu/create.go

@@ -7,6 +7,7 @@ package qemu
 import (
 	"context"
 	"fmt"
+	"os"
 	"path/filepath"
 
 	"github.com/siderolabs/talos/pkg/machinery/constants"
@@ -26,6 +27,16 @@ func (p *provisioner) Create(ctx context.Context, request provision.ClusterReque
 		}
 	}
 
+	kvmErr := checkKVM()
+	if kvmErr != nil {
+		fmt.Println(kvmErr)
+		fmt.Println("running without KVM")
+
+		options.UseKvm = false
+	} else {
+		options.UseKvm = true
+	}
+
 	arch := Arch(options.TargetArch)
 	if !arch.Valid() {
 		return nil, fmt.Errorf("unsupported arch: %q", options.TargetArch)
@@ -148,3 +159,12 @@ func (p *provisioner) Create(ctx context.Context, request provision.ClusterReque
 
 	return state, nil
 }
+
+func checkKVM() error {
+	f, err := os.OpenFile("/dev/kvm", os.O_RDWR, 0)
+	if err != nil {
+		return fmt.Errorf("error opening /dev/kvm, please make sure KVM support is enabled in Linux kernel: %w", err)
+	}
+
+	return f.Close()
+}

pkg/provision/providers/qemu/launch.go

@@ -393,7 +393,7 @@ func launchVM(config *LaunchConfig) error {
 		}
 	}
 
-	args = append(args, config.ArchitectureData.KVMArgs(config.EnableKVM, config.IOMMUEnabled)...)
+	args = append(args, config.ArchitectureData.getMachineArgs(config.EnableKVM, config.IOMMUEnabled)...)
 
 	pflashArgs := make([]string, 2*len(config.PFlashImages))
 	for i := range config.PFlashImages {

pkg/provision/providers/qemu/node.go

@@ -169,7 +169,7 @@ func (p *provisioner) createNode(state *vm.State, clusterReq provision.ClusterRe
 		ExtraISOPath:      extraISOPath,
 		PFlashImages:      pflashImages,
 		MonitorPath:       state.GetRelativePath(fmt.Sprintf("%s.monitor", nodeReq.Name)),
-		EnableKVM:         opts.TargetArch == runtime.GOARCH,
+		EnableKVM:         opts.TargetArch == runtime.GOARCH && opts.UseKvm,
 		BadRTC:            nodeReq.BadRTC,
 		DefaultBootOrder:  defaultBootOrder,
 		BootloaderEnabled: opts.BootloaderEnabled,

pkg/provision/providers/qemu/preflight.go

@@ -31,7 +31,6 @@ func (p *provisioner) preflightChecks(ctx context.Context, request provision.Clu
 
 	for _, check := range []func(ctx context.Context) error{
 		checkContext.verifyRoot,
-		checkContext.checkKVM,
 		checkContext.qemuExecutable,
 		checkContext.checkFlashImages,
 		checkContext.swtpmExecutable,
@@ -61,15 +60,6 @@ func (check *preflightCheckContext) verifyRoot(context.Context) error {
 	return nil
 }
 
-func (check *preflightCheckContext) checkKVM(context.Context) error {
-	f, err := os.OpenFile("/dev/kvm", os.O_RDWR, 0)
-	if err != nil {
-		return fmt.Errorf("error opening /dev/kvm, please make sure KVM support is enabled in Linux kernel: %w", err)
-	}
-
-	return f.Close()
-}
-
 func (check *preflightCheckContext) qemuExecutable(context.Context) error {
 	if check.arch.QemuExecutable() == "" {
 		return fmt.Errorf("QEMU executable (qemu-system-%s or qemu-kvm) not found, please install QEMU with package manager", check.arch.QemuArch())