Support for VBox driver

This is a legacy driver for Oracle VirtualBox, x86_64 only.

It also has support for shared folders and hostonly networks,
but they are not implemented just yet (sshfs and nat only)

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

Author: afbjorklund

pkg/driverutil/instance.go

@@ -7,12 +7,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/vbox"
 	"github.com/lima-vm/lima/pkg/vz"
 	"github.com/lima-vm/lima/pkg/wsl2"
 )
 
 func CreateTargetDriverInstance(base *driver.BaseDriver) driver.Driver {
 	limaDriver := base.Instance.Config.VMType
+	if *limaDriver == limayaml.VBOX {
+		return vbox.New(base)
+	}
 	if *limaDriver == limayaml.VZ {
 		return vz.New(base)
 	}

pkg/instance/start.go

@@ -402,19 +402,31 @@ func prepareDiffDisk(inst *store.Instance) error {
 		return err
 	}
 
-	f, err := os.Open(diffDisk)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
+	var diskSize int64
+	var format string
+	if *inst.Config.VMType != limayaml.VBOX {
+		f, err := os.Open(diffDisk)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
 
-	img, err := qcow2reader.Open(f)
-	if err != nil {
-		return err
-	}
+		img, err := qcow2reader.Open(f)
+		if err != nil {
+			return err
+		}
 
-	diskSize := img.Size()
-	format := string(img.Type())
+		diskSize = img.Size()
+		format = string(img.Type())
+	} else {
+		info, err := imgutil.GetInfo(diffDisk)
+		if err != nil {
+			return err
+		}
+
+		diskSize = info.VSize
+		format = info.Format
+	}
 
 	if inst.Disk == diskSize {
 		return nil

pkg/limayaml/defaults.go

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

pkg/limayaml/limayaml.go

@@ -86,6 +86,7 @@ const (
 	WSLMount MountType = "wsl2"
 
 	QEMU VMType = "qemu"
+	VBOX VMType = "vbox"
 	VZ   VMType = "vz"
 	WSL2 VMType = "wsl2"
 )

pkg/limayaml/validate.go

@@ -84,12 +84,16 @@ func Validate(y *LimaYAML, warn bool) error {
 		// NOP
 	case WSL2:
 		// NOP
+	case VBOX:
+		if *y.Arch != X8664 {
+			return fmt.Errorf("field `arch` must be %q for VBox; got %q", X8664, *y.Arch)
+		}
 	case VZ:
 		if !IsNativeArch(*y.Arch) {
 			return fmt.Errorf("field `arch` must be %q for VZ; got %q", NewArch(runtime.GOARCH), *y.Arch)
 		}
 	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, or %q; got %q", QEMU, VBOX, VZ, WSL2, *y.VMType)
 	}
 
 	if len(y.Images) == 0 {

pkg/qemu/imgutil/imgutil.go

@@ -71,6 +71,11 @@ func (sp *InfoFormatSpecific) Vmdk() *InfoFormatSpecificDataVmdk {
 	return &x
 }
 
+func (sp *InfoFormatSpecific) Vdi() *InfoFormatSpecificDataVdi {
+	var x InfoFormatSpecificDataVdi
+	return &x
+}
+
 type InfoFormatSpecificDataQcow2 struct {
 	Compat          string `json:"compat,omitempty"`           // since QEMU 1.7
 	LazyRefcounts   bool   `json:"lazy-refcounts,omitempty"`   // since QEMU 1.7
@@ -94,6 +99,9 @@ type InfoFormatSpecificDataVmdkExtent struct {
 	ClusterSize int    `json:"cluster-size,omitempty"` // since QEMU 1.7
 }
 
+type InfoFormatSpecificDataVdi struct {
+}
+
 // Info corresponds to the output of `qemu-img info --output=json FILE`.
 type Info struct {
 	Filename              string              `json:"filename,omitempty"`                // since QEMU 1.3
@@ -121,6 +129,18 @@ func ConvertToRaw(source, dest string) error {
 	return nil
 }
 
+func ConvertToVDI(source string, dest string) error {
+	var stdout, stderr bytes.Buffer
+	cmd := exec.Command("qemu-img", "convert", "-O", "vdi", source, dest)
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to run %v: stdout=%q, stderr=%q: %w",
+			cmd.Args, stdout.String(), stderr.String(), err)
+	}
+	return nil
+}
+
 func ParseInfo(b []byte) (*Info, error) {
 	var imgInfo Info
 	if err := json.Unmarshal(b, &imgInfo); err != nil {

pkg/vbox/disk.go

@@ -0,0 +1,93 @@
+package vbox
+
+import (
+	"context"
+	"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/qemu/imgutil"
+	"github.com/lima-vm/lima/pkg/store/filenames"
+)
+
+func EnsureDisk(ctx context.Context, 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.Instance.Config.Images))
+		for i, f := range driver.Instance.Config.Images {
+			if _, err := fileutils.DownloadFile(ctx, baseDisk, f.File, true, "the image", *driver.Instance.Config.Arch); err != nil {
+				errs[i] = err
+				continue
+			}
+			ensuredBaseDisk = true
+			break
+		}
+		if !ensuredBaseDisk {
+			return fileutils.Errors(errs)
+		}
+	}
+	diskSize, _ := units.RAMInBytes(*driver.Instance.Config.Disk)
+	if diskSize == 0 {
+		return nil
+	}
+	//TODO - Break qemu dependency
+	isBaseDiskISO, err := iso9660util.IsISO9660(baseDisk)
+	if err != nil {
+		return err
+	}
+	baseDiskInfo, err := imgutil.GetInfo(baseDisk)
+	if err != nil {
+		return fmt.Errorf("failed to get the information of base disk %q: %w", baseDisk, err)
+	}
+	if err = imgutil.AcceptableAsBasedisk(baseDiskInfo); err != nil {
+		return fmt.Errorf("file %q is not acceptable as the base disk: %w", baseDisk, err)
+	}
+	if baseDiskInfo.Format == "" {
+		return fmt.Errorf("failed to inspect the format of %q", baseDisk)
+	}
+	args := []string{"create", "-f", "qcow2"}
+	if !isBaseDiskISO {
+		args = append(args, "-F", baseDiskInfo.Format, "-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)
+	}
+	if isBaseDiskISO {
+		if err = os.Rename(baseDisk, baseDisk+".iso"); err != nil {
+			return err
+		}
+		if err = os.Symlink(filenames.BaseDisk+".iso", baseDisk); err != nil {
+			return err
+		}
+	} else {
+		if err = os.Rename(baseDisk, baseDisk+".img"); err != nil {
+			return err
+		}
+		if err = os.Symlink(filenames.BaseDisk+".img", baseDisk); err != nil {
+			return err
+		}
+	}
+	if err = imgutil.ConvertToVDI(diffDisk, diffDisk+".vdi"); err != nil {
+		return fmt.Errorf("cannot convert qcow2 to vdi for vbox driver")
+	}
+	if err = os.Remove(diffDisk); err != nil {
+		return err
+	}
+	return os.Symlink(filenames.DiffDisk+".vdi", diffDisk)
+}