Statistics
| Branch: | Revision:

root / qemu-config.c @ dfe795e7

History | View | Annotate | Download (13.7 kB)

1
#include "qemu-common.h"
2
#include "qemu-error.h"
3
#include "qemu-option.h"
4
#include "qemu-config.h"
5
#include "sysemu.h"
6
#include "hw/qdev.h"
7

    
8
QemuOptsList qemu_drive_opts = {
9
    .name = "drive",
10
    .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
11
    .desc = {
12
        {
13
            .name = "bus",
14
            .type = QEMU_OPT_NUMBER,
15
            .help = "bus number",
16
        },{
17
            .name = "unit",
18
            .type = QEMU_OPT_NUMBER,
19
            .help = "unit number (i.e. lun for scsi)",
20
        },{
21
            .name = "if",
22
            .type = QEMU_OPT_STRING,
23
            .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
24
        },{
25
            .name = "index",
26
            .type = QEMU_OPT_NUMBER,
27
        },{
28
            .name = "cyls",
29
            .type = QEMU_OPT_NUMBER,
30
            .help = "number of cylinders (ide disk geometry)",
31
        },{
32
            .name = "heads",
33
            .type = QEMU_OPT_NUMBER,
34
            .help = "number of heads (ide disk geometry)",
35
        },{
36
            .name = "secs",
37
            .type = QEMU_OPT_NUMBER,
38
            .help = "number of sectors (ide disk geometry)",
39
        },{
40
            .name = "trans",
41
            .type = QEMU_OPT_STRING,
42
            .help = "chs translation (auto, lba. none)",
43
        },{
44
            .name = "media",
45
            .type = QEMU_OPT_STRING,
46
            .help = "media type (disk, cdrom)",
47
        },{
48
            .name = "snapshot",
49
            .type = QEMU_OPT_BOOL,
50
        },{
51
            .name = "file",
52
            .type = QEMU_OPT_STRING,
53
            .help = "disk image",
54
        },{
55
            .name = "cache",
56
            .type = QEMU_OPT_STRING,
57
            .help = "host cache usage (none, writeback, writethrough, unsafe)",
58
        },{
59
            .name = "aio",
60
            .type = QEMU_OPT_STRING,
61
            .help = "host AIO implementation (threads, native)",
62
        },{
63
            .name = "format",
64
            .type = QEMU_OPT_STRING,
65
            .help = "disk format (raw, qcow2, ...)",
66
        },{
67
            .name = "serial",
68
            .type = QEMU_OPT_STRING,
69
        },{
70
            .name = "rerror",
71
            .type = QEMU_OPT_STRING,
72
        },{
73
            .name = "werror",
74
            .type = QEMU_OPT_STRING,
75
        },{
76
            .name = "addr",
77
            .type = QEMU_OPT_STRING,
78
            .help = "pci address (virtio only)",
79
        },{
80
            .name = "readonly",
81
            .type = QEMU_OPT_BOOL,
82
        },
83
        { /* end if list */ }
84
    },
85
};
86

    
87
QemuOptsList qemu_chardev_opts = {
88
    .name = "chardev",
89
    .implied_opt_name = "backend",
90
    .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
91
    .desc = {
92
        {
93
            .name = "backend",
94
            .type = QEMU_OPT_STRING,
95
        },{
96
            .name = "path",
97
            .type = QEMU_OPT_STRING,
98
        },{
99
            .name = "host",
100
            .type = QEMU_OPT_STRING,
101
        },{
102
            .name = "port",
103
            .type = QEMU_OPT_STRING,
104
        },{
105
            .name = "localaddr",
106
            .type = QEMU_OPT_STRING,
107
        },{
108
            .name = "localport",
109
            .type = QEMU_OPT_STRING,
110
        },{
111
            .name = "to",
112
            .type = QEMU_OPT_NUMBER,
113
        },{
114
            .name = "ipv4",
115
            .type = QEMU_OPT_BOOL,
116
        },{
117
            .name = "ipv6",
118
            .type = QEMU_OPT_BOOL,
119
        },{
120
            .name = "wait",
121
            .type = QEMU_OPT_BOOL,
122
        },{
123
            .name = "server",
124
            .type = QEMU_OPT_BOOL,
125
        },{
126
            .name = "delay",
127
            .type = QEMU_OPT_BOOL,
128
        },{
129
            .name = "telnet",
130
            .type = QEMU_OPT_BOOL,
131
        },{
132
            .name = "width",
133
            .type = QEMU_OPT_NUMBER,
134
        },{
135
            .name = "height",
136
            .type = QEMU_OPT_NUMBER,
137
        },{
138
            .name = "cols",
139
            .type = QEMU_OPT_NUMBER,
140
        },{
141
            .name = "rows",
142
            .type = QEMU_OPT_NUMBER,
143
        },{
144
            .name = "mux",
145
            .type = QEMU_OPT_BOOL,
146
        },{
147
            .name = "signal",
148
            .type = QEMU_OPT_BOOL,
149
        },
150
        { /* end if list */ }
151
    },
152
};
153

    
154
#ifdef CONFIG_LINUX
155
QemuOptsList qemu_fsdev_opts = {
156
    .name = "fsdev",
157
    .implied_opt_name = "fstype",
158
    .head = QTAILQ_HEAD_INITIALIZER(qemu_fsdev_opts.head),
159
    .desc = {
160
        {
161
            .name = "fstype",
162
            .type = QEMU_OPT_STRING,
163
        }, {
164
            .name = "path",
165
            .type = QEMU_OPT_STRING,
166
        }, {
167
            .name = "security_model",
168
            .type = QEMU_OPT_STRING,
169
        },
170
        { /*End of list */ }
171
    },
172
};
173
#endif
174

    
175
#ifdef CONFIG_LINUX
176
QemuOptsList qemu_virtfs_opts = {
177
    .name = "virtfs",
178
    .implied_opt_name = "fstype",
179
    .head = QTAILQ_HEAD_INITIALIZER(qemu_virtfs_opts.head),
180
    .desc = {
181
        {
182
            .name = "fstype",
183
            .type = QEMU_OPT_STRING,
184
        }, {
185
            .name = "path",
186
            .type = QEMU_OPT_STRING,
187
        }, {
188
            .name = "mount_tag",
189
            .type = QEMU_OPT_STRING,
190
        }, {
191
            .name = "security_model",
192
            .type = QEMU_OPT_STRING,
193
        },
194

    
195
        { /*End of list */ }
196
    },
197
};
198
#endif
199

    
200
QemuOptsList qemu_device_opts = {
201
    .name = "device",
202
    .implied_opt_name = "driver",
203
    .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
204
    .desc = {
205
        /*
206
         * no elements => accept any
207
         * sanity checking will happen later
208
         * when setting device properties
209
         */
210
        { /* end if list */ }
211
    },
212
};
213

    
214
QemuOptsList qemu_netdev_opts = {
215
    .name = "netdev",
216
    .implied_opt_name = "type",
217
    .head = QTAILQ_HEAD_INITIALIZER(qemu_netdev_opts.head),
218
    .desc = {
219
        /*
220
         * no elements => accept any params
221
         * validation will happen later
222
         */
223
        { /* end of list */ }
224
    },
225
};
226

    
227
QemuOptsList qemu_net_opts = {
228
    .name = "net",
229
    .implied_opt_name = "type",
230
    .head = QTAILQ_HEAD_INITIALIZER(qemu_net_opts.head),
231
    .desc = {
232
        /*
233
         * no elements => accept any params
234
         * validation will happen later
235
         */
236
        { /* end of list */ }
237
    },
238
};
239

    
240
QemuOptsList qemu_rtc_opts = {
241
    .name = "rtc",
242
    .head = QTAILQ_HEAD_INITIALIZER(qemu_rtc_opts.head),
243
    .desc = {
244
        {
245
            .name = "base",
246
            .type = QEMU_OPT_STRING,
247
        },{
248
            .name = "clock",
249
            .type = QEMU_OPT_STRING,
250
        },{
251
            .name = "driftfix",
252
            .type = QEMU_OPT_STRING,
253
        },
254
        { /* end if list */ }
255
    },
256
};
257

    
258
QemuOptsList qemu_global_opts = {
259
    .name = "global",
260
    .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
261
    .desc = {
262
        {
263
            .name = "driver",
264
            .type = QEMU_OPT_STRING,
265
        },{
266
            .name = "property",
267
            .type = QEMU_OPT_STRING,
268
        },{
269
            .name = "value",
270
            .type = QEMU_OPT_STRING,
271
        },
272
        { /* end if list */ }
273
    },
274
};
275

    
276
QemuOptsList qemu_mon_opts = {
277
    .name = "mon",
278
    .implied_opt_name = "chardev",
279
    .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
280
    .desc = {
281
        {
282
            .name = "mode",
283
            .type = QEMU_OPT_STRING,
284
        },{
285
            .name = "chardev",
286
            .type = QEMU_OPT_STRING,
287
        },{
288
            .name = "default",
289
            .type = QEMU_OPT_BOOL,
290
        },
291
        { /* end if list */ }
292
    },
293
};
294

    
295
QemuOptsList qemu_cpudef_opts = {
296
    .name = "cpudef",
297
    .head = QTAILQ_HEAD_INITIALIZER(qemu_cpudef_opts.head),
298
    .desc = {
299
        {
300
            .name = "name",
301
            .type = QEMU_OPT_STRING,
302
        },{
303
            .name = "level",
304
            .type = QEMU_OPT_NUMBER,
305
        },{
306
            .name = "vendor",
307
            .type = QEMU_OPT_STRING,
308
        },{
309
            .name = "family",
310
            .type = QEMU_OPT_NUMBER,
311
        },{
312
            .name = "model",
313
            .type = QEMU_OPT_NUMBER,
314
        },{
315
            .name = "stepping",
316
            .type = QEMU_OPT_NUMBER,
317
        },{
318
            .name = "feature_edx",      /* cpuid 0000_0001.edx */
319
            .type = QEMU_OPT_STRING,
320
        },{
321
            .name = "feature_ecx",      /* cpuid 0000_0001.ecx */
322
            .type = QEMU_OPT_STRING,
323
        },{
324
            .name = "extfeature_edx",   /* cpuid 8000_0001.edx */
325
            .type = QEMU_OPT_STRING,
326
        },{
327
            .name = "extfeature_ecx",   /* cpuid 8000_0001.ecx */
328
            .type = QEMU_OPT_STRING,
329
        },{
330
            .name = "xlevel",
331
            .type = QEMU_OPT_NUMBER,
332
        },{
333
            .name = "model_id",
334
            .type = QEMU_OPT_STRING,
335
        },{
336
            .name = "vendor_override",
337
            .type = QEMU_OPT_NUMBER,
338
        },
339
        { /* end of list */ }
340
    },
341
};
342

    
343
static QemuOptsList *vm_config_groups[32] = {
344
    &qemu_drive_opts,
345
    &qemu_chardev_opts,
346
    &qemu_device_opts,
347
    &qemu_netdev_opts,
348
    &qemu_net_opts,
349
    &qemu_rtc_opts,
350
    &qemu_global_opts,
351
    &qemu_mon_opts,
352
    &qemu_cpudef_opts,
353
    NULL,
354
};
355

    
356
static QemuOptsList *find_list(QemuOptsList **lists, const char *group)
357
{
358
    int i;
359

    
360
    for (i = 0; lists[i] != NULL; i++) {
361
        if (strcmp(lists[i]->name, group) == 0)
362
            break;
363
    }
364
    if (lists[i] == NULL) {
365
        error_report("there is no option group \"%s\"", group);
366
    }
367
    return lists[i];
368
}
369

    
370
QemuOptsList *qemu_find_opts(const char *group)
371
{
372
    return find_list(vm_config_groups, group);
373
}
374

    
375
void qemu_add_opts(QemuOptsList *list)
376
{
377
    int entries, i;
378

    
379
    entries = ARRAY_SIZE(vm_config_groups);
380
    entries--; /* keep list NULL terminated */
381
    for (i = 0; i < entries; i++) {
382
        if (vm_config_groups[i] == NULL) {
383
            vm_config_groups[i] = list;
384
            return;
385
        }
386
    }
387
    fprintf(stderr, "ran out of space in vm_config_groups");
388
    abort();
389
}
390

    
391
int qemu_set_option(const char *str)
392
{
393
    char group[64], id[64], arg[64];
394
    QemuOptsList *list;
395
    QemuOpts *opts;
396
    int rc, offset;
397

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

    
404
    list = qemu_find_opts(group);
405
    if (list == NULL) {
406
        return -1;
407
    }
408

    
409
    opts = qemu_opts_find(list, id);
410
    if (!opts) {
411
        error_report("there is no %s \"%s\" defined",
412
                     list->name, id);
413
        return -1;
414
    }
415

    
416
    if (qemu_opt_set(opts, arg, str+offset+1) == -1) {
417
        return -1;
418
    }
419
    return 0;
420
}
421

    
422
int qemu_global_option(const char *str)
423
{
424
    char driver[64], property[64];
425
    QemuOpts *opts;
426
    int rc, offset;
427

    
428
    rc = sscanf(str, "%63[^.].%63[^=]%n", driver, property, &offset);
429
    if (rc < 2 || str[offset] != '=') {
430
        error_report("can't parse: \"%s\"", str);
431
        return -1;
432
    }
433

    
434
    opts = qemu_opts_create(&qemu_global_opts, NULL, 0);
435
    qemu_opt_set(opts, "driver", driver);
436
    qemu_opt_set(opts, "property", property);
437
    qemu_opt_set(opts, "value", str+offset+1);
438
    return 0;
439
}
440

    
441
struct ConfigWriteData {
442
    QemuOptsList *list;
443
    FILE *fp;
444
};
445

    
446
static int config_write_opt(const char *name, const char *value, void *opaque)
447
{
448
    struct ConfigWriteData *data = opaque;
449

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

    
454
static int config_write_opts(QemuOpts *opts, void *opaque)
455
{
456
    struct ConfigWriteData *data = opaque;
457
    const char *id = qemu_opts_id(opts);
458

    
459
    if (id) {
460
        fprintf(data->fp, "[%s \"%s\"]\n", data->list->name, id);
461
    } else {
462
        fprintf(data->fp, "[%s]\n", data->list->name);
463
    }
464
    qemu_opt_foreach(opts, config_write_opt, data, 0);
465
    fprintf(data->fp, "\n");
466
    return 0;
467
}
468

    
469
void qemu_config_write(FILE *fp)
470
{
471
    struct ConfigWriteData data = { .fp = fp };
472
    QemuOptsList **lists = vm_config_groups;
473
    int i;
474

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

    
482
int qemu_config_parse(FILE *fp, QemuOptsList **lists, const char *fname)
483
{
484
    char line[1024], group[64], id[64], arg[64], value[1024];
485
    Location loc;
486
    QemuOptsList *list = NULL;
487
    QemuOpts *opts = NULL;
488
    int res = -1, lno = 0;
489

    
490
    loc_push_none(&loc);
491
    while (fgets(line, sizeof(line), fp) != NULL) {
492
        loc_set_file(fname, ++lno);
493
        if (line[0] == '\n') {
494
            /* skip empty lines */
495
            continue;
496
        }
497
        if (line[0] == '#') {
498
            /* comment */
499
            continue;
500
        }
501
        if (sscanf(line, "[%63s \"%63[^\"]\"]", group, id) == 2) {
502
            /* group with id */
503
            list = find_list(lists, group);
504
            if (list == NULL)
505
                goto out;
506
            opts = qemu_opts_create(list, id, 1);
507
            continue;
508
        }
509
        if (sscanf(line, "[%63[^]]]", group) == 1) {
510
            /* group without id */
511
            list = find_list(lists, group);
512
            if (list == NULL)
513
                goto out;
514
            opts = qemu_opts_create(list, NULL, 0);
515
            continue;
516
        }
517
        if (sscanf(line, " %63s = \"%1023[^\"]\"", arg, value) == 2) {
518
            /* arg = value */
519
            if (opts == NULL) {
520
                error_report("no group defined");
521
                goto out;
522
            }
523
            if (qemu_opt_set(opts, arg, value) != 0) {
524
                goto out;
525
            }
526
            continue;
527
        }
528
        error_report("parse error");
529
        goto out;
530
    }
531
    if (ferror(fp)) {
532
        error_report("error reading file");
533
        goto out;
534
    }
535
    res = 0;
536
out:
537
    loc_pop(&loc);
538
    return res;
539
}
540

    
541
int qemu_read_config_file(const char *filename)
542
{
543
    FILE *f = fopen(filename, "r");
544
    int ret;
545

    
546
    if (f == NULL) {
547
        return -errno;
548
    }
549

    
550
    ret = qemu_config_parse(f, vm_config_groups, filename);
551
    fclose(f);
552

    
553
    if (ret == 0) {
554
        return 0;
555
    } else {
556
        return -EINVAL;
557
    }
558
}