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 "qom/object_interfaces.h" 8 #include "qemu/help_option.h" 9 #include "qemu/module.h" 10 #include "qemu/option.h" 11 #include "qapi/opts-visitor.h" 12 #include "qemu/config-file.h" 13 14 void user_creatable_complete(UserCreatable *uc, Error **errp) 15 { 16 UserCreatableClass *ucc = USER_CREATABLE_GET_CLASS(uc); 17 18 if (ucc->complete) { 19 ucc->complete(uc, errp); 20 } 21 } 22 23 bool user_creatable_can_be_deleted(UserCreatable *uc) 24 { 25 26 UserCreatableClass *ucc = USER_CREATABLE_GET_CLASS(uc); 27 28 if (ucc->can_be_deleted) { 29 return ucc->can_be_deleted(uc); 30 } else { 31 return true; 32 } 33 } 34 35 Object *user_creatable_add_type(const char *type, const char *id, 36 const QDict *qdict, 37 Visitor *v, Error **errp) 38 { 39 Object *obj; 40 ObjectClass *klass; 41 const QDictEntry *e; 42 Error *local_err = NULL; 43 44 klass = object_class_by_name(type); 45 if (!klass) { 46 error_setg(errp, "invalid object type: %s", type); 47 return NULL; 48 } 49 50 if (!object_class_dynamic_cast(klass, TYPE_USER_CREATABLE)) { 51 error_setg(errp, "object type '%s' isn't supported by object-add", 52 type); 53 return NULL; 54 } 55 56 if (object_class_is_abstract(klass)) { 57 error_setg(errp, "object type '%s' is abstract", type); 58 return NULL; 59 } 60 61 assert(qdict); 62 obj = object_new(type); 63 visit_start_struct(v, NULL, NULL, 0, &local_err); 64 if (local_err) { 65 goto out; 66 } 67 for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { 68 object_property_set(obj, v, e->key, &local_err); 69 if (local_err) { 70 break; 71 } 72 } 73 if (!local_err) { 74 visit_check_struct(v, &local_err); 75 } 76 visit_end_struct(v, NULL); 77 if (local_err) { 78 goto out; 79 } 80 81 if (id != NULL) { 82 object_property_add_child(object_get_objects_root(), 83 id, obj, &local_err); 84 if (local_err) { 85 goto out; 86 } 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 107 Object *user_creatable_add_opts(QemuOpts *opts, Error **errp) 108 { 109 Visitor *v; 110 QDict *pdict; 111 Object *obj; 112 const char *id = qemu_opts_id(opts); 113 char *type = qemu_opt_get_del(opts, "qom-type"); 114 115 if (!type) { 116 error_setg(errp, QERR_MISSING_PARAMETER, "qom-type"); 117 return NULL; 118 } 119 if (!id) { 120 error_setg(errp, QERR_MISSING_PARAMETER, "id"); 121 qemu_opt_set(opts, "qom-type", type, &error_abort); 122 g_free(type); 123 return NULL; 124 } 125 126 qemu_opts_set_id(opts, NULL); 127 pdict = qemu_opts_to_qdict(opts, NULL); 128 129 v = opts_visitor_new(opts); 130 obj = user_creatable_add_type(type, id, pdict, v, errp); 131 visit_free(v); 132 133 qemu_opts_set_id(opts, (char *) id); 134 qemu_opt_set(opts, "qom-type", type, &error_abort); 135 g_free(type); 136 qobject_unref(pdict); 137 return obj; 138 } 139 140 141 int user_creatable_add_opts_foreach(void *opaque, QemuOpts *opts, Error **errp) 142 { 143 bool (*type_opt_predicate)(const char *, QemuOpts *) = opaque; 144 Object *obj = NULL; 145 const char *type; 146 147 type = qemu_opt_get(opts, "qom-type"); 148 if (type && type_opt_predicate && 149 !type_opt_predicate(type, opts)) { 150 return 0; 151 } 152 153 obj = user_creatable_add_opts(opts, errp); 154 if (!obj) { 155 return -1; 156 } 157 object_unref(obj); 158 return 0; 159 } 160 161 bool user_creatable_print_help(const char *type, QemuOpts *opts) 162 { 163 ObjectClass *klass; 164 165 if (is_help_option(type)) { 166 GSList *l, *list; 167 168 printf("List of user creatable objects:\n"); 169 list = object_class_get_list_sorted(TYPE_USER_CREATABLE, false); 170 for (l = list; l != NULL; l = l->next) { 171 ObjectClass *oc = OBJECT_CLASS(l->data); 172 printf(" %s\n", object_class_get_name(oc)); 173 } 174 g_slist_free(list); 175 return true; 176 } 177 178 klass = object_class_by_name(type); 179 if (klass && qemu_opt_has_help_opt(opts)) { 180 ObjectPropertyIterator iter; 181 ObjectProperty *prop; 182 GPtrArray *array = g_ptr_array_new(); 183 int i; 184 185 object_class_property_iter_init(&iter, klass); 186 while ((prop = object_property_iter_next(&iter))) { 187 GString *str; 188 189 if (!prop->set) { 190 continue; 191 } 192 193 str = g_string_new(NULL); 194 g_string_append_printf(str, " %s=<%s>", prop->name, prop->type); 195 if (prop->description) { 196 if (str->len < 24) { 197 g_string_append_printf(str, "%*s", 24 - (int)str->len, ""); 198 } 199 g_string_append_printf(str, " - %s", prop->description); 200 } 201 g_ptr_array_add(array, g_string_free(str, false)); 202 } 203 g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0); 204 if (array->len > 0) { 205 printf("%s options:\n", type); 206 } else { 207 printf("There are no options for %s.\n", type); 208 } 209 for (i = 0; i < array->len; i++) { 210 printf("%s\n", (char *)array->pdata[i]); 211 } 212 g_ptr_array_set_free_func(array, g_free); 213 g_ptr_array_free(array, true); 214 return true; 215 } 216 217 return false; 218 } 219 220 void user_creatable_del(const char *id, Error **errp) 221 { 222 Object *container; 223 Object *obj; 224 225 container = object_get_objects_root(); 226 obj = object_resolve_path_component(container, id); 227 if (!obj) { 228 error_setg(errp, "object '%s' not found", id); 229 return; 230 } 231 232 if (!user_creatable_can_be_deleted(USER_CREATABLE(obj))) { 233 error_setg(errp, "object '%s' is in use, can not be deleted", id); 234 return; 235 } 236 237 /* 238 * if object was defined on the command-line, remove its corresponding 239 * option group entry 240 */ 241 qemu_opts_del(qemu_opts_find(qemu_find_opts_err("object", &error_abort), 242 id)); 243 244 object_unparent(obj); 245 } 246 247 void user_creatable_cleanup(void) 248 { 249 object_unparent(object_get_objects_root()); 250 } 251 252 static void register_types(void) 253 { 254 static const TypeInfo uc_interface_info = { 255 .name = TYPE_USER_CREATABLE, 256 .parent = TYPE_INTERFACE, 257 .class_size = sizeof(UserCreatableClass), 258 }; 259 260 type_register_static(&uc_interface_info); 261 } 262 263 type_init(register_types) 264