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