430 lines
11 KiB
C
430 lines
11 KiB
C
/*
|
|
* Options Visitor
|
|
*
|
|
* Copyright Red Hat, Inc. 2012
|
|
*
|
|
* Author: Laszlo Ersek <lersek@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*
|
|
*/
|
|
|
|
#include "qemu-common.h"
|
|
#include "qapi/qmp/qerror.h"
|
|
#include "qapi/opts-visitor.h"
|
|
#include "qemu/queue.h"
|
|
#include "qemu/option_int.h"
|
|
#include "qapi/visitor-impl.h"
|
|
|
|
|
|
struct OptsVisitor
|
|
{
|
|
Visitor visitor;
|
|
|
|
/* Ownership remains with opts_visitor_new()'s caller. */
|
|
const QemuOpts *opts_root;
|
|
|
|
unsigned depth;
|
|
|
|
/* Non-null iff depth is positive. Each key is a QemuOpt name. Each value
|
|
* is a non-empty GQueue, enumerating all QemuOpt occurrences with that
|
|
* name. */
|
|
GHashTable *unprocessed_opts;
|
|
|
|
/* The list currently being traversed with opts_start_list() /
|
|
* opts_next_list(). The list must have a struct element type in the
|
|
* schema, with a single mandatory scalar member. */
|
|
GQueue *repeated_opts;
|
|
bool repeated_opts_first;
|
|
|
|
/* If "opts_root->id" is set, reinstantiate it as a fake QemuOpt for
|
|
* uniformity. Only its "name" and "str" fields are set. "fake_id_opt" does
|
|
* not survive or escape the OptsVisitor object.
|
|
*/
|
|
QemuOpt *fake_id_opt;
|
|
};
|
|
|
|
|
|
static void
|
|
destroy_list(gpointer list)
|
|
{
|
|
g_queue_free(list);
|
|
}
|
|
|
|
|
|
static void
|
|
opts_visitor_insert(GHashTable *unprocessed_opts, const QemuOpt *opt)
|
|
{
|
|
GQueue *list;
|
|
|
|
list = g_hash_table_lookup(unprocessed_opts, opt->name);
|
|
if (list == NULL) {
|
|
list = g_queue_new();
|
|
|
|
/* GHashTable will never try to free the keys -- we supply NULL as
|
|
* "key_destroy_func" in opts_start_struct(). Thus cast away key
|
|
* const-ness in order to suppress gcc's warning.
|
|
*/
|
|
g_hash_table_insert(unprocessed_opts, (gpointer)opt->name, list);
|
|
}
|
|
|
|
/* Similarly, destroy_list() doesn't call g_queue_free_full(). */
|
|
g_queue_push_tail(list, (gpointer)opt);
|
|
}
|
|
|
|
|
|
static void
|
|
opts_start_struct(Visitor *v, void **obj, const char *kind,
|
|
const char *name, size_t size, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
const QemuOpt *opt;
|
|
|
|
*obj = g_malloc0(size > 0 ? size : 1);
|
|
if (ov->depth++ > 0) {
|
|
return;
|
|
}
|
|
|
|
ov->unprocessed_opts = g_hash_table_new_full(&g_str_hash, &g_str_equal,
|
|
NULL, &destroy_list);
|
|
QTAILQ_FOREACH(opt, &ov->opts_root->head, next) {
|
|
/* ensured by qemu-option.c::opts_do_parse() */
|
|
assert(strcmp(opt->name, "id") != 0);
|
|
|
|
opts_visitor_insert(ov->unprocessed_opts, opt);
|
|
}
|
|
|
|
if (ov->opts_root->id != NULL) {
|
|
ov->fake_id_opt = g_malloc0(sizeof *ov->fake_id_opt);
|
|
|
|
ov->fake_id_opt->name = "id";
|
|
ov->fake_id_opt->str = ov->opts_root->id;
|
|
opts_visitor_insert(ov->unprocessed_opts, ov->fake_id_opt);
|
|
}
|
|
}
|
|
|
|
|
|
static gboolean
|
|
ghr_true(gpointer ign_key, gpointer ign_value, gpointer ign_user_data)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void
|
|
opts_end_struct(Visitor *v, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
GQueue *any;
|
|
|
|
if (--ov->depth > 0) {
|
|
return;
|
|
}
|
|
|
|
/* we should have processed all (distinct) QemuOpt instances */
|
|
any = g_hash_table_find(ov->unprocessed_opts, &ghr_true, NULL);
|
|
if (any) {
|
|
const QemuOpt *first;
|
|
|
|
first = g_queue_peek_head(any);
|
|
error_set(errp, QERR_INVALID_PARAMETER, first->name);
|
|
}
|
|
g_hash_table_destroy(ov->unprocessed_opts);
|
|
ov->unprocessed_opts = NULL;
|
|
g_free(ov->fake_id_opt);
|
|
ov->fake_id_opt = NULL;
|
|
}
|
|
|
|
|
|
static GQueue *
|
|
lookup_distinct(const OptsVisitor *ov, const char *name, Error **errp)
|
|
{
|
|
GQueue *list;
|
|
|
|
list = g_hash_table_lookup(ov->unprocessed_opts, name);
|
|
if (!list) {
|
|
error_set(errp, QERR_MISSING_PARAMETER, name);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
|
|
static void
|
|
opts_start_list(Visitor *v, const char *name, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
|
|
/* we can't traverse a list in a list */
|
|
assert(ov->repeated_opts == NULL);
|
|
ov->repeated_opts = lookup_distinct(ov, name, errp);
|
|
ov->repeated_opts_first = (ov->repeated_opts != NULL);
|
|
}
|
|
|
|
|
|
static GenericList *
|
|
opts_next_list(Visitor *v, GenericList **list, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
GenericList **link;
|
|
|
|
if (ov->repeated_opts_first) {
|
|
ov->repeated_opts_first = false;
|
|
link = list;
|
|
} else {
|
|
const QemuOpt *opt;
|
|
|
|
opt = g_queue_pop_head(ov->repeated_opts);
|
|
if (g_queue_is_empty(ov->repeated_opts)) {
|
|
g_hash_table_remove(ov->unprocessed_opts, opt->name);
|
|
return NULL;
|
|
}
|
|
link = &(*list)->next;
|
|
}
|
|
|
|
*link = g_malloc0(sizeof **link);
|
|
return *link;
|
|
}
|
|
|
|
|
|
static void
|
|
opts_end_list(Visitor *v, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
|
|
ov->repeated_opts = NULL;
|
|
}
|
|
|
|
|
|
static const QemuOpt *
|
|
lookup_scalar(const OptsVisitor *ov, const char *name, Error **errp)
|
|
{
|
|
if (ov->repeated_opts == NULL) {
|
|
GQueue *list;
|
|
|
|
/* the last occurrence of any QemuOpt takes effect when queried by name
|
|
*/
|
|
list = lookup_distinct(ov, name, errp);
|
|
return list ? g_queue_peek_tail(list) : NULL;
|
|
}
|
|
return g_queue_peek_head(ov->repeated_opts);
|
|
}
|
|
|
|
|
|
static void
|
|
processed(OptsVisitor *ov, const char *name)
|
|
{
|
|
if (ov->repeated_opts == NULL) {
|
|
g_hash_table_remove(ov->unprocessed_opts, name);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
opts_type_str(Visitor *v, char **obj, const char *name, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
const QemuOpt *opt;
|
|
|
|
opt = lookup_scalar(ov, name, errp);
|
|
if (!opt) {
|
|
return;
|
|
}
|
|
*obj = g_strdup(opt->str ? opt->str : "");
|
|
processed(ov, name);
|
|
}
|
|
|
|
|
|
/* mimics qemu-option.c::parse_option_bool() */
|
|
static void
|
|
opts_type_bool(Visitor *v, bool *obj, const char *name, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
const QemuOpt *opt;
|
|
|
|
opt = lookup_scalar(ov, name, errp);
|
|
if (!opt) {
|
|
return;
|
|
}
|
|
|
|
if (opt->str) {
|
|
if (strcmp(opt->str, "on") == 0 ||
|
|
strcmp(opt->str, "yes") == 0 ||
|
|
strcmp(opt->str, "y") == 0) {
|
|
*obj = true;
|
|
} else if (strcmp(opt->str, "off") == 0 ||
|
|
strcmp(opt->str, "no") == 0 ||
|
|
strcmp(opt->str, "n") == 0) {
|
|
*obj = false;
|
|
} else {
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
|
|
"on|yes|y|off|no|n");
|
|
return;
|
|
}
|
|
} else {
|
|
*obj = true;
|
|
}
|
|
|
|
processed(ov, name);
|
|
}
|
|
|
|
|
|
static void
|
|
opts_type_int(Visitor *v, int64_t *obj, const char *name, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
const QemuOpt *opt;
|
|
const char *str;
|
|
long long val;
|
|
char *endptr;
|
|
|
|
opt = lookup_scalar(ov, name, errp);
|
|
if (!opt) {
|
|
return;
|
|
}
|
|
str = opt->str ? opt->str : "";
|
|
|
|
errno = 0;
|
|
val = strtoll(str, &endptr, 0);
|
|
if (*str != '\0' && *endptr == '\0' && errno == 0 && INT64_MIN <= val &&
|
|
val <= INT64_MAX) {
|
|
*obj = val;
|
|
processed(ov, name);
|
|
return;
|
|
}
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name, "an int64 value");
|
|
}
|
|
|
|
|
|
static void
|
|
opts_type_uint64(Visitor *v, uint64_t *obj, const char *name, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
const QemuOpt *opt;
|
|
const char *str;
|
|
|
|
opt = lookup_scalar(ov, name, errp);
|
|
if (!opt) {
|
|
return;
|
|
}
|
|
|
|
str = opt->str;
|
|
if (str != NULL) {
|
|
while (isspace((unsigned char)*str)) {
|
|
++str;
|
|
}
|
|
|
|
if (*str != '-' && *str != '\0') {
|
|
unsigned long long val;
|
|
char *endptr;
|
|
|
|
/* non-empty, non-negative subject sequence */
|
|
errno = 0;
|
|
val = strtoull(str, &endptr, 0);
|
|
if (*endptr == '\0' && errno == 0 && val <= UINT64_MAX) {
|
|
*obj = val;
|
|
processed(ov, name);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
|
|
"an uint64 value");
|
|
}
|
|
|
|
|
|
static void
|
|
opts_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
const QemuOpt *opt;
|
|
int64_t val;
|
|
char *endptr;
|
|
|
|
opt = lookup_scalar(ov, name, errp);
|
|
if (!opt) {
|
|
return;
|
|
}
|
|
|
|
val = strtosz_suffix(opt->str ? opt->str : "", &endptr,
|
|
STRTOSZ_DEFSUFFIX_B);
|
|
if (val != -1 && *endptr == '\0') {
|
|
*obj = val;
|
|
processed(ov, name);
|
|
return;
|
|
}
|
|
error_set(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
|
|
"a size value representible as a non-negative int64");
|
|
}
|
|
|
|
|
|
static void
|
|
opts_start_optional(Visitor *v, bool *present, const char *name,
|
|
Error **errp)
|
|
{
|
|
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
|
|
|
|
/* we only support a single mandatory scalar field in a list node */
|
|
assert(ov->repeated_opts == NULL);
|
|
*present = (lookup_distinct(ov, name, NULL) != NULL);
|
|
}
|
|
|
|
|
|
OptsVisitor *
|
|
opts_visitor_new(const QemuOpts *opts)
|
|
{
|
|
OptsVisitor *ov;
|
|
|
|
ov = g_malloc0(sizeof *ov);
|
|
|
|
ov->visitor.start_struct = &opts_start_struct;
|
|
ov->visitor.end_struct = &opts_end_struct;
|
|
|
|
ov->visitor.start_list = &opts_start_list;
|
|
ov->visitor.next_list = &opts_next_list;
|
|
ov->visitor.end_list = &opts_end_list;
|
|
|
|
/* input_type_enum() covers both "normal" enums and union discriminators.
|
|
* The union discriminator field is always generated as "type"; it should
|
|
* match the "type" QemuOpt child of any QemuOpts.
|
|
*
|
|
* input_type_enum() will remove the looked-up key from the
|
|
* "unprocessed_opts" hash even if the lookup fails, because the removal is
|
|
* done earlier in opts_type_str(). This should be harmless.
|
|
*/
|
|
ov->visitor.type_enum = &input_type_enum;
|
|
|
|
ov->visitor.type_int = &opts_type_int;
|
|
ov->visitor.type_uint64 = &opts_type_uint64;
|
|
ov->visitor.type_size = &opts_type_size;
|
|
ov->visitor.type_bool = &opts_type_bool;
|
|
ov->visitor.type_str = &opts_type_str;
|
|
|
|
/* type_number() is not filled in, but this is not the first visitor to
|
|
* skip some mandatory methods... */
|
|
|
|
ov->visitor.start_optional = &opts_start_optional;
|
|
|
|
ov->opts_root = opts;
|
|
|
|
return ov;
|
|
}
|
|
|
|
|
|
void
|
|
opts_visitor_cleanup(OptsVisitor *ov)
|
|
{
|
|
if (ov->unprocessed_opts != NULL) {
|
|
g_hash_table_destroy(ov->unprocessed_opts);
|
|
}
|
|
g_free(ov->fake_id_opt);
|
|
g_free(ov);
|
|
}
|
|
|
|
|
|
Visitor *
|
|
opts_get_visitor(OptsVisitor *ov)
|
|
{
|
|
return &ov->visitor;
|
|
}
|