qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

object_interfaces.c (9553B)

      1 #include "qemu/osdep.h"
      2 
      3 #include "qemu/cutils.h"
      4 #include "qapi/error.h"
      5 #include "qapi/qapi-commands-qom.h"
      6 #include "qapi/qapi-visit-qom.h"
      7 #include "qapi/qmp/qdict.h"
      8 #include "qapi/qmp/qerror.h"
      9 #include "qapi/qmp/qjson.h"
     10 #include "qapi/qobject-input-visitor.h"
     11 #include "qapi/qobject-output-visitor.h"
     12 #include "qom/object_interfaces.h"
     13 #include "qemu/help_option.h"
     14 #include "qemu/id.h"
     15 #include "qemu/module.h"
     16 #include "qemu/option.h"
     17 #include "qemu/qemu-print.h"
     18 #include "qapi/opts-visitor.h"
     19 #include "qemu/config-file.h"
     20 #include "qemu/keyval.h"
     21 
     22 bool user_creatable_complete(UserCreatable *uc, Error **errp)
     23 {
     24     UserCreatableClass *ucc = USER_CREATABLE_GET_CLASS(uc);
     25     Error *err = NULL;
     26 
     27     if (ucc->complete) {
     28         ucc->complete(uc, &err);
     29         error_propagate(errp, err);
     30     }
     31     return !err;
     32 }
     33 
     34 bool user_creatable_can_be_deleted(UserCreatable *uc)
     35 {
     36 
     37     UserCreatableClass *ucc = USER_CREATABLE_GET_CLASS(uc);
     38 
     39     if (ucc->can_be_deleted) {
     40         return ucc->can_be_deleted(uc);
     41     } else {
     42         return true;
     43     }
     44 }
     45 
     46 static void object_set_properties_from_qdict(Object *obj, const QDict *qdict,
     47                                              Visitor *v, Error **errp)
     48 {
     49     const QDictEntry *e;
     50 
     51     if (!visit_start_struct(v, NULL, NULL, 0, errp)) {
     52         return;
     53     }
     54     for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) {
     55         if (!object_property_set(obj, e->key, v, errp)) {
     56             goto out;
     57         }
     58     }
     59     visit_check_struct(v, errp);
     60 out:
     61     visit_end_struct(v, NULL);
     62 }
     63 
     64 void object_set_properties_from_keyval(Object *obj, const QDict *qdict,
     65                                        bool from_json, Error **errp)
     66 {
     67     Visitor *v;
     68     if (from_json) {
     69         v = qobject_input_visitor_new(QOBJECT(qdict));
     70     } else {
     71         v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
     72     }
     73     object_set_properties_from_qdict(obj, qdict, v, errp);
     74     visit_free(v);
     75 }
     76 
     77 Object *user_creatable_add_type(const char *type, const char *id,
     78                                 const QDict *qdict,
     79                                 Visitor *v, Error **errp)
     80 {
     81     ERRP_GUARD();
     82     Object *obj;
     83     ObjectClass *klass;
     84     Error *local_err = NULL;
     85 
     86     if (id != NULL && !id_wellformed(id)) {
     87         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
     88         error_append_hint(errp, "Identifiers consist of letters, digits, "
     89                           "'-', '.', '_', starting with a letter.\n");
     90         return NULL;
     91     }
     92 
     93     klass = object_class_by_name(type);
     94     if (!klass) {
     95         error_setg(errp, "invalid object type: %s", type);
     96         return NULL;
     97     }
     98 
     99     if (!object_class_dynamic_cast(klass, TYPE_USER_CREATABLE)) {
    100         error_setg(errp, "object type '%s' isn't supported by object-add",
    101                    type);
    102         return NULL;
    103     }
    104 
    105     if (object_class_is_abstract(klass)) {
    106         error_setg(errp, "object type '%s' is abstract", type);
    107         return NULL;
    108     }
    109 
    110     assert(qdict);
    111     obj = object_new(type);
    112     object_set_properties_from_qdict(obj, qdict, v, &local_err);
    113     if (local_err) {
    114         goto out;
    115     }
    116 
    117     if (id != NULL) {
    118         object_property_try_add_child(object_get_objects_root(),
    119                                       id, obj, &local_err);
    120         if (local_err) {
    121             goto out;
    122         }
    123     }
    124 
    125     if (!user_creatable_complete(USER_CREATABLE(obj), &local_err)) {
    126         if (id != NULL) {
    127             object_property_del(object_get_objects_root(), id);
    128         }
    129         goto out;
    130     }
    131 out:
    132     if (local_err) {
    133         error_propagate(errp, local_err);
    134         object_unref(obj);
    135         return NULL;
    136     }
    137     return obj;
    138 }
    139 
    140 void user_creatable_add_qapi(ObjectOptions *options, Error **errp)
    141 {
    142     Visitor *v;
    143     QObject *qobj;
    144     QDict *props;
    145     Object *obj;
    146 
    147     v = qobject_output_visitor_new(&qobj);
    148     visit_type_ObjectOptions(v, NULL, &options, &error_abort);
    149     visit_complete(v, &qobj);
    150     visit_free(v);
    151 
    152     props = qobject_to(QDict, qobj);
    153     qdict_del(props, "qom-type");
    154     qdict_del(props, "id");
    155 
    156     v = qobject_input_visitor_new(QOBJECT(props));
    157     obj = user_creatable_add_type(ObjectType_str(options->qom_type),
    158                                   options->id, props, v, errp);
    159     object_unref(obj);
    160     qobject_unref(qobj);
    161     visit_free(v);
    162 }
    163 
    164 char *object_property_help(const char *name, const char *type,
    165                            QObject *defval, const char *description)
    166 {
    167     GString *str = g_string_new(NULL);
    168 
    169     g_string_append_printf(str, "  %s=<%s>", name, type);
    170     if (description || defval) {
    171         if (str->len < 24) {
    172             g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
    173         }
    174         g_string_append(str, " - ");
    175     }
    176     if (description) {
    177         g_string_append(str, description);
    178     }
    179     if (defval) {
    180         g_autofree char *def_json = g_string_free(qobject_to_json(defval),
    181                                                   false);
    182         g_string_append_printf(str, " (default: %s)", def_json);
    183     }
    184 
    185     return g_string_free(str, false);
    186 }
    187 
    188 static void user_creatable_print_types(void)
    189 {
    190     GSList *l, *list;
    191 
    192     qemu_printf("List of user creatable objects:\n");
    193     list = object_class_get_list_sorted(TYPE_USER_CREATABLE, false);
    194     for (l = list; l != NULL; l = l->next) {
    195         ObjectClass *oc = OBJECT_CLASS(l->data);
    196         qemu_printf("  %s\n", object_class_get_name(oc));
    197     }
    198     g_slist_free(list);
    199 }
    200 
    201 bool type_print_class_properties(const char *type)
    202 {
    203     ObjectClass *klass;
    204     ObjectPropertyIterator iter;
    205     ObjectProperty *prop;
    206     GPtrArray *array;
    207     int i;
    208 
    209     klass = object_class_by_name(type);
    210     if (!klass) {
    211         return false;
    212     }
    213 
    214     array = g_ptr_array_new();
    215     object_class_property_iter_init(&iter, klass);
    216     while ((prop = object_property_iter_next(&iter))) {
    217         if (!prop->set) {
    218             continue;
    219         }
    220 
    221         g_ptr_array_add(array,
    222                         object_property_help(prop->name, prop->type,
    223                                              prop->defval, prop->description));
    224     }
    225     g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
    226     if (array->len > 0) {
    227         qemu_printf("%s options:\n", type);
    228     } else {
    229         qemu_printf("There are no options for %s.\n", type);
    230     }
    231     for (i = 0; i < array->len; i++) {
    232         qemu_printf("%s\n", (char *)array->pdata[i]);
    233     }
    234     g_ptr_array_set_free_func(array, g_free);
    235     g_ptr_array_free(array, true);
    236     return true;
    237 }
    238 
    239 bool user_creatable_print_help(const char *type, QemuOpts *opts)
    240 {
    241     if (is_help_option(type)) {
    242         user_creatable_print_types();
    243         return true;
    244     }
    245 
    246     if (qemu_opt_has_help_opt(opts)) {
    247         return type_print_class_properties(type);
    248     }
    249 
    250     return false;
    251 }
    252 
    253 static void user_creatable_print_help_from_qdict(QDict *args)
    254 {
    255     const char *type = qdict_get_try_str(args, "qom-type");
    256 
    257     if (!type || !type_print_class_properties(type)) {
    258         user_creatable_print_types();
    259     }
    260 }
    261 
    262 ObjectOptions *user_creatable_parse_str(const char *optarg, Error **errp)
    263 {
    264     ERRP_GUARD();
    265     QObject *obj;
    266     bool help;
    267     Visitor *v;
    268     ObjectOptions *options;
    269 
    270     if (optarg[0] == '{') {
    271         obj = qobject_from_json(optarg, errp);
    272         if (!obj) {
    273             return NULL;
    274         }
    275         v = qobject_input_visitor_new(obj);
    276     } else {
    277         QDict *args = keyval_parse(optarg, "qom-type", &help, errp);
    278         if (*errp) {
    279             return NULL;
    280         }
    281         if (help) {
    282             user_creatable_print_help_from_qdict(args);
    283             qobject_unref(args);
    284             return NULL;
    285         }
    286 
    287         obj = QOBJECT(args);
    288         v = qobject_input_visitor_new_keyval(obj);
    289     }
    290 
    291     visit_type_ObjectOptions(v, NULL, &options, errp);
    292     visit_free(v);
    293     qobject_unref(obj);
    294 
    295     return options;
    296 }
    297 
    298 bool user_creatable_add_from_str(const char *optarg, Error **errp)
    299 {
    300     ERRP_GUARD();
    301     ObjectOptions *options;
    302 
    303     options = user_creatable_parse_str(optarg, errp);
    304     if (!options) {
    305         return false;
    306     }
    307 
    308     user_creatable_add_qapi(options, errp);
    309     qapi_free_ObjectOptions(options);
    310     return !*errp;
    311 }
    312 
    313 void user_creatable_process_cmdline(const char *optarg)
    314 {
    315     if (!user_creatable_add_from_str(optarg, &error_fatal)) {
    316         /* Help was printed */
    317         exit(EXIT_SUCCESS);
    318     }
    319 }
    320 
    321 bool user_creatable_del(const char *id, Error **errp)
    322 {
    323     QemuOptsList *opts_list;
    324     Object *container;
    325     Object *obj;
    326 
    327     container = object_get_objects_root();
    328     obj = object_resolve_path_component(container, id);
    329     if (!obj) {
    330         error_setg(errp, "object '%s' not found", id);
    331         return false;
    332     }
    333 
    334     if (!user_creatable_can_be_deleted(USER_CREATABLE(obj))) {
    335         error_setg(errp, "object '%s' is in use, can not be deleted", id);
    336         return false;
    337     }
    338 
    339     /*
    340      * if object was defined on the command-line, remove its corresponding
    341      * option group entry
    342      */
    343     opts_list = qemu_find_opts_err("object", NULL);
    344     if (opts_list) {
    345         qemu_opts_del(qemu_opts_find(opts_list, id));
    346     }
    347 
    348     object_unparent(obj);
    349     return true;
    350 }
    351 
    352 void user_creatable_cleanup(void)
    353 {
    354     object_unparent(object_get_objects_root());
    355 }
    356 
    357 static void register_types(void)
    358 {
    359     static const TypeInfo uc_interface_info = {
    360         .name          = TYPE_USER_CREATABLE,
    361         .parent        = TYPE_INTERFACE,
    362         .class_size = sizeof(UserCreatableClass),
    363     };
    364 
    365     type_register_static(&uc_interface_info);
    366 }
    367 
    368 type_init(register_types)