qom/object_interfaces.c

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