vz: Support ASIF on creating diffdisk

- Add `LIMA_VZ_ASIF` environment variable to use ASIF on creating diffdisk
- pkg/imgutil: Add `ImageDiskManager.ConvertToASIF()`
- Remove `hack/convert-diffdisk-to-asif.sh`

Signed-off-by: Norio Nomura <norio.nomura@gmail.com>

Author: norio-nomura

hack/convert-diffdisk-to-asif.sh

@@ -9,13 +9,17 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
 
+	"github.com/coreos/go-semver/semver"
 	"github.com/docker/go-units"
+	"github.com/sirupsen/logrus"
 
 	"github.com/lima-vm/lima/v2/pkg/imgutil/proxyimgutil"
 	"github.com/lima-vm/lima/v2/pkg/iso9660util"
 	"github.com/lima-vm/lima/v2/pkg/limatype"
 	"github.com/lima-vm/lima/v2/pkg/limatype/filenames"
+	"github.com/lima-vm/lima/v2/pkg/osutil"
 )
 
 func EnsureDisk(ctx context.Context, inst *limatype.Instance) error {
@@ -51,8 +55,45 @@ func EnsureDisk(ctx context.Context, inst *limatype.Instance) error {
 		}
 		return diffDiskF.Close()
 	}
-	if err = diskUtil.ConvertToRaw(ctx, baseDisk, diffDisk, &diskSize, false); err != nil {
-		return fmt.Errorf("failed to convert %q to a raw disk %q: %w", baseDisk, diffDisk, err)
+	// Check whether to use ASIF format
+	converter := diskUtil.ConvertToASIF
+	if !determineUseASIF() {
+		converter = diskUtil.ConvertToRaw
+	}
+	if err = converter(ctx, baseDisk, diffDisk, &diskSize, false); err != nil {
+		return fmt.Errorf("failed to convert %q to a disk %q: %w", baseDisk, diffDisk, err)
 	}
 	return err
 }
+
+func determineUseASIF() bool {
+	var useASIF bool
+	if macOSProductVersion, err := osutil.ProductVersion(); err != nil {
+		logrus.WithError(err).Warn("Failed to get macOS product version; using raw format instead of ASIF")
+	} else if macOSProductVersion.LessThan(*semver.New("26.0.0")) {
+		logrus.Infof("macOS version %q does not support ASIF format; using raw format instead", macOSProductVersion)
+	} else {
+		// TODO: change default to true,
+		// if the conversion from ASIF to raw while preserving sparsity is implemented,
+		// or if enough testing is done to confirm that interoperability issues won't happen with ASIF.
+		useASIF = false
+		// allow overriding via LIMA_VZ_ASIF environment variable
+		if envVar := os.Getenv("LIMA_VZ_ASIF"); envVar != "" {
+			if b, err := strconv.ParseBool(envVar); err != nil {
+				logrus.WithError(err).Warnf("invalid LIMA_VZ_ASIF value %q", envVar)
+			} else {
+				useASIF = b
+				uses := "ASIF"
+				if !useASIF {
+					uses = "raw"
+				}
+				logrus.Infof("LIMA_VZ_ASIF=%s; using %s format to diff disk", envVar, uses)
+			}
+		} else if useASIF {
+			logrus.Info("using ASIF format for the disk image")
+		} else {
+			logrus.Info("using raw format for the disk image")
+		}
+	}
+	return useASIF
+}

pkg/driver/vz/disk.go

@@ -21,4 +21,7 @@ type ImageDiskManager interface {
 
 	// MakeSparse makes a file sparse, starting from the specified offset.
 	MakeSparse(ctx context.Context, f *os.File, offset int64) error
+
+	// ConvertToASIF converts a disk image to ASIF format.
+	ConvertToASIF(ctx context.Context, source, dest string, size *int64, allowSourceWithBackingFile bool) error
 }

pkg/imgutil/manager.go

@@ -0,0 +1,48 @@
+package asifutil
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+// NewAttachedASIF creates a new ASIF image file at the specified path with the given size
+// and attaches it, returning the attached device path and an open file handle.
+// The caller is responsible for detaching the ASIF image device when done.
+func NewAttachedASIF(path string, size int64) (string, *os.File, error) {
+	createArgs := []string{"image", "create", "blank", "--fs", "none", "--format", "ASIF", "--size", fmt.Sprintf("%d", size), path}
+	if err := exec.CommandContext(context.Background(), "diskutil", createArgs...).Run(); err != nil {
+		return "", nil, fmt.Errorf("failed to create ASIF image %q: %w", path, err)
+	}
+	attachArgs := []string{"image", "attach", "--noMount", path}
+	out, err := exec.CommandContext(context.Background(), "diskutil", attachArgs...).Output()
+	if err != nil {
+		return "", nil, fmt.Errorf("failed to attach ASIF image %q: %w", path, err)
+	}
+	devicePath := strings.TrimSpace(string(out))
+	f, err := os.OpenFile(devicePath, os.O_RDWR, 0o644)
+	if err != nil {
+		_ = DetachASIF(devicePath)
+		return "", nil, fmt.Errorf("failed to open ASIF device %q: %w", devicePath, err)
+	}
+	return devicePath, f, err
+}
+
+// DetachASIF detaches the ASIF image device at the specified path.
+func DetachASIF(devicePath string) error {
+	if output, err := exec.CommandContext(context.Background(), "hdiutil", "detach", devicePath).CombinedOutput(); err != nil {
+		return fmt.Errorf("failed to detach ASIF image %q: %w: %s", devicePath, err, output)
+	}
+	return nil
+}
+
+// ResizeASIF resizes the ASIF image at the specified path to the given size.
+func ResizeASIF(path string, size int64) error {
+	resizeArgs := []string{"image", "resize", "--size", fmt.Sprintf("%d", size), path}
+	if output, err := exec.CommandContext(context.Background(), "diskutil", resizeArgs...).CombinedOutput(); err != nil {
+		return fmt.Errorf("failed to resize ASIF image %q: %w: %s", path, err, output)
+	}
+	return nil
+}

pkg/imgutil/nativeimgutil/asifutil/asif_darwin.go

@@ -0,0 +1,25 @@
+//go:build !darwin
+
+// SPDX-FileCopyrightText: Copyright The Lima Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package asifutil
+
+import (
+	"errors"
+	"os"
+)
+
+var ErrASIFNotSupported = errors.New("ASIF is only supported on macOS")
+
+func NewAttachedASIF(path string, size int64) (string, *os.File, error) {
+	return "", nil, ErrASIFNotSupported
+}
+
+func DetachASIF(devicePath string) error {
+	return ErrASIFNotSupported
+}
+
+func ResizeASIF(path string, size int64) error {
+	return ErrASIFNotSupported
+}

pkg/imgutil/nativeimgutil/asifutil/asif_others.go

@@ -17,6 +17,6 @@ func FuzzConvertToRaw(f *testing.F) {
 		destPath := filepath.Join(t.TempDir(), "dest.img")
 		err := os.WriteFile(srcPath, imgData, 0o600)
 		assert.NilError(t, err)
-		_ = convertToRaw(srcPath, destPath, &size, withBacking)
+		_ = convertTo(imageRaw, srcPath, destPath, &size, withBacking)
 	})
 }

pkg/imgutil/nativeimgutil/fuzz_test.go

@@ -10,17 +10,21 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
+	"math"
+	"math/rand/v2"
 	"os"
 	"path/filepath"
 
 	containerdfs "github.com/containerd/continuity/fs"
 	"github.com/docker/go-units"
 	"github.com/lima-vm/go-qcow2reader"
 	"github.com/lima-vm/go-qcow2reader/convert"
+	"github.com/lima-vm/go-qcow2reader/image/asif"
 	"github.com/lima-vm/go-qcow2reader/image/qcow2"
 	"github.com/lima-vm/go-qcow2reader/image/raw"
 	"github.com/sirupsen/logrus"
 
+	"github.com/lima-vm/lima/v2/pkg/imgutil/nativeimgutil/asifutil"
 	"github.com/lima-vm/lima/v2/pkg/progressbar"
 )
 
@@ -38,10 +42,17 @@ func roundUp(size int64) int64 {
 	return sectors * sectorSize
 }
 
-// convertToRaw converts a source disk into a raw disk.
+type targetImageType string
+
+const (
+	imageRaw  targetImageType = "raw"
+	imageASIF targetImageType = "ASIF"
+)
+
+// convertTo converts a source disk into a raw or ASIF disk.
 // source and dest may be same.
-// convertToRaw is a NOP if source == dest, and no resizing is needed.
-func convertToRaw(source, dest string, size *int64, allowSourceWithBackingFile bool) error {
+// convertTo is a NOP if source == dest, and no resizing is needed.
+func convertTo(destType targetImageType, source, dest string, size *int64, allowSourceWithBackingFile bool) error {
 	srcF, err := os.Open(source)
 	if err != nil {
 		return err
@@ -54,13 +65,15 @@ func convertToRaw(source, dest string, size *int64, allowSourceWithBackingFile b
 	if size != nil && *size < srcImg.Size() {
 		return fmt.Errorf("specified size %d is smaller than the original image size (%d) of %q", *size, srcImg.Size(), source)
 	}
-	logrus.Infof("Converting %q (%s) to a raw disk %q", source, srcImg.Type(), dest)
+	logrus.Infof("Converting %q (%s) to a %s disk %q", source, srcImg.Type(), destType, dest)
 	switch t := srcImg.Type(); t {
 	case raw.Type:
 		if err = srcF.Close(); err != nil {
 			return err
 		}
-		return convertRawToRaw(source, dest, size)
+		if destType == imageRaw {
+			return convertRawToRaw(source, dest, size)
+		}
 	case qcow2.Type:
 		if !allowSourceWithBackingFile {
 			q, ok := srcImg.(*qcow2.Qcow2)
@@ -71,6 +84,11 @@ func convertToRaw(source, dest string, size *int64, allowSourceWithBackingFile b
 				return fmt.Errorf("qcow2 image %q has an unexpected backing file: %q", source, q.BackingFile)
 			}
 		}
+	case asif.Type:
+		if destType == imageASIF {
+			return convertASIFToASIF(source, dest, size)
+		}
+		return fmt.Errorf("conversion from ASIF to %q is not supported", destType)
 	default:
 		logrus.Warnf("image %q has an unexpected format: %q", source, t)
 	}
@@ -79,11 +97,26 @@ func convertToRaw(source, dest string, size *int64, allowSourceWithBackingFile b
 	}
 
 	// Create a tmp file because source and dest can be same.
-	destTmpF, err := os.CreateTemp(filepath.Dir(dest), filepath.Base(dest)+".lima-*.tmp")
+	var (
+		destTmpF       *os.File
+		destTmp        string
+		attachedDevice string
+	)
+	switch destType {
+	case imageRaw:
+		destTmpF, err = os.CreateTemp(filepath.Dir(dest), filepath.Base(dest)+".lima-*.tmp")
+		destTmp = destTmpF.Name()
+	case imageASIF:
+		// destTmp != destTmpF.Name() because destTmpF is mounted ASIF device file.
+		randomBase := fmt.Sprintf("%s.lima-%d.tmp.asif", filepath.Base(dest), rand.UintN(math.MaxUint))
+		destTmp = filepath.Join(filepath.Dir(dest), randomBase)
+		attachedDevice, destTmpF, err = asifutil.NewAttachedASIF(destTmp, srcImg.Size())
+	default:
+		return fmt.Errorf("unsupported target image type: %q", destType)
+	}
 	if err != nil {
 		return err
 	}
-	destTmp := destTmpF.Name()
 	defer os.RemoveAll(destTmp)
 	defer destTmpF.Close()
 
@@ -116,6 +149,13 @@ func convertToRaw(source, dest string, size *int64, allowSourceWithBackingFile b
 	if err = destTmpF.Close(); err != nil {
 		return err
 	}
+	// Detach ASIF device
+	if destType == imageASIF {
+		err := asifutil.DetachASIF(attachedDevice)
+		if err != nil {
+			return fmt.Errorf("failed to detach ASIF image %q: %w", attachedDevice, err)
+		}
+	}
 
 	// Rename destTmp into dest
 	if err = os.RemoveAll(dest); err != nil {
@@ -149,6 +189,24 @@ func convertRawToRaw(source, dest string, size *int64) error {
 	return nil
 }
 
+func convertASIFToASIF(source, dest string, size *int64) error {
+	if source != dest {
+		if err := containerdfs.CopyFile(dest, source); err != nil {
+			return fmt.Errorf("failed to copy %q into %q: %w", source, dest, err)
+		}
+		if err := os.Chmod(dest, 0o644); err != nil {
+			return fmt.Errorf("failed to set permissions on %q: %w", dest, err)
+		}
+	}
+	if size != nil {
+		logrus.Infof("Resizing to %s", units.BytesSize(float64(*size)))
+		if err := asifutil.ResizeASIF(dest, *size); err != nil {
+			return fmt.Errorf("failed to resize ASIF image %q: %w", dest, err)
+		}
+	}
+	return nil
+}
+
 func makeSparse(f *os.File, offset int64) error {
 	if _, err := f.Seek(offset, io.SeekStart); err != nil {
 		return err
@@ -172,7 +230,7 @@ func (n *NativeImageUtil) CreateDisk(_ context.Context, disk string, size int64)
 
 // ConvertToRaw converts a disk image to raw format.
 func (n *NativeImageUtil) ConvertToRaw(_ context.Context, source, dest string, size *int64, allowSourceWithBackingFile bool) error {
-	return convertToRaw(source, dest, size, allowSourceWithBackingFile)
+	return convertTo(imageRaw, source, dest, size, allowSourceWithBackingFile)
 }
 
 // ResizeDisk resizes an existing disk image to the specified size.
@@ -185,3 +243,8 @@ func (n *NativeImageUtil) ResizeDisk(_ context.Context, disk string, size int64)
 func (n *NativeImageUtil) MakeSparse(_ context.Context, f *os.File, offset int64) error {
 	return makeSparse(f, offset)
 }
+
+// ConvertToASIF converts a disk image to ASIF format.
+func (n *NativeImageUtil) ConvertToASIF(_ context.Context, source, dest string, size *int64, allowSourceWithBackingFile bool) error {
+	return convertTo(imageASIF, source, dest, size, allowSourceWithBackingFile)
+}