error: auto propagated local_err part I
Subsystems (2)
v7 cover error: auto propagated local_err part I
Hi all!
v7 is available at
https://src.openvz.org/scm/~vsementsov/qemu.git #tag up-auto-local-err-partI-v7
Changes v6->v7:
01: - improve commit message
- fix typo in comment [Eric]
- add Eric's and Greg's r-b
02: - grammar/wording [Eric]
- add Eric's and Greg's r-b
03: - improve commit message
- grammar [Eric]
- improve script to rename unusual (Error **) parameters to errp, and after it switch errp back to be "symbol" instead of "identifier"
04: - add Eric's r-b
08: - add Greg's a-b
11: - add Paul's a-b
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 | 112 ++++++++++++- 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 | 158 ++++++++++++++++++ 24 files changed, 500 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 v7 1/11 qapi/error: add (Error **errp) cleaning APIs
Add functions to clean Error **errp: call corresponding Error *err cleaning function an set pointer to NULL.
New functions:
error_free_errp
error_report_errp
warn_report_errp
---
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, then 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 v7 01/11] qapi/error: add (Error **errp) cleaning APIs
Quoted 60 lines · Vladimir Sementsov-Ogievskiy
Add functions to clean Error **errp: call corresponding Error *err cleaning function an set pointer to NULL.
New functions:
error_free_errp
error_report_errp
warn_report_errpSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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, then 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
These appear to be unused apart from the Coccinelle script in PATCH 03.
They are used in the full "[RFC v5 000/126] error: auto propagated local_err" series. Options:
1. Pick a few more patches into this part I series, so these guys come with users.
2. Punt this patch to the first part that has users, along with the part of the Coccinelle script that deals with them.
3. Do nothing: accept the functions without users.
I habitually dislike 3., but reviewing the rest of this series might make me override that dislike.
Re: [PATCH v7 01/11] qapi/error: add (Error **errp) cleaning APIs
Quoted 75 lines · Markus Armbruster
Quoted 60 lines · Vladimir Sementsov-Ogievskiy
Add functions to clean Error **errp: call corresponding Error *err cleaning function an set pointer to NULL.
New functions:
error_free_errp
error_report_errp
warn_report_errpSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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, then 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 These appear to be unused apart from the Coccinelle script in PATCH 03.
Quoted 5 lines
They are used in the full "[RFC v5 000/126] error: auto propagated
local_err" series. Options:1. Pick a few more patches into this part I series, so these guys come with users.
It needs some additional effort for this series.. But it's possible. Still, I think that we at least should not pull out patches which should be in future series (for example from ppc or block/)..
Grepping through v5:
for x in {warn_report_errp,error_report_errp,error_free_errp}; do echo == $x ==; git grep -l $x | grep -v coccinelle | grep -v 'error\.h'; echo; done
== warn_report_errp ==block/file-posix.chw/ppc/spapr.chw/ppc/spapr_caps.chw/ppc/spapr_irq.chw/vfio/pci.cnet/tap.cqom/object.c
== error_report_errp ==hw/block/vhost-user-blk.cutil/oslib-posix.c
== error_free_errp ==block.cblock/qapi.cblock/sheepdog.cblock/snapshot.cblockdev.cchardev/char-socket.chw/audio/intel-hda.chw/core/qdev-properties.chw/pci-bridge/pci_bridge_dev.chw/pci-bridge/pcie_pci_bridge.chw/scsi/megasas.chw/scsi/mptsas.chw/usb/hcd-xhci.cio/net-listener.cmigration/colo.cqga/commands-posix.cqga/commands-win32.cutil/qemu-sockets.c
What do you want to add?
Quoted 3 lines
2. Punt this patch to the first part that has users, along with the part of the Coccinelle script that deals with them.
But coccinelle script would be wrong, if we drop this part from it. I think, that after commit which adds coccinelle script, it should work with any file, not only subset of these series.
So, it's probably OK for now to drop these functions, forcing their addition if coccinelle script will be applied where these functions are needed. We can, for example comment these three functions.
Splitting coccinelle script into two parts, which will be in different series will not help any patch-porting processes.
Moreover, this will create dependencies between future series updating other files.
So, I don't like [2.]..
Quoted 2 lines
3. Do nothing: accept the functions without users.
OK for me)
Quoted 4 lines
I habitually dislike 3., but reviewing the rest of this series might make me override that dislike.
----------------
same grep with maintainers:
for x in {warn_report_errp,error_report_errp,error_free_errp}; do echo == $x ==; git grep -l $x | grep -v coccinelle | grep -v 'error\.h' | while read f; do echo $f; ./scripts/get_maintainer.pl -f --no-rolestats $f | grep -v 'qemu-block\|qemu-devel' | sed -e 's/^/ /'; done; echo; done
== warn_report_errp ==block/file-posix.c
Kevin Wolf <[email protected]>
Max Reitz <[email protected]>hw/ppc/spapr.c
David Gibson <[email protected]>
[email protected]hw/ppc/spapr_caps.c
David Gibson <[email protected]>
[email protected]hw/ppc/spapr_irq.c
David Gibson <[email protected]>
[email protected]hw/vfio/pci.c
Alex Williamson <[email protected]>net/tap.c
Jason Wang <[email protected]>qom/object.c
Paolo Bonzini <[email protected]>
"Daniel P. Berrangé" <[email protected]>
Eduardo Habkost <[email protected]>
== error_report_errp ==hw/block/vhost-user-blk.c
"Michael S. Tsirkin" <[email protected]>
Kevin Wolf <[email protected]>
Max Reitz <[email protected]>util/oslib-posix.c
Paolo Bonzini <[email protected]>
== error_free_errp ==block.c
Kevin Wolf <[email protected]>
Max Reitz <[email protected]>block/qapi.c
Markus Armbruster <[email protected]> Kevin Wolf <[email protected]>
Max Reitz <[email protected]>block/sheepdog.c
Liu Yuan <[email protected]>
Kevin Wolf <[email protected]>
Max Reitz <[email protected]> [email protected]block/snapshot.c
Kevin Wolf <[email protected]>
Max Reitz <[email protected]>blockdev.c
Markus Armbruster <[email protected]> Kevin Wolf <[email protected]>
Max Reitz <[email protected]>chardev/char-socket.c
"Marc-André Lureau" <[email protected]> Paolo Bonzini <[email protected]>hw/audio/intel-hda.c
Gerd Hoffmann <[email protected]>hw/core/qdev-properties.c
Paolo Bonzini <[email protected]> "Daniel P. Berrangé" <[email protected]> Eduardo Habkost <[email protected]>hw/pci-bridge/pci_bridge_dev.c
"Michael S. Tsirkin" <[email protected]> Marcel Apfelbaum <[email protected]>hw/pci-bridge/pcie_pci_bridge.c
"Michael S. Tsirkin" <[email protected]> Marcel Apfelbaum <[email protected]>hw/scsi/megasas.c
Hannes Reinecke <[email protected]>
Paolo Bonzini <[email protected]>
Fam Zheng <[email protected]>hw/scsi/mptsas.c
Paolo Bonzini <[email protected]>
Fam Zheng <[email protected]>hw/usb/hcd-xhci.c
Gerd Hoffmann <[email protected]>io/net-listener.c
"Daniel P. Berrangé" <[email protected]>migration/colo.c
Hailiang Zhang <[email protected]> Juan Quintela <[email protected]>
"Dr. David Alan Gilbert" <[email protected]>qga/commands-posix.c
Michael Roth <[email protected]>qga/commands-win32.c
Michael Roth <[email protected]>util/qemu-sockets.c
"Daniel P. Berrangé" <[email protected]> Gerd Hoffmann <[email protected]>
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 01/11] qapi/error: add (Error **errp) cleaning APIs
Quoted 78 lines · Vladimir Sementsov-Ogievskiy
Quoted 77 lines · Markus Armbruster
Quoted 59 lines · Vladimir Sementsov-Ogievskiy
Add functions to clean Error **errp: call corresponding Error *err cleaning function an set pointer to NULL.
New functions:
error_free_errp
error_report_errp
warn_report_errpSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 +18
-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, then 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 339
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 These appear to be unused apart from the Coccinelle script in PATCH 03.
They are used in the full "[RFC v5 000/126] error: auto propagated
local_err" series. Options:
Quoted 6 lines
Quoted 2 lines
1. Pick a few more patches into this part I series, so these guys come with users.
It needs some additional effort for this series.. But it's possible. Still, I think that we at least should not pull out patches which should be in future series (for example from ppc or
block/)..
Yes, we want to keep related stuff together.
Quoted 35 lines
Grepping through v5:
for x in {warn_report_errp,error_report_errp,error_free_errp}; do echo == $x ==; git grep -l $x | grep -v coccinelle | grep -v 'error\.h'; echo; done
==warn_report_errp==block/file-posix.chw/ppc/spapr.chw/ppc/spapr_caps.chw/ppc/spapr_irq.chw/vfio/pci.cnet/tap.cqom/object.c==
error_report_errp==hw/block/vhost-user-blk.cutil/oslib-posix.c==
error_free_errp==block.cblock/qapi.cblock/sheepdog.cblock/snapshot.cblockdev.cchardev/char-socket.chw/audio/intel-hda.chw/core/qdev-properties.chw/pci-bridge/pci_bridge_dev.chw/pci-bridge/pcie_pci_bridge.chw/scsi/megasas.chw/scsi/mptsas.chw/usb/hcd-xhci.cio/net-listener.cmigration/colo.cqga/commands-posix.cqga/commands-win32.cutil/qemu-sockets.c
Quoted 1 line
What do you want to add?
PATCH v5 032 uses both error_report_errp() and error_free_errp(). Adding warn_report_errp() without a user is okay with me. What do you think?
If there are patches you consider related to 032, feel free to throw them in.
Quoted 12 lines
Quoted 3 lines
2. Punt this patch to the first part that has users, along with the part of the Coccinelle script that deals with them.
But coccinelle script would be wrong, if we drop this part from it. I think, that after commit which adds coccinelle script, it should work with any file, not only subset of these series.
So, it's probably OK for now to drop these functions, forcing their addition if coccinelle script will be applied where these functions are needed. We can, for example comment these three functions.
Quoted 6 lines
Splitting coccinelle script into two parts, which will be in different series will not help any patch-porting processes.
Moreover, this will create dependencies between future series updating other files.
So, I don't like [2.]..
And it's likely more work than 1.
Quoted 7 lines
Quoted 1 line
3. Do nothing: accept the functions without users.
OK for me)
Quoted 3 lines
I habitually dislike 3., but reviewing the rest of this series might make me override that dislike.
[...]
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 01/11] qapi/error: add (Error **errp) cleaning APIs
Quoted 124 lines · Markus Armbruster
Quoted 78 lines · Vladimir Sementsov-Ogievskiy
Quoted 77 lines · Markus Armbruster
Quoted 59 lines · Vladimir Sementsov-Ogievskiy
Add functions to clean Error **errp: call corresponding Error *err cleaning function an set pointer to NULL.
New functions:
error_free_errp
error_report_errp
warn_report_errpSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 +18
-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, then 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 339
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 These appear to be unused apart from the Coccinelle script in PATCH 03.
They are used in the full "[RFC v5 000/126] error: auto propagated
local_err" series. Options:Quoted 6 lines
Quoted 2 lines
1. Pick a few more patches into this part I series, so these guys come with users.
It needs some additional effort for this series.. But it's possible. Still, I think that we at least should not pull out patches which should be in future series (for example from ppc or
block/)..Yes, we want to keep related stuff together.
Quoted 35 lines
Grepping through v5:
for x in {warn_report_errp,error_report_errp,error_free_errp}; do echo == $x ==; git grep -l $x | grep -v coccinelle | grep -v 'error\.h'; echo; done
==warn_report_errp==block/file-posix.chw/ppc/spapr.chw/ppc/spapr_caps.chw/ppc/spapr_irq.chw/vfio/pci.cnet/tap.cqom/object.c==
error_report_errp==hw/block/vhost-user-blk.cutil/oslib-posix.c==
error_free_errp==block.cblock/qapi.cblock/sheepdog.cblock/snapshot.cblockdev.cchardev/char-socket.chw/audio/intel-hda.chw/core/qdev-properties.chw/pci-bridge/pci_bridge_dev.chw/pci-bridge/pcie_pci_bridge.chw/scsi/megasas.chw/scsi/mptsas.chw/usb/hcd-xhci.cio/net-listener.cmigration/colo.cqga/commands-posix.cqga/commands-win32.cutil/qemu-sockets.c
Quoted 8 lines
Quoted 1 line
What do you want to add?
PATCH v5 032 uses both
error_report_errp()anderror_free_errp(). Addingwarn_report_errp()without a user is okay with me. What do you think?If there are patches you consider related to 032, feel free to throw them in.
032 is qga/commands-win32.c and util/oslib-posix.c
Seems that they are wrongly grouped into one patch.
qga/commands-win32.c matches qga/ (Michael Roth) and util/oslib-posix.c matches POSIX (Paolo Bonzini)
So, it should be two separate patches anyway.
For [1.] I only afraid that we'll have to wait for maintainers, who were not interested in previous iterations, to review these new patches..
Quoted 31 lines
Quoted 13 lines
Quoted 4 lines
2. Punt this patch to the first part that has users, along with the part of the Coccinelle script that deals with them.
But coccinelle script would be wrong, if we drop this part from it. I think, that after commit which adds coccinelle script, it should work with any file, not only subset of these series.
So, it's probably OK for now to drop these functions, forcing their addition if coccinelle script will be applied where these functions are needed. We can, for example comment these three functions.
Quoted 6 lines
Splitting coccinelle script into two parts, which will be in different series will not help any patch-porting processes.
Moreover, this will create dependencies between future series updating other files.
So, I don't like [2.]..
And it's likely more work than 1.
Quoted 7 lines
Quoted 1 line
3. Do nothing: accept the functions without users.
OK for me)
Quoted 3 lines
I habitually dislike 3., but reviewing the rest of this series might make me override that dislike.
[...]
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 01/11] qapi/error: add (Error **errp) cleaning APIs
Quoted 138 lines · Vladimir Sementsov-Ogievskiy
Quoted 124 lines · Markus Armbruster
Quoted 78 lines · Vladimir Sementsov-Ogievskiy
Quoted 77 lines · Markus Armbruster
Quoted 59 lines · Vladimir Sementsov-Ogievskiy
Add functions to clean Error **errp: call corresponding Error *err cleaning function an set pointer to NULL.
New functions:
error_free_errp
error_report_errp
warn_report_errpSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 +18
-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, then 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 339
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 These appear to be unused apart from the Coccinelle script in PATCH 03.
They are used in the full "[RFC v5 000/126] error: auto propagated
local_err" series. Options:Quoted 6 lines
Quoted 2 lines
1. Pick a few more patches into this part I series, so these guys come with users.
It needs some additional effort for this series.. But it's possible. Still, I think that we at least should not pull out patches which should be in future series (for example from ppc or
block/)..Yes, we want to keep related stuff together.
Quoted 35 lines
Grepping through v5:
for x in {warn_report_errp,error_report_errp,error_free_errp}; do echo == $x ==; git grep -l $x | grep -v coccinelle | grep -v 'error\.h'; echo; done
==warn_report_errp==block/file-posix.chw/ppc/spapr.chw/ppc/spapr_caps.chw/ppc/spapr_irq.chw/vfio/pci.cnet/tap.cqom/object.c==
error_report_errp==hw/block/vhost-user-blk.cutil/oslib-posix.c==
error_free_errp==block.cblock/qapi.cblock/sheepdog.cblock/snapshot.cblockdev.cchardev/char-socket.chw/audio/intel-hda.chw/core/qdev-properties.chw/pci-bridge/pci_bridge_dev.chw/pci-bridge/pcie_pci_bridge.chw/scsi/megasas.chw/scsi/mptsas.chw/usb/hcd-xhci.cio/net-listener.cmigration/colo.cqga/commands-posix.cqga/commands-win32.cutil/qemu-sockets.cQuoted 8 lines
Quoted 1 line
What do you want to add?
PATCH v5 032 uses both
error_report_errp()anderror_free_errp(). Addingwarn_report_errp()without a user is okay with me. What do you think?If there are patches you consider related to 032, feel free to throw them in.
032 is
qga/commands-win32.candutil/oslib-posix.cSeems that they are wrongly grouped into one patch.
Quoted 7 lines
qga/commands-win32.cmatches qga/ (Michael Roth) andutil/oslib-posix.cmatches POSIX (Paolo Bonzini)So, it should be two separate patches anyway.
For [1.] I only afraid that we'll have to wait for maintainers, who were not interested in previous iterations, to review these new patches..
We won't.
We should and we will give every maintainer a chance to review these patches, even though the changes are mechanical. Maintainers are free to decline or ignore this offer. I will feel free to interpret that as "go ahead and merge this through your tree".
In fact, I fully expect the bulk of the changes to go through my tree. Chasing umpteen maintainers for each one to merge a trivial part of this massive tree-wide change would take ages and accomplish nothing.
[...]
Re: [PATCH v7 01/11] qapi/error: add (Error **errp) cleaning APIs
Quoted 155 lines · Markus Armbruster
Quoted 138 lines · Vladimir Sementsov-Ogievskiy
Quoted 124 lines · Markus Armbruster
Quoted 78 lines · Vladimir Sementsov-Ogievskiy
Quoted 77 lines · Markus Armbruster
Quoted 59 lines · Vladimir Sementsov-Ogievskiy
Add functions to clean Error **errp: call corresponding Error *err cleaning function an set pointer to NULL.
New functions:
error_free_errp
error_report_errp
warn_report_errpSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 +18
-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, then 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 339
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 These appear to be unused apart from the Coccinelle script in PATCH 03.
They are used in the full "[RFC v5 000/126] error: auto propagated
local_err" series. Options:Quoted 6 lines
Quoted 2 lines
1. Pick a few more patches into this part I series, so these guys come with users.
It needs some additional effort for this series.. But it's possible. Still, I think that we at least should not pull out patches which should be in future series (for example from ppc or
block/)..Yes, we want to keep related stuff together.
Quoted 35 lines
Grepping through v5:
for x in {warn_report_errp,error_report_errp,error_free_errp}; do echo == $x ==; git grep -l $x | grep -v coccinelle | grep -v 'error\.h'; echo; done==
warn_report_errp==block/file-posix.chw/ppc/spapr.chw/ppc/spapr_caps.chw/ppc/spapr_irq.chw/vfio/pci.cnet/tap.cqom/object.c==
error_report_errp==hw/block/vhost-user-blk.cutil/oslib-posix.c==
error_free_errp==block.cblock/qapi.cblock/sheepdog.cblock/snapshot.cblockdev.cchardev/char-socket.chw/audio/intel-hda.chw/core/qdev-properties.chw/pci-bridge/pci_bridge_dev.chw/pci-bridge/pcie_pci_bridge.chw/scsi/megasas.chw/scsi/mptsas.chw/usb/hcd-xhci.cio/net-listener.cmigration/colo.cqga/commands-posix.cqga/commands-win32.cutil/qemu-sockets.cQuoted 8 lines
Quoted 1 line
What do you want to add?
PATCH v5 032 uses both
error_report_errp()anderror_free_errp(). Addingwarn_report_errp()without a user is okay with me. What do you think?If there are patches you consider related to 032, feel free to throw them in.
032 is
qga/commands-win32.candutil/oslib-posix.cSeems that they are wrongly grouped into one patch.
Quoted 7 lines
qga/commands-win32.cmatches qga/ (Michael Roth) andutil/oslib-posix.cmatches POSIX (Paolo Bonzini)So, it should be two separate patches anyway.
For [1.] I only afraid that we'll have to wait for maintainers, who were not interested in previous iterations, to review these new patches..
We won't.
We should and we will give every maintainer a chance to review these patches, even though the changes are mechanical. Maintainers are free to decline or ignore this offer. I will feel free to interpret that as "go ahead and merge this through your tree".
Quoted 6 lines
In fact, I fully expect the bulk of the changes to go through my tree. Chasing umpteen maintainers for each one to merge a trivial part of this massive tree-wide change would take ages and accomplish nothing.
[...]
Hmm, then OK. I'll add these two patches.. Still, you pointed missed in cocci script cases about error_reportf_err() and warn_reportf_err()... I'm afraid we just don't have corresponding files, and therefore don't want to add unused errp wrappers for them..
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 01/11] qapi/error: add (Error **errp) cleaning APIs
In reply to Vladimir Sementsov-OgievskiyQuoted 32 lines · Vladimir Sementsov-Ogievskiy
Quoted 14 lines
Quoted 11 lines
include/qapi/error.h +8
-0+static inline void warn_report_errp (Error **errp) +{ + assert(errp && *errp); + warn_report_err(*errp); + *errp = NULL; +} + +/*
* Just likeerror_setg(), except you get to specify the error class.
* Note: use of error classes other thanERROR_CLASS_GENERIC_ERRORisThese appear to be unused apart from the Coccinelle script in PATCH 03.
Quoted 5 lines
They are used in the full "[RFC v5 000/126] error: auto propagated
local_err" series. Options:1. Pick a few more patches into this part I series, so these guys come with users.
It needs some additional effort for this series.. But it's possible. Still, I think that we at least should not pull out patches which should be in future series (for example from ppc or
block/)..Quoted 2 lines
2. Punt this patch to the first part that has users, along with the part of the Coccinelle script that deals with them.
But coccinelle script would be wrong, if we drop this part from it. I think, that after commit which adds coccinelle script, it should work with any file, not only subset of these series.
Quoted 6 lines
So, it's probably OK for now to drop these functions, forcing their addition if coccinelle script will be applied where these functions are needed. We can, for example comment these three functions.
Splitting coccinelle script into two parts, which will be in different series will not help any patch-porting processes.
Splitting the coccinelle script across multiple patches is actually quite reviewable, and still easy to backport. Consider this series by Philippe:
https://lists.gnu.org/archive/html/qemu-devel/2020-02/msg05554.html
which makes multiple additions to scripts/coccinelle/exec_rw_const.cocci over the course of the series.
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 v7 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 an errp OUT parameter.
It has three goals:
1. Fix issue with error_fatal and 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 and error_propagate: when we wrap error_abort by local_err+error_propagate, the 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 us to [3.] drop the 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, 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).
---
include/qapi/error.h | 83 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 82 insertions(+), 1 deletion(-)
include/qapi/error.h +82 -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, the use ERRP_AUTO_PROPAGATE macro +* instead (defined below). +* It's deprecated because of two things: +* +* 1. Issue with error_abort and error_propagate: when we wrap error_abort by +* local_err+error_propagate, the 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,43 @@ 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 v7 02/11] error: auto propagated local_err
Quoted 106 lines · Vladimir Sementsov-Ogievskiy
Here is introduced
ERRP_AUTO_PROPAGATEmacro, to be used at start of functions with an errp OUT parameter.It has three goals:
1. Fix issue with
error_fataland 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_abortanderror_propagate: when we wraperror_abortby local_err+error_propagate, the resulting coredump will refer toerror_propagateand not to the place where error happened. (the macro itself doesn't fix the issue, but it allows us to [3.] drop the 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, 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).
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 83 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 82 insertions(+), 1 deletion(-)include/qapi/error.h +38
-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, the use ERRP_AUTO_PROPAGATE macro +* instead (defined below). +* It's deprecated because of two things: +* +* 1. Issue with error_abort and error_propagate: when we wrap error_abort by +* local_err+error_propagate, the 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) {
include/qapi/error.h line 147
Quoted 10 lines
include/qapi/error.h +7
-0+* handle the error... +* return; +* } +* ... +* } +* +* * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; * foo(arg, &err);
Let's explain what should be done *first*, and only then talk about the deprecated pattern and how to convert it to current usage.
Quoted 25 lines
include/qapi/error.h +21
-0@@ -348,6 +392,43 @@ 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
include/qapi/error.h void error_set_internal(Error **errp, · line 425
Quoted 10 lines
include/qapi/error.h +10
-0+* 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.
Tradeoff: we gain more useful backtraces, we lose message improvements from error_prepend(), error_append_hint() and such, if any. Makes sense.
include/qapi/error.h void error_set_internal(Error **errp, · line 426
Quoted 1 line
include/qapi/error.h +1
-0+*/
The comment's contents looks okay to me. I'll want to tweak formatting to better blend in with the rest of this file, but let's not worry about that now.
include/qapi/error.h void error_set_internal(Error **errp, · line 434
Quoted 8 lines
include/qapi/error.h +5
-0+#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.
*errp == error_fatal tests *errp == NULL, which is not what you want. You need to test errp == &error_fatal, just like error_handle_fatal().
Superfluous parenthesis around the first operand of ?:.
Wouldn't
#define ERRP_AUTO_PROPAGATE() \
g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \
if (!errp || errp == &error_fatal) { \
errp = &_auto_errp_prop.local_err; \
}be clearer?
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 02/11] error: auto propagated local_err
Quoted 168 lines · Markus Armbruster
Quoted 106 lines · Vladimir Sementsov-Ogievskiy
Here is introduced
ERRP_AUTO_PROPAGATEmacro, to be used at start of functions with an errp OUT parameter.It has three goals:
1. Fix issue with
error_fataland 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_abortanderror_propagate: when we wraperror_abortby local_err+error_propagate, the resulting coredump will refer toerror_propagateand not to the place where error happened. (the macro itself doesn't fix the issue, but it allows us to [3.] drop the 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, 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).
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 83 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 82 insertions(+), 1 deletion(-)include/qapi/error.h +38
-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, the use ERRP_AUTO_PROPAGATE macro +* instead (defined below). +* It's deprecated because of two things: +* +* 1. Issue with error_abort and error_propagate: when we wrap error_abort by +* local_err+error_propagate, the 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) { include/qapi/error.h line 147
Quoted 10 lines
include/qapi/error.h +7
-0+* handle the error... +* return; +* } +* ... +* } +* +* * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; * foo(arg, &err); Let's explain what should be done *first*, and only then talk about the deprecated pattern and how to convert it to current usage.
Quoted 25 lines
include/qapi/error.h +21
-0@@ -348,6 +392,43 @@ 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 include/qapi/error.h void error_set_internal(Error **errp, · line 425
Quoted 10 lines
include/qapi/error.h +10
-0+* 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. Tradeoff: we gain more useful backtraces, we lose message improvements from
error_prepend(),error_append_hint()and such, if any. Makes sense.include/qapi/error.h void error_set_internal(Error **errp, · line 426
Quoted 1 line
include/qapi/error.h +1
-0+*/ The comment's contents looks okay to me. I'll want to tweak formatting to better blend in with the rest of this file, but let's not worry about that now.
Quoted 11 lines
include/qapi/error.h void error_set_internal(Error **errp, · line 434
Quoted 8 lines
include/qapi/error.h +5
-0+#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. *errp ==
error_fataltests *errp == NULL, which is not what you want. You need to test errp ==&error_fatal, just likeerror_handle_fatal().
Oops, great bug) And nobody noticed before) Of course, you are right.
Quoted 5 lines
Superfluous parenthesis around the first operand of ?:.
Wouldn't
Quoted 8 lines
#define ERRP_AUTO_PROPAGATE() \ g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ if (!errp || errp == &error_fatal) { \ errp = &_auto_errp_prop.local_err; \ }be clearer?
Hmm, notation with "if" will allow omitting ';' after macro invocation, which seems not good.. And if I'm not wrong we've already discussed it somewhere in previous versions.
Still, no objections for s/errp == NULL/!errp/ and we need s/*errp == error_fatal/errp == &error_fatal/ for sure.
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 02/11] error: auto propagated local_err
Quoted 180 lines · Vladimir Sementsov-Ogievskiy
Quoted 167 lines · Markus Armbruster
Quoted 106 lines · Vladimir Sementsov-Ogievskiy
Here is introduced
ERRP_AUTO_PROPAGATEmacro, to be used at start of functions with an errp OUT parameter.It has three goals:
1. Fix issue with
error_fataland 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_abortanderror_propagate: when we wraperror_abortby local_err+error_propagate, the resulting coredump will refer toerror_propagateand not to the place where error happened. (the macro itself doesn't fix the issue, but it allows us to [3.] drop the 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, 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).
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Greg Kurz <[email protected]>Reviewed-by Eric Blake <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 83 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 82 insertions(+), 1 deletion(-)include/qapi/error.h +38
-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, the use ERRP_AUTO_PROPAGATE macro +* instead (defined below). +* It's deprecated because of two things: +* +* 1. Issue with error_abort and error_propagate: when we wrap error_abort by +* local_err+error_propagate, the 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) { include/qapi/error.h line 147
Quoted 10 lines
include/qapi/error.h +7
-0+* handle the error... +* return; +* } +* ... +* } +* +* * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; * foo(arg, &err); Let's explain what should be done *first*, and only then talk about the deprecated pattern and how to convert it to current usage.
Quoted 24 lines
include/qapi/error.h +20
-0@@ -348,6 +392,43 @@ 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 include/qapi/error.h void error_set_internal(Error **errp, · line 424
Quoted 10 lines
include/qapi/error.h +10
-0+* 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. Tradeoff: we gain more useful backtraces, we lose message improvements from
error_prepend(),error_append_hint()and such, if any. Makes sense.include/qapi/error.h void error_set_internal(Error **errp, · line 426
Quoted 1 line
include/qapi/error.h +1
-0+*/ The comment's contents looks okay to me. I'll want to tweak formatting to better blend in with the rest of this file, but let's not worry about that now.
Quoted 11 lines
include/qapi/error.h void error_set_internal(Error **errp, · line 434
Quoted 8 lines
include/qapi/error.h +5
-0+#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. *errp ==
error_fataltests *errp == NULL, which is not what you want. You need to test errp ==&error_fatal, just likeerror_handle_fatal().
Quoted 1 line
Oops, great bug) And nobody noticed before) Of course, you are right.
That's why we review patches :)
Quoted 10 lines
Quoted 10 lines
Superfluous parenthesis around the first operand of ?:.
Wouldn't
#define ERRP_AUTO_PROPAGATE() \ g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ if (!errp || errp == &error_fatal) { \ errp = &_auto_errp_prop.local_err; \ }
Quoted 5 lines
Quoted 2 lines
be clearer?
Hmm, notation with "if" will allow omitting ';' after macro invocation, which seems not good.. And if I'm not wrong we've already discussed it somewhere in previous versions.
Nevermind. We'd have to add do ... while semicolon armor, and then it's hardly clearer anymore.
Quoted 1 line
Still, no objections for s/errp == NULL/!errp/ and we need s/*errp == error_fatal/errp == &error_fatal/ for sure.
Okay!
Re: [PATCH v7 02/11] error: auto propagated local_err
In reply to Vladimir Sementsov-OgievskiyQuoted 12 lines · Vladimir Sementsov-Ogievskiy
Quoted 11 lines
Quoted 8 lines
include/qapi/error.h +5
-0+#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.
* Seeerror_setg()anderror_propagate()for details.*errp ==
error_fataltests *errp == NULL, which is not what you want. You need to test errp ==&error_fatal, just likeerror_handle_fatal().
Quoted 1 line
Oops, great bug) And nobody noticed before) Of course, you are right.
Sorry I missed it in my earlier looks.
Quoted 12 lines
Quoted 12 lines
Superfluous parenthesis around the first operand of ?:.
Wouldn't
#define ERRP_AUTO_PROPAGATE() \
g_auto(ErrorPropagator)_auto_errp_prop= {.errp = errp}; \
if (!errp || errp ==&error_fatal) { \
errp = &_auto_errp_prop.local_err; \
}
Quoted 4 lines
Quoted 2 lines
be clearer?
Hmm, notation with "if" will allow omitting ';' after macro invocation, which seems not good..
Then wrap it:
g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \
do { \
if (!errp || errp == &error_fata) {
errp = &_auto_errp_prop.local_err; \ } \
while (0)
Quoted 1 line
And if I'm not wrong we've already discussed it somewhere in previous versions.
The original use of ?: stems from my suggestion on an earlier revision when we were still trying to pack everything into two consecutive declaration lines, rather than a declaration and a statement (as ?: is necessary for conditionals in declarations). But since then, we decided to go with a statement (we require a C99 compiler, so declaration after statement is supported by our compiler, even if our coding style currently avoids it where possible), so as long as we support statements, we might as well go with a legible statement instead of insisting on the compact ?: form.
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 v7 3/11 scripts: add coccinelle script to use auto propagated errp
In reply to Vladimir Sementsov-OgievskiyScript adds ERRP_AUTO_PROPAGATE macro invocation where appropriate and does corresponding changes in code (look for details in include/qapi/error.h)
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]
---
include/qapi/error.h | 3 + scripts/coccinelle/auto-propagated-errp.cocci | 158 ++++++++++++++++++ 2 files changed, 161 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 +158 -0
158 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 v7 03/11] scripts: add coccinelle script to use auto propagated errp
Quoted 39 lines · Vladimir Sementsov-Ogievskiy
Script adds
ERRP_AUTO_PROPAGATEmacro invocation where appropriate and does corresponding changes in code (look for details ininclude/qapi/error.h)Usage example:
spatch --sp-filescripts/coccinelle/auto-propagated-errp.cocci\
--macro-filescripts/cocci-macro-file.h--in-place --no-show-diff \
blockdev-nbd.cqemu-nbd.c{block/nbd*,nbd/*,include/block/nbd*}.[hc]Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 158 ++++++++++++++++++ 2 files changed, 161 insertions(+) create mode 100644 scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +0
-0
include/qapi/error.h line 149
Quoted 9 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;
Extra blank line.
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +20
-0@@ -0,0 +1,158 @@ +// 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 \
scripts/coccinelle/auto-propagated-errp.cocci line 30
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@rule0@ +// 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 did not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation.
Not skipping a function we should skip fails to compile.
What about skipping a function we should not skip?
scripts/coccinelle/auto-propagated-errp.cocci line 32
Quoted 2 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +2
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err, ERRP;
A few of our coccinelle scripts use ALL_CAPS for meta-variables. Most don't. Either is fine with me. Mixing the two styles feels a bit confusing, though.
Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+@@ + + fn(..., Error **ERRP, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+...
scripts/coccinelle/auto-propagated-errp.cocci line 48
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ when != ERRP_AUTO_PROPAGATE(); +( + error_append_hint(ERRP, ...); +| + error_prepend(ERRP, ...); +| + Error *local_err = NULL; +) + ...+> + }
Misses error_vprepend(). Currently harmless, but as long as we commit the script, we better make it as robust as we reasonably can.
The previous patch explains this Coccinelle script's intent:
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).
This rule matches "use error_prepend/error_append_hint" directly. It appears to use presence of a local Error * variable as proxy for "use local_err+error_propagate to check errors". Hmm.
We obviously have such a variable when we use "local_err+error_propagate to check errors". But we could also have such variables without use of error_propagate(). In fact, error.h documents such use:
* Call a function and receive an error from it:
* Error *err = NULL;
* foo(arg, &err);
* if (err) { * handle the error...
* }
where "handle the error" frees it.
I figure such uses typically occur in functions without an Error **errp parameter. This rule doesn't apply then. But they could occur even in functions with such a parameter. Consider:
void foo(Error **errp)
{
Error *err = NULL;
bar(&err);
if (err) {
error_free(err);
error_setg(errp, "completely different error");
}
}Reasonable enough when bar() gives us an error that's misleading in this context, isn't it?
The script transforms it like this:
void foo(Error **errp)
{
- Error *err = NULL;
+ ERRP_AUTO_PROPAGATE();
- bar(&err);
- if (err) {
- error_free(err);
+ bar(errp);
+ if (*errp) {
+ error_free_errp(errp);
error_setg(errp, "completely different error");
}
}Unwanted.
Now, if this script applied in just a few dozen places, we could rely on eyeballing its output to catch unwanted transformations. Since it applies in so many more, I don't feel comfortable relying on reviewer eyeballs.
Can we make rule0 directly match error_propagate(errp, local_err) somehow?
Another observation: the rule does not match error_reportf_err() and warn_reportf_err(). These combine error_prepend(), error_report()/warn_report() and error_free(), for convenience. Don't their users need ERRP_AUTO_PROPAGATE() just like error_prepend()'s users?
scripts/coccinelle/auto-propagated-errp.cocci line 52
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+ +@@ +// Switch unusual (Error **) parameter names to errp +// (this is necessary to use ERRP_AUTO_PROPAGATE).
Please put your rule comments right before the rule, i.e. before the @-line introducing metavariable declarations, not after. Same elsewhere.
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+identifier rule0.fn; +identifier rule0.ERRP != errp; +@@ +
scripts/coccinelle/auto-propagated-errp.cocci line 66
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ fn(..., +- Error **ERRP ++ Error **errp + ,...) + { + <... +- ERRP ++ errp + ...> + }
This normalizes errp parameter naming. It matches exactly when rule0 matches (and inserts ERRP_AUTO_PROPAGATE()) and the Error ** parameter is unusual. Good.
scripts/coccinelle/auto-propagated-errp.cocci line 71
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+ +@rule1@ +// We want to patch error propagation in functions regardless of +// whether the function already uses ERRP_AUTO_PROPAGATE prior to +// applying rule0, hence this one does not inherit from it.
I'm not sure I get this comment. Let's see what the rule does.
scripts/coccinelle/auto-propagated-errp.cocci line 82
Quoted 11 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +11
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err; +symbol errp; +@@ + + fn(..., Error **errp, ...) + { + <... +- Error *local_err = NULL; + ...> + }
rule1 matches like rule0, except the Error ** parameter match is tightened from any C identifier to the C identifier errp, and the function body match tightened from "either use error_prepend/error_append_hint or which use local_err+error_propagate to check errors" to just the latter.
I figure tightening the Error ** parameter match has no effect, because we already normalized the parameter name.
So rule1 deletes variable local_err where rule0 applied. Correct?
Quoted 7 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +7
-0+ +@@ +// Handle pattern with goto, otherwise we'll finish up +// with labels at function end which will not compile. +identifier rule1.fn, rule1.local_err; +identifier OUT; +@@
scripts/coccinelle/auto-propagated-errp.cocci line 99
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ + fn(...) + { + <... +- goto OUT; ++ return; + ...> +- OUT: +- error_propagate(errp, local_err); + }
This is one special case of error_propagate() deletion. It additionally gets rid of a goto we no longer want. For the general case, see below.
The rule applies only where rule1 just deleted the variable. Thus, the two rules work in tandem. Makes sense.
scripts/coccinelle/auto-propagated-errp.cocci line 87
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+ +@@ +identifier rule1.fn, rule1.local_err;
This rule also works in tandem with rule1.
scripts/coccinelle/auto-propagated-errp.cocci line 103
Quoted 1 line
scripts/coccinelle/auto-propagated-errp.cocci new file +1
-0+expression list args; // to reindent error_propagate_prepend
What is the comment trying to tell me?
scripts/coccinelle/auto-propagated-errp.cocci line 112
Quoted 9 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +9
-0+@@ + + fn(...) + { + <... +( +- error_free(local_err); +- local_err = NULL; ++ error_free_errp(errp);
Reminder:
static inline void error_free_errp(Error **errp)
{
assert(errp && *errp);
error_free(*errp);
*errp = NULL;
}Now let's examine the actual change.
The assertion's first half trivially holds, ERRP_AUTO_PROPAGATE() ensures it.
The second half is new. We now crash when we haven't set an error. Why is this safe? Note that error_free(local_err) does nothing when !local_err.
The zapping of the variable pointing to the Error just freed is unchanged.
scripts/coccinelle/auto-propagated-errp.cocci line 115
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_free(local_err); ++ error_free_errp(errp);
Here, the zapping is new. Zapping dangling pointers is obviously safe. Needed, or else the automatic error_propagate() due to ERRP_AUTO_PROPAGATE() would propagate the dangling pointer.
scripts/coccinelle/auto-propagated-errp.cocci line 118
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_report_err(local_err); ++ error_report_errp(errp);
The only difference to the previous case is that we also report the error.
The previous case has a buddy that additionally matches *errp = NULL. Why not this one?
scripts/coccinelle/auto-propagated-errp.cocci line 121
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- warn_report_err(local_err); ++ warn_report_errp(errp);
Likewise.
What about error_reportf_err(), warn_reportf_err()?
Up to here, this rule transforms the various forms of error_free().
Next: error_propagate().
scripts/coccinelle/auto-propagated-errp.cocci line 126
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+| +- error_propagate_prepend(errp, local_err, args); ++ error_prepend(errp, args); +| +- error_propagate(errp, local_err);
rule0's adding of ERRP_AUTO_PROPAGATE() made error_propagate() redundant.
This is the general case of error_propagate() deletion.
I'd put the plain error_propagate() first, variations second, like you do with error_free().
If neither of these two patterns match on a path from ERRP_AUTO_PROPAGATE() to return, we effectively insert error_propagate() where it wasn't before. Does nothing when the local error is null there. Bug fix when it isn't: it's at least a memory leak, and quite possibly worse.
Identifying these bug fixes would be nice, but I don't have practical ideas on how to do that.
Can we explain this in the commit message?
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+) + ...> + } + +@@ +identifier rule1.fn, rule1.local_err; +@@ + + fn(...) + {
scripts/coccinelle/auto-propagated-errp.cocci line 146
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ <... +( +- &local_err ++ errp +| +- local_err ++ *errp +) + ...> + }
Also in tandem with rule1, fixes up uses of local_err. Good.
scripts/coccinelle/auto-propagated-errp.cocci line 158
Quoted 12 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +12
-0+ +@@ +identifier rule1.fn; +@@ + + fn(...) + { + <... +- *errp != NULL ++ *errp + ...> + }
Still in tandem with rule1, normalizes style. Good.
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp
Quoted 92 lines · Markus Armbruster
Quoted 39 lines · Vladimir Sementsov-Ogievskiy
Script adds
ERRP_AUTO_PROPAGATEmacro invocation where appropriate and does corresponding changes in code (look for details ininclude/qapi/error.h)Usage example:
spatch --sp-filescripts/coccinelle/auto-propagated-errp.cocci\
--macro-filescripts/cocci-macro-file.h--in-place --no-show-diff \
blockdev-nbd.cqemu-nbd.c{block/nbd*,nbd/*,include/block/nbd*}.[hc]Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 158 ++++++++++++++++++ 2 files changed, 161 insertions(+)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +0
-0include/qapi/error.h line 149
Quoted 9 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; Extra blank line.
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +20
-0@@ -0,0 +1,158 @@ +// 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 \scripts/coccinelle/auto-propagated-errp.cocci line 30
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@rule0@ +// 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 did not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation.Not skipping a function we should skip fails to compile.
Quoted 1 line
What about skipping a function we should not skip?
Then it will not be updated.. Not good but I don't have better solution. Still, I hope, function called *error_append_*_hint will not return error through errp pointer.
Quoted 88 lines
scripts/coccinelle/auto-propagated-errp.cocci line 32
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +2
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err, ERRP;A few of our coccinelle scripts use
ALL_CAPSfor meta-variables. Most don't. Either is fine with me. Mixing the two styles feels a bit confusing, though.Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+@@ + + fn(..., Error **ERRP, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+...scripts/coccinelle/auto-propagated-errp.cocci line 48
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ when != ERRP_AUTO_PROPAGATE(); +( + error_append_hint(ERRP, ...); +| + error_prepend(ERRP, ...); +| + Error *local_err = NULL; +) + ...+> + }Misses
error_vprepend(). Currently harmless, but as long as we commit the script, we better make it as robust as we reasonably can.The previous patch explains this Coccinelle script's intent:
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).
This rule matches "use error_prepend/error_append_hint" directly. It appears to use presence of a local Error * variable as proxy for "use local_err+error_propagate to check errors". Hmm.
We obviously have such a variable when we use "local_err+error_propagate to check errors". But we could also have such variables without use of
error_propagate(). In fact,error.hdocuments such use:* Call a function and receive an error from it:
* Error *err = NULL; * foo(arg, &err); * if (err) {* handle the error...
* }where "handle the error" frees it.
I figure such uses typically occur in functions without an Error **errp parameter. This rule doesn't apply then. But they could occur even in functions with such a parameter. Consider:
void foo(Error **errp) { Error *err = NULL; bar(&err); if (err) { error_free(err); error_setg(errp, "completely different error"); } }Reasonable enough when
bar()gives us an error that's misleading in this context, isn't it?The script transforms it like this:
void
foo(Error **errp)
{
- Error *err = NULL;
+ERRP_AUTO_PROPAGATE();-
bar(&err);
- if (err) {
-error_free(err);
+ bar(errp);
+ if (*errp) {
+error_free_errp(errp);
error_setg(errp, "completely different error");
}
}
Quoted 1 line
Unwanted.
What is the problem with it? Updated code just use "new usual notation" for handling error of sub-calls in function which reports errors through errp pointer.
Quoted 8 lines
Now, if this script applied in just a few dozen places, we could rely on eyeballing its output to catch unwanted transformations. Since it applies in so many more, I don't feel comfortable relying on reviewer eyeballs.
Can we make rule0 directly match
error_propagate(errp, local_err)somehow?
I think it is possible, still I'm not sure we need it.
Quoted 6 lines
Another observation: the rule does not match
error_reportf_err()andwarn_reportf_err(). These combineerror_prepend(), error_report()/warn_report() anderror_free(), for convenience. Don't their users needERRP_AUTO_PROPAGATE()just like error_prepend()'s users?
Right. These functions want to add information, which will not work for error_fatal without wrapping.
Quoted 55 lines
scripts/coccinelle/auto-propagated-errp.cocci line 52
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+ +@@ +// Switch unusual (Error **) parameter names to errp +// (this is necessary to use ERRP_AUTO_PROPAGATE).Please put your rule comments right before the rule, i.e. before the @-line introducing metavariable declarations, not after. Same elsewhere.
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+identifier rule0.fn; +identifier rule0.ERRP != errp; +@@ +scripts/coccinelle/auto-propagated-errp.cocci line 66
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ fn(..., +- Error **ERRP ++ Error **errp + ,...) + { + <... +- ERRP ++ errp + ...> + }This normalizes errp parameter naming. It matches exactly when rule0 matches (and inserts
ERRP_AUTO_PROPAGATE()) and the Error ** parameter is unusual. Good.scripts/coccinelle/auto-propagated-errp.cocci line 71
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+ +@rule1@ +// We want to patch error propagation in functions regardless of +// whether the function already uses ERRP_AUTO_PROPAGATE prior to +// applying rule0, hence this one does not inherit from it.I'm not sure I get this comment. Let's see what the rule does.
scripts/coccinelle/auto-propagated-errp.cocci line 82
Quoted 11 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +11
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err; +symbol errp; +@@ + + fn(..., Error **errp, ...) + { + <... +- Error *local_err = NULL; + ...> + }rule1 matches like rule0, except the Error ** parameter match is tightened from any C identifier to the C identifier errp, and the function body match tightened from "either use error_prepend/error_append_hint or which use local_err+error_propagate to check errors" to just the latter.
Quoted 4 lines
I figure tightening the Error ** parameter match has no effect, because we already normalized the parameter name.
So rule1 deletes variable
local_errwhere rule0 applied. Correct?
The difference with rule0 is that rule0 contains
"when != ERRP_AUTO_PROPAGATE()", so rule0 is not applied where
we already have macro invocation.
This is why we can't inherit from rule0.
No we believe that we have ERRP_AUTO_PROPAGATE invocation in all corresponding places (added by rule0 or before script run) and want to update all usage of local_err objects.
Quoted 31 lines
Quoted 8 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +7
-0+ +@@ +// Handle pattern with goto, otherwise we'll finish up +// with labels at function end which will not compile. +identifier rule1.fn, rule1.local_err; +identifier OUT; +@@scripts/coccinelle/auto-propagated-errp.cocci line 99
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ + fn(...) + { + <... +- goto OUT; ++ return; + ...> +- OUT: +- error_propagate(errp, local_err); + }This is one special case of
error_propagate()deletion. It additionally gets rid of a goto we no longer want. For the general case, see below.The rule applies only where rule1 just deleted the variable. Thus, the two rules work in tandem. Makes sense.
scripts/coccinelle/auto-propagated-errp.cocci line 87
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+ +@@ +identifier rule1.fn, rule1.local_err;This rule also works in tandem with rule1.
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci line 103
Quoted 1 line
scripts/coccinelle/auto-propagated-errp.cocci new file +1
-0+expression list args; // to reindent error_propagate_prependWhat is the comment trying to tell me?
Hmm, we can safely drop it. It's about the following:
instead of
- error_propagate_prepend(errp, local_err, args);
+ error_prepend(errp, args);
we can use "...", like
- error_propagate_prepend(errp, local_err
+ error_prepend(errp
, ...);
but with metavar in use, coccinelle will correctly reindent the whole call, which looks a lot better.
Quoted 20 lines
scripts/coccinelle/auto-propagated-errp.cocci line 112
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +9
-0+@@ + + fn(...) + { + <... +( +- error_free(local_err); +- local_err = NULL; ++ error_free_errp(errp);Reminder:
static inline void error_free_errp(Error **errp) { assert(errp && *errp); error_free(*errp); *errp = NULL; }
Quoted 8 lines
Now let's examine the actual change.
The assertion's first half trivially holds,
ERRP_AUTO_PROPAGATE()ensures it.The second half is new. We now crash when we haven't set an error. Why is this safe? Note that
error_free(local_err)does nothing when !local_err.
Hmm. Looks like we should tighten this restriction, and follow error_free interface, which allows freeing unset errp.
Quoted 16 lines
The zapping of the variable pointing to the Error just freed is unchanged.
scripts/coccinelle/auto-propagated-errp.cocci line 115
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_free(local_err); ++ error_free_errp(errp);Here, the zapping is new. Zapping dangling pointers is obviously safe. Needed, or else the automatic
error_propagate()due toERRP_AUTO_PROPAGATE()would propagate the dangling pointer.scripts/coccinelle/auto-propagated-errp.cocci line 118
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_report_err(local_err); ++ error_report_errp(errp);
Quoted 5 lines
The only difference to the previous case is that we also report the error.
The previous case has a buddy that additionally matches *errp = NULL. Why not this one?
Probably because no matches in code. But should be added here for better case coverage.
Quoted 23 lines
scripts/coccinelle/auto-propagated-errp.cocci line 121
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- warn_report_err(local_err); ++ warn_report_errp(errp);Likewise.
What about
error_reportf_err(),warn_reportf_err()?Up to here, this rule transforms the various forms of
error_free().
Next:error_propagate().scripts/coccinelle/auto-propagated-errp.cocci line 126
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+| +- error_propagate_prepend(errp, local_err, args); ++ error_prepend(errp, args); +| +- error_propagate(errp, local_err);rule0's adding of
ERRP_AUTO_PROPAGATE()madeerror_propagate()redundant.This is the general case of
error_propagate()deletion.
Quoted 8 lines
I'd put the plain
error_propagate()first, variations second, like you do witherror_free().If neither of these two patterns match on a path from
ERRP_AUTO_PROPAGATE()to return, we effectively inserterror_propagate()where it wasn't before. Does nothing when the local error is null there. Bug fix when it isn't: it's at least a memory leak, and quite possibly worse.
Hmm. How can it be memory leak after any of error_free variants?
Quoted 44 lines
Identifying these bug fixes would be nice, but I don't have practical ideas on how to do that.
Can we explain this in the commit message?
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+) + ...> + } + +@@ +identifier rule1.fn, rule1.local_err; +@@ + + fn(...) + {scripts/coccinelle/auto-propagated-errp.cocci line 146
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ <... +( +- &local_err ++ errp +| +- local_err ++ *errp +) + ...> + }Also in tandem with rule1, fixes up uses of
local_err. Good.scripts/coccinelle/auto-propagated-errp.cocci line 158
Quoted 12 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +12
-0+ +@@ +identifier rule1.fn; +@@ + + fn(...) + { + <... +- *errp != NULL ++ *errp + ...> + }Still in tandem with rule1, normalizes style. Good.
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp
Quoted 93 lines · Vladimir Sementsov-Ogievskiy
Quoted 92 lines · Markus Armbruster
Quoted 39 lines · Vladimir Sementsov-Ogievskiy
Script adds
ERRP_AUTO_PROPAGATEmacro invocation where appropriate and does corresponding changes in code (look for details ininclude/qapi/error.h)Usage example:
spatch --sp-filescripts/coccinelle/auto-propagated-errp.cocci\
--macro-filescripts/cocci-macro-file.h--in-place --no-show-diff \
blockdev-nbd.cqemu-nbd.c{block/nbd*,nbd/*,include/block/nbd*}.[hc]Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 158 ++++++++++++++++++ 2 files changed, 161 insertions(+)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +0
-0include/qapi/error.h line 149
Quoted 9 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; Extra blank line.
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +20
-0@@ -0,0 +1,158 @@ +// 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 \scripts/coccinelle/auto-propagated-errp.cocci line 30
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@rule0@ +// 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 did not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation.Not skipping a function we should skip fails to compile.
Quoted 5 lines
Quoted 1 line
What about skipping a function we should not skip?
Then it will not be updated.. Not good but I don't have better solution. Still, I hope, function called *error_append_*_hint will not return error through errp pointer.
Seems likely. I just dislike inferring behavior from name patterns.
Ideally, we recognize the true exceptional pattern instead, i.e. the presence of const. But figuring out how to make Coccinelle do that for us may be more trouble than it's worth.
Hmm... Coccinelle matches the parameter even with const due to what it calls "isomorphism". Can I disable it? *Tinker* *tinker*
scripts/coccinelle/auto-propagated-errp.cocci +4 -8
@@ -20,15 +20,11 @@ // --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] -@rule0@ +@rule0 disable optional_qualifier@ // 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 did 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"; +// Disable optional_qualifier to skip functions with "Error *const *errp" +// parameter, +identifier fn; identifier local_err, ERRP; @@
Could you verify this results in the same tree-wide change as your version?
Quoted 87 lines
Quoted 87 lines
scripts/coccinelle/auto-propagated-errp.cocci line 32
Quoted 2 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +2
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err, ERRP;A few of our coccinelle scripts use
ALL_CAPSfor meta-variables. Most don't. Either is fine with me. Mixing the two styles feels a bit confusing, though.Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+@@ + + fn(..., Error **ERRP, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+...scripts/coccinelle/auto-propagated-errp.cocci line 48
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ when != ERRP_AUTO_PROPAGATE(); +( + error_append_hint(ERRP, ...); +| + error_prepend(ERRP, ...); +| + Error *local_err = NULL; +) + ...+> + }Misses
error_vprepend(). Currently harmless, but as long as we commit the script, we better make it as robust as we reasonably can.The previous patch explains this Coccinelle script's intent:
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).
This rule matches "use error_prepend/error_append_hint" directly. It appears to use presence of a local Error * variable as proxy for "use local_err+error_propagate to check errors". Hmm.
We obviously have such a variable when we use "local_err+error_propagate to check errors". But we could also have such variables without use of
error_propagate(). In fact,error.hdocuments such use:* Call a function and receive an error from it:
* Error *err = NULL; * foo(arg, &err); * if (err) {* handle the error...
* }where "handle the error" frees it.
I figure such uses typically occur in functions without an Error **errp parameter. This rule doesn't apply then. But they could occur even in functions with such a parameter. Consider:
void foo(Error **errp) { Error *err = NULL; bar(&err); if (err) { error_free(err); error_setg(errp, "completely different error"); } }Reasonable enough when
bar()gives us an error that's misleading in this context, isn't it?The script transforms it like this:
void
foo(Error **errp)
{
- Error *err = NULL;
+ERRP_AUTO_PROPAGATE();-
bar(&err);
- if (err) {
-error_free(err);
+ bar(errp);
+ if (*errp) {
+error_free_errp(errp);
error_setg(errp, "completely different error");
}
}
Quoted 5 lines
Quoted 1 line
Unwanted.
What is the problem with it? Updated code just use "new usual notation" for handling error of sub-calls in function which reports errors through errp pointer.
error.h's big comment asks for use of ERRP_AUTO_PROPAGATE() to "Receive an error and pass it on to the caller". We're not doing that here. We "Call a function and receive an error from it", then "Handle an error without reporting it".
The updated code works anyway, but it's needlessly complicated.
Quoted 9 lines
Quoted 7 lines
Now, if this script applied in just a few dozen places, we could rely on eyeballing its output to catch unwanted transformations. Since it applies in so many more, I don't feel comfortable relying on reviewer eyeballs.
Can we make rule0 directly match
error_propagate(errp, local_err)somehow?I think it is possible, still I'm not sure we need it.
We don't need it in the sense of "must have to avoid a buggy transformation". It's more like "I'd like to have it to stay close to the documented usage of ERRP_AUTO_PROPAGATE(), and to avoid complicating cases like the one above".
Quoted 8 lines
Quoted 5 lines
Another observation: the rule does not match
error_reportf_err()andwarn_reportf_err(). These combineerror_prepend(), error_report()/warn_report() anderror_free(), for convenience. Don't their users needERRP_AUTO_PROPAGATE()just like error_prepend()'s users?Right. These functions want to add information, which will not work for
error_fatalwithout wrapping.
A simple improvement, I hope.
Quoted 54 lines
Quoted 54 lines
scripts/coccinelle/auto-propagated-errp.cocci line 52
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+ +@@ +// Switch unusual (Error **) parameter names to errp +// (this is necessary to use ERRP_AUTO_PROPAGATE).Please put your rule comments right before the rule, i.e. before the @-line introducing metavariable declarations, not after. Same elsewhere.
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+identifier rule0.fn; +identifier rule0.ERRP != errp; +@@ +scripts/coccinelle/auto-propagated-errp.cocci line 66
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ fn(..., +- Error **ERRP ++ Error **errp + ,...) + { + <... +- ERRP ++ errp + ...> + }This normalizes errp parameter naming. It matches exactly when rule0 matches (and inserts
ERRP_AUTO_PROPAGATE()) and the Error ** parameter is unusual. Good.scripts/coccinelle/auto-propagated-errp.cocci line 71
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+ +@rule1@ +// We want to patch error propagation in functions regardless of +// whether the function already uses ERRP_AUTO_PROPAGATE prior to +// applying rule0, hence this one does not inherit from it.I'm not sure I get this comment. Let's see what the rule does.
scripts/coccinelle/auto-propagated-errp.cocci line 82
Quoted 11 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +11
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err; +symbol errp; +@@ + + fn(..., Error **errp, ...) + { + <... +- Error *local_err = NULL; + ...> + }rule1 matches like rule0, except the Error ** parameter match is tightened from any C identifier to the C identifier errp, and the function body match tightened from "either use error_prepend/error_append_hint or which use local_err+error_propagate to check errors" to just the latter.
Quoted 8 lines
Quoted 4 lines
I figure tightening the Error ** parameter match has no effect, because we already normalized the parameter name.
So rule1 deletes variable
local_errwhere rule0 applied. Correct?The difference with rule0 is that rule0 contains
"when !=ERRP_AUTO_PROPAGATE()", so rule0 is not applied where
we already have macro invocation.
Ah, I missed the when clause.
Quoted 5 lines
This is why we can't inherit from rule0.
No we believe that we have
ERRP_AUTO_PROPAGATEinvocation in all corresponding places (added by rule0 or before script run) and want to update all usage oflocal_errobjects.
Let's see whether I got it:
* The first rule (rule0) adds ERRP_AUTO_PROPAGATE() to all functions that take an Error ** parameter, and either pass it error_prepend() or error_append_hint(), or use local_err, and don't have ERRP_AUTO_PROPAGATE() already, except it skips the ones named error_append_FOO_hint(). Uff.
The "use local_err" part is an approximation of "use local_err + error_propagate()".
The "except for the ones named error_append_FOO_hint()" part is an approximation of "except for the ones taking an Error *const * parameter".
ERRP_AUTO_PROPAGATE() requires the Error ** parameter to be named @errp, which need not be the case. The next rule fixes it up:
* The second rule ensures the parameter is named @errp wherever the first rule applied, renaming if necessary.
Correct?
Incorrect transformation followed by fixup is not ideal, because it can trip up reviewers. But ideal is too expensive; this is good enough.
* The third rule (rule1) ensures functions that take an Error **errp parameter don't declare local_err, except it skips the ones named error_append_FOO_hint().
In isolation, this rule makes no sense. To make sense of it, we need context:
* Subsequent rules remove all uses of @errp from any function where rule1 matches.
* Preceding rules ensure any function where rule1 matches has ERRP_AUTO_PROPAGATE().
Correct?
The need for this much context is hard on reviewers. Good enough for transforming the tree now, but I'd hate having to make sense of this again in six months.
Quoted 41 lines
Quoted 30 lines
Quoted 7 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +7
-0+ +@@ +// Handle pattern with goto, otherwise we'll finish up +// with labels at function end which will not compile. +identifier rule1.fn, rule1.local_err; +identifier OUT; +@@scripts/coccinelle/auto-propagated-errp.cocci line 99
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ + fn(...) + { + <... +- goto OUT; ++ return; + ...> +- OUT: +- error_propagate(errp, local_err); + }This is one special case of
error_propagate()deletion. It additionally gets rid of a goto we no longer want. For the general case, see below.The rule applies only where rule1 just deleted the variable. Thus, the two rules work in tandem. Makes sense.
scripts/coccinelle/auto-propagated-errp.cocci line 102
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+ +@@ +identifier rule1.fn, rule1.local_err;This rule also works in tandem with rule1.
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci line 103
Quoted 1 line
scripts/coccinelle/auto-propagated-errp.cocci new file +1
-0+expression list args; // to reindent error_propagate_prependWhat is the comment trying to tell me?
Hmm, we can safely drop it. It's about the following:
instead of
-
error_propagate_prepend(errp, local_err, args);
+error_prepend(errp, args);
Quoted 8 lines
we can use "...", like
- error_propagate_prepend(errp,
local_err
+ error_prepend(errp
, ...);but with metavar in use, coccinelle will correctly reindent the whole call, which looks a lot better.
Let's drop the comment.
Quoted 47 lines
Quoted 19 lines
scripts/coccinelle/auto-propagated-errp.cocci line 112
Quoted 9 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +9
-0+@@ + + fn(...) + { + <... +( +- error_free(local_err); +- local_err = NULL; ++ error_free_errp(errp);Reminder:
static inline void error_free_errp(Error **errp) { assert(errp && *errp); error_free(*errp); *errp = NULL; }Quoted 8 lines
Now let's examine the actual change.
The assertion's first half trivially holds,
ERRP_AUTO_PROPAGATE()ensures it.The second half is new. We now crash when we haven't set an error. Why is this safe? Note that
error_free(local_err)does nothing when !local_err.Hmm. Looks like we should tighten this restriction, and follow
error_freeinterface, which allows freeing unset errp.Quoted 16 lines
The zapping of the variable pointing to the Error just freed is unchanged.
scripts/coccinelle/auto-propagated-errp.cocci line 115
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_free(local_err); ++ error_free_errp(errp);Here, the zapping is new. Zapping dangling pointers is obviously safe. Needed, or else the automatic
error_propagate()due toERRP_AUTO_PROPAGATE()would propagate the dangling pointer.Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_report_err(local_err); ++ error_report_errp(errp);
Quoted 8 lines
Quoted 5 lines
The only difference to the previous case is that we also report the error.
The previous case has a buddy that additionally matches *errp = NULL. Why not this one?
Probably because no matches in code. But should be added here for better case coverage.
Either that or a comment pointing out what's missing, and why, namely because the pattern doesn't exist in the tree.
Quoted 26 lines
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci line 121
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- warn_report_err(local_err); ++ warn_report_errp(errp);Likewise.
What about
error_reportf_err(),warn_reportf_err()?Up to here, this rule transforms the various forms of
error_free().
Next:error_propagate().scripts/coccinelle/auto-propagated-errp.cocci line 126
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+| +- error_propagate_prepend(errp, local_err, args); ++ error_prepend(errp, args); +| +- error_propagate(errp, local_err);rule0's adding of
ERRP_AUTO_PROPAGATE()madeerror_propagate()redundant.This is the general case of
error_propagate()deletion.I'd put the plain
error_propagate()first, variations second, like you do witherror_free().
Quoted 7 lines
Quoted 5 lines
If neither of these two patterns match on a path from
ERRP_AUTO_PROPAGATE()to return, we effectively inserterror_propagate()where it wasn't before. Does nothing when the local error is null there. Bug fix when it isn't: it's at least a memory leak, and quite possibly worse.Hmm. How can it be memory leak after any of
error_freevariants?
Consider nfs_options_qdict_to_qapi() right before commit 54b7af4369a fixed it:
static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
Error **errp)
{
BlockdevOptionsNfs *opts = NULL;
QObject *crumpled = NULL;
Visitor *v;
Error *local_err = NULL;
crumpled = qdict_crumple(options, errp);
if (crumpled == NULL) {
return NULL;
}
v = qobject_input_visitor_new_keyval(crumpled);
visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err);
visit_free(v);
qobject_unref(crumpled);
if (local_err) {
return NULL;
}
return opts;
}When visit_type_BlockdevOptionsNfs() fails, we return null without setting an error. We also leak the error we got from visit_type_BlockdevOptionsNfs().
Commit 54b7af4369a fixed this:
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -570,6 +570,7 @@ static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *
options,
qobject_unref(crumpled);
if (local_err) {
+ error_propagate(errp, local_err);
return NULL;
}If it was still broken, then your transformation would *also* fix it, wouldn't it?
My point is: your transformation might fix actual bugs!
Quoted 28 lines
Quoted 28 lines
Identifying these bug fixes would be nice, but I don't have practical ideas on how to do that.
Can we explain this in the commit message?
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+) + ...> + } + +@@ +identifier rule1.fn, rule1.local_err; +@@ + + fn(...) + {scripts/coccinelle/auto-propagated-errp.cocci line 146
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ <... +( +- &local_err ++ errp +| +- local_err ++ *errp +) + ...> + }Also in tandem with rule1, fixes up uses of
local_err. Good.
Quoted 15 lines
Quoted 6 lines
Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+ +@@ +identifier rule1.fn; +@@ + + fn(...)Quoted 9 lines
scripts/coccinelle/auto-propagated-errp.cocci line 158
Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+ { + <... +- *errp != NULL ++ *errp + ...> + }Still in tandem with rule1, normalizes style. Good.
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp
Quoted 134 lines · Markus Armbruster
Quoted 93 lines · Vladimir Sementsov-Ogievskiy
Quoted 92 lines · Markus Armbruster
Quoted 39 lines · Vladimir Sementsov-Ogievskiy
Script adds
ERRP_AUTO_PROPAGATEmacro invocation where appropriate and does corresponding changes in code (look for details ininclude/qapi/error.h)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]Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 158 ++++++++++++++++++ 2 files changed, 161 insertions(+)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +0
-0include/qapi/error.h line 149
Quoted 9 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; Extra blank line.
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +20
-0@@ -0,0 +1,158 @@ +// 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 \scripts/coccinelle/auto-propagated-errp.cocci line 30
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@rule0@ +// 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 did not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation.Not skipping a function we should skip fails to compile.
Quoted 5 lines
Quoted 1 line
What about skipping a function we should not skip?
Then it will not be updated.. Not good but I don't have better solution. Still, I hope, function called *error_append_*_hint will not return error through errp pointer.
Seems likely. I just dislike inferring behavior from name patterns.
Ideally, we recognize the true exceptional pattern instead, i.e. the presence of const. But figuring out how to make Coccinelle do that for us may be more trouble than it's worth.
Hmm... Coccinelle matches the parameter even with const due to what it calls "isomorphism". Can I disable it? *Tinker* *tinker*
scripts/coccinelle/auto-propagated-errp.cocci +4
-8@@ -20,15 +20,11 @@ // --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] -@rule0@ +@rule0 disable optional_qualifier@ // 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 did 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"; +// Disable optional_qualifier to skip functions with "Error *const *errp" +// parameter, +identifier fn; identifier local_err, ERRP; @@
Quoted 2 lines
Could you verify this results in the same tree-wide change as your version?
Yes, no difference. Thanks!
Quoted 94 lines
Quoted 88 lines
Quoted 88 lines
scripts/coccinelle/auto-propagated-errp.cocci line 32
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +2
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err, ERRP;A few of our coccinelle scripts use
ALL_CAPSfor meta-variables. Most don't. Either is fine with me. Mixing the two styles feels a bit confusing, though.Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+@@ + + fn(..., Error **ERRP, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+...scripts/coccinelle/auto-propagated-errp.cocci line 48
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ when != ERRP_AUTO_PROPAGATE(); +( + error_append_hint(ERRP, ...); +| + error_prepend(ERRP, ...); +| + Error *local_err = NULL; +) + ...+> + }Misses
error_vprepend(). Currently harmless, but as long as we commit the script, we better make it as robust as we reasonably can.The previous patch explains this Coccinelle script's intent:
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).
This rule matches "use error_prepend/error_append_hint" directly. It appears to use presence of a local Error * variable as proxy for "use local_err+error_propagate to check errors". Hmm.
We obviously have such a variable when we use "local_err+error_propagate to check errors". But we could also have such variables without use of
error_propagate(). In fact,error.hdocuments such use:* Call a function and receive an error from it:
* Error *err = NULL; * foo(arg, &err); * if (err) {* handle the error...
* }where "handle the error" frees it.
I figure such uses typically occur in functions without an Error **errp parameter. This rule doesn't apply then. But they could occur even in functions with such a parameter. Consider:
void foo(Error **errp) { Error *err = NULL; bar(&err); if (err) { error_free(err); error_setg(errp, "completely different error"); } }Reasonable enough when
bar()gives us an error that's misleading in this context, isn't it?The script transforms it like this:
void
foo(Error **errp)
{
- Error *err = NULL;
+ERRP_AUTO_PROPAGATE();-
bar(&err);
- if (err) {
-error_free(err);
+ bar(errp);
+ if (*errp) {
+error_free_errp(errp);
error_setg(errp, "completely different error");
}
}Quoted 5 lines
Quoted 1 line
Unwanted.
What is the problem with it? Updated code just use "new usual notation" for handling error of sub-calls in function which reports errors through errp pointer.
Quoted 6 lines
error.h's big comment asks for use of
ERRP_AUTO_PROPAGATE()to "Receive an error and pass it on to the caller". We're not doing that here. We "Call a function and receive an error from it", then "Handle an error without reporting it".The updated code works anyway, but it's needlessly complicated.
OK, will try.
Quoted 125 lines
Quoted 10 lines
Quoted 8 lines
Now, if this script applied in just a few dozen places, we could rely on eyeballing its output to catch unwanted transformations. Since it applies in so many more, I don't feel comfortable relying on reviewer eyeballs.
Can we make rule0 directly match
error_propagate(errp, local_err)somehow?I think it is possible, still I'm not sure we need it.
We don't need it in the sense of "must have to avoid a buggy transformation". It's more like "I'd like to have it to stay close to the documented usage of
ERRP_AUTO_PROPAGATE(), and to avoid complicating cases like the one above".Quoted 8 lines
Quoted 5 lines
Another observation: the rule does not match
error_reportf_err()andwarn_reportf_err(). These combineerror_prepend(), error_report()/warn_report() anderror_free(), for convenience. Don't their users needERRP_AUTO_PROPAGATE()just like error_prepend()'s users?Right. These functions want to add information, which will not work for
error_fatalwithout wrapping.A simple improvement, I hope.
Quoted 54 lines
Quoted 54 lines
scripts/coccinelle/auto-propagated-errp.cocci line 52
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+ +@@ +// Switch unusual (Error **) parameter names to errp +// (this is necessary to use ERRP_AUTO_PROPAGATE).Please put your rule comments right before the rule, i.e. before the @-line introducing metavariable declarations, not after. Same elsewhere.
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+identifier rule0.fn; +identifier rule0.ERRP != errp; +@@ +scripts/coccinelle/auto-propagated-errp.cocci line 66
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ fn(..., +- Error **ERRP ++ Error **errp + ,...) + { + <... +- ERRP ++ errp + ...> + }This normalizes errp parameter naming. It matches exactly when rule0 matches (and inserts
ERRP_AUTO_PROPAGATE()) and the Error ** parameter is unusual. Good.scripts/coccinelle/auto-propagated-errp.cocci line 71
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+ +@rule1@ +// We want to patch error propagation in functions regardless of +// whether the function already uses ERRP_AUTO_PROPAGATE prior to +// applying rule0, hence this one does not inherit from it.I'm not sure I get this comment. Let's see what the rule does.
scripts/coccinelle/auto-propagated-errp.cocci line 82
Quoted 11 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +11
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err; +symbol errp; +@@ + + fn(..., Error **errp, ...) + { + <... +- Error *local_err = NULL; + ...> + }rule1 matches like rule0, except the Error ** parameter match is tightened from any C identifier to the C identifier errp, and the function body match tightened from "either use error_prepend/error_append_hint or which use local_err+error_propagate to check errors" to just the latter.
Quoted 8 lines
Quoted 4 lines
I figure tightening the Error ** parameter match has no effect, because we already normalized the parameter name.
So rule1 deletes variable
local_errwhere rule0 applied. Correct?The difference with rule0 is that rule0 contains
"when !=ERRP_AUTO_PROPAGATE()", so rule0 is not applied where
we already have macro invocation.Ah, I missed the when clause.
Quoted 5 lines
This is why we can't inherit from rule0.
No we believe that we have
ERRP_AUTO_PROPAGATEinvocation in all corresponding places (added by rule0 or before script run) and want to update all usage oflocal_errobjects.Let's see whether I got it:
* The first rule (rule0) adds
ERRP_AUTO_PROPAGATE()to all functions that take an Error ** parameter, and either pass iterror_prepend()orerror_append_hint(), or uselocal_err, and don't haveERRP_AUTO_PROPAGATE()already, except it skips the ones namederror_append_FOO_hint(). Uff.The "use
local_err" part is an approximation of "uselocal_err+error_propagate()".The "except for the ones named
error_append_FOO_hint()" part is an approximation of "except for the ones taking an Error *const * parameter".
ERRP_AUTO_PROPAGATE()requires the Error ** parameter to be named @errp, which need not be the case. The next rule fixes it up:* The second rule ensures the parameter is named @errp wherever the first rule applied, renaming if necessary.
Correct?
Incorrect transformation followed by fixup is not ideal, because it can trip up reviewers. But ideal is too expensive; this is good enough.
Quoted 8 lines
* The third rule (rule1) ensures functions that take an Error **errp parameter don't declare
local_err, except it skips the ones namederror_append_FOO_hint().In isolation, this rule makes no sense. To make sense of it, we need context:
* Subsequent rules remove all uses of @errp from any function where
of local_err
Quoted 6 lines
rule1 matches.
* Preceding rules ensure any function where rule1 matches has
ERRP_AUTO_PROPAGATE().Correct?
Oh, yes, everything is correct.
Quoted 4 lines
The need for this much context is hard on reviewers. Good enough for transforming the tree now, but I'd hate having to make sense of this again in six months.
Ohh, yes. Far from good design. I can try to reorder chunks a bit.
Quoted 191 lines
Quoted 42 lines
Quoted 31 lines
Quoted 8 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +7
-0+ +@@ +// Handle pattern with goto, otherwise we'll finish up +// with labels at function end which will not compile. +identifier rule1.fn, rule1.local_err; +identifier OUT; +@@scripts/coccinelle/auto-propagated-errp.cocci line 99
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ + fn(...) + { + <... +- goto OUT; ++ return; + ...> +- OUT: +- error_propagate(errp, local_err); + }This is one special case of
error_propagate()deletion. It additionally gets rid of a goto we no longer want. For the general case, see below.The rule applies only where rule1 just deleted the variable. Thus, the two rules work in tandem. Makes sense.
scripts/coccinelle/auto-propagated-errp.cocci line 102
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+ +@@ +identifier rule1.fn, rule1.local_err;This rule also works in tandem with rule1.
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci line 103
Quoted 1 line
scripts/coccinelle/auto-propagated-errp.cocci new file +1
-0+expression list args; // to reindent error_propagate_prependWhat is the comment trying to tell me?
Hmm, we can safely drop it. It's about the following:
instead of
-
error_propagate_prepend(errp, local_err, args);
+error_prepend(errp, args);Quoted 8 lines
we can use "...", like
- error_propagate_prepend(errp,
local_err
+ error_prepend(errp, ...);but with metavar in use, coccinelle will correctly reindent the whole call, which looks a lot better.
Let's drop the comment.
Quoted 47 lines
Quoted 19 lines
scripts/coccinelle/auto-propagated-errp.cocci line 112
Quoted 9 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +9
-0+@@ + + fn(...) + { + <... +( +- error_free(local_err); +- local_err = NULL; ++ error_free_errp(errp);Reminder:
static inline void error_free_errp(Error **errp) { assert(errp && *errp); error_free(*errp); *errp = NULL; }Quoted 8 lines
Now let's examine the actual change.
The assertion's first half trivially holds,
ERRP_AUTO_PROPAGATE()ensures it.The second half is new. We now crash when we haven't set an error. Why is this safe? Note that
error_free(local_err)does nothing when !local_err.Hmm. Looks like we should tighten this restriction, and follow
error_freeinterface, which allows freeing unset errp.Quoted 16 lines
The zapping of the variable pointing to the Error just freed is unchanged.
scripts/coccinelle/auto-propagated-errp.cocci line 115
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_free(local_err); ++ error_free_errp(errp);Here, the zapping is new. Zapping dangling pointers is obviously safe. Needed, or else the automatic
error_propagate()due toERRP_AUTO_PROPAGATE()would propagate the dangling pointer.Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_report_err(local_err); ++ error_report_errp(errp);Quoted 8 lines
Quoted 5 lines
The only difference to the previous case is that we also report the error.
The previous case has a buddy that additionally matches *errp = NULL. Why not this one?
Probably because no matches in code. But should be added here for better case coverage.
Either that or a comment pointing out what's missing, and why, namely because the pattern doesn't exist in the tree.
Quoted 26 lines
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci line 121
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- warn_report_err(local_err); ++ warn_report_errp(errp);Likewise.
What about
error_reportf_err(),warn_reportf_err()?Up to here, this rule transforms the various forms of
error_free().
Next:error_propagate().scripts/coccinelle/auto-propagated-errp.cocci line 126
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+| +- error_propagate_prepend(errp, local_err, args); ++ error_prepend(errp, args); +| +- error_propagate(errp, local_err);rule0's adding of
ERRP_AUTO_PROPAGATE()madeerror_propagate()redundant.This is the general case of
error_propagate()deletion.I'd put the plain
error_propagate()first, variations second, like you do witherror_free().Quoted 7 lines
Quoted 5 lines
If neither of these two patterns match on a path from
ERRP_AUTO_PROPAGATE()to return, we effectively inserterror_propagate()where it wasn't before. Does nothing when the local error is null there. Bug fix when it isn't: it's at least a memory leak, and quite possibly worse.Hmm. How can it be memory leak after any of
error_freevariants?Consider
nfs_options_qdict_to_qapi()right before commit54b7af4369afixed it:static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options, Error **errp) { BlockdevOptionsNfs *opts = NULL; QObject *crumpled = NULL; Visitor *v; Error *local_err = NULL; crumpled = qdict_crumple(options, errp); if (crumpled == NULL) { return NULL; } v = qobject_input_visitor_new_keyval(crumpled); visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err); visit_free(v); qobject_unref(crumpled); if (local_err) { return NULL; } return opts; }When
visit_type_BlockdevOptionsNfs()fails, we return null without setting an error. We also leak the error we got fromvisit_type_BlockdevOptionsNfs().Commit
54b7af4369afixed this:--- a/block/nfs.c +++ b/block/nfs.c @@ -570,6 +570,7 @@ static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict * options, qobject_unref(crumpled); if (local_err) { + error_propagate(errp, local_err); return NULL; }
Quoted 2 lines
If it was still broken, then your transformation would *also* fix it, wouldn't it?
Ah, yes. You mean addition of the macro invocation, I thought about transforming error_free variants to error_free_errp variants.
Quoted 47 lines
My point is: your transformation might fix actual bugs!
Quoted 43 lines
Quoted 43 lines
Identifying these bug fixes would be nice, but I don't have practical ideas on how to do that.
Can we explain this in the commit message?
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+) + ...> + } + +@@ +identifier rule1.fn, rule1.local_err; +@@ + + fn(...) + {scripts/coccinelle/auto-propagated-errp.cocci line 146
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ <... +( +- &local_err ++ errp +| +- local_err ++ *errp +) + ...> + }Also in tandem with rule1, fixes up uses of
local_err. Good.scripts/coccinelle/auto-propagated-errp.cocci line 158
Quoted 12 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +12
-0+ +@@ +identifier rule1.fn; +@@ + + fn(...) + { + <... +- *errp != NULL ++ *errp + ...> + }Still in tandem with rule1, normalizes style. Good.
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp
Quoted 134 lines · Vladimir Sementsov-Ogievskiy
Quoted 133 lines · Markus Armbruster
Quoted 93 lines · Vladimir Sementsov-Ogievskiy
Quoted 92 lines · Markus Armbruster
Quoted 39 lines · Vladimir Sementsov-Ogievskiy
Script adds
ERRP_AUTO_PROPAGATEmacro invocation where appropriate and does corresponding changes in code (look for details ininclude/qapi/error.h)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]Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 158 ++++++++++++++++++ 2 files changed, 161 insertions(+)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +0
-0include/qapi/error.h line 149
Quoted 9 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; Extra blank line.
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +20
-0@@ -0,0 +1,158 @@ +// 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 \scripts/coccinelle/auto-propagated-errp.cocci line 30
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@rule0@ +// 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 did not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation.Not skipping a function we should skip fails to compile.
Quoted 5 lines
Quoted 1 line
What about skipping a function we should not skip?
Then it will not be updated.. Not good but I don't have better solution. Still, I hope, function called *error_append_*_hint will not return error through errp pointer.
Seems likely. I just dislike inferring behavior from name patterns.
Ideally, we recognize the true exceptional pattern instead, i.e. the presence of const. But figuring out how to make Coccinelle do that for us may be more trouble than it's worth.
Hmm... Coccinelle matches the parameter even with const due to what it calls "isomorphism". Can I disable it? *Tinker* *tinker*
scripts/coccinelle/auto-propagated-errp.cocci +4
-7@@ -20,15 +20,11 @@ // --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] -@rule0@ +@rule0 disable optional_qualifier@ // 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 did 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"; +// Disable optional_qualifier to skip functions with "Error *const *errp" +// parameter, +identifier fn; identifier local_err, ERRP; @@
Quoted 4 lines
Quoted 2 lines
Could you verify this results in the same tree-wide change as your version?
Yes, no difference. Thanks!
Excellent!
[...]
Quoted 38 lines
Quoted 27 lines
Let's see whether I got it:
* The first rule (rule0) adds
ERRP_AUTO_PROPAGATE()to all functions that take an Error ** parameter, and either pass iterror_prepend()orerror_append_hint(), or uselocal_err, and don't haveERRP_AUTO_PROPAGATE()already, except it skips the ones namederror_append_FOO_hint(). Uff.The "use
local_err" part is an approximation of "uselocal_err+error_propagate()".The "except for the ones named
error_append_FOO_hint()" part is an approximation of "except for the ones taking an Error *const * parameter".
ERRP_AUTO_PROPAGATE()requires the Error ** parameter to be named @errp, which need not be the case. The next rule fixes it up:* The second rule ensures the parameter is named @errp wherever the first rule applied, renaming if necessary.
Correct?
Incorrect transformation followed by fixup is not ideal, because it can trip up reviewers. But ideal is too expensive; this is good enough.
Quoted 8 lines
* The third rule (rule1) ensures functions that take an Error **errp parameter don't declare
local_err, except it skips the ones namederror_append_FOO_hint().In isolation, this rule makes no sense. To make sense of it, we need context:
* Subsequent rules remove all uses of @errp from any function where
of
local_err
Quoted 8 lines
Quoted 6 lines
rule1 matches.
* Preceding rules ensure any function where rule1 matches has
ERRP_AUTO_PROPAGATE().Correct?
Oh, yes, everything is correct.
Thank you!
Quoted 6 lines
Quoted 4 lines
The need for this much context is hard on reviewers. Good enough for transforming the tree now, but I'd hate having to make sense of this again in six months.
Ohh, yes. Far from good design. I can try to reorder chunks a bit.
Please don't spend too much effort on it. The script is primarily for helping us convert the whole tree within a short time span. We may also use it later to convert instances of the old pattern that have crept back. We hopefully won't have to change the script then. Readability is not as important as it is for code we expect to be read again and again over a long time.
[...]
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp
In reply to Markus ArmbrusterQuoted 6 lines · Markus Armbruster
Quoted 3 lines
+|
+- warn_report_err(local_err); ++ warn_report_errp(errp);Likewise.
What about
error_reportf_err(),warn_reportf_err()?
Hmm I'm afraid, we don't have corresponding cases to update..
We can still handle them here, but, then, should we use nonexistent error_reportf_errp, so if it matched, we'll have compilation error? Or may be coccinelle has some kind of "abort()" on the match, to error-out that "please define error_reportf_errp and update coccinelle script first"...
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp
In reply to Markus ArmbrusterQuoted 188 lines · Markus Armbruster
Quoted 39 lines · Vladimir Sementsov-Ogievskiy
Script adds
ERRP_AUTO_PROPAGATEmacro invocation where appropriate and does corresponding changes in code (look for details ininclude/qapi/error.h)Usage example:
spatch --sp-filescripts/coccinelle/auto-propagated-errp.cocci\
--macro-filescripts/cocci-macro-file.h--in-place --no-show-diff \
blockdev-nbd.cqemu-nbd.c{block/nbd*,nbd/*,include/block/nbd*}.[hc]Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 158 ++++++++++++++++++ 2 files changed, 161 insertions(+)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +0
-0include/qapi/error.h line 149
Quoted 9 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; Extra blank line.
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +20
-0@@ -0,0 +1,158 @@ +// 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 \scripts/coccinelle/auto-propagated-errp.cocci line 30
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@rule0@ +// 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 did not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation.Not skipping a function we should skip fails to compile.
What about skipping a function we should not skip?
scripts/coccinelle/auto-propagated-errp.cocci line 32
Quoted 2 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +2
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err, ERRP;A few of our coccinelle scripts use
ALL_CAPSfor meta-variables. Most don't. Either is fine with me. Mixing the two styles feels a bit confusing, though.Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+@@ + + fn(..., Error **ERRP, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+...scripts/coccinelle/auto-propagated-errp.cocci line 48
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ when != ERRP_AUTO_PROPAGATE(); +( + error_append_hint(ERRP, ...); +| + error_prepend(ERRP, ...); +| + Error *local_err = NULL; +) + ...+> + }Misses
error_vprepend(). Currently harmless, but as long as we commit the script, we better make it as robust as we reasonably can.The previous patch explains this Coccinelle script's intent:
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).
This rule matches "use error_prepend/error_append_hint" directly. It appears to use presence of a local Error * variable as proxy for "use local_err+error_propagate to check errors". Hmm.
We obviously have such a variable when we use "local_err+error_propagate to check errors". But we could also have such variables without use of
error_propagate(). In fact,error.hdocuments such use:* Call a function and receive an error from it:
* Error *err = NULL; * foo(arg, &err); * if (err) {* handle the error...
* }where "handle the error" frees it.
I figure such uses typically occur in functions without an Error **errp parameter. This rule doesn't apply then. But they could occur even in functions with such a parameter. Consider:
void foo(Error **errp) { Error *err = NULL; bar(&err); if (err) { error_free(err); error_setg(errp, "completely different error"); } }Reasonable enough when
bar()gives us an error that's misleading in this context, isn't it?The script transforms it like this:
void
foo(Error **errp)
{
- Error *err = NULL;
+ERRP_AUTO_PROPAGATE();-
bar(&err);
- if (err) {
-error_free(err);
+ bar(errp);
+ if (*errp) {
+error_free_errp(errp);
error_setg(errp, "completely different error");
}
}Unwanted.
Now, if this script applied in just a few dozen places, we could rely on eyeballing its output to catch unwanted transformations. Since it applies in so many more, I don't feel comfortable relying on reviewer eyeballs.
Quoted 5 lines
Can we make rule0 directly match
error_propagate(errp, local_err)somehow?Another observation: the rule does not match
error_reportf_err()andwarn_reportf_err().
They are unrelated, as they take Error* argument, not Error**
Quoted 221 lines
These combine
error_prepend(),
error_report()/warn_report() anderror_free(), for convenience. Don't their users needERRP_AUTO_PROPAGATE()just like error_prepend()'s users?scripts/coccinelle/auto-propagated-errp.cocci line 52
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+ +@@ +// Switch unusual (Error **) parameter names to errp +// (this is necessary to use ERRP_AUTO_PROPAGATE).Please put your rule comments right before the rule, i.e. before the @-line introducing metavariable declarations, not after. Same elsewhere.
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+identifier rule0.fn; +identifier rule0.ERRP != errp; +@@ +scripts/coccinelle/auto-propagated-errp.cocci line 66
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ fn(..., +- Error **ERRP ++ Error **errp + ,...) + { + <... +- ERRP ++ errp + ...> + }This normalizes errp parameter naming. It matches exactly when rule0 matches (and inserts
ERRP_AUTO_PROPAGATE()) and the Error ** parameter is unusual. Good.scripts/coccinelle/auto-propagated-errp.cocci line 71
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+ +@rule1@ +// We want to patch error propagation in functions regardless of +// whether the function already uses ERRP_AUTO_PROPAGATE prior to +// applying rule0, hence this one does not inherit from it.I'm not sure I get this comment. Let's see what the rule does.
scripts/coccinelle/auto-propagated-errp.cocci line 82
Quoted 11 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +11
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err; +symbol errp; +@@ + + fn(..., Error **errp, ...) + { + <... +- Error *local_err = NULL; + ...> + }rule1 matches like rule0, except the Error ** parameter match is tightened from any C identifier to the C identifier errp, and the function body match tightened from "either use error_prepend/error_append_hint or which use local_err+error_propagate to check errors" to just the latter.
I figure tightening the Error ** parameter match has no effect, because we already normalized the parameter name.
So rule1 deletes variable
local_errwhere rule0 applied. Correct?Quoted 7 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +7
-0+ +@@ +// Handle pattern with goto, otherwise we'll finish up +// with labels at function end which will not compile. +identifier rule1.fn, rule1.local_err; +identifier OUT; +@@scripts/coccinelle/auto-propagated-errp.cocci line 99
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ + fn(...) + { + <... +- goto OUT; ++ return; + ...> +- OUT: +- error_propagate(errp, local_err); + }This is one special case of
error_propagate()deletion. It additionally gets rid of a goto we no longer want. For the general case, see below.The rule applies only where rule1 just deleted the variable. Thus, the two rules work in tandem. Makes sense.
scripts/coccinelle/auto-propagated-errp.cocci line 87
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+ +@@ +identifier rule1.fn, rule1.local_err;This rule also works in tandem with rule1.
scripts/coccinelle/auto-propagated-errp.cocci line 103
Quoted 1 line
scripts/coccinelle/auto-propagated-errp.cocci new file +1
-0+expression list args; // to reindent error_propagate_prependWhat is the comment trying to tell me?
scripts/coccinelle/auto-propagated-errp.cocci line 112
Quoted 9 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +9
-0+@@ + + fn(...) + { + <... +( +- error_free(local_err); +- local_err = NULL; ++ error_free_errp(errp);Reminder:
static inline void error_free_errp(Error **errp) { assert(errp && *errp); error_free(*errp); *errp = NULL; }Now let's examine the actual change.
The assertion's first half trivially holds,
ERRP_AUTO_PROPAGATE()ensures it.The second half is new. We now crash when we haven't set an error. Why is this safe? Note that
error_free(local_err)does nothing when !local_err.The zapping of the variable pointing to the Error just freed is unchanged.
scripts/coccinelle/auto-propagated-errp.cocci line 115
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_free(local_err); ++ error_free_errp(errp);Here, the zapping is new. Zapping dangling pointers is obviously safe. Needed, or else the automatic
error_propagate()due toERRP_AUTO_PROPAGATE()would propagate the dangling pointer.scripts/coccinelle/auto-propagated-errp.cocci line 118
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_report_err(local_err); ++ error_report_errp(errp);The only difference to the previous case is that we also report the error.
The previous case has a buddy that additionally matches *errp = NULL. Why not this one?
scripts/coccinelle/auto-propagated-errp.cocci line 121
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- warn_report_err(local_err); ++ warn_report_errp(errp);Likewise.
What about
error_reportf_err(),warn_reportf_err()?Up to here, this rule transforms the various forms of
error_free().
Next:error_propagate().scripts/coccinelle/auto-propagated-errp.cocci line 126
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+| +- error_propagate_prepend(errp, local_err, args); ++ error_prepend(errp, args); +| +- error_propagate(errp, local_err);rule0's adding of
ERRP_AUTO_PROPAGATE()madeerror_propagate()redundant.This is the general case of
error_propagate()deletion.I'd put the plain
error_propagate()first, variations second, like you do witherror_free().If neither of these two patterns match on a path from
ERRP_AUTO_PROPAGATE()to return, we effectively inserterror_propagate()where it wasn't before. Does nothing when the local error is null there. Bug fix when it isn't: it's at least a memory leak, and quite possibly worse.Identifying these bug fixes would be nice, but I don't have practical ideas on how to do that.
Can we explain this in the commit message?
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+) + ...> + } + +@@ +identifier rule1.fn, rule1.local_err; +@@ + + fn(...) + {scripts/coccinelle/auto-propagated-errp.cocci line 146
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ <... +( +- &local_err ++ errp +| +- local_err ++ *errp +) + ...> + }Also in tandem with rule1, fixes up uses of
local_err. Good.scripts/coccinelle/auto-propagated-errp.cocci line 158
Quoted 12 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +12
-0+ +@@ +identifier rule1.fn; +@@ + + fn(...) + { + <... +- *errp != NULL ++ *errp + ...> + }Still in tandem with rule1, normalizes style. Good.
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Re: [PATCH v7 03/11] scripts: add coccinelle script to use auto propagated errp
Quoted 189 lines · Vladimir Sementsov-Ogievskiy
Quoted 188 lines · Markus Armbruster
Quoted 39 lines · Vladimir Sementsov-Ogievskiy
Script adds
ERRP_AUTO_PROPAGATEmacro invocation where appropriate and does corresponding changes in code (look for details ininclude/qapi/error.h)Usage example:
spatch --sp-filescripts/coccinelle/auto-propagated-errp.cocci\
--macro-filescripts/cocci-macro-file.h--in-place --no-show-diff \
blockdev-nbd.cqemu-nbd.c{block/nbd*,nbd/*,include/block/nbd*}.[hc]Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>---
CC Eric Blake <[email protected]>CC Kevin Wolf <[email protected]>CC Max Reitz <[email protected]>CC Greg Kurz <[email protected]>CC Stefano Stabellini <[email protected]>CC Anthony Perard <[email protected]>CC Paul Durrant <[email protected]>CC Stefan Hajnoczi <[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 | 158 ++++++++++++++++++ 2 files changed, 161 insertions(+)create mode 100644
scripts/coccinelle/auto-propagated-errp.cocciinclude/qapi/error.h +0
-0include/qapi/error.h line 149
Quoted 9 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; Extra blank line.
Quoted 26 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +20
-0@@ -0,0 +1,158 @@ +// 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 \scripts/coccinelle/auto-propagated-errp.cocci line 30
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+// blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] + +@rule0@ +// 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 did not skip some functions with +// "Error *const *errp", ERRP_AUTO_PROPAGATE invocation +// will fail to compile, because of const violation.Not skipping a function we should skip fails to compile.
What about skipping a function we should not skip?
scripts/coccinelle/auto-propagated-errp.cocci line 32
Quoted 2 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +2
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err, ERRP;A few of our coccinelle scripts use
ALL_CAPSfor meta-variables. Most don't. Either is fine with me. Mixing the two styles feels a bit confusing, though.Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+@@ + + fn(..., Error **ERRP, ...) + { ++ ERRP_AUTO_PROPAGATE(); + <+...scripts/coccinelle/auto-propagated-errp.cocci line 48
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ when != ERRP_AUTO_PROPAGATE(); +( + error_append_hint(ERRP, ...); +| + error_prepend(ERRP, ...); +| + Error *local_err = NULL; +) + ...+> + }Misses
error_vprepend(). Currently harmless, but as long as we commit the script, we better make it as robust as we reasonably can.The previous patch explains this Coccinelle script's intent:
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).
This rule matches "use error_prepend/error_append_hint" directly. It appears to use presence of a local Error * variable as proxy for "use local_err+error_propagate to check errors". Hmm.
We obviously have such a variable when we use "local_err+error_propagate to check errors". But we could also have such variables without use of
error_propagate(). In fact,error.hdocuments such use:* Call a function and receive an error from it:
* Error *err = NULL; * foo(arg, &err); * if (err) {* handle the error...
* }where "handle the error" frees it.
I figure such uses typically occur in functions without an Error **errp parameter. This rule doesn't apply then. But they could occur even in functions with such a parameter. Consider:
void foo(Error **errp) { Error *err = NULL; bar(&err); if (err) { error_free(err); error_setg(errp, "completely different error"); } }Reasonable enough when
bar()gives us an error that's misleading in this context, isn't it?The script transforms it like this:
void
foo(Error **errp)
{
- Error *err = NULL;
+ERRP_AUTO_PROPAGATE();-
bar(&err);
- if (err) {
-error_free(err);
+ bar(errp);
+ if (*errp) {
+error_free_errp(errp);
error_setg(errp, "completely different error");
}
}Unwanted.
Now, if this script applied in just a few dozen places, we could rely on eyeballing its output to catch unwanted transformations. Since it applies in so many more, I don't feel comfortable relying on reviewer eyeballs.
Quoted 12 lines
Quoted 5 lines
Can we make rule0 directly match
error_propagate(errp, local_err)somehow?Another observation: the rule does not match
error_reportf_err()andwarn_reportf_err().They are unrelated, as they take Error* argument, not Error**
Quoted 4 lines
These combine
error_prepend(),
error_report()/warn_report() anderror_free(), for convenience. Don't their users needERRP_AUTO_PROPAGATE()just like error_prepend()'s users?
Right, we never pass *errp to error_reportf_err() and warn_reportf_err(), so there's no need to wrap it.
But see below.
Quoted 129 lines
Quoted 129 lines
scripts/coccinelle/auto-propagated-errp.cocci line 52
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+ +@@ +// Switch unusual (Error **) parameter names to errp +// (this is necessary to use ERRP_AUTO_PROPAGATE).Please put your rule comments right before the rule, i.e. before the @-line introducing metavariable declarations, not after. Same elsewhere.
Quoted 4 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +4
-0+identifier rule0.fn; +identifier rule0.ERRP != errp; +@@ +scripts/coccinelle/auto-propagated-errp.cocci line 66
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ fn(..., +- Error **ERRP ++ Error **errp + ,...) + { + <... +- ERRP ++ errp + ...> + }This normalizes errp parameter naming. It matches exactly when rule0 matches (and inserts
ERRP_AUTO_PROPAGATE()) and the Error ** parameter is unusual. Good.scripts/coccinelle/auto-propagated-errp.cocci line 71
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+ +@rule1@ +// We want to patch error propagation in functions regardless of +// whether the function already uses ERRP_AUTO_PROPAGATE prior to +// applying rule0, hence this one does not inherit from it.I'm not sure I get this comment. Let's see what the rule does.
scripts/coccinelle/auto-propagated-errp.cocci line 82
Quoted 11 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +11
-0+identifier fn !~ "error_append_.*_hint"; +identifier local_err; +symbol errp; +@@ + + fn(..., Error **errp, ...) + { + <... +- Error *local_err = NULL; + ...> + }rule1 matches like rule0, except the Error ** parameter match is tightened from any C identifier to the C identifier errp, and the function body match tightened from "either use error_prepend/error_append_hint or which use local_err+error_propagate to check errors" to just the latter.
I figure tightening the Error ** parameter match has no effect, because we already normalized the parameter name.
So rule1 deletes variable
local_errwhere rule0 applied. Correct?Quoted 7 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +7
-0+ +@@ +// Handle pattern with goto, otherwise we'll finish up +// with labels at function end which will not compile. +identifier rule1.fn, rule1.local_err; +identifier OUT; +@@scripts/coccinelle/auto-propagated-errp.cocci line 99
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ + fn(...) + { + <... +- goto OUT; ++ return; + ...> +- OUT: +- error_propagate(errp, local_err); + }This is one special case of
error_propagate()deletion. It additionally gets rid of a goto we no longer want. For the general case, see below.The rule applies only where rule1 just deleted the variable. Thus, the two rules work in tandem. Makes sense.
scripts/coccinelle/auto-propagated-errp.cocci line 87
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+ +@@ +identifier rule1.fn, rule1.local_err;This rule also works in tandem with rule1.
scripts/coccinelle/auto-propagated-errp.cocci line 103
Quoted 1 line
scripts/coccinelle/auto-propagated-errp.cocci new file +1
-0+expression list args; // to reindent error_propagate_prependWhat is the comment trying to tell me?
scripts/coccinelle/auto-propagated-errp.cocci line 112
Quoted 9 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +9
-0+@@ + + fn(...) + { + <... +( +- error_free(local_err); +- local_err = NULL; ++ error_free_errp(errp);Reminder:
static inline void error_free_errp(Error **errp) { assert(errp && *errp); error_free(*errp); *errp = NULL; }Now let's examine the actual change.
The assertion's first half trivially holds,
ERRP_AUTO_PROPAGATE()ensures it.The second half is new. We now crash when we haven't set an error. Why is this safe? Note that
error_free(local_err)does nothing when !local_err.The zapping of the variable pointing to the Error just freed is unchanged.
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_free(local_err); ++ error_free_errp(errp);
Quoted 7 lines
Quoted 7 lines
Here, the zapping is new. Zapping dangling pointers is obviously safe. Needed, or else the automatic
error_propagate()due toERRP_AUTO_PROPAGATE()would propagate the dangling pointer.Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- error_report_err(local_err); ++ error_report_errp(errp);
error_reportf_err() is just like error_report_err(), except it additionally modifies the error message. Does it need a similar transformation?
Quoted 9 lines
Quoted 9 lines
The only difference to the previous case is that we also report the error.
The previous case has a buddy that additionally matches *errp = NULL. Why not this one?
Quoted 3 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +3
-0+| +- warn_report_err(local_err); ++ warn_report_errp(errp);
Likewise.
Quoted 55 lines
Quoted 55 lines
Likewise.
What about
error_reportf_err(),warn_reportf_err()?Up to here, this rule transforms the various forms of
error_free().
Next:error_propagate().scripts/coccinelle/auto-propagated-errp.cocci line 126
Quoted 5 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +5
-0+| +- error_propagate_prepend(errp, local_err, args); ++ error_prepend(errp, args); +| +- error_propagate(errp, local_err);rule0's adding of
ERRP_AUTO_PROPAGATE()madeerror_propagate()redundant.This is the general case of
error_propagate()deletion.I'd put the plain
error_propagate()first, variations second, like you do witherror_free().If neither of these two patterns match on a path from
ERRP_AUTO_PROPAGATE()to return, we effectively inserterror_propagate()where it wasn't before. Does nothing when the local error is null there. Bug fix when it isn't: it's at least a memory leak, and quite possibly worse.Identifying these bug fixes would be nice, but I don't have practical ideas on how to do that.
Can we explain this in the commit message?
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+) + ...> + } + +@@ +identifier rule1.fn, rule1.local_err; +@@ + + fn(...) + {scripts/coccinelle/auto-propagated-errp.cocci line 146
Quoted 10 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +10
-0+ <... +( +- &local_err ++ errp +| +- local_err ++ *errp +) + ...> + }Also in tandem with rule1, fixes up uses of
local_err. Good.
Quoted 15 lines
Quoted 6 lines
Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+ +@@ +identifier rule1.fn; +@@ + + fn(...)Quoted 9 lines
scripts/coccinelle/auto-propagated-errp.cocci line 158
Quoted 6 lines
scripts/coccinelle/auto-propagated-errp.cocci new file +6
-0+ { + <... +- *errp != NULL ++ *errp + ...> + }Still in tandem with rule1, normalizes style. Good.
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
PATCH v7 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
PATCH v7 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 v7 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 v7 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 v7 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
@@ -1479,10 +1479,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" );
@@ -1516,11 +1516,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 ; } }
@@ -1530,9 +1529,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
@@ -4002,6 +4002,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
PATCH v7 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 v7 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 v7 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
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 v7 00/11] error: auto propagated local_err part I
Message-id: [email protected]
Type: series
=== 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 ===
From https://github.com/patchew-project/qemu
9281736..adcd6e9 master -> master
From https://github.com/patchew-project/qemu
* [new tag] patchew/[email protected] -> patchew/[email protected]
Switched to a new branch 'test'
b0f4834 xen: introduce ERRP_AUTO_PROPAGATE
c704561 nbd: introduce ERRP_AUTO_PROPAGATE
238b4d2 TPM: introduce ERRP_AUTO_PROPAGATE
56af634 virtio-9p: introduce ERRP_AUTO_PROPAGATE 8dd497a fw_cfg: introduce ERRP_AUTO_PROPAGATE
cd54750 pflash: introduce ERRP_AUTO_PROPAGATE
031d7ed SD (Secure Card): introduce ERRP_AUTO_PROPAGATE 7dc91c5 hw/sd/ssi-sd: fix error handling in ssi_sd_realize 57435c4 scripts: add coccinelle script to use auto propagated errp 0883f29 error: auto propagated local_err
df0db83 qapi/error: add (Error **errp) cleaning APIs
=== OUTPUT BEGIN ===
1/11 Checking commit df0db83cd18a (qapi/error: add (Error **errp) cleaning APIs) 2/11 Checking commit 0883f296ed8f (error: auto propagated local_err)
ERROR: Macros with multiple statements should be enclosed in a do - while loop #139: FILE: include/qapi/error.h:427:
+#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, 101 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 57435c473bf1 (scripts: add coccinelle script to use auto propagated errp)
WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
#34:
new file mode 100644
total: 0 errors, 1 warnings, 167 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 7dc91c560263 (hw/sd/ssi-sd: fix error handling in ssi_sd_realize) 5/11 Checking commit 031d7eda4bbb (SD (Secure Card): introduce ERRP_AUTO_PROPAGATE) 6/11 Checking commit cd54750748f4 (pflash: introduce ERRP_AUTO_PROPAGATE) 7/11 Checking commit 8dd497a506bc (fw_cfg: introduce ERRP_AUTO_PROPAGATE) 8/11 Checking commit 56af634941d2 (virtio-9p: introduce ERRP_AUTO_PROPAGATE) 9/11 Checking commit 238b4d2c886f (TPM: introduce ERRP_AUTO_PROPAGATE) 10/11 Checking commit c7045610d28d (nbd: introduce ERRP_AUTO_PROPAGATE) 11/11 Checking commit b0f483460534 (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
Quoted 44 lines · 31.01.2020 16:12, [email protected] wrote:
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 v7 00/11] error: auto propagated
local_errpart I
Message-id: [email protected]
Type: series=== 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 ===From https://github.com/patchew-project/qemu
9281736..adcd6e9 master -> masterFrom https://github.com/patchew-project/qemu
* [new tag] patchew/[email protected] -> patchew/[email protected]
Switched to a new branch 'test'
b0f4834 xen: introduceERRP_AUTO_PROPAGATE
c704561 nbd: introduceERRP_AUTO_PROPAGATE
238b4d2 TPM: introduceERRP_AUTO_PROPAGATE
56af634 virtio-9p: introduceERRP_AUTO_PROPAGATE8dd497afw_cfg: introduceERRP_AUTO_PROPAGATE
cd54750 pflash: introduceERRP_AUTO_PROPAGATE
031d7ed SD (Secure Card): introduceERRP_AUTO_PROPAGATE7dc91c5 hw/sd/ssi-sd: fix error handling inssi_sd_realize57435c4 scripts: add coccinelle script to use auto propagated errp 0883f29 error: auto propagatedlocal_err
df0db83 qapi/error: add (Error **errp) cleaning APIs=== OUTPUT BEGIN ===
1/11 Checking commitdf0db83cd18a(qapi/error: add (Error **errp) cleaning APIs) 2/11 Checking commit0883f296ed8f(error: auto propagatedlocal_err)
ERROR: Macros with multiple statements should be enclosed in a do - while loop #139: FILE:include/qapi/error.h:427:
Review
Quoted 4 lines
(quoted diff) +4
-0+#define ERRP_AUTO_PROPAGATE() \ + g_auto(ErrorPropagator) _auto_errp_prop = {.errp = errp}; \ + errp = ((errp == NULL || *errp == error_fatal) \ + ? &_auto_errp_prop.local_err : errp)
It worth it.
Quoted 36 lines
total: 1 errors, 0 warnings, 101 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
57435c473bf1(scripts: add coccinelle script to use auto propagated errp)
WARNING: added, moved or deleted file(s), doesMAINTAINERSneed updating?
#34:
new file mode 100644total: 0 errors, 1 warnings, 167 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 inMAINTAINERS.
4/11 Checking commit7dc91c560263(hw/sd/ssi-sd: fix error handling inssi_sd_realize) 5/11 Checking commit031d7eda4bbb(SD (Secure Card): introduceERRP_AUTO_PROPAGATE) 6/11 Checking commitcd54750748f4(pflash: introduceERRP_AUTO_PROPAGATE) 7/11 Checking commit8dd497a506bc(fw_cfg: introduceERRP_AUTO_PROPAGATE) 8/11 Checking commit56af634941d2(virtio-9p: introduceERRP_AUTO_PROPAGATE) 9/11 Checking commit238b4d2c886f(TPM: introduceERRP_AUTO_PROPAGATE) 10/11 Checking commitc7045610d28d(nbd: introduceERRP_AUTO_PROPAGATE) 11/11 Checking commitb0f483460534(xen: introduceERRP_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]
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Hi Vladimir,
I've come to rather like your ERRP_AUTO_PROPAGATE() idea. What I wouldn't like is a protracted conversion.
Once we're happy with PATCH 1-3, it's a matter of running Coccinelle and reviewing its output. I'm confident we can converge on PATCH 1-3.
It's two weeks until soft freeze. We need to decide whether to pursue a partial conversion for 5.0 (basically this series plus the two patches we identified in review of PATCH 1), or delay until 5.1. In either case, I want the conversion to be finished in 5.1.
Please do not feel pressured to make the 5.0 deadline.
I can queue up patches for 5.1 during the freeze.
How would you like to proceed?
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Quoted 13 lines · Markus Armbruster
Hi Vladimir,
I've come to rather like your
ERRP_AUTO_PROPAGATE()idea. What I wouldn't like is a protracted conversion.Once we're happy with PATCH 1-3, it's a matter of running Coccinelle and reviewing its output. I'm confident we can converge on PATCH 1-3.
It's two weeks until soft freeze. We need to decide whether to pursue a partial conversion for 5.0 (basically this series plus the two patches we identified in review of PATCH 1), or delay until 5.1. In either case, I want the conversion to be finished in 5.1.
Quoted 6 lines
Please do not feel pressured to make the 5.0 deadline.
I can queue up patches for 5.1 during the freeze.
How would you like to proceed?
Hi Markus! Funny coincidence: exactly now (less than 1 hour ago), I've started working for the next version for these series. So, I'm going to resend today. Of course, I'd prefer to merge something to 5.0 if at all possible.
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel
Quoted 18 lines · Vladimir Sementsov-Ogievskiy
Quoted 17 lines · Markus Armbruster
Hi Vladimir,
I've come to rather like your
ERRP_AUTO_PROPAGATE()idea. What I wouldn't like is a protracted conversion.Once we're happy with PATCH 1-3, it's a matter of running Coccinelle and reviewing its output. I'm confident we can converge on PATCH 1-3.
It's two weeks until soft freeze. We need to decide whether to pursue a partial conversion for 5.0 (basically this series plus the two patches we identified in review of PATCH 1), or delay until 5.1. In either case, I want the conversion to be finished in 5.1.
Please do not feel pressured to make the 5.0 deadline.
I can queue up patches for 5.1 during the freeze.
Quoted 7 lines
Quoted 2 lines
How would you like to proceed?
Hi Markus! Funny coincidence: exactly now (less than 1 hour ago), I've started working for the next version for these series. So, I'm going to resend today. Of course, I'd prefer to merge something to 5.0 if at all possible.
That was v8, followed by v9. We're clearly converging. However, the soft freeze is tomorrow already.
You've persevered with this idea for quite a while; some impatience would be quite excusable now. Still, I doubt part I making 5.0 matters. The hand-written part is likely to rebase easily, and the generated part should be regenerated instead of rebased anyway.
What actually matters is *finishing* the job. What does that take?
* Consensus on the hand-written part. I think we're basically there, we just want to work in a few more tweaks.
* Split the generated part into reviewable batches, regenerating patches as necessary. Solicit review. First batch is part of this series, and v9 looks ready to me. I assume you'll prepare the remaining batches.
* Queue up batches as they become ready, post pull requests. I can do that.
* Update the QAPI code generator to the new Error usage. I can do that.
_______________________________________________
Xen-devel mailing list
[email protected]
https://lists.xenproject.org/mailman/listinfo/xen-devel
Quoted 28 lines · Markus Armbruster
Quoted 18 lines · Vladimir Sementsov-Ogievskiy
Quoted 17 lines · Markus Armbruster
Hi Vladimir,
I've come to rather like your
ERRP_AUTO_PROPAGATE()idea. What I wouldn't like is a protracted conversion.Once we're happy with PATCH 1-3, it's a matter of running Coccinelle and reviewing its output. I'm confident we can converge on PATCH 1-3.
It's two weeks until soft freeze. We need to decide whether to pursue a partial conversion for 5.0 (basically this series plus the two patches we identified in review of PATCH 1), or delay until 5.1. In either case, I want the conversion to be finished in 5.1.
Please do not feel pressured to make the 5.0 deadline.
I can queue up patches for 5.1 during the freeze.
Quoted 7 lines
Quoted 2 lines
How would you like to proceed?
Hi Markus! Funny coincidence: exactly now (less than 1 hour ago), I've started working for the next version for these series. So, I'm going to resend today. Of course, I'd prefer to merge something to 5.0 if at all possible.
Quoted 5 lines
That was v8, followed by v9. We're clearly converging. However, the soft freeze is tomorrow already.
You've persevered with this idea for quite a while; some impatience would be quite excusable now. Still, I doubt part I making 5.0 matters.
Not a problem. I hope, I'll resend soon, then it will be up to you.
Quoted 7 lines
The hand-written part is likely to rebase easily, and the generated part should be regenerated instead of rebased anyway.
What actually matters is *finishing* the job. What does that take?
* Consensus on the hand-written part. I think we're basically there, we just want to work in a few more tweaks.
I'll resend today, most probably it would be your version of coccinelle (if I will not find real sense in fn inheritance).
Quoted 5 lines
* Split the generated part into reviewable batches, regenerating patches as necessary. Solicit review. First batch is part of this series, and v9 looks ready to me. I assume you'll prepare the remaining batches.
Yes I will. This is the reward for this work: send one hundred generated patches :))
Quoted 6 lines
* Queue up batches as they become ready, post pull requests. I can do that.
* Update the QAPI code generator to the new Error usage. I can do that.
Great!
Signature · 7 lines
Best regards, Vladimir _______________________________________________ Xen-devel mailing list [email protected] https://lists.xenproject.org/mailman/listinfo/xen-devel