all lists on lists.proxmox.com
 help / color / mirror / Atom feed
From: Thomas Lamprecht <t.lamprecht@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [PATCH cluster v3 02/38] pmxcfs: generate a cluster ID on standalone nodes
Date: Wed, 18 Nov 2026 05:37:14 +0100	[thread overview]
Message-ID: <20261118043817.1659212-3-t.lamprecht@proxmox.com> (raw)
In-Reply-To: <20261118043817.1659212-1-t.lamprecht@proxmox.com>

Standalone nodes need a cluster ID to distinguish them from other
installations. Generate and persist it before mounting the filesystem
or starting the IPC server, when no other writer or reader can access
the database.

Use 20 random characters of the lowercase RFC 4648 base32 alphabet, each
from a random byte of /dev/urandom, followed by a newline. These 100
random bits make a duplicate between installations practically
impossible, fit into a 128-bit value with bits to spare, and stay short
and free of characters that need quoting. Keep a valid existing ID, with
or without its newline. Replace invalid content, including an empty file
left by interrupted initialization. Log a directory at the path and
leave it for an administrator to remove with rmdir.

Abort startup if storing the ID fails: the in-memory database could
otherwise expose an ID that is lost or replaced after a restart. A
failure to obtain random data only logs an error, since nothing was
written and the next startup can retry.

Do not generate an ID in forced local mode if corosync.conf exists.
That node belongs to a cluster and must not create a conflicting ID
before rejoining it.

Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
---

changes v2 -> v3:
* say in the comment that it is about a failed generation

changes v1 -> v2:
* take each character from a random byte of its own instead of encoding
  13 random bytes, which drops the encoder and its test vectors
  (Dominik)
* give the reasons for the format in the commit message

 src/pmxcfs/Makefile      |   2 +-
 src/pmxcfs/check_memdb.c | 165 +++++++++++++++++++++++++++++++++++++++
 src/pmxcfs/cluster-id.c  | 142 +++++++++++++++++++++++++++++++++
 src/pmxcfs/cluster-id.h  |  50 ++++++++++++
 src/pmxcfs/pmxcfs.c      |   6 ++
 5 files changed, 364 insertions(+), 1 deletion(-)
 create mode 100644 src/pmxcfs/cluster-id.c
 create mode 100644 src/pmxcfs/cluster-id.h

diff --git a/src/pmxcfs/Makefile b/src/pmxcfs/Makefile
index 547f258..cd93e72 100644
--- a/src/pmxcfs/Makefile
+++ b/src/pmxcfs/Makefile
@@ -21,7 +21,7 @@ all: pmxcfs create_pmxcfs_db logtest check_memdb
 
 libpmxcfs.a: logger.o loop.o server.o status.o confdb.o quorum.o dcdb.o dfsm.o
 libpmxcfs.a: cfs-plug.o cfs-plug-memdb.o cfs-plug-link.o cfs-plug-func.o
-libpmxcfs.a: cfs-utils.o memdb.o database.o
+libpmxcfs.a: cfs-utils.o memdb.o database.o cluster-id.o
 libpmxcfs.a:
 	$(AR) $(ARFLAGS) $@ $^
 
diff --git a/src/pmxcfs/check_memdb.c b/src/pmxcfs/check_memdb.c
index caac740..db85cbd 100644
--- a/src/pmxcfs/check_memdb.c
+++ b/src/pmxcfs/check_memdb.c
@@ -19,8 +19,10 @@
 */
 
 #include <check.h>
+#include <dirent.h>
 #include <errno.h>
 #include <glib.h>
+#include <sqlite3.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -28,6 +30,7 @@
 
 #include "cfs-plug-memdb.h"
 #include "cfs-utils.h"
+#include "cluster-id.h"
 #include "memdb.h"
 #include "status.h"
 
@@ -302,6 +305,158 @@ START_TEST(test_cluster_id_fuse_read_only) {
 }
 END_TEST
 
+START_TEST(test_cluster_id_is_valid) {
+    ck_assert(cluster_id_is_valid("abcdefghijklmnopqrst\n", 21));
+    ck_assert(cluster_id_is_valid("uvwxyz234567abcdefgh\n", 21));
+    ck_assert(cluster_id_is_valid("abcdefghijklmnopqrst", 20));
+
+    ck_assert(!cluster_id_is_valid(NULL, 21));
+    ck_assert(!cluster_id_is_valid("", 0));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmno", 15));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnop", 16));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnop\n", 17));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnopqrs\n", 20));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnopqrstu", 21));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnopqrstu\n", 22));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnopqrst\n\n", 22));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnopqrst ", 21));
+    ck_assert(!cluster_id_is_valid("Abcdefghijklmnopqrst\n", 21));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnopqrs1\n", 21));
+    ck_assert(!cluster_id_is_valid("abcdefghijklmnopqrs8\n", 21));
+    ck_assert(!cluster_id_is_valid("abcdefgh\0jklmnopqrst\n", 21));
+}
+END_TEST
+
+START_TEST(test_cluster_id_generate) {
+    char id1[CLUSTER_ID_FILE_SIZE], id2[CLUSTER_ID_FILE_SIZE];
+
+    ck_assert(cluster_id_generate(id1));
+    ck_assert(cluster_id_generate(id2));
+
+    ck_assert(cluster_id_is_valid(id1, sizeof(id1)));
+    ck_assert(cluster_id_is_valid(id2, sizeof(id2)));
+    ck_assert(memcmp(id1, id2, sizeof(id1)) != 0);
+}
+END_TEST
+
+START_TEST(test_cluster_id_state) {
+    time_t ctime = 1234;
+
+    ck_assert(cluster_id_state(memdb) == CLUSTER_ID_MISSING);
+
+    ck_assert(memdb_create(memdb, "cluster-id", 0, ctime) == 0);
+    ck_assert(cluster_id_state(memdb) == CLUSTER_ID_INVALID);
+
+    ck_assert(memdb_write(memdb, "cluster-id", 0, ctime, "abcdefghijklmnopqrst\n", 21, 0, 1) == 21);
+    ck_assert(cluster_id_state(memdb) == CLUSTER_ID_VALID);
+
+    ck_assert(memdb_write(memdb, "cluster-id", 0, ctime, "foo", 3, 0, 1) == 3);
+    ck_assert(cluster_id_state(memdb) == CLUSTER_ID_INVALID);
+
+    ck_assert(memdb_delete(memdb, "cluster-id", 0, ctime) == 0);
+    ck_assert(memdb_mkdir(memdb, "cluster-id", 0, ctime) == 0);
+    ck_assert(cluster_id_state(memdb) == CLUSTER_ID_NOT_A_FILE);
+}
+END_TEST
+
+START_TEST(test_cluster_id_standalone) {
+    time_t ctime = 1234;
+    gpointer data;
+    int len;
+
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    len = memdb_read(memdb, "cluster-id", &data);
+    ck_assert(len == CLUSTER_ID_FILE_SIZE);
+    ck_assert(cluster_id_is_valid(data, len));
+
+    /* an existing ID is kept */
+    char id[CLUSTER_ID_FILE_SIZE];
+    memcpy(id, data, sizeof(id));
+    g_free(data);
+
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    ck_assert(memdb_read(memdb, "cluster-id", &data) == CLUSTER_ID_FILE_SIZE);
+    ck_assert(memcmp(data, id, sizeof(id)) == 0);
+    g_free(data);
+
+    /* an empty file is what a crash between creating and writing leaves behind, it gets filled */
+    ck_assert(memdb_delete(memdb, "cluster-id", 0, ctime) == 0);
+    ck_assert(memdb_create(memdb, "cluster-id", 0, ctime) == 0);
+
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    len = memdb_read(memdb, "cluster-id", &data);
+    ck_assert(len == CLUSTER_ID_FILE_SIZE);
+    ck_assert(cluster_id_is_valid(data, len));
+    g_free(data);
+
+    /* so is invalid content */
+    ck_assert(memdb_write(memdb, "cluster-id", 0, ctime, "foo\n", 4, 0, 1) == 4);
+
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    len = memdb_read(memdb, "cluster-id", &data);
+    ck_assert(len == CLUSTER_ID_FILE_SIZE);
+    ck_assert(cluster_id_is_valid(data, len));
+    g_free(data);
+
+    /* a valid ID without newline is kept as is */
+    ck_assert(memdb_write(memdb, "cluster-id", 0, ctime, "abcdefghijklmnopqrst", 20, 0, 1) == 20);
+
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    ck_assert(memdb_read(memdb, "cluster-id", &data) == 20);
+    ck_assert(memcmp(data, "abcdefghijklmnopqrst", 20) == 0);
+    g_free(data);
+
+    /* an ID with only 16 characters is malformed like anything else and gets replaced */
+    ck_assert(memdb_write(memdb, "cluster-id", 0, ctime, "abcdefghijklmnop\n", 17, 0, 1) == 17);
+
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    len = memdb_read(memdb, "cluster-id", &data);
+    ck_assert(len == CLUSTER_ID_FILE_SIZE);
+    ck_assert(cluster_id_is_valid(data, len));
+    g_free(data);
+
+    /* a directory is left for the admin and does not stop the start */
+    ck_assert(memdb_delete(memdb, "cluster-id", 0, ctime) == 0);
+    ck_assert(memdb_mkdir(memdb, "cluster-id", 0, ctime) == 0);
+
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    memdb_tree_entry_t *te = memdb_getattr(memdb, "cluster-id");
+    ck_assert(te != NULL);
+    ck_assert(te->type == DT_DIR);
+    memdb_tree_entry_free(te);
+}
+END_TEST
+
+static void sql_exec(const char *statement) {
+    sqlite3 *db = NULL;
+    ck_assert(sqlite3_open(TESTDB, &db) == SQLITE_OK);
+    ck_assert(sqlite3_exec(db, statement, NULL, NULL, NULL) == SQLITE_OK);
+    ck_assert(sqlite3_close(db) == SQLITE_OK);
+}
+
+START_TEST(test_cluster_id_standalone_write_failure) {
+    sql_exec(
+        "CREATE TRIGGER fail_cluster_id BEFORE INSERT ON tree "
+        "WHEN NEW.name = 'cluster-id' AND length(NEW.data) > 0 "
+        "BEGIN SELECT RAISE(FAIL, 'injected failure'); END;"
+    );
+
+    /* creating the empty file still works, storing the content fails */
+    ck_assert(!cluster_id_ensure_standalone(memdb));
+    ck_assert(memdb->errors);
+
+    memdb_close(memdb);
+    sql_exec("DROP TRIGGER fail_cluster_id;");
+    memdb = memdb_open(TESTDB);
+    ck_assert(memdb != NULL);
+
+    /* the next start finds the empty file and fills it */
+    ck_assert(cluster_id_state(memdb) == CLUSTER_ID_INVALID);
+    ck_assert(cluster_id_ensure_standalone(memdb));
+    ck_assert(cluster_id_state(memdb) == CLUSTER_ID_VALID);
+}
+END_TEST
+
 START_TEST(test_truncate_grow) {
     const char *fn = "/f1";
     time_t ctime = 1234;
@@ -590,6 +745,16 @@ static Suite *memdb_suite(void) {
 
     add_test(s, test_cluster_id_fuse_read_only, "cluster_id_fuse_read_only");
 
+    add_test(s, test_cluster_id_is_valid, "cluster_id_is_valid");
+
+    add_test(s, test_cluster_id_generate, "cluster_id_generate");
+
+    add_test(s, test_cluster_id_state, "cluster_id_state");
+
+    add_test(s, test_cluster_id_standalone, "cluster_id_standalone");
+
+    add_test(s, test_cluster_id_standalone_write_failure, "cluster_id_standalone_write_failure");
+
     add_test(s, test_indextest1, "indextest1");
 
     add_test(s, test_loaddb1, "loaddb1");
diff --git a/src/pmxcfs/cluster-id.c b/src/pmxcfs/cluster-id.c
new file mode 100644
index 0000000..381f638
--- /dev/null
+++ b/src/pmxcfs/cluster-id.c
@@ -0,0 +1,142 @@
+/*
+  Copyright (C) 2026 Proxmox Server Solutions GmbH
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU Affero General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Affero General Public License for more details.
+
+  You should have received a copy of the GNU Affero General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+  Author: Thomas Lamprecht <t.lamprecht@proxmox.com>
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <glib.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "cfs-utils.h"
+#include "cluster-id.h"
+
+static const char base32_alphabet[] = "abcdefghijklmnopqrstuvwxyz234567";
+
+gboolean cluster_id_generate(char id[CLUSTER_ID_FILE_SIZE]) {
+    guint8 raw[CLUSTER_ID_LEN];
+
+    int fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC);
+    if (fd == -1) {
+        cfs_critical("unable to open /dev/urandom - %s", g_strerror(errno));
+        return FALSE;
+    }
+
+    ssize_t res = safe_read(fd, (char *)raw, sizeof(raw));
+    int saved_errno = errno;
+    close(fd);
+
+    if (res != (ssize_t)sizeof(raw)) {
+        cfs_critical(
+            "unable to read from /dev/urandom - %s",
+            res < 0 ? g_strerror(saved_errno) : "short read"
+        );
+        return FALSE;
+    }
+
+    /* five bits of a random byte per character, so each one is uniformly distributed */
+    for (int i = 0; i < CLUSTER_ID_LEN; i++) {
+        id[i] = base32_alphabet[raw[i] & 0x1f];
+    }
+    id[CLUSTER_ID_LEN] = '\n';
+
+    return TRUE;
+}
+
+gboolean cluster_id_is_valid(gconstpointer data, size_t len) {
+    const char *id = data;
+
+    if (!id ||
+        !(len == CLUSTER_ID_LEN || (len == CLUSTER_ID_FILE_SIZE && id[CLUSTER_ID_LEN] == '\n'))) {
+        return FALSE;
+    }
+
+    for (int i = 0; i < CLUSTER_ID_LEN; i++) {
+        if (!((id[i] >= 'a' && id[i] <= 'z') || (id[i] >= '2' && id[i] <= '7'))) {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+cluster_id_state_t cluster_id_state(memdb_t *memdb) {
+    g_return_val_if_fail(memdb != NULL, CLUSTER_ID_NOT_A_FILE);
+
+    memdb_tree_entry_t *te = memdb_getattr(memdb, CFS_CLUSTER_ID_FN);
+    if (!te) {
+        return CLUSTER_ID_MISSING;
+    }
+
+    gboolean is_file = te->type == DT_REG;
+    memdb_tree_entry_free(te);
+    if (!is_file) {
+        return CLUSTER_ID_NOT_A_FILE;
+    }
+
+    gpointer data = NULL;
+    int len = memdb_read(memdb, CFS_CLUSTER_ID_FN, &data);
+    gboolean valid = len >= 0 && cluster_id_is_valid(data, len);
+    g_free(data);
+
+    return valid ? CLUSTER_ID_VALID : CLUSTER_ID_INVALID;
+}
+
+gboolean cluster_id_ensure_standalone(memdb_t *memdb) {
+    g_return_val_if_fail(memdb != NULL, FALSE);
+
+    cluster_id_state_t state = cluster_id_state(memdb);
+    if (state == CLUSTER_ID_VALID) {
+        return TRUE;
+    }
+
+    if (state == CLUSTER_ID_NOT_A_FILE) {
+        cfs_message("not generating a cluster ID, '%s' is not a regular file", CFS_CLUSTER_ID_FN);
+        return TRUE;
+    }
+
+    /* on failure nothing got written, so the start can go on and the next one tries again */
+    char id[CLUSTER_ID_FILE_SIZE];
+    if (!cluster_id_generate(id)) {
+        return TRUE;
+    }
+
+    /* nothing is mounted yet, so no reader can see the file between creating and writing it, and
+     * a crash in between leaves an empty file that the next start fills */
+    guint32 mtime = time(NULL);
+    int res = state == CLUSTER_ID_MISSING ? memdb_create(memdb, CFS_CLUSTER_ID_FN, 0, mtime) : 0;
+    if (res == 0) {
+        res = memdb_write(memdb, CFS_CLUSTER_ID_FN, 0, mtime, id, CLUSTER_ID_FILE_SIZE, 0, TRUE);
+    }
+
+    /* the memdb already shows the new content if only storing it failed, so it must not be used */
+    if (res != CLUSTER_ID_FILE_SIZE) {
+        cfs_critical("unable to write '%s' - %s", CFS_CLUSTER_ID_FN, g_strerror(-res));
+        return FALSE;
+    }
+
+    cfs_message("generated cluster ID %.*s", CLUSTER_ID_LEN, id);
+
+    return TRUE;
+}
diff --git a/src/pmxcfs/cluster-id.h b/src/pmxcfs/cluster-id.h
new file mode 100644
index 0000000..2715f7d
--- /dev/null
+++ b/src/pmxcfs/cluster-id.h
@@ -0,0 +1,50 @@
+/*
+  Copyright (C) 2026 Proxmox Server Solutions GmbH
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU Affero General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Affero General Public License for more details.
+
+  You should have received a copy of the GNU Affero General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+  Author: Thomas Lamprecht <t.lamprecht@proxmox.com>
+
+*/
+
+#ifndef _PVE_CLUSTER_ID_H_
+#define _PVE_CLUSTER_ID_H_
+
+#include <glib.h>
+
+#include "memdb.h"
+
+/* the ID is 20 random characters of the lowercase RFC 4648 base32 alphabet, so 100 random bits,
+ * pmxcfs writes it plus a newline */
+#define CLUSTER_ID_LEN 20
+#define CLUSTER_ID_FILE_SIZE (CLUSTER_ID_LEN + 1)
+
+gboolean cluster_id_generate(char id[CLUSTER_ID_FILE_SIZE]);
+
+gboolean cluster_id_is_valid(gconstpointer data, size_t len);
+
+typedef enum {
+    CLUSTER_ID_VALID,
+    CLUSTER_ID_MISSING,
+    CLUSTER_ID_INVALID,
+    /* a directory, which only rmdir can remove */
+    CLUSTER_ID_NOT_A_FILE,
+} cluster_id_state_t;
+
+cluster_id_state_t cluster_id_state(memdb_t *memdb);
+
+/* FALSE only if storing the ID failed, the memdb must not be used then */
+gboolean cluster_id_ensure_standalone(memdb_t *memdb);
+
+#endif /* _PVE_CLUSTER_ID_H_ */
diff --git a/src/pmxcfs/pmxcfs.c b/src/pmxcfs/pmxcfs.c
index b8a212d..2bf9145 100644
--- a/src/pmxcfs/pmxcfs.c
+++ b/src/pmxcfs/pmxcfs.c
@@ -48,6 +48,7 @@
 #include "cfs-plug-memdb.h"
 #include "cfs-plug.h"
 #include "cfs-utils.h"
+#include "cluster-id.h"
 #include "confdb.h"
 #include "dcdb.h"
 #include "dfsm.h"
@@ -912,6 +913,11 @@ int main(int argc, char *argv[]) {
     } else {
         cfs_debug("using local mode (corosync.conf does not exist)");
         cfs_set_quorate(1, TRUE);
+        /* only without a corosync.conf, forced local mode on a cluster node must not generate an ID
+         * of its own */
+        if (!cluster_id_ensure_standalone(memdb)) {
+            goto err;
+        }
     }
     if (conf_data) {
         g_free(conf_data);
-- 
2.47.3





  parent reply	other threads:[~2026-11-18  4:39 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 ` Thomas Lamprecht [this message]
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 ` [PATCH guest-common v3 10/38] abstract config: assign a guest identity and keep it on config writes Thomas Lamprecht
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-3-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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.
Service provided by Proxmox Server Solutions GmbH | Privacy | Legal