error: auto propagated local_err part I
Subsystems (2)
v6 cover error: auto propagated local_err part I
Hi all!
Now, when preparations from
[RFC v5 000/126] error: auto propagated local_err
https://lists.gnu.org/archive/html/qemu-devel/2019-10/msg02771.html
https://src.openvz.org/scm/~vsementsov/qemu.git #tag up-auto-local-err-v5
, after some iterations, are finally merged, let's proceed with the rest. Sorry for a big delay on my part.
As a first step, I decided to take subsystems, each of them covered by one patch, which get r-b/a-b marks by maintainer of the subsystem in v5.
v6 is available at
https://src.openvz.org/scm/~vsementsov/qemu.git #tag up-auto-local-err-partI-v6
Changes v5->v6:
01: use errp name for the parameter, add assertion
02: add a lot of text information, drop Eric's r-b.
no semantic changes.
03: add more comments
skip functions with pattern error_append_.*_hint in name make errp identifier, to match any name of Error ** paramter some other improvements
04: only commit message changed,
keep Philippe's r-b
05: new, manual update for hw/sd/ssi-sd
06: only commit message changed,
keep Philippe's r-b
07: only commit message changed,
keep Philippe's r-b
08: local_parse_opts() changed, so patch changed in this
function, drop a-b mark
also, indentation fixed, by improvement in coccinelle script
09: only commit message changed,
keep Stefan's r-b
10: commit message and a bit of context changed, still seems
valid to keep Eric's r-b
11: add new hunk: hw/pci-host/xen_igd_pt.c, so, drop r-b
also, indentation fixed, by improvement in coccinelle script
In these series, there is no commit-per-subsystem script, each generated commit is generated in separate.
Still, generating commands are very similar, and looks like
sed -n '/^<Subsystem name>$/,/^$/{s/^F: //p}' MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80Note, that in each generated commit, generation command is the only text, indented by 8 spaces in 'git log -1' output, so, to regenerate all commits (for example, after rebase, or change in coccinelle script), you may use the following command:
git rebase -x "sh -c \"git show --pretty= --name-only | xargs git checkout HEAD^ -- ; git reset; git log -1 | grep '^ ' | sh\"" HEAD~7
Which will start automated interactive rebase for generated patches, which will stop if generated patch changed
(you may do git commit --amend to apply updated generated changes).
Note:
git show --pretty= --name-only - lists files, changed in HEAD
git log -1 | grep '^ ' | sh - rerun generation command of HEAD
Check for compilation of changed .c files
git rebase -x "sh -c \"git show --pretty= --name-only | sed -n 's/\.c$/.o/p' | xargs make -j9\"" HEAD~7
Vladimir Sementsov-Ogievskiy (11):
qapi/error: add (Error **errp) cleaning APIs
error: auto propagated local_err
scripts: add coccinelle script to use auto propagated errp hw/sd/ssi-sd: fix error handling in ssi_sd_realize SD (Secure Card): introduce ERRP_AUTO_PROPAGATE
pflash: introduce ERRP_AUTO_PROPAGATE
fw_cfg: introduce ERRP_AUTO_PROPAGATE
virtio-9p: introduce ERRP_AUTO_PROPAGATE
TPM: introduce ERRP_AUTO_PROPAGATE
nbd: introduce ERRP_AUTO_PROPAGATE
xen: introduce ERRP_AUTO_PROPAGATE
include/block/nbd.h | 1 + include/qapi/error.h | 113 +++++++++++++- block/nbd.c | 49 +++--- hw/9pfs/9p-local.c | 12 +- hw/9pfs/9p.c | 1 + hw/block/dataplane/xen-block.c | 17 +-- hw/block/pflash_cfi01.c | 7 +- hw/block/pflash_cfi02.c | 7 +- hw/block/xen-block.c | 125 +++++++--------- hw/nvram/fw_cfg.c | 14 +- hw/pci-host/xen_igd_pt.c | 7 +- hw/sd/sdhci-pci.c | 7 +- hw/sd/sdhci.c | 21 ++- hw/sd/ssi-sd.c | 26 +++- hw/tpm/tpm_util.c | 7 +- hw/xen/xen-backend.c | 7 +- hw/xen/xen-bus.c | 100 ++++++------- hw/xen/xen-host-pci-device.c | 27 ++-- hw/xen/xen_pt.c | 25 ++-- hw/xen/xen_pt_config_init.c | 20 +-- nbd/client.c | 5 + nbd/server.c | 5 + tpm.c | 7 +- scripts/coccinelle/auto-propagated-errp.cocci | 139 ++++++++++++++++++ 24 files changed, 482 insertions(+), 267 deletions(-) create mode 100644 scripts/coccinelle/auto-propagated-errp.cocci
Signature · 7 lines
2.21.0 _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
PATCH v6 1/11 qapi/error: add (Error **errp) cleaning APIs
---
include/qapi/error.h | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
include/qapi/error.h +26 -0
@@ -309,6 +309,32 @@ void warn_reportf_err(Error *err, const char *fmt, ...) void error_reportf_err(Error *err, const char *fmt, ...) GCC_FMT_ATTR(2, 3); +/* +* Functions to clean Error **errp: call corresponding Error *err cleaning +* function an set pointer to NULL +*/ +static inline void error_free_errp (Error **errp) +{ +assert (errp && *errp); +error_free (*errp); + *errp =NULL ; +} + +static inline void error_report_errp (Error **errp) +{ +assert (errp && *errp); +error_report_err (*errp); + *errp =NULL ; +} + +static inline void warn_report_errp (Error **errp) +{ +assert (errp && *errp); +warn_report_err (*errp); + *errp =NULL ; +} + +/* * Just like error_setg(), except you get to specify the error class. * Note: use of error classes other than ERROR_CLASS_GENERIC_ERROR is
Signature · 7 lines
2.21.0 _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 01/11] qapi/error: add (Error **errp) cleaning APIs
Quoted 3 lines · On Fri, 10 Jan 2020 22:41:48 +0300 Vladimir Sementsov-Ogievskiy…
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
Quoted 48 lines
CC Cornelia Huck <[email protected]>CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC "Philippe Mathieu-Daudé" <[email protected]>CC Laszlo Ersek <[email protected]>CC Gerd Hoffmann <[email protected]>CC Stefan Berger <[email protected]>CC Markus Armbruster <[email protected]>CC Michael Roth <[email protected]>include/qapi/error.h | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)include/qapi/error.h +19
-0@@ -309,6 +309,32 @@ void warn_reportf_err(Error *err, const char *fmt, ...) void error_reportf_err(Error *err, const char *fmt, ...) GCC_FMT_ATTR(2, 3); +/* +* Functions to clean Error **errp: call corresponding Error *err cleaning +* function an set pointer to NULL +*/ +static inline void error_free_errp (Error **errp) +{ +assert (errp && *errp); +error_free (*errp); + *errp =NULL ; +} + +static inline void error_report_errp (Error **errp) +{ +assert (errp && *errp); +error_report_err (*errp); + *errp =NULL ; +} + +static inline void warn_report_errp (Error **errp)
include/qapi/error.h void warn_reportf_err(Error *err, const char *fmt, ...) · line 340
Quoted 10 lines
include/qapi/error.h +7
-0+{ +assert (errp && *errp); +warn_report_err (*errp); + *errp =NULL ; +} + +/* * Just like error_setg(), except you get to specify the error class. * Note: use of error classes other than ERROR_CLASS_GENERIC_ERROR is
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 01/11] qapi/error: add (Error **errp) cleaning APIs
In reply to Vladimir Sementsov-OgievskiyQuoted 2 lines · Vladimir Sementsov-Ogievskiy
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
Sparse commit message; it might be nice (for future 'git log' greppability) to at least mention the names of the functions being added.
Quoted 4 lines
+/*
+ * Functions to clean Error **errp: call corresponding Error *err cleaning
+ * function an set pointer to NULL
s/ an/, then/
Missing a '.' at the end of the sentence.
Otherwise,
Signature · 9 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
PATCH v6 2/11 error: auto propagated local_err
In reply to Vladimir Sementsov-OgievskiyHere is introduced ERRP_AUTO_PROPAGATE macro, to be used at start of functions with errp OUT parameter.
It has three goals:
1. Fix issue with error_fatal & error_prepend/error_append_hint: user can't see this additional information, because exit() happens in error_setg earlier than information is added. [Reported by Greg Kurz]
2. Fix issue with error_abort & error_propagate: when we wrap error_abort by local_err+error_propagate, resulting coredump will refer to error_propagate and not to the place where error happened. (the macro itself doesn't fix the issue, but it allows to [3.] drop all local_err+error_propagate pattern, which will definitely fix the issue) [Reported by Kevin Wolf]
3. Drop local_err+error_propagate pattern, which is used to workaround void functions with errp parameter, when caller wants to know resulting status. (Note: actually these functions could be merely updated to return int error code).
To achieve these goals, we need to add invocation of the macro at start of functions, which needs error_prepend/error_append_hint (1.); add invocation of the macro at start of functions which do local_err+error_propagate scenario the check errors, drop local errors from them and just use *errp instead (2., 3.).
---
include/qapi/error.h | 84 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 83 insertions(+), 1 deletion(-)
include/qapi/error.h +83 -1
@@ -78,7 +78,7 @@* Call a function treating errors as fatal: * foo(arg, &error_fatal); * -* Receive an error and pass it on to the caller: +* Receive an error and pass it on to the caller (DEPRECATED*): * Error *err = NULL; * foo(arg, &err); * if (err) {
@@ -98,6 +98,50 @@* foo(arg, errp); * for readability. * +* DEPRECATED* This pattern is deprecated now, use ERRP_AUTO_PROPAGATE macro +* instead (defined below). +* It's deprecated because of two things: +* +* 1. Issue with error_abort & error_propagate: when we wrap error_abort by +* local_err+error_propagate, resulting coredump will refer to error_propagate +* and not to the place where error happened. +* +* 2. A lot of extra code of the same pattern +* +* How to update old code to use ERRP_AUTO_PROPAGATE? +* +* All you need is to add ERRP_AUTO_PROPAGATE() invocation at function start, +* than you may safely dereference errp to check errors and do not need any +* additional local Error variables or calls to error_propagate(). +* +* Example: +* +* old code +* +* void fn(..., Error **errp) { +* Error *err = NULL; +* foo(arg, &err); +* if (err) { +* handle the error... +* error_propagate(errp, err); +* return; +* } +* ... +* } +* +* updated code +* +* void fn(..., Error **errp) { +* ERRP_AUTO_PROPAGATE(); +* foo(arg, errp); +* if (*errp) { +* handle the error... +* return; +* } +* ... +* } +* +* * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; * foo(arg, &err);
@@ -348,6 +392,44 @@ void error_set_internal(Error **errp, ErrorClass err_class, const char *fmt, ...) GCC_FMT_ATTR(6, 7); +typedef struct ErrorPropagator { +Error *local_err; +Error **errp; +}ErrorPropagator ; + +static inline void error_propagator_cleanup (ErrorPropagator *prop) +{ +error_propagate (prop->errp, prop->local_err); +} + +G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (ErrorPropagator, error_propagator_cleanup); + +/* +* ERRP_AUTO_PROPAGATE +* +* This macro is created to be the first line of a function which use +* Error **errp parameter to report error. It's needed only in cases where we +* want to use error_prepend, error_append_hint or dereference *errp. It's +* still safe (but useless) in other cases. +* +* If errp is NULL or points to error_fatal, it is rewritten to point to a +* local Error object, which will be automatically propagated to the original +* errp on function exit (see error_propagator_cleanup). +* +* After invocation of this macro it is always safe to dereference errp +* (as it's not NULL anymore) and to add information (by error_prepend or +* error_append_hint) +* (as, if it was error_fatal, we swapped it with a local_error to be +* propagated on cleanup). +* +* Note: we don't wrap the error_abort case, as we want resulting coredump +* to point to the place where the error happened, not to error_propagate. +*/ +#define ERRP_AUTO_PROPAGATE () \ + g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ + errp = ((errp == NULL || *errp == error_fatal) \ + ? &_auto_errp_prop.local_err : errp) +/* * Special error destination to abort on error. * See error_setg() and error_propagate() for details.
Signature · 7 lines
2.21.0 _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 02/11] error: auto propagated local_err
On Fri, 10 Jan 2020 at 19:42, Vladimir Sementsov-Ogievskiy <[email protected]> wrote:
[snip]
Quoted 14 lines
include/qapi/error.h +14
-0+/* +* ERRP_AUTO_PROPAGATE +* +* This macro is created to be the first line of a function which use +* Error **errp parameter to report error. It's needed only in cases where we +* want to use error_prepend, error_append_hint or dereference *errp. It's +* still safe (but useless) in other cases. +* +* If errp is NULL or points to error_fatal, it is rewritten to point to a +* local Error object, which will be automatically propagated to the original +* errp on function exit (see error_propagator_cleanup). +* +* After invocation of this macro it is always safe to dereference errp +* (as it's not NULL anymore) and to add information (by error_prepend or
include/qapi/error.h void error_set_internal(Error **errp, · line 430
Quoted 10 lines
include/qapi/error.h +10
-0+* error_append_hint) +* (as, if it was error_fatal, we swapped it with a local_error to be +* propagated on cleanup). +* +* Note: we don't wrap the error_abort case, as we want resulting coredump +* to point to the place where the error happened, not to error_propagate. +*/ +#define ERRP_AUTO_PROPAGATE () \ + g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ + errp = ((errp == NULL || *errp == error_fatal) \
Perhaps !errp rather than errp == NULL, for brevity.
Paul
Quoted 8 lines
include/qapi/error.h +2
-1+ ? &_auto_errp_prop.local_err : errp) +/* * Special error destination to abort on error. * See error_setg() and error_propagate() for details. -- 2.21.0
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 02/11] error: auto propagated local_err
Quoted 21 lines · Paul Durrant
On Fri, 10 Jan 2020 at 19:42, Vladimir Sementsov-Ogievskiy <[email protected]> wrote:
[snip]Quoted 18 lines
+/*
+ *ERRP_AUTO_PROPAGATE
+ *
+ * This macro is created to be the first line of a function which use
+ * Error **errp parameter to report error. It's needed only in cases where we
+ * want to useerror_prepend,error_append_hintor dereference *errp. It's
+ * still safe (but useless) in other cases.
+ *
+ * If errp is NULL or points toerror_fatal, it is rewritten to point to a
+ * local Error object, which will be automatically propagated to the original
+ * errp on function exit (seeerror_propagator_cleanup).
+ *
+ * After invocation of this macro it is always safe to dereference errp
+ * (as it's not NULL anymore) and to add information (byerror_prependor
+ *error_append_hint)
+ * (as, if it waserror_fatal, we swapped it with alocal_errorto be
+ * propagated on cleanup).
+ *
Quoted 9 lines
include/qapi/error.h void error_set_internal(Error **errp, · line 430
Quoted 6 lines
+ * Note: we don't wrap the
error_abortcase, as we want resulting coredump
+ * to point to the place where the error happened, not toerror_propagate.
+ */include/qapi/error.h +3
-0+#define ERRP_AUTO_PROPAGATE () \ + g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ + errp = ((errp == NULL || *errp == error_fatal) \Perhaps !errp rather than errp == NULL, for brevity.
I mostly prefer !ptr notation.. But may be here, I'd keep it as is, to stress special-casing NULL in this non-trivial place.. And it is in good relation with phrasing "If errp is NULL or points to error_fatal". But !errp is OK for me to. Let it be as Markus prefer, he is maintainer.
Quoted 9 lines
Quoted 9 lines
include/qapi/error.h +2
-1+ ? &_auto_errp_prop.local_err : errp) +/* * Special error destination to abort on error. * See error_setg() and error_propagate() for details. -- 2.21.0
Signature · 6 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 02/11] error: auto propagated local_err
In reply to Vladimir Sementsov-OgievskiyQuoted 21 lines · On Fri, 10 Jan 2020 22:41:49 +0300 Vladimir Sementsov-Ogievskiy…
Here is introduced
ERRP_AUTO_PROPAGATEmacro, to be used at start of functions with errp OUT parameter.It has three goals:
1. Fix issue with
error_fatal& error_prepend/error_append_hint: user can't see this additional information, becauseexit()happens inerror_setgearlier than information is added. [Reported by Greg Kurz]2. Fix issue with
error_abort&error_propagate: when we wraperror_abortby local_err+error_propagate, resulting coredump will refer toerror_propagateand not to the place where error happened. (the macro itself doesn't fix the issue, but it allows to [3.] drop all local_err+error_propagate pattern, which will definitely fix the issue) [Reported by Kevin Wolf]3. Drop local_err+error_propagate pattern, which is used to workaround void functions with errp parameter, when caller wants to know resulting status. (Note: actually these functions could be merely updated to return int error code).
Quoted 9 lines
To achieve these goals, we need to add invocation of the macro at start of functions, which needs error_prepend/error_append_hint (1.); add invocation of the macro at start of functions which do local_err+error_propagate scenario the check errors, drop local errors from them and just use *errp instead (2., 3.).
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
LGTM
Quoted 120 lines
CC Cornelia Huck <[email protected]>CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC "Philippe Mathieu-Daudé" <[email protected]>CC Laszlo Ersek <[email protected]>CC Gerd Hoffmann <[email protected]>CC Stefan Berger <[email protected]>CC Markus Armbruster <[email protected]>CC Michael Roth <[email protected]>include/qapi/error.h | 84 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 83 insertions(+), 1 deletion(-)include/qapi/error.h +76
-1@@ -78,7 +78,7 @@* Call a function treating errors as fatal: * foo(arg, &error_fatal); * -* Receive an error and pass it on to the caller: +* Receive an error and pass it on to the caller (DEPRECATED*): * Error *err = NULL; * foo(arg, &err); * if (err) { @@ -98,6 +98,50 @@* foo(arg, errp); * for readability. * +* DEPRECATED* This pattern is deprecated now, use ERRP_AUTO_PROPAGATE macro +* instead (defined below). +* It's deprecated because of two things: +* +* 1. Issue with error_abort & error_propagate: when we wrap error_abort by +* local_err+error_propagate, resulting coredump will refer to error_propagate +* and not to the place where error happened. +* +* 2. A lot of extra code of the same pattern +* +* How to update old code to use ERRP_AUTO_PROPAGATE? +* +* All you need is to add ERRP_AUTO_PROPAGATE() invocation at function start, +* than you may safely dereference errp to check errors and do not need any +* additional local Error variables or calls to error_propagate(). +* +* Example: +* +* old code +* +* void fn(..., Error **errp) { +* Error *err = NULL; +* foo(arg, &err); +* if (err) { +* handle the error... +* error_propagate(errp, err); +* return; +* } +* ... +* } +* +* updated code +* +* void fn(..., Error **errp) { +* ERRP_AUTO_PROPAGATE(); +* foo(arg, errp); +* if (*errp) { +* handle the error... +* return; +* } +* ... +* } +* +* * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; * foo(arg, &err); @@ -348,6 +392,44 @@ void error_set_internal(Error **errp, ErrorClass err_class, const char *fmt, ...) GCC_FMT_ATTR(6, 7); +typedef struct ErrorPropagator { +Error *local_err; +Error **errp; +}ErrorPropagator ; + +static inline void error_propagator_cleanup (ErrorPropagator *prop) +{ +error_propagate (prop->errp, prop->local_err); +} + +G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (ErrorPropagator, error_propagator_cleanup); + +/* +* ERRP_AUTO_PROPAGATE +* +* This macro is created to be the first line of a function which use +* Error **errp parameter to report error. It's needed only in cases where we +* want to use error_prepend, error_append_hint or dereference *errp. It's +* still safe (but useless) in other cases. +* +* If errp is NULL or points to error_fatal, it is rewritten to point to a +* local Error object, which will be automatically propagated to the original +* errp on function exit (see error_propagator_cleanup). +* +* After invocation of this macro it is always safe to dereference errp +* (as it's not NULL anymore) and to add information (by error_prepend or +* error_append_hint) +* (as, if it was error_fatal, we swapped it with a local_error to be +* propagated on cleanup). +* +* Note: we don't wrap the error_abort case, as we want resulting coredump
include/qapi/error.h void error_set_internal(Error **errp, · line 435
Quoted 10 lines
include/qapi/error.h +7
-0+* to point to the place where the error happened, not to error_propagate. +*/ +#define ERRP_AUTO_PROPAGATE () \ + g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ + errp = ((errp == NULL || *errp == error_fatal) \ + ? &_auto_errp_prop.local_err : errp) +/* * Special error destination to abort on error. * See error_setg() and error_propagate() for details.
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 02/11] error: auto propagated local_err
In reply to Vladimir Sementsov-OgievskiyQuoted 2 lines · Vladimir Sementsov-Ogievskiy
Here is introduced
ERRP_AUTO_PROPAGATEmacro, to be used at start of functions with errp OUT parameter.
s/with/with an/
Quoted 4 lines
It has three goals:
1. Fix issue with
error_fatal& error_prepend/error_append_hint: user
maybe s/&/and/ so it doesn't look like the C & operator.
Quoted 4 lines
can't see this additional information, because
exit()happens inerror_setgearlier than information is added. [Reported by Greg Kurz]2. Fix issue with
error_abort&error_propagate: when we wrap
and again
Quoted 1 line
error_abortby local_err+error_propagate, resulting coredump will
s/,/, the/
Quoted 2 lines
refer to
error_propagateand not to the place where error happened. (the macro itself doesn't fix the issue, but it allows to [3.] drop all
s/allows/allows us/
s/all/the/
Quoted 8 lines
local_err+error_propagate pattern, which will definitely fix the issue) [Reported by Kevin Wolf]
3. Drop local_err+error_propagate pattern, which is used to workaround void functions with errp parameter, when caller wants to know resulting status. (Note: actually these functions could be merely updated to return int error code).
Quoted 5 lines
To achieve these goals, we need to add invocation of the macro at start of functions, which needs error_prepend/error_append_hint (1.); add invocation of the macro at start of functions which do local_err+error_propagate scenario the check errors, drop local errors from them and just use *errp instead (2., 3.).
To achieve these goals, later patches will add invocations of this macro at the start of functions with either use error_prepend/error_append_hint (solving 1) or which use local_err+error_propagate to check errors, switching those functions to use *errp instead (solving 2 and 3).
Quoted 11 lines
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
- * Receive an error and pass it on to the caller:
+ * Receive an error and pass it on to the caller (DEPRECATED*):* Error *err = NULL; * foo(arg, &err); * if (err) {
include/qapi/error.h line 101
Quoted 4 lines
include/qapi/error.h +1
-0@@ -98,6 +98,50 @@* foo(arg, errp); * for readability. * +* DEPRECATED* This pattern is deprecated now, use ERRP_AUTO_PROPAGATE macro
s/use/use the/
include/qapi/error.h line 105
Quoted 4 lines
include/qapi/error.h +4
-0+* instead (defined below). +* It's deprecated because of two things: +* +* 1. Issue with error_abort & error_propagate: when we wrap error_abort by
s/&/and/
include/qapi/error.h line 106
Quoted 1 line
include/qapi/error.h +1
-0+* local_err+error_propagate, resulting coredump will refer to error_propagate
s/,/, the/
include/qapi/error.h void error_set_internal(Error **errp, · line 413
Quoted 12 lines
include/qapi/error.h +11
-0+* and not to the place where error happened. +* +* 2. A lot of extra code of the same pattern +* +/* +* ERRP_AUTO_PROPAGATE +* +* This macro is created to be the first line of a function which use +* Error **errp parameter to report error. It's needed only in cases where we +* want to use error_prepend, error_append_hint or dereference *errp. It's +* still safe (but useless) in other cases.
It doesn't _have_ to be the first line to compile (we require C99+ compilers, which allow declarations after statements); but rather because it makes it easier for our Coccinelle conversion script to catch outliers. But I think this text is okay, without calling out that extra information (maybe the commit message should mention it, though).
include/qapi/error.h void error_set_internal(Error **errp, · line 423
Quoted 10 lines
include/qapi/error.h +10
-0+* +* If errp is NULL or points to error_fatal, it is rewritten to point to a +* local Error object, which will be automatically propagated to the original +* errp on function exit (see error_propagator_cleanup). +* +* After invocation of this macro it is always safe to dereference errp +* (as it's not NULL anymore) and to add information (by error_prepend or +* error_append_hint) +* (as, if it was error_fatal, we swapped it with a local_error to be +* propagated on cleanup).
double () () looks odd, as does the mid-sentence newline.
include/qapi/error.h void error_set_internal(Error **errp, · line 435
Quoted 13 lines
include/qapi/error.h +9
-0+* +* Note: we don't wrap the error_abort case, as we want resulting coredump +* to point to the place where the error happened, not to error_propagate. +*/ +#define ERRP_AUTO_PROPAGATE () \ + g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ + errp = ((errp == NULL || *errp == error_fatal) \ + ? &_auto_errp_prop.local_err : errp) +/* * Special error destination to abort on error. * See error_setg() and error_propagate() for details.
The macro itself is fine, my comments are solely on the commit message and comments. Depending on how much cleanup Markus is willing to do rather than require a respin, you can add:
Signature · 9 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
PATCH v6 3/11 scripts: add coccinelle script to use auto propagated errp
In reply to Vladimir Sementsov-Ogievskiy---
include/qapi/error.h | 3 + scripts/coccinelle/auto-propagated-errp.cocci | 139 ++++++++++++++++++ 2 files changed, 142 insertions(+) create mode 100644 scripts/coccinelle/auto-propagated-errp.cocci
include/qapi/error.h +3 -0
@@ -141,6 +141,9 @@* ... * } * +* For mass conversion use script +* scripts/coccinelle/auto-propagated-errp.cocci +* * * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL;
scripts/coccinelle/auto-propagated-errp.cocci new file +139 -0
139 lines not on this page · raw message
Signature · 7 lines
2.21.0 _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 03/11] scripts: add coccinelle script to use auto propagated errp
Quoted 2 lines · Vladimir Sementsov-Ogievskiy
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
Rather light on the commit message. If nothing else, a comment about typical command-line usage would be helpful (yes, it's in the patch body, but sometimes I just refer to git log).
Quoted 24 lines
include/qapi/error.h +3
-0@@ -141,6 +141,9 @@* ... * } * +* For mass conversion use script +* scripts/coccinelle/auto-propagated-errp.cocci +* * * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0@@ -0,0 +1,139 @@ +// Use ERRP_AUTO_PROPAGATE (see include/qapi/error.h) +// +// Usage example:
scripts/coccinelle/auto-propagated-errp.cocci line 28
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// spatch --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ +// --macro-file scripts/cocci-macro-file.h --in-place --no-show-diff \ +// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@@ +// Add invocation to errp-functions where necessary +// We should skip functions with "Error *const *errp" +// parameter, but how to do it with coccinelle? +// I don't know, so, I skip them by function name regex. +// It's safe: if we not skip some functions with
s/not/did not/
Quoted 11 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +11
-0+// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation. +identifier fn !~ "error_append_.*_hint"; +identifier local_err, errp; +@@ + + fn(..., Error **errp, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+... + when != ERRP_AUTO_PROPAGATE();
scripts/coccinelle/auto-propagated-errp.cocci line 49
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+( + error_append_hint(errp, ...); +| + error_prepend(errp, ...); +| + Error *local_err = NULL; +) + ...+> + } +
Looks like it should catch all functions that require adding the macro.
scripts/coccinelle/auto-propagated-errp.cocci line 53
Quoted 4 lines
+@rule1@
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+// We do not inherit from previous rule, as we want to match +// also functions, which already had ERRP_AUTO_PROPAGATE +// invocation.
Grammar suggestion:
// We want to patch error propagation in functions regardless of // whether the function already uses ERRP_AUTO_PROPAGATE, hence // this one does not inherit from the first rule.
Signature · 9 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 03/11] scripts: add coccinelle script to use auto propagated errp
In reply to Vladimir Sementsov-OgievskiyQuoted 68 lines · Vladimir Sementsov-Ogievskiy
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Cornelia Huck <[email protected]>CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC "Philippe Mathieu-Daudé" <[email protected]>CC Laszlo Ersek <[email protected]>CC Gerd Hoffmann <[email protected]>CC Stefan Berger <[email protected]>CC Markus Armbruster <[email protected]>CC Michael Roth <[email protected]>include/qapi/error.h | 3 + scripts/coccinelle/auto-propagated-errp.cocci | 139 ++++++++++++++++++ 2 files changed, 142 insertions(+)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +3
-0@@ -141,6 +141,9 @@* ... * } * +* For mass conversion use script +* scripts/coccinelle/auto-propagated-errp.cocci +* * * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; scripts/coccinelle/auto-propagated-errp.cocci new file +22
-0@@ -0,0 +1,139 @@ +// Use ERRP_AUTO_PROPAGATE (see include/qapi/error.h) +// +// Copyright (c) 2020 Virtuozzo International GmbH. +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// +// Usage example: +// spatch --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ +// --macro-file scripts/cocci-macro-file.h --in-place --no-show-diff \ +// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] +
scripts/coccinelle/auto-propagated-errp.cocci line 32
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+@@ +// Add invocation to errp-functions where necessary +// We should skip functions with "Error *const *errp" +// parameter, but how to do it with coccinelle? +// I don't know, so, I skip them by function name regex. +// It's safe: if we not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation. +identifier fn !~ "error_append_.*_hint"; +identifier local_err, errp;
Hmm.
Note, that in new version I define errp as "identifier", which means, that we'll match Error ** parameters with other names..
Still, our ERRP_AUTO_PROPAGATE assumes that parameter called errp, and I'd prefere not to change it.
We can ignore this fact for now: inappropriately named errp parameter will break compilation in ERRP_AUTO_PROPAGATE() invocation, so it's safe enough. (Hope, there are no functions with two Error** parameters)
Or we can revert errp to be symbol again.
Quoted 108 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +107
-0+@@ + + fn(..., Error **errp, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+... + when != ERRP_AUTO_PROPAGATE(); +( + error_append_hint(errp, ...); +| + error_prepend(errp, ...); +| + Error *local_err = NULL; +) + ...+> + } + +@rule1@ +// We do not inherit from previous rule, as we want to match +// also functions, which already had ERRP_AUTO_PROPAGATE +// invocation. +identifier fn !~ "error_append_.*_hint"; +identifier local_err, errp; +@@ + + fn(..., Error **errp, ...) + { + <... +- Error *local_err = NULL; + ...> + } + +@@ +// Handle pattern with goto, otherwise we'll finish up +// with labels at function end which will not compile. +identifier rule1.fn, rule1.local_err, rule1.errp; +identifier OUT; +@@ + + fn(...) + { + <... +- goto OUT; ++ return; + ...> +- OUT: +- error_propagate(errp, local_err); + } + +@@ +identifier rule1.fn, rule1.local_err, rule1.errp; +expression list args; // to reindent error_propagate_prepend +@@ + + fn(...) + { + <... +( +- error_free(local_err); +- local_err = NULL; ++ error_free_errp(errp); +| +- error_free(local_err); ++ error_free_errp(errp); +| +- error_report_err(local_err); ++ error_report_errp(errp); +| +- warn_report_err(local_err); ++ warn_report_errp(errp); +| +- error_propagate_prepend(errp, local_err, args); ++ error_prepend(errp, args); +| +- error_propagate(errp, local_err); +) + ...> + } + +@@ +identifier rule1.fn, rule1.local_err, rule1.errp; +@@ + + fn(...) + { + <... +( +- &local_err ++ errp +| +- local_err ++ *errp +) + ...> + } + +@@ +identifier rule1.fn, rule1.errp; +@@ + + fn(...) + { + <... +- *errp != NULL ++ *errp + ...> + }
Signature · 6 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
PATCH v6 4/11 hw/sd/ssi-sd: fix error handling in ssi_sd_realize
In reply to Vladimir Sementsov-OgievskiyIt's wrong to use same err object as errp parameter for several function calls without intermediate checking for error: we'll crash if try to set err object twice.
Fix that, using new ERRP_AUTO_PROPAGATE macro.
--- hw/sd/ssi-sd.c | 26 +++++++++++++++++++------- 1 file changed, 19 insertions(+), 7 deletions(-)
hw/sd/ssi-sd.c +19 -7
@@ -241,10 +241,10 @@ static const VMStateDescription vmstate_ssi_sd = {static void ssi_sd_realize (SSISlave *d,Error **errp) { +ERRP_AUTO_PROPAGATE ();ssi_sd_state *s =FROM_SSI_SLAVE (ssi_sd_state, d);DeviceState *carddev;DriveInfo *dinfo; -Error *err =NULL ;qbus_create_inplace (&s->sdbus,sizeof (s->sdbus),TYPE_SD_BUS ,DEVICE (d),"sd-bus" );
@@ -254,14 +254,26 @@ static void ssi_sd_realize(SSISlave *d, Error **errp) dinfo =drive_get_next (IF_SD ); carddev =qdev_create (BUS (&s->sdbus),TYPE_SD_CARD );if (dinfo) { -qdev_prop_set_drive (carddev,"drive" ,blk_by_legacy_dinfo (dinfo), &err); +qdev_prop_set_drive (carddev,"drive" ,blk_by_legacy_dinfo (dinfo), errp); +if (*errp) { + goto fail; + } + } + +object_property_set_bool (OBJECT (carddev), true,"spi" , errp); +if (*errp) { + goto fail; } -object_property_set_bool (OBJECT (carddev), true,"spi" , &err); -object_property_set_bool (OBJECT (carddev), true,"realized" , &err); -if (err) { -error_setg (errp,"failed to init SD card: %s" ,error_get_pretty (err)); -return ; + +object_property_set_bool (OBJECT (carddev), true,"realized" , errp); +if (*errp) { + goto fail; } + +return ; + +fail: +error_prepend (errp,"failed to init SD card: " ); }static void ssi_sd_reset (DeviceState *dev)
Signature · 1 line
2.21.0
Re: [PATCH v6 04/11] hw/sd/ssi-sd: fix error handling in ssi_sd_realize
Quoted 11 lines · Vladimir Sementsov-Ogievskiy
It's wrong to use same err object as errp parameter for several function calls without intermediate checking for error: we'll crash if try to set err object twice.
Fix that, using new
ERRP_AUTO_PROPAGATEmacro.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- hw/sd/ssi-sd.c | 26 +++++++++++++++++++------- 1 file changed, 19 insertions(+), 7 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
PATCH v6 5/11 SD (Secure Card): introduce ERRP_AUTO_PROPAGATE
In reply to Vladimir Sementsov-OgievskiyIf we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases.
If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate)
This commit is generated by command
sed -n '/^SD (Secure Card)$/,/^$/{s/^F: //p}' \
MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80--- hw/sd/sdhci-pci.c | 7 +++---- hw/sd/sdhci.c | 21 +++++++++------------ 2 files changed, 12 insertions(+), 16 deletions(-)
hw/sd/sdhci-pci.c +3 -4
@@ -29,13 +29,12 @@ static Property sdhci_pci_properties[] = {static void sdhci_pci_realize (PCIDevice *dev,Error **errp) { +ERRP_AUTO_PROPAGATE ();SDHCIState *s =PCI_SDHCI (dev); -Error *local_err =NULL ;sdhci_initfn (s); -sdhci_common_realize (s, &local_err); -if (local_err) { -error_propagate (errp, local_err); +sdhci_common_realize (s, errp); +if (*errp) {return ; }
hw/sd/sdhci.c +9 -12
@@ -1293,7 +1293,7 @@ static const MemoryRegionOps sdhci_mmio_ops = {static void sdhci_init_readonly_registers (SDHCIState *s,Error **errp) { -Error *local_err =NULL ; +ERRP_AUTO_PROPAGATE ();switch (s->sd_spec_version) { case 2 ... 3:
@@ -1304,9 +1304,8 @@ static void sdhci_init_readonly_registers(SDHCIState *s, Error **errp) } s->version = (SDHC_HCVER_VENDOR <<8 ) | (s->sd_spec_version -1 ); -sdhci_check_capareg (s, &local_err); -if (local_err) { -error_propagate (errp, local_err); +sdhci_check_capareg (s, errp); +if (*errp) {return ; } }
@@ -1337,11 +1336,10 @@ void sdhci_uninitfn(SDHCIState *s)void sdhci_common_realize (SDHCIState *s,Error **errp) { -Error *local_err =NULL ; +ERRP_AUTO_PROPAGATE (); -sdhci_init_readonly_registers (s, &local_err); -if (local_err) { -error_propagate (errp, local_err); +sdhci_init_readonly_registers (s, errp); +if (*errp) {return ; } s->buf_maxsz =sdhci_get_fifolen (s);
@@ -1461,13 +1459,12 @@ static void sdhci_sysbus_finalize(Object *obj)static void sdhci_sysbus_realize (DeviceState *dev,Error **errp) { +ERRP_AUTO_PROPAGATE ();SDHCIState *s =SYSBUS_SDHCI (dev);SysBusDevice *sbd =SYS_BUS_DEVICE (dev); -Error *local_err =NULL ; -sdhci_common_realize (s, &local_err); -if (local_err) { -error_propagate (errp, local_err); +sdhci_common_realize (s, errp); +if (*errp) {return ; }
Signature · 1 line
2.21.0
PATCH v6 6/11 pflash: introduce ERRP_AUTO_PROPAGATE
In reply to Vladimir Sementsov-OgievskiyIf we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases.
If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate)
This commit is generated by command
sed -n '/^Parallel NOR Flash devices$/,/^$/{s/^F: //p}' \
MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80--- hw/block/pflash_cfi01.c | 7 +++---- hw/block/pflash_cfi02.c | 7 +++---- 2 files changed, 6 insertions(+), 8 deletions(-)
hw/block/pflash_cfi01.c +3 -4
@@ -700,12 +700,12 @@ static const MemoryRegionOps pflash_cfi01_ops = {static void pflash_cfi01_realize (DeviceState *dev,Error **errp) { +ERRP_AUTO_PROPAGATE ();PFlashCFI01 *pfl =PFLASH_CFI01 (dev);uint64_t total_len;int ret;uint64_t blocks_per_device, sector_len_per_device, device_len;int num_devices; -Error *local_err =NULL ;if (pfl->sector_len ==0 ) {error_setg (errp,"attribute \"sector-length\" not specified or zero." );
@@ -739,9 +739,8 @@ static void pflash_cfi01_realize(DeviceState *dev, Error **errp) &pfl->mem,OBJECT (dev), &pflash_cfi01_ops, pfl, - pfl->name, total_len, &local_err); -if (local_err) { -error_propagate (errp, local_err); + pfl->name, total_len, errp); +if (*errp) {return ; }
hw/block/pflash_cfi02.c +3 -4
@@ -719,9 +719,9 @@ static const MemoryRegionOps pflash_cfi02_ops = {static void pflash_cfi02_realize (DeviceState *dev,Error **errp) { +ERRP_AUTO_PROPAGATE ();PFlashCFI02 *pfl =PFLASH_CFI02 (dev);int ret; -Error *local_err =NULL ;if (pfl->uniform_sector_len ==0 && pfl->sector_len[0 ] ==0 ) {error_setg (errp,"attribute \"sector-length\" not specified or zero." );
@@ -787,9 +787,8 @@ static void pflash_cfi02_realize(DeviceState *dev, Error **errp)memory_region_init_rom_device (&pfl->orig_mem,OBJECT (pfl), &pflash_cfi02_ops, pfl, pfl->name, - pfl->chip_len, &local_err); -if (local_err) { -error_propagate (errp, local_err); + pfl->chip_len, errp); +if (*errp) {return ; }
Signature · 1 line
2.21.0
PATCH v6 7/11 fw_cfg: introduce ERRP_AUTO_PROPAGATE
In reply to Vladimir Sementsov-OgievskiyIf we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases.
If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate)
This commit is generated by command
sed -n '/^Firmware configuration (fw_cfg)$/,/^$/{s/^F: //p}' \
MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80--- hw/nvram/fw_cfg.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
hw/nvram/fw_cfg.c +6 -8
@@ -1142,12 +1142,11 @@ static Property fw_cfg_io_properties[] = {static void fw_cfg_io_realize (DeviceState *dev,Error **errp) { +ERRP_AUTO_PROPAGATE ();FWCfgIoState *s =FW_CFG_IO (dev); -Error *local_err =NULL ; -fw_cfg_file_slots_allocate (FW_CFG (s), &local_err); -if (local_err) { -error_propagate (errp, local_err); +fw_cfg_file_slots_allocate (FW_CFG (s), errp); +if (*errp) {return ; }
@@ -1193,14 +1192,13 @@ static Property fw_cfg_mem_properties[] = {static void fw_cfg_mem_realize (DeviceState *dev,Error **errp) { +ERRP_AUTO_PROPAGATE ();FWCfgMemState *s =FW_CFG_MEM (dev);SysBusDevice *sbd =SYS_BUS_DEVICE (dev);const MemoryRegionOps *data_ops = &fw_cfg_data_mem_ops; -Error *local_err =NULL ; -fw_cfg_file_slots_allocate (FW_CFG (s), &local_err); -if (local_err) { -error_propagate (errp, local_err); +fw_cfg_file_slots_allocate (FW_CFG (s), errp); +if (*errp) {return ; }
Signature · 1 line
2.21.0
PATCH v6 8/11 virtio-9p: introduce ERRP_AUTO_PROPAGATE
In reply to Vladimir Sementsov-OgievskiyIf we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases.
If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate)
This commit is generated by command
sed -n '/^virtio-9p$/,/^$/{s/^F: //p}' MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80--- hw/9pfs/9p-local.c | 12 +++++------- hw/9pfs/9p.c | 1 + 2 files changed, 6 insertions(+), 7 deletions(-)
hw/9pfs/9p-local.c +5 -7
@@ -1481,10 +1481,10 @@ static void error_append_security_model_hint(Error *const *errp)static int local_parse_opts (QemuOpts *opts,FsDriverEntry *fse,Error **errp) { +ERRP_AUTO_PROPAGATE ();const char *sec_model =qemu_opt_get (opts,"security_model" );const char *path =qemu_opt_get (opts,"path" );const char *multidevs =qemu_opt_get (opts,"multidevs" ); -Error *local_err =NULL ;if (!sec_model) {error_setg (errp,"security_model property not set" );
@@ -1518,11 +1518,10 @@ static int local_parse_opts(QemuOpts *opts, FsDriverEntry *fse, Error **errp) fse->export_flags &= ~V9FS_FORBID_MULTIDEVS ; fse->export_flags &= ~V9FS_REMAP_INODES ; }else { -error_setg (&local_err,"invalid multidevs property '%s'" , +error_setg (errp,"invalid multidevs property '%s'" , multidevs); -error_append_hint (&local_err,"Valid options are: multidevs=" +error_append_hint (errp,"Valid options are: multidevs=" "[remap|forbid|warn]\n" ); -error_propagate (errp, local_err);return -1 ; } }
@@ -1532,9 +1531,8 @@ static int local_parse_opts(QemuOpts *opts, FsDriverEntry *fse, Error **errp)return -1 ; } -if (fsdev_throttle_parse_opts (opts, &fse->fst, &local_err)) { -error_propagate_prepend (errp, local_err, -"invalid throttle configuration: " ); +if (fsdev_throttle_parse_opts (opts, &fse->fst, errp)) { +error_prepend (errp,"invalid throttle configuration: " );return -1 ; }
hw/9pfs/9p.c +1 -0
@@ -3994,6 +3994,7 @@ void pdu_submit(V9fsPDU *pdu, P9MsgHeader *hdr)int v9fs_device_realize_common (V9fsState *s,const V9fsTransport *t,Error **errp) { +ERRP_AUTO_PROPAGATE ();int i, len;struct stat stat;FsDriverEntry *fse;
Signature · 1 line
2.21.0
Re: [PATCH v6 08/11] virtio-9p: introduce ERRP_AUTO_PROPAGATE
Quoted 24 lines · On Fri, 10 Jan 2020 22:41:55 +0300 Vladimir Sementsov-Ogievskiy…
If we want to add some info to errp (by
error_prepend()orerror_append_hint()), we must use theERRP_AUTO_PROPAGATEmacro. Otherwise, this info will not be added when errp ==&error_fatal(the program will exit prior to theerror_append_hint()orerror_prepend()call). Fix such cases.If we want to check error after errp-function call, we need to introduce
local_errand then propagate it to errp. Instead, useERRP_AUTO_PROPAGATEmacro, benefits are:
1. No need of expliciterror_propagatecall
2. No need of explicitlocal_errvariable: use errp directly
3.ERRP_AUTO_PROPAGATEleaves errp as is if it's not NULL or&error_fatal, this means that we don't breakerror_abort(we'll abort onerror_set, not onerror_propagate)This commit is generated by command
sed -n '/^virtio-9p$/,/^$/{s/^F: //p}' MAINTAINERS | \ xargs git ls-files | grep '\.[hc]$' | \ xargs spatch \ --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ --macro-file scripts/cocci-macro-file.h \ --in-place --no-show-diff --max-width 80
Quoted 4 lines
Reported-by Kevin Wolf <[email protected]>Reported-by Greg Kurz <[email protected]>Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
Quoted 58 lines
hw/9pfs/9p-local.c | 12 +++++------- hw/9pfs/9p.c | 1 + 2 files changed, 6 insertions(+), 7 deletions(-)hw/9pfs/9p-local.c +5
-7@@ -1481,10 +1481,10 @@ static void error_append_security_model_hint(Error *const *errp)static int local_parse_opts (QemuOpts *opts,FsDriverEntry *fse,Error **errp) { +ERRP_AUTO_PROPAGATE ();const char *sec_model =qemu_opt_get (opts,"security_model" );const char *path =qemu_opt_get (opts,"path" );const char *multidevs =qemu_opt_get (opts,"multidevs" ); -Error *local_err =NULL ;if (!sec_model) {error_setg (errp,"security_model property not set" );@@ -1518,11 +1518,10 @@ static int local_parse_opts(QemuOpts *opts, FsDriverEntry *fse, Error **errp) fse->export_flags &= ~V9FS_FORBID_MULTIDEVS ; fse->export_flags &= ~V9FS_REMAP_INODES ; }else { -error_setg (&local_err,"invalid multidevs property '%s'" , +error_setg (errp,"invalid multidevs property '%s'" , multidevs); -error_append_hint (&local_err,"Valid options are: multidevs=" +error_append_hint (errp,"Valid options are: multidevs=" "[remap|forbid|warn]\n" ); -error_propagate (errp, local_err);return -1 ; } }@@ -1532,9 +1531,8 @@ static int local_parse_opts(QemuOpts *opts, FsDriverEntry *fse, Error **errp)return -1 ; } -if (fsdev_throttle_parse_opts (opts, &fse->fst, &local_err)) { -error_propagate_prepend (errp, local_err, -"invalid throttle configuration: " ); +if (fsdev_throttle_parse_opts (opts, &fse->fst, errp)) { +error_prepend (errp,"invalid throttle configuration: " );return -1 ; }hw/9pfs/9p.c +1
-0@@ -3994,6 +3994,7 @@ void pdu_submit(V9fsPDU *pdu, P9MsgHeader *hdr)int v9fs_device_realize_common (V9fsState *s,const V9fsTransport *t,Error **errp) { +ERRP_AUTO_PROPAGATE ();int i, len;struct stat stat;FsDriverEntry *fse;
PATCH v6 9/11 TPM: introduce ERRP_AUTO_PROPAGATE
In reply to Vladimir Sementsov-OgievskiyIf we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases.
If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate)
This commit is generated by command
sed -n '/^TPM$/,/^$/{s/^F: //p}' MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80--- hw/tpm/tpm_util.c | 7 +++---- tpm.c | 7 +++---- 2 files changed, 6 insertions(+), 8 deletions(-)
hw/tpm/tpm_util.c +3 -4
@@ -47,8 +47,8 @@ static void get_tpm(Object *obj, Visitor *v, const char *name, void *opaque,static void set_tpm (Object *obj,Visitor *v,const char *name,void *opaque,Error **errp) { +ERRP_AUTO_PROPAGATE ();DeviceState *dev =DEVICE (obj); -Error *local_err =NULL ;Property *prop = opaque;TPMBackend *s, **be =qdev_get_prop_ptr (dev, prop);char *str;
@@ -58,9 +58,8 @@ static void set_tpm(Object *obj, Visitor *v, const char *name, void *opaque,return ; } -visit_type_str (v, name, &str, &local_err); -if (local_err) { -error_propagate (errp, local_err); +visit_type_str (v, name, &str, errp); +if (*errp) {return ; }
tpm.c +3 -4
@@ -81,11 +81,11 @@ TPMBackend *qemu_find_tpm_be(const char *id)static int tpm_init_tpmdev (void *dummy,QemuOpts *opts,Error **errp) { +ERRP_AUTO_PROPAGATE ();const char *value;const char *id;const TPMBackendClass *be;TPMBackend *drv; -Error *local_err =NULL ;int i;if (!QLIST_EMPTY (&tpm_backends)) {
@@ -116,9 +116,8 @@ static int tpm_init_tpmdev(void *dummy, QemuOpts *opts, Error **errp) }/* validate backend specific opts */ -qemu_opts_validate (opts, be->opts, &local_err); -if (local_err) { -error_propagate (errp, local_err); +qemu_opts_validate (opts, be->opts, errp); +if (*errp) {return 1 ; }
Signature · 1 line
2.21.0
PATCH v6 10/11 nbd: introduce ERRP_AUTO_PROPAGATE
In reply to Vladimir Sementsov-OgievskiyIf we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases.
If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate)
This commit is generated by command
sed -n '/^Network Block Device (NBD)$/,/^$/{s/^F: //p}' \
MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80--- include/block/nbd.h | 1 + block/nbd.c | 49 +++++++++++++++++++++------------------------ nbd/client.c | 5 +++++ nbd/server.c | 5 +++++ 4 files changed, 34 insertions(+), 26 deletions(-)
include/block/nbd.h +1 -0
@@ -360,6 +360,7 @@ void nbd_server_start(SocketAddress *addr, const char *tls_creds,static inline int nbd_read (QIOChannel *ioc,void *buffer,size_t size,const char *desc,Error **errp) { +ERRP_AUTO_PROPAGATE ();int ret =qio_channel_read_all (ioc, buffer, size, errp) <0 ? -EIO :0 ;if (ret <0 ) {
block/nbd.c +23 -26
148 lines not on this page · raw message
nbd/client.c +5 -0
@@ -68,6 +68,7 @@ static int nbd_send_option_request(QIOChannel *ioc, uint32_t opt, uint32_t len, const char *data, Error **errp) { +ERRP_AUTO_PROPAGATE ();NBDOption req;QEMU_BUILD_BUG_ON (sizeof (req) !=16 );
@@ -153,6 +154,7 @@ static int nbd_receive_option_reply(QIOChannel *ioc, uint32_t opt,static int nbd_handle_reply_err (QIOChannel *ioc,NBDOptionReply *reply,bool strict,Error **errp) { +ERRP_AUTO_PROPAGATE (); g_autofree char *msg = NULL;if (!(reply->type & (1 <<31 ))) {
@@ -337,6 +339,7 @@ static int nbd_receive_list(QIOChannel *ioc, char **name, char **description,static int nbd_opt_info_or_go (QIOChannel *ioc,uint32_t opt,NBDExportInfo *info,Error **errp) { +ERRP_AUTO_PROPAGATE ();NBDOptionReply reply;uint32_t len =strlen (info->name);uint16_t type;
@@ -882,6 +885,7 @@ static int nbd_start_negotiate(AioContext *aio_context, QIOChannel *ioc, bool structured_reply, bool *zeroes, Error **errp) { +ERRP_AUTO_PROPAGATE ();uint64_t magic;trace_nbd_start_negotiate (tlscreds, hostname ? hostname :"<null>" );
@@ -1017,6 +1021,7 @@ int nbd_receive_negotiate(AioContext *aio_context, QIOChannel *ioc, const char *hostname, QIOChannel **outioc, NBDExportInfo *info, Error **errp) { +ERRP_AUTO_PROPAGATE ();int result;bool zeroes;bool base_allocation = info->base_allocation;
nbd/server.c +5 -0
@@ -211,6 +211,7 @@ static int GCC_FMT_ATTR(4, 0) nbd_negotiate_send_rep_verr(NBDClient *client, uint32_t type, Error **errp, const char *fmt, va_list va) { +ERRP_AUTO_PROPAGATE (); g_autofree char *msg = NULL;int ret;size_t len;
@@ -369,6 +370,7 @@ static int nbd_opt_read_name(NBDClient *client, char **name, uint32_t *length,static int nbd_negotiate_send_rep_list (NBDClient *client,NBDExport *exp,Error **errp) { +ERRP_AUTO_PROPAGATE ();size_t name_len, desc_len;uint32_t len;const char *name = exp->name ? exp->name :"" ;
@@ -432,6 +434,7 @@ static void nbd_check_meta_export(NBDClient *client)static int nbd_negotiate_handle_export_name (NBDClient *client,bool no_zeroes,Error **errp) { +ERRP_AUTO_PROPAGATE (); g_autofree char *name = NULL;char buf[NBD_REPLY_EXPORT_NAME_SIZE ] ="" ;size_t len;
@@ -1272,6 +1275,7 @@ static int nbd_negotiate_options(NBDClient *client, Error **errp)*/ static coroutine_fn int nbd_negotiate(NBDClient *client, Error **errp) { +ERRP_AUTO_PROPAGATE ();char buf[NBD_OLDSTYLE_NEGOTIATE_SIZE ] ="" ;int ret;
@@ -1646,6 +1650,7 @@ void nbd_export_close(NBDExport *exp)void nbd_export_remove (NBDExport *exp,NbdServerRemoveMode mode,Error **errp) { +ERRP_AUTO_PROPAGATE ();if (mode ==NBD_SERVER_REMOVE_MODE_HARD ||QTAILQ_EMPTY (&exp->clients)) {nbd_export_close (exp);return ;
Signature · 1 line
2.21.0
PATCH v6 11/11 xen: introduce ERRP_AUTO_PROPAGATE
In reply to Vladimir Sementsov-OgievskiyIf we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases.
If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are:
1. No need of explicit error_propagate call
2. No need of explicit local_err variable: use errp directly
3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate)
This commit is generated by command
sed -n '/^X86 Xen CPUs$/,/^$/{s/^F: //p}' MAINTAINERS | \
xargs git ls-files | grep '\.[hc]$' | \
xargs spatch \
--sp-file scripts/coccinelle/auto-propagated-errp.cocci \
--macro-file scripts/cocci-macro-file.h \
--in-place --no-show-diff --max-width 80--- hw/block/dataplane/xen-block.c | 17 ++--- hw/block/xen-block.c | 125 ++++++++++++++------------------- hw/pci-host/xen_igd_pt.c | 7 +- hw/xen/xen-backend.c | 7 +- hw/xen/xen-bus.c | 100 ++++++++++++-------------- hw/xen/xen-host-pci-device.c | 27 ++++--- hw/xen/xen_pt.c | 25 +++---- hw/xen/xen_pt_config_init.c | 20 +++--- 8 files changed, 142 insertions(+), 186 deletions(-)
hw/block/dataplane/xen-block.c +7 -10
@@ -727,8 +727,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane,unsigned int protocol, Error **errp) { +ERRP_AUTO_PROPAGATE ();XenDevice *xendev = dataplane->xendev; -Error *local_err =NULL ;unsigned int ring_size;unsigned int i;
@@ -764,9 +764,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, }xen_device_set_max_grant_refs (xendev, dataplane->nr_ring_ref, - &local_err); -if (local_err) { -error_propagate (errp, local_err); + errp); +if (*errp) { goto stop; }
@@ -774,9 +773,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, dataplane->ring_ref, dataplane->nr_ring_ref,PROT_READ |PROT_WRITE , - &local_err); -if (local_err) { -error_propagate (errp, local_err); + errp); +if (*errp) { goto stop; }
@@ -809,9 +807,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, dataplane->event_channel =xen_device_bind_event_channel (xendev, dataplane->ctx, event_channel, xen_block_dataplane_event, dataplane, - &local_err); -if (local_err) { -error_propagate (errp, local_err); + errp); +if (*errp) { goto stop; }
hw/block/xen-block.c +52 -73
301 lines not on this page · raw message
hw/pci-host/xen_igd_pt.c +3 -4
@@ -79,17 +79,16 @@ static void host_pci_config_read(int pos, int len, uint32_t *val, Error **errp)static void igd_pt_i440fx_realize (PCIDevice *pci_dev,Error **errp) { +ERRP_AUTO_PROPAGATE ();uint32_t val =0 ;size_t i;int pos, len; -Error *local_err =NULL ;for (i =0 ; i <ARRAY_SIZE (igd_host_bridge_infos); i++) { pos = igd_host_bridge_infos[i].offset; len = igd_host_bridge_infos[i].len; -host_pci_config_read (pos, len, &val, &local_err); -if (local_err) { -error_propagate (errp, local_err); +host_pci_config_read (pos, len, &val, errp); +if (*errp) {return ; }pci_default_write_config (pci_dev, pos, val, len);
hw/xen/xen-backend.c +3 -4
@@ -98,9 +98,9 @@ static void xen_backend_list_remove(XenBackendInstance *backend)void xen_backend_device_create (XenBus *xenbus,const char *type,const char *name,QDict *opts,Error **errp) { +ERRP_AUTO_PROPAGATE ();const XenBackendImpl *impl =xen_backend_table_lookup (type);XenBackendInstance *backend; -Error *local_error =NULL ;if (!impl) {return ;
@@ -110,9 +110,8 @@ void xen_backend_device_create(XenBus *xenbus, const char *type, backend->xenbus = xenbus; backend->name =g_strdup (name); - impl->create (backend, opts, &local_error); -if (local_error) { -error_propagate (errp, local_error); + impl->create (backend, opts, errp); +if (*errp) {g_free (backend->name);g_free (backend);return ;
hw/xen/xen-bus.c +43 -57
242 lines not on this page · raw message
hw/xen/xen-host-pci-device.c +13 -14
@@ -333,8 +333,8 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, uint8_t bus, uint8_t dev, uint8_t func, Error **errp) { +ERRP_AUTO_PROPAGATE ();unsigned int v; -Error *err =NULL ; d->config_fd =-1 ; d->domain = domain;
@@ -342,36 +342,36 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, d->dev = dev; d->func = func; -xen_host_pci_config_open (d, &err); -if (err) { +xen_host_pci_config_open (d, errp); +if (*errp) { goto error; } -xen_host_pci_get_resource (d, &err); -if (err) { +xen_host_pci_get_resource (d, errp); +if (*errp) { goto error; } -xen_host_pci_get_hex_value (d,"vendor" , &v, &err); -if (err) { +xen_host_pci_get_hex_value (d,"vendor" , &v, errp); +if (*errp) { goto error; } d->vendor_id = v; -xen_host_pci_get_hex_value (d,"device" , &v, &err); -if (err) { +xen_host_pci_get_hex_value (d,"device" , &v, errp); +if (*errp) { goto error; } d->device_id = v; -xen_host_pci_get_dec_value (d,"irq" , &v, &err); -if (err) { +xen_host_pci_get_dec_value (d,"irq" , &v, errp); +if (*errp) { goto error; } d->irq = v; -xen_host_pci_get_hex_value (d,"class" , &v, &err); -if (err) { +xen_host_pci_get_hex_value (d,"class" , &v, errp); +if (*errp) { goto error; } d->class_code = v;
@@ -381,7 +381,6 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain,return ; error: -error_propagate (errp, err);if (d->config_fd >=0 ) {close (d->config_fd);
hw/xen/xen_pt.c +11 -14
@@ -767,12 +767,12 @@ static void xen_pt_destroy(PCIDevice *d) {static void xen_pt_realize (PCIDevice *d,Error **errp) { +ERRP_AUTO_PROPAGATE ();XenPCIPassthroughState *s =XEN_PT_DEVICE (d);int i, rc =0 ;uint8_t machine_irq =0 , scratch;uint16_t cmd =0 ;int pirq =XEN_PT_UNASSIGNED_PIRQ ; -Error *err =NULL ;/* register real device */ XEN_PT_LOG(d, "Assigning real physical device %02x:%02x.%d"
@@ -783,10 +783,9 @@ static void xen_pt_realize(PCIDevice *d, Error **errp)xen_host_pci_device_get (&s->real_device, s->hostaddr.domain, s->hostaddr.bus, s->hostaddr.slot, s->hostaddr.function, - &err); -if (err) { -error_append_hint (&err,"Failed to \"open\" the real pci device" ); -error_propagate (errp, err); + errp); +if (*errp) { +error_append_hint (errp,"Failed to \"open\" the real pci device" );return ; }
@@ -813,11 +812,10 @@ static void xen_pt_realize(PCIDevice *d, Error **errp)return ; } -xen_pt_setup_vga (s, &s->real_device, &err); -if (err) { -error_append_hint (&err,"Setup VGA BIOS of passthrough" -" GFX failed" ); -error_propagate (errp, err); +xen_pt_setup_vga (s, &s->real_device, errp); +if (*errp) { +error_append_hint (errp,"Setup VGA BIOS of passthrough" +" GFX failed" );xen_host_pci_device_put (&s->real_device);return ; }
@@ -830,10 +828,9 @@ static void xen_pt_realize(PCIDevice *d, Error **errp)xen_pt_register_regions (s, &cmd);/* reinitialize each config register to be emulated */ -xen_pt_config_init (s, &err); -if (err) { -error_append_hint (&err,"PCI Config space initialisation failed" ); -error_propagate (errp, err); +xen_pt_config_init (s, errp); +if (*errp) { +error_append_hint (errp,"PCI Config space initialisation failed" ); rc =-1 ; goto err_out; }
hw/xen/xen_pt_config_init.c +10 -10
@@ -2008,8 +2008,8 @@ static void xen_pt_config_reg_init(XenPCIPassthroughState *s,void xen_pt_config_init (XenPCIPassthroughState *s,Error **errp) { +ERRP_AUTO_PROPAGATE ();int i, rc; -Error *err =NULL ;QLIST_INIT (&s->reg_grps);
@@ -2052,10 +2052,9 @@ void xen_pt_config_init(XenPCIPassthroughState *s, Error **errp) reg_grp_offset, ®_grp_entry->size);if (rc <0 ) { -error_setg (&err,"Failed to initialize %d/%zu, type = 0x%x," +error_setg (errp,"Failed to initialize %d/%zu, type = 0x%x," " rc: %d" , i,ARRAY_SIZE (xen_pt_emu_reg_grps), xen_pt_emu_reg_grps[i].grp_type, rc); -error_propagate (errp, err);xen_pt_config_delete (s);return ; }
@@ -2068,13 +2067,14 @@ void xen_pt_config_init(XenPCIPassthroughState *s, Error **errp)/* initialize capability register */ for (j =0 ; regs->size !=0 ; j++, regs++) { -xen_pt_config_reg_init (s, reg_grp_entry, regs, &err); -if (err) { -error_append_hint (&err,"Failed to init register %d" -" offsets 0x%x in grp_type = 0x%x (%d/%zu)" , j, - regs->offset, xen_pt_emu_reg_grps[i].grp_type, - i,ARRAY_SIZE (xen_pt_emu_reg_grps)); -error_propagate (errp, err); +xen_pt_config_reg_init (s, reg_grp_entry, regs, errp); +if (*errp) { +error_append_hint (errp,"Failed to init register %d" +" offsets 0x%x in grp_type = 0x%x (%d/%zu)" , + j, + regs->offset, + xen_pt_emu_reg_grps[i].grp_type, + i,ARRAY_SIZE (xen_pt_emu_reg_grps));xen_pt_config_delete (s);return ; }
Signature · 7 lines
2.21.0 _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 11/11] xen: introduce ERRP_AUTO_PROPAGATE
Quoted 25 lines · Vladimir Sementsov-Ogievskiy
If we want to add some info to errp (by
error_prepend()orerror_append_hint()), we must use theERRP_AUTO_PROPAGATEmacro. Otherwise, this info will not be added when errp ==&error_fatal(the program will exit prior to theerror_append_hint()orerror_prepend()call). Fix such cases.If we want to check error after errp-function call, we need to introduce
local_errand then propagate it to errp. Instead, useERRP_AUTO_PROPAGATEmacro, benefits are:
1. No need of expliciterror_propagatecall
2. No need of explicitlocal_errvariable: use errp directly
3.ERRP_AUTO_PROPAGATEleaves errp as is if it's not NULL or&error_fatal, this means that we don't breakerror_abort(we'll abort onerror_set, not onerror_propagate)This commit is generated by command
sed -n '/^X86 Xen CPUs$/,/^$/{s/^F: //p}' MAINTAINERS | \ xargs git ls-files | grep '\.[hc]$' | \ xargs spatch \ --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ --macro-file scripts/cocci-macro-file.h \ --in-place --no-show-diff --max-width 80
Quoted 3 lines
Reported-by Kevin Wolf <[email protected]>Reported-by Greg Kurz <[email protected]>Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v6 11/11] xen: introduce ERRP_AUTO_PROPAGATE
Quoted 27 lines · Paul Durrant
Quoted 25 lines · Vladimir Sementsov-Ogievskiy
If we want to add some info to errp (by
error_prepend()orerror_append_hint()), we must use theERRP_AUTO_PROPAGATEmacro. Otherwise, this info will not be added when errp ==&error_fatal(the program will exit prior to theerror_append_hint()orerror_prepend()call). Fix such cases.If we want to check error after errp-function call, we need to introduce
local_errand then propagate it to errp. Instead, useERRP_AUTO_PROPAGATEmacro, benefits are:
1. No need of expliciterror_propagatecall
2. No need of explicitlocal_errvariable: use errp directly
3.ERRP_AUTO_PROPAGATEleaves errp as is if it's not NULL or&error_fatal, this means that we don't breakerror_abort(we'll abort onerror_set, not onerror_propagate)This commit is generated by command
sed -n '/^X86 Xen CPUs$/,/^$/{s/^F: //p}' MAINTAINERS | \ xargs git ls-files | grep '\.[hc]$' | \ xargs spatch \ --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ --macro-file scripts/cocci-macro-file.h \ --in-place --no-show-diff --max-width 80
Quoted 6 lines
Quoted 3 lines
Reported-by Kevin Wolf <[email protected]>Reported-by Greg Kurz <[email protected]>Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Acked-by Paul Durrant <[email protected]>
Thanks!
Signature · 6 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Patchew URL: https://patchew.org/QEMU/[email protected]/
Patchew URL: https://patchew.org/QEMU/[email protected]/
Hi,
This series seems to have some coding style problems. See output below for more information:
Subject: [Xen-devel] [PATCH v6 00/11] error: auto propagated local_err part I
Type: series
Message-id: [email protected]
=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base > /dev/null || exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram./scripts/checkpatch.pl --mailback base..
=== TEST SCRIPT END ===
Switched to a new branch 'test'
fee0dd2 xen: introduce ERRP_AUTO_PROPAGATE
9074b45 nbd: introduce ERRP_AUTO_PROPAGATE
05632cb TPM: introduce ERRP_AUTO_PROPAGATE
2a019cd virtio-9p: introduce ERRP_AUTO_PROPAGATE b4e0525 fw_cfg: introduce ERRP_AUTO_PROPAGATE
3a69800 pflash: introduce ERRP_AUTO_PROPAGATE
f4ac870 SD (Secure Card): introduce ERRP_AUTO_PROPAGATE 29fbc1d hw/sd/ssi-sd: fix error handling in ssi_sd_realize 6ebc57a scripts: add coccinelle script to use auto propagated errp 477b9ec error: auto propagated local_err
0c38914 qapi/error: add (Error **errp) cleaning APIs
=== OUTPUT BEGIN ===
1/11 Checking commit 0c389147591a (qapi/error: add (Error **errp) cleaning APIs) 2/11 Checking commit 477b9ec03898 (error: auto propagated local_err)
ERROR: Macros with multiple statements should be enclosed in a do - while loop #138: FILE: include/qapi/error.h:428:
+#define ERRP_AUTO_PROPAGATE() \
+ g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \
+ errp = ((errp == NULL || *errp == error_fatal) \+ ? &_auto_errp_prop.local_err : errp)
total: 1 errors, 0 warnings, 102 lines checked
Patch 2/11 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
3/11 Checking commit 6ebc57a94cf0 (scripts: add coccinelle script to use auto propagated errp)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#25:
new file mode 100644
total: 0 errors, 1 warnings, 148 lines checked
Patch 3/11 has style problems, please review. If any of these errors are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
4/11 Checking commit 29fbc1d61eb1 (hw/sd/ssi-sd: fix error handling in ssi_sd_realize) 5/11 Checking commit f4ac87065f2c (SD (Secure Card): introduce ERRP_AUTO_PROPAGATE) 6/11 Checking commit 3a69800331a4 (pflash: introduce ERRP_AUTO_PROPAGATE) 7/11 Checking commit b4e0525d3dcf (fw_cfg: introduce ERRP_AUTO_PROPAGATE) 8/11 Checking commit 2a019cd1f992 (virtio-9p: introduce ERRP_AUTO_PROPAGATE) 9/11 Checking commit 05632cbe2d39 (TPM: introduce ERRP_AUTO_PROPAGATE) 10/11 Checking commit 9074b450cb34 (nbd: introduce ERRP_AUTO_PROPAGATE) 11/11 Checking commit fee0dd26ea0b (xen: introduce ERRP_AUTO_PROPAGATE) === OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/[email protected]/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to [email protected]
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Markus, what about this? Should I respin?
Quoted 130 lines · Vladimir Sementsov-Ogievskiy
Hi all!
Now, when preparations from
[RFC v5 000/126] error: auto propagatedlocal_err
https://lists.gnu.org/archive/html/qemu-devel/2019-10/msg02771.html
https://src.openvz.org/scm/~vsementsov/qemu.git #tag up-auto-local-err-v5
, after some iterations, are finally merged, let's proceed with the rest. Sorry for a big delay on my part.As a first step, I decided to take subsystems, each of them covered by one patch, which get r-b/a-b marks by maintainer of the subsystem in v5.
v6 is available at
https://src.openvz.org/scm/~vsementsov/qemu.git #tag up-auto-local-err-partI-v6Changes
v5->v6:
01: use errp name for the parameter, add assertion
02: add a lot of text information, drop Eric's r-b.
no semantic changes.
03: add more comments
skip functions with pattern error_append_.*_hint in name make errp identifier, to match any name of Error ** paramter some other improvements
04: only commit message changed,
keep Philippe's r-b
05: new, manual update for hw/sd/ssi-sd
06: only commit message changed,
keep Philippe's r-b
07: only commit message changed,
keep Philippe's r-b
08:local_parse_opts()changed, so patch changed in this
function, drop a-b mark
also, indentation fixed, by improvement in coccinelle script
09: only commit message changed,
keep Stefan's r-b
10: commit message and a bit of context changed, still seems
valid to keep Eric's r-b
11: add new hunk:hw/pci-host/xen_igd_pt.c, so, drop r-b
also, indentation fixed, by improvement in coccinelle scriptIn these series, there is no commit-per-subsystem script, each generated commit is generated in separate.
Still, generating commands are very similar, and looks like
sed -n '/^<Subsystem name>$/,/^$/{s/^F: //p}' MAINTAINERS | \ xargs git ls-files | grep '\.[hc]$' | \ xargs spatch \ --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ --macro-file scripts/cocci-macro-file.h \ --in-place --no-show-diff --max-width 80Note, that in each generated commit, generation command is the only text, indented by 8 spaces in 'git log -1' output, so, to regenerate all commits (for example, after rebase, or change in coccinelle script), you may use the following command:
git rebase -x "sh -c \"git show --pretty= --name-only | xargs git checkout HEAD^ -- ; git reset; git log -1 | grep '^ ' | sh\"" HEAD~7
Which will start automated interactive rebase for generated patches, which will stop if generated patch changed
(you may do git commit --amend to apply updated generated changes).Note:
git show --pretty= --name-only - lists files, changed in HEAD
git log -1 | grep '^ ' | sh - rerun generation command of HEADCheck for compilation of changed .c files
git rebase -x "sh -c \"git show --pretty= --name-only | sed -n 's/\.c$/.o/p' | xargs make -j9\"" HEAD~7Vladimir Sementsov-Ogievskiy (11):
qapi/error: add (Error **errp) cleaning APIs
error: auto propagatedlocal_err
scripts: add coccinelle script to use auto propagated errp hw/sd/ssi-sd: fix error handling inssi_sd_realizeSD (Secure Card): introduceERRP_AUTO_PROPAGATE
pflash: introduceERRP_AUTO_PROPAGATE
fw_cfg: introduceERRP_AUTO_PROPAGATE
virtio-9p: introduceERRP_AUTO_PROPAGATE
TPM: introduceERRP_AUTO_PROPAGATE
nbd: introduceERRP_AUTO_PROPAGATE
xen: introduceERRP_AUTO_PROPAGATEinclude/block/nbd.h | 1 + include/qapi/error.h | 113 +++++++++++++- block/nbd.c | 49 +++--- hw/9pfs/9p-local.c | 12 +- hw/9pfs/9p.c | 1 + hw/block/dataplane/xen-block.c | 17 +-- hw/block/pflash_cfi01.c | 7 +- hw/block/pflash_cfi02.c | 7 +- hw/block/xen-block.c | 125 +++++++--------- hw/nvram/fw_cfg.c | 14 +- hw/pci-host/xen_igd_pt.c | 7 +- hw/sd/sdhci-pci.c | 7 +- hw/sd/sdhci.c | 21 ++- hw/sd/ssi-sd.c | 26 +++- hw/tpm/tpm_util.c | 7 +- hw/xen/xen-backend.c | 7 +- hw/xen/xen-bus.c | 100 ++++++------- hw/xen/xen-host-pci-device.c | 27 ++-- hw/xen/xen_pt.c | 25 ++-- hw/xen/xen_pt_config_init.c | 20 +-- nbd/client.c | 5 + nbd/server.c | 5 + tpm.c | 7 +- scripts/coccinelle/auto-propagated-errp.cocci | 139 ++++++++++++++++++ 24 files changed, 482 insertions(+), 267 deletions(-)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciCC Cornelia Huck <[email protected]>CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefan Hajnoczi <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC "Philippe Mathieu-Daudé" <[email protected]>CC Laszlo Ersek <[email protected]>CC Gerd Hoffmann <[email protected]>CC Stefan Berger <[email protected]>CC Markus Armbruster <[email protected]>CC Michael Roth <[email protected]>
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Quoted 1 line · Vladimir Sementsov-Ogievskiy
Markus, what about this? Should I respin?
I still haven't looked at this, must be frustrating for you, sorry! I've been under water ever since my Christmas vacation... If you rather want me to look at a v7 that addresses the review comments from others, then go ahead and respin.
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel