xref: /openbmc/qemu/qom/object_interfaces.c (revision b86c6ba6) 
1 #include "qemu/osdep.h"
2 
3 #include "qemu/cutils.h"
4 #include "qapi/error.h"
5 #include "qapi/qapi-visit-qom.h"
6 #include "qapi/qmp/qobject.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 *str, Error **errp)
263 {
264     ERRP_GUARD();
265     QObject *obj;
266     bool help;
267     Visitor *v;
268     ObjectOptions *options;
269 
270     if (str[0] == '{') {
271         obj = qobject_from_json(str, errp);
272         if (!obj) {
273             return NULL;
274         }
275         v = qobject_input_visitor_new(obj);
276     } else {
277         QDict *args = keyval_parse(str, "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 *str, Error **errp)
299 {
300     ERRP_GUARD();
301     ObjectOptions *options;
302 
303     options = user_creatable_parse_str(str, 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 *cmdline)
314 {
315     if (!user_creatable_add_from_str(cmdline, &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)
369