vm: renamed VM operation methods

This provides clarity on the grouping of VM operations as well as make
explicit the "request" versus async calls.

Managers/UTMAppleVirtualMachine.swift

@@ -122,7 +122,7 @@ import Virtualization
         // FIXME: Apple VM doesn't support saving bookmarks
     }
     
-    override func startVM() async throws {
+    override func vmStart() async throws {
         guard state == .vmStopped else {
             return
         }
@@ -138,7 +138,7 @@ import Virtualization
         changeState(.vmStarted)
     }
     
-    override func quitVM(force: Bool) async throws {
+    override func vmStop(force: Bool) async throws {
         guard state == .vmStarted else {
             return
         }
@@ -170,7 +170,7 @@ import Virtualization
         }
     }
     
-    override func resetVM() async throws {
+    override func vmReset() async throws {
         guard #available(macOS 12, *) else {
             return
         }
@@ -194,7 +194,7 @@ import Virtualization
         changeState(.vmStarted)
     }
     
-    override func pauseVM() async throws {
+    override func vmPause() async throws {
         guard state == .vmStarted else {
             return
         }
@@ -213,15 +213,15 @@ import Virtualization
         changeState(.vmPaused)
     }
     
-    override func saveVM() async throws {
+    override func vmSaveState() async throws {
         // FIXME: implement this
     }
     
-    override func deleteSaveVM() async throws {
+    override func vmDeleteState() async throws {
         // FIXME: implement this
     }
     
-    override func resumeVM() async throws {
+    override func vmResume() async throws {
         guard state == .vmPaused else {
             return
         }

Managers/UTMQemuManager.h

@@ -38,13 +38,13 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)disconnect;
 - (BOOL)continueBootWithError:(NSError * _Nullable __autoreleasing *)error;
 
-- (void)vmPowerDownWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
-- (void)vmResetWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
-- (void)vmStopWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
-- (void)vmResumeWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
-- (void)vmQuitWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
-- (void)vmSaveWithCompletion:(void (^ _Nullable)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name;
-- (void)vmDeleteSaveWithCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name;
+- (void)qemuPowerDownWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
+- (void)qemuResetWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
+- (void)qemuStopWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
+- (void)qemuResumeWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
+- (void)qemuQuitWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
+- (void)qemuSaveStateWithCompletion:(void (^ _Nullable)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name;
+- (void)qemuDeleteStateWithCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name;
 
 - (void)mouseIndexForAbsolute:(BOOL)absolute withCompletion:(void (^)(int64_t, NSError * _Nullable))completion;
 - (void)mouseSelect:(int64_t)index withCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion;

Managers/UTMQemuManager.m

@@ -286,7 +286,7 @@ void qmp_rpc_call(CFDictionaryRef args, CFDictionaryRef *ret, Error **err, void
     }
 }
 
-- (void)vmPowerCommand:(NSString *)command completion:(void (^ _Nullable)(NSError * _Nullable))completion {
+- (void)qmpPowerCommand:(NSString *)command completion:(void (^ _Nullable)(NSError * _Nullable))completion {
     dispatch_async(dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), ^{
         Error *qerr = NULL;
         NSError *err;
@@ -304,7 +304,7 @@ void qmp_rpc_call(CFDictionaryRef args, CFDictionaryRef *ret, Error **err, void
     });
 }
 
-- (void)vmHmpCommand:(NSString *)cmd completion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion {
+- (void)qmpHmpCommand:(NSString *)cmd completion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion {
     dispatch_async(dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), ^{
         Error *qerr = NULL;
         NSError *err;
@@ -325,34 +325,34 @@ void qmp_rpc_call(CFDictionaryRef args, CFDictionaryRef *ret, Error **err, void
     });
 }
 
-- (void)vmPowerDownWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
-    [self vmPowerCommand:@"system_powerdown" completion:completion];
+- (void)qemuPowerDownWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
+    [self qmpPowerCommand:@"system_powerdown" completion:completion];
 }
 
-- (void)vmResetWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
-    [self vmPowerCommand:@"system_reset" completion:completion];
+- (void)qemuResetWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
+    [self qmpPowerCommand:@"system_reset" completion:completion];
 }
 
-- (void)vmStopWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
-    [self vmPowerCommand:@"stop" completion:completion];
+- (void)qemuStopWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
+    [self qmpPowerCommand:@"stop" completion:completion];
 }
 
-- (void)vmResumeWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
-    [self vmPowerCommand:@"cont" completion:completion];
+- (void)qemuResumeWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
+    [self qmpPowerCommand:@"cont" completion:completion];
 }
 
-- (void)vmQuitWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
-    [self vmPowerCommand:@"quit" completion:completion];
+- (void)qemuQuitWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion {
+    [self qmpPowerCommand:@"quit" completion:completion];
 }
 
-- (void)vmSaveWithCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name {
+- (void)qemuSaveStateWithCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name {
     NSString *cmd = [NSString stringWithFormat:@"savevm %@", name];
-    [self vmHmpCommand:cmd completion:completion];
+    [self qmpHmpCommand:cmd completion:completion];
 }
 
-- (void)vmDeleteSaveWithCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name {
+- (void)qemuDeleteStateWithCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion snapshotName:(NSString *)name {
     NSString *cmd = [NSString stringWithFormat:@"delvm %@", name];
-    [self vmHmpCommand:cmd completion:completion];
+    [self qmpHmpCommand:cmd completion:completion];
 }
 
 - (void)mouseIndexForAbsolute:(BOOL)absolute withCompletion:(void (^)(int64_t, NSError * _Nullable))completion {
@@ -383,7 +383,7 @@ void qmp_rpc_call(CFDictionaryRef args, CFDictionaryRef *ret, Error **err, void
 
 - (void)mouseSelect:(int64_t)index withCompletion:(void (^)(NSString * _Nullable, NSError * _Nullable))completion {
     NSString *cmd = [NSString stringWithFormat:@"mouse_set %lld", index];
-    [self vmHmpCommand:cmd completion:completion];
+    [self qmpHmpCommand:cmd completion:completion];
 }
 
 @end

Managers/UTMQemuVirtualMachine.m

@@ -259,7 +259,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
 
 #pragma mark - VM actions
 
-- (void)_startVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)_vmStartWithCompletion:(void (^)(NSError * _Nullable))completion {
     if (self.state != kVMStopped) {
         completion([self errorGeneric]);
         return;
@@ -323,7 +323,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
             });
         }
         dispatch_semaphore_signal(_self.qemuDidExitEvent);
-        [_self quitVMForce:YES completion:^(NSError *error){}];
+        [_self vmStopForce:YES completion:^(NSError *error){}];
     }];
     // connect to QMP
     [self.qemu connectWithCompletion:^(BOOL success, NSError *error) {
@@ -372,7 +372,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
                 [self restoreViewState];
             });
             if (self.viewState.suspended) {
-                [self _deleteSaveVMWithCompletion:completion];
+                [self _vmDeleteStateWithCompletion:completion];
             } else {
                 completion(nil); // everything successful
             }
@@ -380,9 +380,9 @@ NSString *const kSuspendSnapshotName = @"suspend";
     } retries:kQMPMaxConnectionTries];
 }
 
-- (void)startVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmStartWithCompletion:(void (^)(NSError * _Nullable))completion {
     dispatch_async(self.vmOperations, ^{
-        [self _startVMWithCompletion:^(NSError *err){
+        [self _vmStartWithCompletion:^(NSError *err){
             if (err) { // delete suspend state on error
                 dispatch_sync(dispatch_get_main_queue(), ^{
                     self.viewState.suspended = NO;
@@ -394,7 +394,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
     });
 }
 
-- (void)_quitVMForce:(BOOL)force completion:(void (^)(NSError * _Nullable))completion {
+- (void)_vmStopForce:(BOOL)force completion:(void (^)(NSError * _Nullable))completion {
     if (self.state == kVMStopped) {
         completion(nil);
         return;
@@ -413,7 +413,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
     [self saveViewState];
     
     [self.qemu cancelConnectRetry];
-    [_qemu vmQuitWithCompletion:nil];
+    [_qemu qemuQuitWithCompletion:nil];
     if (force || dispatch_semaphore_wait(self.qemuWillQuitEvent, dispatch_time(DISPATCH_TIME_NOW, kStopTimeout)) != 0) {
         UTMLog(@"Stop operation timeout or force quit");
     }
@@ -437,13 +437,13 @@ NSString *const kSuspendSnapshotName = @"suspend";
     [self.logging endLog];
 }
 
-- (void)quitVMForce:(BOOL)force completion:(void (^)(NSError * _Nullable))completion {
+- (void)vmStopForce:(BOOL)force completion:(void (^)(NSError * _Nullable))completion {
     dispatch_async(self.vmOperations, ^{
-        [self _quitVMForce:force completion:completion];
+        [self _vmStopForce:force completion:completion];
     });
 }
 
-- (void)_resetVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)_vmResetWithCompletion:(void (^)(NSError * _Nullable))completion {
     if (self.state != kVMStarted && self.state != kVMPaused) {
         completion([self errorGeneric]);
         return;
@@ -453,12 +453,12 @@ NSString *const kSuspendSnapshotName = @"suspend";
     });
     [self changeState:kVMStopping];
     if (self.viewState.suspended) {
-        [self _deleteSaveVMWithCompletion:^(NSError *error) {}];
+        [self _vmDeleteStateWithCompletion:^(NSError *error) {}];
     }
     [self saveViewState];
     __block NSError *resetError = nil;
     dispatch_semaphore_t resetTriggeredEvent = dispatch_semaphore_create(0);
-    [_qemu vmResetWithCompletion:^(NSError *err) {
+    [_qemu qemuResetWithCompletion:^(NSError *err) {
         UTMLog(@"reset callback: err? %@", err);
         if (err) {
             UTMLog(@"error: %@", err);
@@ -478,13 +478,13 @@ NSString *const kSuspendSnapshotName = @"suspend";
     completion(resetError);
 }
 
-- (void)resetVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmResetWithCompletion:(void (^)(NSError * _Nullable))completion {
     dispatch_async(self.vmOperations, ^{
-        [self _resetVMWithCompletion:completion];
+        [self _vmResetWithCompletion:completion];
     });
 }
 
-- (void)_pauseVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)_vmPauseWithCompletion:(void (^)(NSError * _Nullable))completion {
     if (self.state != kVMStarted) {
         completion([self errorGeneric]);
         return;
@@ -499,7 +499,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
     [self saveScreenshot];
     __block NSError *suspendError = nil;
     dispatch_semaphore_t suspendTriggeredEvent = dispatch_semaphore_create(0);
-    [_qemu vmStopWithCompletion:^(NSError * err) {
+    [_qemu qemuStopWithCompletion:^(NSError * err) {
         UTMLog(@"stop callback: err? %@", err);
         if (err) {
             UTMLog(@"error: %@", err);
@@ -519,20 +519,20 @@ NSString *const kSuspendSnapshotName = @"suspend";
     completion(suspendError);
 }
 
-- (void)pauseVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmPauseWithCompletion:(void (^)(NSError * _Nullable))completion {
     dispatch_async(self.vmOperations, ^{
-        [self _pauseVMWithCompletion:completion];
+        [self _vmPauseWithCompletion:completion];
     });
 }
 
-- (void)_saveVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)_vmSaveStateWithCompletion:(void (^)(NSError * _Nullable))completion {
     if (self.state != kVMPaused && self.state != kVMStarted) {
         completion([self errorGeneric]);
         return;
     }
     __block NSError *saveError = nil;
     dispatch_semaphore_t saveTriggeredEvent = dispatch_semaphore_create(0);
-    [_qemu vmSaveWithCompletion:^(NSString *result, NSError *err) {
+    [_qemu qemuSaveStateWithCompletion:^(NSString *result, NSError *err) {
         UTMLog(@"save callback: %@", result);
         if (err) {
             UTMLog(@"error: %@", err);
@@ -560,17 +560,17 @@ NSString *const kSuspendSnapshotName = @"suspend";
     completion(saveError);
 }
 
-- (void)saveVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmSaveStateWithCompletion:(void (^)(NSError * _Nullable))completion {
     dispatch_async(self.vmOperations, ^{
-        [self _saveVMWithCompletion:completion];
+        [self _vmSaveStateWithCompletion:completion];
     });
 }
 
-- (void)_deleteSaveVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)_vmDeleteStateWithCompletion:(void (^)(NSError * _Nullable))completion {
     __block NSError *deleteError = nil;
     if (self.qemu) { // if QEMU is running
         dispatch_semaphore_t deleteTriggeredEvent = dispatch_semaphore_create(0);
-        [_qemu vmDeleteSaveWithCompletion:^(NSString *result, NSError *err) {
+        [_qemu qemuDeleteStateWithCompletion:^(NSString *result, NSError *err) {
             UTMLog(@"delete save callback: %@", result);
             if (err) {
                 UTMLog(@"error: %@", err);
@@ -593,13 +593,13 @@ NSString *const kSuspendSnapshotName = @"suspend";
     completion(deleteError);
 }
 
-- (void)deleteSaveVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmDeleteStateWithCompletion:(void (^)(NSError * _Nullable))completion {
     dispatch_async(self.vmOperations, ^{
-        [self _deleteSaveVMWithCompletion:completion];
+        [self _vmDeleteStateWithCompletion:completion];
     });
 }
 
-- (void)_resumeVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)_vmResumeWithCompletion:(void (^)(NSError * _Nullable))completion {
     if (self.state != kVMPaused) {
         completion([self errorGeneric]);
         return;
@@ -607,7 +607,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
     [self changeState:kVMResuming];
     __block NSError *resumeError = nil;
     dispatch_semaphore_t resumeTriggeredEvent = dispatch_semaphore_create(0);
-    [_qemu vmResumeWithCompletion:^(NSError *err) {
+    [_qemu qemuResumeWithCompletion:^(NSError *err) {
         UTMLog(@"resume callback: err? %@", err);
         if (err) {
             UTMLog(@"error: %@", err);
@@ -628,15 +628,15 @@ NSString *const kSuspendSnapshotName = @"suspend";
         [self changeState:kVMStopped];
     }
     if (self.viewState.suspended) {
-        [self _deleteSaveVMWithCompletion:^(NSError *error){}];
+        [self _vmDeleteStateWithCompletion:^(NSError *error){}];
     } else {
         completion(nil);
     }
 }
 
-- (void)resumeVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmResumeWithCompletion:(void (^)(NSError * _Nullable))completion {
     dispatch_async(self.vmOperations, ^{
-        [self _resumeVMWithCompletion:completion];
+        [self _vmResumeWithCompletion:completion];
     });
 }
 
@@ -681,7 +681,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
 - (void)qemuWillQuit:(UTMQemuManager *)manager guest:(BOOL)guest reason:(ShutdownCause)reason {
     UTMLog(@"qemuWillQuit, reason = %s", ShutdownCause_str(reason));
     dispatch_semaphore_signal(self.qemuWillQuitEvent);
-    [self quitVMWithCompletion:^(NSError *error) {}]; // trigger quit
+    [self vmStopWithCompletion:^(NSError *error) {}]; // trigger quit
 }
 
 - (void)qemuError:(UTMQemuManager *)manager error:(NSString *)error {
@@ -689,7 +689,7 @@ NSString *const kSuspendSnapshotName = @"suspend";
     dispatch_async(dispatch_get_main_queue(), ^{
         [self.delegate virtualMachine:self didErrorWithMessage:error];
     });
-    [self quitVMForce:YES completion:^(NSError *error) {}];
+    [self vmStopForce:YES completion:^(NSError *error) {}];
 }
 
 // this is called right before we execute qmp_cont so we can setup additional option

Managers/UTMVirtualMachine.h

@@ -48,22 +48,22 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)accessShortcutWithCompletion:(void (^ _Nullable)(NSError * _Nullable))completion;
 
-- (void)startVM;
-- (void)startVMWithCompletion:(void (^)(NSError * _Nullable))completion;
-- (void)quitVM;
-- (void)quitVMWithCompletion:(void (^)(NSError * _Nullable))completion;
+- (void)requestVmStart;
+- (void)vmStartWithCompletion:(void (^)(NSError * _Nullable))completion;
+- (void)requestVmStop;
+- (void)vmStopWithCompletion:(void (^)(NSError * _Nullable))completion;
 - (void)requestVmStopForce:(BOOL)force NS_SWIFT_NAME(requestVmStop(force:));
-- (void)quitVMForce:(BOOL)force completion:(void (^)(NSError * _Nullable))completion NS_SWIFT_NAME(quitVM(force:completion:));
-- (void)resetVM;
-- (void)resetVMWithCompletion:(void (^)(NSError * _Nullable))completion;
-- (void)pauseVM;
-- (void)pauseVMWithCompletion:(void (^)(NSError * _Nullable))completion;
-- (void)saveVM;
-- (void)saveVMWithCompletion:(void (^)(NSError * _Nullable))completion;
-- (void)deleteSaveVM;
-- (void)deleteSaveVMWithCompletion:(void (^)(NSError * _Nullable))completion;
-- (void)resumeVM;
-- (void)resumeVMWithCompletion:(void (^)(NSError * _Nullable))completion;
+- (void)vmStopForce:(BOOL)force completion:(void (^)(NSError * _Nullable))completion NS_SWIFT_NAME(vmStop(force:completion:));
+- (void)requestVmReset;
+- (void)vmResetWithCompletion:(void (^)(NSError * _Nullable))completion;
+- (void)requestVmPause;
+- (void)vmPauseWithCompletion:(void (^)(NSError * _Nullable))completion;
+- (void)requestVmSaveState;
+- (void)vmSaveStateWithCompletion:(void (^)(NSError * _Nullable))completion;
+- (void)requestVmDeleteState;
+- (void)vmDeleteStateWithCompletion:(void (^)(NSError * _Nullable))completion;
+- (void)requestVmResume;
+- (void)vmResumeWithCompletion:(void (^)(NSError * _Nullable))completion;
 
 @end
 

Managers/UTMVirtualMachine.m

@@ -249,8 +249,8 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     return [self loadConfigurationWithReload:YES error:err];
 }
 
-- (void)startVM {
-    [self startVMWithCompletion:^(NSError *error) {
+- (void)requestVmStart {
+    [self vmStartWithCompletion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -259,8 +259,8 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     }];
 }
 
-- (void)quitVM {
-    [self quitVMWithCompletion:^(NSError *error) {
+- (void)requestVmStop {
+    [self vmStopWithCompletion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -270,7 +270,7 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
 }
 
 - (void)requestVmStopForce:(BOOL)force {
-    [self quitVMForce:force completion:^(NSError *error) {
+    [self vmStopForce:force completion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -279,8 +279,8 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     }];
 }
 
-- (void)resetVM {
-    [self resetVMWithCompletion:^(NSError *error) {
+- (void)requestVmReset {
+    [self vmResetWithCompletion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -289,8 +289,8 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     }];
 }
 
-- (void)pauseVM {
-    [self pauseVMWithCompletion:^(NSError *error) {
+- (void)requestVmPause {
+    [self vmPauseWithCompletion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -299,8 +299,8 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     }];
 }
 
-- (void)saveVM {
-    [self saveVMWithCompletion:^(NSError *error) {
+- (void)requestVmSaveState {
+    [self vmSaveStateWithCompletion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -309,8 +309,8 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     }];
 }
 
-- (void)deleteSaveVM {
-    [self deleteSaveVMWithCompletion:^(NSError *error) {
+- (void)requestVmDeleteState {
+    [self vmDeleteStateWithCompletion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -319,8 +319,8 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     }];
 }
 
-- (void)resumeVM {
-    [self resumeVMWithCompletion:^(NSError *error) {
+- (void)requestVmResume {
+    [self vmResumeWithCompletion:^(NSError *error) {
         if (error) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [self.delegate virtualMachine:self didErrorWithMessage:error.localizedDescription];
@@ -343,35 +343,35 @@ const dispatch_time_t kScreenshotPeriodSeconds = 60 * NSEC_PER_SEC;
     notImplemented;
 }
 
-- (void)startVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmStartWithCompletion:(void (^)(NSError * _Nullable))completion {
     notImplemented;
 }
 
-- (void)quitVMWithCompletion:(void (^)(NSError * _Nullable))completion {
-    return [self quitVMForce:NO completion:completion];
+- (void)vmStopWithCompletion:(void (^)(NSError * _Nullable))completion {
+    return [self vmStopForce:NO completion:completion];
 }
 
-- (void)quitVMForce:(BOOL)force completion:(nonnull void (^)(NSError * _Nullable))completion {
+- (void)vmStopForce:(BOOL)force completion:(nonnull void (^)(NSError * _Nullable))completion {
     notImplemented;
 }
 
-- (void)resetVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmResetWithCompletion:(void (^)(NSError * _Nullable))completion {
     notImplemented;
 }
 
-- (void)pauseVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmPauseWithCompletion:(void (^)(NSError * _Nullable))completion {
     notImplemented;
 }
 
-- (void)saveVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmSaveStateWithCompletion:(void (^)(NSError * _Nullable))completion {
     notImplemented;
 }
 
-- (void)deleteSaveVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmDeleteStateWithCompletion:(void (^)(NSError * _Nullable))completion {
     notImplemented;
 }
 
-- (void)resumeVMWithCompletion:(void (^)(NSError * _Nullable))completion {
+- (void)vmResumeWithCompletion:(void (^)(NSError * _Nullable))completion {
     notImplemented;
 }
 

Platform/Shared/ContentView.swift

@@ -186,20 +186,20 @@ struct ContentView: View {
             case "restart":
                 if let vm = await findVM(), vm.state == .vmStarted {
                     DispatchQueue.global(qos: .background).async {
-                        vm.resetVM()
+                        vm.requestVmReset()
                     }
                 }
                 break
             case "pause":
                 if let vm = await findVM(), vm.state == .vmStarted {
                     DispatchQueue.global(qos: .background).async {
-                        vm.pauseVM()
+                        vm.requestVmPause()
                     }
                 }
             case "resume":
                 if let vm = await findVM(), vm.state == .vmPaused {
                     DispatchQueue.global(qos: .background).async {
-                        vm.resumeVM()
+                        vm.requestVmResume()
                     }
                 }
                 break

Platform/iOS/Display/VMDisplayMetalViewController.m

@@ -106,7 +106,7 @@
 - (void)viewDidAppear:(BOOL)animated {
     [super viewDidAppear:animated];
     if (self.vm.state == kVMStopped) {
-        [self.vm startVM];
+        [self.vm requestVmStart];
     }
 }
 

Platform/iOS/Display/VMDisplayTerminalViewController.m

@@ -80,7 +80,7 @@ NSString* const kVMSendTerminalSizeHandler = @"UTMSendTerminalSize";
     [super viewWillAppear: animated];
 
     if (self.vm.state == kVMStopped) {
-        [self.vm startVM];
+        [self.vm requestVmStart];
     }
 }
 

Platform/iOS/Display/VMDisplayViewController.swift

@@ -145,7 +145,7 @@ public extension VMDisplayViewController {
         if autosaveLowMemory {
             logger.info("Saving VM state on low memory warning.")
             DispatchQueue.global(qos: .background).async {
-                self.vm.saveVM()
+                self.vm.requestVmSaveState()
             }
         }
         
@@ -267,7 +267,7 @@ extension VMDisplayViewController {
                 task = .invalid
             }
             DispatchQueue.global(qos: .default).async {
-                self.vm.saveVM()
+                self.vm.requestVmSaveState()
                 self.hasAutoSave = true
                 logger.info("Save snapshot complete")
                 UIApplication.shared.endBackgroundTask(task)
@@ -281,7 +281,7 @@ extension VMDisplayViewController {
         if (hasAutoSave && vm.state == .vmStarted) {
             logger.info("Deleting snapshot")
             DispatchQueue.global(qos: .background).async {
-                self.vm.deleteSaveVM()
+                self.vm.requestVmDeleteState()
             }
         }
     }

Platform/iOS/Display/VMToolbarActions.swift

@@ -215,10 +215,10 @@ import SwiftUI
         }
         DispatchQueue.global(qos: .background).async {
             if viewController.vm.state == .vmStarted {
-                viewController.vm.pauseVM()
-                viewController.vm.saveVM()
+                viewController.vm.requestVmPause()
+                viewController.vm.requestVmSaveState()
             } else if viewController.vm.state == .vmPaused {
-                viewController.vm.resumeVM()
+                viewController.vm.requestVmResume()
             }
         }
     }
@@ -230,8 +230,8 @@ import SwiftUI
         if viewController.vm.state == .vmStarted {
             let yes = UIAlertAction(title: NSLocalizedString("Yes", comment: "VMDisplayViewController"), style: .destructive) { action in
                 DispatchQueue.global(qos: .background).async {
-                    viewController.vm.deleteSaveVM()
-                    viewController.vm.quitVM()
+                    viewController.vm.requestVmDeleteState()
+                    viewController.vm.requestVmStop()
                     viewController.terminateApplication()
                 }
             }
@@ -252,7 +252,7 @@ import SwiftUI
         }
         let yes = UIAlertAction(title: NSLocalizedString("Yes", comment: "VMDisplayViewController"), style: .destructive) { action in
             DispatchQueue.global(qos: .background).async {
-                viewController.vm.resetVM()
+                viewController.vm.requestVmReset()
             }
         }
         let no = UIAlertAction(title: NSLocalizedString("No", comment: "VMDisplayViewController"), style: .cancel, handler: nil)

Platform/iOS/UTMDataExtension.swift

@@ -53,7 +53,7 @@ extension UTMData {
     
     func stop(vm: UTMVirtualMachine) throws {
         if vm.viewState.suspended {
-            vm.deleteSaveVM()
+            vm.requestVmDeleteState()
         }
     }
     

Platform/macOS/Display/VMDisplayAppleWindowController.swift

@@ -293,7 +293,7 @@ extension VMDisplayAppleWindowController {
             self.enterSuspended(isBusy: true)
             self.appleConfig.macRecoveryIpswURL = nil
             // start VM
-            self.vm.startVM()
+            self.vm.requestVmStart()
         }
     }
     

Platform/macOS/Display/VMDisplayWindowController.swift

@@ -59,7 +59,7 @@ class VMDisplayWindowController: NSWindowController {
     @IBAction func stopButtonPressed(_ sender: Any) {
         showConfirmAlert(NSLocalizedString("This may corrupt the VM and any unsaved changes will be lost. To quit safely, shut down from the guest.", comment: "VMDisplayWindowController")) {
             DispatchQueue.global(qos: .background).async {
-                self.vm.deleteSaveVM()
+                self.vm.requestVmDeleteState()
                 self.vm.requestVmStop(force: self.isPowerForce)
             }
         }
@@ -68,17 +68,17 @@ class VMDisplayWindowController: NSWindowController {
     @IBAction func startPauseButtonPressed(_ sender: Any) {
         if vm.state == .vmStarted {
             DispatchQueue.global(qos: .background).async {
-                self.vm.pauseVM()
-                self.vm.saveVM()
+                self.vm.requestVmPause()
+                self.vm.requestVmSaveState()
                 return
             }
         } else if vm.state == .vmPaused {
             DispatchQueue.global(qos: .background).async {
-                self.vm.resumeVM()
+                self.vm.requestVmResume()
             }
         } else if vm.state == .vmStopped {
             DispatchQueue.global(qos: .userInitiated).async {
-                self.vm.startVM()
+                self.vm.requestVmStart()
             }
         } else {
             logger.error("Invalid state \(vm.state)")
@@ -88,7 +88,7 @@ class VMDisplayWindowController: NSWindowController {
     @IBAction func restartButtonPressed(_ sender: Any) {
         showConfirmAlert(NSLocalizedString("This will reset the VM and any unsaved state will be lost.", comment: "VMDisplayWindowController")) {
             DispatchQueue.global(qos: .background).async {
-                self.vm.resetVM()
+                self.vm.requestVmReset()
             }
         }
     }
@@ -128,9 +128,9 @@ class VMDisplayWindowController: NSWindowController {
         }
         DispatchQueue.global(qos: .userInitiated).async {
             if (self.vm.state == .vmStopped) {
-                self.vm.startVM()
+                self.vm.requestVmStart()
             } else if (self.vm.state == .vmPaused) {
-                self.vm.resumeVM()
+                self.vm.requestVmResume()
             }
         }
     }

Platform/macOS/UTMDataExtension.swift

@@ -56,7 +56,7 @@ extension UTMData {
     
     func stop(vm: UTMVirtualMachine) throws {
         if vm.viewState.suspended {
-            vm.deleteSaveVM()
+            vm.requestVmDeleteState()
         }
         vm.requestVmStop(force: true)
         if let window = vmWindows[vm] {