xref: /openbmc/qemu/qom/object_interfaces.c (revision d2623129) 
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);
87     }
88 
89     user_creatable_complete(USER_CREATABLE(obj), &local_err);
90     if (local_err) {
91         if (id != NULL) {
92             object_property_del(object_get_objects_root(),
93                                 id, &error_abort);
94         }
95         goto out;
96     }
97 out:
98     if (local_err) {
99         error_propagate(errp, local_err);
100         object_unref(obj);
101         return NULL;
102     }
103     return obj;
104 }
105 
106 void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
107 {
108     Visitor *v;
109     Object *obj;
110     g_autofree char *type = NULL;
111     g_autofree char *id = NULL;
112 
113     type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
114     if (!type) {
115         error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
116         return;
117     }
118     qdict_del(qdict, "qom-type");
119 
120     id = g_strdup(qdict_get_try_str(qdict, "id"));
121     if (!id) {
122         error_setg(errp, QERR_MISSING_PARAMETER, "id");
123         return;
124     }
125     qdict_del(qdict, "id");
126 
127     if (keyval) {
128         v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
129     } else {
130         v = qobject_input_visitor_new(QOBJECT(qdict));
131     }
132     obj = user_creatable_add_type(type, id, qdict, v, errp);
133     visit_free(v);
134     object_unref(obj);
135 }
136 
137 Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
138 {
139     Visitor *v;
140     QDict *pdict;
141     Object *obj;
142     const char *id = qemu_opts_id(opts);
143     char *type = qemu_opt_get_del(opts, "qom-type");
144 
145     if (!type) {
146         error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
147         return NULL;
148     }
149     if (!id) {
150         error_setg(errp, QERR_MISSING_PARAMETER, "id");
151         qemu_opt_set(opts, "qom-type", type, &error_abort);
152         g_free(type);
153         return NULL;
154     }
155 
156     qemu_opts_set_id(opts, NULL);
157     pdict = qemu_opts_to_qdict(opts, NULL);
158 
159     v = opts_visitor_new(opts);
160     obj = user_creatable_add_type(type, id, pdict, v, errp);
161     visit_free(v);
162 
163     qemu_opts_set_id(opts, (char *) id);
164     qemu_opt_set(opts, "qom-type", type, &error_abort);
165     g_free(type);
166     qobject_unref(pdict);
167     return obj;
168 }
169 
170 
171 int user_creatable_add_opts_foreach(void *opaque, QemuOpts *opts, Error **errp)
172 {
173     bool (*type_opt_predicate)(const char *, QemuOpts *) = opaque;
174     Object *obj = NULL;
175     const char *type;
176 
177     type = qemu_opt_get(opts, "qom-type");
178     if (type && type_opt_predicate &&
179         !type_opt_predicate(type, opts)) {
180         return 0;
181     }
182 
183     obj = user_creatable_add_opts(opts, errp);
184     if (!obj) {
185         return -1;
186     }
187     object_unref(obj);
188     return 0;
189 }
190 
191 char *object_property_help(const char *name, const char *type,
192                            QObject *defval, const char *description)
193 {
194     GString *str = g_string_new(NULL);
195 
196     g_string_append_printf(str, "  %s=<%s>", name, type);
197     if (description || defval) {
198         if (str->len < 24) {
199             g_string_append_printf(str, "%*s", 24 - (int)str->len, "");
200         }
201         g_string_append(str, " - ");
202     }
203     if (description) {
204         g_string_append(str, description);
205     }
206     if (defval) {
207         g_autofree char *def_json = qstring_free(qobject_to_json(defval), TRUE);
208         g_string_append_printf(str, " (default: %s)", def_json);
209     }
210 
211     return g_string_free(str, false);
212 }
213 
214 bool user_creatable_print_help(const char *type, QemuOpts *opts)
215 {
216     ObjectClass *klass;
217 
218     if (is_help_option(type)) {
219         GSList *l, *list;
220 
221         printf("List of user creatable objects:\n");
222         list = object_class_get_list_sorted(TYPE_USER_CREATABLE, false);
223         for (l = list; l != NULL; l = l->next) {
224             ObjectClass *oc = OBJECT_CLASS(l->data);
225             printf("  %s\n", object_class_get_name(oc));
226         }
227         g_slist_free(list);
228         return true;
229     }
230 
231     klass = object_class_by_name(type);
232     if (klass && qemu_opt_has_help_opt(opts)) {
233         ObjectPropertyIterator iter;
234         ObjectProperty *prop;
235         GPtrArray *array = g_ptr_array_new();
236         int i;
237 
238         object_class_property_iter_init(&iter, klass);
239         while ((prop = object_property_iter_next(&iter))) {
240             if (!prop->set) {
241                 continue;
242             }
243 
244             g_ptr_array_add(array,
245                             object_property_help(prop->name, prop->type,
246                                                  prop->defval, prop->description));
247         }
248         g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
249         if (array->len > 0) {
250             printf("%s options:\n", type);
251         } else {
252             printf("There are no options for %s.\n", type);
253         }
254         for (i = 0; i < array->len; i++) {
255             printf("%s\n", (char *)array->pdata[i]);
256         }
257         g_ptr_array_set_free_func(array, g_free);
258         g_ptr_array_free(array, true);
259         return true;
260     }
261 
262     return false;
263 }
264 
265 void user_creatable_del(const char *id, Error **errp)
266 {
267     Object *container;
268     Object *obj;
269 
270     container = object_get_objects_root();
271     obj = object_resolve_path_component(container, id);
272     if (!obj) {
273         error_setg(errp, "object '%s' not found", id);
274         return;
275     }
276 
277     if (!user_creatable_can_be_deleted(USER_CREATABLE(obj))) {
278         error_setg(errp, "object '%s' is in use, can not be deleted", id);
279         return;
280     }
281 
282     /*
283      * if object was defined on the command-line, remove its corresponding
284      * option group entry
285      */
286     qemu_opts_del(qemu_opts_find(qemu_find_opts_err("object", &error_abort),
287                                  id));
288 
289     object_unparent(obj);
290 }
291 
292 void user_creatable_cleanup(void)
293 {
294     object_unparent(object_get_objects_root());
295 }
296 
297 static void register_types(void)
298 {
299     static const TypeInfo uc_interface_info = {
300         .name          = TYPE_USER_CREATABLE,
301         .parent        = TYPE_INTERFACE,
302         .class_size = sizeof(UserCreatableClass),
303     };
304 
305     type_register_static(&uc_interface_info);
306 }
307 
308 type_init(register_types)
309