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