qemu

1
#include "qemu/osdep.h"
2
#include "block/qdict.h" /* for qdict_extract_subqdict() */
3
#include "qapi/error.h"
4
#include "qapi/qmp/qdict.h"
5
#include "qapi/qmp/qlist.h"
6
#include "qemu/error-report.h"
7
#include "qemu/option.h"
8
#include "qemu/config-file.h"
9

10
QemuOptsList *vm_config_groups[48];
11
QemuOptsList *drive_config_groups[5];
12

13
static QemuOptsList *find_list(QemuOptsList **lists, const char *group,
14
                               Error **errp)
15
{
16
    int i;
17

18
    qemu_load_module_for_opts(group);
19
    for (i = 0; lists[i] != NULL; i++) {
20
        if (strcmp(lists[i]->name, group) == 0)
21
            break;
22
    }
23
    if (lists[i] == NULL) {
24
        error_setg(errp, "There is no option group '%s'", group);
25
    }
26
    return lists[i];
27
}
28

29
QemuOptsList *qemu_find_opts(const char *group)
30
{
31
    QemuOptsList *ret;
32
    Error *local_err = NULL;
33

34
    ret = find_list(vm_config_groups, group, &local_err);
35
    if (local_err) {
36
        error_report_err(local_err);
37
    }
38

39
    return ret;
40
}
41

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

56
QemuOptsList *qemu_find_opts_err(const char *group, Error **errp)
57
{
58
    return find_list(vm_config_groups, group, errp);
59
}
60

61
void qemu_add_drive_opts(QemuOptsList *list)
62
{
63
    int entries, i;
64

65
    entries = ARRAY_SIZE(drive_config_groups);
66
    entries--; /* keep list NULL terminated */
67
    for (i = 0; i < entries; i++) {
68
        if (drive_config_groups[i] == NULL) {
69
            drive_config_groups[i] = list;
70
            return;
71
        }
72
    }
73
    fprintf(stderr, "ran out of space in drive_config_groups");
74
    abort();
75
}
76

77
void qemu_add_opts(QemuOptsList *list)
78
{
79
    int entries, i;
80

81
    entries = ARRAY_SIZE(vm_config_groups);
82
    entries--; /* keep list NULL terminated */
83
    for (i = 0; i < entries; i++) {
84
        if (vm_config_groups[i] == NULL) {
85
            vm_config_groups[i] = list;
86
            return;
87
        }
88
    }
89
    fprintf(stderr, "ran out of space in vm_config_groups");
90
    abort();
91
}
92

93
/* Returns number of config groups on success, -errno on error */
94
static int qemu_config_foreach(FILE *fp, QEMUConfigCB *cb, void *opaque,
95
                               const char *fname, Error **errp)
96
{
97
    ERRP_GUARD();
98
    char line[1024], prev_group[64], group[64], arg[64], value[1024];
99
    Location loc;
100
    QDict *qdict = NULL;
101
    int res = -EINVAL, lno = 0;
102
    int count = 0;
103

104
    loc_push_none(&loc);
105
    while (fgets(line, sizeof(line), fp) != NULL) {
106
        ++lno;
107
        if (line[0] == '\n') {
108
            /* skip empty lines */
109
            continue;
110
        }
111
        if (line[0] == '#') {
112
            /* comment */
113
            continue;
114
        }
115
        if (line[0] == '[') {
116
            QDict *prev = qdict;
117
            if (sscanf(line, "[%63s \"%63[^\"]\"]", group, value) == 2) {
118
                qdict = qdict_new();
119
                qdict_put_str(qdict, "id", value);
120
                count++;
121
            } else if (sscanf(line, "[%63[^]]]", group) == 1) {
122
                qdict = qdict_new();
123
                count++;
124
            }
125
            if (qdict != prev) {
126
                if (prev) {
127
                    cb(prev_group, prev, opaque, errp);
128
                    qobject_unref(prev);
129
                    if (*errp) {
130
                        goto out;
131
                    }
132
                }
133
                strcpy(prev_group, group);
134
                continue;
135
            }
136
        }
137
        loc_set_file(fname, lno);
138
        value[0] = '\0';
139
        if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2 ||
140
            sscanf(line, " %63s = \"\"", arg) == 1) {
141
            /* arg = value */
142
            if (qdict == NULL) {
143
                error_setg(errp, "no group defined");
144
                goto out;
145
            }
146
            qdict_put_str(qdict, arg, value);
147
            continue;
148
        }
149
        error_setg(errp, "parse error");
150
        goto out;
151
    }
152
    if (ferror(fp)) {
153
        loc_pop(&loc);
154
        error_setg_errno(errp, errno, "Cannot read config file");
155
        goto out_no_loc;
156
    }
157
    res = count;
158
    if (qdict) {
159
        cb(group, qdict, opaque, errp);
160
    }
161
out:
162
    loc_pop(&loc);
163
out_no_loc:
164
    qobject_unref(qdict);
165
    return res;
166
}
167

168
void qemu_config_do_parse(const char *group, QDict *qdict, void *opaque, Error **errp)
169
{
170
    QemuOptsList **lists = opaque;
171
    QemuOptsList *list;
172

173
    list = find_list(lists, group, errp);
174
    if (!list) {
175
        return;
176
    }
177

178
    qemu_opts_from_qdict(list, qdict, errp);
179
}
180

181
int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname, Error **errp)
182
{
183
    return qemu_config_foreach(fp, qemu_config_do_parse, lists, fname, errp);
184
}
185

186
int qemu_read_config_file(const char *filename, QEMUConfigCB *cb, Error **errp)
187
{
188
    FILE *f = fopen(filename, "r");
189
    int ret;
190

191
    if (f == NULL) {
192
        error_setg_file_open(errp, errno, filename);
193
        return -errno;
194
    }
195

196
    ret = qemu_config_foreach(f, cb, vm_config_groups, filename, errp);
197
    fclose(f);
198
    return ret;
199
}
200

201
static bool config_parse_qdict_section(QDict *options, QemuOptsList *opts,
202
                                       Error **errp)
203
{
204
    QemuOpts *subopts;
205
    g_autoptr(QDict) subqdict = NULL;
206
    g_autoptr(QList) list = NULL;
207
    size_t orig_size, enum_size;
208
    char *prefix;
209

210
    prefix = g_strdup_printf("%s.", opts->name);
211
    qdict_extract_subqdict(options, &subqdict, prefix);
212
    g_free(prefix);
213
    orig_size = qdict_size(subqdict);
214
    if (!orig_size) {
215
        return true;
216
    }
217

218
    subopts = qemu_opts_create(opts, NULL, 0, errp);
219
    if (!subopts) {
220
        return false;
221
    }
222

223
    if (!qemu_opts_absorb_qdict(subopts, subqdict, errp)) {
224
        return false;
225
    }
226

227
    enum_size = qdict_size(subqdict);
228
    if (enum_size < orig_size && enum_size) {
229
        error_setg(errp, "Unknown option '%s' for [%s]",
230
                   qdict_first(subqdict)->key, opts->name);
231
        return false;
232
    }
233

234
    if (enum_size) {
235
        /* Multiple, enumerated sections */
236
        QListEntry *list_entry;
237
        unsigned i = 0;
238

239
        /* Not required anymore */
240
        qemu_opts_del(subopts);
241

242
        qdict_array_split(subqdict, &list);
243
        if (qdict_size(subqdict)) {
244
            error_setg(errp, "Unused option '%s' for [%s]",
245
                       qdict_first(subqdict)->key, opts->name);
246
            return false;
247
        }
248

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

253
            if (!section) {
254
                error_setg(errp, "[%s] section (index %u) does not consist of "
255
                           "keys", opts->name, i);
256
                return false;
257
            }
258

259
            opt_name = g_strdup_printf("%s.%u", opts->name, i++);
260
            subopts = qemu_opts_create(opts, opt_name, 1, errp);
261
            g_free(opt_name);
262
            if (!subopts) {
263
                return false;
264
            }
265

266
            if (!qemu_opts_absorb_qdict(subopts, section, errp)) {
267
                qemu_opts_del(subopts);
268
                return false;
269
            }
270

271
            if (qdict_size(section)) {
272
                error_setg(errp, "[%s] section doesn't support the option '%s'",
273
                           opts->name, qdict_first(section)->key);
274
                qemu_opts_del(subopts);
275
                return false;
276
            }
277
        }
278
    }
279

280
    return true;
281
}
282

283
bool qemu_config_parse_qdict(QDict *options, QemuOptsList **lists,
284
                             Error **errp)
285
{
286
    int i;
287

288
    for (i = 0; lists[i]; i++) {
289
        if (!config_parse_qdict_section(options, lists[i], errp)) {
290
            return false;
291
        }
292
    }
293

294
    return true;
295
}
296