public inbox for pve-devel@lists.proxmox.com
 help / color / mirror / Atom feed
From: Thomas Lamprecht <t.lamprecht@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [PATCH guest-common v4 09/41] abstract config: assign a guest identity and keep it on config writes
Date: Thu, 19 Nov 2026 11:33:55 +0100	[thread overview]
Message-ID: <20261119103551.1666964-10-t.lamprecht@proxmox.com> (raw)
In-Reply-To: <20261119103551.1666964-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. Adopting 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>
Reviewed-by: Dominik Csapak <d.csapak@proxmox.com>
Tested-by: Dominik Csapak <d.csapak@proxmox.com>
---

changes v3 -> v4:
* rebase (test Makefile), and 'adopt' instead of 'take over' in the
  commit message

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 623f8a2..d6dfd66 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 778b296..145f6c4 100644
--- a/src/tests/Makefile
+++ b/src/tests/Makefile
@@ -1,12 +1,15 @@
 
 all:
 
-.PHONY: check abstract-config config-reservation firewall-config guest-id guest-identity hookscript storage-tunnel
-check: abstract-config config-reservation firewall-config guest-id guest-identity hookscript storage-tunnel
+.PHONY: check abstract-config config-identity config-reservation firewall-config guest-id guest-identity hookscript storage-tunnel
+check: abstract-config config-identity config-reservation firewall-config guest-id guest-identity hookscript storage-tunnel
 
 abstract-config: abstract-config-tests.pl
 	perl -I.. ./abstract-config-tests.pl
 
+config-identity: config-identity-tests.pl
+	perl -I.. ./config-identity-tests.pl
+
 config-reservation: config-reservation-tests.pl
 	perl -I.. ./config-reservation-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





  parent reply	other threads:[~2026-11-19 10:38 UTC|newest]

Thread overview: 46+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-19 10:33 [PATCH cluster/guest-common/qemu-server/container/manager/docs v4 00/41] fix #7846: guest identity (uid) and cluster ID Thomas Lamprecht
2026-11-19 10:33 ` [PATCH cluster v4 01/41] pmxcfs: reject changes to the cluster ID file from user space Thomas Lamprecht
2026-11-19 10:33 ` [PATCH cluster v4 02/41] pmxcfs: generate a cluster ID on standalone nodes Thomas Lamprecht
2026-11-19 10:33 ` [PATCH cluster v4 03/41] pmxcfs: dfsm: add a callback that runs once all members are in sync Thomas Lamprecht
2026-11-19 10:33 ` [PATCH cluster v4 04/41] pmxcfs: quorum: record the corosync membership Thomas Lamprecht
2026-11-19 10:33 ` [PATCH cluster v4 05/41] pmxcfs: dcdb: generate the cluster ID once the cluster is in sync Thomas Lamprecht
2026-11-19 10:33 ` [PATCH cluster v4 06/41] cluster: add helper to read the cluster ID Thomas Lamprecht
2026-11-19 10:33 ` [PATCH cluster v4 07/41] pmxcfs: allow removing the cluster ID file in forced local mode Thomas Lamprecht
2026-11-19 10:33 ` [PATCH guest-common v4 08/41] guest identity: add helpers for the guest uid and registration time Thomas Lamprecht
2026-11-19 10:33 ` Thomas Lamprecht [this message]
2026-11-19 10:33 ` [PATCH guest-common v4 10/41] abstract config: let the VMID reservation return the previous state Thomas Lamprecht
2026-11-19 10:33 ` [PATCH guest-common v4 11/41] guest identity: allow adopting a uid that is unused in the cluster Thomas Lamprecht
2026-11-19 10:33 ` [PATCH guest-common v4 12/41] migrate: add shared helpers for the identity command of the migration tunnel Thomas Lamprecht
2026-11-19 10:33 ` [PATCH guest-common v4 13/41] vzdump: notes template: list the uid variable Thomas Lamprecht
2026-11-19 10:34 ` [PATCH qemu-server v4 14/41] api: restore: release the VMID if a restore to an unused VMID fails Thomas Lamprecht
2026-11-19 10:34 ` [PATCH qemu-server v4 15/41] api: migrate, clone: refuse targets that would drop the guest identity Thomas Lamprecht
2026-11-19 10:34 ` [PATCH qemu-server v4 16/41] fix #7846: config: add a guest identity to the 'meta' property Thomas Lamprecht
2026-11-19 10:34 ` [PATCH qemu-server v4 17/41] restore: take over the guest uid from the backup where possible Thomas Lamprecht
2026-11-19 10:34 ` [PATCH qemu-server v4 18/41] api: remote migration: take over the guest uid from the source Thomas Lamprecht
2026-11-19 10:34 ` [PATCH qemu-server v4 19/41] api: status: return the guest uid Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 20/41] restore: decide by the reservation whether the container is new Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 21/41] config: add read-only meta property with the creation time Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 22/41] fix #7846: config: add a guest identity to the 'meta' property Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 23/41] api: migrate, clone: refuse targets that would drop the guest identity Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 24/41] restore: take over the guest uid from the backup where possible Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 25/41] restore: refuse overwriting a container with another guest's backup Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 26/41] api: remote migration: take over the guest uid from the source Thomas Lamprecht
2026-11-19 10:34 ` [PATCH container v4 27/41] api: status: return the guest uid Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 28/41] api: cluster resources: add guest uid and registration time Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 29/41] api: cluster status: add cluster ID Thomas Lamprecht
2026-11-19 12:32   ` Lukas Wagner
2026-11-19 12:51     ` Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 30/41] ui: datacenter summary: show the " Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 31/41] ui: restore: allow overwriting a guest with a backup of another guest Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 32/41] ui: migrate: refuse target nodes that would drop the guest identity Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 33/41] ui: guest summary: show " Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 34/41] api: bulk migrate: refuse targets that would drop " Thomas Lamprecht
2026-11-19 10:34 ` [PATCH manager v4 35/41] vzdump: notes template: add the guest uid as variable Thomas Lamprecht
2026-11-19 10:34 ` [PATCH docs v4 36/41] vzdump: restore: describe what a failed restore can leave behind Thomas Lamprecht
2026-11-19 10:34 ` [PATCH docs v4 37/41] vzdump: describe the guest identity of VMs and containers Thomas Lamprecht
2026-11-19 10:34 ` [PATCH docs v4 38/41] pvecm: document the cluster ID and how to get a new one Thomas Lamprecht
2026-11-19 10:34 ` [PATCH docs v4 39/41] qm: configuration: describe the read-only meta property Thomas Lamprecht
2026-11-19 10:34 ` [PATCH docs v4 40/41] pct: " Thomas Lamprecht
2026-11-19 10:34 ` [PATCH docs v4 41/41] vzdump: notes: document the uid template variable Thomas Lamprecht
2026-11-19 14:46 ` [PATCH cluster/guest-common/qemu-server/container/manager/docs v4 00/41] fix #7846: guest identity (uid) and cluster ID Dominik Csapak
2026-11-19 19:49 ` 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=20261119103551.1666964-10-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
Service provided by Proxmox Server Solutions GmbH | Privacy | Legal