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