From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from gate001.proxmox.com (gate001.proxmox.com [IPv6:2a0f:8001:1:32::40]) by lore.proxmox.com (Postfix) with ESMTPS id 0EB911FF0AA for ; Tue, 17 Nov 2026 23:41:36 +0100 (CET) Received: from gate001.proxmox.com (localhost.localdomain [127.0.0.1]) by gate001.proxmox.com (Proxmox) with ESMTP id 13F68216EF; Tue, 17 Nov 2026 23:40:48 +0100 (CET) From: Thomas Lamprecht To: pve-devel@lists.proxmox.com Subject: [PATCH qemu-server v2 13/36] api: migrate, clone: refuse targets that would drop the guest identity Date: Tue, 17 Nov 2026 23:34:23 +0100 Message-ID: <20261117223945.862914-14-t.lamprecht@proxmox.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20261117223945.862914-1-t.lamprecht@proxmox.com> References: <20261117223945.862914-1-t.lamprecht@proxmox.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Bm-Milter-Handled: 55990f41-d878-4baa-be0a-ee34c49e34d2 X-Bm-Transport-Timestamp: 1794955191445 X-SPAM-LEVEL: Spam detection results: 0 AWL 0.199 Adjusted score from AWL reputation of From: address DMARC_MISSING 0.1 Missing DMARC policy KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment (newer systems) RCVD_IN_DNSWL_MED -2.3 Sender listed at https://www.dnswl.org/, medium trust SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_PASS -0.001 SPF: sender matches SPF record Message-ID-Hash: OF6NZTVPKGVXC442AUCR6XBSUENAO2IX X-Message-ID-Hash: OF6NZTVPKGVXC442AUCR6XBSUENAO2IX X-MailFrom: t.lamprecht@proxmox.com X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; loop; banned-address; emergency; member-moderation; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header X-Mailman-Version: 3.3.10 Precedence: list List-Id: Proxmox VE development discussion List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: Older qemu-server versions reject the identity members of 'meta' and drop the whole property when they write the config. A guest that moves to such a node loses its identity, and gets a new one with a later write by an upgraded node. Refuse online and offline migrations and clones to another node unless the target reports a Proxmox VE version that keeps the identity. Use the shared version threshold and treat missing version information as too old. Report the reason and the versions involved in the migration preconditions, so that clients can explain the refusal. Leave such nodes out of the nodes reported for the clone feature, which the web interface uses to validate the target of a clone. Check before starting the task or handing an API migration request to HA. This does not keep an HA resource plugin from shutting down a VM for a relocation before it calls the migration API. Signed-off-by: Thomas Lamprecht --- changes v1 -> v2: * leave such nodes out of the nodes of the clone feature, which the clone dialog uses * use the shared schema for the precondition result src/PVE/API2/Qemu.pm | 24 +++++- src/test/run_api_tests.pl | 152 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 175 insertions(+), 1 deletion(-) diff --git a/src/PVE/API2/Qemu.pm b/src/PVE/API2/Qemu.pm index be0928ea..219e36c6 100644 --- a/src/PVE/API2/Qemu.pm +++ b/src/PVE/API2/Qemu.pm @@ -28,6 +28,7 @@ use PVE::RESTHandler; use PVE::ReplicationConfig; use PVE::GuestHelpers qw(assert_tag_permissions); use PVE::GuestID; +use PVE::GuestIdentity; use PVE::GuestImport; use PVE::QemuConfig; use PVE::QemuServer; @@ -4376,6 +4377,8 @@ __PACKAGE__->register_method({ properties => { hasFeature => { type => 'boolean' }, nodes => { + description => "Nodes that can be the target of a clone: the storages of the VM" + . " are available there and the node keeps the guest identity.", type => 'array', items => { type => 'string' }, }, @@ -4404,6 +4407,12 @@ __PACKAGE__->register_method({ my $storecfg = PVE::Storage::config(); my $nodelist = PVE::QemuServer::shared_nodes($conf, $storecfg); + # a clone to another node is refused if that node would drop the guest identity + my $nodename = PVE::INotify::nodename(); + for my $other (keys $nodelist->%*) { + next if $other eq $nodename; + delete $nodelist->{$other} if PVE::GuestIdentity::node_identity_unsupported($other); + } my $hasFeature = PVE::QemuConfig->has_feature($feature, $conf, $storecfg, $snapname, $running); @@ -4536,7 +4545,10 @@ __PACKAGE__->register_method({ my $load_and_check = sub { $rpcenv->check_pool_exist($pool) if defined($pool); - PVE::Cluster::check_node_exists($target) if $target; + if ($target) { + PVE::Cluster::check_node_exists($target); + PVE::GuestIdentity::assert_node_supports_identity($target); + } my $storecfg = PVE::Storage::config(); @@ -5413,6 +5425,8 @@ __PACKAGE__->register_method({ }, }, }, + 'guest-identity-unsupported' => + PVE::GuestIdentity::node_identity_unsupported_schema(), }, description => "List of not allowed nodes with additional information.", }, @@ -5554,6 +5568,12 @@ __PACKAGE__->register_method({ $blocking_ha_resources; } + # the migration refuses nodes that would drop the guest identity + if (my $unsupported = PVE::GuestIdentity::node_identity_unsupported($node)) { + $res->{not_allowed_nodes}->{$node}->{'guest-identity-unsupported'} = + $unsupported; + } + # if nothing came up, add it to the allowed nodes if (scalar($res->{not_allowed_nodes}->{$node}->%*) == 0) { push $res->{allowed_nodes}->@*, $node; @@ -5666,6 +5686,8 @@ __PACKAGE__->register_method({ PVE::Cluster::check_node_exists($target); + PVE::GuestIdentity::assert_node_supports_identity($target); + my $targetip = PVE::Cluster::remote_node_ip($target); my $vmid = extract_param($param, 'vmid'); diff --git a/src/test/run_api_tests.pl b/src/test/run_api_tests.pl index 4d5e1cdf..9bb227c7 100755 --- a/src/test/run_api_tests.pl +++ b/src/test/run_api_tests.pl @@ -13,6 +13,7 @@ use Test::MockModule; use Test::More; use PVE::API2::Qemu; +use PVE::GuestIdentity; use PVE::RPCEnvironment; my $rpcenv = PVE::RPCEnvironment->init('cli'); @@ -38,6 +39,31 @@ sub mock_unreachable_config { } mock_unreachable_config(); +my $qemu_server_module = Test::MockModule->new('PVE::QemuServer'); +$qemu_server_module->mock(check_running => sub { return 0; }); + +# Proxmox VE versions the cluster nodes report, undef for none +my $node_versions = {}; + +my $cluster_module = Test::MockModule->new('PVE::Cluster'); +$cluster_module->mock( + check_cfs_quorum => sub { return 1; }, + check_node_exists => sub { return 1; }, + remote_node_ip => sub { return '192.0.2.2'; }, + get_node_pvecfg_version => sub { + my ($node) = @_; + return $node_versions->{$node}; + }, + node_pvecfg_version_at_least => sub { + my ($node, @required) = @_; + my @version = split(/\./, $node_versions->{$node} // return 0); + for my $i (0 .. 2) { + return $version[$i] > $required[$i] if $version[$i] != $required[$i]; + } + return 1; + }, +); + # Returns the error of calling the API method $method with $param, either the parameter errors as # hash or the error message. sub api_error { @@ -145,4 +171,130 @@ subtest 'pending changes of meta are dropped' => sub { mock_unreachable_config(); }; +my $min_version = PVE::GuestIdentity::MIN_PVE_MANAGER_VERSION; +my $node_cases = [ + [$min_version, "reached load_config\n"], + ['10.0.0', "reached load_config\n"], + [ + '9.2.0', + "node 'pve2' runs Proxmox VE 9.2.0, keeping the guest identity requires $min_version or" + . " newer - upgrade the node first\n", + ], + [ + undef, + "node 'pve2' does not report its Proxmox VE version, so it is unknown whether the node" + . " keeps the guest identity\n", + ], +]; + +for my $case ($node_cases->@*) { + my ($version, $expected) = $case->@*; + $node_versions->{pve2} = $version; + my $what = 'target node with ' . ($version // 'no') . ' version'; + + is( + api_error('migrate_vm', { target => 'pve2' }), $expected, "migrate_vm: offline, $what", + ); + is( + api_error('migrate_vm', { target => 'pve2', online => 1 }), + $expected, + "migrate_vm: online, $what", + ); + is( + api_error('clone_vm', { newid => 101, target => 'pve2' }), $expected, "clone_vm: $what", + ); +} + +$node_versions->{pve2} = undef; +is( + api_error('clone_vm', { newid => 101 }), + "reached load_config\n", + 'clone_vm: no check without target node', +); + +subtest 'migration preconditions' => sub { + my $nodes = ['localhost', 'pve2', 'pve3', 'pve4']; + $cluster_module->mock(get_nodelist => sub { return $nodes; }); + my $inotify_module = Test::MockModule->new('PVE::INotify'); + $inotify_module->mock(nodename => sub { return 'localhost'; }); + + $qemu_config_module->mock(load_config => sub { return { memory => 512 }; }); + my $migrate_helpers_module = Test::MockModule->new('PVE::QemuMigrate::Helpers'); + $migrate_helpers_module->mock( + check_local_resources => sub { + return ([], {}, { map { $_ => [] } $nodes->@* }); + }, + ); + my $ha_config_module = Test::MockModule->new('PVE::HA::Config'); + $ha_config_module->mock(vm_is_ha_managed => sub { return 0; }); + + $node_versions->@{ 'pve2', 'pve3', 'pve4' } = ($min_version, '9.2.0', undef); + + my $res = PVE::API2::Qemu->migrate_vm_precondition({ node => 'localhost', vmid => 100 }); + + is_deeply($res->{allowed_nodes}, ['pve2'], 'only the node keeping the identity is allowed'); + is_deeply( + $res->{not_allowed_nodes}->{pve3}, + { + 'guest-identity-unsupported' => { + version => '9.2.0', + 'required-version' => $min_version, + }, + }, + 'node with an older version is not allowed', + ); + is_deeply( + $res->{not_allowed_nodes}->{pve4}, + { 'guest-identity-unsupported' => { 'required-version' => $min_version } }, + 'node without version is not allowed', + ); + + my $returns = PVE::API2::Qemu->map_method_by_name('migrate_vm_precondition')->{returns}; + eval { PVE::JSONSchema::validate($res, $returns) }; + is($@, '', 'result matches the schema'); + # the schema documents the reasons of a node as the properties of 'not_allowed_nodes' + my $reasons_schema = + { $returns->{properties}->{not_allowed_nodes}->%*, additionalProperties => 0 }; + for my $node ('pve3', 'pve4') { + eval { PVE::JSONSchema::validate($res->{not_allowed_nodes}->{$node}, $reasons_schema) }; + is($@, '', "reason for $node is documented in the schema"); + } + + $cluster_module->unmock('get_nodelist'); + mock_unreachable_config(); +}; + +subtest 'clone target nodes' => sub { + my $inotify_module = Test::MockModule->new('PVE::INotify'); + $inotify_module->mock(nodename => sub { return 'pve1'; }); + + $qemu_config_module->mock( + load_config => sub { return { memory => 512 }; }, + has_feature => sub { return 1; }, + ); + $qemu_server_module->mock( + shared_nodes => sub { + return { map { $_ => 1 } 'pve1', 'pve2', 'pve3', 'pve4' }; + }, + ); + + # the version of the local node does not matter, a clone on the same node needs no check + $node_versions->@{ 'pve1', 'pve2', 'pve3', 'pve4' } = (undef, $min_version, '9.2.0', undef); + + # the local node is the one the handler runs on, whatever name the API path used for it + for my $node ('pve1', 'localhost') { + my $res = + PVE::API2::Qemu->vm_feature({ node => $node, vmid => 100, feature => 'clone' }); + is_deeply( + [sort $res->{nodes}->@*], + ['pve1', 'pve2'], + "node '$node': only nodes that keep the identity are offered as clone target", + ); + } + + $qemu_server_module->unmock('shared_nodes'); + $qemu_config_module->unmock('has_feature'); + mock_unreachable_config(); +}; + done_testing(); -- 2.47.3