Support for Virt driver

examples/experimental/virt.yaml

@@ -0,0 +1,13 @@
+# A template to run ubuntu using vmType: virt instead of qemu (Default)
+vmType: "virt"
+
+images:
+- location: "https://cloud-images.ubuntu.com/releases/22.04/release/ubuntu-22.04-server-cloudimg-amd64.img"
+  arch: "x86_64"
+- location: "https://cloud-images.ubuntu.com/releases/22.04/release/ubuntu-22.04-server-cloudimg-arm64.img"
+  arch: "aarch64"
+
+mounts:
+- location: "~"
+- location: "/tmp/lima"
+  writable: true

pkg/driverutil/driverutil.go

@@ -2,13 +2,17 @@ package driverutil
 
 import (
 	"github.com/lima-vm/lima/pkg/limayaml"
+	"github.com/lima-vm/lima/pkg/virt"
 	"github.com/lima-vm/lima/pkg/vz"
 	"github.com/lima-vm/lima/pkg/wsl2"
 )
 
 // Drivers returns the available drivers.
 func Drivers() []string {
 	drivers := []string{limayaml.QEMU}
+	if virt.Enabled {
+		drivers = append(drivers, limayaml.VIRT)
+	}
 	if vz.Enabled {
 		drivers = append(drivers, limayaml.VZ)
 	}

pkg/driverutil/instance.go

@@ -4,12 +4,16 @@ import (
 	"github.com/lima-vm/lima/pkg/driver"
 	"github.com/lima-vm/lima/pkg/limayaml"
 	"github.com/lima-vm/lima/pkg/qemu"
+	"github.com/lima-vm/lima/pkg/virt"
 	"github.com/lima-vm/lima/pkg/vz"
 	"github.com/lima-vm/lima/pkg/wsl2"
 )
 
 func CreateTargetDriverInstance(base *driver.BaseDriver) driver.Driver {
 	limaDriver := base.Yaml.VMType
+	if *limaDriver == limayaml.VIRT {
+		return virt.New(base)
+	}
 	if *limaDriver == limayaml.VZ {
 		return vz.New(base)
 	}

pkg/limayaml/defaults.go

@@ -848,6 +848,8 @@ func NewArch(arch string) Arch {
 
 func NewVMType(driver string) VMType {
 	switch driver {
+	case "virt":
+		return VIRT
 	case "vz":
 		return VZ
 	case "qemu":

pkg/limayaml/limayaml.go

@@ -62,6 +62,7 @@ const (
 	WSLMount MountType = "wsl2"
 
 	QEMU VMType = "qemu"
+	VIRT VMType = "virt"
 	VZ   VMType = "vz"
 	WSL2 VMType = "wsl2"
 )

pkg/limayaml/validate.go

@@ -61,8 +61,10 @@ func Validate(y LimaYAML, warn bool) error {
 		if !IsNativeArch(*y.Arch) {
 			return fmt.Errorf("field `arch` must be %q for VZ; got %q", NewArch(runtime.GOARCH), *y.Arch)
 		}
+	case VIRT:
+		// NOP
 	default:
-		return fmt.Errorf("field `vmType` must be %q, %q, %q; got %q", QEMU, VZ, WSL2, *y.VMType)
+		return fmt.Errorf("field `vmType` must be %q, %q, %q, %q; got %q", QEMU, VIRT, VZ, WSL2, *y.VMType)
 	}
 
 	if len(y.Images) == 0 {

pkg/virt/disk.go

@@ -0,0 +1,59 @@
+package virt
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+
+	"github.com/docker/go-units"
+	"github.com/lima-vm/lima/pkg/driver"
+	"github.com/lima-vm/lima/pkg/fileutils"
+	"github.com/lima-vm/lima/pkg/iso9660util"
+	"github.com/lima-vm/lima/pkg/store/filenames"
+)
+
+func EnsureDisk(driver *driver.BaseDriver) error {
+	diffDisk := filepath.Join(driver.Instance.Dir, filenames.DiffDisk)
+	if _, err := os.Stat(diffDisk); err == nil || !errors.Is(err, os.ErrNotExist) {
+		// disk is already ensured
+		return err
+	}
+
+	baseDisk := filepath.Join(driver.Instance.Dir, filenames.BaseDisk)
+	if _, err := os.Stat(baseDisk); errors.Is(err, os.ErrNotExist) {
+		var ensuredBaseDisk bool
+		errs := make([]error, len(driver.Yaml.Images))
+		for i, f := range driver.Yaml.Images {
+			if _, err := fileutils.DownloadFile(baseDisk, f.File, true, "the image", *driver.Yaml.Arch); err != nil {
+				errs[i] = err
+				continue
+			}
+			ensuredBaseDisk = true
+			break
+		}
+		if !ensuredBaseDisk {
+			return fileutils.Errors(errs)
+		}
+	}
+	diskSize, _ := units.RAMInBytes(*driver.Yaml.Disk)
+	if diskSize == 0 {
+		return nil
+	}
+	isBaseDiskISO, err := iso9660util.IsISO9660(baseDisk)
+	if err != nil {
+		return err
+	}
+	args := []string{"create", "-f", "qcow2"}
+	if !isBaseDiskISO {
+		args = append(args, "-b", baseDisk)
+	}
+	args = append(args, diffDisk, strconv.Itoa(int(diskSize)))
+	cmd := exec.Command("qemu-img", args...)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("failed to run %v: %q: %w", cmd.Args, string(out), err)
+	}
+	return nil
+}

pkg/virt/domain.go

@@ -0,0 +1,122 @@
+package virt
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"text/template"
+
+	"github.com/lima-vm/lima/pkg/driver"
+	"github.com/lima-vm/lima/pkg/networks"
+	"github.com/lima-vm/lima/pkg/store/filenames"
+)
+
+type DomainConfig struct {
+	Name            string
+	Memory          int64
+	CPUs            int
+	CIDataPath      string
+	DiskPath        string
+	Interface       string
+	QemuCommandline string
+	Network         string
+	SlirpNetwork    string
+	SlirpIPAddress  string
+	SSHLocalPort    int
+}
+
+const domainXMLTemplate = `<domain type='kvm' xmlns:qemu='http://libvirt.org/schemas/domain/qemu/1.0'>
+  <name>{{.Name}}</name><memory unit='B'>{{.Memory}}</memory>
+  <vcpu>{{.CPUs}}</vcpu>
+  <features><acpi/><apic/></features>
+  <cpu mode='host-passthrough'></cpu>
+  <os firmware='efi'>
+    <type>hvm</type>
+    <boot dev='cdrom'/>
+    <boot dev='hd'/>
+    <bootmenu enable='no'/>
+  </os>
+  <devices>
+    <console type='pty'>
+      <target type='serial'/>
+    </console>
+    <disk type='file' device='cdrom'>
+      <driver name='qemu' type='raw'/>
+      <source file='{{.CIDataPath}}'/>
+      <target dev='hdd' bus='sata'/>
+      <readonly/>
+    </disk>
+    <disk type='file' device='disk'>
+      <driver name='qemu' type='qcow2'/>
+      <source file='{{.DiskPath}}'/>
+      <target dev='vda' bus='virtio'/>
+    </disk>
+<!--
+    <graphics type='vnc' autoport='yes' listen='127.0.0.1'>
+      <listen type='address' address='127.0.0.1'/>
+    </graphics>
+-->
+{{.Interface}}
+  </devices>
+{{.QemuCommandline}}
+</domain>`
+
+const interfaceXMLTemplate = `
+    <interface type='user'>
+      <source network='{{.Network}}'/>
+      <model type='virtio'/>
+    </interface>`
+
+const qemuXMLTemplate = `
+    <qemu:commandline>
+        <qemu:arg value='-netdev'/>
+        <qemu:arg value='user,id=net0,net={{.SlirpNetwork}},dhcpstart={{.SlirpIPAddress}},hostfwd=tcp:127.0.0.1:{{.SSHLocalPort}}-:22'/>
+        <qemu:arg value='-device'/>
+        <qemu:arg value='virtio-net-pci,netdev=net0'/>
+        <qemu:arg value='-device'/>
+        <qemu:arg value='virtio-rng-pci'/>
+    </qemu:commandline>`
+
+func DomainXML(driver *driver.BaseDriver) (string, error) {
+	tmpl, err := template.New("domain").Parse(domainXMLTemplate)
+	if err != nil {
+		return "", err
+	}
+	_ = interfaceXMLTemplate
+	qemu, err := template.New("qemu").Parse(qemuXMLTemplate)
+	if err != nil {
+		return "", err
+	}
+	// baseDisk := filepath.Join(driver.Instance.Dir, filenames.BaseDisk)
+	diffDisk := filepath.Join(driver.Instance.Dir, filenames.DiffDisk)
+	ciDataPath := filepath.Join(driver.Instance.Dir, filenames.CIDataISO)
+	cfg := DomainConfig{
+		Name:       "lima-" + driver.Instance.Name,
+		Memory:     driver.Instance.Memory,
+		CPUs:       driver.Instance.CPUs,
+		CIDataPath: ciDataPath,
+		DiskPath:   diffDisk,
+		// Network:        "lima-" + driver.Instance.Name,
+		SlirpNetwork:   networks.SlirpNetwork,
+		SlirpIPAddress: networks.SlirpIPAddress,
+		SSHLocalPort:   driver.SSHLocalPort,
+	}
+	var buf bytes.Buffer
+	err = qemu.Execute(&buf, cfg)
+	if err != nil {
+		return "", err
+	}
+	cfg.QemuCommandline = buf.String()
+
+	var xml bytes.Buffer
+	err = tmpl.Execute(&xml, cfg)
+	if err != nil {
+		return "", err
+	}
+	domainXML := filepath.Join(driver.Instance.Dir, "domain.xml")
+	err = os.WriteFile(domainXML, xml.Bytes(), 0o644)
+	if err != nil {
+		return "", err
+	}
+	return domainXML, nil
+}

pkg/virt/network.go

@@ -0,0 +1,45 @@
+package virt
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"text/template"
+
+	"github.com/lima-vm/lima/pkg/driver"
+)
+
+type NetworkConfig struct {
+	Name    string
+	Address string
+	Netmask string
+}
+
+const networkXMLTemplate = `<network>
+  <name>{{.Name}}</name>
+  <ip address='{{.Address}}' netmask='{{.Netmask}}'>
+  </ip>
+</network>`
+
+func NetworkXML(driver *driver.BaseDriver) (string, error) {
+	tmpl, err := template.New("network").Parse(networkXMLTemplate)
+	if err != nil {
+		return "", err
+	}
+	cfg := NetworkConfig{
+		Name:    "lima-" + driver.Instance.Name,
+		Address: "192.168.55.15",
+		Netmask: "255.255.255.0",
+	}
+	var xml bytes.Buffer
+	err = tmpl.Execute(&xml, cfg)
+	if err != nil {
+		return "", err
+	}
+	networkXML := filepath.Join(driver.Instance.Dir, "network.xml")
+	err = os.WriteFile(networkXML, xml.Bytes(), 0o644)
+	if err != nil {
+		return "", err
+	}
+	return networkXML, nil
+}

pkg/virt/virt.go

@@ -0,0 +1,36 @@
+package virt
+
+import (
+	"fmt"
+	"os/exec"
+	"regexp"
+)
+
+func Version() (string, error) {
+	out, err := exec.Command("virsh", "version").Output()
+	if err != nil {
+		return "", err
+	}
+	re := regexp.MustCompile("Using library: libvirt (.*)")
+	m := re.FindStringSubmatch(string(out))
+	if m == nil {
+		return "", fmt.Errorf("can't find libvirt version")
+	}
+	return m[1], nil
+}
+
+const connectString = "qemu:///session"
+
+func virsh(args ...string) error {
+	connect := []string{"--connect", connectString}
+	args = append(connect, args...)
+	return exec.Command("virsh", args...).Run()
+}
+
+func CreateNetwork(xml string) error {
+	return virsh("net-create", xml)
+}
+
+func CreateDomain(xml string) error {
+	return virsh("create", xml)
+}