vhost: switch to use IOTLB v2 format
[qemu.git] / qapi / opts-visitor.c
1 /*
2 * Options Visitor
3 *
4 * Copyright Red Hat, Inc. 2012-2016
5 *
6 * Author: Laszlo Ersek <lersek@redhat.com>
7 *
8 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
9 * See the COPYING.LIB file in the top-level directory.
10 *
11 */
12
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "qemu/cutils.h"
16 #include "qapi/qmp/qerror.h"
17 #include "qapi/opts-visitor.h"
18 #include "qemu/queue.h"
19 #include "qemu/option_int.h"
20 #include "qapi/visitor-impl.h"
21
22
23 enum ListMode
24 {
25 LM_NONE, /* not traversing a list of repeated options */
26
27 LM_IN_PROGRESS, /*
28 * opts_next_list() ready to be called.
29 *
30 * Generating the next list link will consume the most
31 * recently parsed QemuOpt instance of the repeated
32 * option.
33 *
34 * Parsing a value into the list link will examine the
35 * next QemuOpt instance of the repeated option, and
36 * possibly enter LM_SIGNED_INTERVAL or
37 * LM_UNSIGNED_INTERVAL.
38 */
39
40 LM_SIGNED_INTERVAL, /*
41 * opts_next_list() has been called.
42 *
43 * Generating the next list link will consume the most
44 * recently stored element from the signed interval,
45 * parsed from the most recent QemuOpt instance of the
46 * repeated option. This may consume QemuOpt itself
47 * and return to LM_IN_PROGRESS.
48 *
49 * Parsing a value into the list link will store the
50 * next element of the signed interval.
51 */
52
53 LM_UNSIGNED_INTERVAL, /* Same as above, only for an unsigned interval. */
54
55 LM_TRAVERSED /*
56 * opts_next_list() has been called.
57 *
58 * No more QemuOpt instance in the list.
59 * The traversal has been completed.
60 */
61 };
62
63 typedef enum ListMode ListMode;
64
65 struct OptsVisitor
66 {
67 Visitor visitor;
68
69 /* Ownership remains with opts_visitor_new()'s caller. */
70 const QemuOpts *opts_root;
71
72 unsigned depth;
73
74 /* Non-null iff depth is positive. Each key is a QemuOpt name. Each value
75 * is a non-empty GQueue, enumerating all QemuOpt occurrences with that
76 * name. */
77 GHashTable *unprocessed_opts;
78
79 /* The list currently being traversed with opts_start_list() /
80 * opts_next_list(). The list must have a struct element type in the
81 * schema, with a single mandatory scalar member. */
82 ListMode list_mode;
83 GQueue *repeated_opts;
84
85 /* When parsing a list of repeating options as integers, values of the form
86 * "a-b", representing a closed interval, are allowed. Elements in the
87 * range are generated individually.
88 */
89 union {
90 int64_t s;
91 uint64_t u;
92 } range_next, range_limit;
93
94 /* If "opts_root->id" is set, reinstantiate it as a fake QemuOpt for
95 * uniformity. Only its "name" and "str" fields are set. "fake_id_opt" does
96 * not survive or escape the OptsVisitor object.
97 */
98 QemuOpt *fake_id_opt;
99 };
100
101
102 static OptsVisitor *to_ov(Visitor *v)
103 {
104 return container_of(v, OptsVisitor, visitor);
105 }
106
107
108 static void
109 destroy_list(gpointer list)
110 {
111 g_queue_free(list);
112 }
113
114
115 static void
116 opts_visitor_insert(GHashTable *unprocessed_opts, const QemuOpt *opt)
117 {
118 GQueue *list;
119
120 list = g_hash_table_lookup(unprocessed_opts, opt->name);
121 if (list == NULL) {
122 list = g_queue_new();
123
124 /* GHashTable will never try to free the keys -- we supply NULL as
125 * "key_destroy_func" in opts_start_struct(). Thus cast away key
126 * const-ness in order to suppress gcc's warning.
127 */
128 g_hash_table_insert(unprocessed_opts, (gpointer)opt->name, list);
129 }
130
131 /* Similarly, destroy_list() doesn't call g_queue_free_full(). */
132 g_queue_push_tail(list, (gpointer)opt);
133 }
134
135
136 static bool
137 opts_start_struct(Visitor *v, const char *name, void **obj,
138 size_t size, Error **errp)
139 {
140 OptsVisitor *ov = to_ov(v);
141 const QemuOpt *opt;
142
143 if (obj) {
144 *obj = g_malloc0(size);
145 }
146 if (ov->depth++ > 0) {
147 return true;
148 }
149
150 ov->unprocessed_opts = g_hash_table_new_full(&g_str_hash, &g_str_equal,
151 NULL, &destroy_list);
152 QTAILQ_FOREACH(opt, &ov->opts_root->head, next) {
153 /* ensured by qemu-option.c::opts_do_parse() */
154 assert(strcmp(opt->name, "id") != 0);
155
156 opts_visitor_insert(ov->unprocessed_opts, opt);
157 }
158
159 if (ov->opts_root->id != NULL) {
160 ov->fake_id_opt = g_malloc0(sizeof *ov->fake_id_opt);
161
162 ov->fake_id_opt->name = g_strdup("id");
163 ov->fake_id_opt->str = g_strdup(ov->opts_root->id);
164 opts_visitor_insert(ov->unprocessed_opts, ov->fake_id_opt);
165 }
166 return true;
167 }
168
169
170 static bool
171 opts_check_struct(Visitor *v, Error **errp)
172 {
173 OptsVisitor *ov = to_ov(v);
174 GHashTableIter iter;
175 GQueue *any;
176
177 if (ov->depth > 1) {
178 return true;
179 }
180
181 /* we should have processed all (distinct) QemuOpt instances */
182 g_hash_table_iter_init(&iter, ov->unprocessed_opts);
183 if (g_hash_table_iter_next(&iter, NULL, (void **)&any)) {
184 const QemuOpt *first;
185
186 first = g_queue_peek_head(any);
187 error_setg(errp, QERR_INVALID_PARAMETER, first->name);
188 return false;
189 }
190 return true;
191 }
192
193
194 static void
195 opts_end_struct(Visitor *v, void **obj)
196 {
197 OptsVisitor *ov = to_ov(v);
198
199 if (--ov->depth > 0) {
200 return;
201 }
202
203 g_hash_table_destroy(ov->unprocessed_opts);
204 ov->unprocessed_opts = NULL;
205 if (ov->fake_id_opt) {
206 g_free(ov->fake_id_opt->name);
207 g_free(ov->fake_id_opt->str);
208 g_free(ov->fake_id_opt);
209 }
210 ov->fake_id_opt = NULL;
211 }
212
213
214 static GQueue *
215 lookup_distinct(const OptsVisitor *ov, const char *name, Error **errp)
216 {
217 GQueue *list;
218
219 list = g_hash_table_lookup(ov->unprocessed_opts, name);
220 if (!list) {
221 error_setg(errp, QERR_MISSING_PARAMETER, name);
222 }
223 return list;
224 }
225
226
227 static bool
228 opts_start_list(Visitor *v, const char *name, GenericList **list, size_t size,
229 Error **errp)
230 {
231 OptsVisitor *ov = to_ov(v);
232
233 /* we can't traverse a list in a list */
234 assert(ov->list_mode == LM_NONE);
235 /* we don't support visits without a list */
236 assert(list);
237 ov->repeated_opts = lookup_distinct(ov, name, errp);
238 if (!ov->repeated_opts) {
239 *list = NULL;
240 return false;
241 }
242 ov->list_mode = LM_IN_PROGRESS;
243 *list = g_malloc0(size);
244 return true;
245 }
246
247
248 static GenericList *
249 opts_next_list(Visitor *v, GenericList *tail, size_t size)
250 {
251 OptsVisitor *ov = to_ov(v);
252
253 switch (ov->list_mode) {
254 case LM_TRAVERSED:
255 return NULL;
256 case LM_SIGNED_INTERVAL:
257 case LM_UNSIGNED_INTERVAL:
258 if (ov->list_mode == LM_SIGNED_INTERVAL) {
259 if (ov->range_next.s < ov->range_limit.s) {
260 ++ov->range_next.s;
261 break;
262 }
263 } else if (ov->range_next.u < ov->range_limit.u) {
264 ++ov->range_next.u;
265 break;
266 }
267 ov->list_mode = LM_IN_PROGRESS;
268 /* range has been completed, fall through in order to pop option */
269
270 case LM_IN_PROGRESS: {
271 const QemuOpt *opt;
272
273 opt = g_queue_pop_head(ov->repeated_opts);
274 if (g_queue_is_empty(ov->repeated_opts)) {
275 g_hash_table_remove(ov->unprocessed_opts, opt->name);
276 ov->repeated_opts = NULL;
277 ov->list_mode = LM_TRAVERSED;
278 return NULL;
279 }
280 break;
281 }
282
283 default:
284 abort();
285 }
286
287 tail->next = g_malloc0(size);
288 return tail->next;
289 }
290
291
292 static bool
293 opts_check_list(Visitor *v, Error **errp)
294 {
295 /*
296 * Unvisited list elements will be reported later when checking
297 * whether unvisited struct members remain.
298 */
299 return true;
300 }
301
302
303 static void
304 opts_end_list(Visitor *v, void **obj)
305 {
306 OptsVisitor *ov = to_ov(v);
307
308 assert(ov->list_mode == LM_IN_PROGRESS ||
309 ov->list_mode == LM_SIGNED_INTERVAL ||
310 ov->list_mode == LM_UNSIGNED_INTERVAL ||
311 ov->list_mode == LM_TRAVERSED);
312 ov->repeated_opts = NULL;
313 ov->list_mode = LM_NONE;
314 }
315
316
317 static const QemuOpt *
318 lookup_scalar(const OptsVisitor *ov, const char *name, Error **errp)
319 {
320 if (ov->list_mode == LM_NONE) {
321 GQueue *list;
322
323 /* the last occurrence of any QemuOpt takes effect when queried by name
324 */
325 list = lookup_distinct(ov, name, errp);
326 return list ? g_queue_peek_tail(list) : NULL;
327 }
328 if (ov->list_mode == LM_TRAVERSED) {
329 error_setg(errp, "Fewer list elements than expected");
330 return NULL;
331 }
332 assert(ov->list_mode == LM_IN_PROGRESS);
333 return g_queue_peek_head(ov->repeated_opts);
334 }
335
336
337 static void
338 processed(OptsVisitor *ov, const char *name)
339 {
340 if (ov->list_mode == LM_NONE) {
341 g_hash_table_remove(ov->unprocessed_opts, name);
342 return;
343 }
344 assert(ov->list_mode == LM_IN_PROGRESS);
345 /* do nothing */
346 }
347
348
349 static bool
350 opts_type_str(Visitor *v, const char *name, char **obj, Error **errp)
351 {
352 OptsVisitor *ov = to_ov(v);
353 const QemuOpt *opt;
354
355 opt = lookup_scalar(ov, name, errp);
356 if (!opt) {
357 *obj = NULL;
358 return false;
359 }
360 *obj = g_strdup(opt->str ? opt->str : "");
361 /* Note that we consume a string even if this is called as part of
362 * an enum visit that later fails because the string is not a
363 * valid enum value; this is harmless because tracking what gets
364 * consumed only matters to visit_end_struct() as the final error
365 * check if there were no other failures during the visit. */
366 processed(ov, name);
367 return true;
368 }
369
370
371 /* mimics qemu-option.c::parse_option_bool() */
372 static bool
373 opts_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
374 {
375 OptsVisitor *ov = to_ov(v);
376 const QemuOpt *opt;
377
378 opt = lookup_scalar(ov, name, errp);
379 if (!opt) {
380 return false;
381 }
382
383 if (opt->str) {
384 if (strcmp(opt->str, "on") == 0 ||
385 strcmp(opt->str, "yes") == 0 ||
386 strcmp(opt->str, "y") == 0) {
387 *obj = true;
388 } else if (strcmp(opt->str, "off") == 0 ||
389 strcmp(opt->str, "no") == 0 ||
390 strcmp(opt->str, "n") == 0) {
391 *obj = false;
392 } else {
393 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
394 "on|yes|y|off|no|n");
395 return false;
396 }
397 } else {
398 *obj = true;
399 }
400
401 processed(ov, name);
402 return true;
403 }
404
405
406 static bool
407 opts_type_int64(Visitor *v, const char *name, int64_t *obj, Error **errp)
408 {
409 OptsVisitor *ov = to_ov(v);
410 const QemuOpt *opt;
411 const char *str;
412 long long val;
413 char *endptr;
414
415 if (ov->list_mode == LM_SIGNED_INTERVAL) {
416 *obj = ov->range_next.s;
417 return true;
418 }
419
420 opt = lookup_scalar(ov, name, errp);
421 if (!opt) {
422 return false;
423 }
424 str = opt->str ? opt->str : "";
425
426 /* we've gotten past lookup_scalar() */
427 assert(ov->list_mode == LM_NONE || ov->list_mode == LM_IN_PROGRESS);
428
429 errno = 0;
430 val = strtoll(str, &endptr, 0);
431 if (errno == 0 && endptr > str && INT64_MIN <= val && val <= INT64_MAX) {
432 if (*endptr == '\0') {
433 *obj = val;
434 processed(ov, name);
435 return true;
436 }
437 if (*endptr == '-' && ov->list_mode == LM_IN_PROGRESS) {
438 long long val2;
439
440 str = endptr + 1;
441 val2 = strtoll(str, &endptr, 0);
442 if (errno == 0 && endptr > str && *endptr == '\0' &&
443 INT64_MIN <= val2 && val2 <= INT64_MAX && val <= val2 &&
444 (val > INT64_MAX - OPTS_VISITOR_RANGE_MAX ||
445 val2 < val + OPTS_VISITOR_RANGE_MAX)) {
446 ov->range_next.s = val;
447 ov->range_limit.s = val2;
448 ov->list_mode = LM_SIGNED_INTERVAL;
449
450 /* as if entering on the top */
451 *obj = ov->range_next.s;
452 return true;
453 }
454 }
455 }
456 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
457 (ov->list_mode == LM_NONE) ? "an int64 value" :
458 "an int64 value or range");
459 return false;
460 }
461
462
463 static bool
464 opts_type_uint64(Visitor *v, const char *name, uint64_t *obj, Error **errp)
465 {
466 OptsVisitor *ov = to_ov(v);
467 const QemuOpt *opt;
468 const char *str;
469 unsigned long long val;
470 char *endptr;
471
472 if (ov->list_mode == LM_UNSIGNED_INTERVAL) {
473 *obj = ov->range_next.u;
474 return true;
475 }
476
477 opt = lookup_scalar(ov, name, errp);
478 if (!opt) {
479 return false;
480 }
481 str = opt->str;
482
483 /* we've gotten past lookup_scalar() */
484 assert(ov->list_mode == LM_NONE || ov->list_mode == LM_IN_PROGRESS);
485
486 if (parse_uint(str, &val, &endptr, 0) == 0 && val <= UINT64_MAX) {
487 if (*endptr == '\0') {
488 *obj = val;
489 processed(ov, name);
490 return true;
491 }
492 if (*endptr == '-' && ov->list_mode == LM_IN_PROGRESS) {
493 unsigned long long val2;
494
495 str = endptr + 1;
496 if (parse_uint_full(str, &val2, 0) == 0 &&
497 val2 <= UINT64_MAX && val <= val2 &&
498 val2 - val < OPTS_VISITOR_RANGE_MAX) {
499 ov->range_next.u = val;
500 ov->range_limit.u = val2;
501 ov->list_mode = LM_UNSIGNED_INTERVAL;
502
503 /* as if entering on the top */
504 *obj = ov->range_next.u;
505 return true;
506 }
507 }
508 }
509 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
510 (ov->list_mode == LM_NONE) ? "a uint64 value" :
511 "a uint64 value or range");
512 return false;
513 }
514
515
516 static bool
517 opts_type_size(Visitor *v, const char *name, uint64_t *obj, Error **errp)
518 {
519 OptsVisitor *ov = to_ov(v);
520 const QemuOpt *opt;
521 int err;
522
523 opt = lookup_scalar(ov, name, errp);
524 if (!opt) {
525 return false;
526 }
527
528 err = qemu_strtosz(opt->str ? opt->str : "", NULL, obj);
529 if (err < 0) {
530 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
531 "a size value");
532 return false;
533 }
534
535 processed(ov, name);
536 return true;
537 }
538
539
540 static void
541 opts_optional(Visitor *v, const char *name, bool *present)
542 {
543 OptsVisitor *ov = to_ov(v);
544
545 /* we only support a single mandatory scalar field in a list node */
546 assert(ov->list_mode == LM_NONE);
547 *present = (lookup_distinct(ov, name, NULL) != NULL);
548 }
549
550
551 static void
552 opts_free(Visitor *v)
553 {
554 OptsVisitor *ov = to_ov(v);
555
556 if (ov->unprocessed_opts != NULL) {
557 g_hash_table_destroy(ov->unprocessed_opts);
558 }
559 g_free(ov->fake_id_opt);
560 g_free(ov);
561 }
562
563
564 Visitor *
565 opts_visitor_new(const QemuOpts *opts)
566 {
567 OptsVisitor *ov;
568
569 assert(opts);
570 ov = g_malloc0(sizeof *ov);
571
572 ov->visitor.type = VISITOR_INPUT;
573
574 ov->visitor.start_struct = &opts_start_struct;
575 ov->visitor.check_struct = &opts_check_struct;
576 ov->visitor.end_struct = &opts_end_struct;
577
578 ov->visitor.start_list = &opts_start_list;
579 ov->visitor.next_list = &opts_next_list;
580 ov->visitor.check_list = &opts_check_list;
581 ov->visitor.end_list = &opts_end_list;
582
583 ov->visitor.type_int64 = &opts_type_int64;
584 ov->visitor.type_uint64 = &opts_type_uint64;
585 ov->visitor.type_size = &opts_type_size;
586 ov->visitor.type_bool = &opts_type_bool;
587 ov->visitor.type_str = &opts_type_str;
588
589 /* type_number() is not filled in, but this is not the first visitor to
590 * skip some mandatory methods... */
591
592 ov->visitor.optional = &opts_optional;
593 ov->visitor.free = opts_free;
594
595 ov->opts_root = opts;
596
597 return &ov->visitor;
598 }