1 #include "qemu-common.h" 2 #include "qemu/error-report.h" 3 #include "qemu/option.h" 4 #include "qemu/config-file.h" 5 #include "qapi/qmp/qerror.h" 6 #include "hw/qdev.h" 7 #include "qapi/error.h" 8 #include "qmp-commands.h" 9 10 static QemuOptsList *vm_config_groups[32]; 11 static QemuOptsList *drive_config_groups[4]; 12 13 static QemuOptsList *find_list(QemuOptsList **lists, const char *group, 14 Error **errp) 15 { 16 int i; 17 18 for (i = 0; lists[i] != NULL; i++) { 19 if (strcmp(lists[i]->name, group) == 0) 20 break; 21 } 22 if (lists[i] == NULL) { 23 error_set(errp, QERR_INVALID_OPTION_GROUP, group); 24 } 25 return lists[i]; 26 } 27 28 QemuOptsList *qemu_find_opts(const char *group) 29 { 30 QemuOptsList *ret; 31 Error *local_err = NULL; 32 33 ret = find_list(vm_config_groups, group, &local_err); 34 if (local_err) { 35 error_report("%s", error_get_pretty(local_err)); 36 error_free(local_err); 37 } 38 39 return ret; 40 } 41 42 static CommandLineParameterInfoList *query_option_descs(const QemuOptDesc *desc) 43 { 44 CommandLineParameterInfoList *param_list = NULL, *entry; 45 CommandLineParameterInfo *info; 46 int i; 47 48 for (i = 0; desc[i].name != NULL; i++) { 49 info = g_malloc0(sizeof(*info)); 50 info->name = g_strdup(desc[i].name); 51 52 switch (desc[i].type) { 53 case QEMU_OPT_STRING: 54 info->type = COMMAND_LINE_PARAMETER_TYPE_STRING; 55 break; 56 case QEMU_OPT_BOOL: 57 info->type = COMMAND_LINE_PARAMETER_TYPE_BOOLEAN; 58 break; 59 case QEMU_OPT_NUMBER: 60 info->type = COMMAND_LINE_PARAMETER_TYPE_NUMBER; 61 break; 62 case QEMU_OPT_SIZE: 63 info->type = COMMAND_LINE_PARAMETER_TYPE_SIZE; 64 break; 65 } 66 67 if (desc[i].help) { 68 info->has_help = true; 69 info->help = g_strdup(desc[i].help); 70 } 71 72 entry = g_malloc0(sizeof(*entry)); 73 entry->value = info; 74 entry->next = param_list; 75 param_list = entry; 76 } 77 78 return param_list; 79 } 80 81 /* remove repeated entry from the info list */ 82 static void cleanup_infolist(CommandLineParameterInfoList *head) 83 { 84 CommandLineParameterInfoList *pre_entry, *cur, *del_entry; 85 86 cur = head; 87 while (cur->next) { 88 pre_entry = head; 89 while (pre_entry != cur->next) { 90 if (!strcmp(pre_entry->value->name, cur->next->value->name)) { 91 del_entry = cur->next; 92 cur->next = cur->next->next; 93 g_free(del_entry); 94 break; 95 } 96 pre_entry = pre_entry->next; 97 } 98 cur = cur->next; 99 } 100 } 101 102 /* merge the description items of two parameter infolists */ 103 static void connect_infolist(CommandLineParameterInfoList *head, 104 CommandLineParameterInfoList *new) 105 { 106 CommandLineParameterInfoList *cur; 107 108 cur = head; 109 while (cur->next) { 110 cur = cur->next; 111 } 112 cur->next = new; 113 } 114 115 /* access all the local QemuOptsLists for drive option */ 116 static CommandLineParameterInfoList *get_drive_infolist(void) 117 { 118 CommandLineParameterInfoList *head = NULL, *cur; 119 int i; 120 121 for (i = 0; drive_config_groups[i] != NULL; i++) { 122 if (!head) { 123 head = query_option_descs(drive_config_groups[i]->desc); 124 } else { 125 cur = query_option_descs(drive_config_groups[i]->desc); 126 connect_infolist(head, cur); 127 } 128 } 129 cleanup_infolist(head); 130 131 return head; 132 } 133 134 CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option, 135 const char *option, 136 Error **errp) 137 { 138 CommandLineOptionInfoList *conf_list = NULL, *entry; 139 CommandLineOptionInfo *info; 140 int i; 141 142 for (i = 0; vm_config_groups[i] != NULL; i++) { 143 if (!has_option || !strcmp(option, vm_config_groups[i]->name)) { 144 info = g_malloc0(sizeof(*info)); 145 info->option = g_strdup(vm_config_groups[i]->name); 146 if (!strcmp("drive", vm_config_groups[i]->name)) { 147 info->parameters = get_drive_infolist(); 148 } else { 149 info->parameters = 150 query_option_descs(vm_config_groups[i]->desc); 151 } 152 entry = g_malloc0(sizeof(*entry)); 153 entry->value = info; 154 entry->next = conf_list; 155 conf_list = entry; 156 } 157 } 158 159 if (conf_list == NULL) { 160 error_setg(errp, "invalid option name: %s", option); 161 } 162 163 return conf_list; 164 } 165 166 QemuOptsList *qemu_find_opts_err(const char *group, Error **errp) 167 { 168 return find_list(vm_config_groups, group, errp); 169 } 170 171 void qemu_add_drive_opts(QemuOptsList *list) 172 { 173 int entries, i; 174 175 entries = ARRAY_SIZE(drive_config_groups); 176 entries--; /* keep list NULL terminated */ 177 for (i = 0; i < entries; i++) { 178 if (drive_config_groups[i] == NULL) { 179 drive_config_groups[i] = list; 180 return; 181 } 182 } 183 fprintf(stderr, "ran out of space in drive_config_groups"); 184 abort(); 185 } 186 187 void qemu_add_opts(QemuOptsList *list) 188 { 189 int entries, i; 190 191 entries = ARRAY_SIZE(vm_config_groups); 192 entries--; /* keep list NULL terminated */ 193 for (i = 0; i < entries; i++) { 194 if (vm_config_groups[i] == NULL) { 195 vm_config_groups[i] = list; 196 return; 197 } 198 } 199 fprintf(stderr, "ran out of space in vm_config_groups"); 200 abort(); 201 } 202 203 int qemu_set_option(const char *str) 204 { 205 char group[64], id[64], arg[64]; 206 QemuOptsList *list; 207 QemuOpts *opts; 208 int rc, offset; 209 210 rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset); 211 if (rc < 3 || str[offset] != '=') { 212 error_report("can't parse: \"%s\"", str); 213 return -1; 214 } 215 216 list = qemu_find_opts(group); 217 if (list == NULL) { 218 return -1; 219 } 220 221 opts = qemu_opts_find(list, id); 222 if (!opts) { 223 error_report("there is no %s \"%s\" defined", 224 list->name, id); 225 return -1; 226 } 227 228 if (qemu_opt_set(opts, arg, str+offset+1) == -1) { 229 return -1; 230 } 231 return 0; 232 } 233 234 struct ConfigWriteData { 235 QemuOptsList *list; 236 FILE *fp; 237 }; 238 239 static int config_write_opt(const char *name, const char *value, void *opaque) 240 { 241 struct ConfigWriteData *data = opaque; 242 243 fprintf(data->fp, " %s = \"%s\"\n", name, value); 244 return 0; 245 } 246 247 static int config_write_opts(QemuOpts *opts, void *opaque) 248 { 249 struct ConfigWriteData *data = opaque; 250 const char *id = qemu_opts_id(opts); 251 252 if (id) { 253 fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id); 254 } else { 255 fprintf(data->fp, "[%s]\n", data->list->name); 256 } 257 qemu_opt_foreach(opts, config_write_opt, data, 0); 258 fprintf(data->fp, "\n"); 259 return 0; 260 } 261 262 void qemu_config_write(FILE *fp) 263 { 264 struct ConfigWriteData data = { .fp = fp }; 265 QemuOptsList **lists = vm_config_groups; 266 int i; 267 268 fprintf(fp, "# qemu config file\n\n"); 269 for (i = 0; lists[i] != NULL; i++) { 270 data.list = lists[i]; 271 qemu_opts_foreach(data.list, config_write_opts, &data, 0); 272 } 273 } 274 275 int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname) 276 { 277 char line[1024], group[64], id[64], arg[64], value[1024]; 278 Location loc; 279 QemuOptsList *list = NULL; 280 Error *local_err = NULL; 281 QemuOpts *opts = NULL; 282 int res = -1, lno = 0; 283 284 loc_push_none(&loc); 285 while (fgets(line, sizeof(line), fp) != NULL) { 286 loc_set_file(fname, ++lno); 287 if (line[0] == '\n') { 288 /* skip empty lines */ 289 continue; 290 } 291 if (line[0] == '#') { 292 /* comment */ 293 continue; 294 } 295 if (sscanf(line, "[%63s \"%63[^\"]\"]", group, id) == 2) { 296 /* group with id */ 297 list = find_list(lists, group, &local_err); 298 if (local_err) { 299 error_report("%s", error_get_pretty(local_err)); 300 error_free(local_err); 301 goto out; 302 } 303 opts = qemu_opts_create(list, id, 1, NULL); 304 continue; 305 } 306 if (sscanf(line, "[%63[^]]]", group) == 1) { 307 /* group without id */ 308 list = find_list(lists, group, &local_err); 309 if (local_err) { 310 error_report("%s", error_get_pretty(local_err)); 311 error_free(local_err); 312 goto out; 313 } 314 opts = qemu_opts_create(list, NULL, 0, &error_abort); 315 continue; 316 } 317 if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2) { 318 /* arg = value */ 319 if (opts == NULL) { 320 error_report("no group defined"); 321 goto out; 322 } 323 if (qemu_opt_set(opts, arg, value) != 0) { 324 goto out; 325 } 326 continue; 327 } 328 error_report("parse error"); 329 goto out; 330 } 331 if (ferror(fp)) { 332 error_report("error reading file"); 333 goto out; 334 } 335 res = 0; 336 out: 337 loc_pop(&loc); 338 return res; 339 } 340 341 int qemu_read_config_file(const char *filename) 342 { 343 FILE *f = fopen(filename, "r"); 344 int ret; 345 346 if (f == NULL) { 347 return -errno; 348 } 349 350 ret = qemu_config_parse(f, vm_config_groups, filename); 351 fclose(f); 352 353 if (ret == 0) { 354 return 0; 355 } else { 356 return -EINVAL; 357 } 358 } 359 360 static void config_parse_qdict_section(QDict *options, QemuOptsList *opts, 361 Error **errp) 362 { 363 QemuOpts *subopts; 364 QDict *subqdict; 365 QList *list = NULL; 366 Error *local_err = NULL; 367 size_t orig_size, enum_size; 368 char *prefix; 369 370 prefix = g_strdup_printf("%s.", opts->name); 371 qdict_extract_subqdict(options, &subqdict, prefix); 372 g_free(prefix); 373 orig_size = qdict_size(subqdict); 374 if (!orig_size) { 375 goto out; 376 } 377 378 subopts = qemu_opts_create(opts, NULL, 0, &local_err); 379 if (local_err) { 380 error_propagate(errp, local_err); 381 goto out; 382 } 383 384 qemu_opts_absorb_qdict(subopts, subqdict, &local_err); 385 if (local_err) { 386 error_propagate(errp, local_err); 387 goto out; 388 } 389 390 enum_size = qdict_size(subqdict); 391 if (enum_size < orig_size && enum_size) { 392 error_setg(errp, "Unknown option '%s' for [%s]", 393 qdict_first(subqdict)->key, opts->name); 394 goto out; 395 } 396 397 if (enum_size) { 398 /* Multiple, enumerated sections */ 399 QListEntry *list_entry; 400 unsigned i = 0; 401 402 /* Not required anymore */ 403 qemu_opts_del(subopts); 404 405 qdict_array_split(subqdict, &list); 406 if (qdict_size(subqdict)) { 407 error_setg(errp, "Unused option '%s' for [%s]", 408 qdict_first(subqdict)->key, opts->name); 409 goto out; 410 } 411 412 QLIST_FOREACH_ENTRY(list, list_entry) { 413 QDict *section = qobject_to_qdict(qlist_entry_obj(list_entry)); 414 char *opt_name; 415 416 if (!section) { 417 error_setg(errp, "[%s] section (index %u) does not consist of " 418 "keys", opts->name, i); 419 goto out; 420 } 421 422 opt_name = g_strdup_printf("%s.%u", opts->name, i++); 423 subopts = qemu_opts_create(opts, opt_name, 1, &local_err); 424 g_free(opt_name); 425 if (local_err) { 426 error_propagate(errp, local_err); 427 goto out; 428 } 429 430 qemu_opts_absorb_qdict(subopts, section, &local_err); 431 if (local_err) { 432 error_propagate(errp, local_err); 433 qemu_opts_del(subopts); 434 goto out; 435 } 436 437 if (qdict_size(section)) { 438 error_setg(errp, "[%s] section doesn't support the option '%s'", 439 opts->name, qdict_first(section)->key); 440 qemu_opts_del(subopts); 441 goto out; 442 } 443 } 444 } 445 446 out: 447 QDECREF(subqdict); 448 QDECREF(list); 449 } 450 451 void qemu_config_parse_qdict(QDict *options, QemuOptsList **lists, 452 Error **errp) 453 { 454 int i; 455 Error *local_err = NULL; 456 457 for (i = 0; lists[i]; i++) { 458 config_parse_qdict_section(options, lists[i], &local_err); 459 if (local_err) { 460 error_propagate(errp, local_err); 461 return; 462 } 463 } 464 } 465