On Thu, Nov 12, 2026 at 9:31 PM Daniel P. Berrangé <[email protected]> wrote:
>
> All QOM types must have a globally unique typename, however, for
> user convenience, some might also want to have aliases which are
> permitted to be ambiguous. Define an "Aliased" interface which
> can be implemented by types which want to support aliases.
>
> When resolving an alias, if there are multiple QOM types with a
> matching alias this is considered an error. Ambiguity can be
> resolved by matching system state, with the selected target
> being the currently implemented filter.
>
> Signed-off-by: Daniel P. Berrangé <[email protected]>
> ---
> include/qom/object_interfaces.h | 77 +++++++++++++++++++++++++++++++++
> qom/object_interfaces.c | 57 ++++++++++++++++++++++++
> 2 files changed, 134 insertions(+)
>
> diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
> index d222a3d7481..010e37d63f7 100644
> --- a/include/qom/object_interfaces.h
> +++ b/include/qom/object_interfaces.h
> @@ -27,6 +27,17 @@ DECLARE_CLASS_CHECKERS(TargetSpecificClass,
> TARGET_SPECIFIC,
>
> typedef struct TargetSpecific TargetSpecific;
>
> +#define TYPE_ALIASED "aliased"
> +
> +typedef struct AliasedClass AliasedClass;
> +DECLARE_CLASS_CHECKERS(AliasedClass, ALIASED,
> + TYPE_ALIASED)
> +#define ALIASED(obj) \
> + INTERFACE_CHECK(Aliased, (obj), \
> + TYPE_ALIASED)
> +
> +typedef struct Aliased Aliased;
> +
> /**
> * UserCreatableClass:
> * @parent_class: the base class
> @@ -242,4 +253,70 @@ bool target_specific_class_creatable(ObjectClass *oc);
> ObjectClass *target_specific_class_check(ObjectClass *oc,
> Error **errp);
>
> +/**
> + * AliasedClass
> + * @parent_class: the base class
> + *
> + * Interface for classes that want to declare they have aliases
> + * for their primary type name.
> + *
> + * While QOM type names are required to be unique, aliases allow
> + * for ambiguity across classes. The ambiguity is resolved at
> + * runtime based on system state, typically by the selection of
> + * a specific target. If ambiguity cannot be resolved, the user
> + * will need to use the unique QOM type name instead.
> + */
> +struct AliasedClass {
> + InterfaceClass parent_class;
> +
> + const char *const *aliases; /* NULL terminated list of typenames */
Hi Daniel,
I have a though that can we specify the target for each alias, so for example
"aarch64-virt" will pair with QEMU_ARCH_BIT(SYS_EMU_TARGET_AARCH64)
and
"arm-virt" will pair with QEMU_ARCH_BIT(SYS_EMU_TARGET_ARM),
so that when select name aarch64-virt, we will automatically infer the
QEMU_ARCH_BIT(SYS_EMU_TARGET_AARCH64) out.
Also
"virt" will pair with QEMU_ARCH_ALL, this is for single-target binary.
So that the paired target can be either QEMU_ARCH_ALL or single
QEMU_ARCH_BIT(target_arch).
After this design, the TYPE_TARGET_SPECIFIC won't be needed anymore and
we can use machine names to select "target_arch" in an explicit way(As
each alias name is
mapped to explicit QEMU_ARCH_BIT(target_arch)). for QEMU_ARCH_ALL is
only work for single-target binary.
And we can add some helper macro to generate the pair easily.
> +};
> +
> +
> +/**
> + * aliased_class_matches:
> + * @oc: the class object to check
> + * @typename: the possible type name alias to check
> + *
> + * Determine whether @oc implements the Aliased interface
> + * and has declared an alias that matches @typename.
> + *
> + * Returns: true if @oc implements Aliased and has an
> + * alias named @typename, false otherwise
> + */
> +bool aliased_class_matches(ObjectClass *oc,
> + const char *typename);
> +
> +
> +/**
> + * aliased_class_resolve:
> + * @implements: a parent type to validate
> + * @typename: a type name to search for
> + * @errp: pointer to a NULL initialized error object
> + *
> + * Search all registered QOM types that implement
> + * both @implements and the Aliased interface for
> + * one that declares an alias @typename.
> + *
> + * If there is a single QOM class with a matching alias
> + * it will be returned.
> + *
> + * If there are multiple QOM classes with a matching
> + * alias an error will be raised about the ambiguous
> + * match.
> + *
> + * If the QOM class also implements the TargetSpecific
> + * interface and the current system target does not
> + * match the declared supported targets, aliases for
> + * that QOM class will be ignored. This is usually
> + * sufficient to resolve ambiguity between types.
> + *
> + * Returns: a unique QOM class with an alias @typename,
> + * or NULL if zero or multiple aliases match, with @errp
> + * set.
> + */
> + ObjectClass *aliased_class_resolve(const char *implements,
> + const char *typename,
> + Error **errp);
> +
> #endif
> diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
> index f523a55b93a..136629f88b2 100644
> --- a/qom/object_interfaces.c
> +++ b/qom/object_interfaces.c
> @@ -305,6 +305,57 @@ ObjectClass *target_specific_class_check(ObjectClass *oc,
> }
>
>
> +bool aliased_class_matches(ObjectClass *oc, const char *typename)
> +{
> + AliasedClass *alc =
> + (AliasedClass *)object_class_dynamic_cast(
> + oc, TYPE_ALIASED);
> +
> + return alc && alc->aliases && g_strv_contains(alc->aliases, typename);
> +}
> +
> +
> +ObjectClass *aliased_class_resolve(const char *implements,
> + const char *typename,
> + Error **errp)
> +{
> + g_autoptr(GSList) objs = object_class_get_list(implements, false);
> + GSList *el;
> + ObjectClass *ret = NULL;
> + g_autofree const char **matches = NULL;
> + size_t nmatches = 0;
> +
> + for (el = objs; el; el = el->next) {
> + ObjectClass *oc = el->data;
> +
> + if (aliased_class_matches(oc, typename) &&
> + target_specific_class_creatable(oc)) {
> + matches = g_renew(const char *, matches, nmatches + 2);
> + matches[nmatches] = object_class_get_name(oc);
> + matches[nmatches + 1] = NULL;
> +
> + ret = oc;
> + }
> + }
> +
> + if (nmatches > 1) {
> + g_autofree char *matchesstr = g_strjoinv(", ", (char **)matches);
> + error_setg(errp,
> + "Object alias '%s' is not unique, matches %s",
> + typename, matchesstr);
> + return NULL;
> + }
> +
> + if (!ret) {
> + error_setg(errp, "Object '%s' not found, no child of '%s'
> registered",
> + typename, implements);
> + return NULL;
> + }
> +
> + return ret;
> +}
> +
> +
> static void register_types(void)
> {
> static const TypeInfo uc_interface_info = {
> @@ -317,9 +368,15 @@ static void register_types(void)
> .parent = TYPE_INTERFACE,
> .class_size = sizeof(TargetSpecificClass),
> };
> + static const TypeInfo al_interface_info = {
> + .name = TYPE_ALIASED,
> + .parent = TYPE_INTERFACE,
> + .class_size = sizeof(AliasedClass),
> + };
>
> type_register_static(&uc_interface_info);
> type_register_static(&ts_interface_info);
> + type_register_static(&al_interface_info);
> }
>
> type_init(register_types)
> --
> 2.56.1
>
--
此致
礼
罗勇刚
Yours
sincerely,
Yonggang Luo