]>
git.proxmox.com Git - mirror_qemu.git/blob - qobject/block-qdict.c
2 * Special QDict functions used by the block layer
4 * Copyright (c) 2013-2018 Red Hat, Inc.
6 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
7 * See the COPYING.LIB file in the top-level directory.
10 #include "qemu/osdep.h"
11 #include "block/qdict.h"
12 #include "qapi/qmp/qbool.h"
13 #include "qapi/qmp/qlist.h"
14 #include "qapi/qmp/qnum.h"
15 #include "qapi/qmp/qstring.h"
16 #include "qapi/qobject-input-visitor.h"
17 #include "qemu/cutils.h"
18 #include "qapi/error.h"
21 * qdict_copy_default(): If no entry mapped by 'key' exists in 'dst' yet, the
22 * value of 'key' in 'src' is copied there (and the refcount increased
25 void qdict_copy_default(QDict
*dst
, QDict
*src
, const char *key
)
29 if (qdict_haskey(dst
, key
)) {
33 val
= qdict_get(src
, key
);
35 qdict_put_obj(dst
, key
, qobject_ref(val
));
40 * qdict_set_default_str(): If no entry mapped by 'key' exists in 'dst' yet, a
41 * new QString initialised by 'val' is put there.
43 void qdict_set_default_str(QDict
*dst
, const char *key
, const char *val
)
45 if (qdict_haskey(dst
, key
)) {
49 qdict_put_str(dst
, key
, val
);
52 static void qdict_flatten_qdict(QDict
*qdict
, QDict
*target
,
55 static void qdict_flatten_qlist(QList
*qlist
, QDict
*target
, const char *prefix
)
58 const QListEntry
*entry
;
62 /* This function is never called with prefix == NULL, i.e., it is always
63 * called from within qdict_flatten_q(list|dict)(). Therefore, it does not
64 * need to remove list entries during the iteration (the whole list will be
65 * deleted eventually anyway from qdict_flatten_qdict()). */
68 entry
= qlist_first(qlist
);
70 for (i
= 0; entry
; entry
= qlist_next(entry
), i
++) {
71 value
= qlist_entry_obj(entry
);
72 new_key
= g_strdup_printf("%s.%i", prefix
, i
);
74 if (qobject_type(value
) == QTYPE_QDICT
) {
75 qdict_flatten_qdict(qobject_to(QDict
, value
), target
, new_key
);
76 } else if (qobject_type(value
) == QTYPE_QLIST
) {
77 qdict_flatten_qlist(qobject_to(QList
, value
), target
, new_key
);
79 /* All other types are moved to the target unchanged. */
80 qdict_put_obj(target
, new_key
, qobject_ref(value
));
87 static void qdict_flatten_qdict(QDict
*qdict
, QDict
*target
, const char *prefix
)
90 const QDictEntry
*entry
, *next
;
94 entry
= qdict_first(qdict
);
96 while (entry
!= NULL
) {
98 next
= qdict_next(qdict
, entry
);
99 value
= qdict_entry_value(entry
);
104 new_key
= g_strdup_printf("%s.%s", prefix
, entry
->key
);
107 if (qobject_type(value
) == QTYPE_QDICT
) {
108 /* Entries of QDicts are processed recursively, the QDict object
109 * itself disappears. */
110 qdict_flatten_qdict(qobject_to(QDict
, value
), target
,
111 new_key
? new_key
: entry
->key
);
113 } else if (qobject_type(value
) == QTYPE_QLIST
) {
114 qdict_flatten_qlist(qobject_to(QList
, value
), target
,
115 new_key
? new_key
: entry
->key
);
118 /* All other objects are moved to the target unchanged. */
119 qdict_put_obj(target
, new_key
, qobject_ref(value
));
126 qdict_del(qdict
, entry
->key
);
128 /* Restart loop after modifying the iterated QDict */
129 entry
= qdict_first(qdict
);
138 * qdict_flatten(): For each nested QDict with key x, all fields with key y
139 * are moved to this QDict and their key is renamed to "x.y". For each nested
140 * QList with key x, the field at index y is moved to this QDict with the key
141 * "x.y" (i.e., the reverse of what qdict_array_split() does).
142 * This operation is applied recursively for nested QDicts and QLists.
144 void qdict_flatten(QDict
*qdict
)
146 qdict_flatten_qdict(qdict
, qdict
, NULL
);
149 /* extract all the src QDict entries starting by start into dst */
150 void qdict_extract_subqdict(QDict
*src
, QDict
**dst
, const char *start
)
153 const QDictEntry
*entry
, *next
;
157 entry
= qdict_first(src
);
159 while (entry
!= NULL
) {
160 next
= qdict_next(src
, entry
);
161 if (strstart(entry
->key
, start
, &p
)) {
162 qdict_put_obj(*dst
, p
, qobject_ref(entry
->value
));
163 qdict_del(src
, entry
->key
);
169 static int qdict_count_prefixed_entries(const QDict
*src
, const char *start
)
171 const QDictEntry
*entry
;
174 for (entry
= qdict_first(src
); entry
; entry
= qdict_next(src
, entry
)) {
175 if (strstart(entry
->key
, start
, NULL
)) {
176 if (count
== INT_MAX
) {
187 * qdict_array_split(): This function moves array-like elements of a QDict into
188 * a new QList. Every entry in the original QDict with a key "%u" or one
189 * prefixed "%u.", where %u designates an unsigned integer starting at 0 and
190 * incrementally counting up, will be moved to a new QDict at index %u in the
191 * output QList with the key prefix removed, if that prefix is "%u.". If the
192 * whole key is just "%u", the whole QObject will be moved unchanged without
193 * creating a new QDict. The function terminates when there is no entry in the
194 * QDict with a prefix directly (incrementally) following the last one; it also
195 * returns if there are both entries with "%u" and "%u." for the same index %u.
196 * Example: {"0.a": 42, "0.b": 23, "1.x": 0, "4.y": 1, "o.o": 7, "2": 66}
197 * (or {"1.x": 0, "4.y": 1, "0.a": 42, "o.o": 7, "0.b": 23, "2": 66})
198 * => [{"a": 42, "b": 23}, {"x": 0}, 66]
199 * and {"4.y": 1, "o.o": 7} (remainder of the old QDict)
201 void qdict_array_split(QDict
*src
, QList
**dst
)
207 for (i
= 0; i
< UINT_MAX
; i
++) {
211 char indexstr
[32], prefix
[32];
214 snprintf_ret
= snprintf(indexstr
, 32, "%u", i
);
215 assert(snprintf_ret
< 32);
217 subqobj
= qdict_get(src
, indexstr
);
219 snprintf_ret
= snprintf(prefix
, 32, "%u.", i
);
220 assert(snprintf_ret
< 32);
222 /* Overflow is the same as positive non-zero results */
223 is_subqdict
= qdict_count_prefixed_entries(src
, prefix
);
226 * There may be either a single subordinate object (named
227 * "%u") or multiple objects (each with a key prefixed "%u."),
230 if (!subqobj
== !is_subqdict
) {
235 qdict_extract_subqdict(src
, &subqdict
, prefix
);
236 assert(qdict_size(subqdict
) > 0);
238 qobject_ref(subqobj
);
239 qdict_del(src
, indexstr
);
242 qlist_append_obj(*dst
, subqobj
?: QOBJECT(subqdict
));
247 * qdict_split_flat_key:
248 * @key: the key string to split
249 * @prefix: non-NULL pointer to hold extracted prefix
250 * @suffix: non-NULL pointer to remaining suffix
252 * Given a flattened key such as 'foo.0.bar', split it into two parts
253 * at the first '.' separator. Allows double dot ('..') to escape the
257 * 'foo.0.bar' -> prefix='foo' and suffix='0.bar'
258 * 'foo..0.bar' -> prefix='foo.0' and suffix='bar'
260 * The '..' sequence will be unescaped in the returned 'prefix'
261 * string. The 'suffix' string will be left in escaped format, so it
262 * can be fed back into the qdict_split_flat_key() key as the input
265 * The caller is responsible for freeing the string returned in @prefix
268 static void qdict_split_flat_key(const char *key
, char **prefix
,
271 const char *separator
;
274 /* Find first '.' separator, but if there is a pair '..'
275 * that acts as an escape, so skip over '..' */
283 separator
= strchr(separator
, '.');
284 } while (separator
&& separator
[1] == '.');
287 *prefix
= g_strndup(key
, separator
- key
);
288 *suffix
= separator
+ 1;
290 *prefix
= g_strdup(key
);
294 /* Unescape the '..' sequence into '.' */
295 for (i
= 0, j
= 0; (*prefix
)[i
] != '\0'; i
++, j
++) {
296 if ((*prefix
)[i
] == '.') {
297 assert((*prefix
)[i
+ 1] == '.');
300 (*prefix
)[j
] = (*prefix
)[i
];
307 * @maybe_list: dict to check if keys represent list elements.
309 * Determine whether all keys in @maybe_list are valid list elements.
310 * If @maybe_list is non-zero in length and all the keys look like
311 * valid list indexes, this will return 1. If @maybe_list is zero
312 * length or all keys are non-numeric then it will return 0 to indicate
313 * it is a normal qdict. If there is a mix of numeric and non-numeric
314 * keys, or the list indexes are non-contiguous, an error is reported.
316 * Returns: 1 if a valid list, 0 if a dict, -1 on error
318 static int qdict_is_list(QDict
*maybe_list
, Error
**errp
)
320 const QDictEntry
*ent
;
326 for (ent
= qdict_first(maybe_list
); ent
!= NULL
;
327 ent
= qdict_next(maybe_list
, ent
)) {
329 if (qemu_strtoi64(ent
->key
, NULL
, 10, &val
) == 0) {
332 } else if (!is_list
) {
334 "Cannot mix list and non-list keys");
344 } else if (is_list
) {
346 "Cannot mix list and non-list keys");
353 assert(!qdict_size(maybe_list
));
357 /* NB this isn't a perfect check - e.g. it won't catch
358 * a list containing '1', '+1', '01', '3', but that
359 * does not matter - we've still proved that the
360 * input is a list. It is up the caller to do a
361 * stricter check if desired */
362 if (len
!= (max
+ 1)) {
363 error_setg(errp
, "List indices are not contiguous, "
364 "saw %zd elements but %zd largest index",
374 * @src: the original flat dictionary (only scalar values) to crumple
376 * Takes a flat dictionary whose keys use '.' separator to indicate
377 * nesting, and values are scalars, and crumples it into a nested
380 * To include a literal '.' in a key name, it must be escaped as '..'
382 * For example, an input of:
384 * { 'foo.0.bar': 'one', 'foo.0.wizz': '1',
385 * 'foo.1.bar': 'two', 'foo.1.wizz': '2' }
387 * will result in an output of:
391 * { 'bar': 'one', 'wizz': '1' },
392 * { 'bar': 'two', 'wizz': '2' }
396 * The following scenarios in the input dict will result in an
397 * error being returned:
399 * - Any values in @src are non-scalar types
400 * - If keys in @src imply that a particular level is both a
401 * list and a dict. e.g., "foo.0.bar" and "foo.eek.bar".
402 * - If keys in @src imply that a particular level is a list,
403 * but the indices are non-contiguous. e.g. "foo.0.bar" and
404 * "foo.2.bar" without any "foo.1.bar" present.
405 * - If keys in @src represent list indexes, but are not in
406 * the "%zu" format. e.g. "foo.+0.bar"
408 * Returns: either a QDict or QList for the nested data structure, or NULL
411 QObject
*qdict_crumple(const QDict
*src
, Error
**errp
)
413 const QDictEntry
*ent
;
414 QDict
*two_level
, *multi_level
= NULL
;
415 QObject
*dst
= NULL
, *child
;
418 const char *suffix
= NULL
;
421 two_level
= qdict_new();
423 /* Step 1: split our totally flat dict into a two level dict */
424 for (ent
= qdict_first(src
); ent
!= NULL
; ent
= qdict_next(src
, ent
)) {
425 if (qobject_type(ent
->value
) == QTYPE_QDICT
||
426 qobject_type(ent
->value
) == QTYPE_QLIST
) {
427 error_setg(errp
, "Value %s is not a scalar",
432 qdict_split_flat_key(ent
->key
, &prefix
, &suffix
);
434 child
= qdict_get(two_level
, prefix
);
436 QDict
*child_dict
= qobject_to(QDict
, child
);
439 error_setg(errp
, "Key %s prefix is already set as a scalar",
444 child_dict
= qdict_new();
445 qdict_put_obj(two_level
, prefix
, QOBJECT(child_dict
));
448 qdict_put_obj(child_dict
, suffix
, qobject_ref(ent
->value
));
451 error_setg(errp
, "Key %s prefix is already set as a dict",
455 qdict_put_obj(two_level
, prefix
, qobject_ref(ent
->value
));
462 /* Step 2: optionally process the two level dict recursively
463 * into a multi-level dict */
464 multi_level
= qdict_new();
465 for (ent
= qdict_first(two_level
); ent
!= NULL
;
466 ent
= qdict_next(two_level
, ent
)) {
467 QDict
*dict
= qobject_to(QDict
, ent
->value
);
469 child
= qdict_crumple(dict
, errp
);
474 qdict_put_obj(multi_level
, ent
->key
, child
);
476 qdict_put_obj(multi_level
, ent
->key
, qobject_ref(ent
->value
));
479 qobject_unref(two_level
);
482 /* Step 3: detect if we need to turn our dict into list */
483 is_list
= qdict_is_list(multi_level
, errp
);
489 dst
= QOBJECT(qlist_new());
491 for (i
= 0; i
< qdict_size(multi_level
); i
++) {
492 char *key
= g_strdup_printf("%zu", i
);
494 child
= qdict_get(multi_level
, key
);
498 error_setg(errp
, "Missing list index %zu", i
);
502 qlist_append_obj(qobject_to(QList
, dst
), qobject_ref(child
));
504 qobject_unref(multi_level
);
507 dst
= QOBJECT(multi_level
);
514 qobject_unref(multi_level
);
515 qobject_unref(two_level
);
521 * qdict_crumple_for_keyval_qiv:
522 * @src: the flat dictionary (only scalar values) to crumple
523 * @errp: location to store error
525 * Like qdict_crumple(), but additionally transforms scalar values so
526 * the result can be passed to qobject_input_visitor_new_keyval().
528 * The block subsystem uses this function to prepare its flat QDict
529 * with possibly confused scalar types for a visit. It should not be
530 * used for anything else, and it should go away once the block
531 * subsystem has been cleaned up.
533 static QObject
*qdict_crumple_for_keyval_qiv(QDict
*src
, Error
**errp
)
538 const QDictEntry
*ent
;
541 for (ent
= qdict_first(src
); ent
; ent
= qdict_next(src
, ent
)) {
543 switch (qobject_type(ent
->value
)) {
548 s
= buf
= qnum_to_string(qobject_to(QNum
, ent
->value
));
552 /* @src isn't flat; qdict_crumple() will fail */
555 s
= qbool_get_bool(qobject_to(QBool
, ent
->value
))
563 tmp
= qdict_clone_shallow(src
);
565 qdict_put(tmp
, ent
->key
, qstring_from_str(s
));
569 dst
= qdict_crumple(tmp
?: src
, errp
);
575 * qdict_array_entries(): Returns the number of direct array entries if the
576 * sub-QDict of src specified by the prefix in subqdict (or src itself for
577 * prefix == "") is valid as an array, i.e. the length of the created list if
578 * the sub-QDict would become empty after calling qdict_array_split() on it. If
579 * the array is not valid, -EINVAL is returned.
581 int qdict_array_entries(QDict
*src
, const char *subqdict
)
583 const QDictEntry
*entry
;
585 unsigned entries
= 0;
586 size_t subqdict_len
= strlen(subqdict
);
588 assert(!subqdict_len
|| subqdict
[subqdict_len
- 1] == '.');
590 /* qdict_array_split() loops until UINT_MAX, but as we want to return
591 * negative errors, we only have a signed return value here. Any additional
592 * entries will lead to -EINVAL. */
593 for (i
= 0; i
< INT_MAX
; i
++) {
595 int subqdict_entries
;
596 char *prefix
= g_strdup_printf("%s%u.", subqdict
, i
);
598 subqdict_entries
= qdict_count_prefixed_entries(src
, prefix
);
600 /* Remove ending "." */
601 prefix
[strlen(prefix
) - 1] = 0;
602 subqobj
= qdict_get(src
, prefix
);
606 if (subqdict_entries
< 0) {
607 return subqdict_entries
;
610 /* There may be either a single subordinate object (named "%u") or
611 * multiple objects (each with a key prefixed "%u."), but not both. */
612 if (subqobj
&& subqdict_entries
) {
614 } else if (!subqobj
&& !subqdict_entries
) {
618 entries
+= subqdict_entries
? subqdict_entries
: 1;
621 /* Consider everything handled that isn't part of the given sub-QDict */
622 for (entry
= qdict_first(src
); entry
; entry
= qdict_next(src
, entry
)) {
623 if (!strstart(qdict_entry_key(entry
), subqdict
, NULL
)) {
628 /* Anything left in the sub-QDict that wasn't handled? */
629 if (qdict_size(src
) != entries
) {
637 * qdict_join(): Absorb the src QDict into the dest QDict, that is, move all
638 * elements from src to dest.
640 * If an element from src has a key already present in dest, it will not be
641 * moved unless overwrite is true.
643 * If overwrite is true, the conflicting values in dest will be discarded and
644 * replaced by the corresponding values from src.
646 * Therefore, with overwrite being true, the src QDict will always be empty when
647 * this function returns. If overwrite is false, the src QDict will be empty
648 * iff there were no conflicts.
650 void qdict_join(QDict
*dest
, QDict
*src
, bool overwrite
)
652 const QDictEntry
*entry
, *next
;
654 entry
= qdict_first(src
);
656 next
= qdict_next(src
, entry
);
658 if (overwrite
|| !qdict_haskey(dest
, entry
->key
)) {
659 qdict_put_obj(dest
, entry
->key
, qobject_ref(entry
->value
));
660 qdict_del(src
, entry
->key
);
668 * qdict_rename_keys(): Rename keys in qdict according to the replacements
669 * specified in the array renames. The array must be terminated by an entry
672 * The renames are performed individually in the order of the array, so entries
673 * may be renamed multiple times and may or may not conflict depending on the
674 * order of the renames array.
676 * Returns true for success, false in error cases.
678 bool qdict_rename_keys(QDict
*qdict
, const QDictRenames
*renames
, Error
**errp
)
682 while (renames
->from
) {
683 if (qdict_haskey(qdict
, renames
->from
)) {
684 if (qdict_haskey(qdict
, renames
->to
)) {
685 error_setg(errp
, "'%s' and its alias '%s' can't be used at the "
686 "same time", renames
->to
, renames
->from
);
690 qobj
= qdict_get(qdict
, renames
->from
);
691 qdict_put_obj(qdict
, renames
->to
, qobject_ref(qobj
));
692 qdict_del(qdict
, renames
->from
);
701 * Create a QObject input visitor for flat @qdict with possibly
702 * confused scalar types.
704 * The block subsystem uses this function to visit its flat QDict with
705 * possibly confused scalar types. It should not be used for anything
706 * else, and it should go away once the block subsystem has been
709 Visitor
*qobject_input_visitor_new_flat_confused(QDict
*qdict
,
715 crumpled
= qdict_crumple_for_keyval_qiv(qdict
, errp
);
720 v
= qobject_input_visitor_new_keyval(crumpled
);
721 qobject_unref(crumpled
);