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