Auto-generated IDs

Multiple sub-systems in QEMU may find it useful to generate IDs for objects that a user may reference via QMP or HMP. This patch presents a standardized way to do it, so that automatic ID generation follows the same rules.

This patch enforces the following rules when generating an ID:

1.) Guarantee no collisions with a user-specified ID
2.) Identify the sub-system the ID belongs to
3.) Guarantee of uniqueness
4.) Spoiling predictability, to avoid creating an assumption
of object ordering and parsing (i.e., we don't want users to think they can guess the next ID based on prior behavior).

The scheme for this is as follows (no spaces):

                # subsys D RR
Reserved char --|    |   | |
Subsystem String ----|   | |
Unique number (64-bit) --| |
Two-digit random number ---|

For example, a generated node-name for the block sub-system may look like this:

    #block076

The caller of id_generate() is responsible for freeing the generated node name string with g_free().

Signed-off-by Jeff Cody <[email protected]>

---
 include/qemu-common.h |  8 ++++++++
 util/id.c             | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

Quoted 27 lines · Jeff Cody

Multiple sub-systems in QEMU may find it useful to generate IDs for objects that a user may reference via QMP or HMP. This patch presents a standardized way to do it, so that automatic ID generation follows the same rules.

This patch enforces the following rules when generating an ID:

1.) Guarantee no collisions with a user-specified ID
2.) Identify the sub-system the ID belongs to
3.) Guarantee of uniqueness
4.) Spoiling predictability, to avoid creating an assumption
of object ordering and parsing (i.e., we don't want users to think they can guess the next ID based on prior behavior).

The scheme for this is as follows (no spaces):

                # subsys D RR
Reserved char --|    |   | |
Subsystem String ----|   | |
Unique number (64-bit) --| |
Two-digit random number ---|

For example, a generated node-name for the block sub-system may look like this:

    #block076

Quoted 8 lines

The caller of id_generate() is responsible for freeing the generated node name string with g_free().

Signed-off-by Jeff Cody <[email protected]>

---
 include/qemu-common.h |  8 ++++++++
 util/id.c             | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

Reviewed-by Eric Blake <[email protected]>

util/id.c bool id_wellformed(const char *id) · line 35

Quoted 5 lines

util/id.c +5 -0

+
+static const char * const id_subsys_str[] = {
+    [ID_QDEV]  = "qdev",
+    [ID_BLOCK] = "block",
+};

We're inconsistent on whether there should be a space in '*const' (compare commit a91e211 with b86f461, for example). But since qemu.git has both spellings in various contexts, it's probably not worth changing here.

Review

Quoted 2 lines

(quoted diff) +2 -0

+
+    rnd = g_random_int_range(0, 99);

Thankfully, g_random_* is a PRNG that is not consuming system entropy (auto-generated names should not be starving /dev/random).

Multiple sub-systems in QEMU may find it useful to generate IDs for objects that a user may reference via QMP or HMP. This patch presents a standardized way to do it, so that automatic ID generation follows the same rules.

This patch enforces the following rules when generating an ID:

1.) Guarantee no collisions with a user-specified ID
2.) Identify the sub-system the ID belongs to
3.) Guarantee of uniqueness
4.) Spoiling predictability, to avoid creating an assumption
of object ordering and parsing (i.e., we don't want users to think they can guess the next ID based on prior behavior).

The scheme for this is as follows (no spaces):

                # subsys D RR
Reserved char --|    |   | |
Subsystem String ----|   | |
Unique number (64-bit) --| |
Two-digit random number ---|

For example, a generated node-name for the block sub-system may look like this:

    #block076

The caller of id_generate() is responsible for freeing the generated node name string with g_free().

Signed-off-by Jeff Cody <[email protected]>

---
 include/qemu-common.h |  8 ++++++++
 util/id.c             | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

include/qemu-common.h +8 -0

index bbaffd1..f6b0105 100644
@@ -237,6 +237,14 @@ int64_t strtosz_suffix_unit(const char *nptr, char **end,
 #define STR_OR_NULL(str) ((str) ? (str) : "null")
 
 /* id.c */
+
+typedef enum IdSubSystems {
+    ID_QDEV,
+    ID_BLOCK,
+    ID_MAX      /* last element, used as array size */
+} IdSubSystems;
+
+char *id_generate(IdSubSystems);
 bool id_wellformed(const char *id);
 
 /* path.c */

util/id.c +26 -0

index 09b22fb..9457f2d 100644
@@ -26,3 +26,39 @@ bool id_wellformed(const char *id)
     }
     return true;
 }
+
+#define ID_SPECIAL_CHAR '#'
+
+static const char * const id_subsys_str[] = {
+    [ID_QDEV]  = "qdev",
+    [ID_BLOCK] = "block",
+};
+
+/* Generates an ID of the form:
+ *
+ * "#block146",
+ *
+ *  where:
+ *      - "#" is always the reserved character '#'
+ *      - "block" refers to the subsystem identifed via IdSubSystems
+ *        and id_subsys_str[]
+ *      - "1" is a unique number (up to a uint64_t) for the subsystem
+ *      - "46" is a zero-padded two digit pseudo-random number
+ *
+ * The caller is responsible for freeing the returned string with g_free()
+ */
+char *id_generate(IdSubSystems id)
+{
+    static uint64_t id_counters[ID_MAX];
+    uint32_t rnd;
+

Quoted 4 lines · Jeff Cody

Multiple sub-systems in QEMU may find it useful to generate IDs for objects that a user may reference via QMP or HMP. This patch presents a standardized way to do it, so that automatic ID generation follows the same rules.

include/qemu-common.h int64_t strtosz_suffix_unit(const char *nptr, char **end, · line 247

Quoted 8 lines

include/qemu-common.h +8 -0

+
+typedef enum IdSubSystems {
+    ID_QDEV,
+    ID_BLOCK,
+    ID_MAX      /* last element, used as array size */
+} IdSubSystems;
+
+char *id_generate(IdSubSystems);

Not that it matters much, but it seems that everywhere else in the QEMU source code the rule is to name the parameters in function prototypes.

Otherwise, the patch looks good!

Reviewed-by Alberto Garcia <[email protected]>

Berto

Changes from RFC v1:

Patch 1: Several typos / grammatical errors (thanks Eric, John)
Make id_subsys_str[] const pointer to const strings (thanks Eric) Moved id_subsys_str[] out from id_generate() (thanks John) Assert on null string for given id (thanks Eric) Zero-pad the 2-digit random # (thanks John)

Patch 2: None

Born from the conversation on qemu-devel, this generation scheme uses the format ultimately proposed by Kevin, after list discussion.

It attempts to keep the ID strings as small as possible, while fulfilling:

1.) Guarantee no collisions with a user-specified ID
2.) Identify the sub-system the ID belongs to
3.) Guarantee of uniqueness
4.) Spoiling predictibility, to avoid creating an assumption
of object ordering and parsing (i.e., we don't want users to think they can guess the next ID based on prior behavior).

See patch 1 for the generation scheme details.

Am 02.09.2015 um 00:30 hat Jeff Cody geschrieben:

Quoted 22 lines

Changes from RFC v1:

Patch 1: Several typos / grammatical errors (thanks Eric, John)
Make id_subsys_str[] const pointer to const strings (thanks Eric) Moved id_subsys_str[] out from id_generate() (thanks John) Assert on null string for given id (thanks Eric) Zero-pad the 2-digit random # (thanks John)

Patch 2: None

Born from the conversation on qemu-devel, this generation scheme uses the format ultimately proposed by Kevin, after list discussion.

It attempts to keep the ID strings as small as possible, while fulfilling:

1.) Guarantee no collisions with a user-specified ID
2.) Identify the sub-system the ID belongs to
3.) Guarantee of uniqueness
4.) Spoiling predictibility, to avoid creating an assumption
of object ordering and parsing (i.e., we don't want users to think they can guess the next ID based on prior behavior).

Quoted 1 line

See patch 1 for the generation scheme details.

Thanks, applied to the block branch.

While applying, I fixed up the id_generate() declaration in the header file to include an identifier for the parameter.

Multiple sub-systems in QEMU may find it useful to generate IDs for objects that a user may reference via QMP or HMP. This patch presents a standardized way to do it, so that automatic ID generation follows the same rules.

This patch enforces the following rules when generating an ID:

1.) Guarantee no collisions with a user-specified ID
2.) Identify the sub-system the ID belongs to
3.) Guarantee of uniqueness
4.) Spoiling predictability, to avoid creating an assumption
of object ordering and parsing (i.e., we don't want users to think they can guess the next ID based on prior behavior).

The scheme for this is as follows (no spaces):

                # subsys D RR
Reserved char --|    |   | |
Subsystem String ----|   | |
Unique number (64-bit) --| |
Two-digit random number ---|

For example, a generated node-name for the block sub-system may look like this:

    #block076

The caller of id_generate() is responsible for freeing the generated node name string with g_free().

Signed-off-by Jeff Cody <[email protected]>

---
 include/qemu-common.h |  8 ++++++++
 util/id.c             | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

include/qemu-common.h +8 -0

index bbaffd1..f6b0105 100644
@@ -237,6 +237,14 @@ int64_t strtosz_suffix_unit(const char *nptr, char **end,
 #define STR_OR_NULL(str) ((str) ? (str) : "null")
 
 /* id.c */
+
+typedef enum IdSubSystems {
+    ID_QDEV,
+    ID_BLOCK,
+    ID_MAX      /* last element, used as array size */
+} IdSubSystems;
+
+char *id_generate(IdSubSystems);
 bool id_wellformed(const char *id);
 
 /* path.c */

util/id.c +0 -0

index 09b22fb..9457f2d 100644

util/id.c +6 -0

+
+    return g_strdup_printf("%c%s%" PRIu64 "%02" PRId32, ID_SPECIAL_CHAR,
+                                                        id_subsys_str[id],
+                                                        id_counters[id]++,
+                                                        rnd);
+}

If a node-name is not specified, automatically generate the node-name.

Generated node-names will use the "block" sub-system identifier.

Reviewed-by Eric Blake <[email protected]>

Reviewed-by John Snow <[email protected]>

Signed-off-by Jeff Cody <[email protected]>

---
 block.c | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

block.c +2 -0

index d088ee0..892e127 100644
@@ -771,32 +771,39 @@ static void bdrv_assign_node_name(BlockDriverState *bs,
                                   const char *node_name,
                                   Error **errp)
 {
+    char *gen_node_name = NULL;
+

block.c +4 -2

     /* takes care of avoiding namespaces collisions */
     if (blk_by_name(node_name)) {
         error_setg(errp, "node-name=%s is conflicting with a device id",
                    node_name);
-        return;
+        goto out;
     }
 
     /* takes care of avoiding duplicates node names */
     if (bdrv_find_node(node_name)) {
         error_setg(errp, "Duplicate node name");
-        return;
+        goto out;
     }
 
     /* copy node name into the bs and insert it into the graph list */
     pstrcpy(bs->node_name, sizeof(bs->node_name), node_name);
     QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list);
+out:
+    g_free(gen_node_name);
 }
 
 static QemuOptsList bdrv_runtime_opts = {

Changes from RFC v1:

Patch 1: Several typos / grammatical errors (thanks Eric, John)
Make id_subsys_str[] const pointer to const strings (thanks Eric) Moved id_subsys_str[] out from id_generate() (thanks John) Assert on null string for given id (thanks Eric) Zero-pad the 2-digit random # (thanks John)

Patch 2: None

Born from the conversation on qemu-devel, this generation scheme uses the format ultimately proposed by Kevin, after list discussion.

It attempts to keep the ID strings as small as possible, while fulfilling:

1.) Guarantee no collisions with a user-specified ID
2.) Identify the sub-system the ID belongs to
3.) Guarantee of uniqueness
4.) Spoiling predictibility, to avoid creating an assumption
of object ordering and parsing (i.e., we don't want users to think they can guess the next ID based on prior behavior).

See patch 1 for the generation scheme details.