yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2024-12-22 19:15:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

qapi: Add new clone visitor

Browse source 
We have a couple places in the code base that want to deep-clone
one QAPI object into another, and they were resorting to serializing
the struct out to QObject then reparsing it. A much more efficient
version can be done by adding a new clone visitor.

Since cloning is still relatively uncommon, expose the use of the
new visitor via a QAPI_CLONE() macro that takes care of type-punning
the underlying function pointer, rather than generating lots of
unused functions for types that won't be cloned. And yes, we're
relying on the compiler treating all pointers equally, even though
a strict C program cannot portably do so - but we're not the first
one in the qemu code base to expect it to work (hello, glib!).

The choice of adding a fourth visitor type deserves some explanation.
On the surface, the clone visitor is mostly an input visitor (it
takes arbitrary input - in this case, another QAPI object - and
creates a new QAPI object during the course of the visit). But
ever since commit da72ab0 consolidated enum visits based on the
visitor type, using VISITOR_INPUT would cause us to run
visit_type_str(), even though for cloning there is nothing to do
(we just copy the enum value across, without regards to its mapping
to strings). Also, since our input happens to be a QAPI object,
we can also satisfy the internal checks for VISITOR_OUTPUT. So in
the end, I settled with a new VISITOR_CLONE, and chose its value
such that many internal checks can use 'v->type & mask', sticking
to 'v->type == value' where the difference matters.

Note that we can only clone objects (including alternates) and lists,
not built-ins or enums. The visitor core hides integer width from
the actual visitor (since commit 04e070d), and as long as that's the
case, we can't clone top-level integers. Then again, those can
always be cloned by direct copy, since they are not objects with
deep pointers, so it's no real loss. And restricting cloning to
just objects and lists is cleaner than restricting it to non-integers.
As such, I documented that the clone visitor is for direct use only
by code internal to QAPI, and should not be used on incomplete objects
(other than a hack to work around the fact that we allow NULL in place
of "" in visit_type_str() in other output visitors). Note that as
written, the clone visitor will never fail on a complete object.

Scalars (including enums) not at the root of the clone copy just fine
with no additional effort while visiting the scalar, by virtue of a
g_memdup() each time we push another struct onto the stack. Cloning
a string requires deduplication of a pointer, which means it can also
provide the guarantee of an input visitor of never producing NULL
even when still accepting NULL in place of "" the way the QMP output
visitor does.

Cloning an 'any' type could be possible by incrementing the QObject
refcnt, but it's not obvious whether that is better than implementing
a QObject deep clone. So for now, we document it as unsupported,
and intentionally omit the .type_any() callback to let a developer
know their usage needs implementation.

Add testsuite coverage for several different clone situations, to
ensure that the code is working. I also tested that valgrind was
happy with the test.

Backports commit a15fcc3cf69ee3d408f60d6cc316488d2b0249b4 from qemu
This commit is contained in:
Lioncash 2018-02-25 01:27:18 -05:00
parent 85af4b2030
commit 532f840dc3
No known key found for this signature in database
GPG key ID: 4E3C3CC1031BA9C7
10 changed files with 301 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
msvc/unicorn/unicorn/unicorn.vcxproj
View file

@ -198,6 +198,7 @@ copy $(SolutionDir)..\include\unicorn\*.h $(SolutionDir)distro\include\unicorn\
<ClCompile Include="..\..\..\qemu\crypto\aes.c" />
<ClCompile Include="..\..\..\qemu\hw\core\machine.c" />
<ClCompile Include="..\..\..\qemu\hw\core\qdev.c" />
<ClCompile Include="..\..\..\qemu\qapi\qmp-clone-visitor.c" />
<ClCompile Include="..\..\..\qemu\qapi\qapi-dealloc-visitor.c" />
<ClCompile Include="..\..\..\qemu\qapi\qapi-visit-core.c" />
<ClCompile Include="..\..\..\qemu\qapi\qmp-input-visitor.c" />
@ -311,6 +312,7 @@ copy $(SolutionDir)..\include\unicorn\*.h $(SolutionDir)distro\include\unicorn\
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sparc.h" />
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sparc32_dma.h" />
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sun4m.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\clone-visitor.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\dealloc-visitor.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\error.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\opts-visitor.h" />

6
msvc/unicorn/unicorn/unicorn.vcxproj.filters
View file

@ -68,6 +68,9 @@
<ClCompile Include="..\..\..\qemu\hw\core\qdev.c">
<Filter>qemu\hw\core</Filter>
</ClCompile>
<ClCompile Include="..\..\..\qemu\qapi\qapi-clone-visitor.c">
<Filter>qemu\qapi</Filter>
</ClCompile>
<ClCompile Include="..\..\..\qemu\qapi\qapi-dealloc-visitor.c">
<Filter>qemu\qapi</Filter>
</ClCompile>
@ -367,6 +370,9 @@
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sun4m.h">
<Filter>qemu\include\hw\sparc</Filter>
</ClInclude>
<ClInclude Include="..\..\..\qemu\include\qapi\clone-visitor.h">
<Filter>qemu\include\qapi</Filter>
</ClInclude>
<ClInclude Include="..\..\..\qemu\include\qapi\dealloc-visitor.h">
<Filter>qemu\include\qapi</Filter>
</ClInclude>

2
msvc/unicorn/unicorn_static/unicorn_static.vcxproj
View file

@ -26,6 +26,7 @@
<ClCompile Include="..\..\..\qemu\crypto\hash.c" />
<ClCompile Include="..\..\..\qemu\hw\core\machine.c" />
<ClCompile Include="..\..\..\qemu\hw\core\qdev.c" />
<ClCompile Include="..\..\..\qemu\qapi\qapi-clone-visitor.c" />
<ClCompile Include="..\..\..\qemu\qapi\qapi-dealloc-visitor.c" />
<ClCompile Include="..\..\..\qemu\qapi\qapi-visit-core.c" />
<ClCompile Include="..\..\..\qemu\qapi\qmp-input-visitor.c" />
@ -125,6 +126,7 @@
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sparc.h" />
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sparc32_dma.h" />
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sun4m.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\clone-visitor.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\dealloc-visitor.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\error.h" />
<ClInclude Include="..\..\..\qemu\include\qapi\opts-visitor.h" />

6
msvc/unicorn/unicorn_static/unicorn_static.vcxproj.filters
View file

@ -99,6 +99,9 @@
<ClCompile Include="..\..\..\qemu\hw\core\qdev.c">
<Filter>qemu\hw\core</Filter>
</ClCompile>
<ClCompile Include="..\..\..\qemu\qapi\qapi-clone-visitor.c">
<Filter>qemu\qapi</Filter>
</ClCompile>
<ClCompile Include="..\..\..\qemu\qapi\qapi-dealloc-visitor.c">
<Filter>qemu\qapi</Filter>
</ClCompile>
@ -357,6 +360,9 @@
<ClInclude Include="..\..\..\qemu\include\hw\sparc\sun4m.h">
<Filter>qemu\include\hw\sparc</Filter>
</ClInclude>
<ClInclude Include="..\..\..\qemu\include\qapi\clone-visitor.h">
<Filter>qemu\include\qapi</Filter>
</ClInclude>
<ClInclude Include="..\..\..\qemu\include\qapi\dealloc-visitor.h">
<Filter>qemu\include\qapi</Filter>
</ClInclude>

37
qemu/include/qapi/clone-visitor.h Normal file
View file

@ -0,0 +1,37 @@
/*
* Clone Visitor
*
* Copyright (C) 2016 Red Hat, Inc.
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*
*/
#ifndef QAPI_CLONE_VISITOR_H
#define QAPI_CLONE_VISITOR_H
#include "qapi/visitor.h"
/*
* The clone visitor is for direct use only by the QAPI_CLONE() macro;
* it requires that the root visit occur on an object, list, or
* alternate, and is not usable directly on built-in QAPI types.
*/
typedef struct QapiCloneVisitor QapiCloneVisitor;
void *qapi_clone(const void *src, void (*visit_type)(Visitor *, const char *,
void **, Error **));
/*
* Deep-clone QAPI object @src of the given @type, and return the result.
*
* Not usable on QAPI scalars (integers, strings, enums), nor on a
* QAPI object that references the 'any' type. Safe when @src is NULL.
*/
#define QAPI_CLONE(type, src) \
((type *)qapi_clone(src, \
(void (*)(Visitor *, const char *, void**, \
Error **))visit_type_ ## type))
#endif

14
qemu/include/qapi/visitor-impl.h
View file

@ -28,14 +28,18 @@
*/
/*
* There are three classes of visitors; setting the class determines
* There are four classes of visitors; setting the class determines
* how QAPI enums are visited, as well as what additional restrictions
* can be asserted.
* can be asserted. The values are intentionally chosen so as to
* permit some assertions based on whether a given bit is set (that
* is, some assertions apply to input and clone visitors, some
* assertions apply to output and clone visitors).
*/
typedef enum VisitorType {
VISITOR_INPUT,
VISITOR_OUTPUT,
VISITOR_DEALLOC,
VISITOR_INPUT = 1,
VISITOR_OUTPUT = 2,
VISITOR_CLONE = 3,
VISITOR_DEALLOC = 4,
} VisitorType;
struct Visitor

66
qemu/include/qapi/visitor.h
View file

@ -26,15 +26,16 @@
* for doing work at each node of a QAPI graph; it can also be used
* for a virtual walk, where there is no actual QAPI C struct.
*
* There are three kinds of visitor classes: input visitors (QMP,
* There are four kinds of visitor classes: input visitors (QMP,
* string, and QemuOpts) parse an external representation and build
* the corresponding QAPI graph, output visitors (QMP and string) take
* a completed QAPI graph and generate an external representation, and
* the dealloc visitor can take a QAPI graph (possibly partially
* constructed) and recursively free its resources. While the dealloc
* and QMP input/output visitors are general, the string and QemuOpts
* visitors have some implementation limitations; see the
* documentation for each visitor for more details on what it
* a completed QAPI graph and generate an external representation, the
* dealloc visitor can take a QAPI graph (possibly partially
* constructed) and recursively free its resources, and the clone
* visitor performs a deep clone of one QAPI object to another. While
* the dealloc and QMP input/output visitors are general, the string,
* QemuOpts, and clone visitors have some implementation limitations;
* see the documentation for each visitor for more details on what it
* supports. Also, see visitor-impl.h for the callback contracts
* implemented by each visitor, and docs/qapi-code-gen.txt for more
* about the QAPI code generator.
@ -82,9 +83,9 @@
*
* If an error is detected during visit_type_FOO() with an input
* visitor, then *@obj will be NULL for pointer types, and left
* unchanged for scalar types. Using an output visitor with an
* incomplete object has undefined behavior (other than a special case
* for visit_type_str() treating NULL like ""), while the dealloc
* unchanged for scalar types. Using an output or clone visitor with
* an incomplete object has undefined behavior (other than a special
* case for visit_type_str() treating NULL like ""), while the dealloc
* visitor safely handles incomplete objects. Since input visitors
* never produce an incomplete object, such an object is possible only
* by manual construction.
@ -104,11 +105,19 @@
*
* void qapi_free_FOO(FOO *obj);
*
* which behaves like free() in that @obj may be NULL. Because of
* these functions, the dealloc visitor is seldom used directly
* outside of generated code. QAPI types can also inherit from a base
* class; when this happens, a function is generated for easily going
* from the derived type to the base type:
* where behaves like free() in that @obj may be NULL. Such objects
* may also be used with the following macro, provided alongside the
* clone visitor:
*
* Type *QAPI_CLONE(Type, src);
*
* in order to perform a deep clone of @src. Because of the generated
* qapi_free functions and the QAPI_CLONE() macro, the clone and
* dealloc visitor should not be used directly outside of QAPI code.
*
* QAPI types can also inherit from a base class; when this happens, a
* function is generated for easily going from the derived type to the
* base type:
*
* BASE *qapi_CHILD_base(CHILD *obj);
*
@ -275,9 +284,9 @@ void visit_free(Visitor *v);
* container; see the general description of @name above.
*
* @obj must be non-NULL for a real walk, in which case @size
* determines how much memory an input visitor will allocate into
* *@obj. @obj may also be NULL for a virtual walk, in which case
* @size is ignored.
* determines how much memory an input or clone visitor will allocate
* into *@obj. @obj may also be NULL for a virtual walk, in which
* case @size is ignored.
*
* @errp obeys typical error usage, and reports failures such as a
* member @name is not present, or present but not an object. On
@ -330,9 +339,9 @@ void visit_end_struct(Visitor *v, void **obj);
* container; see the general description of @name above.
*
* @list must be non-NULL for a real walk, in which case @size
* determines how much memory an input visitor will allocate into
* *@list (at least sizeof(GenericList)). Some visitors also allow
* @list to be NULL for a virtual walk, in which case @size is
* determines how much memory an input or clone visitor will allocate
* into *@list (at least sizeof(GenericList)). Some visitors also
* allow @list to be NULL for a virtual walk, in which case @size is
* ignored.
*
* @errp obeys typical error usage, and reports failures such as a
@ -391,10 +400,10 @@ void visit_end_list(Visitor *v, void **list);
* @name expresses the relationship of this alternate to its parent
* container; see the general description of @name above.
*
* @obj must not be NULL. Input visitors use @size to determine how
* much memory to allocate into *@obj, then determine the qtype of the
* next thing to be visited, stored in (*@obj)->type. Other visitors
* will leave @obj unchanged.
* @obj must not be NULL. Input and clone visitors use @size to
* determine how much memory to allocate into *@obj, then determine
* the qtype of the next thing to be visited, stored in (*@obj)->type.
* Other visitors will leave @obj unchanged.
*
* If @promote_int, treat integers as QTYPE_FLOAT.
*
@ -558,9 +567,10 @@ void visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp);
* @name expresses the relationship of this string to its parent
* container; see the general description of @name above.
*
* @obj must be non-NULL. Input visitors set *@obj to the value
* (never NULL). Other visitors leave *@obj unchanged, and commonly
* treat NULL like "".
* @obj must be non-NULL. Input and clone visitors set *@obj to the
* value (always using "" rather than NULL for an empty string).
* Other visitors leave *@obj unchanged, and commonly treat NULL like
* "".
*
* It is safe to cast away const when preparing a (const char *) value
* into @obj for use by an output visitor.

1
qemu/qapi/Makefile.objs
View file

@ -1,3 +1,4 @@
util-obj-y = qapi-visit-core.o qapi-dealloc-visitor.o qmp-input-visitor.o
util-obj-y += qapi-clone-visitor.o
util-obj-y += qmp-output-visitor.o
util-obj-y += string-input-visitor.o

182
qemu/qapi/qapi-clone-visitor.c Normal file
View file

@ -0,0 +1,182 @@
/*
* Copy one QAPI object to another
*
* Copyright (C) 2016 Red Hat, Inc.
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*
*/
#include "qemu/osdep.h"
#include "qapi/clone-visitor.h"
#include "qapi/visitor-impl.h"
#include "qapi/error.h"
struct QapiCloneVisitor {
Visitor visitor;
size_t depth;
};
static QapiCloneVisitor *to_qcv(Visitor *v)
{
return container_of(v, QapiCloneVisitor, visitor);
}
static void qapi_clone_start_struct(Visitor *v, const char *name, void **obj,
size_t size, Error **errp)
{
QapiCloneVisitor *qcv = to_qcv(v);
if (!obj) {
assert(qcv->depth);
/* Only possible when visiting an alternate's object
* branch. Nothing further to do here, since the earlier
* visit_start_alternate() already copied memory. */
return;
}
*obj = g_memdup(*obj, size);
qcv->depth++;
}
static void qapi_clone_end(Visitor *v, void **obj)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
if (obj) {
qcv->depth--;
}
}
static void qapi_clone_start_list(Visitor *v, const char *name,
GenericList **listp, size_t size,
Error **errp)
{
qapi_clone_start_struct(v, name, (void **)listp, size, errp);
}
static GenericList *qapi_clone_next_list(Visitor *v, GenericList *tail,
size_t size)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
/* Unshare the tail of the list cloned by g_memdup() */
tail->next = g_memdup(tail->next, size);
return tail->next;
}
static void qapi_clone_start_alternate(Visitor *v, const char *name,
GenericAlternate **obj, size_t size,
bool promote_int, Error **errp)
{
qapi_clone_start_struct(v, name, (void **)obj, size, errp);
}
static void qapi_clone_type_int64(Visitor *v, const char *name, int64_t *obj,
Error **errp)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
/* Value was already cloned by g_memdup() */
}
static void qapi_clone_type_uint64(Visitor *v, const char *name,
uint64_t *obj, Error **errp)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
/* Value was already cloned by g_memdup() */
}
static void qapi_clone_type_bool(Visitor *v, const char *name, bool *obj,
Error **errp)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
/* Value was already cloned by g_memdup() */
}
static void qapi_clone_type_str(Visitor *v, const char *name, char **obj,
Error **errp)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
/*
* Pointer was already cloned by g_memdup; create fresh copy.
* Note that as long as qmp-output-visitor accepts NULL instead of
* "", then we must do likewise. However, we want to obey the
* input visitor semantics of never producing NULL when the empty
* string is intended.
*/
*obj = g_strdup(*obj ?: "");
}
static void qapi_clone_type_number(Visitor *v, const char *name, double *obj,
Error **errp)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
/* Value was already cloned by g_memdup() */
}
static void qapi_clone_type_null(Visitor *v, const char *name, Error **errp)
{
QapiCloneVisitor *qcv = to_qcv(v);
assert(qcv->depth);
/* Nothing to do */
}
static void qapi_clone_free(Visitor *v)
{
g_free(v);
}
static Visitor *qapi_clone_visitor_new(void)
{
QapiCloneVisitor *v;
v = g_malloc0(sizeof(*v));
v->visitor.type = VISITOR_CLONE;
v->visitor.start_struct = qapi_clone_start_struct;
v->visitor.end_struct = qapi_clone_end;
v->visitor.start_list = qapi_clone_start_list;
v->visitor.next_list = qapi_clone_next_list;
v->visitor.end_list = qapi_clone_end;
v->visitor.start_alternate = qapi_clone_start_alternate;
v->visitor.end_alternate = qapi_clone_end;
v->visitor.type_int64 = qapi_clone_type_int64;
v->visitor.type_uint64 = qapi_clone_type_uint64;
v->visitor.type_bool = qapi_clone_type_bool;
v->visitor.type_str = qapi_clone_type_str;
v->visitor.type_number = qapi_clone_type_number;
v->visitor.type_null = qapi_clone_type_null;
v->visitor.free = qapi_clone_free;
return &v->visitor;
}
void *qapi_clone(const void *src, void (*visit_type)(Visitor *, const char *,
void **, Error **))
{
Visitor *v;
void *dst = (void *) src; /* Cast away const */
if (!src) {
return NULL;
}
v = qapi_clone_visitor_new();
visit_type(v, NULL, &dst, &error_abort);
visit_free(v);
return dst;
}

26
qemu/qapi/qapi-visit-core.c
View file

@ -43,10 +43,10 @@ void visit_start_struct(Visitor *v, const char *name, void **obj,
if (obj) {
assert(size);
assert(v->type != VISITOR_OUTPUT || *obj);
assert(!(v->type & VISITOR_OUTPUT) || *obj);
}
v->start_struct(v, name, obj, size, &err);
if (obj && v->type == VISITOR_INPUT) {
if (obj && (v->type & VISITOR_INPUT)) {
assert(!err != !*obj);
}
error_propagate(errp, err);
@ -71,7 +71,7 @@ void visit_start_list(Visitor *v, const char *name, GenericList **list,
assert(!list || size >= sizeof(GenericList));
v->start_list(v, name, list, size, &err);
if (list && v->type == VISITOR_INPUT) {
if (list && (v->type & VISITOR_INPUT)) {
assert(!(err && *list));
}
error_propagate(errp, err);
@ -93,7 +93,7 @@ void visit_start_alternate(Visitor *v, const char *name,
bool promote_int, Error **errp)
{
assert(obj && size >= sizeof(GenericAlternate));
assert(v->type != VISITOR_OUTPUT || *obj);
assert(!(v->type & VISITOR_OUTPUT) || *obj);
if (v->start_alternate) {
v->start_alternate(v, name, obj, size, promote_int, errp);
}
@ -242,10 +242,10 @@ void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp)
assert(obj);
/* TODO: Fix callers to not pass NULL when they mean "", so that we
* can enable:
assert(v->type != VISITOR_OUTPUT || *obj);
assert(!(v->type & VISITOR_OUTPUT) || *obj);
*/
v->type_str(v, name, obj, &err);
if (v->type == VISITOR_INPUT) {
if (v->type & VISITOR_INPUT) {
assert(!err != !*obj);
}
error_propagate(errp, err);
@ -327,9 +327,19 @@ void visit_type_enum(Visitor *v, const char *name, int *obj,
const char *const strings[], Error **errp)
{
assert(strings);
if (v->type == VISITOR_INPUT) {
switch (v->type) {
case VISITOR_INPUT:
input_type_enum(v, name, obj, strings, errp);
} else if (v->type == VISITOR_OUTPUT) {
break;
case VISITOR_OUTPUT:
output_type_enum(v, name, obj, strings, errp);
break;
case VISITOR_CLONE:
/* nothing further to do, scalar value was already copied by
* g_memdup() during visit_start_*() */
break;
case VISITOR_DEALLOC:
/* nothing to deallocate for a scalar */
break;
}
}