diff --git a/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateImageStoreCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateImageStoreCmd.java
index 0e1631a46ba2..ee83b78d07fe 100644
--- a/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateImageStoreCmd.java
+++ b/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateImageStoreCmd.java
@@ -50,6 +50,13 @@ public class UpdateImageStoreCmd extends BaseCmd {
             description = "The number of bytes CloudStack can use on this image storage.\n\tNOTE: this will be overwritten by the StatsCollector as soon as there is a SSVM to query the storage.")
     private Long capacityBytes;
 
+    @Parameter(name = ApiConstants.URL, type = CommandType.STRING, required = false,
+            description = "The new URL for the image store (e.g. nfs://new-host/export). " +
+                    "The image store must be in read-only state before its URL can be changed. " +
+                    "After updating, destroy and recreate any Secondary Storage VMs so they remount the new path.",
+            since = "4.23.0")
+    private String url;
+
     /////////////////////////////////////////////////////
     /////////////////// Accessors ///////////////////////
     /////////////////////////////////////////////////////
@@ -70,6 +77,10 @@ public Long getCapacityBytes() {
         return capacityBytes;
     }
 
+    public String getUrl() {
+        return url;
+    }
+
     /////////////////////////////////////////////////////
     /////////////// API Implementation///////////////////
     /////////////////////////////////////////////////////
diff --git a/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateStoragePoolCmd.java b/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateStoragePoolCmd.java
index 4b0a6ba00b28..9529da84df76 100644
--- a/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateStoragePoolCmd.java
+++ b/api/src/main/java/org/apache/cloudstack/api/command/admin/storage/UpdateStoragePoolCmd.java
@@ -73,7 +73,12 @@ public class UpdateStoragePoolCmd extends BaseCmd {
     @Parameter(name = ApiConstants.URL,
                             type = CommandType.STRING,
                             required = false,
-                            description = "the URL of the storage pool",
+                            description = "the URL of the storage pool. Supported only for NFS and Gluster pool type." +
+                                    "The pool must be in Maintenance mode before changing the URL. WARNING: use this parameter" +
+                                    "with caution. It is intended for failover scenarios where the storage content is already " +
+                                    "fully mirrored at the new location. Pointing to a new location without ensuring complete " +
+                                    "data parity will result in data loss or corruption. After the URL is updated, the new mount" +
+                                    "is applied to all connected hosts or restart the Management server",
                             since = "4.19.0")
     private String url;
 
diff --git a/engine/components-api/src/main/java/com/cloud/storage/StorageManager.java b/engine/components-api/src/main/java/com/cloud/storage/StorageManager.java
index 3c62738f9ed5..455ac8c33389 100644
--- a/engine/components-api/src/main/java/com/cloud/storage/StorageManager.java
+++ b/engine/components-api/src/main/java/com/cloud/storage/StorageManager.java
@@ -411,7 +411,7 @@ void connectHostsToPool(DataStore primaryStore, List<Long> hostIds, Scope scope,
 
     Long getDiskIopsWriteRate(ServiceOffering offering, DiskOffering diskOffering);
 
-    ImageStore updateImageStoreStatus(Long id, String name, Boolean readonly, Long capacityBytes);
+    ImageStore updateImageStoreStatus(Long id, String name, Boolean readonly, Long capacityBytes, String url);
 
     void cleanupDownloadUrls();
 
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptor.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptor.java
index a03daeb197bf..5e00c24e45c8 100644
--- a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptor.java
+++ b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptor.java
@@ -766,6 +766,39 @@ public KVMStoragePool createStoragePool(String name, String host, int port, Stri
             path = path.substring(0, path.length() - 1);
         }
 
+        // For NFS and Gluster pools, if the existing pool's source host or path has changed
+        // (e.g. after a storage URL update), destroy and undefine it so it gets recreated
+        // with the new source below. Restricted to NFS/Gluster only.
+        if (sp != null && (type == StoragePoolType.NetworkFilesystem || type == StoragePoolType.Gluster)) {
+            try {
+                LibvirtStoragePoolDef existingDef = getStoragePoolDef(conn, sp);
+                if (existingDef != null) {
+                    String existingSourceHost = existingDef.getSourceHost();
+                    String existingSourceDir = existingDef.getSourceDir();
+                    boolean hostChanged = host != null && existingSourceHost != null && !existingSourceHost.equals(host);
+                    boolean pathChanged = path != null && existingSourceDir != null && !existingSourceDir.equals(path);
+                    if (hostChanged || pathChanged) {
+                        logger.info("Storage pool {} source has changed (host: {} -> {}, path: {} -> {}); destroying and redefining.",
+                                name, existingSourceHost, host, existingSourceDir, path);
+                        try {
+                            if (sp.isPersistent() == 1) {
+                                sp.destroy();
+                                sp.undefine();
+                            } else {
+                                sp.destroy();
+                            }
+                            sp.free();
+                            sp = null;
+                        } catch (LibvirtException destroyEx) {
+                            logger.error("Failed to destroy storage pool {} with changed source; will attempt to reuse existing pool: {}", name, destroyEx.getMessage());
+                        }
+                    }
+                }
+            } catch (LibvirtException e) {
+                logger.warn("Failed to check existing storage pool {} source path, will attempt to reuse it: {}", name, e.getMessage());
+            }
+        }
+
         if (sp == null) {
             // see if any existing pool by another name is using our storage path.
             // if anyone is, undefine the pool so we can define it as requested.
diff --git a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java
index 88346abd0176..259cb603aeb8 100644
--- a/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java
+++ b/plugins/hypervisors/kvm/src/test/java/com/cloud/hypervisor/kvm/storage/LibvirtStorageAdaptorTest.java
@@ -42,9 +42,13 @@
 import com.cloud.hypervisor.kvm.resource.LibvirtConnection;
 import com.cloud.hypervisor.kvm.resource.LibvirtStoragePoolDef;
 import com.cloud.storage.Storage;
+import com.cloud.storage.StorageLayer;
 import com.cloud.utils.Pair;
 import com.cloud.utils.exception.CloudRuntimeException;
 import com.cloud.utils.script.Script;
+import org.libvirt.LibvirtException;
+
+import org.springframework.test.util.ReflectionTestUtils;
 
 @RunWith(MockitoJUnitRunner.class)
 public class LibvirtStorageAdaptorTest {
@@ -56,6 +60,9 @@ public class LibvirtStorageAdaptorTest {
     @Mock
     LibvirtStoragePool mockPool;
 
+    @Mock
+    StorageLayer storageLayer;
+
     MockedStatic<Script> mockScript;
 
     @Spy
@@ -67,6 +74,7 @@ public void initMocks() {
         libvirtConnectionMockedStatic = Mockito.mockStatic(LibvirtConnection.class);
         Mockito.reset(mockPool);
         mockScript = Mockito.mockStatic(Script.class);
+        ReflectionTestUtils.setField(libvirtStorageAdaptor, "_storageLayer", storageLayer);
     }
 
     @After
@@ -176,4 +184,171 @@ public void testUpdateLocalPoolIops_NullResultFromScript() {
 
         Mockito.verify(mockPool, never()).setUsedIops(anyLong());
     }
+
+    /**
+     * Creates a {@link LibvirtException} via reflection since its only constructor is package-private.
+     */
+    private static LibvirtException createLibvirtException(String message) throws Exception {
+        org.libvirt.Error virError = Mockito.mock(org.libvirt.Error.class);
+        Mockito.when(virError.getMessage()).thenReturn(message);
+        java.lang.reflect.Constructor<LibvirtException> ctor =
+                LibvirtException.class.getDeclaredConstructor(org.libvirt.Error.class);
+        ctor.setAccessible(true);
+        return ctor.newInstance(virError);
+    }
+
+    private String buildNfsPoolXml(String uuid, String host, String dir, String targetPath) {
+        return "<pool type='netfs'>\n" +
+                "<name>" + uuid + "</name>\n<uuid>" + uuid + "</uuid>\n" +
+                "<source>\n<host name='" + host + "'/>\n<dir path='" + dir + "'/>\n</source>\n" +
+                "<target>\n<path>" + targetPath + "</path>\n</target>\n</pool>\n";
+    }
+
+    /**
+     * NFS pool exists with same host and path: should reuse it without destroying.
+     */
+    @Test
+    public void testCreateStoragePool_NFS_SameHostAndPath_ReusesPool() throws Exception {
+        String uuid = UUID.randomUUID().toString();
+        String host = "10.0.0.1";
+        String path = "/export/primary";
+        String targetPath = "/mnt/" + uuid;
+        String poolXml = buildNfsPoolXml(uuid, host, path, targetPath);
+
+        Connect conn = Mockito.mock(Connect.class);
+        StoragePool sp = Mockito.mock(StoragePool.class);
+        Mockito.when(LibvirtConnection.getConnection()).thenReturn(conn);
+        Mockito.when(conn.storagePoolLookupByUUIDString(uuid)).thenReturn(sp);
+        Mockito.when(sp.isActive()).thenReturn(1);
+        Mockito.when(sp.getXMLDesc(0)).thenReturn(poolXml);
+        Mockito.when(Script.runSimpleBashScriptForExitValue(anyString())).thenReturn(0);
+        Mockito.doReturn(Mockito.mock(KVMStoragePool.class)).when(libvirtStorageAdaptor).getStoragePool(uuid);
+
+        libvirtStorageAdaptor.createStoragePool(uuid, host, 0, path, null,
+                Storage.StoragePoolType.NetworkFilesystem, null, true);
+
+        // pool was not destroyed since source didn't change
+        Mockito.verify(sp, Mockito.never()).destroy();
+        Mockito.verify(sp, Mockito.never()).undefine();
+    }
+
+    /**
+     * NFS pool exists but path has changed: should destroy and recreate.
+     */
+    @Test
+    public void testCreateStoragePool_NFS_PathChanged_DestroysAndRecreates() throws Exception {
+        String uuid = UUID.randomUUID().toString();
+        String host = "10.0.0.1";
+        String oldPath = "/export/old";
+        String newPath = "/export/new";
+        String targetPath = "/mnt/" + uuid;
+        String poolXml = buildNfsPoolXml(uuid, host, oldPath, targetPath);
+
+        Connect conn = Mockito.mock(Connect.class);
+        StoragePool sp = Mockito.mock(StoragePool.class);
+        Mockito.when(LibvirtConnection.getConnection()).thenReturn(conn);
+        Mockito.when(conn.storagePoolLookupByUUIDString(uuid)).thenReturn(sp);
+        Mockito.when(sp.isActive()).thenReturn(1);
+        Mockito.when(sp.getXMLDesc(0)).thenReturn(poolXml);
+        Mockito.when(sp.isPersistent()).thenReturn(1);
+        Mockito.when(conn.listStoragePools()).thenReturn(new String[]{});
+        StoragePool newSp = Mockito.mock(StoragePool.class);
+        Mockito.when(conn.storagePoolCreateXML(anyString(), Mockito.eq(0))).thenReturn(newSp);
+        Mockito.when(Script.runSimpleBashScriptForExitValue(anyString())).thenReturn(0);
+        Mockito.doReturn(Mockito.mock(KVMStoragePool.class)).when(libvirtStorageAdaptor).getStoragePool(uuid);
+
+        libvirtStorageAdaptor.createStoragePool(uuid, host, 0, newPath, null,
+                Storage.StoragePoolType.NetworkFilesystem, null, true);
+
+        Mockito.verify(sp).destroy();
+        Mockito.verify(sp).undefine();
+        Mockito.verify(sp).free();
+    }
+
+    /**
+     * NFS pool exists but host has changed: should destroy and recreate.
+     */
+    @Test
+    public void testCreateStoragePool_NFS_HostChanged_DestroysAndRecreates() throws Exception {
+        String uuid = UUID.randomUUID().toString();
+        String oldHost = "10.0.0.1";
+        String newHost = "10.0.0.2";
+        String path = "/export/primary";
+        String targetPath = "/mnt/" + uuid;
+        String poolXml = buildNfsPoolXml(uuid, oldHost, path, targetPath);
+
+        Connect conn = Mockito.mock(Connect.class);
+        StoragePool sp = Mockito.mock(StoragePool.class);
+        Mockito.when(LibvirtConnection.getConnection()).thenReturn(conn);
+        Mockito.when(conn.storagePoolLookupByUUIDString(uuid)).thenReturn(sp);
+        Mockito.when(sp.isActive()).thenReturn(1);
+        Mockito.when(sp.getXMLDesc(0)).thenReturn(poolXml);
+        Mockito.when(sp.isPersistent()).thenReturn(1);
+        Mockito.when(conn.listStoragePools()).thenReturn(new String[]{});
+        StoragePool newSp = Mockito.mock(StoragePool.class);
+        Mockito.when(conn.storagePoolCreateXML(anyString(), Mockito.eq(0))).thenReturn(newSp);
+        Mockito.when(Script.runSimpleBashScriptForExitValue(anyString())).thenReturn(0);
+        Mockito.doReturn(Mockito.mock(KVMStoragePool.class)).when(libvirtStorageAdaptor).getStoragePool(uuid);
+
+        libvirtStorageAdaptor.createStoragePool(uuid, newHost, 0, path, null,
+                Storage.StoragePoolType.NetworkFilesystem, null, true);
+
+        Mockito.verify(sp).destroy();
+        Mockito.verify(sp).undefine();
+        Mockito.verify(sp).free();
+    }
+
+    /**
+     * RBD pool exists with different source — should NOT destroy (RBD is excluded from this logic).
+     */
+    @Test
+    public void testCreateStoragePool_RBD_SourceChanged_DoesNotDestroy() throws Exception {
+        String uuid = UUID.randomUUID().toString();
+        String rbdPoolXml = "<pool type='rbd'>\n<name>" + uuid + "</name>\n<uuid>" + uuid + "</uuid>\n" +
+                "<source>\n<host name='10.0.0.1'/>\n<name>oldpool</name>\n</source>\n</pool>\n";
+
+        Connect conn = Mockito.mock(Connect.class);
+        StoragePool sp = Mockito.mock(StoragePool.class);
+        Mockito.when(LibvirtConnection.getConnection()).thenReturn(conn);
+        Mockito.when(conn.storagePoolLookupByUUIDString(uuid)).thenReturn(sp);
+        Mockito.when(sp.isActive()).thenReturn(1);
+        Mockito.doReturn(Mockito.mock(KVMStoragePool.class)).when(libvirtStorageAdaptor).getStoragePool(uuid);
+
+        libvirtStorageAdaptor.createStoragePool(uuid, "10.0.0.2", 6789, "newpool", "user:secret",
+                Storage.StoragePoolType.RBD, null, true);
+
+        Mockito.verify(sp, Mockito.never()).destroy();
+        Mockito.verify(sp, Mockito.never()).undefine();
+    }
+
+    /**
+     * NFS pool exists, destroy fails — pool should be reused (not crash), sp.free() not called.
+     */
+    @Test
+    public void testCreateStoragePool_NFS_DestroyFails_ReusesExistingPool() throws Exception {
+        String uuid = UUID.randomUUID().toString();
+        String host = "10.0.0.1";
+        String oldPath = "/export/old";
+        String newPath = "/export/new";
+        String targetPath = "/mnt/" + uuid;
+        String poolXml = buildNfsPoolXml(uuid, host, oldPath, targetPath);
+
+        Connect conn = Mockito.mock(Connect.class);
+        StoragePool sp = Mockito.mock(StoragePool.class);
+        Mockito.when(LibvirtConnection.getConnection()).thenReturn(conn);
+        Mockito.when(conn.storagePoolLookupByUUIDString(uuid)).thenReturn(sp);
+        Mockito.when(sp.isActive()).thenReturn(1);
+        Mockito.when(sp.getXMLDesc(0)).thenReturn(poolXml);
+        Mockito.when(sp.isPersistent()).thenReturn(1);
+        LibvirtException libvirtException = createLibvirtException("pool is busy");
+        Mockito.doThrow(libvirtException).when(sp).destroy();
+        Mockito.when(Script.runSimpleBashScriptForExitValue(anyString())).thenReturn(0);
+        Mockito.doReturn(Mockito.mock(KVMStoragePool.class)).when(libvirtStorageAdaptor).getStoragePool(uuid);
+
+        libvirtStorageAdaptor.createStoragePool(uuid, host, 0, newPath, null,
+                Storage.StoragePoolType.NetworkFilesystem, null, true);
+
+        Mockito.verify(sp).destroy();
+        Mockito.verify(sp, Mockito.never()).free();
+    }
 }
diff --git a/server/src/main/java/com/cloud/server/StatsCollector.java b/server/src/main/java/com/cloud/server/StatsCollector.java
index 049ed4543617..5a98feac51a2 100644
--- a/server/src/main/java/com/cloud/server/StatsCollector.java
+++ b/server/src/main/java/com/cloud/server/StatsCollector.java
@@ -1787,7 +1787,7 @@ private void updateStorageStats(ConcurrentHashMap<Long, StorageStats> storageSta
                         && (_storageStats.get(storeId).getCapacityBytes() == 0l
                         || _storageStats.get(storeId).getCapacityBytes() != storageStats.get(storeId).getCapacityBytes())) {
                         // get add to DB rigorously
-                        _storageManager.updateImageStoreStatus(storeId, null, null, storageStats.get(storeId).getCapacityBytes());
+                        _storageManager.updateImageStoreStatus(storeId, null, null, storageStats.get(storeId).getCapacityBytes(), null);
                 }
             }
             // if in _storageStats and not in storageStats it gets discarded
diff --git a/server/src/main/java/com/cloud/storage/StorageManagerImpl.java b/server/src/main/java/com/cloud/storage/StorageManagerImpl.java
index 7c501c78beeb..fd4fe7af668f 100644
--- a/server/src/main/java/com/cloud/storage/StorageManagerImpl.java
+++ b/server/src/main/java/com/cloud/storage/StorageManagerImpl.java
@@ -1285,6 +1285,10 @@ public PrimaryDataStoreInfo updateStoragePool(UpdateStoragePoolCmd cmd) throws I
             changes = true;
         }
 
+        if (cmd.getUrl() != null) {
+            changes = true;
+        }
+
         if (changes) {
             StoragePoolVO storagePool = _storagePoolDao.findById(id);
             DataStoreProvider dataStoreProvider = _dataStoreProviderMgr.getDataStoreProvider(storagePool.getStorageProviderName());
@@ -1301,15 +1305,100 @@ public PrimaryDataStoreInfo updateStoragePool(UpdateStoragePoolCmd cmd) throws I
                 }
                 if (cmd.getUrl() != null) {
                     details.put("url", cmd.getUrl());
+
+                    // Updating host/path/port and propagating the remount to agents is only
+                    // supported for NFS and Gluster pools. For other types of storage pools, the URL is just informational and won't be used for actual connection, so we don't need to parse and propagate it.
+                    StoragePoolType poolType = storagePool.getPoolType();
+                    if (poolType == StoragePoolType.NetworkFilesystem || poolType == StoragePoolType.Gluster) {
+                        if (!storagePool.isInMaintenance()) {
+                            throw new InvalidParameterValueException("Storage pool must be in Maintenance state before its URL can be changed. " +
+                                    "Please put the pool into maintenance first.");
+                        }
+                        Map<String, String> newUriParams = extractUriParamsAsMap(cmd.getUrl());
+                        String newHost = newUriParams.get("host");
+                        String newPath = newUriParams.get("hostPath");
+                        if (StringUtils.isAnyBlank(newHost, newPath)) {
+                            throw new InvalidParameterValueException("Invalid URL: host and path must not be empty. " +
+                                    "Expected format: nfs://hostname/path or gluster://hostname/volume");
+                        }
+                        storagePool.setHostAddress(newHost);
+                        storagePool.setPath(newPath);
+                        String newPortStr = newUriParams.get("port");
+                        storagePool.setPort(newPortStr != null ? Integer.parseInt(newPortStr) : 0);
+                    }
                 }
                 _storagePoolDao.update(id, storagePool);
                 _storagePoolDao.updateDetails(id, details);
+                ((PrimaryDataStoreLifeCycle) dataStoreLifeCycle).updateStoragePool(storagePool, details);
+                StoragePoolType poolType = storagePool.getPoolType();
+                if (cmd.getUrl() != null &&
+                        (poolType == StoragePoolType.NetworkFilesystem || poolType == StoragePoolType.Gluster)) {
+                    propagateStoragePoolUrlChangeToHosts(storagePool);
+                }
             }
         }
 
         return (PrimaryDataStoreInfo)_dataStoreMgr.getDataStore(pool.getId(), DataStoreRole.Primary);
     }
 
+    /**
+     * Propagates a storage pool URL change to all currently connected hosts by sending
+     * a {@link ModifyStoragePoolCommand} with the updated connection details.
+     * This is called after the pool URL has been persisted to the DB while the pool is
+     * in Maintenance state (so no VMs are actively using it).
+     *
+     * @param updatedPool the {@link StoragePoolVO} whose hostAddress/path/port have already been updated
+     */
+    private void propagateStoragePoolUrlChangeToHosts(StoragePoolVO updatedPool) {
+        List<Long> poolIds = List.of(updatedPool.getId());
+        List<Long> connectedHostIds = _storagePoolHostDao.findHostsConnectedToPools(poolIds);
+        if (connectedHostIds.isEmpty()) {
+            logger.debug("No connected hosts found for storage pool [{}]; nothing to propagate for URL change.", updatedPool.getName());
+            return;
+        }
+
+        // Fetch fresh DataStore so that StoragePool delegates (getHostAddress, getPath, getPort)
+        // return the newly saved values.
+        StoragePool freshPool = (StoragePool) _dataStoreMgr.getDataStore(updatedPool.getId(), DataStoreRole.Primary);
+
+        Pair<Map<String, String>, Boolean> nfsMountOpts = getStoragePoolNFSMountOpts(freshPool, null);
+        Map<String, String> mountDetails = nfsMountOpts != null ? nfsMountOpts.first() : new java.util.HashMap<>();
+
+        logger.info("Propagating new URL for storage pool [{}] to {} connected host(s).", updatedPool.getName(), connectedHostIds.size());
+
+        List<String> failedHosts = new ArrayList<>();
+        for (Long hostId : connectedHostIds) {
+            HostVO host = _hostDao.findById(hostId);
+            if (host == null) {
+                logger.warn("Host [{}] not found; skipping URL propagation for pool [{}].", hostId, updatedPool.getName());
+                failedHosts.add("unknown-host-" + hostId);
+                continue;
+            }
+
+            ModifyStoragePoolCommand cmd = new ModifyStoragePoolCommand(true, freshPool, mountDetails);
+            Answer answer = _agentMgr.easySend(hostId, cmd);
+
+            if (answer == null || !answer.getResult()) {
+                String detail = (answer == null) ? "no answer returned" : answer.getDetails();
+                logger.warn("Failed to propagate new URL for storage pool [{}] to host [{}]: {}",
+                        updatedPool.getName(), host.getName(), detail);
+                failedHosts.add(host.getName());
+            } else {
+                logger.info("Successfully propagated new URL for storage pool [{}] to host [{}].",
+                        updatedPool.getName(), host.getName());
+                updateStoragePoolHostVOAndBytes(freshPool, hostId, (ModifyStoragePoolAnswer) answer);
+            }
+        }
+
+        if (!failedHosts.isEmpty()) {
+            throw new CloudRuntimeException(String.format(
+                    "Storage pool [%s] URL was updated in the database, but the new mount could not be applied " +
+                    "on the following host(s): %s. The pool may be in an inconsistent state; please verify " +
+                    "connectivity and remount manually if necessary.",
+                    updatedPool.getName(), String.join(", ", failedHosts)));
+        }
+    }
+
     private void changeStoragePoolScopeToZone(StoragePoolVO primaryStorage) {
         /*
          * For cluster wide primary storage the hypervisor type might not be set.
@@ -4129,18 +4218,29 @@ public ImageStore migrateToObjectStore(String name, String url, String providerN
 
     @Override
     public ImageStore updateImageStore(UpdateImageStoreCmd cmd) {
-        return updateImageStoreStatus(cmd.getId(), cmd.getName(), cmd.getReadonly(), cmd.getCapacityBytes());
+        return updateImageStoreStatus(cmd.getId(), cmd.getName(), cmd.getReadonly(), cmd.getCapacityBytes(), cmd.getUrl());
     }
 
     @Override
     @ActionEvent(eventType = EventTypes.EVENT_UPDATE_IMAGE_STORE_ACCESS_STATE,
             eventDescription = "image store access updated")
-    public ImageStore updateImageStoreStatus(Long id, String name, Boolean readonly, Long capacityBytes) {
+    public ImageStore updateImageStoreStatus(Long id, String name, Boolean readonly, Long capacityBytes, String url) {
         // Input validation
         ImageStoreVO imageStoreVO = _imageStoreDao.findById(id);
         if (imageStoreVO == null) {
             throw new IllegalArgumentException("Unable to find image store with ID: " + id);
         }
+        if (url != null) {
+            boolean willBeReadonly = (readonly != null && readonly) || imageStoreVO.isReadonly();
+            if (!willBeReadonly) {
+                throw new InvalidParameterValueException("Image store must be set to read-only (maintenance) state before its URL can be changed. " +
+                        "Please set readOnly=true on the image store first.");
+            }
+
+            String existingProtocol = imageStoreVO.getProtocol();
+            validateUrl(url, existingProtocol);
+            imageStoreVO.setUrl(url);
+        }
         if (com.cloud.utils.StringUtils.isNotBlank(name)) {
             imageStoreVO.setName(name);
         }
@@ -4154,9 +4254,29 @@ public ImageStore updateImageStoreStatus(Long id, String name, Boolean readonly,
         return imageStoreVO;
     }
 
+    private void validateUrl(String url, String existingProtocol) {
+        try {
+            UriUtils.UriInfo newUriInfo = UriUtils.getUriInfo(url);
+            String newScheme = newUriInfo.getScheme();
+            String newHost = newUriInfo.getStorageHost();
+            String newPath = newUriInfo.getStoragePath();
+            if (StringUtils.isAnyBlank(newScheme, newHost, newPath)) {
+                throw new InvalidParameterValueException("Invalid image store URL: scheme, host and path must not be empty.");
+            }
+
+            if (existingProtocol != null && !existingProtocol.equalsIgnoreCase(newScheme)) {
+                throw new InvalidParameterValueException(String.format(
+                        "URL scheme '%s' does not match the image store's existing protocol '%s'.",
+                        newScheme, existingProtocol));
+            }
+        } catch (CloudRuntimeException e) {
+            throw new InvalidParameterValueException("Invalid image store URL: " + e.getMessage());
+        }
+    }
+
     @Override
     public ImageStore updateImageStoreStatus(Long id, Boolean readonly) {
-        return updateImageStoreStatus(id, null, readonly, null);
+        return updateImageStoreStatus(id, null, readonly, null, null);
     }
 
     /**
diff --git a/server/src/test/java/com/cloud/storage/StorageManagerImplTest.java b/server/src/test/java/com/cloud/storage/StorageManagerImplTest.java
index 8f88800d549f..be65675be476 100644
--- a/server/src/test/java/com/cloud/storage/StorageManagerImplTest.java
+++ b/server/src/test/java/com/cloud/storage/StorageManagerImplTest.java
@@ -30,6 +30,8 @@
 import com.cloud.host.dao.HostDao;
 import com.cloud.resource.ResourceManager;
 import com.cloud.storage.dao.StoragePoolAndAccessGroupMapDao;
+import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
+import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
 import org.apache.cloudstack.api.ApiConstants;
 import org.apache.cloudstack.api.command.admin.storage.ChangeStoragePoolScopeCmd;
 import org.apache.cloudstack.api.command.admin.storage.ConfigureStorageAccessCmd;
@@ -170,6 +172,9 @@ public class StorageManagerImplTest {
     @Mock
     DataStoreManager dataStoreMgr;
 
+    @Mock
+    ImageStoreDao imageStoreDao;
+
     @Test
     public void createLocalStoragePoolName() {
         String hostMockName = "host1";
@@ -1716,4 +1721,69 @@ public void testDiscoverObjectStoreInitializationFailure() {
 
         storageManagerImpl.discoverObjectStore(name, url, size, providerName, details);
     }
+
+    private ImageStoreVO mockImageStoreVO(String protocol, boolean readonly) {
+        ImageStoreVO vo = Mockito.mock(ImageStoreVO.class);
+        Mockito.when(vo.getProtocol()).thenReturn(protocol);
+        Mockito.when(vo.isReadonly()).thenReturn(readonly);
+        return vo;
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testUpdateImageStoreStatus_rejectsUrlChangeWhenNotReadonly() {
+        long storeId = 1L;
+        ImageStoreVO vo = mockImageStoreVO("nfs", false);
+        Mockito.when(imageStoreDao.findById(storeId)).thenReturn(vo);
+
+        storageManagerImpl.updateImageStoreStatus(storeId, null, null, null, "nfs://newhost/newpath");
+    }
+
+    @Test
+    public void testUpdateImageStoreStatus_allowsUrlChangeWhenAlreadyReadonly() {
+        long storeId = 2L;
+        ImageStoreVO vo = mockImageStoreVO("nfs", true);
+        Mockito.when(imageStoreDao.findById(storeId)).thenReturn(vo);
+        Mockito.when(imageStoreDao.update(Mockito.eq(storeId), Mockito.any())).thenReturn(true);
+
+        ImageStore result = storageManagerImpl.updateImageStoreStatus(storeId, null, null, null, "nfs://newhost/newpath");
+
+        assertNotNull(result);
+        Mockito.verify(imageStoreDao).update(Mockito.eq(storeId), Mockito.any(ImageStoreVO.class));
+    }
+
+    @Test
+    public void testUpdateImageStoreStatus_allowsUrlChangeWhenReadonlySetInSameRequest() {
+        long storeId = 3L;
+        ImageStoreVO vo = mockImageStoreVO("nfs", false);
+        Mockito.when(imageStoreDao.findById(storeId)).thenReturn(vo);
+        Mockito.when(imageStoreDao.update(Mockito.eq(storeId), Mockito.any())).thenReturn(true);
+
+        ImageStore result = storageManagerImpl.updateImageStoreStatus(storeId, null, Boolean.TRUE, null, "nfs://newhost/newpath");
+
+        assertNotNull(result);
+        Mockito.verify(imageStoreDao).update(Mockito.eq(storeId), Mockito.any(ImageStoreVO.class));
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testUpdateImageStoreStatus_rejectsMalformedUrl() {
+        long storeId = 4L;
+        ImageStoreVO vo = mockImageStoreVO("nfs", true);
+        Mockito.when(imageStoreDao.findById(storeId)).thenReturn(vo);
+
+        storageManagerImpl.updateImageStoreStatus(storeId, null, null, null, "nfs://");
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testUpdateImageStoreStatus_rejectsMismatchedProtocol() {
+        long storeId = 5L;
+        ImageStoreVO vo = mockImageStoreVO("nfs", true);
+        Mockito.when(imageStoreDao.findById(storeId)).thenReturn(vo);
+
+        storageManagerImpl.updateImageStoreStatus(storeId, null, null, null, "http://somehost/path");
+    }
+
+    @Test(expected = InvalidParameterValueException.class)
+    public void testExtractUriParamsAsMap_rejectsMissingHostForNfs() {
+        storageManagerImpl.extractUriParamsAsMap("nfs:///just-a-path");
+    }
 }