qom/object_interfaces.c

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