[Qemu-commits] [qemu/qemu] 2ea179: qapi-schema: mark InetSocketAddress as mandatory a...

[GitHub]

  Branch: refs/heads/master
  Home:   https://github.com/qemu/qemu
  Commit: 2ea1793bd90f04c34fbb75a1b84d71cb5b1f9c08
      
https://github.com/qemu/qemu/commit/2ea1793bd90f04c34fbb75a1b84d71cb5b1f9c08
  Author: Daniel P. Berrange <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M qapi-schema.json

  Log Message:
  -----------
  qapi-schema: mark InetSocketAddress as mandatory again

Revert the qapi-schema.json change done in:

  commit 0983f5e6af76d5df8c6346cbdfff9d8305fb6da0
  Author: Daniel P. Berrange <address@hidden>
  Date:   Tue Sep 1 14:46:50 2015 +0100

    sockets: allow port to be NULL when listening on IP address

Switching "port" from mandatory to optional causes the QAPI
code generator to add a 'has_port' field to the InetSocketAddress
struct. No code that created InetSocketAddress objects was updated
to set 'has_port = true', which caused the non-NULL port strings
to be silently dropped when copying InetSocketAddress objects.

Reported-by: Knut Omang <address@hidden>
Signed-off-by: Daniel P. Berrange <address@hidden>
Message-Id: <address@hidden>
Reviewed-by: Eric Blake <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 1976708321f21ed51d0a374db6b28a6cd1bd5d66
      
https://github.com/qemu/qemu/commit/1976708321f21ed51d0a374db6b28a6cd1bd5d66
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M tests/Makefile
    R tests/qapi-schema/enum-union-clash.err
    R tests/qapi-schema/enum-union-clash.exit
    R tests/qapi-schema/enum-union-clash.json
    R tests/qapi-schema/enum-union-clash.out
    M tests/qapi-schema/qapi-schema-test.json
    M tests/qapi-schema/qapi-schema-test.out
    A tests/qapi-schema/reserved-command-q.err
    A tests/qapi-schema/reserved-command-q.exit
    A tests/qapi-schema/reserved-command-q.json
    A tests/qapi-schema/reserved-command-q.out
    A tests/qapi-schema/reserved-member-has.err
    A tests/qapi-schema/reserved-member-has.exit
    A tests/qapi-schema/reserved-member-has.json
    A tests/qapi-schema/reserved-member-has.out
    A tests/qapi-schema/reserved-member-q.err
    A tests/qapi-schema/reserved-member-q.exit
    A tests/qapi-schema/reserved-member-q.json
    A tests/qapi-schema/reserved-member-q.out
    A tests/qapi-schema/reserved-type-kind.err
    A tests/qapi-schema/reserved-type-kind.exit
    A tests/qapi-schema/reserved-type-kind.json
    A tests/qapi-schema/reserved-type-kind.out
    A tests/qapi-schema/reserved-type-list.err
    A tests/qapi-schema/reserved-type-list.exit
    A tests/qapi-schema/reserved-type-list.json
    A tests/qapi-schema/reserved-type-list.out

  Log Message:
  -----------
  tests/qapi-schema: Test for reserved names, empty struct

Add some testsuite coverage to ensure future patches are on
the right track:

Our current C representation of qapi arrays is done by appending
'List' to the element name; but we are not preventing the
creation of an object type with the same name.  Add
reserved-type-list.json to test this.  Then rename
enum-union-clash.json to reserved-type-kind.json to cover the
reservation that we DO detect, and shorten it to match the fact
that the name is reserved even if there is no clash.

We are failing to detect a collision between a dictionary member
and the implicit 'has_*' flag for another optional member. The
easiest fix would be for a future patch to reserve the entire
"has[-_]" namespace for member names (the collision is also
possible for branch names within flat unions, but only as long as
branch names can collide with (non-variant) members; however,
since future patches are about to remove that, it is not worth
testing here). Add reserved-member-has.json to test this.

A similar collision exists between a dictionary member where
c_name() munges what might otherwise be a reserved name to start
with 'q_', and another member explicitly starts with "q[-_]".
Again, the easiest solution for a future patch will be reserving
the entire namespace, but here for commands as well as members.
Add reserved-member-q.json and reserved-command-q.json to test
this; separate tests since arguably our munging of command 'unix'
to 'qmp_q_unix()' could be done without a q_, which is different
than the munging of a member 'unix' to 'foo.q_unix'.

Finally, our testsuite does not have any compilation coverage
of struct inheritance with empty qapi structs.  Update
qapi-schema-test.json to test this.

Note that there is currently no technical reason to forbid type
name patterns from member names, or member name patterns from
types, since the two are not in the same namespace in C and
won't collide; but it's not worth adding positive tests of these
corner cases at this time, especially while there is other churn
pending in patches that rearrange which collisions actually
happen.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 8712fa5333ad348da20034b717dd814219d1ec11
      
https://github.com/qemu/qemu/commit/8712fa5333ad348da20034b717dd814219d1ec11
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi.py

  Log Message:
  -----------
  qapi: More idiomatic string operations

Rather than slicing the end of a string, we can use python's
endswith().  And rather than creating a set of characters,
we can search for a character within a string.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: f9e6102b48f21e464a847a858a456c521e7a83e5
      
https://github.com/qemu/qemu/commit/f9e6102b48f21e464a847a858a456c521e7a83e5
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-commands.py
    M scripts/qapi-visit.py

  Log Message:
  -----------
  qapi: More robust conditions for when labels are needed

We were using regular expressions to see if ret included
any earlier text that emitted a 'goto out;' line, to decide
whether we needed to output an 'out:' label.  But this is
fragile, if the ret text can possibly combine more than one
generated function body, where the first function used a
goto but the second does not.  Change the code to just check
for the known conditions which cause an error check to be
needed.  Besides, it's slightly more efficient to use plain
checks than regular expression searching.

No change to generated code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 255960dd374d4497d6ea537305f1b0d8a3433789
      
https://github.com/qemu/qemu/commit/255960dd374d4497d6ea537305f1b0d8a3433789
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M docs/qapi-code-gen.txt
    M scripts/qapi.py
    M tests/qapi-schema/reserved-type-list.err
    M tests/qapi-schema/reserved-type-list.exit
    M tests/qapi-schema/reserved-type-list.json
    M tests/qapi-schema/reserved-type-list.out

  Log Message:
  -----------
  qapi: Reserve '*List' type names for list types

Type names ending in 'List' can clash with qapi list types in
generated C.  We don't currently use such names. It is easier to
outlaw them now than to worry about how to resolve such a clash
in the future. For precedence, see commit 4dc2e69, which did the
same for names ending in 'Kind' versus implicit enum types for
qapi unions.

Update the testsuite to match.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 9fb081e0b98409556d023c7193eeb68947cd1211
      
https://github.com/qemu/qemu/commit/9fb081e0b98409556d023c7193eeb68947cd1211
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M docs/qapi-code-gen.txt
    M scripts/qapi.py
    M tests/qapi-schema/reserved-command-q.err
    M tests/qapi-schema/reserved-command-q.exit
    M tests/qapi-schema/reserved-command-q.json
    M tests/qapi-schema/reserved-command-q.out
    M tests/qapi-schema/reserved-member-has.err
    M tests/qapi-schema/reserved-member-has.exit
    M tests/qapi-schema/reserved-member-has.json
    M tests/qapi-schema/reserved-member-has.out
    M tests/qapi-schema/reserved-member-q.err
    M tests/qapi-schema/reserved-member-q.exit
    M tests/qapi-schema/reserved-member-q.json
    M tests/qapi-schema/reserved-member-q.out

  Log Message:
  -----------
  qapi: Reserve 'q_*' and 'has_*' member names

c_name() produces names starting with 'q_' when protecting a
dictionary member name that would fail to directly compile, but
in doing so can cause clashes with any member name already
beginning with 'q-' or 'q_'.  Likewise, we create a C name 'has_'
for any optional member that can clash with any member name
beginning with 'has-' or 'has_'.

Technically, rather than blindly reserving the namespace,
we could try to complain about user names only when an actual
collision occurs, or even teach c_name() how to munge names
to avoid collisions.  But it is not trivial, especially when
collisions can occur across multiple types (such as via
inheritance or flat unions).  Besides, no existing .json
files are trying to use these names.  So it's easier to just
outright forbid the potential for collision.  We can always
relax things in the future if a real need arises for QMP to
express member names that have been forbidden here.

'has_' only has to be reserved for struct/union member names,
while 'q_' is reserved everywhere (matching the fact that
only members can be optional, while we use c_name() for munging
both members and entities).  Note that we could relax 'q_'
restrictions on entities independently from member names; for
example, c_name('qmp_' + 'unix') would result in a different
function name than our current 'qmp_' + c_name('unix').

Update and add tests to cover the new error messages.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Consistently pass protect=False to c_name(); commit message tweaked
slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 98481bfcd661daa3c160cc87a297b0e60a307788
      
https://github.com/qemu/qemu/commit/98481bfcd661daa3c160cc87a297b0e60a307788
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M ui/vnc.c

  Log Message:
  -----------
  vnc: Hoist allocation of VncBasicInfo to callers

A future qapi patch will rework generated structs with a base
class to be unboxed.  In preparation for that, change the code
that allocates then populates an info struct to instead merely
populate the fields of an info field passed in as a parameter
(renaming vnc_basic_info_get* to vnc_init_basic_info*). Add
rudimentary Error handling at the lowest levels for cases
where the old code returned NULL; but rather than plumb Error
all the way through the stack, the callers drop the error and
return NULL as before.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: d02cf37766ba3cf918d7085aa7848c9dc05fd11a
      
https://github.com/qemu/qemu/commit/d02cf37766ba3cf918d7085aa7848c9dc05fd11a
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-visit.py

  Log Message:
  -----------
  qapi-visit: Split off visit_type_FOO_fields forward decl

We generate a static visit_type_FOO_fields() for every type
FOO.  However, sometimes we need a forward declaration. Split
the code to generate the forward declaration out of
gen_visit_implicit_struct() into a new gen_visit_fields_decl(),
and also prepare for a forward declaration to be emitted
during gen_visit_struct(), so that a future patch can switch
from using visit_type_FOO_implicit() to the simpler
visit_type_FOO_fields() as part of unboxing the base class
of a struct.

No change to generated code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: f87ab7f9bd956250c48b5c6e9b607b537fd21543
      
https://github.com/qemu/qemu/commit/f87ab7f9bd956250c48b5c6e9b607b537fd21543
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-types.py

  Log Message:
  -----------
  qapi-types: Refactor base fields output

Move code from gen_union() into gen_struct_fields() in order for
a later patch to share code when enumerating inherited fields
for struct types.

No change to generated code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 30594fe1cd4355626e73b80645428105d0df3cf6
      
https://github.com/qemu/qemu/commit/30594fe1cd4355626e73b80645428105d0df3cf6
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-types.py
    M tests/test-qmp-input-visitor.c

  Log Message:
  -----------
  qapi: Prefer typesafe upcasts to qapi base classes

A previous patch (commit 1e6c1616) made it possible to
directly cast from a qapi flat union type to its base type.
However, it requires the use of a C cast, which turns off
compiler type-safety checks.  Fortunately, no such casts
exist, just yet.

Regardless, add inline type-safe wrappers named
qapi_FOO_base() for any union type FOO that has a base,
which can be used for a safer upcast, and enhance the
testsuite to cover the new functionality.

A future patch will extend the upcast support to structs,
where such conversions do exist already.

Note that C makes const-correct upcasts annoying because
it lacks overloads; these functions cast away const so that
they can accept user pointers whether const or not, and the
result in turn can be assigned to normal or const pointers.
Alternatively, this could have been done with macros, but
type-safe macros are hairy, and not worthwhile here.

This patch just adds upcasts.  None of our code needed to
downcast from a base qapi class to a child.  Also, in the
case of grandchildren (such as BlockdevOptionsQcow2), the
caller will need to call two functions to get to the inner
base (although it wouldn't be too hard to generate a
qapi_FOO_base_base() if desired).  If a user changes qapi
to alter the base class hierarchy, such as going from
'A -> C' to 'A -> B -> C', it will change the type of
'qapi_C_base()', and the compiler will point out the places
that are affected by the new base.

One alternative was proposed, but was deemed too ugly to use
in practice: the generators could output redundant
information using anonymous types:
| struct Child {
|     union {
|         struct {
|             Type1 parent_member1;
|             Type2 parent_member2;
|         };
|         Parent base;
|     };
| };
With that ugly proposal, for a given qapi type, obj->member
and obj->base.member would refer to the same storage; allowing
convenience in working with members without needing 'base.'
allowing typesafe upcast without needing a C cast by accessing
'&obj->base', and allowing downcasts from the parent back to
the child possible through container_of(obj, Child, base).

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: ddf21908961073199f3d186204da4810f2ea150b
      
https://github.com/qemu/qemu/commit/ddf21908961073199f3d186204da4810f2ea150b
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M hmp.c
    M scripts/qapi-types.py
    M scripts/qapi-visit.py
    M tests/Makefile
    R tests/qapi-schema/struct-base-clash-base.err
    R tests/qapi-schema/struct-base-clash-base.exit
    R tests/qapi-schema/struct-base-clash-base.json
    R tests/qapi-schema/struct-base-clash-base.out
    M tests/test-qmp-commands.c
    M tests/test-qmp-event.c
    M tests/test-qmp-input-visitor.c
    M tests/test-qmp-output-visitor.c
    M tests/test-visitor-serialization.c
    M ui/spice-core.c
    M ui/vnc.c

  Log Message:
  -----------
  qapi: Unbox base members

Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent.  This gives
less malloc overhead, less pointer dereferencing, and even less
generated code.  Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions).  It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.

Changes to the generated code look like this in qapi-types.h:

| struct SpiceChannel {
|-    SpiceBasicInfo *base;
|+    /* Members inherited from SpiceBasicInfo: */
|+    char *host;
|+    char *port;
|+    NetworkAddressFamily family;
|+    /* Own members: */
|     int64_t connection_id;

as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:

| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, 
Error **errp)
| {
|     Error *err = NULL;
|
|-    visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+    visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
|     if (err) {

(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.

Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).

And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 5c5e51a05b567fd48fb155d94ca6f7679dd0d478
      
https://github.com/qemu/qemu/commit/5c5e51a05b567fd48fb155d94ca6f7679dd0d478
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-visit.py

  Log Message:
  -----------
  qapi-visit: Remove redundant functions for flat union base

The code for visiting the base class of a child struct created
visit_type_Base_fields() which covers all fields of Base; while
the code for visiting the base class of a flat union created
visit_type_Union_fields() covering all fields of the base
except the discriminator.  But since the base class includes
the discriminator of a flat union, we can just visit the entire
base, without needing a separate visit of the discriminator.
Not only is consistently visiting all fields easier to
understand, it lets us share code.

The generated code in qapi-visit.c loses several now-unused
visit_type_UNION_fields(), along with changes like:

|@@ -1654,11 +1557,7 @@ void visit_type_BlockdevOptions(Visitor
|     if (!*obj) {
|         goto out_obj;
|     }
|-    visit_type_BlockdevOptions_fields(v, obj, &err);
|-    if (err) {
|-        goto out_obj;
|-    }
|-    visit_type_BlockdevDriver(v, &(*obj)->driver, "driver", &err);
|+    visit_type_BlockdevOptionsBase_fields(v, (BlockdevOptionsBase **)obj, 
&err);
|     if (err) {
|         goto out_obj;
|     }

and forward declarations where needed.  Note that the cast of obj
to BASE ** is necessary to call visit_type_BASE_fields() (and we
can't use our upcast wrappers, because those work on pointers while
we have a pointer-to-pointer).

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: f51d8fab44b231aa299d8de24cfdf9ba41ef4a21
      
https://github.com/qemu/qemu/commit/f51d8fab44b231aa299d8de24cfdf9ba41ef4a21
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-types.py
    M scripts/qapi.py

  Log Message:
  -----------
  qapi: Start converting to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

This patch is the front end for a series that converts to a
saner qapi union layout.  By the end of the series, we will no
longer have the type/kind mismatch, and all tag values will be
under a named union, which requires clients to access
'obj->u.value' instead of 'obj->value'.  But since the
conversion touches a number of files, it is easiest if we
temporarily support BOTH layouts simultaneously.

Given a simple union qapi type:

{ 'union':'Foo', 'data': { 'a':'int', 'b':'bool' } }

make the following changes in generated qapi-types.h:

| struct Foo {
|-    FooKind kind;
|-    union { /* union tag is @kind */
|+    union {
|+        FooKind kind;
|+        FooKind type;
|+    };
|+    union { /* union tag is @type */
|         void *data;
|         int64_t a;
|         bool b;
|+        union { /* union tag is @type */
|+            void *data;
|+            int64_t a;
|+            bool b;
|+        } u;
|     };
| };

Flat unions do not need the anonymous union for the tag member,
as we already fixed that to use the member name instead of 'kind'
back in commit 0f61af3e.

One additional change is needed in qapi.py: check_union() now
needs to check for collisions with 'type' in addition to those
with 'kind'.

Later, when the conversions are complete, we will remove the
duplication hacks, and also drop the check_union() restrictions.

Note, however, that we do not rename the generated enum, which
is still 'FooKind'.  A further patch could generate implicit
enums as 'FooType', but while the generator already reserved
the '*Kind' namespace (commit 4dc2e69), there are already QMP
constructs with '*Type' naming, which means changing our
reservation namespace would have lots of churn to C code to
deal with a forced name change.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 150d0564a4c626642897c748f7906260a13c14e1
      
https://github.com/qemu/qemu/commit/150d0564a4c626642897c748f7906260a13c14e1
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-visit.py

  Log Message:
  -----------
  qapi-visit: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for qapi-visit.py.

Generated code changes look like:

|@@ -4912,16 +4912,16 @@ void visit_type_MemoryDeviceInfo(Visitor
|     if (!*obj) {
|         goto out_obj;
|     }
|-    visit_type_MemoryDeviceInfoKind(v, &(*obj)->kind, "type", &err);
|+    visit_type_MemoryDeviceInfoKind(v, &(*obj)->type, "type", &err);
|     if (err) {
|         goto out_obj;
|     }
|-    if (!visit_start_union(v, !!(*obj)->data, &err) || err) {
|+    if (!visit_start_union(v, !!(*obj)->u.data, &err) || err) {
|         goto out_obj;
|     }
|-    switch ((*obj)->kind) {
|+    switch ((*obj)->type) {
|     case MEMORY_DEVICE_INFO_KIND_DIMM:
|-        visit_type_PCDIMMDeviceInfo(v, &(*obj)->dimm, "data", &err);
|+        visit_type_PCDIMMDeviceInfo(v, &(*obj)->u.dimm, "data", &err);
|         break;
|     default:
|         abort();
|@@ -4930,7 +4930,7 @@ out_obj:
|     error_propagate(errp, err);
|     err = NULL;
|     if (*obj) {
|-        visit_end_union(v, !!(*obj)->data, &err);
|+        visit_end_union(v, !!(*obj)->u.data, &err);
|     }
|     error_propagate(errp, err);
|     err = NULL;

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: c363acef772647f66becdbf46dd54e70e67f3cc9
      
https://github.com/qemu/qemu/commit/c363acef772647f66becdbf46dd54e70e67f3cc9
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M tests/test-qmp-commands.c
    M tests/test-qmp-input-visitor.c
    M tests/test-qmp-output-visitor.c

  Log Message:
  -----------
  tests: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for testsuite code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 6a8f9661dc3c088ed0d2f5b41d940190407cbdc5
      
https://github.com/qemu/qemu/commit/6a8f9661dc3c088ed0d2f5b41d940190407cbdc5
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M block/nbd.c
    M block/qcow2.c
    M block/vmdk.c
    M blockdev.c

  Log Message:
  -----------
  block: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for block-related code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 2d32addae70987521578d8bb27c6b3f52cdcbdcb
      
https://github.com/qemu/qemu/commit/2d32addae70987521578d8bb27c6b3f52cdcbdcb
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M qemu-nbd.c
    M ui/vnc.c
    M util/qemu-sockets.c

  Log Message:
  -----------
  sockets: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for socket-related code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 8d0bcba8370a4e8606dee602393a14d0c48e8bfc
      
https://github.com/qemu/qemu/commit/8d0bcba8370a4e8606dee602393a14d0c48e8bfc
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M net/dump.c
    M net/hub.c
    M net/l2tpv3.c
    M net/net.c
    M net/slirp.c
    M net/socket.c
    M net/tap-win32.c
    M net/tap.c
    M net/vde.c
    M net/vhost-user.c

  Log Message:
  -----------
  net: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for net-related code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 130257dc443574a9da91dc293665be2cfc40245a
      
https://github.com/qemu/qemu/commit/130257dc443574a9da91dc293665be2cfc40245a
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M qemu-char.c
    M spice-qemu-char.c

  Log Message:
  -----------
  char: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for character-related
code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 568c73a4783cd981e9aa6de4f15dcda7829643ad
      
https://github.com/qemu/qemu/commit/568c73a4783cd981e9aa6de4f15dcda7829643ad
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M hmp.c
    M hw/char/escc.c
    M hw/input/hid.c
    M hw/input/ps2.c
    M hw/input/virtio-input-hid.c
    M ui/console.c
    M ui/input-keymap.c
    M ui/input-legacy.c
    M ui/input.c

  Log Message:
  -----------
  input: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for input-related code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 1fd5d4fea4ba686705fd377c7cffc0f0c9f83f93
      
https://github.com/qemu/qemu/commit/1fd5d4fea4ba686705fd377c7cffc0f0c9f83f93
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M hmp.c
    M hw/mem/pc-dimm.c
    M numa.c

  Log Message:
  -----------
  memory: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for memory-related code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: ce21131a0b9e556bb73bf65eacdc07ccb21f78a9
      
https://github.com/qemu/qemu/commit/ce21131a0b9e556bb73bf65eacdc07ccb21f78a9
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M hmp.c
    M tpm.c

  Log Message:
  -----------
  tpm: Convert to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for TPM-related code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: e4ba22b31943ab02373359555bd7bcd66442632f
      
https://github.com/qemu/qemu/commit/e4ba22b31943ab02373359555bd7bcd66442632f
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-types.py

  Log Message:
  -----------
  qapi: Finish converting to new qapi union layout

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

This patch is the back end for a series that converts to a
saner qapi union layout.  Now that all clients have been
converted to use 'type' and 'obj->u.value', we can drop the
temporary parallel support for 'kind' and 'obj->value'.

Given a simple union qapi type:

{ 'union':'Foo', 'data': { 'a':'int', 'b':'bool' } }

this is the overall effect, when compared to the state before
this series of patches:

| struct Foo {
|-    FooKind kind;
|-    union { /* union tag is @kind */
|+    FooKind type;
|+    union { /* union tag is @type */
|         void *data;
|         int64_t a;
|         bool b;
|-    };
|+    } u;
| };

The testsuite still contains some examples of artificial restrictions
(see flat-union-clash-type.json, for example) that are no longer
technically necessary, now that there is no longer a collision between
enum tag values and non-variant member names; but fixing this will be
done in later patches, in part because some further changes are required
to keep QAPISchema*.check() from asserting.  Also, a later patch will
add a reservation for the member name 'u' to avoid a collision between a
user's non-variant names and our internal choice of C union name.

Note, however, that we do not rename the generated enum, which
is still 'FooKind'.  A further patch could generate implicit
enums as 'FooType', but while the generator already reserved
the '*Kind' namespace (commit 4dc2e69), there are already QMP
constructs with '*Type' naming, which means changing our
reservation namespace would have lots of churn to C code to
deal with a forced name change.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
[Commit message tweaked]
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 5e59baf90a72cd25d38a3134edc029f4f022da74
      
https://github.com/qemu/qemu/commit/5e59baf90a72cd25d38a3134edc029f4f022da74
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi.py
    M tests/Makefile
    A tests/qapi-schema/reserved-member-u.err
    A tests/qapi-schema/reserved-member-u.exit
    A tests/qapi-schema/reserved-member-u.json
    A tests/qapi-schema/reserved-member-u.out

  Log Message:
  -----------
  qapi: Reserve 'u' member name

Now that we have separated union tag values from colliding with
non-variant C names, by naming the union 'u', we should reserve
this name for our use.  Note that we want to forbid 'u' even in
a struct with no variants, because it is possible for a future
qemu release to extend QMP in a backwards-compatible manner while
converting from a struct to a flat union.  Fortunately, no
existing clients were using this member name.  If we ever find
the need for QMP to have a member 'u', we could at that time
relax things, perhaps by having c_name() munge the QMP member to
'q_u'.

Note that we cannot forbid 'u' everywhere (by adding the
rejection code to check_name()), because the existing QKeyCode
enum already uses it; therefore we only reserve it as a struct
type member name.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 32bc6879beea0b0cac6196cb15a71d206401e96d
      
https://github.com/qemu/qemu/commit/32bc6879beea0b0cac6196cb15a71d206401e96d
  Author: Eric Blake <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M scripts/qapi-types.py

  Log Message:
  -----------
  qapi: Simplify gen_struct_field()

Rather than having all callers pass a name, type, and optional
flag, have them instead pass a QAPISchemaObjectTypeMember which
already has all that information.

No change to generated code.

Signed-off-by: Eric Blake <address@hidden>
Message-Id: <address@hidden>
Signed-off-by: Markus Armbruster <address@hidden>


  Commit: 3d861a01093f8eedfac9889746ccafcfd32039b7
      
https://github.com/qemu/qemu/commit/3d861a01093f8eedfac9889746ccafcfd32039b7
  Author: Peter Maydell <address@hidden>
  Date:   2015-11-02 (Mon, 02 Nov 2015)

  Changed paths:
    M block/nbd.c
    M block/qcow2.c
    M block/vmdk.c
    M blockdev.c
    M docs/qapi-code-gen.txt
    M hmp.c
    M hw/char/escc.c
    M hw/input/hid.c
    M hw/input/ps2.c
    M hw/input/virtio-input-hid.c
    M hw/mem/pc-dimm.c
    M net/dump.c
    M net/hub.c
    M net/l2tpv3.c
    M net/net.c
    M net/slirp.c
    M net/socket.c
    M net/tap-win32.c
    M net/tap.c
    M net/vde.c
    M net/vhost-user.c
    M numa.c
    M qapi-schema.json
    M qemu-char.c
    M qemu-nbd.c
    M scripts/qapi-commands.py
    M scripts/qapi-types.py
    M scripts/qapi-visit.py
    M scripts/qapi.py
    M spice-qemu-char.c
    M tests/Makefile
    R tests/qapi-schema/enum-union-clash.err
    R tests/qapi-schema/enum-union-clash.exit
    R tests/qapi-schema/enum-union-clash.json
    R tests/qapi-schema/enum-union-clash.out
    M tests/qapi-schema/qapi-schema-test.json
    M tests/qapi-schema/qapi-schema-test.out
    A tests/qapi-schema/reserved-command-q.err
    A tests/qapi-schema/reserved-command-q.exit
    A tests/qapi-schema/reserved-command-q.json
    A tests/qapi-schema/reserved-command-q.out
    A tests/qapi-schema/reserved-member-has.err
    A tests/qapi-schema/reserved-member-has.exit
    A tests/qapi-schema/reserved-member-has.json
    A tests/qapi-schema/reserved-member-has.out
    A tests/qapi-schema/reserved-member-q.err
    A tests/qapi-schema/reserved-member-q.exit
    A tests/qapi-schema/reserved-member-q.json
    A tests/qapi-schema/reserved-member-q.out
    A tests/qapi-schema/reserved-member-u.err
    A tests/qapi-schema/reserved-member-u.exit
    A tests/qapi-schema/reserved-member-u.json
    A tests/qapi-schema/reserved-member-u.out
    A tests/qapi-schema/reserved-type-kind.err
    A tests/qapi-schema/reserved-type-kind.exit
    A tests/qapi-schema/reserved-type-kind.json
    A tests/qapi-schema/reserved-type-kind.out
    A tests/qapi-schema/reserved-type-list.err
    A tests/qapi-schema/reserved-type-list.exit
    A tests/qapi-schema/reserved-type-list.json
    A tests/qapi-schema/reserved-type-list.out
    R tests/qapi-schema/struct-base-clash-base.err
    R tests/qapi-schema/struct-base-clash-base.exit
    R tests/qapi-schema/struct-base-clash-base.json
    R tests/qapi-schema/struct-base-clash-base.out
    M tests/test-qmp-commands.c
    M tests/test-qmp-event.c
    M tests/test-qmp-input-visitor.c
    M tests/test-qmp-output-visitor.c
    M tests/test-visitor-serialization.c
    M tpm.c
    M ui/console.c
    M ui/input-keymap.c
    M ui/input-legacy.c
    M ui/input.c
    M ui/spice-core.c
    M ui/vnc.c
    M util/qemu-sockets.c

  Log Message:
  -----------
  Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2015-11-02' into 
staging

QAPI patches

# gpg: Signature made Mon 02 Nov 2015 09:07:23 GMT using RSA key ID EB918653
# gpg: Good signature from "Markus Armbruster <address@hidden>"
# gpg:                 aka "Markus Armbruster <address@hidden>"

* remotes/armbru/tags/pull-qapi-2015-11-02: (25 commits)
  qapi: Simplify gen_struct_field()
  qapi: Reserve 'u' member name
  qapi: Finish converting to new qapi union layout
  tpm: Convert to new qapi union layout
  memory: Convert to new qapi union layout
  input: Convert to new qapi union layout
  char: Convert to new qapi union layout
  net: Convert to new qapi union layout
  sockets: Convert to new qapi union layout
  block: Convert to new qapi union layout
  tests: Convert to new qapi union layout
  qapi-visit: Convert to new qapi union layout
  qapi: Start converting to new qapi union layout
  qapi-visit: Remove redundant functions for flat union base
  qapi: Unbox base members
  qapi: Prefer typesafe upcasts to qapi base classes
  qapi-types: Refactor base fields output
  qapi-visit: Split off visit_type_FOO_fields forward decl
  vnc: Hoist allocation of VncBasicInfo to callers
  qapi: Reserve 'q_*' and 'has_*' member names
  ...

Signed-off-by: Peter Maydell <address@hidden>


Compare: https://github.com/qemu/qemu/compare/24f4a0f5c969...3d861a01093f