You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by da...@apache.org on 2026/09/09 14:25:55 UTC

(cloudstack) branch 4.22 updated: KVM: fix UEFI disk-only instance snapshot NVRAM handling (#13020)

This is an automated email from the ASF dual-hosted git repository.

DaanHoogland pushed a commit to branch 4.22
in repository https://gitbox.apache.org/repos/asf/cloudstack.git


The following commit(s) were added to refs/heads/4.22 by this push:
     new 10d3e115122 KVM: fix UEFI disk-only instance snapshot NVRAM handling (#13020)
10d3e115122 is described below

commit 10d3e115122e4e253c098ce30a76b0bf0ab0c689
Author: Kunal Behbudzade <12...@users.noreply.github.com>
AuthorDate: Wed Sep 9 17:25:48 2026 +0300

    KVM: fix UEFI disk-only instance snapshot NVRAM handling (#13020)
    
    Signed-off-by: kunal.behbudzade <ku...@btsgrp.com>
    Co-authored-by: kunal.behbudzade <ku...@btsgrp.com>
---
 PendingReleaseNotes                                |  14 +
 api/src/main/java/com/cloud/host/Host.java         |   1 +
 .../user/vmsnapshot/CreateVMSnapshotCmd.java       |   3 +-
 .../storage/CreateDiskOnlyVmSnapshotAnswer.java    |  11 +
 .../storage/CreateDiskOnlyVmSnapshotCommand.java   |  17 +
 .../storage/DeleteDiskOnlyVmSnapshotCommand.java   |  25 +-
 .../storage/RevertDiskOnlyVmSnapshotCommand.java   |  22 +
 .../com/cloud/agent/manager/AgentManagerImpl.java  |  38 +-
 .../cloud/agent/manager/AgentManagerImplTest.java  |  37 +-
 .../KvmFileBasedStorageVmSnapshotStrategy.java     | 269 ++++++-
 .../KvmFileBasedStorageVmSnapshotStrategyTest.java | 550 ++++++++++++++
 .../kvm/resource/LibvirtComputingResource.java     |  11 +
 ...virtCreateDiskOnlyVMSnapshotCommandWrapper.java | 254 ++++++-
 ...virtDeleteDiskOnlyVMSnapshotCommandWrapper.java |  38 +
 .../wrapper/LibvirtReadyCommandWrapper.java        |   1 +
 ...virtRevertDiskOnlyVMSnapshotCommandWrapper.java |  94 ++-
 ...ibvirtDiskOnlyVMSnapshotCommandWrapperTest.java | 816 +++++++++++++++++++++
 ui/public/locales/en.json                          |   1 +
 ui/src/config/section/compute.js                   |   1 +
 ui/src/config/section/network.js                   |   1 +
 20 files changed, 2174 insertions(+), 30 deletions(-)

diff --git a/PendingReleaseNotes b/PendingReleaseNotes
index 9670b6e7c13..02d63811e36 100644
--- a/PendingReleaseNotes
+++ b/PendingReleaseNotes
@@ -39,3 +39,17 @@ example.ver.1 > example.ver.2:
     which can now be attached to Instances. This is to prevent the Secondary
     Storage to grow to enormous sizes as Linux Distributions keep growing in
     size while a stripped down Linux should fit on a 2.88MB floppy.
+
+4.22.0.0 > 4.22.0.1:
+  * Disk-only instance snapshots for KVM UEFI VMs now include a sidecar copy of
+    the active NVRAM state so revert operations restore both disk and firmware
+    boot state consistently.
+
+  * UEFI disk-only instance snapshots taken before this change do not contain an
+    NVRAM sidecar and cannot be safely reverted. Take a new snapshot after
+    upgrading before relying on revert for UEFI VMs.
+
+  * Taking a disk-only instance snapshot for KVM UEFI VMs now briefly suspends
+    the guest while the NVRAM sidecar is copied, so that the captured firmware
+    state is consistent with the disk snapshot. Non-UEFI VMs are unaffected and
+    continue to snapshot live.
diff --git a/api/src/main/java/com/cloud/host/Host.java b/api/src/main/java/com/cloud/host/Host.java
index b5234820151..a7b89b8a2b8 100644
--- a/api/src/main/java/com/cloud/host/Host.java
+++ b/api/src/main/java/com/cloud/host/Host.java
@@ -55,6 +55,7 @@ public interface Host extends StateObject<Status>, Identity, Partition, HAResour
     }
 
     String HOST_UEFI_ENABLE = "host.uefi.enable";
+    String HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM = "host.kvm.diskonlyvmsnapshot.nvram";
     String HOST_VOLUME_ENCRYPTION = "host.volume.encryption";
     String HOST_INSTANCE_CONVERSION = "host.instance.conversion";
     String HOST_VDDK_SUPPORT = "host.vddk.support";
diff --git a/api/src/main/java/org/apache/cloudstack/api/command/user/vmsnapshot/CreateVMSnapshotCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/user/vmsnapshot/CreateVMSnapshotCmd.java
index 6e1a7daf4c2..f2decf21a1d 100644
--- a/api/src/main/java/org/apache/cloudstack/api/command/user/vmsnapshot/CreateVMSnapshotCmd.java
+++ b/api/src/main/java/org/apache/cloudstack/api/command/user/vmsnapshot/CreateVMSnapshotCmd.java
@@ -37,7 +37,8 @@ import com.cloud.uservm.UserVm;
 import com.cloud.vm.VirtualMachine;
 import com.cloud.vm.snapshot.VMSnapshot;
 
-@APICommand(name = "createVMSnapshot", description = "Creates Snapshot for an Instance.", responseObject = VMSnapshotResponse.class, since = "4.2.0", entityType = {VMSnapshot.class},
+@APICommand(name = "createVMSnapshot", description = "Creates Snapshot for an Instance. Running KVM UEFI disk-only snapshots briefly suspend the Instance while copying NVRAM state.",
+        responseObject = VMSnapshotResponse.class, since = "4.2.0", entityType = {VMSnapshot.class},
         requestHasSensitiveInfo = false, responseHasSensitiveInfo = false)
 public class CreateVMSnapshotCmd extends BaseAsyncCreateCmd {
 
diff --git a/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotAnswer.java b/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotAnswer.java
index 4d61249c7cb..ffa4eaff296 100644
--- a/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotAnswer.java
+++ b/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotAnswer.java
@@ -27,13 +27,24 @@ import java.util.Map;
 public class CreateDiskOnlyVmSnapshotAnswer extends Answer {
 
     protected Map<String, Pair<Long, String>> mapVolumeToSnapshotSizeAndNewVolumePath;
+    private String nvramSnapshotPath;
 
     public CreateDiskOnlyVmSnapshotAnswer(Command command, boolean success, String details, Map<String, Pair<Long, String>> mapVolumeToSnapshotSizeAndNewVolumePath) {
+        this(command, success, details, mapVolumeToSnapshotSizeAndNewVolumePath, null);
+    }
+
+    public CreateDiskOnlyVmSnapshotAnswer(Command command, boolean success, String details, Map<String, Pair<Long, String>> mapVolumeToSnapshotSizeAndNewVolumePath,
+            String nvramSnapshotPath) {
         super(command, success, details);
         this.mapVolumeToSnapshotSizeAndNewVolumePath = mapVolumeToSnapshotSizeAndNewVolumePath;
+        this.nvramSnapshotPath = nvramSnapshotPath;
     }
 
     public Map<String, Pair<Long, String>> getMapVolumeToSnapshotSizeAndNewVolumePath() {
         return mapVolumeToSnapshotSizeAndNewVolumePath;
     }
+
+    public String getNvramSnapshotPath() {
+        return nvramSnapshotPath;
+    }
 }
diff --git a/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotCommand.java b/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotCommand.java
index 952bf0c971d..7f328bab81d 100644
--- a/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotCommand.java
+++ b/core/src/main/java/com/cloud/agent/api/storage/CreateDiskOnlyVmSnapshotCommand.java
@@ -29,13 +29,30 @@ import java.util.List;
 public class CreateDiskOnlyVmSnapshotCommand extends VMSnapshotBaseCommand {
 
     protected VirtualMachine.State vmState;
+    private final String vmUuid;
+    private final boolean uefiEnabled;
 
     public CreateDiskOnlyVmSnapshotCommand(String vmName, VMSnapshotTO snapshot, List<VolumeObjectTO> volumeTOs, String guestOSType, VirtualMachine.State vmState) {
+        this(vmName, null, snapshot, volumeTOs, guestOSType, vmState, false);
+    }
+
+    public CreateDiskOnlyVmSnapshotCommand(String vmName, String vmUuid, VMSnapshotTO snapshot, List<VolumeObjectTO> volumeTOs, String guestOSType,
+            VirtualMachine.State vmState, boolean uefiEnabled) {
         super(vmName, snapshot, volumeTOs, guestOSType);
+        this.vmUuid = vmUuid;
         this.vmState = vmState;
+        this.uefiEnabled = uefiEnabled;
     }
 
     public VirtualMachine.State getVmState() {
         return vmState;
     }
+
+    public String getVmUuid() {
+        return vmUuid;
+    }
+
+    public boolean isUefiEnabled() {
+        return uefiEnabled;
+    }
 }
diff --git a/core/src/main/java/com/cloud/agent/api/storage/DeleteDiskOnlyVmSnapshotCommand.java b/core/src/main/java/com/cloud/agent/api/storage/DeleteDiskOnlyVmSnapshotCommand.java
index bf7bdd59736..1ac0a0ff719 100644
--- a/core/src/main/java/com/cloud/agent/api/storage/DeleteDiskOnlyVmSnapshotCommand.java
+++ b/core/src/main/java/com/cloud/agent/api/storage/DeleteDiskOnlyVmSnapshotCommand.java
@@ -19,24 +19,43 @@
 package com.cloud.agent.api.storage;
 
 import com.cloud.agent.api.Command;
-
 import com.cloud.agent.api.to.DataTO;
-
+import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
 
 import java.util.List;
 
 public class DeleteDiskOnlyVmSnapshotCommand extends Command {
 
-    List<DataTO> snapshots;
+    private final List<DataTO> snapshots;
+    private final String nvramSnapshotPath;
+    private final PrimaryDataStoreTO primaryDataStore;
 
     public DeleteDiskOnlyVmSnapshotCommand(List<DataTO> snapshots) {
+        this(snapshots, null);
+    }
+
+    public DeleteDiskOnlyVmSnapshotCommand(List<DataTO> snapshots, String nvramSnapshotPath) {
+        this(snapshots, nvramSnapshotPath, null);
+    }
+
+    public DeleteDiskOnlyVmSnapshotCommand(List<DataTO> snapshots, String nvramSnapshotPath, PrimaryDataStoreTO primaryDataStore) {
         this.snapshots = snapshots;
+        this.nvramSnapshotPath = nvramSnapshotPath;
+        this.primaryDataStore = primaryDataStore;
     }
 
     public List<DataTO> getSnapshots() {
         return snapshots;
     }
 
+    public String getNvramSnapshotPath() {
+        return nvramSnapshotPath;
+    }
+
+    public PrimaryDataStoreTO getPrimaryDataStore() {
+        return primaryDataStore;
+    }
+
     @Override
     public boolean executeInSequence() {
         return false;
diff --git a/core/src/main/java/com/cloud/agent/api/storage/RevertDiskOnlyVmSnapshotCommand.java b/core/src/main/java/com/cloud/agent/api/storage/RevertDiskOnlyVmSnapshotCommand.java
index 72bb92bcb10..3c9859aa44a 100644
--- a/core/src/main/java/com/cloud/agent/api/storage/RevertDiskOnlyVmSnapshotCommand.java
+++ b/core/src/main/java/com/cloud/agent/api/storage/RevertDiskOnlyVmSnapshotCommand.java
@@ -27,11 +27,21 @@ public class RevertDiskOnlyVmSnapshotCommand extends Command {
 
     private List<SnapshotObjectTO> snapshotObjectTos;
     private String vmName;
+    private final String vmUuid;
+    private final boolean uefiEnabled;
+    private final String nvramSnapshotPath;
 
     public RevertDiskOnlyVmSnapshotCommand(List<SnapshotObjectTO> snapshotObjectTos, String vmName) {
+        this(snapshotObjectTos, vmName, null, false, null);
+    }
+
+    public RevertDiskOnlyVmSnapshotCommand(List<SnapshotObjectTO> snapshotObjectTos, String vmName, String vmUuid, boolean uefiEnabled, String nvramSnapshotPath) {
         super();
         this.snapshotObjectTos = snapshotObjectTos;
         this.vmName = vmName;
+        this.vmUuid = vmUuid;
+        this.uefiEnabled = uefiEnabled;
+        this.nvramSnapshotPath = nvramSnapshotPath;
     }
 
     public List<SnapshotObjectTO> getSnapshotObjectTos() {
@@ -42,6 +52,18 @@ public class RevertDiskOnlyVmSnapshotCommand extends Command {
         return vmName;
     }
 
+    public String getVmUuid() {
+        return vmUuid;
+    }
+
+    public boolean isUefiEnabled() {
+        return uefiEnabled;
+    }
+
+    public String getNvramSnapshotPath() {
+        return nvramSnapshotPath;
+    }
+
     @Override
     public boolean executeInSequence() {
         return false;
diff --git a/engine/orchestration/src/main/java/com/cloud/agent/manager/AgentManagerImpl.java b/engine/orchestration/src/main/java/com/cloud/agent/manager/AgentManagerImpl.java
index 8c69dcdc482..ecb789a15bd 100644
--- a/engine/orchestration/src/main/java/com/cloud/agent/manager/AgentManagerImpl.java
+++ b/engine/orchestration/src/main/java/com/cloud/agent/manager/AgentManagerImpl.java
@@ -108,10 +108,12 @@ import com.cloud.exception.OperationTimedoutException;
 import com.cloud.exception.UnsupportedVersionException;
 import com.cloud.ha.HighAvailabilityManager;
 import com.cloud.host.Host;
+import com.cloud.host.DetailVO;
 import com.cloud.host.HostVO;
 import com.cloud.host.Status;
 import com.cloud.host.Status.Event;
 import com.cloud.host.dao.HostDao;
+import com.cloud.host.dao.HostDetailsDao;
 import com.cloud.hypervisor.Hypervisor.HypervisorType;
 import com.cloud.hypervisor.HypervisorGuruManager;
 import com.cloud.org.Cluster;
@@ -167,6 +169,8 @@ public class AgentManagerImpl extends ManagerBase implements AgentManager, Handl
     @Inject
     protected HostDao _hostDao = null;
     @Inject
+    protected HostDetailsDao _hostDetailsDao = null;
+    @Inject
     private ManagementServerHostDao _mshostDao;
     @Inject
     protected OutOfBandManagementDao outOfBandManagementDao;
@@ -802,18 +806,24 @@ public class AgentManagerImpl extends ManagerBase implements AgentManager, Handl
             ReadyAnswer readyAnswer = (ReadyAnswer)answer;
             Map<String, String> detailsMap = readyAnswer.getDetailsMap();
             if (detailsMap != null) {
+                _hostDao.loadDetails(host);
+                if (host.getDetails() == null) {
+                    host.setDetails(new HashMap<>());
+                }
                 String uefiEnabled = detailsMap.get(Host.HOST_UEFI_ENABLE);
+                String diskOnlyVmSnapshotNvramSupport = detailsMap.get(Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM);
                 String virtv2vVersion = detailsMap.get(Host.HOST_VIRTV2V_VERSION);
                 String ovftoolVersion = detailsMap.get(Host.HOST_OVFTOOL_VERSION);
                 String vddkSupport = detailsMap.get(Host.HOST_VDDK_SUPPORT);
                 String vddkLibDir = detailsMap.get(Host.HOST_VDDK_LIB_DIR);
                 String vddkVersion = detailsMap.get(Host.HOST_VDDK_VERSION);
                 logger.debug("Got HOST_UEFI_ENABLE [{}] for host [{}]:", uefiEnabled, host);
-                if (ObjectUtils.anyNotNull(uefiEnabled, virtv2vVersion, ovftoolVersion, vddkSupport, vddkLibDir, vddkVersion)) {
-                    _hostDao.loadDetails(host);
+                if (ObjectUtils.anyNotNull(uefiEnabled, diskOnlyVmSnapshotNvramSupport, virtv2vVersion, ovftoolVersion, vddkSupport, vddkLibDir, vddkVersion)) {
                     boolean updateNeeded = false;
-                    if (StringUtils.isNotBlank(uefiEnabled) && !uefiEnabled.equals(host.getDetails().get(Host.HOST_UEFI_ENABLE))) {
-                        host.getDetails().put(Host.HOST_UEFI_ENABLE, uefiEnabled);
+                    if (syncBooleanHostCapability(host, Host.HOST_UEFI_ENABLE, uefiEnabled)) {
+                        updateNeeded = true;
+                    }
+                    if (syncBooleanHostCapability(host, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, diskOnlyVmSnapshotNvramSupport)) {
                         updateNeeded = true;
                     }
                     if (StringUtils.isNotBlank(virtv2vVersion) && !virtv2vVersion.equals(host.getDetails().get(Host.HOST_VIRTV2V_VERSION))) {
@@ -856,6 +866,26 @@ public class AgentManagerImpl extends ManagerBase implements AgentManager, Handl
         return attache;
     }
 
+    protected boolean syncBooleanHostCapability(HostVO host, String capabilityName, String advertisedValue) {
+        if (StringUtils.isNotBlank(advertisedValue)) {
+            if (!advertisedValue.equals(host.getDetails().get(capabilityName))) {
+                host.getDetails().put(capabilityName, advertisedValue);
+                return true;
+            }
+            return false;
+        }
+
+        if (host.getDetails().containsKey(capabilityName)) {
+            host.getDetails().remove(capabilityName);
+            DetailVO hostDetail = _hostDetailsDao.findDetail(host.getId(), capabilityName);
+            if (hostDetail != null) {
+                _hostDetailsDao.remove(hostDetail.getId());
+            }
+            return true;
+        }
+        return false;
+    }
+
     @Override
     public boolean start() {
         ManagementServerHostVO msHost = _mshostDao.findByMsid(_nodeId);
diff --git a/engine/orchestration/src/test/java/com/cloud/agent/manager/AgentManagerImplTest.java b/engine/orchestration/src/test/java/com/cloud/agent/manager/AgentManagerImplTest.java
index 43d83a672c0..2377bbaefbc 100644
--- a/engine/orchestration/src/test/java/com/cloud/agent/manager/AgentManagerImplTest.java
+++ b/engine/orchestration/src/test/java/com/cloud/agent/manager/AgentManagerImplTest.java
@@ -18,14 +18,17 @@ package com.cloud.agent.manager;
 
 import com.cloud.agent.Listener;
 import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.ReadyAnswer;
 import com.cloud.agent.api.ReadyCommand;
 import com.cloud.agent.api.StartupCommand;
 import com.cloud.agent.api.StartupRoutingCommand;
 import com.cloud.exception.ConnectionException;
+import com.cloud.host.DetailVO;
 import com.cloud.host.Host;
 import com.cloud.host.HostVO;
 import com.cloud.host.Status;
 import com.cloud.host.dao.HostDao;
+import com.cloud.host.dao.HostDetailsDao;
 import com.cloud.hypervisor.Hypervisor;
 import com.cloud.utils.Pair;
 import org.junit.Assert;
@@ -34,10 +37,13 @@ import org.junit.Test;
 import org.mockito.Mockito;
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 
 public class AgentManagerImplTest {
 
     private HostDao hostDao;
+    private HostDetailsDao hostDetailsDao;
     private Listener storagePoolMonitor;
     private AgentAttache attache;
     private AgentManagerImpl mgr = Mockito.spy(new AgentManagerImpl());
@@ -46,15 +52,18 @@ public class AgentManagerImplTest {
 
     @Before
     public void setUp() throws Exception {
-        host = new HostVO("some-Uuid");
+        host = Mockito.spy(new HostVO("some-Uuid"));
+        Mockito.when(host.getId()).thenReturn(1L);
         host.setDataCenterId(1L);
         cmds = new StartupCommand[]{new StartupRoutingCommand()};
         attache = new ConnectedAgentAttache(null, 1L, "uuid", "kvm-attache", Hypervisor.HypervisorType.KVM, null, false);
 
         hostDao = Mockito.mock(HostDao.class);
+        hostDetailsDao = Mockito.mock(HostDetailsDao.class);
         storagePoolMonitor = Mockito.mock(Listener.class);
 
         mgr._hostDao = hostDao;
+        mgr._hostDetailsDao = hostDetailsDao;
         mgr._hostMonitors = new ArrayList<>();
         mgr._hostMonitors.add(new Pair<>(0, storagePoolMonitor));
     }
@@ -86,6 +95,32 @@ public class AgentManagerImplTest {
         Mockito.verify(mgr, Mockito.times(1)).handleDisconnectWithoutInvestigation(Mockito.any(attache.getClass()), Mockito.eq(Status.Event.AgentDisconnected), Mockito.eq(true), Mockito.eq(true));
     }
 
+    @Test
+    public void testNotifyMonitorsOfConnectionClearsStaleNvramCapabilityOnReconnect() throws ConnectionException {
+        DetailVO staleNvramCapability = Mockito.mock(DetailVO.class);
+        ReadyAnswer readyAnswer = Mockito.mock(ReadyAnswer.class);
+        host.setDetails(new HashMap<>(Map.of(Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString(),
+                Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString())));
+
+        Mockito.when(staleNvramCapability.getId()).thenReturn(11L);
+        Mockito.when(hostDao.findById(Mockito.anyLong())).thenReturn(host);
+        Mockito.doNothing().when(hostDao).loadDetails(host);
+        Mockito.when(hostDetailsDao.findDetail(host.getId(), Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)).thenReturn(staleNvramCapability);
+        Mockito.doNothing().when(storagePoolMonitor).processConnect(Mockito.eq(host), Mockito.eq(cmds[0]), Mockito.eq(false));
+        Mockito.doReturn(true).when(mgr).handleDisconnectWithoutInvestigation(Mockito.any(attache.getClass()), Mockito.any(Status.Event.class), Mockito.anyBoolean(), Mockito.anyBoolean());
+        Mockito.when(readyAnswer.getResult()).thenReturn(true);
+        Mockito.when(readyAnswer.getDetailsMap()).thenReturn(Map.of(Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString()));
+        Mockito.doReturn(readyAnswer).when(mgr).easySend(Mockito.anyLong(), Mockito.any(ReadyCommand.class));
+        Mockito.doReturn(true).when(mgr).agentStatusTransitTo(Mockito.eq(host), Mockito.eq(Status.Event.Ready), Mockito.anyLong());
+
+        final AgentAttache agentAttache = mgr.notifyMonitorsOfConnection(attache, cmds, false);
+
+        Assert.assertTrue(agentAttache.isReady());
+        Assert.assertFalse(host.getDetails().containsKey(Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM));
+        Mockito.verify(hostDetailsDao).remove(11L);
+        Mockito.verify(hostDao).saveDetails(host);
+    }
+
     @Test
     public void testGetTimeoutWithPositiveTimeout() {
         Commands commands = Mockito.mock(Commands.class);
diff --git a/engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategy.java b/engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategy.java
index 003065e394f..79e2a972203 100644
--- a/engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategy.java
+++ b/engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategy.java
@@ -28,9 +28,14 @@ import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotAnswer;
 import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotCommand;
 import com.cloud.agent.api.storage.SnapshotMergeTreeTO;
 import com.cloud.agent.api.to.DataTO;
+import com.cloud.alert.AlertManager;
 import com.cloud.configuration.Resource;
 import com.cloud.event.EventTypes;
 import com.cloud.event.UsageEventUtils;
+import com.cloud.host.DetailVO;
+import com.cloud.host.Host;
+import com.cloud.host.HostVO;
+import com.cloud.host.dao.HostDetailsDao;
 import com.cloud.hypervisor.Hypervisor;
 import com.cloud.storage.DataStoreRole;
 import com.cloud.storage.Snapshot;
@@ -46,9 +51,11 @@ import com.cloud.utils.exception.CloudRuntimeException;
 import com.cloud.utils.fsm.NoTransitionException;
 import com.cloud.vm.UserVmVO;
 import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.dao.VMInstanceDetailsDao;
 import com.cloud.vm.snapshot.VMSnapshot;
 import com.cloud.vm.snapshot.VMSnapshotDetailsVO;
 import com.cloud.vm.snapshot.VMSnapshotVO;
+import org.apache.cloudstack.api.ApiConstants;
 import org.apache.cloudstack.backup.BackupOfferingVO;
 import org.apache.cloudstack.backup.dao.BackupOfferingDao;
 import org.apache.cloudstack.engine.subsystem.api.storage.ObjectInDataStoreStateMachine;
@@ -59,10 +66,12 @@ import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;
 import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
 import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreVO;
 import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
 import org.apache.cloudstack.storage.snapshot.SnapshotObject;
 import org.apache.cloudstack.storage.to.SnapshotObjectTO;
 import org.apache.cloudstack.storage.to.VolumeObjectTO;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
@@ -76,6 +85,7 @@ import java.util.stream.Collectors;
 public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStrategy {
 
     private static final List<Storage.StoragePoolType> supportedStoragePoolTypes = List.of(Storage.StoragePoolType.Filesystem, Storage.StoragePoolType.NetworkFilesystem, Storage.StoragePoolType.SharedMountPoint);
+    private static final String KVM_FILE_BASED_STORAGE_SNAPSHOT_NVRAM = "kvmFileBasedStorageSnapshotNvram";
 
     @Inject
     protected SnapshotDataStoreDao snapshotDataStoreDao;
@@ -86,6 +96,15 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
     @Inject
     protected BackupOfferingDao backupOfferingDao;
 
+    @Inject
+    protected VMInstanceDetailsDao vmInstanceDetailsDao;
+
+    @Inject
+    protected HostDetailsDao hostDetailsDao;
+
+    @Inject
+    protected AlertManager alertManager;
+
     @Override
     public VMSnapshot takeVMSnapshot(VMSnapshot vmSnapshot) {
         Map<VolumeInfo, SnapshotObject> volumeInfoToSnapshotObjectMap = new HashMap<>();
@@ -116,7 +135,8 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
         logger.info("Starting VM snapshot delete process for snapshot [{}].", vmSnapshot.getUuid());
         UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
         VMSnapshotVO vmSnapshotBeingDeleted = (VMSnapshotVO) vmSnapshot;
-        Long hostId = vmSnapshotHelper.pickRunningHost(vmSnapshotBeingDeleted.getVmId());
+        Long hostId = pickHostForNvramSidecarCleanup(vmSnapshotBeingDeleted, userVm, "delete");
+        validateHostSupportsNvramSidecarCleanup(vmSnapshotBeingDeleted, hostId, "delete");
         long virtualSize = 0;
         boolean isCurrent = vmSnapshotBeingDeleted.getCurrent();
 
@@ -124,6 +144,7 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
 
         List<VolumeObjectTO> volumeTOs = vmSnapshotHelper.getVolumeTOList(vmSnapshotBeingDeleted.getVmId());
         List<VMSnapshotVO> snapshotChildren = vmSnapshotDao.listByParentAndStateIn(vmSnapshotBeingDeleted.getId(), VMSnapshot.State.Ready, VMSnapshot.State.Hidden);
+        PrimaryDataStoreTO nvramPrimaryDataStore = getPrimaryDataStoreForNvramCleanup(vmSnapshotBeingDeleted, volumeTOs);
 
         long realSize = getVMSnapshotRealSize(vmSnapshotBeingDeleted);
         int numberOfChildren = snapshotChildren.size();
@@ -157,6 +178,8 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
             return true;
         }
 
+        deleteNvramSnapshotIfNeeded(vmSnapshotBeingDeleted, hostId, nvramPrimaryDataStore);
+
         transitStateWithoutThrow(vmSnapshotBeingDeleted, VMSnapshot.Event.OperationSucceeded);
 
         vmSnapshotDetailsDao.removeDetails(vmSnapshotBeingDeleted.getId());
@@ -175,7 +198,8 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
         }
 
         VMSnapshotVO vmSnapshotBeingReverted = (VMSnapshotVO) vmSnapshot;
-        Long hostId = vmSnapshotHelper.pickRunningHost(vmSnapshotBeingReverted.getVmId());
+        Long hostId = pickHostForUefiNvramAwareDiskOnlySnapshot(userVm, "revert");
+        validateHostSupportsUefiNvramAwareDiskOnlySnapshots(hostId, userVm, "revert");
 
         transitStateWithoutThrow(vmSnapshotBeingReverted, VMSnapshot.Event.RevertRequested);
 
@@ -184,7 +208,9 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
                 .map(snapshot -> (SnapshotObjectTO) snapshotDataFactory.getSnapshot(snapshot.getSnapshotId(), snapshot.getDataStoreId(), DataStoreRole.Primary).getTO())
                 .collect(Collectors.toList());
 
-        RevertDiskOnlyVmSnapshotCommand revertDiskOnlyVMSnapshotCommand = new RevertDiskOnlyVmSnapshotCommand(volumeSnapshotTos, userVm.getName());
+        RevertDiskOnlyVmSnapshotCommand revertDiskOnlyVMSnapshotCommand =
+                new RevertDiskOnlyVmSnapshotCommand(volumeSnapshotTos, userVm.getName(), userVm.getUuid(), isUefiVm(userVm),
+                        getNvramSnapshotPath(vmSnapshotBeingReverted));
         Answer answer = agentMgr.easySend(hostId, revertDiskOnlyVMSnapshotCommand);
 
         if (answer == null || !answer.getResult()) {
@@ -204,6 +230,13 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
             publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_REVERT, vmSnapshotBeingReverted, userVm, volumeObjectTo);
         }
 
+        if (isUefiVm(userVm) && !Objects.equals(userVm.getLastHostId(), hostId)) {
+            logger.debug("Updating last host of UEFI VM [{}] to [{}] after disk-only snapshot revert because the NVRAM state was restored on that host.",
+                    userVm.getUuid(), hostId);
+            userVm.setLastHostId(hostId);
+            userVmDao.update(userVm.getId(), userVm);
+        }
+
         transitStateWithoutThrow(vmSnapshotBeingReverted, VMSnapshot.Event.OperationSucceeded);
 
         VMSnapshotVO currentVmSnapshot = vmSnapshotDao.findCurrentSnapshotByVmId(userVm.getId());
@@ -248,6 +281,8 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
             return;
         }
 
+        validateHostSupportsNvramSidecarCleanup(oldParent, hostId, "clean up");
+        PrimaryDataStoreTO nvramPrimaryDataStore = getPrimaryDataStoreForNvramCleanup(oldParent, volumeTOs);
         List<SnapshotVO> snapshotVos;
 
         if (oldParent.getCurrent()) {
@@ -276,6 +311,8 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
             snapshotDao.update(snapshotVO.getId(), snapshotVO);
         }
 
+        deleteNvramSnapshotIfNeeded(oldParent, hostId, nvramPrimaryDataStore);
+
         vmSnapshotDetailsDao.removeDetails(oldParent.getId());
 
         oldParent.setRemoved(DateUtil.now());
@@ -347,12 +384,13 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
     }
 
     private List<SnapshotVO> deleteSnapshot(VMSnapshotVO vmSnapshotVO, Long hostId) {
+        validateHostSupportsNvramSidecarCleanup(vmSnapshotVO, hostId, "delete");
         List<SnapshotDataStoreVO> volumeSnapshots = getVolumeSnapshotsAssociatedWithVmSnapshot(vmSnapshotVO);
         List<DataTO> volumeSnapshotTOList = volumeSnapshots.stream()
                 .map(snapshotDataStoreVO -> snapshotDataFactory.getSnapshot(snapshotDataStoreVO.getSnapshotId(), snapshotDataStoreVO.getDataStoreId(), DataStoreRole.Primary).getTO())
                 .collect(Collectors.toList());
 
-        DeleteDiskOnlyVmSnapshotCommand deleteSnapshotCommand = new DeleteDiskOnlyVmSnapshotCommand(volumeSnapshotTOList);
+        DeleteDiskOnlyVmSnapshotCommand deleteSnapshotCommand = new DeleteDiskOnlyVmSnapshotCommand(volumeSnapshotTOList, getNvramSnapshotPath(vmSnapshotVO));
         Answer answer = agentMgr.easySend(hostId, deleteSnapshotCommand);
         if (answer == null || !answer.getResult()) {
             logger.error("Failed to delete VM snapshot [{}] due to {}.", vmSnapshotVO.getUuid(), answer != null ? answer.getDetails() : "Communication failure");
@@ -368,6 +406,20 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
         return snapshotVOList;
     }
 
+    protected void deleteNvramSnapshotIfNeeded(VMSnapshotVO vmSnapshotVO, Long hostId, PrimaryDataStoreTO primaryDataStore) {
+        String nvramSnapshotPath = getNvramSnapshotPath(vmSnapshotVO);
+        if (StringUtils.isBlank(nvramSnapshotPath) || primaryDataStore == null) {
+            return;
+        }
+
+        DeleteDiskOnlyVmSnapshotCommand deleteSnapshotCommand = new DeleteDiskOnlyVmSnapshotCommand(List.of(), nvramSnapshotPath, primaryDataStore);
+        Answer answer = agentMgr.easySend(hostId, deleteSnapshotCommand);
+        if (answer == null || !answer.getResult()) {
+            logger.warn("Failed to delete the NVRAM sidecar of VM snapshot [{}] due to {}.", vmSnapshotVO.getUuid(),
+                    answer != null ? answer.getDetails() : "communication failure");
+        }
+    }
+
     private List<SnapshotVO> mergeSnapshots(VMSnapshotVO vmSnapshotVO, VMSnapshotVO childSnapshot, UserVmVO userVm, List<VolumeObjectTO> volumeObjectTOS, Long hostId) {
         logger.debug("Merging VM snapshot [{}] with its child [{}].", vmSnapshotVO.getUuid(), childSnapshot.getUuid());
 
@@ -470,12 +522,13 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
 
         logger.info("Starting disk-only VM snapshot process for VM [{}].", userVm.getUuid());
 
-        Long hostId = vmSnapshotHelper.pickRunningHost(vmSnapshot.getVmId());
+        transitStateWithoutThrow(vmSnapshot, VMSnapshot.Event.CreateRequested);
+
+        Long hostId = pickHostForUefiNvramAwareDiskOnlySnapshot(userVm, "create");
+        validateHostSupportsUefiNvramAwareDiskOnlySnapshots(hostId, userVm, "create");
         VMSnapshotVO vmSnapshotVO = (VMSnapshotVO) vmSnapshot;
         List<VolumeObjectTO> volumeTOs = vmSnapshotHelper.getVolumeTOList(userVm.getId());
 
-        transitStateWithoutThrow(vmSnapshot, VMSnapshot.Event.CreateRequested);
-
         VMSnapshotTO parentSnapshotTo = null;
         VMSnapshotVO parentSnapshotVo = vmSnapshotDao.findCurrentSnapshotByVmId(userVm.getId());
         if (parentSnapshotVo != null) {
@@ -493,14 +546,18 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
 
         VMSnapshotTO target = new VMSnapshotTO(vmSnapshot.getId(), vmSnapshot.getName(), vmSnapshot.getType(), null, vmSnapshot.getDescription(), false, parentSnapshotTo, quiesceVm);
 
-        CreateDiskOnlyVmSnapshotCommand ccmd = new CreateDiskOnlyVmSnapshotCommand(userVm.getInstanceName(), target, volumeTOs, null, userVm.getState());
+        CreateDiskOnlyVmSnapshotCommand ccmd =
+                new CreateDiskOnlyVmSnapshotCommand(userVm.getInstanceName(), userVm.getUuid(), target, volumeTOs, null, userVm.getState(), isUefiVm(userVm));
 
         logger.info("Sending disk-only VM snapshot creation of VM Snapshot [{}] command for host [{}].", vmSnapshot.getUuid(), hostId);
         Answer answer = agentMgr.easySend(hostId, ccmd);
 
         if (answer != null && answer.getResult()) {
             CreateDiskOnlyVmSnapshotAnswer createDiskOnlyVMSnapshotAnswer = (CreateDiskOnlyVmSnapshotAnswer) answer;
-            return processCreateVmSnapshotAnswer(vmSnapshot, volumeInfoToSnapshotObjectMap, createDiskOnlyVMSnapshotAnswer, userVm, vmSnapshotVO, virtualSize, parentSnapshotVo);
+            VMSnapshot createdVmSnapshot = processCreateVmSnapshotAnswer(vmSnapshot, volumeInfoToSnapshotObjectMap, createDiskOnlyVMSnapshotAnswer, userVm, vmSnapshotVO,
+                    virtualSize, parentSnapshotVo);
+            notifyGuestRecoveryIssueIfNeeded(createDiskOnlyVMSnapshotAnswer, userVm, vmSnapshotVO);
+            return createdVmSnapshot;
         }
 
         logger.error("Disk-only VM snapshot for VM [{}] failed{}.", userVm.getUuid(), answer != null ? " due to" + answer.getDetails() : "");
@@ -541,6 +598,14 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
             publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_CREATE, vmSnapshot, userVm, (VolumeObjectTO) volumeInfo.getTO());
         }
 
+        if (StringUtils.isNotBlank(answer.getNvramSnapshotPath())) {
+            vmSnapshotDetailsDao.addDetail(vmSnapshot.getId(), KVM_FILE_BASED_STORAGE_SNAPSHOT_NVRAM, answer.getNvramSnapshotPath(), false);
+        } else if (isUefiVm(userVm)) {
+            logger.warn("Disk-only snapshot [{}] for UEFI VM [{}] was created without an NVRAM sidecar and cannot be safely reverted. "
+                    + "Upgrade the KVM agent and take a new snapshot.",
+                    vmSnapshot.getUuid(), userVm.getUuid());
+        }
+
         vmSnapshotVO.setCurrent(true);
         vmSnapshotDao.persist(vmSnapshotVO);
 
@@ -651,6 +716,192 @@ public class KvmFileBasedStorageVmSnapshotStrategy extends StorageVMSnapshotStra
         return realSize;
     }
 
+    protected boolean isUefiVm(UserVm userVm) {
+        return vmInstanceDetailsDao.findDetail(userVm.getId(), ApiConstants.BootType.UEFI.toString()) != null;
+    }
+
+    protected PrimaryDataStoreTO getRootVolumePrimaryDataStore(List<VolumeObjectTO> volumeTOs) {
+        return (PrimaryDataStoreTO) volumeTOs.stream()
+                .filter(volumeObjectTO -> Volume.Type.ROOT.equals(volumeObjectTO.getVolumeType()))
+                .findFirst()
+                .orElseThrow(() -> new CloudRuntimeException("Failed to locate the root volume while handling the VM snapshot."))
+                .getDataStore();
+    }
+
+    protected PrimaryDataStoreTO getRootVolumePrimaryDataStoreForCleanup(VMSnapshotVO vmSnapshot, List<VolumeObjectTO> volumeTOs) {
+        try {
+            return getRootVolumePrimaryDataStore(volumeTOs);
+        } catch (CloudRuntimeException e) {
+            logger.warn("Failed to locate the root volume while cleaning up the NVRAM sidecar for VM snapshot [{}].", vmSnapshot.getUuid(), e);
+            return null;
+        }
+    }
+
+    protected PrimaryDataStoreTO getPrimaryDataStoreForNvramCleanup(VMSnapshotVO vmSnapshot, List<VolumeObjectTO> volumeTOs) {
+        PrimaryDataStoreTO rootSnapshotPrimaryDataStore = getRootSnapshotPrimaryDataStoreForCleanup(vmSnapshot);
+        return rootSnapshotPrimaryDataStore != null ? rootSnapshotPrimaryDataStore : getRootVolumePrimaryDataStoreForCleanup(vmSnapshot, volumeTOs);
+    }
+
+    protected PrimaryDataStoreTO getRootSnapshotPrimaryDataStoreForCleanup(VMSnapshotVO vmSnapshot) {
+        try {
+            return (PrimaryDataStoreTO) getVolumeSnapshotsAssociatedWithVmSnapshot(vmSnapshot).stream()
+                    .map(snapshotDataStoreVO -> (SnapshotObjectTO) snapshotDataFactory.getSnapshot(snapshotDataStoreVO.getSnapshotId(),
+                            snapshotDataStoreVO.getDataStoreId(), DataStoreRole.Primary).getTO())
+                    .filter(snapshotObjectTO -> Volume.Type.ROOT.equals(snapshotObjectTO.getVolume().getVolumeType()))
+                    .findFirst()
+                    .orElseThrow(() -> new CloudRuntimeException("Failed to locate the root volume snapshot while handling the VM snapshot."))
+                    .getDataStore();
+        } catch (CloudRuntimeException e) {
+            logger.warn("Failed to locate the root volume snapshot while cleaning up the NVRAM sidecar for VM snapshot [{}].", vmSnapshot.getUuid(), e);
+            return null;
+        }
+    }
+
+    protected String getNvramSnapshotPath(VMSnapshotVO vmSnapshot) {
+        VMSnapshotDetailsVO nvramDetail = vmSnapshotDetailsDao.findDetail(vmSnapshot.getId(), KVM_FILE_BASED_STORAGE_SNAPSHOT_NVRAM);
+        return nvramDetail != null ? nvramDetail.getValue() : null;
+    }
+
+    protected Long pickHostForUefiNvramAwareDiskOnlySnapshot(UserVm userVm, String operation) {
+        Long selectedHostId = vmSnapshotHelper.pickRunningHost(userVm.getId());
+        if (!isUefiVm(userVm)) {
+            return selectedHostId;
+        }
+
+        boolean isCreate = "create".equals(operation);
+        if (isCreate) {
+            validateUefiSnapshotCreateHostOwnsActiveNvram(userVm, selectedHostId);
+        }
+
+        return pickHostWithRequiredCapabilities(userVm, selectedHostId, operation, !isCreate,
+                List.of(Host.HOST_UEFI_ENABLE, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM));
+    }
+
+    protected void validateUefiSnapshotCreateHostOwnsActiveNvram(UserVm userVm, Long selectedHostId) {
+        if (VirtualMachine.State.Running.equals(userVm.getState())) {
+            return;
+        }
+
+        Long lastHostId = userVm.getLastHostId();
+        if (lastHostId == null || !Objects.equals(lastHostId, selectedHostId)) {
+            throw new CloudRuntimeException(String.format("Cannot create a disk-only snapshot for stopped UEFI VM [%s] on host [%s] because the active NVRAM "
+                    + "state is expected on last host [%s]. Make the last host available or start the VM on a UEFI-capable KVM host before retrying.",
+                    userVm.getUuid(), selectedHostId, lastHostId));
+        }
+    }
+
+    protected Long pickHostForNvramSidecarCleanup(VMSnapshotVO vmSnapshotVO, UserVm userVm, String operation) {
+        Long selectedHostId = vmSnapshotHelper.pickRunningHost(vmSnapshotVO.getVmId());
+        if (StringUtils.isBlank(getNvramSnapshotPath(vmSnapshotVO))) {
+            return selectedHostId;
+        }
+
+        return pickHostWithRequiredCapabilities(userVm, selectedHostId, operation, true, List.of(Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM));
+    }
+
+    protected Long pickHostWithRequiredCapabilities(UserVm userVm, Long selectedHostId, String operation, boolean canFallbackFromSelectedHost,
+            List<String> requiredCapabilities) {
+        if (hostSupportsCapabilities(selectedHostId, requiredCapabilities)) {
+            return selectedHostId;
+        }
+
+        if (VirtualMachine.State.Running.equals(userVm.getState()) || !canFallbackFromSelectedHost) {
+            return selectedHostId;
+        }
+
+        return listCandidateHostsForVmSnapshot(userVm).stream()
+                .filter(host -> hostSupportsCapabilities(host.getId(), requiredCapabilities))
+                .findFirst()
+                .map(HostVO::getId)
+                .orElseThrow(() -> new CloudRuntimeException(String.format("Cannot %s disk-only snapshot state for VM [%s] because no Up and Enabled host in the "
+                        + "VM storage scope advertises [%s].", operation, userVm.getUuid(), String.join(", ", requiredCapabilities))));
+    }
+
+    protected List<HostVO> listCandidateHostsForVmSnapshot(UserVm userVm) {
+        List<VolumeVO> volumes = volumeDao.findByInstance(userVm.getId());
+        if (CollectionUtils.isEmpty(volumes)) {
+            throw new CloudRuntimeException(String.format("Cannot find a host for VM snapshot operation because VM [%s] has no volumes.", userVm.getUuid()));
+        }
+
+        VolumeVO volume = volumes.stream()
+                .filter(volumeVO -> Volume.Type.ROOT.equals(volumeVO.getVolumeType()))
+                .findFirst()
+                .orElse(volumes.get(0));
+        Long poolId = volume.getPoolId();
+        if (poolId == null) {
+            throw new CloudRuntimeException(String.format("Cannot find a host for VM snapshot operation because volume [%s] has no pool.", volume.getUuid()));
+        }
+
+        StoragePoolVO storagePoolVO = storagePool.findById(poolId);
+        if (storagePoolVO == null) {
+            throw new CloudRuntimeException(String.format("Cannot find a host for VM snapshot operation because storage pool [%s] was not found.", poolId));
+        }
+
+        List<HostVO> hosts = hostDao.listAllUpAndEnabledNonHAHosts(Host.Type.Routing, storagePoolVO.getClusterId(), storagePoolVO.getPodId(),
+                storagePoolVO.getDataCenterId(), null);
+        if (CollectionUtils.isEmpty(hosts)) {
+            throw new CloudRuntimeException(String.format("Cannot find a host for VM snapshot operation because no Up and Enabled host was found in storage pool [%s] scope.",
+                    storagePoolVO.getUuid()));
+        }
+        return hosts;
+    }
+
+    protected boolean hostSupportsCapabilities(Long hostId, List<String> requiredCapabilities) {
+        if (hostId == null || CollectionUtils.isEmpty(requiredCapabilities)) {
+            return false;
+        }
+        return requiredCapabilities.stream().allMatch(capability -> isHostCapabilityEnabled(hostId, capability));
+    }
+
+    protected void validateHostSupportsUefiNvramAwareDiskOnlySnapshots(Long hostId, UserVm userVm, String operation) {
+        if (!isUefiVm(userVm)) {
+            return;
+        }
+
+        if (!isHostCapabilityEnabled(hostId, Host.HOST_UEFI_ENABLE)) {
+            throw new CloudRuntimeException(String.format("Cannot %s a disk-only snapshot for UEFI VM [%s] on host [%s] because the host does not advertise "
+                    + "UEFI support. Ensure the host is configured with UEFI support and retry.", operation, userVm.getUuid(), hostId));
+        }
+
+        if (!isHostCapabilityEnabled(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)) {
+            throw new CloudRuntimeException(String.format("Cannot %s a disk-only snapshot for UEFI VM [%s] on host [%s] because the KVM agent does not advertise "
+                    + "NVRAM-aware disk-only snapshot support. Upgrade the host and retry.", operation, userVm.getUuid(), hostId));
+        }
+    }
+
+    protected boolean isHostCapabilityEnabled(Long hostId, String capabilityName) {
+        DetailVO hostCapability = hostDetailsDao.findDetail(hostId, capabilityName);
+        return hostCapability != null && Boolean.parseBoolean(hostCapability.getValue());
+    }
+
+    protected void validateHostSupportsNvramSidecarCleanup(VMSnapshotVO vmSnapshotVO, Long hostId, String operation) {
+        if (StringUtils.isBlank(getNvramSnapshotPath(vmSnapshotVO))) {
+            return;
+        }
+
+        if (!isHostCapabilityEnabled(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)) {
+            throw new CloudRuntimeException(String.format("Cannot %s VM snapshot [%s] on host [%s] because the KVM agent does not advertise "
+                    + "NVRAM-aware disk-only snapshot support and the snapshot has an NVRAM sidecar that must be cleaned up. Upgrade the host and retry.",
+                    operation, vmSnapshotVO.getUuid(), hostId));
+        }
+    }
+
+    protected void notifyGuestRecoveryIssueIfNeeded(CreateDiskOnlyVmSnapshotAnswer answer, UserVm userVm, VMSnapshotVO vmSnapshot) {
+        if (StringUtils.isBlank(answer.getDetails())) {
+            return;
+        }
+
+        String subject = String.format("Disk-only VM snapshot [%s] completed with guest recovery warnings", vmSnapshot.getUuid());
+        String message = String.format("Disk-only VM snapshot [%s] for UEFI VM [%s] completed, but post-snapshot guest recovery reported: %s",
+                vmSnapshot.getUuid(), userVm.getUuid(), answer.getDetails());
+        logger.error(message);
+        try {
+            alertManager.sendAlert(AlertManager.AlertType.ALERT_TYPE_VM_SNAPSHOT, userVm.getDataCenterId(), userVm.getPodIdToDeployIn(), subject, message);
+        } catch (Exception e) {
+            logger.warn("Failed to send post-snapshot guest recovery alert for VM snapshot [{}].", vmSnapshot.getUuid(), e);
+        }
+    }
+
     /**
      * Given a list of VM snapshots, will remove any that are part of the current direct backing chain (all the direct ancestors of the current vm snapshot).
      * This is done because, when using <a href="https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockCommit">virDomainBlockCommit</a>}, Libvirt will maintain
diff --git a/engine/storage/snapshot/src/test/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategyTest.java b/engine/storage/snapshot/src/test/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategyTest.java
new file mode 100644
index 00000000000..35b1f9ff65b
--- /dev/null
+++ b/engine/storage/snapshot/src/test/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategyTest.java
@@ -0,0 +1,550 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.cloudstack.storage.vmsnapshot;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotDataFactory;
+import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotInfo;
+import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreVO;
+import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
+import org.apache.cloudstack.storage.to.SnapshotObjectTO;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
+import org.apache.cloudstack.api.ApiConstants;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+
+import com.cloud.agent.AgentManager;
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.DeleteDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotCommand;
+import com.cloud.alert.AlertManager;
+import com.cloud.host.DetailVO;
+import com.cloud.host.Host;
+import com.cloud.host.HostVO;
+import com.cloud.host.dao.HostDao;
+import com.cloud.host.dao.HostDetailsDao;
+import com.cloud.storage.DataStoreRole;
+import com.cloud.storage.Volume;
+import com.cloud.storage.VolumeVO;
+import com.cloud.storage.dao.VolumeDao;
+import com.cloud.user.ResourceLimitService;
+import com.cloud.uservm.UserVm;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.vm.VMInstanceDetailVO;
+import com.cloud.vm.UserVmVO;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.dao.VMInstanceDetailsDao;
+import com.cloud.vm.dao.UserVmDao;
+import com.cloud.vm.snapshot.VMSnapshot;
+import com.cloud.vm.snapshot.VMSnapshotDetailsVO;
+import com.cloud.vm.snapshot.VMSnapshotVO;
+import com.cloud.vm.snapshot.dao.VMSnapshotDao;
+import com.cloud.vm.snapshot.dao.VMSnapshotDetailsDao;
+
+public class KvmFileBasedStorageVmSnapshotStrategyTest {
+
+    private KvmFileBasedStorageVmSnapshotStrategy strategy;
+    private VMSnapshotDetailsDao vmSnapshotDetailsDao;
+    private VMSnapshotDao vmSnapshotDao;
+    private VMSnapshotHelper vmSnapshotHelper;
+    private AgentManager agentMgr;
+    private SnapshotDataStoreDao snapshotDataStoreDao;
+    private HostDetailsDao hostDetailsDao;
+    private HostDao hostDao;
+    private PrimaryDataStoreDao storagePoolDao;
+
+    @Before
+    public void setup() {
+        strategy = Mockito.spy(new KvmFileBasedStorageVmSnapshotStrategy());
+        vmSnapshotDetailsDao = mock(VMSnapshotDetailsDao.class);
+        vmSnapshotDao = mock(VMSnapshotDao.class);
+        vmSnapshotHelper = mock(VMSnapshotHelper.class);
+        agentMgr = mock(AgentManager.class);
+        snapshotDataStoreDao = mock(SnapshotDataStoreDao.class);
+        hostDetailsDao = mock(HostDetailsDao.class);
+        hostDao = mock(HostDao.class);
+        storagePoolDao = mock(PrimaryDataStoreDao.class);
+
+        strategy.vmSnapshotDetailsDao = vmSnapshotDetailsDao;
+        strategy.vmSnapshotDao = vmSnapshotDao;
+        strategy.vmSnapshotHelper = vmSnapshotHelper;
+        strategy.agentMgr = agentMgr;
+        strategy.snapshotDataStoreDao = snapshotDataStoreDao;
+        strategy.hostDao = hostDao;
+        strategy.storagePool = storagePoolDao;
+        strategy.resourceLimitManager = mock(ResourceLimitService.class);
+        strategy.snapshotDataFactory = mock(SnapshotDataFactory.class);
+        strategy.userVmDao = mock(UserVmDao.class);
+        strategy.volumeDao = mock(VolumeDao.class);
+        strategy.vmInstanceDetailsDao = mock(VMInstanceDetailsDao.class);
+        strategy.hostDetailsDao = hostDetailsDao;
+        strategy.alertManager = mock(AlertManager.class);
+        doNothing().when(strategy).publishUsageEvent(anyString(), any(VMSnapshot.class), any(UserVm.class), anyLong(), anyLong());
+        doNothing().when(strategy).publishUsageEvent(anyString(), any(VMSnapshot.class), any(UserVm.class), any(VolumeObjectTO.class));
+    }
+
+    @Test
+    public void testProcessCreateVmSnapshotAnswerPersistsNvramPath() throws Exception {
+        VMSnapshot vmSnapshot = mock(VMSnapshot.class);
+        CreateDiskOnlyVmSnapshotAnswer answer = mock(CreateDiskOnlyVmSnapshotAnswer.class);
+        UserVm userVm = mock(UserVm.class);
+        VMSnapshotVO vmSnapshotVO = mock(VMSnapshotVO.class);
+
+        when(vmSnapshot.getId()).thenReturn(42L);
+        when(vmSnapshot.getUuid()).thenReturn("vm-snapshot");
+        when(answer.getMapVolumeToSnapshotSizeAndNewVolumePath()).thenReturn(Collections.emptyMap());
+        when(answer.getNvramSnapshotPath()).thenReturn("nvram/42.fd");
+
+        Method method = KvmFileBasedStorageVmSnapshotStrategy.class.getDeclaredMethod("processCreateVmSnapshotAnswer", VMSnapshot.class, java.util.Map.class,
+                CreateDiskOnlyVmSnapshotAnswer.class, UserVm.class, VMSnapshotVO.class, long.class, VMSnapshotVO.class);
+        method.setAccessible(true);
+        method.invoke(strategy, vmSnapshot, Collections.emptyMap(), answer, userVm, vmSnapshotVO, 0L, null);
+
+        verify(vmSnapshotDetailsDao).addDetail(42L, "kvmFileBasedStorageSnapshotNvram", "nvram/42.fd", false);
+    }
+
+    @Test
+    public void testRevertVMSnapshotPassesNvramPathToAgentCommand() {
+        long vmId = 10L;
+        long snapshotId = 20L;
+        long dataStoreId = 30L;
+        long hostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+        VMSnapshotVO currentVmSnapshot = mock(VMSnapshotVO.class);
+        SnapshotDataStoreVO snapshotDataStoreVO = mock(SnapshotDataStoreVO.class);
+        SnapshotInfo snapshotInfo = mock(SnapshotInfo.class);
+        SnapshotObjectTO snapshotObjectTO = mock(SnapshotObjectTO.class);
+        VMSnapshotDetailsVO volumeSnapshotDetail = new VMSnapshotDetailsVO(snapshotId, "kvmFileBasedStorageSnapshot", String.valueOf(snapshotId), true);
+        VMSnapshotDetailsVO nvramDetail = new VMSnapshotDetailsVO(snapshotId, "kvmFileBasedStorageSnapshotNvram", "nvram/42.fd", false);
+
+        when(vmSnapshot.getVmId()).thenReturn(vmId);
+        when(vmSnapshot.getId()).thenReturn(snapshotId);
+        when(vmSnapshot.getUuid()).thenReturn("vm-snapshot");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Stopped);
+        when(userVm.getName()).thenReturn("i-10-VM");
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getLastHostId()).thenReturn(39L);
+        when(strategy.userVmDao.findById(vmId)).thenReturn(userVm);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(hostId);
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_UEFI_ENABLE))
+                .thenReturn(new DetailVO(hostId, Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString()));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM))
+                .thenReturn(new DetailVO(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString()));
+        when(vmSnapshotDetailsDao.findDetails(snapshotId, "kvmFileBasedStorageSnapshot")).thenReturn(List.of(volumeSnapshotDetail));
+        when(vmSnapshotDetailsDao.findDetail(snapshotId, "kvmFileBasedStorageSnapshotNvram")).thenReturn(nvramDetail);
+        when(snapshotDataStoreDao.findOneBySnapshotAndDatastoreRole(snapshotId, DataStoreRole.Primary)).thenReturn(snapshotDataStoreVO);
+        when(snapshotDataStoreVO.getSnapshotId()).thenReturn(snapshotId);
+        when(snapshotDataStoreVO.getDataStoreId()).thenReturn(dataStoreId);
+        when(strategy.snapshotDataFactory.getSnapshot(snapshotId, dataStoreId, DataStoreRole.Primary)).thenReturn(snapshotInfo);
+        when(snapshotInfo.getTO()).thenReturn(snapshotObjectTO);
+        when(vmSnapshotDao.findCurrentSnapshotByVmId(vmId)).thenReturn(currentVmSnapshot);
+        when(agentMgr.easySend(eq(hostId), any())).thenAnswer(invocation ->
+                new RevertDiskOnlyVmSnapshotAnswer((RevertDiskOnlyVmSnapshotCommand) invocation.getArgument(1), Collections.emptyList()));
+
+        ArgumentCaptor<RevertDiskOnlyVmSnapshotCommand> commandCaptor = ArgumentCaptor.forClass(RevertDiskOnlyVmSnapshotCommand.class);
+
+        strategy.revertVMSnapshot(vmSnapshot);
+
+        verify(agentMgr).easySend(eq(hostId), commandCaptor.capture());
+        verify(userVm).setLastHostId(hostId);
+        verify(strategy.userVmDao).update(vmId, userVm);
+        assertEquals("vm-uuid", commandCaptor.getValue().getVmUuid());
+        assertEquals(true, commandCaptor.getValue().isUefiEnabled());
+        assertEquals("nvram/42.fd", commandCaptor.getValue().getNvramSnapshotPath());
+    }
+
+    @Test
+    public void testPickHostForUefiNvramAwareDiskOnlySnapshotUsesCapableCandidateForRevertWhenDefaultHostLacksSupport() {
+        long vmId = 10L;
+        long defaultHostId = 40L;
+        long capableHostId = 41L;
+        long poolId = 50L;
+        long clusterId = 60L;
+        long podId = 70L;
+        long dataCenterId = 80L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VolumeVO rootVolume = mock(VolumeVO.class);
+        StoragePoolVO storagePool = mock(StoragePoolVO.class);
+        HostVO defaultHost = mock(HostVO.class);
+        HostVO capableHost = mock(HostVO.class);
+
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Stopped);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(defaultHostId);
+        when(rootVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
+        when(rootVolume.getPoolId()).thenReturn(poolId);
+        when(strategy.volumeDao.findByInstance(vmId)).thenReturn(List.of(rootVolume));
+        when(storagePoolDao.findById(poolId)).thenReturn(storagePool);
+        when(storagePool.getClusterId()).thenReturn(clusterId);
+        when(storagePool.getPodId()).thenReturn(podId);
+        when(storagePool.getDataCenterId()).thenReturn(dataCenterId);
+        when(defaultHost.getId()).thenReturn(defaultHostId);
+        when(capableHost.getId()).thenReturn(capableHostId);
+        when(hostDao.listAllUpAndEnabledNonHAHosts(Host.Type.Routing, clusterId, podId, dataCenterId, null))
+                .thenReturn(List.of(defaultHost, capableHost));
+        when(hostDetailsDao.findDetail(defaultHostId, Host.HOST_UEFI_ENABLE)).thenReturn(null);
+        when(hostDetailsDao.findDetail(defaultHostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)).thenReturn(null);
+        when(hostDetailsDao.findDetail(capableHostId, Host.HOST_UEFI_ENABLE))
+                .thenReturn(new DetailVO(capableHostId, Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString()));
+        when(hostDetailsDao.findDetail(capableHostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM))
+                .thenReturn(new DetailVO(capableHostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString()));
+
+        Long hostId = strategy.pickHostForUefiNvramAwareDiskOnlySnapshot(userVm, "revert");
+
+        assertEquals(Long.valueOf(capableHostId), hostId);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testPickHostForUefiNvramAwareDiskOnlySnapshotFailsCreateWhenSelectedHostIsNotLastHost() {
+        long vmId = 10L;
+        long lastHostId = 39L;
+        long selectedHostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Stopped);
+        when(userVm.getLastHostId()).thenReturn(lastHostId);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(selectedHostId);
+        when(hostDetailsDao.findDetail(selectedHostId, Host.HOST_UEFI_ENABLE))
+                .thenReturn(new DetailVO(selectedHostId, Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString()));
+        when(hostDetailsDao.findDetail(selectedHostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM))
+                .thenReturn(new DetailVO(selectedHostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString()));
+
+        strategy.pickHostForUefiNvramAwareDiskOnlySnapshot(userVm, "create");
+    }
+
+    @Test
+    public void testDeleteNvramSnapshotIfNeededPassesPrimaryDataStoreToAgentCommand() {
+        long hostId = 40L;
+
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+        VMSnapshotDetailsVO nvramDetail = new VMSnapshotDetailsVO(20L, "kvmFileBasedStorageSnapshotNvram", "nvram/42.fd", false);
+        PrimaryDataStoreTO primaryDataStore = mock(PrimaryDataStoreTO.class);
+
+        when(vmSnapshot.getId()).thenReturn(20L);
+        when(vmSnapshot.getUuid()).thenReturn("vm-snapshot");
+        when(vmSnapshotDetailsDao.findDetail(20L, "kvmFileBasedStorageSnapshotNvram")).thenReturn(nvramDetail);
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM))
+                .thenReturn(new DetailVO(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString()));
+        when(agentMgr.easySend(eq(hostId), any())).thenReturn(new Answer(null, true, null));
+
+        strategy.deleteNvramSnapshotIfNeeded(vmSnapshot, hostId, primaryDataStore);
+
+        verify(agentMgr).easySend(eq(hostId), argThat(command -> {
+            if (!(command instanceof DeleteDiskOnlyVmSnapshotCommand)) {
+                return false;
+            }
+
+            DeleteDiskOnlyVmSnapshotCommand deleteCommand = (DeleteDiskOnlyVmSnapshotCommand) command;
+            return deleteCommand.getSnapshots().isEmpty()
+                    && "nvram/42.fd".equals(deleteCommand.getNvramSnapshotPath())
+                    && deleteCommand.getPrimaryDataStore() == primaryDataStore;
+        }));
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testValidateHostSupportsNvramSidecarCleanupFailsWhenHostLacksNvramAwareCleanupCapability() {
+        long hostId = 40L;
+
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+        VMSnapshotDetailsVO nvramDetail = new VMSnapshotDetailsVO(20L, "kvmFileBasedStorageSnapshotNvram", "nvram/42.fd", false);
+
+        when(vmSnapshot.getId()).thenReturn(20L);
+        when(vmSnapshot.getUuid()).thenReturn("vm-snapshot");
+        when(vmSnapshotDetailsDao.findDetail(20L, "kvmFileBasedStorageSnapshotNvram")).thenReturn(nvramDetail);
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)).thenReturn(null);
+
+        try {
+            strategy.validateHostSupportsNvramSidecarCleanup(vmSnapshot, hostId, "delete");
+        } finally {
+            verify(agentMgr, never()).easySend(eq(hostId), any());
+        }
+    }
+
+    @Test
+    public void testGetRootVolumePrimaryDataStoreForCleanupReturnsNullWhenRootVolumeIsMissing() {
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+        VolumeObjectTO dataVolume = mock(VolumeObjectTO.class);
+
+        when(vmSnapshot.getUuid()).thenReturn("vm-snapshot");
+        when(dataVolume.getVolumeType()).thenReturn(Volume.Type.DATADISK);
+
+        PrimaryDataStoreTO primaryDataStore = strategy.getRootVolumePrimaryDataStoreForCleanup(vmSnapshot, List.of(dataVolume));
+
+        assertNull(primaryDataStore);
+    }
+
+    @Test
+    public void testGetPrimaryDataStoreForNvramCleanupPrefersRootSnapshotPrimaryDataStore() {
+        long vmSnapshotId = 20L;
+        long rootSnapshotId = 30L;
+        long dataStoreId = 40L;
+
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+        VolumeObjectTO rootVolume = mock(VolumeObjectTO.class);
+        PrimaryDataStoreTO liveRootVolumePrimaryDataStore = mock(PrimaryDataStoreTO.class);
+        PrimaryDataStoreTO rootSnapshotPrimaryDataStore = mock(PrimaryDataStoreTO.class);
+        SnapshotDataStoreVO rootSnapshotDataStore = mock(SnapshotDataStoreVO.class);
+        SnapshotInfo rootSnapshotInfo = mock(SnapshotInfo.class);
+        SnapshotObjectTO rootSnapshotObjectTo = mock(SnapshotObjectTO.class);
+        VolumeObjectTO rootSnapshotVolume = mock(VolumeObjectTO.class);
+        VMSnapshotDetailsVO volumeSnapshotDetail = new VMSnapshotDetailsVO(vmSnapshotId, "kvmFileBasedStorageSnapshot", String.valueOf(rootSnapshotId), true);
+
+        when(vmSnapshot.getId()).thenReturn(vmSnapshotId);
+        when(vmSnapshot.getUuid()).thenReturn("vm-snapshot");
+        when(vmSnapshotDetailsDao.findDetails(vmSnapshotId, "kvmFileBasedStorageSnapshot")).thenReturn(List.of(volumeSnapshotDetail));
+        when(snapshotDataStoreDao.findOneBySnapshotAndDatastoreRole(rootSnapshotId, DataStoreRole.Primary)).thenReturn(rootSnapshotDataStore);
+        when(rootSnapshotDataStore.getSnapshotId()).thenReturn(rootSnapshotId);
+        when(rootSnapshotDataStore.getDataStoreId()).thenReturn(dataStoreId);
+        when(strategy.snapshotDataFactory.getSnapshot(rootSnapshotId, dataStoreId, DataStoreRole.Primary)).thenReturn(rootSnapshotInfo);
+        when(rootSnapshotInfo.getTO()).thenReturn(rootSnapshotObjectTo);
+        when(rootSnapshotObjectTo.getVolume()).thenReturn(rootSnapshotVolume);
+        when(rootSnapshotVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
+        when(rootSnapshotObjectTo.getDataStore()).thenReturn(rootSnapshotPrimaryDataStore);
+        when(rootVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
+        when(rootVolume.getDataStore()).thenReturn(liveRootVolumePrimaryDataStore);
+
+        PrimaryDataStoreTO primaryDataStore = strategy.getPrimaryDataStoreForNvramCleanup(vmSnapshot, List.of(rootVolume));
+
+        assertSame(rootSnapshotPrimaryDataStore, primaryDataStore);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testTakeVmSnapshotInternalFailsWhenHostLacksNvramAwareSnapshotCapabilityForUefiVm() throws Exception {
+        long vmId = 10L;
+        long hostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+
+        when(vmSnapshot.getVmId()).thenReturn(vmId);
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Running);
+        when(strategy.userVmDao.findById(vmId)).thenReturn(userVm);
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(hostId);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_UEFI_ENABLE))
+                .thenReturn(new DetailVO(hostId, Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString()));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)).thenReturn(null);
+
+        strategy.takeVmSnapshotInternal(vmSnapshot, Collections.emptyMap());
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testTakeVMSnapshotMarksSnapshotFailedWhenHostCapabilityValidationFails() throws Exception {
+        long vmId = 10L;
+        long hostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+
+        when(vmSnapshot.getVmId()).thenReturn(vmId);
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Running);
+        when(strategy.userVmDao.findById(vmId)).thenReturn(userVm);
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(hostId);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_UEFI_ENABLE))
+                .thenReturn(new DetailVO(hostId, Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString()));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)).thenReturn(null);
+
+        try {
+            strategy.takeVMSnapshot(vmSnapshot);
+        } finally {
+            InOrder inOrder = inOrder(vmSnapshotHelper);
+            inOrder.verify(vmSnapshotHelper).vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.CreateRequested);
+            inOrder.verify(vmSnapshotHelper).vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.OperationFailed);
+            verify(agentMgr, never()).easySend(eq(hostId), any());
+        }
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testDeleteVMSnapshotFailsWhenHostLacksNvramAwareCleanupCapabilityForSidecarSnapshot() {
+        long vmId = 10L;
+        long vmSnapshotId = 20L;
+        long hostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+        VMSnapshotDetailsVO nvramDetail = new VMSnapshotDetailsVO(vmSnapshotId, "kvmFileBasedStorageSnapshotNvram", "nvram/42.fd", false);
+
+        when(vmSnapshot.getVmId()).thenReturn(vmId);
+        when(vmSnapshot.getId()).thenReturn(vmSnapshotId);
+        when(vmSnapshot.getUuid()).thenReturn("vm-snapshot");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Running);
+        when(strategy.userVmDao.findById(vmId)).thenReturn(userVm);
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(hostId);
+        when(vmSnapshotDetailsDao.findDetail(vmSnapshotId, "kvmFileBasedStorageSnapshotNvram")).thenReturn(nvramDetail);
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)).thenReturn(null);
+
+        strategy.deleteVMSnapshot(vmSnapshot);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testTakeVmSnapshotInternalFailsWhenHostLacksUefiCapabilityForUefiVm() throws Exception {
+        long vmId = 10L;
+        long hostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+
+        when(vmSnapshot.getVmId()).thenReturn(vmId);
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Running);
+        when(strategy.userVmDao.findById(vmId)).thenReturn(userVm);
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(hostId);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_UEFI_ENABLE)).thenReturn(null);
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM))
+                .thenReturn(new DetailVO(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString()));
+
+        strategy.takeVmSnapshotInternal(vmSnapshot, Collections.emptyMap());
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testRevertVMSnapshotFailsWhenHostLacksNvramAwareSnapshotCapabilityForUefiVm() {
+        long vmId = 10L;
+        long hostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+
+        when(vmSnapshot.getVmId()).thenReturn(vmId);
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Stopped);
+        when(strategy.userVmDao.findById(vmId)).thenReturn(userVm);
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(hostId);
+        mockCandidateHostScope(vmId, hostId);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_UEFI_ENABLE))
+                .thenReturn(new DetailVO(hostId, Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString()));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM)).thenReturn(null);
+
+        strategy.revertVMSnapshot(vmSnapshot);
+    }
+
+    @Test(expected = CloudRuntimeException.class)
+    public void testRevertVMSnapshotFailsWhenHostLacksUefiCapabilityForUefiVm() {
+        long vmId = 10L;
+        long hostId = 40L;
+
+        UserVmVO userVm = mock(UserVmVO.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+
+        when(vmSnapshot.getVmId()).thenReturn(vmId);
+        when(userVm.getId()).thenReturn(vmId);
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getState()).thenReturn(VirtualMachine.State.Stopped);
+        when(strategy.userVmDao.findById(vmId)).thenReturn(userVm);
+        when(vmSnapshotHelper.pickRunningHost(vmId)).thenReturn(hostId);
+        mockCandidateHostScope(vmId, hostId);
+        when(strategy.vmInstanceDetailsDao.findDetail(vmId, ApiConstants.BootType.UEFI.toString()))
+                .thenReturn(new VMInstanceDetailVO(vmId, ApiConstants.BootType.UEFI.toString(), "SECURE", true));
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_UEFI_ENABLE)).thenReturn(null);
+        when(hostDetailsDao.findDetail(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM))
+                .thenReturn(new DetailVO(hostId, Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString()));
+
+        strategy.revertVMSnapshot(vmSnapshot);
+    }
+
+    @Test
+    public void testNotifyGuestRecoveryIssueIfNeededSendsAlert() {
+        CreateDiskOnlyVmSnapshotAnswer answer = mock(CreateDiskOnlyVmSnapshotAnswer.class);
+        UserVm userVm = mock(UserVm.class);
+        VMSnapshotVO vmSnapshot = mock(VMSnapshotVO.class);
+
+        when(answer.getDetails()).thenReturn("VM could not be thawed");
+        when(userVm.getUuid()).thenReturn("vm-uuid");
+        when(userVm.getDataCenterId()).thenReturn(1L);
+        when(userVm.getPodIdToDeployIn()).thenReturn(2L);
+        when(vmSnapshot.getUuid()).thenReturn("snapshot-uuid");
+
+        strategy.notifyGuestRecoveryIssueIfNeeded(answer, userVm, vmSnapshot);
+
+        verify(strategy.alertManager).sendAlert(eq(AlertManager.AlertType.ALERT_TYPE_VM_SNAPSHOT), eq(1L), eq(2L), anyString(), anyString());
+    }
+
+    private void mockCandidateHostScope(long vmId, long hostId) {
+        long poolId = 50L;
+        long clusterId = 60L;
+        long podId = 70L;
+        long dataCenterId = 80L;
+
+        VolumeVO rootVolume = mock(VolumeVO.class);
+        StoragePoolVO storagePool = mock(StoragePoolVO.class);
+        HostVO host = mock(HostVO.class);
+
+        when(rootVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
+        when(rootVolume.getPoolId()).thenReturn(poolId);
+        when(strategy.volumeDao.findByInstance(vmId)).thenReturn(List.of(rootVolume));
+        when(storagePoolDao.findById(poolId)).thenReturn(storagePool);
+        when(storagePool.getClusterId()).thenReturn(clusterId);
+        when(storagePool.getPodId()).thenReturn(podId);
+        when(storagePool.getDataCenterId()).thenReturn(dataCenterId);
+        when(host.getId()).thenReturn(hostId);
+        when(hostDao.listAllUpAndEnabledNonHAHosts(Host.Type.Routing, clusterId, podId, dataCenterId, null)).thenReturn(List.of(host));
+    }
+}
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java
index a2498abfd4e..a9ed0c62cab 100644
--- a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java
+++ b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java
@@ -17,6 +17,7 @@
 package com.cloud.hypervisor.kvm.resource;
 
 import static com.cloud.host.Host.HOST_INSTANCE_CONVERSION;
+import static com.cloud.host.Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM;
 import static com.cloud.host.Host.HOST_OVFTOOL_VERSION;
 import static com.cloud.host.Host.HOST_VDDK_LIB_DIR;
 import static com.cloud.host.Host.HOST_VDDK_SUPPORT;
@@ -4265,6 +4266,7 @@ public class LibvirtComputingResource extends ServerResourceBase implements Serv
         privateIp = cmd.getPrivateIpAddress();
         cmd.getHostDetails().putAll(getVersionStrings());
         cmd.getHostDetails().put(KeyStoreUtils.SECURED, String.valueOf(isHostSecured()).toLowerCase());
+        cmd.getHostDetails().put(HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString());
         cmd.setPool(pool);
         cmd.setCluster(clusterId);
         cmd.setGatewayIpAddress(localGateway);
@@ -6334,6 +6336,15 @@ public class LibvirtComputingResource extends ServerResourceBase implements Serv
         return String.join(File.separator, diskPathSplitted);
     }
 
+    public String getUefiNvramPath(String vmUuid) {
+        String nvramDirectory = uefiProperties.getProperty(LibvirtVMDef.GuestDef.GUEST_NVRAM_PATH);
+        if (StringUtils.isBlank(nvramDirectory) || StringUtils.isBlank(vmUuid)) {
+            return null;
+        }
+
+        return nvramDirectory + vmUuid + ".fd";
+    }
+
     public static String generateSecretUUIDFromString(String seed) {
         return UuidUtils.nameUUIDFromBytes(seed.getBytes()).toString();
     }
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtCreateDiskOnlyVMSnapshotCommandWrapper.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtCreateDiskOnlyVMSnapshotCommandWrapper.java
index 84d17a1a116..46a7da70c61 100644
--- a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtCreateDiskOnlyVMSnapshotCommandWrapper.java
+++ b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtCreateDiskOnlyVMSnapshotCommandWrapper.java
@@ -19,6 +19,7 @@
 package com.cloud.hypervisor.kvm.resource.wrapper;
 
 import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.FreezeThawVMCommand;
 import com.cloud.agent.api.VMSnapshotTO;
 import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotAnswer;
 import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotCommand;
@@ -32,24 +33,33 @@ import com.cloud.utils.Pair;
 import com.cloud.vm.VirtualMachine;
 import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
 import org.apache.cloudstack.storage.to.VolumeObjectTO;
+import org.apache.cloudstack.utils.qemu.QemuCommand;
 import org.apache.cloudstack.utils.qemu.QemuImg;
 import org.apache.cloudstack.utils.qemu.QemuImgException;
 import org.apache.cloudstack.utils.qemu.QemuImgFile;
+import org.apache.commons.lang3.StringUtils;
 import org.libvirt.Connect;
 import org.libvirt.Domain;
 import org.libvirt.LibvirtException;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
 
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
+import com.cloud.storage.Volume;
+
 @ResourceWrapper(handles = CreateDiskOnlyVmSnapshotCommand.class)
 public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrapper<CreateDiskOnlyVmSnapshotCommand, Answer, LibvirtComputingResource> {
+    protected static final String NVRAM_SNAPSHOT_DIR = ".cloudstack-vm-snapshot-nvram";
 
     private static final String SNAPSHOT_XML = "<domainsnapshot>\n" +
             "<name>%s</name>\n" +
@@ -79,6 +89,11 @@ public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
         logger.info("Taking disk-only VM snapshot of running VM [{}].", vmName);
 
         Domain dm = null;
+        String nvramSnapshotPath = null;
+        boolean suspendedByThisWrapper = false;
+        boolean filesystemsFrozenByThisWrapper = false;
+        CreateDiskOnlyVmSnapshotAnswer answer = null;
+        String postSnapshotCleanupIssue = null;
         try {
             LibvirtUtilitiesHelper libvirtUtilitiesHelper = resource.getLibvirtUtilitiesHelper();
             Connect conn = libvirtUtilitiesHelper.getConnection();
@@ -88,26 +103,45 @@ public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
             dm = resource.getDomain(conn, vmName);
 
             if (dm == null) {
-                return new CreateDiskOnlyVmSnapshotAnswer(cmd, false, String.format("Creation of disk-only VM Snapshot failed as we could not find the VM [%s].", vmName), null);
+                answer = new CreateDiskOnlyVmSnapshotAnswer(cmd, false,
+                        String.format("Creation of disk-only VM Snapshot failed as we could not find the VM [%s].", vmName), null, null);
+                return answer;
             }
 
             VMSnapshotTO target = cmd.getTarget();
             Pair<String, Map<String, Pair<Long, String>>> snapshotXmlAndVolumeToNewPathMap = createSnapshotXmlAndNewVolumePathMap(volumeObjectTOS, disks, target, resource);
+            if (shouldFreezeVmFilesystemsForSnapshot(cmd)) {
+                // The guest-agent freeze flushes guest filesystems; suspend below prevents concurrent UEFI NVRAM writes.
+                freezeVmFilesystems(dm, vmName);
+                filesystemsFrozenByThisWrapper = true;
+                verifyVmFilesystemsFrozen(dm, vmName);
+            }
+            if (shouldSuspendVmForSnapshot(cmd)) {
+                suspendedByThisWrapper = suspendVmIfNeeded(dm);
+            }
+            nvramSnapshotPath = backupNvramIfNeeded(cmd, resource);
 
-            dm.snapshotCreateXML(snapshotXmlAndVolumeToNewPathMap.first(), getFlagsToUseForRunningVmSnapshotCreation(target));
+            dm.snapshotCreateXML(snapshotXmlAndVolumeToNewPathMap.first(), getFlagsToUseForRunningVmSnapshotCreation(target, filesystemsFrozenByThisWrapper));
 
-            return new CreateDiskOnlyVmSnapshotAnswer(cmd, true, null, snapshotXmlAndVolumeToNewPathMap.second());
-        } catch (LibvirtException e) {
+            postSnapshotCleanupIssue = recoverVmAfterSnapshot(dm, vmName, suspendedByThisWrapper, filesystemsFrozenByThisWrapper, postSnapshotCleanupIssue);
+            filesystemsFrozenByThisWrapper = false;
+            suspendedByThisWrapper = false;
+
+            answer = new CreateDiskOnlyVmSnapshotAnswer(cmd, true, null, snapshotXmlAndVolumeToNewPathMap.second(), nvramSnapshotPath);
+        } catch (LibvirtException | IOException e) {
             String errorMsg = String.format("Creation of disk-only VM snapshot for VM [%s] failed due to %s.", vmName, e.getMessage());
             logger.error(errorMsg, e);
-            if (e.getMessage().contains("QEMU guest agent is not connected")) {
+            cleanupNvramSnapshotIfNeeded(cmd, resource, nvramSnapshotPath);
+            if (StringUtils.contains(e.getMessage(), "QEMU guest agent is not connected")) {
                 errorMsg = "QEMU guest agent is not connected. If the VM has been recently started, it might connect soon. Otherwise the VM does not have the" +
                         " guest agent installed; thus the QuiesceVM parameter is not supported.";
-                return new CreateDiskOnlyVmSnapshotAnswer(cmd, false, errorMsg, null);
+                answer = new CreateDiskOnlyVmSnapshotAnswer(cmd, false, errorMsg, null, null);
+            } else {
+                answer = new CreateDiskOnlyVmSnapshotAnswer(cmd, false, e.getMessage(), null, null);
             }
-            return new CreateDiskOnlyVmSnapshotAnswer(cmd, false, e.getMessage(), null);
         } finally {
             if (dm != null) {
+                postSnapshotCleanupIssue = recoverVmAfterSnapshot(dm, vmName, suspendedByThisWrapper, filesystemsFrozenByThisWrapper, postSnapshotCleanupIssue);
                 try {
                     dm.free();
                 } catch (LibvirtException l) {
@@ -115,6 +149,12 @@ public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
                 }
             }
         }
+
+        if (answer != null && StringUtils.isNotBlank(postSnapshotCleanupIssue)) {
+            answer = new CreateDiskOnlyVmSnapshotAnswer(cmd, answer.getResult(),
+                    appendSnapshotOperationIssue(answer.getDetails(), postSnapshotCleanupIssue), answer.getMapVolumeToSnapshotSizeAndNewVolumePath(), answer.getNvramSnapshotPath());
+        }
+        return answer;
     }
 
     protected Answer takeDiskOnlyVmSnapshotOfStoppedVm(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource) {
@@ -122,10 +162,12 @@ public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
         logger.info("Taking disk-only VM snapshot of stopped VM [{}].", vmName);
 
         Map<String, Pair<Long, String>> mapVolumeToSnapshotSizeAndNewVolumePath = new HashMap<>();
+        String nvramSnapshotPath = null;
 
         List<VolumeObjectTO> volumeObjectTos = cmd.getVolumeTOs();
         KVMStoragePoolManager storagePoolMgr = resource.getStoragePoolMgr();
         try {
+            nvramSnapshotPath = backupNvramIfNeeded(cmd, resource);
             for (VolumeObjectTO volumeObjectTO : volumeObjectTos) {
                 PrimaryDataStoreTO primaryDataStoreTO = (PrimaryDataStoreTO) volumeObjectTO.getDataStore();
                 KVMStoragePool kvmStoragePool = storagePoolMgr.getStoragePool(primaryDataStoreTO.getPoolType(), primaryDataStoreTO.getUuid());
@@ -144,7 +186,7 @@ public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
 
                 mapVolumeToSnapshotSizeAndNewVolumePath.put(volumeObjectTO.getUuid(), new Pair<>(getFileSize(currentDeltaFullPath), snapshotPath));
             }
-        } catch (LibvirtException | QemuImgException e) {
+        } catch (LibvirtException | QemuImgException | IOException e) {
             logger.error("Exception while creating disk-only VM snapshot for VM [{}]. Deleting leftover deltas.", vmName, e);
             for (VolumeObjectTO volumeObjectTO : volumeObjectTos) {
                 Pair<Long, String> volSizeAndNewPath = mapVolumeToSnapshotSizeAndNewVolumePath.get(volumeObjectTO.getUuid());
@@ -160,14 +202,15 @@ public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
                     logger.warn("Tried to delete leftover snapshot at [{}] failed.", volSizeAndNewPath.second(), ex);
                 }
             }
+            cleanupNvramSnapshotIfNeeded(cmd, resource, nvramSnapshotPath);
             return new Answer(cmd, e);
         }
 
-        return new CreateDiskOnlyVmSnapshotAnswer(cmd, true, null, mapVolumeToSnapshotSizeAndNewVolumePath);
+        return new CreateDiskOnlyVmSnapshotAnswer(cmd, true, null, mapVolumeToSnapshotSizeAndNewVolumePath, nvramSnapshotPath);
     }
 
-    protected int getFlagsToUseForRunningVmSnapshotCreation(VMSnapshotTO target) {
-        int flags = target.getQuiescevm() ? Domain.SnapshotCreateFlags.QUIESCE : 0;
+    protected int getFlagsToUseForRunningVmSnapshotCreation(VMSnapshotTO target, boolean filesystemsFrozenByThisWrapper) {
+        int flags = target.getQuiescevm() && !filesystemsFrozenByThisWrapper ? Domain.SnapshotCreateFlags.QUIESCE : 0;
         flags += Domain.SnapshotCreateFlags.DISK_ONLY +
                 Domain.SnapshotCreateFlags.ATOMIC +
                 Domain.SnapshotCreateFlags.NO_METADATA;
@@ -195,4 +238,193 @@ public class LibvirtCreateDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
     protected long getFileSize(String path) {
         return new File(path).length();
     }
+
+    protected String backupNvramIfNeeded(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource) throws IOException, LibvirtException {
+        if (!cmd.isUefiEnabled()) {
+            return null;
+        }
+
+        String activeNvramPath = resource.getUefiNvramPath(cmd.getVmUuid());
+        if (StringUtils.isBlank(activeNvramPath) || !Files.exists(Path.of(activeNvramPath))) {
+            throw new IOException(String.format("Unable to find the active UEFI NVRAM file for VM [%s].", cmd.getVmName()));
+        }
+
+        VolumeObjectTO rootVolume = getRootVolume(cmd.getVolumeTOs());
+        PrimaryDataStoreTO primaryDataStoreTO = (PrimaryDataStoreTO) rootVolume.getDataStore();
+        KVMStoragePool storagePool = resource.getStoragePoolMgr().getStoragePool(primaryDataStoreTO.getPoolType(), primaryDataStoreTO.getUuid());
+
+        String nvramSnapshotPath = getNvramSnapshotRelativePath(cmd.getTarget().getId());
+        Path targetPath = Path.of(storagePool.getLocalPathFor(nvramSnapshotPath));
+        Files.createDirectories(targetPath.getParent());
+        Files.copy(Path.of(activeNvramPath), targetPath, StandardCopyOption.REPLACE_EXISTING);
+        return nvramSnapshotPath;
+    }
+
+    protected void cleanupNvramSnapshotIfNeeded(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource, String nvramSnapshotPath) {
+        if (StringUtils.isBlank(nvramSnapshotPath)) {
+            return;
+        }
+
+        try {
+            VolumeObjectTO rootVolume = getRootVolume(cmd.getVolumeTOs());
+            PrimaryDataStoreTO primaryDataStoreTO = (PrimaryDataStoreTO) rootVolume.getDataStore();
+            KVMStoragePool storagePool = resource.getStoragePoolMgr().getStoragePool(primaryDataStoreTO.getPoolType(), primaryDataStoreTO.getUuid());
+            Files.deleteIfExists(Path.of(storagePool.getLocalPathFor(nvramSnapshotPath)));
+        } catch (Exception e) {
+            logger.warn("Failed to clean up temporary NVRAM snapshot [{}] for VM [{}].", nvramSnapshotPath, cmd.getVmName(), e);
+        }
+    }
+
+    protected String getNvramSnapshotRelativePath(Long vmSnapshotId) {
+        return String.format("%s/%s.fd", NVRAM_SNAPSHOT_DIR, vmSnapshotId);
+    }
+
+    protected VolumeObjectTO getRootVolume(List<VolumeObjectTO> volumeObjectTos) {
+        return volumeObjectTos.stream()
+                .filter(volumeObjectTO -> Volume.Type.ROOT.equals(volumeObjectTO.getVolumeType()))
+                .findFirst()
+                .orElseThrow(() -> new IllegalStateException("Unable to locate the root volume while handling the VM snapshot."));
+    }
+
+    protected boolean shouldSuspendVmForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+        return cmd.isUefiEnabled();
+    }
+
+    protected boolean shouldFreezeVmFilesystemsForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+        return cmd.isUefiEnabled() && cmd.getTarget().getQuiescevm();
+    }
+
+    protected boolean suspendVmIfNeeded(Domain domain) throws LibvirtException {
+        if (domain.getInfo().state == org.libvirt.DomainInfo.DomainState.VIR_DOMAIN_PAUSED) {
+            return false;
+        }
+
+        domain.suspend();
+        return true;
+    }
+
+    protected void freezeVmFilesystems(Domain domain, String vmName) throws LibvirtException, IOException {
+        String result = getResultOfQemuCommand(FreezeThawVMCommand.FREEZE, domain);
+        if (isQemuAgentErrorResponse(result)) {
+            throw new IOException(String.format("Failed to freeze VM [%s] filesystems before taking the disk-only VM snapshot. Result: %s", vmName, result));
+        }
+    }
+
+    protected void verifyVmFilesystemsFrozen(Domain domain, String vmName) throws LibvirtException, IOException {
+        String status = getResultOfQemuCommand(FreezeThawVMCommand.STATUS, domain);
+        if (StringUtils.isBlank(status)) {
+            throw new IOException(String.format("Failed to verify VM [%s] filesystem freeze state before taking the disk-only VM snapshot. Result: %s", vmName, status));
+        }
+
+        JsonObject statusObject;
+        try {
+            JsonElement statusElement = new JsonParser().parse(status);
+            if (!statusElement.isJsonObject()) {
+                throw new IOException(String.format("Failed to verify VM [%s] filesystem freeze state before taking the disk-only VM snapshot. Result: %s", vmName, status));
+            }
+            statusObject = statusElement.getAsJsonObject();
+        } catch (RuntimeException e) {
+            throw new IOException(String.format("Failed to verify VM [%s] filesystem freeze state before taking the disk-only VM snapshot. Result: %s", vmName, status), e);
+        }
+
+        if (statusObject.has("error")) {
+            throw new IOException(String.format("Failed to verify VM [%s] filesystem freeze state before taking the disk-only VM snapshot. Result: %s", vmName, status));
+        }
+
+        JsonElement returnElement = statusObject.get("return");
+        if (returnElement == null || !returnElement.isJsonPrimitive() || !returnElement.getAsJsonPrimitive().isString()) {
+            throw new IOException(String.format("Failed to verify VM [%s] filesystem freeze state before taking the disk-only VM snapshot. Result: %s", vmName, status));
+        }
+
+        String statusResult = returnElement.getAsString();
+        if (!FreezeThawVMCommand.FREEZE.equals(statusResult)) {
+            throw new IOException(String.format("Failed to freeze VM [%s] filesystems before taking the disk-only VM snapshot. Status: %s", vmName, statusResult));
+        }
+    }
+
+    protected boolean thawVmFilesystemsIfNeeded(Domain domain, String vmName, boolean filesystemsFrozenByThisWrapper) {
+        if (!filesystemsFrozenByThisWrapper) {
+            return true;
+        }
+        return thawVmFilesystemsIfNeeded(domain, vmName);
+    }
+
+    protected boolean thawVmFilesystemsIfNeeded(Domain domain, String vmName) {
+        try {
+            String result = getResultOfQemuCommand(FreezeThawVMCommand.THAW, domain);
+            if (isQemuAgentErrorResponse(result)) {
+                logger.warn("Failed to thaw VM [{}] filesystems after taking the disk-only VM snapshot. Result: {}", vmName, result);
+                return false;
+            }
+            return true;
+        } catch (LibvirtException e) {
+            logger.warn("Failed to thaw VM [{}] filesystems after taking the disk-only VM snapshot.", vmName, e);
+            return false;
+        }
+    }
+
+    protected boolean isQemuAgentErrorResponse(String result) {
+        if (StringUtils.isBlank(result) || result.startsWith("error")) {
+            return true;
+        }
+
+        try {
+            JsonElement resultElement = new JsonParser().parse(result);
+            return resultElement.isJsonObject() && resultElement.getAsJsonObject().has("error");
+        } catch (RuntimeException e) {
+            return false;
+        }
+    }
+
+    protected String getResultOfQemuCommand(String cmd, Domain domain) throws LibvirtException {
+        if (cmd.equals(FreezeThawVMCommand.FREEZE)) {
+            return domain.qemuAgentCommand(QemuCommand.buildQemuCommand(QemuCommand.AGENT_FREEZE, null), 10, 0);
+        } else if (cmd.equals(FreezeThawVMCommand.THAW)) {
+            return domain.qemuAgentCommand(QemuCommand.buildQemuCommand(QemuCommand.AGENT_THAW, null), 10, 0);
+        } else if (cmd.equals(FreezeThawVMCommand.STATUS)) {
+            return domain.qemuAgentCommand(QemuCommand.buildQemuCommand(QemuCommand.AGENT_FREEZE_STATUS, null), 10, 0);
+        }
+        return null;
+    }
+
+    protected boolean resumeVmIfNeeded(Domain domain, String vmName, boolean suspendedByThisWrapper) {
+        if (!suspendedByThisWrapper) {
+            return true;
+        }
+        return resumeVmIfNeeded(domain, vmName);
+    }
+
+    protected boolean resumeVmIfNeeded(Domain domain, String vmName) {
+        try {
+            if (domain.getInfo().state == org.libvirt.DomainInfo.DomainState.VIR_DOMAIN_PAUSED) {
+                domain.resume();
+            }
+            return true;
+        } catch (LibvirtException e) {
+            logger.warn("Failed to resume VM [{}] after taking the disk-only VM snapshot.", vmName, e);
+            return false;
+        }
+    }
+
+    protected String recoverVmAfterSnapshot(Domain domain, String vmName, boolean suspendedByThisWrapper, boolean filesystemsFrozenByThisWrapper, String currentIssue) {
+        if (suspendedByThisWrapper && !resumeVmIfNeeded(domain, vmName)) {
+            currentIssue = appendSnapshotOperationIssue(currentIssue,
+                    String.format("VM [%s] could not be resumed after taking the disk-only snapshot. Guest may still be paused.", vmName));
+        }
+        if (filesystemsFrozenByThisWrapper && !thawVmFilesystemsIfNeeded(domain, vmName)) {
+            currentIssue = appendSnapshotOperationIssue(currentIssue,
+                    String.format("VM [%s] filesystems could not be thawed after taking the disk-only snapshot. Guest may still be frozen.", vmName));
+        }
+        return currentIssue;
+    }
+
+    protected String appendSnapshotOperationIssue(String currentIssue, String newIssue) {
+        if (StringUtils.isBlank(newIssue)) {
+            return currentIssue;
+        }
+        if (StringUtils.isBlank(currentIssue)) {
+            return newIssue;
+        }
+        return currentIssue + " " + newIssue;
+    }
 }
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper.java
index 15df8627a8a..62c7c501337 100644
--- a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper.java
+++ b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper.java
@@ -27,12 +27,16 @@ import com.cloud.hypervisor.kvm.storage.KVMStoragePoolManager;
 import com.cloud.resource.CommandWrapper;
 import com.cloud.resource.ResourceWrapper;
 import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
+import org.apache.cloudstack.storage.to.SnapshotObjectTO;
+import org.apache.commons.lang3.StringUtils;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 
+import com.cloud.storage.Volume;
+
 @ResourceWrapper(handles = DeleteDiskOnlyVmSnapshotCommand.class)
 public class LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper extends CommandWrapper<DeleteDiskOnlyVmSnapshotCommand, Answer, LibvirtComputingResource> {
 
@@ -53,6 +57,40 @@ public class LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
                 return new Answer(command, e);
             }
         }
+
+        deleteNvramSnapshotIfNeeded(command, resource, storagePoolMgr, snapshotsToDelete);
         return new Answer(command, true, null);
     }
+
+    protected void deleteNvramSnapshotIfNeeded(DeleteDiskOnlyVmSnapshotCommand command, LibvirtComputingResource resource, KVMStoragePoolManager storagePoolMgr,
+            List<DataTO> snapshotsToDelete) {
+        if (StringUtils.isBlank(command.getNvramSnapshotPath())) {
+            return;
+        }
+
+        try {
+            KVMStoragePool storagePool;
+            if (command.getPrimaryDataStore() != null) {
+                PrimaryDataStoreTO dataStore = command.getPrimaryDataStore();
+                storagePool = storagePoolMgr.getStoragePool(dataStore.getPoolType(), dataStore.getUuid());
+            } else {
+                SnapshotObjectTO rootVolumeSnapshot = snapshotsToDelete.stream()
+                        .map(SnapshotObjectTO.class::cast)
+                        .filter(snapshotObjectTO -> Volume.Type.ROOT.equals(snapshotObjectTO.getVolume().getVolumeType()))
+                        .findFirst()
+                        .orElse(null);
+
+                if (rootVolumeSnapshot == null) {
+                    logger.warn("Unable to locate the root volume snapshot while deleting NVRAM snapshot [{}].", command.getNvramSnapshotPath());
+                    return;
+                }
+
+                storagePool = resource.getLibvirtUtilitiesHelper().getPrimaryPoolFromDataTo(rootVolumeSnapshot, storagePoolMgr);
+            }
+
+            Files.deleteIfExists(Path.of(storagePool.getLocalPathFor(command.getNvramSnapshotPath())));
+        } catch (Exception e) {
+            logger.warn("Failed to delete the UEFI NVRAM snapshot [{}]. It will be left behind on storage.", command.getNvramSnapshotPath(), e);
+        }
+    }
 }
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtReadyCommandWrapper.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtReadyCommandWrapper.java
index 5a7d6d2c203..1ff6d7851f2 100644
--- a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtReadyCommandWrapper.java
+++ b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtReadyCommandWrapper.java
@@ -43,6 +43,7 @@ public final class LibvirtReadyCommandWrapper extends CommandWrapper<ReadyComman
     @Override
     public Answer execute(final ReadyCommand command, final LibvirtComputingResource libvirtComputingResource) {
         Map<String, String> hostDetails = new HashMap<String, String>();
+        hostDetails.put(Host.HOST_KVM_DISK_ONLY_VM_SNAPSHOT_NVRAM, Boolean.TRUE.toString());
 
         if (hostSupportsUefi(libvirtComputingResource.isUbuntuOrDebianHost()) && libvirtComputingResource.isUefiPropertiesFileLoaded()) {
             hostDetails.put(Host.HOST_UEFI_ENABLE, Boolean.TRUE.toString());
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtRevertDiskOnlyVMSnapshotCommandWrapper.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtRevertDiskOnlyVMSnapshotCommandWrapper.java
index 1aa79d48eec..e4cd527331b 100644
--- a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtRevertDiskOnlyVMSnapshotCommandWrapper.java
+++ b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtRevertDiskOnlyVMSnapshotCommandWrapper.java
@@ -31,15 +31,20 @@ import org.apache.cloudstack.storage.to.VolumeObjectTO;
 import org.apache.cloudstack.utils.qemu.QemuImg;
 import org.apache.cloudstack.utils.qemu.QemuImgException;
 import org.apache.cloudstack.utils.qemu.QemuImgFile;
+import org.apache.commons.lang3.StringUtils;
 import org.libvirt.LibvirtException;
 
 import java.io.IOException;
+import java.nio.file.AtomicMoveNotSupportedException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
+import com.cloud.storage.Volume;
+
 @ResourceWrapper(handles = RevertDiskOnlyVmSnapshotCommand.class)
 public class LibvirtRevertDiskOnlyVMSnapshotCommandWrapper extends CommandWrapper<RevertDiskOnlyVmSnapshotCommand, Answer, LibvirtComputingResource> {
 
@@ -55,6 +60,8 @@ public class LibvirtRevertDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
 
         HashMap<SnapshotObjectTO, String> snapshotToNewDeltaPath = new HashMap<>();
         try {
+            SnapshotObjectTO rootVolumeSnapshot = getRootVolumeSnapshot(snapshotObjectTos);
+            validateNvramRevertState(cmd, resource, rootVolumeSnapshot, storagePoolMgr);
             for (SnapshotObjectTO snapshotObjectTo : snapshotObjectTos) {
                 KVMStoragePool kvmStoragePool = libvirtUtilitiesHelper.getPrimaryPoolFromDataTo(snapshotObjectTo, storagePoolMgr);
 
@@ -71,7 +78,8 @@ public class LibvirtRevertDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
                 qemuImg.create(newDelta, currentDelta);
                 snapshotToNewDeltaPath.put(snapshotObjectTo, deltaPath);
             }
-        } catch (LibvirtException | QemuImgException e) {
+            restoreNvramIfNeeded(cmd, resource, rootVolumeSnapshot, storagePoolMgr);
+        } catch (LibvirtException | QemuImgException | IOException e) {
             logger.error("Exception while reverting disk-only VM snapshot for VM [{}]. Deleting leftover deltas.", vmName, e);
             for (SnapshotObjectTO snapshotObjectTo : snapshotObjectTos) {
                 String newPath = snapshotToNewDeltaPath.get(snapshotObjectTo);
@@ -108,4 +116,88 @@ public class LibvirtRevertDiskOnlyVMSnapshotCommandWrapper extends CommandWrappe
 
         return new RevertDiskOnlyVmSnapshotAnswer(cmd, volumeObjectTos);
     }
+
+    protected SnapshotObjectTO getRootVolumeSnapshot(List<SnapshotObjectTO> snapshotObjectTos) {
+        return snapshotObjectTos.stream()
+                .filter(snapshotObjectTO -> Volume.Type.ROOT.equals(snapshotObjectTO.getVolume().getVolumeType()))
+                .findFirst()
+                .orElse(null);
+    }
+
+    protected void validateNvramRevertState(RevertDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource, SnapshotObjectTO rootVolumeSnapshot,
+            KVMStoragePoolManager storagePoolMgr) throws IOException, LibvirtException {
+        String activeNvramPath = resource.getUefiNvramPath(cmd.getVmUuid());
+        if (StringUtils.isBlank(cmd.getNvramSnapshotPath())) {
+            if (cmd.isUefiEnabled()) {
+                throw new IOException(String.format("Cannot safely revert disk-only VM snapshot for UEFI VM [%s] because the snapshot does not contain NVRAM state.",
+                        cmd.getVmName()));
+            }
+            return;
+        }
+
+        if (StringUtils.isBlank(activeNvramPath)) {
+            throw new IOException(String.format("Unable to determine the active UEFI NVRAM path for VM [%s].", cmd.getVmName()));
+        }
+
+        Path snapshotNvramPath = getNvramSnapshotAbsolutePath(cmd.getNvramSnapshotPath(), rootVolumeSnapshot, resource, storagePoolMgr);
+        if (!Files.exists(snapshotNvramPath)) {
+            throw new IOException(String.format("Unable to find the UEFI NVRAM snapshot [%s] for VM [%s].", cmd.getNvramSnapshotPath(), cmd.getVmName()));
+        }
+    }
+
+    protected void restoreNvramIfNeeded(RevertDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource, SnapshotObjectTO rootVolumeSnapshot,
+            KVMStoragePoolManager storagePoolMgr) throws IOException, LibvirtException {
+        if (StringUtils.isBlank(cmd.getNvramSnapshotPath())) {
+            return;
+        }
+
+        String activeNvramPath = resource.getUefiNvramPath(cmd.getVmUuid());
+        if (StringUtils.isBlank(activeNvramPath)) {
+            throw new IOException(String.format("Unable to determine the active UEFI NVRAM path for VM [%s].", cmd.getVmName()));
+        }
+
+        Path snapshotNvramPath = getNvramSnapshotAbsolutePath(cmd.getNvramSnapshotPath(), rootVolumeSnapshot, resource, storagePoolMgr);
+        if (!Files.exists(snapshotNvramPath)) {
+            throw new IOException(String.format("Unable to find the UEFI NVRAM snapshot [%s] for VM [%s].", cmd.getNvramSnapshotPath(), cmd.getVmName()));
+        }
+
+        replaceNvramAtomically(snapshotNvramPath, Path.of(activeNvramPath));
+    }
+
+    protected void replaceNvramAtomically(Path snapshotNvramPath, Path activeNvramPath) throws IOException {
+        Path targetDirectory = activeNvramPath.getParent();
+        if (targetDirectory != null) {
+            Files.createDirectories(targetDirectory);
+        }
+
+        Path temporaryNvramPath = Files.createTempFile(targetDirectory, activeNvramPath.getFileName().toString(), ".tmp");
+        try {
+            copyNvramSnapshotToTemporaryPath(snapshotNvramPath, temporaryNvramPath);
+            moveTemporaryNvramIntoPlace(temporaryNvramPath, activeNvramPath);
+        } finally {
+            Files.deleteIfExists(temporaryNvramPath);
+        }
+    }
+
+    protected void copyNvramSnapshotToTemporaryPath(Path snapshotNvramPath, Path temporaryNvramPath) throws IOException {
+        Files.copy(snapshotNvramPath, temporaryNvramPath, StandardCopyOption.REPLACE_EXISTING);
+    }
+
+    protected void moveTemporaryNvramIntoPlace(Path temporaryNvramPath, Path activeNvramPath) throws IOException {
+        try {
+            Files.move(temporaryNvramPath, activeNvramPath, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+        } catch (AtomicMoveNotSupportedException e) {
+            Files.move(temporaryNvramPath, activeNvramPath, StandardCopyOption.REPLACE_EXISTING);
+        }
+    }
+
+    protected Path getNvramSnapshotAbsolutePath(String nvramSnapshotPath, SnapshotObjectTO rootVolumeSnapshot, LibvirtComputingResource resource,
+            KVMStoragePoolManager storagePoolMgr) throws IOException, LibvirtException {
+        if (rootVolumeSnapshot == null) {
+            throw new IOException("Unable to locate the root volume snapshot while handling the UEFI NVRAM state.");
+        }
+
+        KVMStoragePool storagePool = resource.getLibvirtUtilitiesHelper().getPrimaryPoolFromDataTo(rootVolumeSnapshot, storagePoolMgr);
+        return Path.of(storagePool.getLocalPathFor(nvramSnapshotPath));
+    }
 }
diff --git a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtDiskOnlyVMSnapshotCommandWrapperTest.java b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtDiskOnlyVMSnapshotCommandWrapperTest.java
new file mode 100644
index 00000000000..e447e6f6cfd
--- /dev/null
+++ b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtDiskOnlyVMSnapshotCommandWrapperTest.java
@@ -0,0 +1,816 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package com.cloud.hypervisor.kvm.resource.wrapper;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
+import org.apache.cloudstack.storage.to.SnapshotObjectTO;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
+import org.junit.Test;
+import org.libvirt.Domain;
+import org.libvirt.DomainInfo;
+
+import com.cloud.agent.api.VMSnapshotTO;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.DeleteDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.to.DataTO;
+import com.cloud.hypervisor.kvm.resource.LibvirtComputingResource;
+import com.cloud.hypervisor.kvm.storage.KVMStoragePool;
+import com.cloud.hypervisor.kvm.storage.KVMStoragePoolManager;
+import com.cloud.storage.Storage;
+import com.cloud.storage.Volume;
+import com.cloud.utils.Pair;
+
+public class LibvirtDiskOnlyVMSnapshotCommandWrapperTest {
+
+    @Test
+    public void testBackupNvramIfNeededCopiesActiveNvram() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        KVMStoragePoolManager storagePoolManager = mock(KVMStoragePoolManager.class);
+        KVMStoragePool storagePool = mock(KVMStoragePool.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO vmSnapshotTO = mock(VMSnapshotTO.class);
+        PrimaryDataStoreTO dataStoreTO = mock(PrimaryDataStoreTO.class);
+        VolumeObjectTO rootVolume = mock(VolumeObjectTO.class);
+
+        Path activeNvram = Files.createTempFile("active-", ".fd");
+        Files.writeString(activeNvram, "snapshot-nvram");
+        Path poolDirectory = Files.createTempDirectory("pool-");
+
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getTarget()).thenReturn(vmSnapshotTO);
+        when(vmSnapshotTO.getId()).thenReturn(42L);
+        when(command.getVolumeTOs()).thenReturn(List.of(rootVolume));
+        when(rootVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
+        when(rootVolume.getDataStore()).thenReturn(dataStoreTO);
+        when(dataStoreTO.getPoolType()).thenReturn(Storage.StoragePoolType.NetworkFilesystem);
+        when(dataStoreTO.getUuid()).thenReturn("pool-uuid");
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn(activeNvram.toString());
+        when(resource.getStoragePoolMgr()).thenReturn(storagePoolManager);
+        when(storagePoolManager.getStoragePool(Storage.StoragePoolType.NetworkFilesystem, "pool-uuid")).thenReturn(storagePool);
+        when(storagePool.getLocalPathFor(anyString())).thenAnswer(invocation -> poolDirectory.resolve(invocation.getArgument(0, String.class)).toString());
+
+        String nvramSnapshotPath = wrapper.backupNvramIfNeeded(command, resource);
+
+        assertEquals(".cloudstack-vm-snapshot-nvram/42.fd", nvramSnapshotPath);
+        assertEquals("snapshot-nvram", Files.readString(poolDirectory.resolve(nvramSnapshotPath)));
+    }
+
+    @Test(expected = IOException.class)
+    public void testBackupNvramIfNeededFailsWhenUefiNvramIsMissing() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn("/tmp/" + UUID.randomUUID() + ".fd");
+
+        wrapper.backupNvramIfNeeded(command, resource);
+    }
+
+    @Test(expected = IOException.class)
+    public void testValidateNvramRevertStateFailsForLegacySnapshotsOnUefiVms() throws Exception {
+        LibvirtRevertDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtRevertDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        RevertDiskOnlyVmSnapshotCommand command = mock(RevertDiskOnlyVmSnapshotCommand.class);
+
+        Path activeNvram = Files.createTempFile("active-", ".fd");
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getNvramSnapshotPath()).thenReturn(null);
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn(activeNvram.toString());
+
+        wrapper.validateNvramRevertState(command, resource, null, mock(KVMStoragePoolManager.class));
+    }
+
+    @Test(expected = IOException.class)
+    public void testValidateNvramRevertStateFailsForLegacySnapshotsOnFallbackHostsForUefiVms() throws Exception {
+        LibvirtRevertDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtRevertDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        RevertDiskOnlyVmSnapshotCommand command = mock(RevertDiskOnlyVmSnapshotCommand.class);
+
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getNvramSnapshotPath()).thenReturn(null);
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn(Path.of("/tmp", UUID.randomUUID() + ".fd").toString());
+
+        wrapper.validateNvramRevertState(command, resource, null, mock(KVMStoragePoolManager.class));
+    }
+
+    @Test
+    public void testValidateNvramRevertStateAllowsFallbackHostsWithoutLocalNvram() throws Exception {
+        LibvirtRevertDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtRevertDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        KVMStoragePoolManager storagePoolManager = mock(KVMStoragePoolManager.class);
+        KVMStoragePool storagePool = mock(KVMStoragePool.class);
+        RevertDiskOnlyVmSnapshotCommand command = mock(RevertDiskOnlyVmSnapshotCommand.class);
+        SnapshotObjectTO rootSnapshot = mock(SnapshotObjectTO.class);
+
+        Path poolDirectory = Files.createTempDirectory("pool-");
+        Path snapshotNvram = poolDirectory.resolve("nvram/42.fd");
+        Files.createDirectories(snapshotNvram.getParent());
+        Files.writeString(snapshotNvram, "snapshot");
+
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getNvramSnapshotPath()).thenReturn("nvram/42.fd");
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn(poolDirectory.resolve("missing").resolve("vm-uuid.fd").toString());
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getPrimaryPoolFromDataTo(rootSnapshot, storagePoolManager)).thenReturn(storagePool);
+        when(storagePool.getLocalPathFor("nvram/42.fd")).thenReturn(snapshotNvram.toString());
+
+        wrapper.validateNvramRevertState(command, resource, rootSnapshot, storagePoolManager);
+    }
+
+    @Test
+    public void testRestoreNvramIfNeededRestoresSnapshotBytes() throws Exception {
+        LibvirtRevertDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtRevertDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        KVMStoragePoolManager storagePoolManager = mock(KVMStoragePoolManager.class);
+        KVMStoragePool storagePool = mock(KVMStoragePool.class);
+        RevertDiskOnlyVmSnapshotCommand command = mock(RevertDiskOnlyVmSnapshotCommand.class);
+        SnapshotObjectTO rootSnapshot = mock(SnapshotObjectTO.class);
+
+        Path activeNvram = Files.createTempFile("active-", ".fd");
+        Files.writeString(activeNvram, "current");
+        Path poolDirectory = Files.createTempDirectory("pool-");
+        Path snapshotNvram = poolDirectory.resolve("nvram/42.fd");
+        Files.createDirectories(snapshotNvram.getParent());
+        Files.writeString(snapshotNvram, "snapshot");
+
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getNvramSnapshotPath()).thenReturn("nvram/42.fd");
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn(activeNvram.toString());
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getPrimaryPoolFromDataTo(rootSnapshot, storagePoolManager)).thenReturn(storagePool);
+        when(storagePool.getLocalPathFor("nvram/42.fd")).thenReturn(snapshotNvram.toString());
+
+        wrapper.restoreNvramIfNeeded(command, resource, rootSnapshot, storagePoolManager);
+
+        assertEquals("snapshot", Files.readString(activeNvram));
+    }
+
+    @Test
+    public void testRestoreNvramIfNeededCreatesMissingActiveNvramFile() throws Exception {
+        LibvirtRevertDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtRevertDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        KVMStoragePoolManager storagePoolManager = mock(KVMStoragePoolManager.class);
+        KVMStoragePool storagePool = mock(KVMStoragePool.class);
+        RevertDiskOnlyVmSnapshotCommand command = mock(RevertDiskOnlyVmSnapshotCommand.class);
+        SnapshotObjectTO rootSnapshot = mock(SnapshotObjectTO.class);
+
+        Path poolDirectory = Files.createTempDirectory("pool-");
+        Path snapshotNvram = poolDirectory.resolve("nvram/42.fd");
+        Path activeNvram = poolDirectory.resolve("target").resolve("vm-uuid.fd");
+        Files.createDirectories(snapshotNvram.getParent());
+        Files.writeString(snapshotNvram, "snapshot");
+
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getNvramSnapshotPath()).thenReturn("nvram/42.fd");
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn(activeNvram.toString());
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getPrimaryPoolFromDataTo(rootSnapshot, storagePoolManager)).thenReturn(storagePool);
+        when(storagePool.getLocalPathFor("nvram/42.fd")).thenReturn(snapshotNvram.toString());
+
+        wrapper.restoreNvramIfNeeded(command, resource, rootSnapshot, storagePoolManager);
+
+        assertEquals("snapshot", Files.readString(activeNvram));
+    }
+
+    @Test
+    public void testRestoreNvramIfNeededPreservesActiveNvramWhenCopyFails() throws Exception {
+        LibvirtRevertDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtRevertDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected void copyNvramSnapshotToTemporaryPath(Path snapshotNvramPath, Path temporaryNvramPath) throws IOException {
+                Files.writeString(temporaryNvramPath, "partial");
+                throw new IOException("copy failed");
+            }
+        };
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        KVMStoragePoolManager storagePoolManager = mock(KVMStoragePoolManager.class);
+        KVMStoragePool storagePool = mock(KVMStoragePool.class);
+        RevertDiskOnlyVmSnapshotCommand command = mock(RevertDiskOnlyVmSnapshotCommand.class);
+        SnapshotObjectTO rootSnapshot = mock(SnapshotObjectTO.class);
+
+        Path activeNvram = Files.createTempFile("active-", ".fd");
+        Files.writeString(activeNvram, "current");
+        Path poolDirectory = Files.createTempDirectory("pool-");
+        Path snapshotNvram = poolDirectory.resolve("nvram/42.fd");
+        Files.createDirectories(snapshotNvram.getParent());
+        Files.writeString(snapshotNvram, "snapshot");
+
+        when(command.getVmUuid()).thenReturn("vm-uuid");
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getNvramSnapshotPath()).thenReturn("nvram/42.fd");
+        when(resource.getUefiNvramPath("vm-uuid")).thenReturn(activeNvram.toString());
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getPrimaryPoolFromDataTo(rootSnapshot, storagePoolManager)).thenReturn(storagePool);
+        when(storagePool.getLocalPathFor("nvram/42.fd")).thenReturn(snapshotNvram.toString());
+
+        try {
+            wrapper.restoreNvramIfNeeded(command, resource, rootSnapshot, storagePoolManager);
+            fail("Expected restore to fail when the snapshot copy fails.");
+        } catch (IOException expected) {
+            assertEquals("current", Files.readString(activeNvram));
+        }
+    }
+
+    @Test
+    public void testDeleteNvramSnapshotIfNeededDeletesSidecar() throws Exception {
+        LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        KVMStoragePoolManager storagePoolManager = mock(KVMStoragePoolManager.class);
+        KVMStoragePool storagePool = mock(KVMStoragePool.class);
+        DeleteDiskOnlyVmSnapshotCommand command = mock(DeleteDiskOnlyVmSnapshotCommand.class);
+        SnapshotObjectTO rootSnapshot = mock(SnapshotObjectTO.class);
+        VolumeObjectTO rootVolume = mock(VolumeObjectTO.class);
+
+        Path poolDirectory = Files.createTempDirectory("pool-");
+        Path snapshotNvram = poolDirectory.resolve("nvram/42.fd");
+        Files.createDirectories(snapshotNvram.getParent());
+        Files.writeString(snapshotNvram, "snapshot");
+
+        when(command.getNvramSnapshotPath()).thenReturn("nvram/42.fd");
+        when(rootSnapshot.getVolume()).thenReturn(rootVolume);
+        when(rootVolume.getVolumeType()).thenReturn(Volume.Type.ROOT);
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getPrimaryPoolFromDataTo(rootSnapshot, storagePoolManager)).thenReturn(storagePool);
+        when(storagePool.getLocalPathFor("nvram/42.fd")).thenReturn(snapshotNvram.toString());
+
+        wrapper.deleteNvramSnapshotIfNeeded(command, resource, storagePoolManager, List.<DataTO>of(rootSnapshot));
+
+        assertFalse(Files.exists(snapshotNvram));
+        assertTrue(Files.exists(poolDirectory));
+    }
+
+    @Test
+    public void testDeleteNvramSnapshotIfNeededDeletesSidecarUsingPrimaryDataStore() throws Exception {
+        LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtDeleteDiskOnlyVMSnapshotCommandWrapper();
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        KVMStoragePoolManager storagePoolManager = mock(KVMStoragePoolManager.class);
+        KVMStoragePool storagePool = mock(KVMStoragePool.class);
+        DeleteDiskOnlyVmSnapshotCommand command = mock(DeleteDiskOnlyVmSnapshotCommand.class);
+        PrimaryDataStoreTO primaryDataStoreTO = mock(PrimaryDataStoreTO.class);
+
+        Path poolDirectory = Files.createTempDirectory("pool-");
+        Path snapshotNvram = poolDirectory.resolve("nvram/42.fd");
+        Files.createDirectories(snapshotNvram.getParent());
+        Files.writeString(snapshotNvram, "snapshot");
+
+        when(command.getNvramSnapshotPath()).thenReturn("nvram/42.fd");
+        when(command.getPrimaryDataStore()).thenReturn(primaryDataStoreTO);
+        when(primaryDataStoreTO.getPoolType()).thenReturn(Storage.StoragePoolType.NetworkFilesystem);
+        when(primaryDataStoreTO.getUuid()).thenReturn("pool-uuid");
+        when(storagePoolManager.getStoragePool(Storage.StoragePoolType.NetworkFilesystem, "pool-uuid")).thenReturn(storagePool);
+        when(storagePool.getLocalPathFor("nvram/42.fd")).thenReturn(snapshotNvram.toString());
+
+        wrapper.deleteNvramSnapshotIfNeeded(command, resource, storagePoolManager, List.of());
+
+        assertFalse(Files.exists(snapshotNvram));
+    }
+
+    @Test
+    public void testResumeVmIfNeededOnlyResumesWhenWrapperSuspendedVm() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        Domain domain = mock(Domain.class);
+
+        wrapper.resumeVmIfNeeded(domain, "vm-name", false);
+
+        verify(domain, never()).resume();
+        verify(domain, never()).getInfo();
+    }
+
+    @Test
+    public void testSuspendVmIfNeededSkipsAlreadyPausedVm() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        Domain domain = mock(Domain.class);
+        DomainInfo domainInfo = new DomainInfo();
+        domainInfo.state = DomainInfo.DomainState.VIR_DOMAIN_PAUSED;
+        when(domain.getInfo()).thenReturn(domainInfo);
+
+        assertFalse(wrapper.suspendVmIfNeeded(domain));
+        verify(domain, never()).suspend();
+    }
+
+    @Test
+    public void testShouldSuspendVmForSnapshotWhenUefiAndNotQuiesced() {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getTarget()).thenReturn(target);
+        when(target.getQuiescevm()).thenReturn(false);
+
+        assertTrue(wrapper.shouldSuspendVmForSnapshot(command));
+    }
+
+    @Test
+    public void testShouldSuspendVmForSnapshotWhenQuiesceIsRequested() {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getTarget()).thenReturn(target);
+        when(target.getQuiescevm()).thenReturn(true);
+
+        assertTrue(wrapper.shouldSuspendVmForSnapshot(command));
+    }
+
+    @Test
+    public void testShouldFreezeVmFilesystemsForSnapshotWhenQuiesceIsRequested() {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(command.getTarget()).thenReturn(target);
+        when(target.getQuiescevm()).thenReturn(true);
+
+        assertTrue(wrapper.shouldFreezeVmFilesystemsForSnapshot(command));
+    }
+
+    @Test
+    public void testGetFlagsToUseForRunningVmSnapshotCreationOmitsLibvirtQuiesceWhenAlreadyFrozen() {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper();
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(target.getQuiescevm()).thenReturn(true);
+
+        int flags = wrapper.getFlagsToUseForRunningVmSnapshotCreation(target, true);
+
+        assertEquals(0, flags & Domain.SnapshotCreateFlags.QUIESCE);
+        assertTrue((flags & Domain.SnapshotCreateFlags.DISK_ONLY) != 0);
+        assertTrue((flags & Domain.SnapshotCreateFlags.ATOMIC) != 0);
+        assertTrue((flags & Domain.SnapshotCreateFlags.NO_METADATA) != 0);
+    }
+
+    @Test
+    public void testFreezeAndVerifyVmFilesystemsSucceedsWhenGuestAgentReportsFrozen() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected String getResultOfQemuCommand(String cmd, Domain domain) {
+                if ("status".equals(cmd)) {
+                    return "{\"return\":\"frozen\"}";
+                }
+                return "{\"return\":0}";
+            }
+        };
+
+        Domain domain = mock(Domain.class);
+        wrapper.freezeVmFilesystems(domain, "vm-name");
+        wrapper.verifyVmFilesystemsFrozen(domain, "vm-name");
+    }
+
+    @Test
+    public void testFreezeVmFilesystemsFailsForQemuErrorResponse() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected String getResultOfQemuCommand(String cmd, Domain domain) {
+                return "{\"error\":{\"class\":\"GenericError\",\"desc\":\"guest agent failure\"}}";
+            }
+        };
+
+        try {
+            wrapper.freezeVmFilesystems(mock(Domain.class), "vm-name");
+            fail("QEMU guest agent error responses must be treated as freeze failures.");
+        } catch (IOException e) {
+            assertTrue(e.getMessage().contains("Failed to freeze VM [vm-name] filesystems"));
+        }
+    }
+
+    @Test
+    public void testThawVmFilesystemsFailsForQemuErrorResponse() {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected String getResultOfQemuCommand(String cmd, Domain domain) {
+                return "{\"error\":{\"class\":\"GenericError\",\"desc\":\"guest agent failure\"}}";
+            }
+        };
+
+        assertFalse(wrapper.thawVmFilesystemsIfNeeded(mock(Domain.class), "vm-name"));
+    }
+
+    @Test
+    public void testTakeDiskOnlyVmSnapshotOfRunningVmThawsWhenFreezeVerificationFails() throws Exception {
+        final boolean[] thawCalled = {false};
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected Pair<String, java.util.Map<String, Pair<Long, String>>> createSnapshotXmlAndNewVolumePathMap(List<VolumeObjectTO> volumeObjectTOS,
+                    List<com.cloud.hypervisor.kvm.resource.LibvirtVMDef.DiskDef> disks, VMSnapshotTO target, LibvirtComputingResource resource) {
+                return new Pair<>("<domainsnapshot/>", Collections.emptyMap());
+            }
+
+            @Override
+            protected boolean shouldSuspendVmForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return false;
+            }
+
+            @Override
+            protected boolean shouldFreezeVmFilesystemsForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return true;
+            }
+
+            @Override
+            protected void freezeVmFilesystems(Domain domain, String vmName) {
+            }
+
+            @Override
+            protected void verifyVmFilesystemsFrozen(Domain domain, String vmName) throws IOException {
+                throw new IOException("status verification failed");
+            }
+
+            @Override
+            protected boolean thawVmFilesystemsIfNeeded(Domain domain, String vmName) {
+                thawCalled[0] = true;
+                return true;
+            }
+        };
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        org.libvirt.Connect connect = mock(org.libvirt.Connect.class);
+        Domain domain = mock(Domain.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getVolumeTOs()).thenReturn(List.of());
+        when(command.getTarget()).thenReturn(target);
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getConnection()).thenReturn(connect);
+        when(resource.getDisks(connect, "vm-name")).thenReturn(List.of());
+        when(resource.getDomain(connect, "vm-name")).thenReturn(domain);
+
+        CreateDiskOnlyVmSnapshotAnswer answer = (CreateDiskOnlyVmSnapshotAnswer) wrapper.takeDiskOnlyVmSnapshotOfRunningVm(command, resource);
+
+        assertFalse(answer.getResult());
+        assertTrue("Thaw must be attempted after a successful freeze followed by verification failure", thawCalled[0]);
+    }
+
+    @Test
+    public void testVerifyVmFilesystemsFrozenFailsForQemuErrorResponse() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected String getResultOfQemuCommand(String cmd, Domain domain) {
+                return "{\"error\":{\"class\":\"GenericError\",\"desc\":\"guest agent failure\"}}";
+            }
+        };
+
+        try {
+            wrapper.verifyVmFilesystemsFrozen(mock(Domain.class), "vm-name");
+            fail("QEMU guest agent error responses must be treated as IO failures.");
+        } catch (IOException e) {
+            assertTrue(e.getMessage().contains("Failed to verify VM [vm-name] filesystem freeze state"));
+        }
+    }
+
+    @Test
+    public void testTakeDiskOnlyVmSnapshotOfRunningVmReturnsFailureAnswerWhenFreezeStatusJsonIsMalformed() throws Exception {
+        final boolean[] thawCalled = {false};
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected Pair<String, java.util.Map<String, Pair<Long, String>>> createSnapshotXmlAndNewVolumePathMap(List<VolumeObjectTO> volumeObjectTOS,
+                    List<com.cloud.hypervisor.kvm.resource.LibvirtVMDef.DiskDef> disks, VMSnapshotTO target, LibvirtComputingResource resource) {
+                return new Pair<>("<domainsnapshot/>", Collections.emptyMap());
+            }
+
+            @Override
+            protected boolean shouldSuspendVmForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return false;
+            }
+
+            @Override
+            protected boolean shouldFreezeVmFilesystemsForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return true;
+            }
+
+            @Override
+            protected void freezeVmFilesystems(Domain domain, String vmName) {
+            }
+
+            @Override
+            protected String getResultOfQemuCommand(String cmd, Domain domain) {
+                return "not-json";
+            }
+
+            @Override
+            protected boolean thawVmFilesystemsIfNeeded(Domain domain, String vmName) {
+                thawCalled[0] = true;
+                return true;
+            }
+        };
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        org.libvirt.Connect connect = mock(org.libvirt.Connect.class);
+        Domain domain = mock(Domain.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getVolumeTOs()).thenReturn(List.of());
+        when(command.getTarget()).thenReturn(target);
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getConnection()).thenReturn(connect);
+        when(resource.getDisks(connect, "vm-name")).thenReturn(List.of());
+        when(resource.getDomain(connect, "vm-name")).thenReturn(domain);
+
+        CreateDiskOnlyVmSnapshotAnswer answer = (CreateDiskOnlyVmSnapshotAnswer) wrapper.takeDiskOnlyVmSnapshotOfRunningVm(command, resource);
+
+        assertFalse(answer.getResult());
+        assertTrue(answer.getDetails().contains("Failed to verify VM [vm-name] filesystem freeze state"));
+        assertTrue("Thaw must be attempted when freeze verification fails on malformed JSON", thawCalled[0]);
+    }
+
+    @Test
+    public void testTakeDiskOnlyVmSnapshotOfRunningVmSuspendsBeforeNvramCopyForQuiescedUefiSnapshots() throws Exception {
+        List<String> operations = new ArrayList<>();
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected Pair<String, java.util.Map<String, Pair<Long, String>>> createSnapshotXmlAndNewVolumePathMap(List<VolumeObjectTO> volumeObjectTOS,
+                    List<com.cloud.hypervisor.kvm.resource.LibvirtVMDef.DiskDef> disks, VMSnapshotTO target, LibvirtComputingResource resource) {
+                return new Pair<>("<domainsnapshot/>", Collections.emptyMap());
+            }
+
+            @Override
+            protected void freezeVmFilesystems(Domain domain, String vmName) {
+                operations.add("freeze");
+            }
+
+            @Override
+            protected void verifyVmFilesystemsFrozen(Domain domain, String vmName) {
+                operations.add("verify");
+            }
+
+            @Override
+            protected boolean suspendVmIfNeeded(Domain domain) {
+                operations.add("suspend");
+                return true;
+            }
+
+            @Override
+            protected String backupNvramIfNeeded(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource) {
+                operations.add("backup");
+                return "nvram/42.fd";
+            }
+
+            @Override
+            protected void cleanupNvramSnapshotIfNeeded(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource, String nvramSnapshotPath) {
+            }
+
+            @Override
+            protected boolean resumeVmIfNeeded(Domain domain, String vmName) {
+                operations.add("resume");
+                return true;
+            }
+
+            @Override
+            protected boolean thawVmFilesystemsIfNeeded(Domain domain, String vmName) {
+                operations.add("thaw");
+                return true;
+            }
+        };
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        org.libvirt.Connect connect = mock(org.libvirt.Connect.class);
+        Domain domain = mock(Domain.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getVolumeTOs()).thenReturn(List.of());
+        when(command.getTarget()).thenReturn(target);
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(target.getQuiescevm()).thenReturn(true);
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getConnection()).thenReturn(connect);
+        when(resource.getDisks(connect, "vm-name")).thenReturn(List.of());
+        when(resource.getDomain(connect, "vm-name")).thenReturn(domain);
+        doThrow(mock(org.libvirt.LibvirtException.class)).when(domain).snapshotCreateXML(anyString(), anyInt());
+
+        CreateDiskOnlyVmSnapshotAnswer answer = (CreateDiskOnlyVmSnapshotAnswer) wrapper.takeDiskOnlyVmSnapshotOfRunningVm(command, resource);
+
+        assertFalse(answer.getResult());
+        assertEquals(List.of("freeze", "verify", "suspend", "backup", "resume", "thaw"), operations);
+    }
+
+    @Test
+    public void testTakeDiskOnlyVmSnapshotOfRunningVmReturnsSuccessWithWarningWhenThawFails() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected Pair<String, java.util.Map<String, Pair<Long, String>>> createSnapshotXmlAndNewVolumePathMap(List<VolumeObjectTO> volumeObjectTOS,
+                    List<com.cloud.hypervisor.kvm.resource.LibvirtVMDef.DiskDef> disks, VMSnapshotTO target, LibvirtComputingResource resource) {
+                return new Pair<>("<domainsnapshot/>", Collections.emptyMap());
+            }
+
+            @Override
+            protected boolean shouldSuspendVmForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return false;
+            }
+
+            @Override
+            protected boolean shouldFreezeVmFilesystemsForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return true;
+            }
+
+            @Override
+            protected void freezeVmFilesystems(Domain domain, String vmName) {
+            }
+
+            @Override
+            protected void verifyVmFilesystemsFrozen(Domain domain, String vmName) {
+            }
+
+            @Override
+            protected String backupNvramIfNeeded(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource) {
+                return null;
+            }
+
+            @Override
+            protected boolean thawVmFilesystemsIfNeeded(Domain domain, String vmName) {
+                return false;
+            }
+
+            @Override
+            protected boolean thawVmFilesystemsIfNeeded(Domain domain, String vmName, boolean frozen) {
+                return false;
+            }
+        };
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        org.libvirt.Connect connect = mock(org.libvirt.Connect.class);
+        Domain domain = mock(Domain.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getVolumeTOs()).thenReturn(List.of());
+        when(command.getTarget()).thenReturn(target);
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getConnection()).thenReturn(connect);
+        when(resource.getDisks(connect, "vm-name")).thenReturn(List.of());
+        when(resource.getDomain(connect, "vm-name")).thenReturn(domain);
+
+        CreateDiskOnlyVmSnapshotAnswer answer = (CreateDiskOnlyVmSnapshotAnswer) wrapper.takeDiskOnlyVmSnapshotOfRunningVm(command, resource);
+
+        assertTrue("Snapshot metadata must still be returned when thaw fails after snapshot creation", answer.getResult());
+        assertTrue(answer.getDetails().contains("could not be thawed"));
+    }
+
+    @Test
+    public void testTakeDiskOnlyVmSnapshotOfRunningVmReturnsSuccessWithWarningWhenResumeFails() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected Pair<String, java.util.Map<String, Pair<Long, String>>> createSnapshotXmlAndNewVolumePathMap(List<VolumeObjectTO> volumeObjectTOS,
+                    List<com.cloud.hypervisor.kvm.resource.LibvirtVMDef.DiskDef> disks, VMSnapshotTO target, LibvirtComputingResource resource) {
+                return new Pair<>("<domainsnapshot/>", Collections.emptyMap());
+            }
+
+            @Override
+            protected boolean shouldSuspendVmForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return true;
+            }
+
+            @Override
+            protected boolean suspendVmIfNeeded(Domain domain) {
+                return true;
+            }
+
+            @Override
+            protected boolean shouldFreezeVmFilesystemsForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return false;
+            }
+
+            @Override
+            protected String backupNvramIfNeeded(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource) {
+                return null;
+            }
+
+            @Override
+            protected boolean resumeVmIfNeeded(Domain domain, String vmName) {
+                return false;
+            }
+
+            @Override
+            protected boolean resumeVmIfNeeded(Domain domain, String vmName, boolean suspended) {
+                return false;
+            }
+        };
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        org.libvirt.Connect connect = mock(org.libvirt.Connect.class);
+        Domain domain = mock(Domain.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getVolumeTOs()).thenReturn(List.of());
+        when(command.getTarget()).thenReturn(target);
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getConnection()).thenReturn(connect);
+        when(resource.getDisks(connect, "vm-name")).thenReturn(List.of());
+        when(resource.getDomain(connect, "vm-name")).thenReturn(domain);
+
+        CreateDiskOnlyVmSnapshotAnswer answer = (CreateDiskOnlyVmSnapshotAnswer) wrapper.takeDiskOnlyVmSnapshotOfRunningVm(command, resource);
+
+        assertTrue("Snapshot metadata must still be returned when resume fails after snapshot creation", answer.getResult());
+        assertTrue(answer.getDetails().contains("could not be resumed"));
+    }
+
+    @Test
+    public void testTakeDiskOnlyVmSnapshotOfRunningVmHandlesNullErrorMessage() throws Exception {
+        LibvirtCreateDiskOnlyVMSnapshotCommandWrapper wrapper = new LibvirtCreateDiskOnlyVMSnapshotCommandWrapper() {
+            @Override
+            protected Pair<String, java.util.Map<String, Pair<Long, String>>> createSnapshotXmlAndNewVolumePathMap(List<VolumeObjectTO> volumeObjectTOS,
+                    List<com.cloud.hypervisor.kvm.resource.LibvirtVMDef.DiskDef> disks, VMSnapshotTO target, LibvirtComputingResource resource) {
+                return new Pair<>("<domainsnapshot/>", Collections.emptyMap());
+            }
+
+            @Override
+            protected boolean shouldSuspendVmForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return false;
+            }
+
+            @Override
+            protected boolean shouldFreezeVmFilesystemsForSnapshot(CreateDiskOnlyVmSnapshotCommand cmd) {
+                return false;
+            }
+
+            @Override
+            protected String backupNvramIfNeeded(CreateDiskOnlyVmSnapshotCommand cmd, LibvirtComputingResource resource) throws IOException {
+                throw new IOException();
+            }
+        };
+        LibvirtComputingResource resource = mock(LibvirtComputingResource.class);
+        LibvirtUtilitiesHelper libvirtUtilitiesHelper = mock(LibvirtUtilitiesHelper.class);
+        org.libvirt.Connect connect = mock(org.libvirt.Connect.class);
+        Domain domain = mock(Domain.class);
+        CreateDiskOnlyVmSnapshotCommand command = mock(CreateDiskOnlyVmSnapshotCommand.class);
+        VMSnapshotTO target = mock(VMSnapshotTO.class);
+
+        when(command.getVmName()).thenReturn("vm-name");
+        when(command.getVolumeTOs()).thenReturn(List.of());
+        when(command.getTarget()).thenReturn(target);
+        when(command.isUefiEnabled()).thenReturn(true);
+        when(resource.getLibvirtUtilitiesHelper()).thenReturn(libvirtUtilitiesHelper);
+        when(libvirtUtilitiesHelper.getConnection()).thenReturn(connect);
+        when(resource.getDisks(connect, "vm-name")).thenReturn(List.of());
+        when(resource.getDomain(connect, "vm-name")).thenReturn(domain);
+
+        CreateDiskOnlyVmSnapshotAnswer answer = (CreateDiskOnlyVmSnapshotAnswer) wrapper.takeDiskOnlyVmSnapshotOfRunningVm(command, resource);
+
+        assertFalse(answer.getResult());
+    }
+}
diff --git a/ui/public/locales/en.json b/ui/public/locales/en.json
index 5eafe5c763d..be82d34a976 100644
--- a/ui/public/locales/en.json
+++ b/ui/public/locales/en.json
@@ -2919,6 +2919,7 @@
 "message.action.cancel.maintenance": "Your host has been successfully canceled for maintenance. This process can take up to several minutes.",
 "message.action.cancel.maintenance.mode": "Please confirm that you want to cancel this maintenance.",
 "message.action.create.snapshot.from.vmsnapshot": "Please confirm that you want to create Snapshot from Instance Snapshot",
+"message.action.vmsnapshot.create": "Please confirm that you want to create an Instance Snapshot.<br>Running KVM UEFI disk-only snapshots briefly suspend the Instance while NVRAM state is copied.",
 "message.action.create.instance.from.backup": "Please confirm that you want to create a new Instance from the given Backup.<br>Click on configure to edit the parameters for the new Instance before creation.",
 "message.create.instance.from.backup.different.zone": "Creating Instance from Backup on a different Zone. Please ensure that the backup repository is accessible in the selected Zone.",
 "message.csv.empty": "Empty CSV File",
diff --git a/ui/src/config/section/compute.js b/ui/src/config/section/compute.js
index 10bf0a3973a..4575cf2a057 100644
--- a/ui/src/config/section/compute.js
+++ b/ui/src/config/section/compute.js
@@ -191,6 +191,7 @@ export default {
           api: 'createVMSnapshot',
           icon: 'camera-outlined',
           label: 'label.action.vmsnapshot.create',
+          message: 'message.action.vmsnapshot.create',
           docHelp: 'adminguide/virtual_machines.html#virtual-machine-snapshots',
           dataView: true,
           args: (record, store) => {
diff --git a/ui/src/config/section/network.js b/ui/src/config/section/network.js
index f59f6e6d15b..e0137b970b2 100644
--- a/ui/src/config/section/network.js
+++ b/ui/src/config/section/network.js
@@ -504,6 +504,7 @@ export default {
           api: 'createVMSnapshot',
           icon: 'camera-outlined',
           label: 'label.action.vmsnapshot.create',
+          message: 'message.action.vmsnapshot.create',
           docHelp: 'adminguide/virtual_machines.html#virtual-machine-snapshots',
           dataView: true,
           args: ['virtualmachineid', 'name', 'description', 'snapshotmemory', 'quiescevm'],