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 #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 *optarg, Error **errp) 263 { 264 ERRP_GUARD(); 265 QObject *obj; 266 bool help; 267 Visitor *v; 268 ObjectOptions *options; 269 270 if (optarg[0] == '{') { 271 obj = qobject_from_json(optarg, errp); 272 if (!obj) { 273 return NULL; 274 } 275 v = qobject_input_visitor_new(obj); 276 } else { 277 QDict *args = keyval_parse(optarg, "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 *optarg, Error **errp) 299 { 300 ERRP_GUARD(); 301 ObjectOptions *options; 302 303 options = user_creatable_parse_str(optarg, 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 *optarg) 314 { 315 if (!user_creatable_add_from_str(optarg, &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