Add rosetta support

doc/usage.md

@@ -214,6 +214,38 @@ The share can be mounted in the guest with `mount -t virtiofs vfkitTag /mnt`, wi
 #### Example
 `--device virtio-fs,sharedDir=/Users/virtuser/vfkit/,mountTag=vfkit-share`
 
+### Rosetta
+
+#### Description
+
+The `-device rosetta` option allows to use Rosetta to run x86_64 binaries in an arm64 linux VM. This option will share a directory containing the rosetta binaries over virtio-fs.
+The share can be mounted in the guest with `mount -t virtiofs vfkitTag /mnt`, with `vfkitTag` corresponding to the value of the `mountTag` option.
+Then, [`binfmt`](https://docs.kernel.org/admin-guide/binfmt-misc.html) needs to be configured to use this rosetta binary for x86_64 executables.
+On systems using systemd, this can be achieved by creating a /etc/binfmt.d/rosetta.conf file with this content (`/mnt/rosetta` is the full path to the rosetta binary):
+```
+:rosetta:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x3e\x00:\xff\xff\xff\xff\xff\xfe\xfe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/mnt/rosetta:F
+```
+and then running `systemctl restart systemd-binfmt`.
+
+This option is only available on machine with Apple CPUs, `vfkit` will fail with an error if it's used on Intel machines.
+
+See https://developer.apple.com/documentation/virtualization/running_intel_binaries_in_linux_vms_with_rosetta?language=objc for more details.
+
+
+#### Arguments
+- `mountTag`: tag which will be used to mount the rosetta share in the guest.
+- `install`: indicates to automatically install rosetta on systems where it's missing. By default, an error will be reported if `--device rosetta` is used when rosetta is not installed.
+
+#### Example
+
+This adds rosetta support to the guest:
+```
+--device rosetta,mountTag=rosetta-share
+```
+
+The share can then be mounted with `mount -t virtiofs rosetta-share /mnt`.
+
+
 ### GPU
 
 #### Description

pkg/config/json.go

@@ -25,6 +25,7 @@ const (
 	vfGpu          vmComponentKind = "virtiogpu"
 	vfInput        vmComponentKind = "virtioinput"
 	usbMassStorage vmComponentKind = "usbmassstorage"
+	rosetta        vmComponentKind = "rosetta"
 )
 
 type jsonKind struct {
@@ -112,6 +113,10 @@ func unmarshalDevice(rawMsg json.RawMessage) (VirtioDevice, error) {
 		var newDevice VirtioFs
 		err = json.Unmarshal(rawMsg, &newDevice)
 		dev = &newDevice
+	case rosetta:
+		var newDevice RosettaShare
+		err = json.Unmarshal(rawMsg, &newDevice)
+		dev = &newDevice
 	case vfRng:
 		var newDevice VirtioRng
 		err = json.Unmarshal(rawMsg, &newDevice)
@@ -253,6 +258,17 @@ func (dev *VirtioFs) MarshalJSON() ([]byte, error) {
 	})
 }
 
+func (dev *RosettaShare) MarshalJSON() ([]byte, error) {
+	type devWithKind struct {
+		jsonKind
+		RosettaShare
+	}
+	return json.Marshal(devWithKind{
+		jsonKind:     kind(rosetta),
+		RosettaShare: *dev,
+	})
+}
+
 func (dev *VirtioRng) MarshalJSON() ([]byte, error) {
 	type devWithKind struct {
 		jsonKind

pkg/config/json_test.go

@@ -106,10 +106,15 @@ var jsonTests = map[string]jsonTest{
 			require.NoError(t, err)
 			err = vm.AddDevice(dev)
 			require.NoError(t, err)
+			// rosetta
+			dev, err = RosettaShareNew("vz-rosetta")
+			require.NoError(t, err)
+			err = vm.AddDevice(dev)
+			require.NoError(t, err)
 
 			return vm
 		},
-		expectedJSON: `{"vcpus":3,"memoryBytes":4000000000,"bootloader":{"kind":"linuxBootloader","VmlinuzPath":"/vmlinuz","KernelCmdLine":"/initrd","InitrdPath":"console=hvc0"},"devices":[{"kind":"virtioserial","LogFile":"/virtioserial","UsesStdio":false},{"kind":"virtioinput","inputType":"keyboard"},{"kind":"virtiogpu","usesGUI":false,"width":800,"height":600},{"kind":"virtionet","Nat":true,"MacAddress":"ABEiM0RV","Socket":null,"UnixSocketPath":""},{"kind":"virtiorng"},{"kind":"virtioblk","DevName":"virtio-blk","ImagePath":"/virtioblk","ReadOnly":false,"DeviceIdentifier":""},{"kind":"virtiosock","Port":1234,"SocketURL":"/virtiovsock","Listen":false},{"kind":"virtiofs","SharedDir":"/virtiofs","MountTag":"tag"},{"kind":"usbmassstorage","DevName":"usb-mass-storage","ImagePath":"/usbmassstorage","ReadOnly":false}]}`,
+		expectedJSON: `{"vcpus":3,"memoryBytes":4000000000,"bootloader":{"kind":"linuxBootloader","VmlinuzPath":"/vmlinuz","KernelCmdLine":"/initrd","InitrdPath":"console=hvc0"},"devices":[{"kind":"virtioserial","LogFile":"/virtioserial","UsesStdio":false},{"kind":"virtioinput","inputType":"keyboard"},{"kind":"virtiogpu","usesGUI":false,"width":800,"height":600},{"kind":"virtionet","Nat":true,"MacAddress":"ABEiM0RV","Socket":null,"UnixSocketPath":""},{"kind":"virtiorng"},{"kind":"virtioblk","DevName":"virtio-blk","ImagePath":"/virtioblk","ReadOnly":false,"DeviceIdentifier":""},{"kind":"virtiosock","Port":1234,"SocketURL":"/virtiovsock","Listen":false},{"kind":"virtiofs","MountTag":"tag","SharedDir":"/virtiofs"},{"kind":"usbmassstorage","DevName":"usb-mass-storage","ImagePath":"/usbmassstorage","ReadOnly":false},{"kind":"rosetta","MountTag":"vz-rosetta","InstallRosetta":false}]}`,
 	},
 }
 
@@ -160,7 +165,7 @@ func testJSON(t *testing.T, test *jsonTest) {
 	vm := test.newVM(t)
 	data, err := json.Marshal(vm)
 	require.NoError(t, err)
-	require.Equal(t, test.expectedJSON, string(data))
+	require.JSONEq(t, test.expectedJSON, string(data))
 
 	var unmarshalledVM VirtualMachine
 	err = json.Unmarshal([]byte(test.expectedJSON), &unmarshalledVM)

pkg/config/virtio.go

@@ -61,10 +61,20 @@ type VirtioBlk struct {
 	DeviceIdentifier string
 }
 
+type DirectorySharingConfig struct {
+	MountTag string
+}
+
 // VirtioFs configures directory sharing between the guest and the host.
 type VirtioFs struct {
+	DirectorySharingConfig
 	SharedDir string
-	MountTag  string
+}
+
+// RosettaShare configures rosetta support in the guest to run Intel binaries on Apple CPUs
+type RosettaShare struct {
+	DirectorySharingConfig
+	InstallRosetta bool
 }
 
 // virtioRng configures a random number generator (RNG) device.
@@ -131,6 +141,8 @@ func deviceFromCmdLine(deviceOpts string) (VirtioDevice, error) {
 	}
 	var dev VirtioDevice
 	switch opts[0] {
+	case "rosetta":
+		dev = &RosettaShare{}
 	case "virtio-blk":
 		dev = virtioBlkNewEmpty()
 	case "virtio-fs":
@@ -545,8 +557,10 @@ func (dev *VirtioVsock) FromOptions(options []option) error {
 // mounted in the VM using `mount -t virtiofs mountTag /some/dir`
 func VirtioFsNew(sharedDir string, mountTag string) (VirtioDevice, error) {
 	return &VirtioFs{
+		DirectorySharingConfig: DirectorySharingConfig{
+			MountTag: mountTag,
+		},
 		SharedDir: sharedDir,
-		MountTag:  mountTag,
 	}, nil
 }
 
@@ -575,6 +589,46 @@ func (dev *VirtioFs) FromOptions(options []option) error {
 	return nil
 }
 
+// RosettaShare creates a new rosetta share for running x86_64 binaries on M1 machines.
+// It will share a directory containing the linux rosetta binaries with the
+// virtual machine. This directory can be mounted in the VM using `mount -t
+// virtiofs mountTag /some/dir`
+func RosettaShareNew(mountTag string) (VirtioDevice, error) {
+	return &RosettaShare{
+		DirectorySharingConfig: DirectorySharingConfig{
+			MountTag: mountTag,
+		},
+	}, nil
+}
+
+func (dev *RosettaShare) ToCmdLine() ([]string, error) {
+	if dev.MountTag == "" {
+		return nil, fmt.Errorf("rosetta shares require a mount tag to be specified")
+	}
+	builder := strings.Builder{}
+	builder.WriteString("rosetta")
+	fmt.Fprintf(&builder, ",mountTag=%s", dev.MountTag)
+	if dev.InstallRosetta {
+		builder.WriteString(",install")
+	}
+
+	return []string{"--device", builder.String()}, nil
+}
+
+func (dev *RosettaShare) FromOptions(options []option) error {
+	for _, option := range options {
+		switch option.key {
+		case "mountTag":
+			dev.MountTag = option.value
+		case "install":
+			dev.InstallRosetta = true
+		default:
+			return fmt.Errorf("Unknown option for rosetta share: %s", option.key)
+		}
+	}
+	return nil
+}
+
 type USBMassStorage struct {
 	StorageConfig
 }

pkg/config/virtio_test.go

@@ -56,11 +56,22 @@ var virtioDevTests = map[string]virtioDevTest{
 		newDev: func() (VirtioDevice, error) { return VirtioFsNew("/foo/bar", "myTag") },
 		expectedDev: &VirtioFs{
 			SharedDir: "/foo/bar",
-			MountTag:  "myTag",
+			DirectorySharingConfig: DirectorySharingConfig{
+				MountTag: "myTag",
+			},
 		},
 		expectedCmdLine:  []string{"--device", "virtio-fs,sharedDir=/foo/bar,mountTag=myTag"},
 		alternateCmdLine: []string{"--device", "virtio-fs,mountTag=myTag,sharedDir=/foo/bar"},
 	},
+	"NewRosettaShare": {
+		newDev: func() (VirtioDevice, error) { return RosettaShareNew("myTag") },
+		expectedDev: &RosettaShare{
+			DirectorySharingConfig: DirectorySharingConfig{
+				MountTag: "myTag",
+			},
+		},
+		expectedCmdLine: []string{"--device", "rosetta,mountTag=myTag"},
+	},
 	"NewVirtioVsock": {
 		newDev: func() (VirtioDevice, error) { return VirtioVsockNew(1234, "/foo/bar.unix", false) },
 		expectedDev: &VirtioVsock{

pkg/vf/rosetta_amd64.go

@@ -0,0 +1,9 @@
+package vf
+
+import (
+	"fmt"
+)
+
+func (dev *RosettaShare) AddToVirtualMachineConfig(_ *vzVirtualMachineConfiguration) error {
+	return fmt.Errorf("rosetta is unsupported on non-arm64 platforms")
+}

pkg/vf/rosetta_arm64.go

@@ -0,0 +1,61 @@
+package vf
+
+import (
+	"fmt"
+
+	"github.com/Code-Hex/vz/v3"
+	log "github.com/sirupsen/logrus"
+)
+
+func checkRosettaAvailability(install bool) error {
+	availability := vz.LinuxRosettaDirectoryShareAvailability()
+	switch availability {
+	case vz.LinuxRosettaAvailabilityNotSupported:
+		return fmt.Errorf("rosetta is not supported")
+	case vz.LinuxRosettaAvailabilityNotInstalled:
+		if !install {
+			return fmt.Errorf("rosetta is not installed")
+		}
+		log.Debugf("installing rosetta")
+		if err := vz.LinuxRosettaDirectoryShareInstallRosetta(); err != nil {
+			return fmt.Errorf("failed to install rosetta: %w", err)
+		}
+		log.Debugf("rosetta installed")
+	case vz.LinuxRosettaAvailabilityInstalled:
+		// nothing to do
+	}
+
+	return nil
+}
+
+func (dev *RosettaShare) toVz() (vz.DirectorySharingDeviceConfiguration, error) {
+	if dev.MountTag == "" {
+		return nil, fmt.Errorf("missing mandatory 'mountTage' option for rosetta share")
+	}
+	if err := checkRosettaAvailability(dev.InstallRosetta); err != nil {
+		return nil, err
+	}
+
+	rosettaShare, err := vz.NewLinuxRosettaDirectoryShare()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create a new rosetta directory share: %w", err)
+	}
+	config, err := vz.NewVirtioFileSystemDeviceConfiguration(dev.MountTag)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create a new virtio file system configuration for rosetta: %w", err)
+	}
+
+	config.SetDirectoryShare(rosettaShare)
+
+	return config, nil
+}
+
+func (dev *RosettaShare) AddToVirtualMachineConfig(vmConfig *vzVirtualMachineConfiguration) error {
+	fileSystemDeviceConfig, err := dev.toVz()
+	if err != nil {
+		return err
+	}
+	log.Infof("Adding virtio-fs device")
+	vmConfig.directorySharingDevicesConfiguration = append(vmConfig.directorySharingDevicesConfiguration, fileSystemDeviceConfig)
+	return nil
+}

pkg/vf/virtio.go

@@ -13,6 +13,7 @@ import (
 	"golang.org/x/sys/unix"
 )
 
+type RosettaShare config.RosettaShare
 type VirtioBlk config.VirtioBlk
 type VirtioFs config.VirtioFs
 type VirtioRng config.VirtioRng
@@ -248,6 +249,8 @@ func AddToVirtualMachineConfig(dev config.VirtioDevice, vmConfig *vzVirtualMachi
 		return (*USBMassStorage)(d).AddToVirtualMachineConfig(vmConfig)
 	case *config.VirtioBlk:
 		return (*VirtioBlk)(d).AddToVirtualMachineConfig(vmConfig)
+	case *config.RosettaShare:
+		return (*RosettaShare)(d).AddToVirtualMachineConfig(vmConfig)
 	case *config.VirtioFs:
 		return (*VirtioFs)(d).AddToVirtualMachineConfig(vmConfig)
 	case *config.VirtioNet: