[qemu.git] / util / qemu-config.c

#include "qemu/osdep.h"
#include "block/qdict.h" /* for qdict_extract_subqdict() */
#include "qapi/error.h"
#include "qapi/qapi-commands-misc.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qlist.h"
#include "qemu/error-report.h"
#include "qemu/option.h"
#include "qemu/config-file.h"

static QemuOptsList *vm_config_groups[48];
static QemuOptsList *drive_config_groups[5];

static QemuOptsList *find_list(QemuOptsList **lists, const char *group,
                               Error **errp)
{
    int i;

    for (i = 0; lists[i] != NULL; i++) {
        if (strcmp(lists[i]->name, group) == 0)
            break;
    }
    if (lists[i] == NULL) {
        error_setg(errp, "There is no option group '%s'", group);
    }
    return lists[i];
}

QemuOptsList *qemu_find_opts(const char *group)
{
    QemuOptsList *ret;
    Error *local_err = NULL;

    ret = find_list(vm_config_groups, group, &local_err);
    if (local_err) {
        error_report_err(local_err);
    }

    return ret;
}

QemuOpts *qemu_find_opts_singleton(const char *group)
{
    QemuOptsList *list;
    QemuOpts *opts;

    list = qemu_find_opts(group);
    assert(list);
    opts = qemu_opts_find(list, NULL);
    if (!opts) {
        opts = qemu_opts_create(list, NULL, 0, &error_abort);
    }
    return opts;
}

static CommandLineParameterInfoList *query_option_descs(const QemuOptDesc *desc)
{
    CommandLineParameterInfoList *param_list = NULL, *entry;
    CommandLineParameterInfo *info;
    int i;

    for (i = 0; desc[i].name != NULL; i++) {
        info = g_malloc0(sizeof(*info));
        info->name = g_strdup(desc[i].name);

        switch (desc[i].type) {
        case QEMU_OPT_STRING:
            info->type = COMMAND_LINE_PARAMETER_TYPE_STRING;
            break;
        case QEMU_OPT_BOOL:
            info->type = COMMAND_LINE_PARAMETER_TYPE_BOOLEAN;
            break;
        case QEMU_OPT_NUMBER:
            info->type = COMMAND_LINE_PARAMETER_TYPE_NUMBER;
            break;
        case QEMU_OPT_SIZE:
            info->type = COMMAND_LINE_PARAMETER_TYPE_SIZE;
            break;
        }

        if (desc[i].help) {
            info->has_help = true;
            info->help = g_strdup(desc[i].help);
        }
        if (desc[i].def_value_str) {
            info->has_q_default = true;
            info->q_default = g_strdup(desc[i].def_value_str);
        }

        entry = g_malloc0(sizeof(*entry));
        entry->value = info;
        entry->next = param_list;
        param_list = entry;
    }

    return param_list;
}

/* remove repeated entry from the info list */
static void cleanup_infolist(CommandLineParameterInfoList *head)
{
    CommandLineParameterInfoList *pre_entry, *cur, *del_entry;

    cur = head;
    while (cur->next) {
        pre_entry = head;
        while (pre_entry != cur->next) {
            if (!strcmp(pre_entry->value->name, cur->next->value->name)) {
                del_entry = cur->next;
                cur->next = cur->next->next;
                del_entry->next = NULL;
                qapi_free_CommandLineParameterInfoList(del_entry);
                break;
            }
            pre_entry = pre_entry->next;
        }
        cur = cur->next;
    }
}

/* merge the description items of two parameter infolists */
static void connect_infolist(CommandLineParameterInfoList *head,
                             CommandLineParameterInfoList *new)
{
    CommandLineParameterInfoList *cur;

    cur = head;
    while (cur->next) {
        cur = cur->next;
    }
    cur->next = new;
}

/* access all the local QemuOptsLists for drive option */
static CommandLineParameterInfoList *get_drive_infolist(void)
{
    CommandLineParameterInfoList *head = NULL, *cur;
    int i;

    for (i = 0; drive_config_groups[i] != NULL; i++) {
        if (!head) {
            head = query_option_descs(drive_config_groups[i]->desc);
        } else {
            cur = query_option_descs(drive_config_groups[i]->desc);
            connect_infolist(head, cur);
        }
    }
    cleanup_infolist(head);

    return head;
}

/* restore machine options that are now machine's properties */
static QemuOptsList machine_opts = {
    .merge_lists = true,
    .head = QTAILQ_HEAD_INITIALIZER(machine_opts.head),
    .desc = {
        {
            .name = "type",
            .type = QEMU_OPT_STRING,
            .help = "emulated machine"
        },{
            .name = "accel",
            .type = QEMU_OPT_STRING,
            .help = "accelerator list",
        },{
            .name = "kernel_irqchip",
            .type = QEMU_OPT_BOOL,
            .help = "use KVM in-kernel irqchip",
        },{
            .name = "kvm_shadow_mem",
            .type = QEMU_OPT_SIZE,
            .help = "KVM shadow MMU size",
        },{
            .name = "kernel",
            .type = QEMU_OPT_STRING,
            .help = "Linux kernel image file",
        },{
            .name = "initrd",
            .type = QEMU_OPT_STRING,
            .help = "Linux initial ramdisk file",
        },{
            .name = "append",
            .type = QEMU_OPT_STRING,
            .help = "Linux kernel command line",
        },{
            .name = "dtb",
            .type = QEMU_OPT_STRING,
            .help = "Linux kernel device tree file",
        },{
            .name = "dumpdtb",
            .type = QEMU_OPT_STRING,
            .help = "Dump current dtb to a file and quit",
        },{
            .name = "phandle_start",
            .type = QEMU_OPT_NUMBER,
            .help = "The first phandle ID we may generate dynamically",
        },{
            .name = "dt_compatible",
            .type = QEMU_OPT_STRING,
            .help = "Overrides the \"compatible\" property of the dt root node",
        },{
            .name = "dump-guest-core",
            .type = QEMU_OPT_BOOL,
            .help = "Include guest memory in  a core dump",
        },{
            .name = "mem-merge",
            .type = QEMU_OPT_BOOL,
            .help = "enable/disable memory merge support",
        },{
            .name = "usb",
            .type = QEMU_OPT_BOOL,
            .help = "Set on/off to enable/disable usb",
        },{
            .name = "firmware",
            .type = QEMU_OPT_STRING,
            .help = "firmware image",
        },{
            .name = "iommu",
            .type = QEMU_OPT_BOOL,
            .help = "Set on/off to enable/disable Intel IOMMU (VT-d)",
        },{
            .name = "suppress-vmdesc",
            .type = QEMU_OPT_BOOL,
            .help = "Set on to disable self-describing migration",
        },{
            .name = "aes-key-wrap",
            .type = QEMU_OPT_BOOL,
            .help = "enable/disable AES key wrapping using the CPACF wrapping key",
        },{
            .name = "dea-key-wrap",
            .type = QEMU_OPT_BOOL,
            .help = "enable/disable DEA key wrapping using the CPACF wrapping key",
        },{
            .name = "loadparm",
            .type = QEMU_OPT_STRING,
            .help = "Up to 8 chars in set of [A-Za-z0-9. ](lower case chars"
                    " converted to upper case) to pass to machine"
                    " loader, boot manager, and guest kernel",
        },
        { /* End of list */ }
    }
};

CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option,
                                                          const char *option,
                                                          Error **errp)
{
    CommandLineOptionInfoList *conf_list = NULL, *entry;
    CommandLineOptionInfo *info;
    int i;

    for (i = 0; vm_config_groups[i] != NULL; i++) {
        if (!has_option || !strcmp(option, vm_config_groups[i]->name)) {
            info = g_malloc0(sizeof(*info));
            info->option = g_strdup(vm_config_groups[i]->name);
            if (!strcmp("drive", vm_config_groups[i]->name)) {
                info->parameters = get_drive_infolist();
            } else if (!strcmp("machine", vm_config_groups[i]->name)) {
                info->parameters = query_option_descs(machine_opts.desc);
            } else {
                info->parameters =
                    query_option_descs(vm_config_groups[i]->desc);
            }
            entry = g_malloc0(sizeof(*entry));
            entry->value = info;
            entry->next = conf_list;
            conf_list = entry;
        }
    }

    if (conf_list == NULL) {
        error_setg(errp, "invalid option name: %s", option);
    }

    return conf_list;
}

QemuOptsList *qemu_find_opts_err(const char *group, Error **errp)
{
    return find_list(vm_config_groups, group, errp);
}

void qemu_add_drive_opts(QemuOptsList *list)
{
    int entries, i;

    entries = ARRAY_SIZE(drive_config_groups);
    entries--; /* keep list NULL terminated */
    for (i = 0; i < entries; i++) {
        if (drive_config_groups[i] == NULL) {
            drive_config_groups[i] = list;
            return;
        }
    }
    fprintf(stderr, "ran out of space in drive_config_groups");
    abort();
}

void qemu_add_opts(QemuOptsList *list)
{
    int entries, i;

    entries = ARRAY_SIZE(vm_config_groups);
    entries--; /* keep list NULL terminated */
    for (i = 0; i < entries; i++) {
        if (vm_config_groups[i] == NULL) {
            vm_config_groups[i] = list;
            return;
        }
    }
    fprintf(stderr, "ran out of space in vm_config_groups");
    abort();
}

int qemu_set_option(const char *str)
{
    Error *local_err = NULL;
    char group[64], id[64], arg[64];
    QemuOptsList *list;
    QemuOpts *opts;
    int rc, offset;

    rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset);
    if (rc < 3 || str[offset] != '=') {
        error_report("can't parse: \"%s\"", str);
        return -1;
    }

    list = qemu_find_opts(group);
    if (list == NULL) {
        return -1;
    }

    opts = qemu_opts_find(list, id);
    if (!opts) {
        error_report("there is no %s \"%s\" defined",
                     list->name, id);
        return -1;
    }

    qemu_opt_set(opts, arg, str + offset + 1, &local_err);
    if (local_err) {
        error_report_err(local_err);
        return -1;
    }
    return 0;
}

struct ConfigWriteData {
    QemuOptsList *list;
    FILE *fp;
};

static int config_write_opt(void *opaque, const char *name, const char *value,
                            Error **errp)
{
    struct ConfigWriteData *data = opaque;

    fprintf(data->fp, "  %s = \"%s\"\n", name, value);
    return 0;
}

static int config_write_opts(void *opaque, QemuOpts *opts, Error **errp)
{
    struct ConfigWriteData *data = opaque;
    const char *id = qemu_opts_id(opts);

    if (id) {
        fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id);
    } else {
        fprintf(data->fp, "[%s]\n", data->list->name);
    }
    qemu_opt_foreach(opts, config_write_opt, data, NULL);
    fprintf(data->fp, "\n");
    return 0;
}

void qemu_config_write(FILE *fp)
{
    struct ConfigWriteData data = { .fp = fp };
    QemuOptsList **lists = vm_config_groups;
    int i;

    fprintf(fp, "# qemu config file\n\n");
    for (i = 0; lists[i] != NULL; i++) {
        data.list = lists[i];
        qemu_opts_foreach(data.list, config_write_opts, &data, NULL);
    }
}

/* Returns number of config groups on success, -errno on error */
int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname)
{
    char line[1024], group[64], id[64], arg[64], value[1024];
    Location loc;
    QemuOptsList *list = NULL;
    Error *local_err = NULL;
    QemuOpts *opts = NULL;
    int res = -EINVAL, lno = 0;
    int count = 0;

    loc_push_none(&loc);
    while (fgets(line, sizeof(line), fp) != NULL) {
        loc_set_file(fname, ++lno);
        if (line[0] == '\n') {
            /* skip empty lines */
            continue;
        }
        if (line[0] == '#') {
            /* comment */
            continue;
        }
        if (sscanf(line, "[%63s \"%63[^\"]\"]", group, id) == 2) {
            /* group with id */
            list = find_list(lists, group, &local_err);
            if (local_err) {
                error_report_err(local_err);
                goto out;
            }
            opts = qemu_opts_create(list, id, 1, NULL);
            count++;
            continue;
        }
        if (sscanf(line, "[%63[^]]]", group) == 1) {
            /* group without id */
            list = find_list(lists, group, &local_err);
            if (local_err) {
                error_report_err(local_err);
                goto out;
            }
            opts = qemu_opts_create(list, NULL, 0, &error_abort);
            count++;
            continue;
        }
        value[0] = '\0';
        if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2 ||
            sscanf(line, " %63s = \"\"", arg) == 1) {
            /* arg = value */
            if (opts == NULL) {
                error_report("no group defined");
                goto out;
            }
            qemu_opt_set(opts, arg, value, &local_err);
            if (local_err) {
                error_report_err(local_err);
                goto out;
            }
            continue;
        }
        error_report("parse error");
        goto out;
    }
    if (ferror(fp)) {
        error_report("error reading file");
        goto out;
    }
    res = count;
out:
    loc_pop(&loc);
    return res;
}

int qemu_read_config_file(const char *filename)
{
    FILE *f = fopen(filename, "r");
    int ret;

    if (f == NULL) {
        return -errno;
    }

    ret = qemu_config_parse(f, vm_config_groups, filename);
    fclose(f);
    return ret;
}

static void config_parse_qdict_section(QDict *options, QemuOptsList *opts,
                                       Error **errp)
{
    QemuOpts *subopts;
    QDict *subqdict;
    QList *list = NULL;
    Error *local_err = NULL;
    size_t orig_size, enum_size;
    char *prefix;

    prefix = g_strdup_printf("%s.", opts->name);
    qdict_extract_subqdict(options, &subqdict, prefix);
    g_free(prefix);
    orig_size = qdict_size(subqdict);
    if (!orig_size) {
        goto out;
    }

    subopts = qemu_opts_create(opts, NULL, 0, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        goto out;
    }

    qemu_opts_absorb_qdict(subopts, subqdict, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        goto out;
    }

    enum_size = qdict_size(subqdict);
    if (enum_size < orig_size && enum_size) {
        error_setg(errp, "Unknown option '%s' for [%s]",
                   qdict_first(subqdict)->key, opts->name);
        goto out;
    }

    if (enum_size) {
        /* Multiple, enumerated sections */
        QListEntry *list_entry;
        unsigned i = 0;

        /* Not required anymore */
        qemu_opts_del(subopts);

        qdict_array_split(subqdict, &list);
        if (qdict_size(subqdict)) {
            error_setg(errp, "Unused option '%s' for [%s]",
                       qdict_first(subqdict)->key, opts->name);
            goto out;
        }

        QLIST_FOREACH_ENTRY(list, list_entry) {
            QDict *section = qobject_to(QDict, qlist_entry_obj(list_entry));
            char *opt_name;

            if (!section) {
                error_setg(errp, "[%s] section (index %u) does not consist of "
                           "keys", opts->name, i);
                goto out;
            }

            opt_name = g_strdup_printf("%s.%u", opts->name, i++);
            subopts = qemu_opts_create(opts, opt_name, 1, &local_err);
            g_free(opt_name);
            if (local_err) {
                error_propagate(errp, local_err);
                goto out;
            }

            qemu_opts_absorb_qdict(subopts, section, &local_err);
            if (local_err) {
                error_propagate(errp, local_err);
                qemu_opts_del(subopts);
                goto out;
            }

            if (qdict_size(section)) {
                error_setg(errp, "[%s] section doesn't support the option '%s'",
                           opts->name, qdict_first(section)->key);
                qemu_opts_del(subopts);
                goto out;
            }
        }
    }

out:
    qobject_unref(subqdict);
    qobject_unref(list);
}

void qemu_config_parse_qdict(QDict *options, QemuOptsList **lists,
                             Error **errp)
{
    int i;
    Error *local_err = NULL;

    for (i = 0; lists[i]; i++) {
        config_parse_qdict_section(options, lists[i], &local_err);
        if (local_err) {
            error_propagate(errp, local_err);
            return;
        }
    }
}
Commit	Line	Data
aafd7584	1	#include "qemu/osdep.h"
609f45ea	2	#include "block/qdict.h" /* for qdict_extract_subqdict() */
e688df6b	3	#include "qapi/error.h"
112ed241	4	#include "qapi/qapi-commands-misc.h"
452fcdbc	5	#include "qapi/qmp/qdict.h"
47e6b297	6	#include "qapi/qmp/qlist.h"
1de7afc9 PB	7	#include "qemu/error-report.h"
	8	#include "qemu/option.h"
	9	#include "qemu/config-file.h"
7282a033	10
1ceaefbd	11	static QemuOptsList *vm_config_groups[48];
c5f3014b	12	static QemuOptsList *drive_config_groups[5];
d058fe03	13
2ac20613 LC	14	static QemuOptsList find_list(QemuOptsList lists, const char group,
2ac20613 LC	15	Error **errp)
ddc97855 GH	16	{
	17	int i;
	18
	19	for (i = 0; lists[i] != NULL; i++) {
	20	if (strcmp(lists[i]->name, group) == 0)
	21	break;
	22	}
	23	if (lists[i] == NULL) {
f231b88d	24	error_setg(errp, "There is no option group '%s'", group);
ddc97855 GH	25	}
	26	return lists[i];
	27	}
	28
490b648e KW	29	QemuOptsList qemu_find_opts(const char group)
490b648e KW	30	{
2ac20613 LC	31	QemuOptsList *ret;
	32	Error *local_err = NULL;
	33
	34	ret = find_list(vm_config_groups, group, &local_err);
84d18f06	35	if (local_err) {
565f65d2	36	error_report_err(local_err);
2ac20613 LC	37	}
	38
	39	return ret;
490b648e KW	40	}
490b648e KW	41
e96e5ae8 PB	42	QemuOpts qemu_find_opts_singleton(const char group)
	43	{
	44	QemuOptsList *list;
	45	QemuOpts *opts;
	46
	47	list = qemu_find_opts(group);
	48	assert(list);
	49	opts = qemu_opts_find(list, NULL);
	50	if (!opts) {
	51	opts = qemu_opts_create(list, NULL, 0, &error_abort);
	52	}
	53	return opts;
	54	}
	55
1f8f987d AK	56	static CommandLineParameterInfoList query_option_descs(const QemuOptDesc desc)
	57	{
	58	CommandLineParameterInfoList param_list = NULL, entry;
	59	CommandLineParameterInfo *info;
	60	int i;
	61
	62	for (i = 0; desc[i].name != NULL; i++) {
	63	info = g_malloc0(sizeof(*info));
	64	info->name = g_strdup(desc[i].name);
	65
	66	switch (desc[i].type) {
	67	case QEMU_OPT_STRING:
	68	info->type = COMMAND_LINE_PARAMETER_TYPE_STRING;
	69	break;
	70	case QEMU_OPT_BOOL:
	71	info->type = COMMAND_LINE_PARAMETER_TYPE_BOOLEAN;
	72	break;
	73	case QEMU_OPT_NUMBER:
	74	info->type = COMMAND_LINE_PARAMETER_TYPE_NUMBER;
	75	break;
	76	case QEMU_OPT_SIZE:
	77	info->type = COMMAND_LINE_PARAMETER_TYPE_SIZE;
	78	break;
	79	}
	80
	81	if (desc[i].help) {
	82	info->has_help = true;
	83	info->help = g_strdup(desc[i].help);
	84	}
e36af94f CL	85	if (desc[i].def_value_str) {
	86	info->has_q_default = true;
	87	info->q_default = g_strdup(desc[i].def_value_str);
	88	}
1f8f987d AK	89
	90	entry = g_malloc0(sizeof(*entry));
	91	entry->value = info;
	92	entry->next = param_list;
	93	param_list = entry;
	94	}
	95
	96	return param_list;
	97	}
	98
968854c8 AK	99	/* remove repeated entry from the info list */
	100	static void cleanup_infolist(CommandLineParameterInfoList *head)
	101	{
	102	CommandLineParameterInfoList pre_entry, cur, *del_entry;
	103
	104	cur = head;
	105	while (cur->next) {
	106	pre_entry = head;
	107	while (pre_entry != cur->next) {
	108	if (!strcmp(pre_entry->value->name, cur->next->value->name)) {
	109	del_entry = cur->next;
	110	cur->next = cur->next->next;
b11e20fb MAL	111	del_entry->next = NULL;
b11e20fb MAL	112	qapi_free_CommandLineParameterInfoList(del_entry);
968854c8 AK	113	break;
	114	}
	115	pre_entry = pre_entry->next;
	116	}
	117	cur = cur->next;
	118	}
	119	}
	120
	121	/* merge the description items of two parameter infolists */
	122	static void connect_infolist(CommandLineParameterInfoList *head,
	123	CommandLineParameterInfoList *new)
	124	{
	125	CommandLineParameterInfoList *cur;
	126
	127	cur = head;
	128	while (cur->next) {
	129	cur = cur->next;
	130	}
	131	cur->next = new;
	132	}
	133
	134	/* access all the local QemuOptsLists for drive option */
	135	static CommandLineParameterInfoList *get_drive_infolist(void)
	136	{
	137	CommandLineParameterInfoList head = NULL, cur;
	138	int i;
	139
	140	for (i = 0; drive_config_groups[i] != NULL; i++) {
	141	if (!head) {
	142	head = query_option_descs(drive_config_groups[i]->desc);
	143	} else {
	144	cur = query_option_descs(drive_config_groups[i]->desc);
	145	connect_infolist(head, cur);
	146	}
	147	}
	148	cleanup_infolist(head);
	149
	150	return head;
	151	}
	152
0a7cf217 MA	153	/* restore machine options that are now machine's properties */
	154	static QemuOptsList machine_opts = {
	155	.merge_lists = true,
	156	.head = QTAILQ_HEAD_INITIALIZER(machine_opts.head),
	157	.desc = {
	158	{
	159	.name = "type",
	160	.type = QEMU_OPT_STRING,
	161	.help = "emulated machine"
	162	},{
	163	.name = "accel",
	164	.type = QEMU_OPT_STRING,
	165	.help = "accelerator list",
	166	},{
	167	.name = "kernel_irqchip",
	168	.type = QEMU_OPT_BOOL,
	169	.help = "use KVM in-kernel irqchip",
	170	},{
	171	.name = "kvm_shadow_mem",
	172	.type = QEMU_OPT_SIZE,
	173	.help = "KVM shadow MMU size",
	174	},{
	175	.name = "kernel",
	176	.type = QEMU_OPT_STRING,
	177	.help = "Linux kernel image file",
	178	},{
	179	.name = "initrd",
	180	.type = QEMU_OPT_STRING,
	181	.help = "Linux initial ramdisk file",
	182	},{
	183	.name = "append",
	184	.type = QEMU_OPT_STRING,
	185	.help = "Linux kernel command line",
	186	},{
	187	.name = "dtb",
	188	.type = QEMU_OPT_STRING,
	189	.help = "Linux kernel device tree file",
	190	},{
	191	.name = "dumpdtb",
	192	.type = QEMU_OPT_STRING,
	193	.help = "Dump current dtb to a file and quit",
	194	},{
	195	.name = "phandle_start",
	196	.type = QEMU_OPT_NUMBER,
	197	.help = "The first phandle ID we may generate dynamically",
	198	},{
	199	.name = "dt_compatible",
	200	.type = QEMU_OPT_STRING,
	201	.help = "Overrides the \"compatible\" property of the dt root node",
	202	},{
	203	.name = "dump-guest-core",
	204	.type = QEMU_OPT_BOOL,
	205	.help = "Include guest memory in a core dump",
	206	},{
	207	.name = "mem-merge",
	208	.type = QEMU_OPT_BOOL,
	209	.help = "enable/disable memory merge support",
	210	},{
	211	.name = "usb",
	212	.type = QEMU_OPT_BOOL,
	213	.help = "Set on/off to enable/disable usb",
	214	},{
	215	.name = "firmware",
	216	.type = QEMU_OPT_STRING,
217	.help = "firmware image",
218	},{
219	.name = "iommu",
220	.type = QEMU_OPT_BOOL,
221	.help = "Set on/off to enable/disable Intel IOMMU (VT-d)",
222	},{
223	.name = "suppress-vmdesc",
224	.type = QEMU_OPT_BOOL,
225	.help = "Set on to disable self-describing migration",
5bcfa0c5 TK	226	},{
	227	.name = "aes-key-wrap",
	228	.type = QEMU_OPT_BOOL,
	229	.help = "enable/disable AES key wrapping using the CPACF wrapping key",
	230	},{
	231	.name = "dea-key-wrap",
	232	.type = QEMU_OPT_BOOL,
	233	.help = "enable/disable DEA key wrapping using the CPACF wrapping key",
5559716c FA	234	},{
	235	.name = "loadparm",
	236	.type = QEMU_OPT_STRING,
	237	.help = "Up to 8 chars in set of [A-Za-z0-9. ](lower case chars"
	238	" converted to upper case) to pass to machine"
	239	" loader, boot manager, and guest kernel",
0a7cf217 MA	240	},
	241	{ /* End of list */ }
	242	}
	243	};
	244
1f8f987d AK	245	CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option,
	246	const char *option,
	247	Error **errp)
	248	{
	249	CommandLineOptionInfoList conf_list = NULL, entry;
	250	CommandLineOptionInfo *info;
	251	int i;
	252
	253	for (i = 0; vm_config_groups[i] != NULL; i++) {
	254	if (!has_option \|\| !strcmp(option, vm_config_groups[i]->name)) {
	255	info = g_malloc0(sizeof(*info));
	256	info->option = g_strdup(vm_config_groups[i]->name);
968854c8 AK	257	if (!strcmp("drive", vm_config_groups[i]->name)) {
968854c8 AK	258	info->parameters = get_drive_infolist();
0a7cf217 MA	259	} else if (!strcmp("machine", vm_config_groups[i]->name)) {
0a7cf217 MA	260	info->parameters = query_option_descs(machine_opts.desc);
968854c8 AK	261	} else {
	262	info->parameters =
	263	query_option_descs(vm_config_groups[i]->desc);
	264	}
1f8f987d AK	265	entry = g_malloc0(sizeof(*entry));
	266	entry->value = info;
	267	entry->next = conf_list;
	268	conf_list = entry;
	269	}
	270	}
	271
	272	if (conf_list == NULL) {
	273	error_setg(errp, "invalid option name: %s", option);
	274	}
	275
	276	return conf_list;
	277	}
	278
60d5666f LC	279	QemuOptsList qemu_find_opts_err(const char group, Error **errp)
	280	{
	281	return find_list(vm_config_groups, group, errp);
	282	}
	283
968854c8 AK	284	void qemu_add_drive_opts(QemuOptsList *list)
	285	{
	286	int entries, i;
	287
	288	entries = ARRAY_SIZE(drive_config_groups);
	289	entries--; /* keep list NULL terminated */
	290	for (i = 0; i < entries; i++) {
	291	if (drive_config_groups[i] == NULL) {
	292	drive_config_groups[i] = list;
	293	return;
	294	}
	295	}
	296	fprintf(stderr, "ran out of space in drive_config_groups");
	297	abort();
	298	}
	299
dfe795e7 GH	300	void qemu_add_opts(QemuOptsList *list)
	301	{
	302	int entries, i;
	303
	304	entries = ARRAY_SIZE(vm_config_groups);
	305	entries--; /* keep list NULL terminated */
	306	for (i = 0; i < entries; i++) {
	307	if (vm_config_groups[i] == NULL) {
	308	vm_config_groups[i] = list;
	309	return;
	310	}
	311	}
	312	fprintf(stderr, "ran out of space in vm_config_groups");
	313	abort();
	314	}
	315
d058fe03 GH	316	int qemu_set_option(const char *str)
d058fe03 GH	317	{
f43e47db	318	Error *local_err = NULL;
d058fe03	319	char group[64], id[64], arg[64];
ddc97855	320	QemuOptsList *list;
d058fe03	321	QemuOpts *opts;
ddc97855	322	int rc, offset;
d058fe03 GH	323
	324	rc = sscanf(str, "%63[^.].%63[^.].%63[^=]%n", group, id, arg, &offset);
	325	if (rc < 3 \|\| str[offset] != '=') {
1ecda02b	326	error_report("can't parse: \"%s\"", str);
d058fe03 GH	327	return -1;
	328	}
	329
304329ee	330	list = qemu_find_opts(group);
ddc97855	331	if (list == NULL) {
d058fe03 GH	332	return -1;
	333	}
	334
ddc97855	335	opts = qemu_opts_find(list, id);
d058fe03	336	if (!opts) {
1ecda02b MA	337	error_report("there is no %s \"%s\" defined",
1ecda02b MA	338	list->name, id);
d058fe03 GH	339	return -1;
	340	}
	341
f43e47db MA	342	qemu_opt_set(opts, arg, str + offset + 1, &local_err);
	343	if (local_err) {
	344	error_report_err(local_err);
d058fe03 GH	345	return -1;
	346	}
	347	return 0;
	348	}
	349
9d993394 GH	350	struct ConfigWriteData {
	351	QemuOptsList *list;
	352	FILE *fp;
	353	};
	354
71df1d83 MA	355	static int config_write_opt(void opaque, const char name, const char *value,
71df1d83 MA	356	Error **errp)
9d993394 GH	357	{
	358	struct ConfigWriteData *data = opaque;
	359
	360	fprintf(data->fp, " %s = \"%s\"\n", name, value);
	361	return 0;
	362	}
	363
28d0de7a	364	static int config_write_opts(void opaque, QemuOpts opts, Error **errp)
9d993394 GH	365	{
	366	struct ConfigWriteData *data = opaque;
	367	const char *id = qemu_opts_id(opts);
	368
	369	if (id) {
	370	fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id);
	371	} else {
	372	fprintf(data->fp, "[%s]\n", data->list->name);
	373	}
71df1d83	374	qemu_opt_foreach(opts, config_write_opt, data, NULL);
9d993394 GH	375	fprintf(data->fp, "\n");
	376	return 0;
	377	}
	378
	379	void qemu_config_write(FILE *fp)
	380	{
	381	struct ConfigWriteData data = { .fp = fp };
490b648e	382	QemuOptsList **lists = vm_config_groups;
9d993394 GH	383	int i;
	384
	385	fprintf(fp, "# qemu config file\n\n");
	386	for (i = 0; lists[i] != NULL; i++) {
	387	data.list = lists[i];
28d0de7a	388	qemu_opts_foreach(data.list, config_write_opts, &data, NULL);
9d993394 GH	389	}
9d993394 GH	390	}
42262ba8	391
e5766d6e	392	/* Returns number of config groups on success, -errno on error */
490b648e	393	int qemu_config_parse(FILE fp, QemuOptsList lists, const char fname)
42262ba8 GH	394	{
42262ba8 GH	395	char line[1024], group[64], id[64], arg[64], value[1024];
cf5a65aa	396	Location loc;
42262ba8	397	QemuOptsList *list = NULL;
2ac20613	398	Error *local_err = NULL;
42262ba8	399	QemuOpts *opts = NULL;
e5766d6e EH	400	int res = -EINVAL, lno = 0;
e5766d6e EH	401	int count = 0;
42262ba8	402
cf5a65aa	403	loc_push_none(&loc);
42262ba8	404	while (fgets(line, sizeof(line), fp) != NULL) {
cf5a65aa	405	loc_set_file(fname, ++lno);
42262ba8 GH	406	if (line[0] == '\n') {
	407	/* skip empty lines */
	408	continue;
	409	}
	410	if (line[0] == '#') {
	411	/* comment */
	412	continue;
	413	}
	414	if (sscanf(line, "[%63s \"%63[^\"]\"]", group, id) == 2) {
	415	/* group with id */
2ac20613	416	list = find_list(lists, group, &local_err);
84d18f06	417	if (local_err) {
565f65d2	418	error_report_err(local_err);
cf5a65aa	419	goto out;
2ac20613	420	}
8be7e7e4	421	opts = qemu_opts_create(list, id, 1, NULL);
e5766d6e	422	count++;
42262ba8 GH	423	continue;
	424	}
	425	if (sscanf(line, "[%63[^]]]", group) == 1) {
	426	/* group without id */
2ac20613	427	list = find_list(lists, group, &local_err);
84d18f06	428	if (local_err) {
565f65d2	429	error_report_err(local_err);
cf5a65aa	430	goto out;
2ac20613	431	}
87ea75d5	432	opts = qemu_opts_create(list, NULL, 0, &error_abort);
e5766d6e	433	count++;
42262ba8 GH	434	continue;
42262ba8 GH	435	}
d9f7e29e EH	436	value[0] = '\0';
	437	if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2 \|\|
	438	sscanf(line, " %63s = \"\"", arg) == 1) {
42262ba8 GH	439	/* arg = value */
42262ba8 GH	440	if (opts == NULL) {
cf5a65aa MA	441	error_report("no group defined");
cf5a65aa MA	442	goto out;
42262ba8	443	}
f43e47db MA	444	qemu_opt_set(opts, arg, value, &local_err);
	445	if (local_err) {
	446	error_report_err(local_err);
cf5a65aa	447	goto out;
42262ba8 GH	448	}
	449	continue;
	450	}
cf5a65aa MA	451	error_report("parse error");
cf5a65aa MA	452	goto out;
42262ba8	453	}
ef82516d MA	454	if (ferror(fp)) {
	455	error_report("error reading file");
	456	goto out;
	457	}
e5766d6e	458	res = count;
cf5a65aa MA	459	out:
	460	loc_pop(&loc);
	461	return res;
42262ba8	462	}
dcfb0939 KW	463
	464	int qemu_read_config_file(const char *filename)
	465	{
	466	FILE *f = fopen(filename, "r");
019e78ba KW	467	int ret;
019e78ba KW	468
dcfb0939 KW	469	if (f == NULL) {
	470	return -errno;
	471	}
	472
019e78ba	473	ret = qemu_config_parse(f, vm_config_groups, filename);
dcfb0939	474	fclose(f);
e5766d6e	475	return ret;
dcfb0939	476	}
adf5c449 HR	477
	478	static void config_parse_qdict_section(QDict options, QemuOptsList opts,
	479	Error **errp)
	480	{
	481	QemuOpts *subopts;
	482	QDict *subqdict;
	483	QList *list = NULL;
	484	Error *local_err = NULL;
	485	size_t orig_size, enum_size;
	486	char *prefix;
	487
	488	prefix = g_strdup_printf("%s.", opts->name);
	489	qdict_extract_subqdict(options, &subqdict, prefix);
	490	g_free(prefix);
	491	orig_size = qdict_size(subqdict);
	492	if (!orig_size) {
	493	goto out;
	494	}
	495
	496	subopts = qemu_opts_create(opts, NULL, 0, &local_err);
84d18f06	497	if (local_err) {
adf5c449 HR	498	error_propagate(errp, local_err);
	499	goto out;
	500	}
	501
	502	qemu_opts_absorb_qdict(subopts, subqdict, &local_err);
84d18f06	503	if (local_err) {
adf5c449 HR	504	error_propagate(errp, local_err);
	505	goto out;
	506	}
	507
	508	enum_size = qdict_size(subqdict);
	509	if (enum_size < orig_size && enum_size) {
	510	error_setg(errp, "Unknown option '%s' for [%s]",
	511	qdict_first(subqdict)->key, opts->name);
	512	goto out;
	513	}
	514
	515	if (enum_size) {
	516	/* Multiple, enumerated sections */
	517	QListEntry *list_entry;
	518	unsigned i = 0;
	519
	520	/* Not required anymore */
	521	qemu_opts_del(subopts);
	522
	523	qdict_array_split(subqdict, &list);
	524	if (qdict_size(subqdict)) {
	525	error_setg(errp, "Unused option '%s' for [%s]",
	526	qdict_first(subqdict)->key, opts->name);
	527	goto out;
	528	}
	529
	530	QLIST_FOREACH_ENTRY(list, list_entry) {
7dc847eb	531	QDict *section = qobject_to(QDict, qlist_entry_obj(list_entry));
adf5c449 HR	532	char *opt_name;
adf5c449 HR	533
ae39c4b2 HR	534	if (!section) {
	535	error_setg(errp, "[%s] section (index %u) does not consist of "
	536	"keys", opts->name, i);
	537	goto out;
	538	}
	539
adf5c449 HR	540	opt_name = g_strdup_printf("%s.%u", opts->name, i++);
	541	subopts = qemu_opts_create(opts, opt_name, 1, &local_err);
	542	g_free(opt_name);
84d18f06	543	if (local_err) {
adf5c449 HR	544	error_propagate(errp, local_err);
	545	goto out;
	546	}
	547
	548	qemu_opts_absorb_qdict(subopts, section, &local_err);
84d18f06	549	if (local_err) {
adf5c449 HR	550	error_propagate(errp, local_err);
	551	qemu_opts_del(subopts);
	552	goto out;
	553	}
	554
	555	if (qdict_size(section)) {
	556	error_setg(errp, "[%s] section doesn't support the option '%s'",
	557	opts->name, qdict_first(section)->key);
	558	qemu_opts_del(subopts);
	559	goto out;
	560	}
	561	}
	562	}
	563
	564	out:
cb3e7f08 MAL	565	qobject_unref(subqdict);
cb3e7f08 MAL	566	qobject_unref(list);
adf5c449 HR	567	}
	568
	569	void qemu_config_parse_qdict(QDict options, QemuOptsList *lists,
	570	Error **errp)
	571	{
	572	int i;
	573	Error *local_err = NULL;
	574
	575	for (i = 0; lists[i]; i++) {
	576	config_parse_qdict_section(options, lists[i], &local_err);
84d18f06	577	if (local_err) {
adf5c449 HR	578	error_propagate(errp, local_err);
	579	return;
	580	}
	581	}
	582	}