WIP : Run as snapshot for macos "Apple Virtualisation"

Configuration/UTMAppleConfiguration.swift

@@ -616,6 +616,23 @@ final class UTMAppleConfiguration: UTMConfigurable, Codable, ObservableObject {
         }
         return urls
     }
+
+    /// Remove the snapshot URL image, this can be done as part of VM cleanup
+    func cleanupDriveSnapShot() throws {
+        for i in diskImages.indices {
+            try diskImages[i].cleanupDriveSnapShot()
+        }
+    }
+
+    /// Perform a snapshot clone of the current image URL to the snapshot URL
+    /// this is required for the snapshotURL image to "work"
+    func resetDriveSnapShot() throws {
+        for i in diskImages.indices {
+            if( diskImages[i].runAsSnapshot ) {
+                try diskImages[i].resetDriveSnapShot()
+            }
+        }
+    }
 }
 
 struct Bootloader: Codable {
@@ -864,13 +881,15 @@ struct DiskImage: Codable, Hashable, Identifiable {
     var sizeMib: Int
     var isReadOnly: Bool
     var isExternal: Bool
+    var runAsSnapshot: Bool
     var imageURL: URL?
     private var uuid = UUID() // for identifiable
 
     private enum CodingKeys: String, CodingKey {
         case sizeMib
         case isReadOnly
         case isExternal
+        case runAsSnapshot
         case imagePath
         case imageBookmark
     }
@@ -891,12 +910,14 @@ struct DiskImage: Codable, Hashable, Identifiable {
         sizeMib = newSize
         isReadOnly = false
         isExternal = false
+        runAsSnapshot = false
     }
 
-    init(importImage url: URL, isReadOnly: Bool = false, isExternal: Bool = false) {
+    init(importImage url: URL, isReadOnly: Bool = false, isExternal: Bool = false, runAsSnapshot: Bool = false) {
         self.imageURL = url
         self.isReadOnly = isReadOnly
         self.isExternal = isExternal
+        self.runAsSnapshot = runAsSnapshot
         if let attributes = try? url.resourceValues(forKeys: [.fileSizeKey]), let fileSize = attributes.fileSize {
             sizeMib = fileSize / bytesInMib
         } else {
@@ -912,6 +933,7 @@ struct DiskImage: Codable, Hashable, Identifiable {
         sizeMib = try container.decode(Int.self, forKey: .sizeMib)
         isReadOnly = try container.decode(Bool.self, forKey: .isReadOnly)
         isExternal = try container.decode(Bool.self, forKey: .isExternal)
+        runAsSnapshot = try container.decode(Bool.self, forKey: .runAsSnapshot)
         if !isExternal, let imagePath = try container.decodeIfPresent(String.self, forKey: .imagePath) {
             imageURL = dataURL.appendingPathComponent(imagePath)
         } else if let bookmark = try container.decodeIfPresent(Data.self, forKey: .imageBookmark) {
@@ -925,6 +947,7 @@ struct DiskImage: Codable, Hashable, Identifiable {
         try container.encode(sizeMib, forKey: .sizeMib)
         try container.encode(isReadOnly, forKey: .isReadOnly)
         try container.encode(isExternal, forKey: .isExternal)
+        try container.encode(runAsSnapshot, forKey: .runAsSnapshot)
         if !isExternal {
             try container.encodeIfPresent(imageURL?.lastPathComponent, forKey: .imagePath)
         } else {
@@ -941,7 +964,45 @@ struct DiskImage: Codable, Hashable, Identifiable {
         }
     }
 
+    /// Returns the snapshot equivalent URL for the current image
+    /// Does not actually prepare the snapshot (this is done via resetDriveSnapShot)
+    func snapshotURL() throws -> URL? {
+        var snapshotURL = imageURL
+        snapshotURL = snapshotURL?.appendingPathComponent(".snapshot")
+        return snapshotURL
+    }
+
+    /// Remove the snapshot URL image, this can be done as part of VM cleanup
+    func cleanupDriveSnapShot() throws {
+        if let snapshotURL = try snapshotURL() {
+            // this is intentionally allowed to return false, as the file may not exists
+            try FileManager.default.removeItem( at: snapshotURL )
+        }
+    }
+
+    /// Perform a snapshot clone of the current image URL to the snapshot URL
+    /// this is required for the snapshotURL image to "work"
+    func resetDriveSnapShot() throws {
+        // Perform any needed cleanup first
+        try cleanupDriveSnapShot()
+
+        // and make a copy of the provided imageURL
+        if let snapshotURL = try snapshotURL(), let imageURL = imageURL {
+            // lets setup the snapshot file 
+            // (currently i have no idea if this optimizes when under APFS)
+            try FileManager.default.copyItem( at: imageURL, to: snapshotURL )
+        }
+    }
+
+    /// Return the VZDiskImageStorageDeviceAttachment using the snapshotURL if runAsSnapshot is enabled
+    /// else returns using the imageURL if its configured.
     func vzDiskImage() throws -> VZDiskImageStorageDeviceAttachment? {
+        if runAsSnapshot, let snapshotURL = try snapshotURL() {
+            return try VZDiskImageStorageDeviceAttachment(url: snapshotURL, readOnly: isReadOnly)
+        } else {
+            return nil
+        }
+
         if let imageURL = imageURL {
             return try VZDiskImageStorageDeviceAttachment(url: imageURL, readOnly: isReadOnly)
         } else {

Managers/UTMAppleVirtualMachine.swift

@@ -323,6 +323,8 @@ import Virtualization
                 }
                 fsConfig.share = self?.makeDirectoryShare(from: newShares)
             }
+
+            try appleConfig.resetDriveSnapShot()
         }
         apple = VZVirtualMachine(configuration: appleConfig.apple, queue: vmQueue)
         apple.delegate = self

Platform/macOS/VMConfigAppleDriveDetailsView.swift

@@ -25,6 +25,7 @@ struct VMConfigAppleDriveDetailsView: View {
             TextField("Name", text: .constant(diskImage.imageURL?.lastPathComponent ?? NSLocalizedString("(New Drive)", comment: "VMConfigAppleDriveDetailsView")))
                 .disabled(true)
             Toggle("Read Only?", isOn: $diskImage.isReadOnly)
+            Toggle("Run using a snapshot? (similar to qemu --snapshot)", isOn: $diskImage.runAsSnapshot)
             Button(action: onDelete) {
                 Label("Delete Drive", systemImage: "externaldrive.badge.minus")
                     .foregroundColor(.red)