tpm: Return QMP error when TPM is disabled in build
v2 cover tpm: Return QMP error when TPM is disabled in build
Since v1:
- make the qapi schema conditional (Marc-André)
Philippe Mathieu-Daudé (2):
qapi: Inline qmp_marshal_output() functions
tpm: Return QMP error when TPM is disabled in build
qapi/tpm.json | 9 ++++++--- monitor/hmp-cmds.c | 4 ++++ stubs/tpm.c | 16 ---------------- scripts/qapi/commands.py | 4 ++-- 4 files changed, 12 insertions(+), 21 deletions(-)
Signature · 1 line
2.31.1
RFC PATCH v2 1/2 qapi: Inline qmp_marshal_output() functions
In case we need to use QAPI types but no QAPI command / QAPI event actually use them, the generated qmp_marshal_output() function will trigger the compiler 'unused-function' warnings.
To prevent that, emit these functions inlined: the compiler will ignore such unused functions.
---
RFC: No clue about QAPI...
Tested with GCC. If the compiler is picky we could use the 'unused' function attribute.
--- scripts/qapi/commands.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
scripts/qapi/commands.py +2 -2
@@ -91,8 +91,8 @@ def gen_call(name: str, def gen_marshal_output(ret_type: QAPISchemaType) -> str: return mcgen(''' -static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, - QObject **ret_out, Error **errp) +static inline void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, + QObject **ret_out, Error **errp) { Visitor *v;
Signature · 1 line
2.31.1
Re: [RFC PATCH v2 1/2] qapi: Inline qmp_marshal_output() functions
Quoted 11 lines · Philippe Mathieu-Daudé
In case we need to use QAPI types but no QAPI command / QAPI event actually use them, the generated
qmp_marshal_output()function will trigger the compiler 'unused-function' warnings.
To prevent that, emit these functions inlined: the compiler will ignore such unused functions.Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
RFC: No clue about QAPI...
Tested with GCC. If the compiler is picky we could use the 'unused' function attribute.
And I have no clue if clang will warn about an unused inline function. Going with the compiler attribute seems safer and just as easy to do in the same two-line change (remember, the "unused" attribute merely means "suppress warnings if I don't use this", and not "warn me if I use it in spite of calling it unused").
Quoted 9 lines
--- scripts/qapi/commands.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)scripts/qapi/commands.py +0
-0
scripts/qapi/commands.py def gen_call(name: str, · line 95
Quoted 7 lines
scripts/qapi/commands.py +2
-2@@ -91,8 +91,8 @@ def gen_call(name: str, def gen_marshal_output(ret_type: QAPISchemaType) -> str: return mcgen(''' -static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, - QObject **ret_out, Error **errp) +static inline void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, + QObject **ret_out, Error **errp)
On the other hand, the qapi generator is smart enough to only output introspection data for qapi types that were actually used by a command or event, so how is that working, and why is it not also being used to elide the generation of unused qmp_marshal_output_FOO functions? This is where I'll have to defer to Markus.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [RFC PATCH v2 1/2] qapi: Inline qmp_marshal_output() functions
Quoted 31 lines · Eric Blake
Quoted 11 lines · Philippe Mathieu-Daudé
In case we need to use QAPI types but no QAPI command / QAPI event actually use them, the generated
qmp_marshal_output()function will trigger the compiler 'unused-function' warnings.
To prevent that, emit these functions inlined: the compiler will ignore such unused functions.Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
RFC: No clue about QAPI...
Tested with GCC. If the compiler is picky we could use the 'unused' function attribute.And I have no clue if clang will warn about an unused inline function. Going with the compiler attribute seems safer and just as easy to do in the same two-line change (remember, the "unused" attribute merely means "suppress warnings if I don't use this", and not "warn me if I use it in spite of calling it unused").
Quoted 12 lines
--- scripts/qapi/commands.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)scripts/qapi/commands.py +0
-0@@ -91,8 +91,8 @@ def gen_call(name: str, def gen_marshal_output(ret_type: QAPISchemaType) -> str: return mcgen('''
Quoted 10 lines
scripts/qapi/commands.py def gen_call(name: str, · line 95
Quoted 4 lines
scripts/qapi/commands.py +2
-2-static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, - QObject **ret_out, Error **errp) +static inline void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, + QObject **ret_out, Error **errp)On the other hand, the qapi generator is smart enough to only output introspection data for qapi types that were actually used by a command or event, so how is that working, and why is it not also being used to elide the generation of unused
qmp_marshal_output_FOOfunctions? This is where I'll have to defer to Markus.
This is a QAPI generator restriction. Let me explain.
The qmp_marshal_output_T() are shared by all commands returning T.
The commands may be conditional. The user is responsible for making T's 'if' the conjunction of the commands'. See the FIXME in commands.py.
If I do this for tpm.json (appended), then tpm.h misses TpmModel when CONFIG_TPM is off, and tpm_backend.h misses TpmType and TpmInfo. I suspect more TPM code needs to be guarded by CONFIG_TPM.
qapi/tpm.json +7 -3
@@ -17,7 +17,9 @@ # # Since: 1.5 ## -{ 'enum': 'TpmModel', 'data': [ 'tpm-tis', 'tpm-crb', 'tpm-spapr' ] } +{ 'enum': 'TpmModel', 'data': [ 'tpm-tis', 'tpm-crb', 'tpm-spapr' ], + 'if': 'defined(CONFIG_TPM)' } + ## # @query-tpm-models: #
@@ -47,7 +49,8 @@ # # Since: 1.5 ## -{ 'enum': 'TpmType', 'data': [ 'passthrough', 'emulator' ] } +{ 'enum': 'TpmType', 'data': [ 'passthrough', 'emulator' ], + 'if': 'defined(CONFIG_TPM)' } ## # @query-tpm-types:
@@ -124,7 +127,8 @@ { 'struct': 'TPMInfo', 'data': {'id': 'str', 'model': 'TpmModel', - 'options': 'TpmTypeOptions' } } + 'options': 'TpmTypeOptions' }, + 'if': 'defined(CONFIG_TPM)' } ## # @query-tpm:
Re: [RFC PATCH v2 1/2] qapi: Inline qmp_marshal_output() functions
Quoted 44 lines · Markus Armbruster
Quoted 31 lines · Eric Blake
Quoted 11 lines · Philippe Mathieu-Daudé
In case we need to use QAPI types but no QAPI command / QAPI event actually use them, the generated
qmp_marshal_output()function will trigger the compiler 'unused-function' warnings.
To prevent that, emit these functions inlined: the compiler will ignore such unused functions.Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
RFC: No clue about QAPI...
Tested with GCC. If the compiler is picky we could use the 'unused' function attribute.And I have no clue if clang will warn about an unused inline function. Going with the compiler attribute seems safer and just as easy to do in the same two-line change (remember, the "unused" attribute merely means "suppress warnings if I don't use this", and not "warn me if I use it in spite of calling it unused").
Quoted 12 lines
--- scripts/qapi/commands.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)scripts/qapi/commands.py +0
-0@@ -91,8 +91,8 @@ def gen_call(name: str, def gen_marshal_output(ret_type: QAPISchemaType) -> str: return mcgen('''Quoted 10 lines
scripts/qapi/commands.py def gen_call(name: str, · line 95
Quoted 4 lines
scripts/qapi/commands.py +2
-2-static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, - QObject **ret_out, Error **errp) +static inline void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, + QObject **ret_out, Error **errp)On the other hand, the qapi generator is smart enough to only output introspection data for qapi types that were actually used by a command or event, so how is that working, and why is it not also being used to elide the generation of unused
qmp_marshal_output_FOOfunctions? This is where I'll have to defer to Markus.
Quoted 6 lines
This is a QAPI generator restriction. Let me explain.
The
qmp_marshal_output_T()are shared by all commands returning T.The commands may be conditional. The user is responsible for making T's 'if' the conjunction of the commands'. See the FIXME in
commands.py.
Yes, I noticed the FIXME:
# FIXME: If T is a user-defined type, the user is responsible # for making this work, i.e. to make T's condition the # conjunction of the T-returning commands' conditions. If T # is a built-in type, this isn't possible: the
# qmp_marshal_output_T() will be generated unconditionally.
Using inline / unused attributes don't invalidate this :)
Quoted 3 lines
If I do this for tpm.json (appended), then
tpm.hmisses TpmModel whenCONFIG_TPMis off, andtpm_backend.hmisses TpmType and TpmInfo. I suspect more TPM code needs to be guarded byCONFIG_TPM.
Yes, this is what I did first, use the code below and add #ifdef'ry, but the code becomes ugly and harder to maintain because the enums are used in middle of a QOM interface structure:
include/sysemu/tpm.h-37-struct TPMIfClass {include/sysemu/tpm.h-38- InterfaceClass parent_class;include/sysemu/tpm.h-39-
include/sysemu/tpm.h:40: enum TpmModel model; include/sysemu/tpm.h-41- void (*request_completed)(TPMIf *obj, int ret); include/sysemu/tpm.h-42- enum TPMVersion (*get_version)(TPMIf *obj);
include/sysemu/tpm.h-43-};include/sysemu/tpm.h-44-
If you think using inline / unused attributes is not an option for QAPI, then the #ifdef'ry isn't worth it and I'd prefer use v1 which doesn't use conditional QAPI suggested by Marc-André.
Quoted 36 lines
qapi/tpm.json +7
-3@@ -17,7 +17,9 @@ # # Since: 1.5 ## -{ 'enum': 'TpmModel', 'data': [ 'tpm-tis', 'tpm-crb', 'tpm-spapr' ] } +{ 'enum': 'TpmModel', 'data': [ 'tpm-tis', 'tpm-crb', 'tpm-spapr' ], + 'if': 'defined(CONFIG_TPM)' } + ## # @query-tpm-models: #@@ -47,7 +49,8 @@ # # Since: 1.5 ## -{ 'enum': 'TpmType', 'data': [ 'passthrough', 'emulator' ] } +{ 'enum': 'TpmType', 'data': [ 'passthrough', 'emulator' ], + 'if': 'defined(CONFIG_TPM)' } ## # @query-tpm-types:@@ -124,7 +127,8 @@ { 'struct': 'TPMInfo', 'data': {'id': 'str', 'model': 'TpmModel', - 'options': 'TpmTypeOptions' } } + 'options': 'TpmTypeOptions' }, + 'if': 'defined(CONFIG_TPM)' } ## # @query-tpm:
Re: [RFC PATCH v2 1/2] qapi: Inline qmp_marshal_output() functions
Quoted 54 lines · Philippe Mathieu-Daudé
Quoted 44 lines · Markus Armbruster
Quoted 31 lines · Eric Blake
Quoted 11 lines · Philippe Mathieu-Daudé
In case we need to use QAPI types but no QAPI command / QAPI event actually use them, the generated
qmp_marshal_output()function will trigger the compiler 'unused-function' warnings.
To prevent that, emit these functions inlined: the compiler will ignore such unused functions.Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
RFC: No clue about QAPI...
Tested with GCC. If the compiler is picky we could use the 'unused' function attribute.And I have no clue if clang will warn about an unused inline function. Going with the compiler attribute seems safer and just as easy to do in the same two-line change (remember, the "unused" attribute merely means "suppress warnings if I don't use this", and not "warn me if I use it in spite of calling it unused").
Quoted 12 lines
--- scripts/qapi/commands.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)scripts/qapi/commands.py +0
-0@@ -91,8 +91,8 @@ def gen_call(name: str, def gen_marshal_output(ret_type: QAPISchemaType) -> str: return mcgen('''Quoted 10 lines
scripts/qapi/commands.py def gen_call(name: str, · line 95
Quoted 4 lines
scripts/qapi/commands.py +2
-2-static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, - QObject **ret_out, Error **errp) +static inline void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, + QObject **ret_out, Error **errp)On the other hand, the qapi generator is smart enough to only output introspection data for qapi types that were actually used by a command or event, so how is that working, and why is it not also being used to elide the generation of unused
qmp_marshal_output_FOOfunctions? This is where I'll have to defer to Markus.Quoted 6 lines
This is a QAPI generator restriction. Let me explain.
The
qmp_marshal_output_T()are shared by all commands returning T.The commands may be conditional. The user is responsible for making T's 'if' the conjunction of the commands'. See the FIXME in
commands.py.Yes, I noticed the FIXME:
Quoted 7 lines
# FIXME: If T is a user-defined type, the user is responsible # for making this work, i.e. to make T's condition the # conjunction of the T-returning commands' conditions. If T # is a built-in type, this isn't possible: the
#qmp_marshal_output_T()will be generated unconditionally.Using inline / unused attributes don't invalidate this :)
Generating the unused attribute lets us keep types unconditional even when the commands returning them are conditional (also takes care of the built-in case, where we cannot make the type conditional).
However, conditional commands returning an unconditional type is a bit of a code smell. In this particular case, the smell seems to lead to a (minor) issue: too much TPM code is compiled even when CONFIG_TPM is off. With the attribute in place, we wouldn't have learned this.
We may still find non-smelly instances of this pattern. Until then, I'm a bit reluctant to generate the attribute.
Quoted 14 lines
Quoted 3 lines
If I do this for tpm.json (appended), then
tpm.hmisses TpmModel whenCONFIG_TPMis off, andtpm_backend.hmisses TpmType and TpmInfo. I suspect more TPM code needs to be guarded byCONFIG_TPM.Yes, this is what I did first, use the code below and add #ifdef'ry, but the code becomes ugly and harder to maintain because the enums are used in middle of a QOM interface structure:
include/sysemu/tpm.h-37-structTPMIfClass {include/sysemu/tpm.h-38-InterfaceClassparent_class;include/sysemu/tpm.h-39-include/sysemu/tpm.h:40: enum TpmModel model; include/sysemu/tpm.h-41- void (*request_completed)(TPMIf *obj, int ret); include/sysemu/tpm.h-42- enum TPMVersion (*get_version)(TPMIf *obj);
Quoted 6 lines
include/sysemu/tpm.h-43-};include/sysemu/tpm.h-44-If you think using inline / unused attributes is not an option for QAPI, then the #ifdef'ry isn't worth it and I'd prefer use v1 which doesn't use conditional QAPI suggested by Marc-André.
Ignorant question: why do we want to define QOM type "tpm-if" when CONFIG_TPM is off?
[...]
Re: [RFC PATCH v2 1/2] qapi: Inline qmp_marshal_output() functions
Quoted 68 lines · Markus Armbruster
Quoted 54 lines · Philippe Mathieu-Daudé
Quoted 44 lines · Markus Armbruster
Quoted 31 lines · Eric Blake
Quoted 11 lines · Philippe Mathieu-Daudé
In case we need to use QAPI types but no QAPI command / QAPI event actually use them, the generated
qmp_marshal_output()function will trigger the compiler 'unused-function' warnings.
To prevent that, emit these functions inlined: the compiler will ignore such unused functions.Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
RFC: No clue about QAPI...
Tested with GCC. If the compiler is picky we could use the 'unused' function attribute.And I have no clue if clang will warn about an unused inline function. Going with the compiler attribute seems safer and just as easy to do in the same two-line change (remember, the "unused" attribute merely means "suppress warnings if I don't use this", and not "warn me if I use it in spite of calling it unused").
Quoted 12 lines
--- scripts/qapi/commands.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)scripts/qapi/commands.py +0
-0@@ -91,8 +91,8 @@ def gen_call(name: str, def gen_marshal_output(ret_type: QAPISchemaType) -> str: return mcgen('''Quoted 10 lines
scripts/qapi/commands.py def gen_call(name: str, · line 95
Quoted 4 lines
scripts/qapi/commands.py +2
-2-static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, - QObject **ret_out, Error **errp) +static inline void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, + QObject **ret_out, Error **errp)On the other hand, the qapi generator is smart enough to only output introspection data for qapi types that were actually used by a command or event, so how is that working, and why is it not also being used to elide the generation of unused
qmp_marshal_output_FOOfunctions? This is where I'll have to defer to Markus.Quoted 6 lines
This is a QAPI generator restriction. Let me explain.
The
qmp_marshal_output_T()are shared by all commands returning T.The commands may be conditional. The user is responsible for making T's 'if' the conjunction of the commands'. See the FIXME in
commands.py.Yes, I noticed the FIXME:
Quoted 7 lines
# FIXME: If T is a user-defined type, the user is responsible # for making this work, i.e. to make T's condition the # conjunction of the T-returning commands' conditions. If T # is a built-in type, this isn't possible: the
#qmp_marshal_output_T()will be generated unconditionally.Using inline / unused attributes don't invalidate this :)
Generating the unused attribute lets us keep types unconditional even when the commands returning them are conditional (also takes care of the built-in case, where we cannot make the type conditional).
Quoted 7 lines
However, conditional commands returning an unconditional type is a bit of a code smell. In this particular case, the smell seems to lead to a (minor) issue: too much TPM code is compiled even when
CONFIG_TPMis off. With the attribute in place, we wouldn't have learned this.We may still find non-smelly instances of this pattern. Until then, I'm a bit reluctant to generate the attribute.
I agree with your nose :)
Quoted 17 lines
Quoted 17 lines
Quoted 3 lines
If I do this for tpm.json (appended), then
tpm.hmisses TpmModel whenCONFIG_TPMis off, andtpm_backend.hmisses TpmType and TpmInfo. I suspect more TPM code needs to be guarded byCONFIG_TPM.Yes, this is what I did first, use the code below and add #ifdef'ry, but the code becomes ugly and harder to maintain because the enums are used in middle of a QOM interface structure:
include/sysemu/tpm.h-37-structTPMIfClass {include/sysemu/tpm.h-38-InterfaceClassparent_class;include/sysemu/tpm.h-39-include/sysemu/tpm.h:40: enum TpmModel model; include/sysemu/tpm.h-41- void (*request_completed)(TPMIf *obj, int ret); include/sysemu/tpm.h-42- enum TPMVersion (*get_version)(TPMIf *obj);
include/sysemu/tpm.h-43-};include/sysemu/tpm.h-44-
Quoted 6 lines
Quoted 3 lines
If you think using inline / unused attributes is not an option for QAPI, then the #ifdef'ry isn't worth it and I'd prefer use v1 which doesn't use conditional QAPI suggested by Marc-André.
Ignorant question: why do we want to define QOM type "tpm-if" when
CONFIG_TPMis off?
Good question. I suppose for historical reasons? Copy/pasting of another older include/sysemu/ files? Recently I saw these headers received more love, such better #ifdef'ry to allow code elision.
I'll defer that to Stefan.
Thanks for the review,
Phil.
Re: [RFC PATCH v2 1/2] qapi: Inline qmp_marshal_output() functions
Quoted 100 lines · Philippe Mathieu-Daudé
Quoted 68 lines · Markus Armbruster
Quoted 54 lines · Philippe Mathieu-Daudé
Quoted 44 lines · Markus Armbruster
Quoted 31 lines · Eric Blake
Quoted 11 lines · Philippe Mathieu-Daudé
In case we need to use QAPI types but no QAPI command / QAPI event actually use them, the generated
qmp_marshal_output()function will trigger the compiler 'unused-function' warnings.
To prevent that, emit these functions inlined: the compiler will ignore such unused functions.Signed-off-by Philippe Mathieu-Daudé <[email protected]>---
RFC: No clue about QAPI...
Tested with GCC. If the compiler is picky we could use the 'unused' function attribute.And I have no clue if clang will warn about an unused inline function. Going with the compiler attribute seems safer and just as easy to do in the same two-line change (remember, the "unused" attribute merely means "suppress warnings if I don't use this", and not "warn me if I use it in spite of calling it unused").
Quoted 12 lines
--- scripts/qapi/commands.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)scripts/qapi/commands.py +0
-0@@ -91,8 +91,8 @@ def gen_call(name: str, def gen_marshal_output(ret_type: QAPISchemaType) -> str: return mcgen('''Quoted 10 lines
scripts/qapi/commands.py def gen_call(name: str, · line 95
Quoted 4 lines
scripts/qapi/commands.py +2
-2-static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, - QObject **ret_out, Error **errp) +static inline void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, + QObject **ret_out, Error **errp)On the other hand, the qapi generator is smart enough to only output introspection data for qapi types that were actually used by a command or event, so how is that working, and why is it not also being used to elide the generation of unused
qmp_marshal_output_FOOfunctions? This is where I'll have to defer to Markus.Quoted 6 lines
This is a QAPI generator restriction. Let me explain.
The
qmp_marshal_output_T()are shared by all commands returning T.The commands may be conditional. The user is responsible for making T's 'if' the conjunction of the commands'. See the FIXME in
commands.py.Yes, I noticed the FIXME:
Quoted 7 lines
# FIXME: If T is a user-defined type, the user is responsible # for making this work, i.e. to make T's condition the # conjunction of the T-returning commands' conditions. If T # is a built-in type, this isn't possible: the
#qmp_marshal_output_T()will be generated unconditionally.Using inline / unused attributes don't invalidate this :)
Generating the unused attribute lets us keep types unconditional even when the commands returning them are conditional (also takes care of the built-in case, where we cannot make the type conditional).
Quoted 7 lines
However, conditional commands returning an unconditional type is a bit of a code smell. In this particular case, the smell seems to lead to a (minor) issue: too much TPM code is compiled even when
CONFIG_TPMis off. With the attribute in place, we wouldn't have learned this.We may still find non-smelly instances of this pattern. Until then, I'm a bit reluctant to generate the attribute.
I agree with your nose :)
Quoted 21 lines
Quoted 20 lines
Quoted 3 lines
If I do this for tpm.json (appended), then
tpm.hmisses TpmModel whenCONFIG_TPMis off, andtpm_backend.hmisses TpmType and TpmInfo. I suspect more TPM code needs to be guarded byCONFIG_TPM.Yes, this is what I did first, use the code below and add #ifdef'ry, but the code becomes ugly and harder to maintain because the enums are used in middle of a QOM interface structure:
include/sysemu/tpm.h-37-structTPMIfClass {include/sysemu/tpm.h-38-InterfaceClassparent_class;include/sysemu/tpm.h-39-include/sysemu/tpm.h:40: enum TpmModel model; include/sysemu/tpm.h-41- void (*request_completed)(TPMIf *obj, int ret); include/sysemu/tpm.h-42- enum TPMVersion (*get_version)(TPMIf *obj);
include/sysemu/tpm.h-43-};include/sysemu/tpm.h-44-If you think using inline / unused attributes is not an option for QAPI, then the #ifdef'ry isn't worth it and I'd prefer use v1 which doesn't use conditional QAPI suggested by Marc-André.
Quoted 8 lines
Quoted 2 lines
Ignorant question: why do we want to define QOM type "tpm-if" when
CONFIG_TPMis off?Good question. I suppose for historical reasons? Copy/pasting of another older
include/sysemu/files? Recently I saw these headers received more love, such better #ifdef'ry to allow code elision.I'll defer that to Stefan.
Stefan, would you be willing to look into this?
Re: [RFC PATCH v2 1/2] qapi: Inline qmp_marshal_output() functions
Quoted 2 lines · Markus Armbruster
Stefan, would you be willing to look into this?
Have a look at the 3 topmost patches: https://github.com/stefanberger/qemu-tpm/commits/tpm-eliminate-if-not-config-tpm
PATCH v2 2/2 tpm: Return QMP error when TPM is disabled in build
In reply to Philippe Mathieu-DaudéWhen the management layer queries a binary built using --disable-tpm for TPM devices, it gets confused by getting empty responses:
{ "execute": "query-tpm" }
{
"return": [
]
}
{ "execute": "query-tpm-types" }
{
"return": [
]
}
{ "execute": "query-tpm-models" }
{
"return": [
]
}To make it clearer by returning an error:
- Make the TPM QAPI schema conditional
- Adapt the HMP command
- Remove stubs which became unnecessary
The management layer now gets a 'CommandNotFound' error:
{ "execute": "query-tpm" }
{
"error": {
"class": "CommandNotFound",
"desc": "The command query-tpm has not been found"
}
}--- qapi/tpm.json | 9 ++++++--- monitor/hmp-cmds.c | 4 ++++ stubs/tpm.c | 16 ---------------- 3 files changed, 10 insertions(+), 19 deletions(-)
qapi/tpm.json +6 -3
@@ -33,7 +33,8 @@ # <- { "return": [ "tpm-tis", "tpm-crb", "tpm-spapr" ] } # ## -{ 'command': 'query-tpm-models', 'returns': ['TpmModel'] } +{ 'command': 'query-tpm-models', 'returns': ['TpmModel'], + 'if': 'defined(CONFIG_TPM)' } ## # @TpmType:
@@ -63,7 +64,8 @@ # <- { "return": [ "passthrough", "emulator" ] } # ## -{ 'command': 'query-tpm-types', 'returns': ['TpmType'] } +{ 'command': 'query-tpm-types', 'returns': ['TpmType'], + 'if': 'defined(CONFIG_TPM)' } ## # @TPMPassthroughOptions:
@@ -152,4 +154,5 @@ # } # ## -{ 'command': 'query-tpm', 'returns': ['TPMInfo'] } +{ 'command': 'query-tpm', 'returns': ['TPMInfo'], + 'if': 'defined(CONFIG_TPM)' }
monitor/hmp-cmds.c +4 -0
@@ -901,6 +901,9 @@ void hmp_info_pci(Monitor *mon, const QDict *qdict)void hmp_info_tpm (Monitor *mon,const QDict *qdict) { +#ifndef CONFIG_TPM +monitor_printf (mon,"TPM device not supported\n" ); +#else TPMInfoList *info_list, *info;Error *err =NULL ;unsigned int c =0 ;
@@ -946,6 +949,7 @@ void hmp_info_tpm(Monitor *mon, const QDict *qdict) c++; }qapi_free_TPMInfoList (info_list); +#endif /* CONFIG_TPM */ }void hmp_quit (Monitor *mon,const QDict *qdict)
stubs/tpm.c +0 -16
@@ -6,7 +6,6 @@*/ #include "qemu/osdep.h" -#include "qapi/qapi-commands-tpm.h" #include "sysemu/tpm.h" #include "hw/acpi/tpm.h"
@@ -19,21 +18,6 @@ void tpm_cleanup(void) { } -TPMInfoList *qmp_query_tpm (Error **errp) -{ -return NULL ; -} - -TpmTypeList *qmp_query_tpm_types (Error **errp) -{ -return NULL ; -} - -TpmModelList *qmp_query_tpm_models (Error **errp) -{ -return NULL ; -} -void tpm_build_ppi_acpi (TPMIf *tpm,Aml *dev) { }
Signature · 1 line
2.31.1
Quoted 3 lines · Philippe Mathieu-Daudé
When the management layer queries a binary built using --disable-tpm for TPM devices, it gets confused by getting empty responses:
...
Quoted 16 lines
To make it clearer by returning an error:
- Make the TPM QAPI schema conditional
- Adapt the HMP command
- Remove stubs which became unnecessaryThe management layer now gets a 'CommandNotFound' error:
{ "execute": "query-tpm" } { "error": { "class": "CommandNotFound", "desc": "The command query-tpm has not been found" } }
Quoted 7 lines
Suggested-by Marc-André Lureau <[email protected]>Signed-off-by Philippe Mathieu-Daudé <[email protected]>--- qapi/tpm.json | 9 ++++++--- monitor/hmp-cmds.c | 4 ++++ stubs/tpm.c | 16 ---------------- 3 files changed, 10 insertions(+), 19 deletions(-)
Yes, looks nicer.
qapi/tpm.json line 37
Quoted 12 lines
qapi/tpm.json +2
-1@@ -33,7 +33,8 @@ # <- { "return": [ "tpm-tis", "tpm-crb", "tpm-spapr" ] } # ## -{ 'command': 'query-tpm-models', 'returns': ['TpmModel'] } +{ 'command': 'query-tpm-models', 'returns': ['TpmModel'], + 'if': 'defined(CONFIG_TPM)' }
May need a rebase if the series to make 'if' language-agnostic lands first (in fact, that would probably result in a build-time semantic conflict rather than a patch-application-time merge conflict), but that's not enough to prevent me from giving:
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Quoted 2 lines · Philippe Mathieu-Daudé
When the management layer queries a binary built using --disable-tpm for TPM devices, it gets confused by getting empty responses:
What software exactly gets confused, and how?
Quoted 32 lines
{ "execute": "query-tpm" } { "return": [ ] } { "execute": "query-tpm-types" } { "return": [ ] } { "execute": "query-tpm-models" } { "return": [ ] }To make it clearer by returning an error:
- Make the TPM QAPI schema conditional
- Adapt the HMP command
- Remove stubs which became unnecessaryThe management layer now gets a 'CommandNotFound' error:
{ "execute": "query-tpm" } { "error": { "class": "CommandNotFound", "desc": "The command query-tpm has not been found" } }
Quoted 2 lines
Suggested-by Marc-André Lureau <[email protected]>Signed-off-by Philippe Mathieu-Daudé <[email protected]>
Yes, please. But see my review of PATCH 1.