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

Reply via email to