]>
Commit | Line | Data |
---|---|---|
eb7ee2cb LE |
1 | /* |
2 | * Options Visitor | |
3 | * | |
4 | * Copyright Red Hat, Inc. 2012 | |
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 "opts-visitor.h" | |
14 | #include "qemu-queue.h" | |
15 | #include "qemu-option-internal.h" | |
16 | #include "qapi-visit-impl.h" | |
17 | ||
18 | ||
19 | struct OptsVisitor | |
20 | { | |
21 | Visitor visitor; | |
22 | ||
23 | /* Ownership remains with opts_visitor_new()'s caller. */ | |
24 | const QemuOpts *opts_root; | |
25 | ||
26 | unsigned depth; | |
27 | ||
28 | /* Non-null iff depth is positive. Each key is a QemuOpt name. Each value | |
29 | * is a non-empty GQueue, enumerating all QemuOpt occurrences with that | |
30 | * name. */ | |
31 | GHashTable *unprocessed_opts; | |
32 | ||
33 | /* The list currently being traversed with opts_start_list() / | |
34 | * opts_next_list(). The list must have a struct element type in the | |
35 | * schema, with a single mandatory scalar member. */ | |
36 | GQueue *repeated_opts; | |
37 | bool repeated_opts_first; | |
38 | ||
39 | /* If "opts_root->id" is set, reinstantiate it as a fake QemuOpt for | |
40 | * uniformity. Only its "name" and "str" fields are set. "fake_id_opt" does | |
41 | * not survive or escape the OptsVisitor object. | |
42 | */ | |
43 | QemuOpt *fake_id_opt; | |
44 | }; | |
45 | ||
46 | ||
47 | static void | |
48 | destroy_list(gpointer list) | |
49 | { | |
50 | g_queue_free(list); | |
51 | } | |
52 | ||
53 | ||
54 | static void | |
55 | opts_visitor_insert(GHashTable *unprocessed_opts, const QemuOpt *opt) | |
56 | { | |
57 | GQueue *list; | |
58 | ||
59 | list = g_hash_table_lookup(unprocessed_opts, opt->name); | |
60 | if (list == NULL) { | |
61 | list = g_queue_new(); | |
62 | ||
63 | /* GHashTable will never try to free the keys -- we supply NULL as | |
64 | * "key_destroy_func" in opts_start_struct(). Thus cast away key | |
65 | * const-ness in order to suppress gcc's warning. | |
66 | */ | |
67 | g_hash_table_insert(unprocessed_opts, (gpointer)opt->name, list); | |
68 | } | |
69 | ||
70 | /* Similarly, destroy_list() doesn't call g_queue_free_full(). */ | |
71 | g_queue_push_tail(list, (gpointer)opt); | |
72 | } | |
73 | ||
74 | ||
75 | static void | |
76 | opts_start_struct(Visitor *v, void **obj, const char *kind, | |
77 | const char *name, size_t size, Error **errp) | |
78 | { | |
79 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
80 | const QemuOpt *opt; | |
81 | ||
82 | *obj = g_malloc0(size > 0 ? size : 1); | |
83 | if (ov->depth++ > 0) { | |
84 | return; | |
85 | } | |
86 | ||
87 | ov->unprocessed_opts = g_hash_table_new_full(&g_str_hash, &g_str_equal, | |
88 | NULL, &destroy_list); | |
89 | QTAILQ_FOREACH(opt, &ov->opts_root->head, next) { | |
90 | /* ensured by qemu-option.c::opts_do_parse() */ | |
91 | assert(strcmp(opt->name, "id") != 0); | |
92 | ||
93 | opts_visitor_insert(ov->unprocessed_opts, opt); | |
94 | } | |
95 | ||
96 | if (ov->opts_root->id != NULL) { | |
97 | ov->fake_id_opt = g_malloc0(sizeof *ov->fake_id_opt); | |
98 | ||
99 | ov->fake_id_opt->name = "id"; | |
100 | ov->fake_id_opt->str = ov->opts_root->id; | |
101 | opts_visitor_insert(ov->unprocessed_opts, ov->fake_id_opt); | |
102 | } | |
103 | } | |
104 | ||
105 | ||
106 | static gboolean | |
107 | ghr_true(gpointer ign_key, gpointer ign_value, gpointer ign_user_data) | |
108 | { | |
109 | return TRUE; | |
110 | } | |
111 | ||
112 | ||
113 | static void | |
114 | opts_end_struct(Visitor *v, Error **errp) | |
115 | { | |
116 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
117 | GQueue *any; | |
118 | ||
119 | if (--ov->depth > 0) { | |
120 | return; | |
121 | } | |
122 | ||
123 | /* we should have processed all (distinct) QemuOpt instances */ | |
124 | any = g_hash_table_find(ov->unprocessed_opts, &ghr_true, NULL); | |
125 | if (any) { | |
126 | const QemuOpt *first; | |
127 | ||
128 | first = g_queue_peek_head(any); | |
129 | error_set(errp, QERR_INVALID_PARAMETER, first->name); | |
130 | } | |
131 | g_hash_table_destroy(ov->unprocessed_opts); | |
132 | ov->unprocessed_opts = NULL; | |
133 | g_free(ov->fake_id_opt); | |
134 | ov->fake_id_opt = NULL; | |
135 | } | |
136 | ||
137 | ||
138 | static GQueue * | |
139 | lookup_distinct(const OptsVisitor *ov, const char *name, Error **errp) | |
140 | { | |
141 | GQueue *list; | |
142 | ||
143 | list = g_hash_table_lookup(ov->unprocessed_opts, name); | |
144 | if (!list) { | |
145 | error_set(errp, QERR_MISSING_PARAMETER, name); | |
146 | } | |
147 | return list; | |
148 | } | |
149 | ||
150 | ||
151 | static void | |
152 | opts_start_list(Visitor *v, const char *name, Error **errp) | |
153 | { | |
154 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
155 | ||
156 | /* we can't traverse a list in a list */ | |
157 | assert(ov->repeated_opts == NULL); | |
158 | ov->repeated_opts = lookup_distinct(ov, name, errp); | |
159 | ov->repeated_opts_first = (ov->repeated_opts != NULL); | |
160 | } | |
161 | ||
162 | ||
163 | static GenericList * | |
164 | opts_next_list(Visitor *v, GenericList **list, Error **errp) | |
165 | { | |
166 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
167 | GenericList **link; | |
168 | ||
169 | if (ov->repeated_opts_first) { | |
170 | ov->repeated_opts_first = false; | |
171 | link = list; | |
172 | } else { | |
173 | const QemuOpt *opt; | |
174 | ||
175 | opt = g_queue_pop_head(ov->repeated_opts); | |
176 | if (g_queue_is_empty(ov->repeated_opts)) { | |
177 | g_hash_table_remove(ov->unprocessed_opts, opt->name); | |
178 | return NULL; | |
179 | } | |
180 | link = &(*list)->next; | |
181 | } | |
182 | ||
183 | *link = g_malloc0(sizeof **link); | |
184 | return *link; | |
185 | } | |
186 | ||
187 | ||
188 | static void | |
189 | opts_end_list(Visitor *v, Error **errp) | |
190 | { | |
191 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
192 | ||
193 | ov->repeated_opts = NULL; | |
194 | } | |
195 | ||
196 | ||
197 | static const QemuOpt * | |
198 | lookup_scalar(const OptsVisitor *ov, const char *name, Error **errp) | |
199 | { | |
200 | if (ov->repeated_opts == NULL) { | |
201 | GQueue *list; | |
202 | ||
203 | /* the last occurrence of any QemuOpt takes effect when queried by name | |
204 | */ | |
205 | list = lookup_distinct(ov, name, errp); | |
206 | return list ? g_queue_peek_tail(list) : NULL; | |
207 | } | |
208 | return g_queue_peek_head(ov->repeated_opts); | |
209 | } | |
210 | ||
211 | ||
212 | static void | |
213 | processed(OptsVisitor *ov, const char *name) | |
214 | { | |
215 | if (ov->repeated_opts == NULL) { | |
216 | g_hash_table_remove(ov->unprocessed_opts, name); | |
217 | } | |
218 | } | |
219 | ||
220 | ||
221 | static void | |
222 | opts_type_str(Visitor *v, char **obj, const char *name, Error **errp) | |
223 | { | |
224 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
225 | const QemuOpt *opt; | |
226 | ||
227 | opt = lookup_scalar(ov, name, errp); | |
228 | if (!opt) { | |
229 | return; | |
230 | } | |
231 | *obj = g_strdup(opt->str ? opt->str : ""); | |
232 | processed(ov, name); | |
233 | } | |
234 | ||
235 | ||
236 | /* mimics qemu-option.c::parse_option_bool() */ | |
237 | static void | |
238 | opts_type_bool(Visitor *v, bool *obj, const char *name, Error **errp) | |
239 | { | |
240 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
241 | const QemuOpt *opt; | |
242 | ||
243 | opt = lookup_scalar(ov, name, errp); | |
244 | if (!opt) { | |
245 | return; | |
246 | } | |
247 | ||
248 | if (opt->str) { | |
249 | if (strcmp(opt->str, "on") == 0 || | |
250 | strcmp(opt->str, "yes") == 0 || | |
251 | strcmp(opt->str, "y") == 0) { | |
252 | *obj = true; | |
253 | } else if (strcmp(opt->str, "off") == 0 || | |
254 | strcmp(opt->str, "no") == 0 || | |
255 | strcmp(opt->str, "n") == 0) { | |
256 | *obj = false; | |
257 | } else { | |
258 | error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name, | |
259 | "on|yes|y|off|no|n"); | |
260 | return; | |
261 | } | |
262 | } else { | |
263 | *obj = true; | |
264 | } | |
265 | ||
266 | processed(ov, name); | |
267 | } | |
268 | ||
269 | ||
270 | static void | |
271 | opts_type_int(Visitor *v, int64_t *obj, const char *name, Error **errp) | |
272 | { | |
273 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
274 | const QemuOpt *opt; | |
275 | const char *str; | |
276 | long long val; | |
277 | char *endptr; | |
278 | ||
279 | opt = lookup_scalar(ov, name, errp); | |
280 | if (!opt) { | |
281 | return; | |
282 | } | |
283 | str = opt->str ? opt->str : ""; | |
284 | ||
285 | errno = 0; | |
286 | val = strtoll(str, &endptr, 0); | |
287 | if (*str != '\0' && *endptr == '\0' && errno == 0 && INT64_MIN <= val && | |
288 | val <= INT64_MAX) { | |
289 | *obj = val; | |
290 | processed(ov, name); | |
291 | return; | |
292 | } | |
293 | error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name, "an int64 value"); | |
294 | } | |
295 | ||
296 | ||
297 | static void | |
298 | opts_type_uint64(Visitor *v, uint64_t *obj, const char *name, Error **errp) | |
299 | { | |
300 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
301 | const QemuOpt *opt; | |
302 | const char *str; | |
303 | ||
304 | opt = lookup_scalar(ov, name, errp); | |
305 | if (!opt) { | |
306 | return; | |
307 | } | |
308 | ||
309 | str = opt->str; | |
310 | if (str != NULL) { | |
311 | while (isspace((unsigned char)*str)) { | |
312 | ++str; | |
313 | } | |
314 | ||
315 | if (*str != '-' && *str != '\0') { | |
316 | unsigned long long val; | |
317 | char *endptr; | |
318 | ||
319 | /* non-empty, non-negative subject sequence */ | |
320 | errno = 0; | |
321 | val = strtoull(str, &endptr, 0); | |
322 | if (*endptr == '\0' && errno == 0 && val <= UINT64_MAX) { | |
323 | *obj = val; | |
324 | processed(ov, name); | |
325 | return; | |
326 | } | |
327 | } | |
328 | } | |
329 | error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name, | |
330 | "an uint64 value"); | |
331 | } | |
332 | ||
333 | ||
334 | static void | |
335 | opts_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp) | |
336 | { | |
337 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
338 | const QemuOpt *opt; | |
339 | int64_t val; | |
340 | char *endptr; | |
341 | ||
342 | opt = lookup_scalar(ov, name, errp); | |
343 | if (!opt) { | |
344 | return; | |
345 | } | |
346 | ||
347 | val = strtosz_suffix(opt->str ? opt->str : "", &endptr, | |
348 | STRTOSZ_DEFSUFFIX_B); | |
349 | if (val != -1 && *endptr == '\0') { | |
350 | *obj = val; | |
351 | processed(ov, name); | |
352 | return; | |
353 | } | |
354 | error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name, | |
355 | "a size value representible as a non-negative int64"); | |
356 | } | |
357 | ||
358 | ||
359 | static void | |
360 | opts_start_optional(Visitor *v, bool *present, const char *name, | |
361 | Error **errp) | |
362 | { | |
363 | OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v); | |
364 | ||
365 | /* we only support a single mandatory scalar field in a list node */ | |
366 | assert(ov->repeated_opts == NULL); | |
367 | *present = (lookup_distinct(ov, name, NULL) != NULL); | |
368 | } | |
369 | ||
370 | ||
371 | OptsVisitor * | |
372 | opts_visitor_new(const QemuOpts *opts) | |
373 | { | |
374 | OptsVisitor *ov; | |
375 | ||
376 | ov = g_malloc0(sizeof *ov); | |
377 | ||
378 | ov->visitor.start_struct = &opts_start_struct; | |
379 | ov->visitor.end_struct = &opts_end_struct; | |
380 | ||
381 | ov->visitor.start_list = &opts_start_list; | |
382 | ov->visitor.next_list = &opts_next_list; | |
383 | ov->visitor.end_list = &opts_end_list; | |
384 | ||
385 | /* input_type_enum() covers both "normal" enums and union discriminators. | |
386 | * The union discriminator field is always generated as "type"; it should | |
387 | * match the "type" QemuOpt child of any QemuOpts. | |
388 | * | |
389 | * input_type_enum() will remove the looked-up key from the | |
390 | * "unprocessed_opts" hash even if the lookup fails, because the removal is | |
391 | * done earlier in opts_type_str(). This should be harmless. | |
392 | */ | |
393 | ov->visitor.type_enum = &input_type_enum; | |
394 | ||
395 | ov->visitor.type_int = &opts_type_int; | |
396 | ov->visitor.type_uint64 = &opts_type_uint64; | |
397 | ov->visitor.type_size = &opts_type_size; | |
398 | ov->visitor.type_bool = &opts_type_bool; | |
399 | ov->visitor.type_str = &opts_type_str; | |
400 | ||
401 | /* type_number() is not filled in, but this is not the first visitor to | |
402 | * skip some mandatory methods... */ | |
403 | ||
404 | ov->visitor.start_optional = &opts_start_optional; | |
405 | ||
406 | ov->opts_root = opts; | |
407 | ||
408 | return ov; | |
409 | } | |
410 | ||
411 | ||
412 | void | |
413 | opts_visitor_cleanup(OptsVisitor *ov) | |
414 | { | |
415 | if (ov->unprocessed_opts != NULL) { | |
416 | g_hash_table_destroy(ov->unprocessed_opts); | |
417 | } | |
418 | g_free(ov->fake_id_opt); | |
419 | memset(ov, '\0', sizeof *ov); | |
420 | } | |
421 | ||
422 | ||
423 | Visitor * | |
424 | opts_get_visitor(OptsVisitor *ov) | |
425 | { | |
426 | return &ov->visitor; | |
427 | } |