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 7F31A1FF0DA for ; Thu, 19 Nov 2026 20:20:36 +0100 (CET) Received: from gate001.proxmox.com (localhost.localdomain [127.0.0.1]) by gate001.proxmox.com (Proxmox) with ESMTP id 9E9D9217E6; Thu, 19 Nov 2026 20:20:03 +0100 (CET) From: Thomas Lamprecht To: pve-devel@lists.proxmox.com Subject: [PATCH guest-common v5 10/41] abstract config: let the VMID reservation return the previous state Date: Thu, 19 Nov 2026 20:18:42 +0100 Message-ID: <20261119191914.2336934-11-t.lamprecht@proxmox.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20261119191914.2336934-1-t.lamprecht@proxmox.com> References: <20261119191914.2336934-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: 1795115959691 X-SPAM-LEVEL: Spam detection results: 0 AWL 0.157 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: SWBTQTWG5VPXYKHNYSH3LORFRBQHVRBZ X-Message-ID-Hash: SWBTQTWG5VPXYKHNYSH3LORFRBQHVRBZ 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: A restore has to know whether its target existed before the operation and whether it had an identity. It needs this to decide if the target keeps its identity or adopts the uid of the backup. The VMID of the target gets reserved with create_and_lock_config, which writes the config with the 'create' lock. With identities enabled, that write already assigns an identity to a target without one. So once the reservation is done, the config no longer shows what was there before. Reading the config before the reservation does not work either, as other writers can change it in between. Return the previous state from within the locked section, together with the identity that the guest has after the reservation. With identities enabled, the reservation reads the existing identity under the same lock under which it writes the config. That read also finds a config that exists but cannot be loaded. Refuse such a config. Replacing it with an empty one would drop the lock and the protection of the guest, even if the restore gets refused afterwards. Existing callers ignore the return value. Signed-off-by: Thomas Lamprecht --- changes v4 -> v5: * create_and_lock_config reads the stored identity without the nested identity lock, it holds the config lock anyway * not carrying over the R-b and T-b that Dominik gave for v4, as the code changed changes v3 -> v4: * rebase onto the independent fix before the series that lets a reservation require an existing config, with a test that a missing one is refused before anything gets written * comment and commit message: 'adopt' instead of 'take over' * commit message: plainer wording, same content changes v2 -> v3: * refuse an existing config that fails to load instead of replacing it with an empty one, which dropped its lock and protection * tests for that and for the reservation of a VMID whose config appeared after the request started (refused by an independent fix before the series) changes v1 -> v2: * rebase: the used guest ID gets registered before the state is captured * name the keys of the returned state after what they hold (previous, assigned) src/PVE/AbstractConfig.pm | 36 ++++++++- src/tests/config-identity-tests.pl | 114 ++++++++++++++++++++++++++++- 2 files changed, 146 insertions(+), 4 deletions(-) diff --git a/src/PVE/AbstractConfig.pm b/src/PVE/AbstractConfig.pm index 2f228e6..dabce7e 100644 --- a/src/PVE/AbstractConfig.pm +++ b/src/PVE/AbstractConfig.pm @@ -312,12 +312,20 @@ sub load_current_config { return $conf; } -# Reserves $vmid by writing its config with the lock $lock, 'create' by default. An existing config -# is only allowed with $allow_existing, and required if that is 'require'. +# Reserves $vmid for an operation by writing its config with the lock $lock, 'create' by default. +# An existing config is only allowed with $allow_existing, and required if that is 'require'. It +# must not be locked. With identities enabled, one that fails to load is refused as well. +# +# Returns the state of the guest identity around the write, captured under the guest config lock, +# as the write can assign an identity to a config without one. Adopting a uid later needs it. +# existed - whether a config existed before +# previous - the guest identity of that config, undef if it had none or did not exist +# assigned - the guest identity of the config after the write, undef with identities +# disabled sub create_and_lock_config { my ($class, $vmid, $allow_existing, $lock) = @_; - $class->lock_config_full( + return $class->lock_config_full( $vmid, 5, sub { @@ -331,10 +339,32 @@ sub create_and_lock_config { die $class->guest_type() . " $vmid already exists\n" if defined($conf) && !$allow_existing; die $load_err if !defined($conf) && ($allow_existing // '') eq 'require'; + my $existed = defined($conf); + my $previous = $existed ? $class->get_identity($conf) : undef; + $conf //= {}; $class->check_lock($conf); $conf->{lock} = $lock // 'create'; + + if ($class->__identity_enabled()) { + # use what the write itself sees as stored, see write_config + my $stored = $class->__identity_read_stored($vmid); + # this also finds a config that failed to load, replacing it with an empty one + # would drop its lock and protection + if ($stored) { + die $class->guest_type() . " $vmid already exists\n" if !$allow_existing; + die $load_err if !$existed; + } + $existed = defined($stored); + $previous = $stored ? $stored->{identity} : undef; + } $class->write_config($vmid, $conf); + + return { + existed => $existed ? 1 : 0, + previous => $previous, + assigned => $class->__identity_enabled() ? $class->get_identity($conf) : undef, + }; }, ); } diff --git a/src/tests/config-identity-tests.pl b/src/tests/config-identity-tests.pl index 048328a..4a07ea7 100755 --- a/src/tests/config-identity-tests.pl +++ b/src/tests/config-identity-tests.pl @@ -136,6 +136,12 @@ $cluster_module->redefine( $versions->{$path} = ++$version_counter; $cache->{$path}->{version} = undef if $cache->{$path}; }, + check_vmid_unused => sub { + my ($vmid, $noerr) = @_; + return 1 if !grep { defined($files->{$_}) && vmid_of_path($_) == $vmid } keys %$files; + return undef if $noerr; + die "guest $vmid already exists\n"; + }, get_config => sub { my ($path) = @_; die $get_config_error if $get_config_error; @@ -149,7 +155,7 @@ $cluster_module->redefine( my $uid_counter = 0; my $now = 1_700_000_000_000; -# recording used guest IDs needs the cluster filesystem and is not what gets tested here +# recording used guest IDs needs the cluster filesystem, only one subtest fakes the list of them my $guest_id_module = Test::MockModule->new('PVE::GuestID'); $guest_id_module->redefine(register_used_id => sub { }); @@ -349,4 +355,110 @@ subtest 'snapshot rollback' => sub { ); }; +subtest 'create and lock config' => sub { + my $class = 'PVE::TestConfig'; + + my $state = $class->create_and_lock_config(150); + my $reserved = identity_of($class, 150); + ok($reserved, 'free VMID: reservation gets an identity'); + is_deeply( + $state, + { existed => 0, previous => undef, assigned => $reserved }, + 'free VMID: no previous identity', + ); + is(conf_of($class, 150)->{lock}, 'create', 'free VMID: reserved'); + + eval { $class->create_and_lock_config(150) }; + like($@, qr/already exists/, 'existing config is refused by default'); + + $class->write_config(151, { name => 'target', meta => 'ctime=1' }); + my $stored = identity_of($class, 151); + $now += 1000; + $state = $class->create_and_lock_config(151, 1, 'restore'); + is_deeply( + $state, + { existed => 1, previous => $stored, assigned => $stored }, + 'in place: previous identity', + ); + my $conf = conf_of($class, 151); + is($conf->{lock}, 'restore', 'in place: locked'); + is($conf->{name}, 'target', 'in place: config is kept'); + is_deeply(identity_of($class, 151), $stored, 'in place: identity is kept'); + + eval { $class->create_and_lock_config(151, 1) }; + like($@, qr/^VM is locked \(restore\)/, 'locked config is refused'); + + eval { $class->create_and_lock_config(159, 'require') }; + like($@, qr/^Configuration file '.*' does not exist/, + 'required config is missing: refused'); + ok(!defined(file_of($class, 159)), 'required config is missing: nothing is written'); + + set_file($class, 152, "meta: ctime=1\nname: old\n"); + $state = $class->create_and_lock_config(152, 1); + is_deeply( + $state, + { existed => 1, previous => undef, assigned => identity_of($class, 152) }, + 'in place without identity: reservation gets one', + ); + ok($state->{assigned}, 'in place without identity: reserved identity'); + + set_file($class, 157, ''); + $state = $class->create_and_lock_config(157, 1); + is_deeply( + $state, + { existed => 1, previous => undef, assigned => identity_of($class, 157) }, + 'in place with empty config: reservation gets an identity', + ); + ok($state->{assigned}, 'in place with empty config: reserved identity'); + + my $unloadable = "lock: backup\nmeta: rtime=5,uid=$foreign_uid\nname: old\n!unparsable\n"; + set_file($class, 156, $unloadable); + eval { $class->create_and_lock_config(156, 1) }; + like($@, qr/^test error: unable to parse/, 'in place, config fails to load: refused'); + is(file_of($class, 156), $unloadable, 'in place, config fails to load: file is unchanged'); + + # the guest list of the process can predate a config created since + my $check_vmid_unused = PVE::Cluster->can('check_vmid_unused'); + $cluster_module->redefine(check_vmid_unused => sub { return 1; }); + for my $raw ("name: other\n", $unloadable) { + set_file($class, 158, $raw); + eval { $class->create_and_lock_config(158) }; + is($@, "VM 158 already exists\n", 'outdated guest list: existing config is refused'); + is(file_of($class, 158), $raw, 'outdated guest list: file is unchanged'); + } + $cluster_module->redefine(check_vmid_unused => $check_vmid_unused); + + # clone: the target's first write must not store the source's identity + $state = $class->create_and_lock_config(153); + $conf = conf_of($class, 151); + delete $conf->{lock}; + $class->write_config(153, $conf); + is_deeply(identity_of($class, 153), $state->{assigned}, + 'clone keeps the reserved identity'); + like(file_of($class, 153), qr/^meta: ctime=1,/m, 'clone keeps other members of the source'); + + $class = 'PVE::TestConfig::NoIdentity'; + + $state = $class->create_and_lock_config(154); + is_deeply( + $state, + { existed => 0, previous => undef, assigned => undef }, + 'disabled, free VMID: no previous identity', + ); + is(file_of($class, 154), "lock: create\n", 'disabled, free VMID: no identity assigned'); + + set_file($class, 155, "meta: ctime=1,rtime=5,uid=$foreign_uid\nname: old\n"); + $state = $class->create_and_lock_config(155, 1); + is_deeply( + $state, + { existed => 1, previous => { uid => $foreign_uid, rtime => 5 }, assigned => undef }, + 'disabled, in place: identity from the config', + ); + is( + file_of($class, 155), + "lock: create\nmeta: ctime=1,rtime=5,uid=$foreign_uid\nname: old\n", + 'disabled, in place: config is kept', + ); +}; + done_testing(); -- 2.47.3