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