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