From: Thomas Lamprecht <t.lamprecht@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [PATCH guest-common v3 10/38] abstract config: assign a guest identity and keep it on config writes
Date: Wed, 18 Nov 2026 05:37:22 +0100 [thread overview]
Message-ID: <20261118043817.1659212-11-t.lamprecht@proxmox.com> (raw)
In-Reply-To: <20261118043817.1659212-1-t.lamprecht@proxmox.com>
With identities enabled for a guest type, every config write keeps the
identity that the guest already has, regardless of the identity in the
written config, and assigns a new one if the guest has none. This covers
both new guests and guests from older versions, and operations need no
identity handling of their own. A stale config, a config copied from a
clone source, or a snapshot rollback can neither change nor duplicate an
identity that way. Taking over the uid of a backup needs a separate
check that no other guest in the cluster uses it.
Read the existing identity directly from the cluster filesystem, as the
parsed config in the cache can be outdated. A read error aborts the
write. This relies on the IPC client of pve-cluster reporting a failed
connection as an error, and not as a missing or empty file.
Some writers, including the container post-stop hook, do not hold the
guest config lock. Read the identity and write the config under a short
local lock, so that concurrent writers cannot assign different
identities.
Guest types have to enable this explicitly: older qemu-server versions
validate 'meta' strictly on writes and would reject a config with the
identity members.
Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
---
changes v2 -> v3:
* commit message wording only
changes v1 -> v2:
* rebase onto the tracking of used guest IDs
* drop the override hooks and test seams that nothing used
* drop the cross-check of the config read against the mounted
filesystem, the IPC client now reports a failed connection
(pve-cluster commit e31fe10)
* say why there is a separate lock and a direct read (Dominik)
* use explicit conditionals instead of '$x && $x->{y}' (Dominik)
src/PVE/AbstractConfig.pm | 81 +++++-
src/tests/Makefile | 7 +-
src/tests/config-identity-tests.pl | 383 +++++++++++++++++++++++++++++
3 files changed, 468 insertions(+), 3 deletions(-)
create mode 100755 src/tests/config-identity-tests.pl
diff --git a/src/PVE/AbstractConfig.pm b/src/PVE/AbstractConfig.pm
index 78e384b..302994e 100644
--- a/src/PVE/AbstractConfig.pm
+++ b/src/PVE/AbstractConfig.pm
@@ -11,6 +11,7 @@ use PVE::Tools qw(lock_file lock_file_full);
use PVE::GuestHelpers qw(typesafe_ne);
use PVE::GuestID;
+use PVE::GuestIdentity;
use PVE::ReplicationConfig;
use PVE::Replication;
@@ -62,13 +63,91 @@ sub load_config {
return $conf;
}
+# Guest identity, see PVE::GuestIdentity
+
+# Whether writing a config keeps the stored guest identity, or assigns one if there is none,
+# see write_config. Only enable it for a guest type whose config format accepts the identity
+# members, as a strict parser would otherwise reject every written config.
+sub __identity_enabled {
+ my ($class) = @_;
+
+ return 0;
+}
+
+# Returns the guest identity contained in the parsed config $conf, for example of a backup, undef
+# if there is none.
+sub get_identity {
+ my ($class, $conf) = @_;
+
+ return PVE::GuestIdentity::parse_identity($conf->{meta});
+}
+
+# Runs $code with the local identity lock of $vmid held and returns its result. Every config write
+# takes it while it reads the existing identity and writes the config. The guest config lock
+# cannot do that job, as some writers do not hold it and cannot take it either: the post-stop hook
+# of a container writes the config while the task that stops the container holds that lock. Never
+# take another lock while holding the identity lock.
+sub __identity_lock {
+ my ($class, $vmid, $code, @param) = @_;
+
+ my $lockdir = $PVE::GuestHelpers::lockdir;
+ mkdir $lockdir;
+
+ my $res = lock_file("$lockdir/pve-guest-identity-$vmid", 10, $code, @param);
+ die $@ if $@;
+
+ return $res;
+}
+
+# Returns undef if no config file exists for $vmid on this node. Otherwise returns a hash whose
+# 'identity' member is the identity stored in the top-level section of the file, or undef if it
+# has none, as for an empty file. Dies on other read errors, like a failed connection to pmxcfs.
+#
+# Reads the file directly and not the parsed config from the file cache. A process only sees the
+# config writes of other processes after PVE::Cluster::cfs_update(), and some writers, like the
+# post-stop hook of a container, write a config that they loaded a while ago.
+sub __identity_read_stored {
+ my ($class, $vmid) = @_;
+
+ my $raw = PVE::Cluster::get_config($class->cfs_config_path($vmid));
+ return undef if !defined($raw);
+
+ return { identity => PVE::GuestIdentity::parse_identity_from_raw_config($raw) };
+}
+
# Generate and write config file for this VM/CT
+#
+# With guest identities enabled for the class, the identity stored in the existing config file
+# gets set in $conf, whatever $conf contains, or a new one if none is stored. So a config write
+# never changes a stored identity.
sub write_config {
my ($class, $vmid, $conf) = @_;
my $cfspath = $class->cfs_config_path($vmid);
- PVE::Cluster::cfs_write_file($cfspath, $conf);
+ if (!$class->__identity_enabled()) {
+ PVE::Cluster::cfs_write_file($cfspath, $conf);
+ return;
+ }
+
+ $class->__identity_lock(
+ $vmid,
+ sub {
+ my $stored = $class->__identity_read_stored($vmid);
+ my $identity = $stored ? $stored->{identity} : undef;
+
+ # a stored uid without valid rtime can only come from a manual edit
+ if (!$identity || !defined($identity->{rtime})) {
+ $identity =
+ PVE::GuestIdentity::new_identity($identity ? $identity->{uid} : undef);
+ }
+
+ $conf->{meta} = PVE::GuestIdentity::merge_identity($conf->{meta}, $identity);
+ PVE::Cluster::cfs_write_file($cfspath, $conf);
+ },
+ );
+
+ return;
}
# Pending changes related
diff --git a/src/tests/Makefile b/src/tests/Makefile
index e2c3d01..4d2036e 100644
--- a/src/tests/Makefile
+++ b/src/tests/Makefile
@@ -1,12 +1,15 @@
all:
-.PHONY: check abstract-config guest-id guest-identity hookscript
-check: abstract-config guest-id guest-identity hookscript
+.PHONY: check abstract-config config-identity guest-id guest-identity hookscript
+check: abstract-config config-identity guest-id guest-identity hookscript
abstract-config: abstract-config-tests.pl
perl -I.. ./abstract-config-tests.pl
+config-identity: config-identity-tests.pl
+ perl -I.. ./config-identity-tests.pl
+
guest-id: guest-id-tests.pl
perl -I.. ./guest-id-tests.pl
diff --git a/src/tests/config-identity-tests.pl b/src/tests/config-identity-tests.pl
new file mode 100755
index 0000000..fcec452
--- /dev/null
+++ b/src/tests/config-identity-tests.pl
@@ -0,0 +1,383 @@
+#!/usr/bin/perl
+
+use v5.36;
+
+use lib qw(..);
+
+use Fcntl qw(:flock);
+use File::Temp qw(tempdir);
+use Storable qw(dclone);
+use Test::MockModule;
+use Test::More;
+
+use PVE::AbstractConfig;
+use PVE::GuestHelpers;
+use PVE::GuestIdentity;
+
+my $tmpdir = tempdir('config-identity-XXXXXX', DIR => '.', CLEANUP => 1);
+$PVE::GuestHelpers::lockdir = "$tmpdir/lock";
+
+# guest config classes using a minimal config file format, see below
+
+package PVE::TestConfig {
+ use base qw(PVE::AbstractConfig);
+
+ sub guest_type { return 'VM'; }
+
+ sub config_file_lock($class, $vmid) {
+ return "$tmpdir/config-$vmid.lock";
+ }
+
+ sub cfs_config_path($class, $vmid, $node = undef) {
+ return "nodes/local/qemu-server/$vmid.conf";
+ }
+
+ # keeps any direct file access of the config class out of /etc/pve
+ sub config_file($class, $vmid, $node = undef) {
+ return "$tmpdir/etc-pve/" . $class->cfs_config_path($vmid, $node);
+ }
+
+ sub __identity_enabled { return 1; }
+
+ # just enough for snapshot rollbacks without volumes
+ sub valid_volume_keys { return (); }
+ sub __snapshot_check_running { return 0; }
+ sub __snapshot_rollback_vm_stop { return; }
+ sub __snapshot_rollback_get_unused { return []; }
+}
+
+package PVE::TestConfig::CT {
+ use base qw(PVE::TestConfig);
+
+ sub guest_type { return 'CT'; }
+
+ sub cfs_config_path($class, $vmid, $node = undef) {
+ return "nodes/local/lxc/$vmid.conf";
+ }
+}
+
+package PVE::TestConfig::NoIdentity {
+ use base qw(PVE::TestConfig);
+
+ sub __identity_enabled { return 0; }
+}
+
+package main;
+
+# fake cluster filesystem with raw config files, indexed by their cfs path, and a file cache that
+# behaves like the one of PVE::Cluster: it only reads a config again after a write of this process,
+# or after cfs_update noticed a newer version
+
+my $files = {};
+my $versions = {};
+my $version_counter = 0;
+my $seen_versions = {};
+my $cache = {};
+
+our $get_config_error;
+our $check_identity_lock = 1;
+
+my $reads = 0;
+my $writes = 0;
+
+sub parse_test_config($raw) {
+ my $conf = { snapshots => {} };
+ my $section = $conf;
+ for my $line (split(/\n/, $raw)) {
+ next if $line =~ m/^\s*$/;
+ if ($line =~ m/^\[([^\]]+)\]$/) {
+ $section = $conf->{snapshots}->{$1} = {};
+ } elsif ($line =~ m/^([a-z][a-z0-9_\-]*):\s*(.*?)\s*$/) {
+ $section->{$1} = $2;
+ } else {
+ die "test error: unable to parse config line '$line'\n";
+ }
+ }
+
+ return $conf;
+}
+
+sub write_test_config($conf) {
+ my $print_section = sub {
+ my ($section) = @_;
+ return join('',
+ map { "$_: $section->{$_}\n" } grep { !ref($section->{$_}) } sort keys %$section);
+ };
+
+ my $raw = $print_section->($conf);
+ for my $snapname (sort keys(($conf->{snapshots} // {})->%*)) {
+ $raw .= "\n[$snapname]\n" . $print_section->($conf->{snapshots}->{$snapname});
+ }
+
+ return $raw;
+}
+
+sub vmid_of_path($path) {
+ return $path =~ m!/(\d+)\.conf$! ? $1 : die "test error: unexpected path '$path'\n";
+}
+
+sub identity_lock_held($vmid) {
+ open(my $fh, '>>', "$PVE::GuestHelpers::lockdir/pve-guest-identity-$vmid") or return 0;
+ my $free = flock($fh, LOCK_EX | LOCK_NB);
+ close($fh);
+
+ return !$free;
+}
+
+my $cluster_module = Test::MockModule->new('PVE::Cluster');
+$cluster_module->redefine(
+ cfs_update => sub {
+ $seen_versions = { $versions->%* };
+ return;
+ },
+ cfs_read_file => sub {
+ my ($path) = @_;
+ my $version = $seen_versions->{$path};
+ my $entry = $cache->{$path};
+ if (!$entry || !$entry->{version} || !$version || $entry->{version} != $version) {
+ my $raw = $files->{$path};
+ my $data = defined($raw) ? parse_test_config($raw) : undef;
+ $entry = $cache->{$path} = { version => $version, data => $data };
+ }
+ return defined($entry->{data}) ? dclone($entry->{data}) : undef;
+ },
+ cfs_write_file => sub {
+ my ($path, $conf) = @_;
+ my $vmid = vmid_of_path($path);
+ die "test error: config of $vmid written without identity lock\n"
+ if $check_identity_lock && !identity_lock_held($vmid);
+ $writes++;
+ $files->{$path} = write_test_config($conf);
+ $versions->{$path} = ++$version_counter;
+ $cache->{$path}->{version} = undef if $cache->{$path};
+ },
+ get_config => sub {
+ my ($path) = @_;
+ my $vmid = vmid_of_path($path);
+ die "test error: config of $vmid read without identity lock\n"
+ if !identity_lock_held($vmid);
+ die $get_config_error if $get_config_error;
+ $reads++;
+ return $files->{$path};
+ },
+);
+
+# deterministic identities: uids count up, the time is set by the tests
+
+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
+my $guest_id_module = Test::MockModule->new('PVE::GuestID');
+$guest_id_module->redefine(register_used_id => sub { });
+
+my $identity_module = Test::MockModule->new('PVE::GuestIdentity');
+$identity_module->redefine(
+ # one byte per uid character, the last three count up
+ __random_bytes => sub {
+ my ($len) = @_;
+ my $n = ++$uid_counter;
+ return ("\0" x ($len - 3)) . pack('C3', map { ($n >> $_) & 31 } (10, 5, 0));
+ },
+ __time_ms => sub { return $now; },
+);
+
+my sub new_uid {
+ return PVE::GuestIdentity::new_identity()->{uid};
+}
+
+my sub file_of($class, $vmid) {
+ return $files->{ $class->cfs_config_path($vmid) };
+}
+
+my sub conf_of($class, $vmid) {
+ my $raw = file_of($class, $vmid);
+ return defined($raw) ? parse_test_config($raw) : undef;
+}
+
+my sub identity_of($class, $vmid) {
+ my $conf = conf_of($class, $vmid) or return undef;
+ return PVE::GuestIdentity::parse_identity($conf->{meta});
+}
+
+# write of another process, the file cache of this process does not notice it
+my sub set_file($class, $vmid, $raw) {
+ my $path = $class->cfs_config_path($vmid);
+ $files->{$path} = $raw;
+ $versions->{$path} = ++$version_counter;
+}
+
+my $foreign_uid = new_uid();
+
+subtest 'disabled by default' => sub {
+ ok(!PVE::AbstractConfig->__identity_enabled(), 'abstract config does not enable it');
+
+ local $check_identity_lock = 0;
+ my $class = 'PVE::TestConfig::NoIdentity';
+ my $reads_before = $reads;
+
+ my $res = [$class->write_config(100, { name => 'a' })];
+ is(file_of($class, 100), "name: a\n", 'config without identity written as is');
+ is_deeply($res, [], 'nothing is returned');
+
+ my $meta = "ctime=1,rtime=5,uid=$foreign_uid";
+ $class->write_config(100, { name => 'a', meta => $meta });
+ is(file_of($class, 100), "meta: $meta\nname: a\n", 'carried identity written as is');
+
+ is($reads, $reads_before, 'stored identity is not read');
+};
+
+subtest 'none stored' => sub {
+ my $class = 'PVE::TestConfig';
+
+ my $conf = { name => 'new' };
+ my $res = [$class->write_config(101, $conf)];
+ my $identity = identity_of($class, 101);
+ ok($identity, 'new config gets an identity');
+ is($identity->{rtime}, $now, 'rtime is the current time');
+ is_deeply($class->get_identity($conf), $identity, 'identity is set in the written hash');
+ is_deeply($res, [], 'nothing is returned');
+
+ # copied from a clone source, a snapshot, or a backup
+ $class->write_config(102, { name => 'clone', meta => "ctime=7,rtime=5,uid=$foreign_uid" });
+ $identity = identity_of($class, 102);
+ isnt($identity->{uid}, $foreign_uid, 'carried identity is not stored');
+ is($identity->{rtime}, $now, 'carried rtime is not stored');
+ like(
+ file_of($class, 102),
+ qr/^meta: ctime=7,rtime=$now,uid=[a-z2-7]{20}$/m,
+ 'other members are kept',
+ );
+
+ set_file($class, 103, "meta: ctime=1\nname: old\n");
+ $class->write_config(103, conf_of($class, 103));
+ $identity = identity_of($class, 103);
+ ok($identity, 'existing config without identity gets one');
+ like(file_of($class, 103), qr/^meta: ctime=1,rtime=$now,uid=/m, 'other members are kept');
+
+ set_file($class, 104, "name: old\n\n[snap]\nmeta: rtime=1,uid=$foreign_uid\n");
+ $class->write_config(104, conf_of($class, 104));
+ isnt(identity_of($class, 104)->{uid}, $foreign_uid, 'identity of a snapshot is ignored');
+ like(
+ file_of($class, 104),
+ qr/^\[snap\]\nmeta: rtime=1,uid=$foreign_uid$/m,
+ 'snapshot keeps its copy',
+ );
+
+ set_file($class, 105, '');
+ $class->write_config(105, { name => 'empty' });
+ ok(identity_of($class, 105), 'existing empty config gets an identity');
+};
+
+subtest 'stored identity wins' => sub {
+ my $class = 'PVE::TestConfig';
+
+ $class->write_config(110, { name => 'a', meta => 'ctime=1' });
+ my $stored = identity_of($class, 110);
+ my $stale = new_uid();
+
+ $now += 1000;
+
+ my $tests = [
+ [{ name => 'b' }, 'missing identity'],
+ [{ name => 'b', meta => 'ctime=1' }, 'missing identity members'],
+ [{ name => 'b', meta => "ctime=1,rtime=5,uid=$stale" }, 'stale identity'],
+ [{ name => 'b', meta => "ctime=1,rtime=$now,uid=$foreign_uid" }, 'foreign identity'],
+ [{ name => 'b', meta => "ctime=1,rtime=5,uid=bogus" }, 'invalid identity'],
+ [{ name => 'b', meta => "ctime=1,uid=$stored->{uid}" }, 'identity without rtime'],
+ ];
+
+ for my $test (@$tests) {
+ my ($conf, $name) = @$test;
+ my $other_members = $conf->{meta} && $conf->{meta} =~ m/ctime=1/;
+
+ $class->write_config(110, $conf);
+ is_deeply(identity_of($class, 110), $stored, "$name: stored identity is kept");
+ is_deeply($class->get_identity($conf), $stored, "$name: hash has it too");
+ like(file_of($class, 110), qr/^meta: ctime=1,/m, "$name: other members are kept")
+ if $other_members;
+ }
+
+ set_file($class, 111, "meta: ctime=1,uid=$stale\nname: old\n");
+ $class->write_config(111, conf_of($class, 111));
+ is_deeply(
+ identity_of($class, 111),
+ { uid => $stale, rtime => $now },
+ 'stored uid without rtime is kept and gets the current time',
+ );
+
+ my ($first, $last) = (new_uid(), new_uid());
+ set_file($class, 112, "meta: rtime=1,uid=$first\nname: x\nmeta: rtime=2,uid=$last\n");
+ $class->write_config(112, { name => 'y' });
+ is_deeply(
+ identity_of($class, 112),
+ { uid => $last, rtime => 2 },
+ 'last top-level meta line counts, like for the config parsers',
+ );
+};
+
+subtest 'read and write under identity lock' => sub {
+ my $class = 'PVE::TestConfig';
+
+ # the cluster filesystem mocks die without the lock, the lock is gone afterwards
+ $class->write_config(120, { name => 'a' });
+ ok(identity_of($class, 120), 'written');
+ ok(!identity_lock_held(120), 'lock is released');
+
+ $class->lock_config(120, sub { $class->write_config(120, conf_of($class, 120)) });
+ ok(!identity_lock_held(120), 'lock is released when nested in config lock');
+};
+
+subtest 'read errors are fatal' => sub {
+ my $class = 'PVE::TestConfig';
+
+ $class->write_config(130, { name => 'a' });
+ my $raw = file_of($class, 130);
+
+ {
+ local $get_config_error = "Connection refused\n";
+ eval { $class->write_config(130, { name => 'b' }) };
+ is($@, "Connection refused\n", 'write dies');
+ is(file_of($class, 130), $raw, 'config is unchanged');
+
+ eval { $class->write_config(131, { name => 'b' }) };
+ is($@, "Connection refused\n", 'write of new config dies');
+ ok(!defined(file_of($class, 131)), 'config is not written');
+ }
+};
+
+subtest 'snapshot rollback' => sub {
+ my $class = 'PVE::TestConfig';
+
+ my $storage_module = Test::MockModule->new('PVE::Storage');
+ $storage_module->redefine(config => sub { return {}; });
+ my $replication_module = Test::MockModule->new('PVE::ReplicationConfig');
+ $replication_module->redefine(
+ new => sub { return bless({}, 'PVE::ReplicationConfig'); },
+ check_for_existing_jobs => sub { return 0; },
+ );
+
+ $class->write_config(140, { name => 'current', meta => 'ctime=2' });
+ my $stored = identity_of($class, 140);
+
+ my $conf = conf_of($class, 140);
+ $conf->{snapshots}->{old} = { name => 'old', meta => "ctime=1,rtime=5,uid=$foreign_uid" };
+ $conf->{snapshots}->{none} = { name => 'none' };
+ $class->write_config(140, $conf);
+
+ $now += 1000;
+
+ for my $snapname (qw(old none)) {
+ $class->snapshot_rollback(140, $snapname);
+ $conf = conf_of($class, 140);
+ is($conf->{name}, $snapname, "rolled back to '$snapname'");
+ is_deeply(identity_of($class, 140), $stored, "'$snapname': current identity is kept");
+ }
+ is(
+ $conf->{snapshots}->{old}->{meta},
+ "ctime=1,rtime=5,uid=$foreign_uid",
+ 'snapshot is unchanged',
+ );
+};
+
+done_testing();
--
2.47.3
next prev parent reply other threads:[~2026-11-18 4:40 UTC|newest]
Thread overview: 42+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 4:37 [PATCH cluster/guest-common/qemu-server/container/manager/docs v3 00/38] fix #7846: guest identity (uid) and cluster ID Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 01/38] pmxcfs: reject changes to the cluster ID file from user space Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 02/38] pmxcfs: generate a cluster ID on standalone nodes Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 03/38] pmxcfs: dfsm: add a callback that runs once all members are in sync Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 04/38] pmxcfs: quorum: pass the corosync membership to an optional listener Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 05/38] pmxcfs: confdb: call an optional listener when the nodes get published Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 06/38] pmxcfs: dcdb: generate the cluster ID once the cluster is in sync Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 07/38] cluster: add helper to read the cluster ID Thomas Lamprecht
2026-11-18 4:37 ` [PATCH cluster v3 08/38] pmxcfs: allow removing the cluster ID file in forced local mode Thomas Lamprecht
2026-11-18 4:37 ` [PATCH guest-common v3 09/38] guest identity: add helpers for the guest uid and registration time Thomas Lamprecht
2026-11-18 4:37 ` Thomas Lamprecht [this message]
2026-11-18 4:37 ` [PATCH guest-common v3 11/38] abstract config: let the VMID reservation return the previous state Thomas Lamprecht
2026-11-18 4:37 ` [PATCH guest-common v3 12/38] guest identity: allow taking over a uid that is unused in the cluster Thomas Lamprecht
2026-11-18 4:37 ` [PATCH guest-common v3 13/38] migrate: add shared helpers for the identity command of the migration tunnel Thomas Lamprecht
2026-11-18 4:37 ` [PATCH qemu-server v3 14/38] api: restore: release the VMID if a restore to an unused VMID fails Thomas Lamprecht
2026-11-18 4:37 ` [PATCH qemu-server v3 15/38] api: migrate, clone: refuse targets that would drop the guest identity Thomas Lamprecht
2026-11-18 4:37 ` [PATCH qemu-server v3 16/38] fix #7846: config: add a guest identity to the 'meta' property Thomas Lamprecht
2026-11-18 4:37 ` [PATCH qemu-server v3 17/38] restore: take over the guest uid from the backup where possible Thomas Lamprecht
2026-11-18 4:37 ` [PATCH qemu-server v3 18/38] api: remote migration: take over the guest uid from the source Thomas Lamprecht
2026-11-18 4:37 ` [PATCH qemu-server v3 19/38] api: status: return the guest uid Thomas Lamprecht
2026-11-18 4:37 ` [PATCH qemu-server v3 20/38] tests: remote migration: check a failed command and an early tunnel end Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 21/38] config: add read-only meta property with the creation time Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 22/38] fix #7846: config: add a guest identity to the 'meta' property Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 23/38] api: migrate, clone: refuse targets that would drop the guest identity Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 24/38] restore: take over the guest uid from the backup where possible Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 25/38] restore: refuse overwriting a container with another guest's backup Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 26/38] test: remote migration: check the cleanup of the target after failures Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 27/38] api: remote migration: take over the guest uid from the source Thomas Lamprecht
2026-11-18 4:37 ` [PATCH container v3 28/38] api: status: return the guest uid Thomas Lamprecht
2026-11-18 4:37 ` [PATCH manager v3 29/38] api: cluster resources: add guest uid and registration time Thomas Lamprecht
2026-11-18 4:37 ` [PATCH manager v3 30/38] api: cluster status: add cluster ID Thomas Lamprecht
2026-11-18 4:37 ` [PATCH manager v3 31/38] ui: restore: allow overwriting a guest with a backup of another guest Thomas Lamprecht
2026-11-18 4:37 ` [PATCH manager v3 32/38] ui: migrate: refuse target nodes that would drop the guest identity Thomas Lamprecht
2026-11-18 4:37 ` [PATCH manager v3 33/38] ui: guest summary: show " Thomas Lamprecht
2026-11-18 4:37 ` [PATCH manager v3 34/38] api: bulk migrate: refuse targets that would drop " Thomas Lamprecht
2026-11-18 4:37 ` [PATCH docs v3 35/38] vzdump: describe the guest identity of VMs and containers Thomas Lamprecht
2026-11-18 4:37 ` [PATCH docs v3 36/38] pvecm: document the cluster ID and how to get a new one Thomas Lamprecht
2026-11-18 4:37 ` [PATCH docs v3 37/38] qm: configuration: describe the read-only meta property Thomas Lamprecht
2026-11-18 4:37 ` [PATCH docs v3 38/38] pct: " Thomas Lamprecht
2026-11-18 13:49 ` [PATCH cluster/guest-common/qemu-server/container/manager/docs v3 00/38] fix #7846: guest identity (uid) and cluster ID Dominik Csapak
2026-11-18 14:13 ` Thomas Lamprecht
2026-11-19 10:38 ` superseded: " Thomas Lamprecht
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261118043817.1659212-11-t.lamprecht@proxmox.com \
--to=t.lamprecht@proxmox.com \
--cc=pve-devel@lists.proxmox.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox