Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20210921' into staging
[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 static bool
372 opts_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
373 {
374 OptsVisitor *ov = to_ov(v);
375 const QemuOpt *opt;
376
377 opt = lookup_scalar(ov, name, errp);
378 if (!opt) {
379 return false;
380 }
381 if (opt->str) {
382 if (!qapi_bool_parse(opt->name, opt->str, obj, errp)) {
383 return false;
384 }
385 } else {
386 *obj = true;
387 }
388
389 processed(ov, name);
390 return true;
391 }
392
393
394 static bool
395 opts_type_int64(Visitor *v, const char *name, int64_t *obj, Error **errp)
396 {
397 OptsVisitor *ov = to_ov(v);
398 const QemuOpt *opt;
399 const char *str;
400 long long val;
401 char *endptr;
402
403 if (ov->list_mode == LM_SIGNED_INTERVAL) {
404 *obj = ov->range_next.s;
405 return true;
406 }
407
408 opt = lookup_scalar(ov, name, errp);
409 if (!opt) {
410 return false;
411 }
412 str = opt->str ? opt->str : "";
413
414 /* we've gotten past lookup_scalar() */
415 assert(ov->list_mode == LM_NONE || ov->list_mode == LM_IN_PROGRESS);
416
417 errno = 0;
418 val = strtoll(str, &endptr, 0);
419 if (errno == 0 && endptr > str && INT64_MIN <= val && val <= INT64_MAX) {
420 if (*endptr == '\0') {
421 *obj = val;
422 processed(ov, name);
423 return true;
424 }
425 if (*endptr == '-' && ov->list_mode == LM_IN_PROGRESS) {
426 long long val2;
427
428 str = endptr + 1;
429 val2 = strtoll(str, &endptr, 0);
430 if (errno == 0 && endptr > str && *endptr == '\0' &&
431 INT64_MIN <= val2 && val2 <= INT64_MAX && val <= val2 &&
432 (val > INT64_MAX - OPTS_VISITOR_RANGE_MAX ||
433 val2 < val + OPTS_VISITOR_RANGE_MAX)) {
434 ov->range_next.s = val;
435 ov->range_limit.s = val2;
436 ov->list_mode = LM_SIGNED_INTERVAL;
437
438 /* as if entering on the top */
439 *obj = ov->range_next.s;
440 return true;
441 }
442 }
443 }
444 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
445 (ov->list_mode == LM_NONE) ? "an int64 value" :
446 "an int64 value or range");
447 return false;
448 }
449
450
451 static bool
452 opts_type_uint64(Visitor *v, const char *name, uint64_t *obj, Error **errp)
453 {
454 OptsVisitor *ov = to_ov(v);
455 const QemuOpt *opt;
456 const char *str;
457 unsigned long long val;
458 char *endptr;
459
460 if (ov->list_mode == LM_UNSIGNED_INTERVAL) {
461 *obj = ov->range_next.u;
462 return true;
463 }
464
465 opt = lookup_scalar(ov, name, errp);
466 if (!opt) {
467 return false;
468 }
469 str = opt->str;
470
471 /* we've gotten past lookup_scalar() */
472 assert(ov->list_mode == LM_NONE || ov->list_mode == LM_IN_PROGRESS);
473
474 if (parse_uint(str, &val, &endptr, 0) == 0 && val <= UINT64_MAX) {
475 if (*endptr == '\0') {
476 *obj = val;
477 processed(ov, name);
478 return true;
479 }
480 if (*endptr == '-' && ov->list_mode == LM_IN_PROGRESS) {
481 unsigned long long val2;
482
483 str = endptr + 1;
484 if (parse_uint_full(str, &val2, 0) == 0 &&
485 val2 <= UINT64_MAX && val <= val2 &&
486 val2 - val < OPTS_VISITOR_RANGE_MAX) {
487 ov->range_next.u = val;
488 ov->range_limit.u = val2;
489 ov->list_mode = LM_UNSIGNED_INTERVAL;
490
491 /* as if entering on the top */
492 *obj = ov->range_next.u;
493 return true;
494 }
495 }
496 }
497 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
498 (ov->list_mode == LM_NONE) ? "a uint64 value" :
499 "a uint64 value or range");
500 return false;
501 }
502
503
504 static bool
505 opts_type_size(Visitor *v, const char *name, uint64_t *obj, Error **errp)
506 {
507 OptsVisitor *ov = to_ov(v);
508 const QemuOpt *opt;
509 int err;
510
511 opt = lookup_scalar(ov, name, errp);
512 if (!opt) {
513 return false;
514 }
515
516 err = qemu_strtosz(opt->str ? opt->str : "", NULL, obj);
517 if (err < 0) {
518 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
519 "a size value");
520 return false;
521 }
522
523 processed(ov, name);
524 return true;
525 }
526
527
528 static void
529 opts_optional(Visitor *v, const char *name, bool *present)
530 {
531 OptsVisitor *ov = to_ov(v);
532
533 /* we only support a single mandatory scalar field in a list node */
534 assert(ov->list_mode == LM_NONE);
535 *present = (lookup_distinct(ov, name, NULL) != NULL);
536 }
537
538
539 static void
540 opts_free(Visitor *v)
541 {
542 OptsVisitor *ov = to_ov(v);
543
544 if (ov->unprocessed_opts != NULL) {
545 g_hash_table_destroy(ov->unprocessed_opts);
546 }
547 g_free(ov->fake_id_opt);
548 g_free(ov);
549 }
550
551
552 Visitor *
553 opts_visitor_new(const QemuOpts *opts)
554 {
555 OptsVisitor *ov;
556
557 assert(opts);
558 ov = g_malloc0(sizeof *ov);
559
560 ov->visitor.type = VISITOR_INPUT;
561
562 ov->visitor.start_struct = &opts_start_struct;
563 ov->visitor.check_struct = &opts_check_struct;
564 ov->visitor.end_struct = &opts_end_struct;
565
566 ov->visitor.start_list = &opts_start_list;
567 ov->visitor.next_list = &opts_next_list;
568 ov->visitor.check_list = &opts_check_list;
569 ov->visitor.end_list = &opts_end_list;
570
571 ov->visitor.type_int64 = &opts_type_int64;
572 ov->visitor.type_uint64 = &opts_type_uint64;
573 ov->visitor.type_size = &opts_type_size;
574 ov->visitor.type_bool = &opts_type_bool;
575 ov->visitor.type_str = &opts_type_str;
576
577 /* type_number() is not filled in, but this is not the first visitor to
578 * skip some mandatory methods... */
579
580 ov->visitor.optional = &opts_optional;
581 ov->visitor.free = opts_free;
582
583 ov->opts_root = opts;
584
585 return &ov->visitor;
586 }