From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 61393C1975A for ; Thu, 12 Mar 2020 09:00:52 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 3AF5F206FA for ; Thu, 12 Mar 2020 09:00:52 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3AF5F206FA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=virtuozzo.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1jCJhi-0000gt-4f; Thu, 12 Mar 2020 09:00:34 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1jCJhh-0000gX-5a for xen-devel@lists.xenproject.org; Thu, 12 Mar 2020 09:00:33 +0000 X-Inumbo-ID: ec00156e-643f-11ea-b12e-12813bfff9fa Received: from relay.sw.ru (unknown [185.231.240.75]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id ec00156e-643f-11ea-b12e-12813bfff9fa; Thu, 12 Mar 2020 09:00:30 +0000 (UTC) Received: from vovaso.qa.sw.ru ([10.94.3.0] helo=kvm.qa.sw.ru) by relay.sw.ru with esmtp (Exim 4.92.3) (envelope-from ) id 1jCJgs-0004Ve-Uu; Thu, 12 Mar 2020 11:59:43 +0300 From: Vladimir Sementsov-Ogievskiy To: qemu-devel@nongnu.org Date: Thu, 12 Mar 2020 11:59:27 +0300 Message-Id: <20200312085936.9552-2-vsementsov@virtuozzo.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20200312085936.9552-1-vsementsov@virtuozzo.com> References: <20200312085936.9552-1-vsementsov@virtuozzo.com> MIME-Version: 1.0 Subject: [Xen-devel] [PATCH v9 01/10] error: auto propagated local_err X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , vsementsov@virtuozzo.com, Laszlo Ersek , qemu-block@nongnu.org, Paul Durrant , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Christian Schoenebeck , Greg Kurz , armbru@redhat.com, Stefano Stabellini , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Eric Blake , Michael Roth , Stefan Berger Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" SW50cm9kdWNlIGEgbmV3IEVSUlBfQVVUT19QUk9QQUdBVEUgbWFjcm8sIHRvIGJlIHVzZWQgYXQg c3RhcnQgb2YKZnVuY3Rpb25zIHdpdGggYW4gZXJycCBPVVQgcGFyYW1ldGVyLgoKSXQgaGFzIHRo cmVlIGdvYWxzOgoKMS4gRml4IGlzc3VlIHdpdGggZXJyb3JfZmF0YWwgYW5kIGVycm9yX3ByZXBl bmQvZXJyb3JfYXBwZW5kX2hpbnQ6IHVzZXIKY2FuJ3Qgc2VlIHRoaXMgYWRkaXRpb25hbCBpbmZv cm1hdGlvbiwgYmVjYXVzZSBleGl0KCkgaGFwcGVucyBpbgplcnJvcl9zZXRnIGVhcmxpZXIgdGhh biBpbmZvcm1hdGlvbiBpcyBhZGRlZC4gW1JlcG9ydGVkIGJ5IEdyZWcgS3Vyel0KCjIuIEZpeCBp c3N1ZSB3aXRoIGVycm9yX2Fib3J0IGFuZCBlcnJvcl9wcm9wYWdhdGU6IHdoZW4gd2Ugd3JhcApl cnJvcl9hYm9ydCBieSBsb2NhbF9lcnIrZXJyb3JfcHJvcGFnYXRlLCB0aGUgcmVzdWx0aW5nIGNv cmVkdW1wIHdpbGwKcmVmZXIgdG8gZXJyb3JfcHJvcGFnYXRlIGFuZCBub3QgdG8gdGhlIHBsYWNl IHdoZXJlIGVycm9yIGhhcHBlbmVkLgoodGhlIG1hY3JvIGl0c2VsZiBkb2Vzbid0IGZpeCB0aGUg aXNzdWUsIGJ1dCBpdCBhbGxvd3MgdXMgdG8gWzMuXSBkcm9wCnRoZSBsb2NhbF9lcnIrZXJyb3Jf cHJvcGFnYXRlIHBhdHRlcm4sIHdoaWNoIHdpbGwgZGVmaW5pdGVseSBmaXggdGhlCmlzc3VlKSBb UmVwb3J0ZWQgYnkgS2V2aW4gV29sZl0KCjMuIERyb3AgbG9jYWxfZXJyK2Vycm9yX3Byb3BhZ2F0 ZSBwYXR0ZXJuLCB3aGljaCBpcyB1c2VkIHRvIHdvcmthcm91bmQKdm9pZCBmdW5jdGlvbnMgd2l0 aCBlcnJwIHBhcmFtZXRlciwgd2hlbiBjYWxsZXIgd2FudHMgdG8ga25vdyByZXN1bHRpbmcKc3Rh dHVzLiAoTm90ZTogYWN0dWFsbHkgdGhlc2UgZnVuY3Rpb25zIGNvdWxkIGJlIG1lcmVseSB1cGRh dGVkIHRvCnJldHVybiBpbnQgZXJyb3IgY29kZSkuCgpUbyBhY2hpZXZlIHRoZXNlIGdvYWxzLCBs YXRlciBwYXRjaGVzIHdpbGwgYWRkIGludm9jYXRpb25zCm9mIHRoaXMgbWFjcm8gYXQgdGhlIHN0 YXJ0IG9mIGZ1bmN0aW9ucyB3aXRoIGVpdGhlciB1c2UKZXJyb3JfcHJlcGVuZC9lcnJvcl9hcHBl bmRfaGludCAoc29sdmluZyAxKSBvciB3aGljaCB1c2UKbG9jYWxfZXJyK2Vycm9yX3Byb3BhZ2F0 ZSB0byBjaGVjayBlcnJvcnMsIHN3aXRjaGluZyB0aG9zZQpmdW5jdGlvbnMgdG8gdXNlICplcnJw IGluc3RlYWQgKHNvbHZpbmcgMiBhbmQgMykuCgpTaWduZWQtb2ZmLWJ5OiBWbGFkaW1pciBTZW1l bnRzb3YtT2dpZXZza2l5IDx2c2VtZW50c292QHZpcnR1b3p6by5jb20+ClJldmlld2VkLWJ5OiBQ YXVsIER1cnJhbnQgPHBhdWxAeGVuLm9yZz4KUmV2aWV3ZWQtYnk6IEdyZWcgS3VyeiA8Z3JvdWdA a2FvZC5vcmc+ClJldmlld2VkLWJ5OiBFcmljIEJsYWtlIDxlYmxha2VAcmVkaGF0LmNvbT4KLS0t CgpDYzogRXJpYyBCbGFrZSA8ZWJsYWtlQHJlZGhhdC5jb20+CkNjOiBLZXZpbiBXb2xmIDxrd29s ZkByZWRoYXQuY29tPgpDYzogTWF4IFJlaXR6IDxtcmVpdHpAcmVkaGF0LmNvbT4KQ2M6IEdyZWcg S3VyeiA8Z3JvdWdAa2FvZC5vcmc+CkNjOiBDaHJpc3RpYW4gU2Nob2VuZWJlY2sgPHFlbXVfb3Nz QGNydWRlYnl0ZS5jb20+CkNjOiBTdGVmYW5vIFN0YWJlbGxpbmkgPHNzdGFiZWxsaW5pQGtlcm5l bC5vcmc+CkNjOiBBbnRob255IFBlcmFyZCA8YW50aG9ueS5wZXJhcmRAY2l0cml4LmNvbT4KQ2M6 IFBhdWwgRHVycmFudCA8cGF1bEB4ZW4ub3JnPgpDYzogU3RlZmFuIEhham5vY3ppIDxzdGVmYW5o YUByZWRoYXQuY29tPgpDYzogIlBoaWxpcHBlIE1hdGhpZXUtRGF1ZMOpIiA8cGhpbG1kQHJlZGhh dC5jb20+CkNjOiBMYXN6bG8gRXJzZWsgPGxlcnNla0ByZWRoYXQuY29tPgpDYzogR2VyZCBIb2Zm bWFubiA8a3JheGVsQHJlZGhhdC5jb20+CkNjOiBTdGVmYW4gQmVyZ2VyIDxzdGVmYW5iQGxpbnV4 LmlibS5jb20+CkNjOiBNYXJrdXMgQXJtYnJ1c3RlciA8YXJtYnJ1QHJlZGhhdC5jb20+CkNjOiBN aWNoYWVsIFJvdGggPG1kcm90aEBsaW51eC52bmV0LmlibS5jb20+CkNjOiBxZW11LWRldmVsQG5v bmdudS5vcmcKQ2M6IHFlbXUtYmxvY2tAbm9uZ251Lm9yZwpDYzogeGVuLWRldmVsQGxpc3RzLnhl bnByb2plY3Qub3JnCgogaW5jbHVkZS9xYXBpL2Vycm9yLmggfCAyMDUgKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDE3MyBpbnNlcnRp b25zKCspLCAzMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL3FhcGkvZXJyb3Iu aCBiL2luY2x1ZGUvcWFwaS9lcnJvci5oCmluZGV4IGFkNWI2ZTg5NmQuLjMwMTQwZDliZmUgMTAw NjQ0Ci0tLSBhL2luY2x1ZGUvcWFwaS9lcnJvci5oCisrKyBiL2luY2x1ZGUvcWFwaS9lcnJvci5o CkBAIC0xNSw2ICsxNSw4IEBACiAvKgogICogRXJyb3IgcmVwb3J0aW5nIHN5c3RlbSBsb29zZWx5 IHBhdHRlcm5lZCBhZnRlciBHbGliJ3MgR0Vycm9yLgogICoKKyAqID0gRGVhbCB3aXRoIEVycm9y IG9iamVjdCA9CisgKgogICogQ3JlYXRlIGFuIGVycm9yOgogICogICAgIGVycm9yX3NldGcoJmVy ciwgInNpdHVhdGlvbiBub3JtYWwsIGFsbCBmb3VsZWQgdXAiKTsKICAqCkBAIC00NywyOCArNDks OTEgQEAKICAqIHJlcG9ydGluZyBpdCAocHJpbWFyaWx5IHVzZWZ1bCBpbiB0ZXN0c3VpdGVzKToK ICAqICAgICBlcnJvcl9mcmVlX29yX2Fib3J0KCZlcnIpOwogICoKLSAqIFBhc3MgYW4gZXhpc3Rp bmcgZXJyb3IgdG8gdGhlIGNhbGxlcjoKLSAqICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgZXJy KTsKLSAqIHdoZXJlIEVycm9yICoqZXJycCBpcyBhIHBhcmFtZXRlciwgYnkgY29udmVudGlvbiB0 aGUgbGFzdCBvbmUuCisgKiA9IERlYWwgd2l0aCBFcnJvciAqKiBmdW5jdGlvbiBwYXJhbWV0ZXIg PQogICoKLSAqIFBhc3MgYW4gZXhpc3RpbmcgZXJyb3IgdG8gdGhlIGNhbGxlciB3aXRoIHRoZSBt ZXNzYWdlIG1vZGlmaWVkOgotICogICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGVy cik7CisgKiBBIGZ1bmN0aW9uIG1heSB1c2UgdGhlIGVycm9yIHN5c3RlbSB0byByZXR1cm4gZXJy b3JzLiBJbiB0aGlzIGNhc2UsIHRoZQorICogZnVuY3Rpb24gZGVmaW5lcyBhbiBFcnJvciAqKmVy cnAgcGFyYW1ldGVyLCBieSBjb252ZW50aW9uIHRoZSBsYXN0IG9uZSAod2l0aAorICogZXhjZXB0 aW9ucyBmb3IgZnVuY3Rpb25zIHVzaW5nIC4uLiBvciB2YV9saXN0KS4KICAqCi0gKiBBdm9pZAot ICogICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIpOwotICogICAgIGVycm9yX3ByZXBlbmQo ZXJycCwgIkNvdWxkIG5vdCBmcm9ibmljYXRlICclcyc6ICIsIG5hbWUpOwotICogYmVjYXVzZSB0 aGlzIGZhaWxzIHRvIHByZXBlbmQgd2hlbiBAZXJycCBpcyAmZXJyb3JfZmF0YWwuCisgKiBUaGUg Y2FsbGVyIG1heSB0aGVuIHBhc3MgaW4gdGhlIGZvbGxvd2luZyBlcnJwIHZhbHVlczoKICAqCi0g KiBDcmVhdGUgYSBuZXcgZXJyb3IgYW5kIHBhc3MgaXQgdG8gdGhlIGNhbGxlcjoKKyAqIDEuICZl cnJvcl9hYm9ydAorICogICAgQW55IGVycm9yIHdpbGwgcmVzdWx0IGluIGFib3J0KCkuCisgKiAy LiAmZXJyb3JfZmF0YWwKKyAqICAgIEFueSBlcnJvciB3aWxsIHJlc3VsdCBpbiBleGl0KCkgd2l0 aCBhIG5vbi16ZXJvIHN0YXR1cy4KKyAqIDMuIE5VTEwKKyAqICAgIE5vIGVycm9yIHJlcG9ydGlu ZyB0aHJvdWdoIGVycnAgcGFyYW1ldGVyLgorICogNC4gVGhlIGFkZHJlc3Mgb2YgYSBOVUxMLWlu aXRpYWxpemVkIEVycm9yICplcnIKKyAqICAgIEFueSBlcnJvciB3aWxsIHBvcHVsYXRlIGVycnAg d2l0aCBhbiBlcnJvciBvYmplY3QuCisgKgorICogVGhlIGZvbGxvd2luZyBydWxlcyB0aGVuIGlt cGxlbWVudCB0aGUgY29ycmVjdCBzZW1hbnRpY3MgZGVzaXJlZCBieSB0aGUKKyAqIGNhbGxlci4K KyAqCisgKiBDcmVhdGUgYSBuZXcgZXJyb3IgdG8gcGFzcyB0byB0aGUgY2FsbGVyOgogICogICAg IGVycm9yX3NldGcoZXJycCwgInNpdHVhdGlvbiBub3JtYWwsIGFsbCBmb3VsZWQgdXAiKTsKICAq Ci0gKiBDYWxsIGEgZnVuY3Rpb24gYW5kIHJlY2VpdmUgYW4gZXJyb3IgZnJvbSBpdDoKKyAqIENh bGxpbmcgYW5vdGhlciBlcnJwLWJhc2VkIGZ1bmN0aW9uOgorICogICAgIGYoLi4uLCBlcnJwKTsK KyAqCisgKiA9PSBDaGVja2luZyBzdWNjZXNzIG9mIHN1YmNhbGwgPT0KKyAqCisgKiBJZiBhIGZ1 bmN0aW9uIHJldHVybnMgYSB2YWx1ZSBpbmRpY2F0aW5nIGFuIGVycm9yIGluIGFkZGl0aW9uIHRv IHNldHRpbmcKKyAqIGVycnAgKHdoaWNoIGlzIHJlY29tbWVuZGVkKSwgdGhlbiB5b3UgZG9uJ3Qg bmVlZCBhbnkgYWRkaXRpb25hbCBjb2RlLCBqdXN0CisgKiBkbzoKKyAqCisgKiAgICAgaW50IHJl dCA9IGYoLi4uLCBlcnJwKTsKKyAqICAgICBpZiAocmV0IDwgMCkgeworICogICAgICAgICAuLi4g aGFuZGxlIGVycm9yIC4uLgorICogICAgICAgICByZXR1cm4gcmV0OworICogICAgIH0KKyAqCisg KiBJZiBhIGZ1bmN0aW9uIHJldHVybnMgbm90aGluZyAobm90IHJlY29tbWVuZGVkIGZvciBuZXcg Y29kZSksIHRoZSBvbmx5IHdheQorICogdG8gY2hlY2sgc3VjY2VzcyBpcyBieSBjb25zdWx0aW5n IGVycnA7IGRvaW5nIHRoaXMgc2FmZWx5IHJlcXVpcmVzIHRoZSB1c2UKKyAqIG9mIHRoZSBFUlJQ X0FVVE9fUFJPUEFHQVRFIG1hY3JvLCBsaWtlIHRoaXM6CisgKgorICogICAgIGludCBvdXJfZnVu YyguLi4sIEVycm9yICoqZXJycCkgeworICogICAgICAgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7 CisgKiAgICAgICAgIC4uLgorICogICAgICAgICBzdWJjYWxsKC4uLiwgZXJycCk7CisgKiAgICAg ICAgIGlmICgqZXJycCkgeworICogICAgICAgICAgICAgLi4uCisgKiAgICAgICAgICAgICByZXR1 cm4gLUVJTlZBTDsKKyAqICAgICAgICAgfQorICogICAgICAgICAuLi4KKyAqICAgICB9CisgKgor ICogRVJSUF9BVVRPX1BST1BBR0FURSB0YWtlcyBjYXJlIG9mIHdyYXBwaW5nIHRoZSBvcmlnaW5h bCBlcnJwIGFzIG5lZWRlZCwgc28KKyAqIHRoYXQgdGhlIHJlc3Qgb2YgdGhlIGZ1bmN0aW9uIGNh biBkaXJlY3RseSB1c2UgZXJycCAoaW5jbHVkaW5nCisgKiBkZXJlZmVyZW5jaW5nKSwgd2hlcmUg YW55IGVycm9ycyB3aWxsIHRoZW4gYmUgcHJvcGFnYXRlZCBvbiB0byB0aGUgb3JpZ2luYWwKKyAq IGVycnAgd2hlbiBsZWF2aW5nIHRoZSBmdW5jdGlvbi4KKyAqCisgKiBJbiBzb21lIGNhc2VzLCB3 ZSBuZWVkIHRvIGNoZWNrIHJlc3VsdCBvZiBzdWJjYWxsLCBidXQgZG8gbm90IHdhbnQgdG8KKyAq IHByb3BhZ2F0ZSB0aGUgRXJyb3Igb2JqZWN0IHRvIG91ciBjYWxsZXIuIEluIHN1Y2ggY2FzZXMg d2UgZG9uJ3QgbmVlZAorICogRVJSUF9BVVRPX1BST1BBR0FURSwgYnV0IGp1c3QgYSBsb2NhbCBF cnJvciBvYmplY3Q6CisgKgorICogUmVjZWl2ZSBhbiBlcnJvciBhbmQgbm90IHBhc3MgaXQ6CiAg KiAgICAgRXJyb3IgKmVyciA9IE5VTEw7Ci0gKiAgICAgZm9vKGFyZywgJmVycik7CisgKiAgICAg c3ViY2FsbChhcmcsICZlcnIpOwogICogICAgIGlmIChlcnIpIHsKICAqICAgICAgICAgaGFuZGxl IHRoZSBlcnJvci4uLgorICogICAgICAgICBlcnJvcl9mcmVlKGVycik7CiAgKiAgICAgfQogICoK KyAqIE5vdGUgdGhhdCBvbGRlciBjb2RlIHRoYXQgZGlkIG5vdCB1c2UgRVJSUF9BVVRPX1BST1BB R0FURSB3b3VsZCBpbnN0ZWFkIG5lZWQKKyAqIGEgbG9jYWwgRXJyb3IgKiB2YXJpYWJsZSBhbmQg dGhlIHVzZSBvZiBlcnJvcl9wcm9wYWdhdGUoKSB0byBwcm9wZXJseSBoYW5kbGUKKyAqIGFsbCBw b3NzaWJsZSBjYWxsZXIgdmFsdWVzIG9mIGVycnAuIE5vdyB0aGlzIGlzIERFUFJFQ0FURUQqIChz ZWUgYmVsb3cpLgorICoKKyAqIE5vdGUgdGhhdCBhbnkgZnVuY3Rpb24gdGhhdCB3YW50cyB0byBt b2RpZnkgYW4gZXJyb3Igb2JqZWN0LCBzdWNoIGFzIGJ5CisgKiBjYWxsaW5nIGVycm9yX2FwcGVu ZF9oaW50IG9yIGVycm9yX3ByZXBlbmQsIG11c3QgdXNlIEVSUlBfQVVUT19QUk9QQUdBVEUsIGlu CisgKiBvcmRlciBmb3IgYSBjYWxsZXIncyB1c2Ugb2YgJmVycm9yX2ZhdGFsIHRvIHNlZSB0aGUg YWRkaXRpb25hbCBpbmZvcm1hdGlvbi4KKyAqCisgKiBJbiByYXJlIGNhc2VzLCB3ZSBuZWVkIHRv IHBhc3MgZXhpc3RpbmcgRXJyb3Igb2JqZWN0IHRvIHRoZSBjYWxsZXIgYnkgaGFuZDoKKyAqICAg ICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgZXJyKTsKKyAqCisgKiBQYXNzIGFuIGV4aXN0aW5nIGVy cm9yIHRvIHRoZSBjYWxsZXIgd2l0aCB0aGUgbWVzc2FnZSBtb2RpZmllZDoKKyAqICAgICBlcnJv cl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCBlcnIpOworICoKKyAqCiAgKiBDYWxsIGEgZnVuY3Rp b24gaWdub3JpbmcgZXJyb3JzOgogICogICAgIGZvbyhhcmcsIE5VTEwpOwogICoKQEAgLTc4LDI2 ICsxNDMsNiBAQAogICogQ2FsbCBhIGZ1bmN0aW9uIHRyZWF0aW5nIGVycm9ycyBhcyBmYXRhbDoK ICAqICAgICBmb28oYXJnLCAmZXJyb3JfZmF0YWwpOwogICoKLSAqIFJlY2VpdmUgYW4gZXJyb3Ig YW5kIHBhc3MgaXQgb24gdG8gdGhlIGNhbGxlcjoKLSAqICAgICBFcnJvciAqZXJyID0gTlVMTDsK LSAqICAgICBmb28oYXJnLCAmZXJyKTsKLSAqICAgICBpZiAoZXJyKSB7Ci0gKiAgICAgICAgIGhh bmRsZSB0aGUgZXJyb3IuLi4KLSAqICAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGVycik7 Ci0gKiAgICAgfQotICogd2hlcmUgRXJyb3IgKiplcnJwIGlzIGEgcGFyYW1ldGVyLCBieSBjb252 ZW50aW9uIHRoZSBsYXN0IG9uZS4KLSAqCi0gKiBEbyAqbm90KiAib3B0aW1pemUiIHRoaXMgdG8K LSAqICAgICBmb28oYXJnLCBlcnJwKTsKLSAqICAgICBpZiAoKmVycnApIHsgLy8gV1JPTkchCi0g KiAgICAgICAgIGhhbmRsZSB0aGUgZXJyb3IuLi4KLSAqICAgICB9Ci0gKiBiZWNhdXNlIGVycnAg bWF5IGJlIE5VTEwhCi0gKgotICogQnV0IHdoZW4gYWxsIHlvdSBkbyB3aXRoIHRoZSBlcnJvciBp cyBwYXNzIGl0IG9uLCBwbGVhc2UgdXNlCi0gKiAgICAgZm9vKGFyZywgZXJycCk7Ci0gKiBmb3Ig cmVhZGFiaWxpdHkuCi0gKgogICogUmVjZWl2ZSBhbmQgYWNjdW11bGF0ZSBtdWx0aXBsZSBlcnJv cnMgKGZpcnN0IG9uZSB3aW5zKToKICAqICAgICBFcnJvciAqZXJyID0gTlVMTCwgKmxvY2FsX2Vy ciA9IE5VTEw7CiAgKiAgICAgZm9vKGFyZywgJmVycik7CkBAIC0xMTQsNiArMTU5LDYxIEBACiAg KiAgICAgICAgIGhhbmRsZSB0aGUgZXJyb3IuLi4KICAqICAgICB9CiAgKiBiZWNhdXNlIHRoaXMg bWF5IHBhc3MgYSBub24tbnVsbCBlcnIgdG8gYmFyKCkuCisgKgorICogREVQUkVDQVRFRCoKKyAq CisgKiBUaGUgZm9sbG93aW5nIHBhdHRlcm4gb2YgcmVjZWl2aW5nLCBjaGVja2luZywgYW5kIHRo ZW4gZm9yd2FyZGluZyBhbiBlcnJvcgorICogdG8gdGhlIGNhbGxlciBieSBoYW5kIGlzIG5vdyBk ZXByZWNhdGVkOgorICoKKyAqICAgICBFcnJvciAqZXJyID0gTlVMTDsKKyAqICAgICBmb28oYXJn LCAmZXJyKTsKKyAqICAgICBpZiAoZXJyKSB7CisgKiAgICAgICAgIGhhbmRsZSB0aGUgZXJyb3Iu Li4KKyAqICAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGVycik7CisgKiAgICAgfQorICoK KyAqIEluc3RlYWQsIHVzZSBFUlJQX0FVVE9fUFJPUEFHQVRFIG1hY3JvLgorICoKKyAqIFRoZSBv bGQgcGF0dGVybiBpcyBkZXByZWNhdGVkIGJlY2F1c2Ugb2YgdHdvIHRoaW5nczoKKyAqCisgKiAx LiBJc3N1ZSB3aXRoIGVycm9yX2Fib3J0IGFuZCBlcnJvcl9wcm9wYWdhdGU6IHdoZW4gd2Ugd3Jh cCBlcnJvcl9hYm9ydCBieQorICogbG9jYWxfZXJyK2Vycm9yX3Byb3BhZ2F0ZSwgdGhlIHJlc3Vs dGluZyBjb3JlZHVtcCB3aWxsIHJlZmVyIHRvCisgKiBlcnJvcl9wcm9wYWdhdGUgYW5kIG5vdCB0 byB0aGUgcGxhY2Ugd2hlcmUgZXJyb3IgaGFwcGVuZWQuCisgKgorICogMi4gQSBsb3Qgb2YgZXh0 cmEgY29kZSBvZiB0aGUgc2FtZSBwYXR0ZXJuCisgKgorICogSG93IHRvIHVwZGF0ZSBvbGQgY29k ZSB0byB1c2UgRVJSUF9BVVRPX1BST1BBR0FURT8KKyAqCisgKiBBbGwgeW91IG5lZWQgaXMgdG8g YWRkIEVSUlBfQVVUT19QUk9QQUdBVEUoKSBpbnZvY2F0aW9uIGF0IGZ1bmN0aW9uIHN0YXJ0LAor ICogdGhhbiB5b3UgbWF5IHNhZmVseSBkZXJlZmVyZW5jZSBlcnJwIHRvIGNoZWNrIGVycm9ycyBh bmQgZG8gbm90IG5lZWQgYW55CisgKiBhZGRpdGlvbmFsIGxvY2FsIEVycm9yIHZhcmlhYmxlcyBv ciBjYWxscyB0byBlcnJvcl9wcm9wYWdhdGUoKS4KKyAqCisgKiBFeGFtcGxlOgorICoKKyAqIG9s ZCBjb2RlCisgKgorICogICAgIHZvaWQgZm4oLi4uLCBFcnJvciAqKmVycnApIHsKKyAqICAgICAg ICAgRXJyb3IgKmVyciA9IE5VTEw7CisgKiAgICAgICAgIGZvbyhhcmcsICZlcnIpOworICogICAg ICAgICBpZiAoZXJyKSB7CisgKiAgICAgICAgICAgICBoYW5kbGUgdGhlIGVycm9yLi4uCisgKiAg ICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgZXJyKTsKKyAqICAgICAgICAgICAgIHJl dHVybjsKKyAqICAgICAgICAgfQorICogICAgICAgICAuLi4KKyAqICAgICB9CisgKgorICogdXBk YXRlZCBjb2RlCisgKgorICogICAgIHZvaWQgZm4oLi4uLCBFcnJvciAqKmVycnApIHsKKyAqICAg ICAgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOworICogICAgICAgICBmb28oYXJnLCBlcnJwKTsK KyAqICAgICAgICAgaWYgKCplcnJwKSB7CisgKiAgICAgICAgICAgICBoYW5kbGUgdGhlIGVycm9y Li4uCisgKiAgICAgICAgICAgICByZXR1cm47CisgKiAgICAgICAgIH0KKyAqICAgICAgICAgLi4u CisgKiAgICAgfQogICovCiAKICNpZm5kZWYgRVJST1JfSApAQCAtMzIyLDYgKzQyMiw0NyBAQCB2 b2lkIGVycm9yX3NldF9pbnRlcm5hbChFcnJvciAqKmVycnAsCiAgICAgICAgICAgICAgICAgICAg ICAgICBFcnJvckNsYXNzIGVycl9jbGFzcywgY29uc3QgY2hhciAqZm10LCAuLi4pCiAgICAgR0ND X0ZNVF9BVFRSKDYsIDcpOwogCit0eXBlZGVmIHN0cnVjdCBFcnJvclByb3BhZ2F0b3IgeworICAg IEVycm9yICpsb2NhbF9lcnI7CisgICAgRXJyb3IgKiplcnJwOworfSBFcnJvclByb3BhZ2F0b3I7 CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBlcnJvcl9wcm9wYWdhdG9yX2NsZWFudXAoRXJyb3JQcm9w YWdhdG9yICpwcm9wKQoreworICAgIGVycm9yX3Byb3BhZ2F0ZShwcm9wLT5lcnJwLCBwcm9wLT5s b2NhbF9lcnIpOworfQorCitHX0RFRklORV9BVVRPX0NMRUFOVVBfQ0xFQVJfRlVOQyhFcnJvclBy b3BhZ2F0b3IsIGVycm9yX3Byb3BhZ2F0b3JfY2xlYW51cCk7CisKKy8qCisgKiBFUlJQX0FVVE9f UFJPUEFHQVRFCisgKgorICogVGhpcyBtYWNybyBleGlzdHMgdG8gYXNzaXN0IHdpdGggcHJvcGVy IGVycm9yIGhhbmRsaW5nIGluIGEgZnVuY3Rpb24gd2hpY2gKKyAqIHVzZXMgYW4gRXJyb3IgKipl cnJwIHBhcmFtZXRlci4gIEl0IG11c3QgYmUgdXNlZCBhcyB0aGUgZmlyc3QgbGluZSBvZiBhCisg KiBmdW5jdGlvbiB3aGljaCBtb2RpZmllcyBhbiBlcnJvciAod2l0aCBlcnJvcl9wcmVwZW5kLCBl cnJvcl9hcHBlbmRfaGludCwgb3IKKyAqIHNpbWlsYXIpIG9yIHdoaWNoIHdhbnRzIHRvIGRlcmVm ZXJlbmNlICplcnJwLiAgSXQgaXMgc3RpbGwgc2FmZSAoYnV0CisgKiB1c2VsZXNzKSB0byB1c2Ug aW4gb3RoZXIgZnVuY3Rpb25zLgorICoKKyAqIElmIGVycnAgaXMgTlVMTCBvciBwb2ludHMgdG8g ZXJyb3JfZmF0YWwsIGl0IGlzIHJld3JpdHRlbiB0byBwb2ludCB0byBhCisgKiBsb2NhbCBFcnJv ciBvYmplY3QsIHdoaWNoIHdpbGwgYmUgYXV0b21hdGljYWxseSBwcm9wYWdhdGVkIHRvIHRoZSBv cmlnaW5hbAorICogZXJycCBvbiBmdW5jdGlvbiBleGl0IChzZWUgZXJyb3JfcHJvcGFnYXRvcl9j bGVhbnVwKS4KKyAqCisgKiBBZnRlciBpbnZvY2F0aW9uIG9mIHRoaXMgbWFjcm8gaXQgaXMgYWx3 YXlzIHNhZmUgdG8gZGVyZWZlcmVuY2UgZXJycAorICogKGFzIGl0J3Mgbm90IE5VTEwgYW55bW9y ZSkgYW5kIHRvIGFkZCBpbmZvcm1hdGlvbiBieSBlcnJvcl9wcmVwZW5kIG9yCisgKiBlcnJvcl9h cHBlbmRfaGludCAoYXMsIGlmIGl0IHdhcyBlcnJvcl9mYXRhbCwgd2Ugc3dhcHBlZCBpdCB3aXRo IGEKKyAqIGxvY2FsX2Vycm9yIHRvIGJlIHByb3BhZ2F0ZWQgb24gY2xlYW51cCkuCisgKgorICog Tm90ZTogd2UgZG9uJ3Qgd3JhcCB0aGUgZXJyb3JfYWJvcnQgY2FzZSwgYXMgd2Ugd2FudCByZXN1 bHRpbmcgY29yZWR1bXAKKyAqIHRvIHBvaW50IHRvIHRoZSBwbGFjZSB3aGVyZSB0aGUgZXJyb3Ig aGFwcGVuZWQsIG5vdCB0byBlcnJvcl9wcm9wYWdhdGUuCisgKi8KKyNkZWZpbmUgRVJSUF9BVVRP X1BST1BBR0FURSgpIFwKKyAgICBnX2F1dG8oRXJyb3JQcm9wYWdhdG9yKSBfYXV0b19lcnJwX3By b3AgPSB7LmVycnAgPSBlcnJwfTsgXAorICAgIGRvIHsgXAorICAgICAgICBpZiAoIWVycnAgfHwg ZXJycCA9PSAmZXJyb3JfZmF0YWwpIHsgXAorICAgICAgICAgICAgZXJycCA9ICZfYXV0b19lcnJw X3Byb3AubG9jYWxfZXJyOyBcCisgICAgICAgIH0gXAorICAgIH0gd2hpbGUgKDApCisKIC8qCiAg KiBTcGVjaWFsIGVycm9yIGRlc3RpbmF0aW9uIHRvIGFib3J0IG9uIGVycm9yLgogICogU2VlIGVy cm9yX3NldGcoKSBhbmQgZXJyb3JfcHJvcGFnYXRlKCkgZm9yIGRldGFpbHMuCi0tIAoyLjIxLjAK CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2 ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xp c3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 35F8AC5ACBF for ; Thu, 12 Mar 2020 09:03:13 +0000 (UTC) Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id F39DD2071C for ; Thu, 12 Mar 2020 09:03:12 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F39DD2071C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=virtuozzo.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Received: from localhost ([::1]:37966 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jCJkG-0004Q1-1r for qemu-devel@archiver.kernel.org; Thu, 12 Mar 2020 05:03:12 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:51632) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jCJhI-00074V-4Y for qemu-devel@nongnu.org; Thu, 12 Mar 2020 05:00:10 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1jCJhB-0004s7-Qp for qemu-devel@nongnu.org; Thu, 12 Mar 2020 05:00:08 -0400 Received: from relay.sw.ru ([185.231.240.75]:48452) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1jCJhB-0004qi-FP for qemu-devel@nongnu.org; Thu, 12 Mar 2020 05:00:01 -0400 Received: from vovaso.qa.sw.ru ([10.94.3.0] helo=kvm.qa.sw.ru) by relay.sw.ru with esmtp (Exim 4.92.3) (envelope-from ) id 1jCJgs-0004Ve-Uu; Thu, 12 Mar 2020 11:59:43 +0300 From: Vladimir Sementsov-Ogievskiy To: qemu-devel@nongnu.org Subject: [PATCH v9 01/10] error: auto propagated local_err Date: Thu, 12 Mar 2020 11:59:27 +0300 Message-Id: <20200312085936.9552-2-vsementsov@virtuozzo.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20200312085936.9552-1-vsementsov@virtuozzo.com> References: <20200312085936.9552-1-vsementsov@virtuozzo.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x [fuzzy] X-Received-From: 185.231.240.75 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , vsementsov@virtuozzo.com, Laszlo Ersek , qemu-block@nongnu.org, Paul Durrant , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Christian Schoenebeck , Greg Kurz , armbru@redhat.com, Stefano Stabellini , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Michael Roth , Stefan Berger Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" Introduce a new 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). Signed-off-by: Vladimir Sementsov-Ogievskiy Reviewed-by: Paul Durrant Reviewed-by: Greg Kurz Reviewed-by: Eric Blake --- Cc: Eric Blake Cc: Kevin Wolf Cc: Max Reitz Cc: Greg Kurz Cc: Christian Schoenebeck Cc: Stefano Stabellini Cc: Anthony Perard Cc: Paul Durrant Cc: Stefan Hajnoczi Cc: "Philippe Mathieu-Daudé" Cc: Laszlo Ersek Cc: Gerd Hoffmann Cc: Stefan Berger Cc: Markus Armbruster Cc: Michael Roth Cc: qemu-devel@nongnu.org Cc: qemu-block@nongnu.org Cc: xen-devel@lists.xenproject.org include/qapi/error.h | 205 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 173 insertions(+), 32 deletions(-) diff --git a/include/qapi/error.h b/include/qapi/error.h index ad5b6e896d..30140d9bfe 100644 --- a/include/qapi/error.h +++ b/include/qapi/error.h @@ -15,6 +15,8 @@ /* * Error reporting system loosely patterned after Glib's GError. * + * = Deal with Error object = + * * Create an error: * error_setg(&err, "situation normal, all fouled up"); * @@ -47,28 +49,91 @@ * reporting it (primarily useful in testsuites): * error_free_or_abort(&err); * - * Pass an existing error to the caller: - * error_propagate(errp, err); - * where Error **errp is a parameter, by convention the last one. + * = Deal with Error ** function parameter = * - * Pass an existing error to the caller with the message modified: - * error_propagate_prepend(errp, err); + * A function may use the error system to return errors. In this case, the + * function defines an Error **errp parameter, by convention the last one (with + * exceptions for functions using ... or va_list). * - * Avoid - * error_propagate(errp, err); - * error_prepend(errp, "Could not frobnicate '%s': ", name); - * because this fails to prepend when @errp is &error_fatal. + * The caller may then pass in the following errp values: * - * Create a new error and pass it to the caller: + * 1. &error_abort + * Any error will result in abort(). + * 2. &error_fatal + * Any error will result in exit() with a non-zero status. + * 3. NULL + * No error reporting through errp parameter. + * 4. The address of a NULL-initialized Error *err + * Any error will populate errp with an error object. + * + * The following rules then implement the correct semantics desired by the + * caller. + * + * Create a new error to pass to the caller: * error_setg(errp, "situation normal, all fouled up"); * - * Call a function and receive an error from it: + * Calling another errp-based function: + * f(..., errp); + * + * == Checking success of subcall == + * + * If a function returns a value indicating an error in addition to setting + * errp (which is recommended), then you don't need any additional code, just + * do: + * + * int ret = f(..., errp); + * if (ret < 0) { + * ... handle error ... + * return ret; + * } + * + * If a function returns nothing (not recommended for new code), the only way + * to check success is by consulting errp; doing this safely requires the use + * of the ERRP_AUTO_PROPAGATE macro, like this: + * + * int our_func(..., Error **errp) { + * ERRP_AUTO_PROPAGATE(); + * ... + * subcall(..., errp); + * if (*errp) { + * ... + * return -EINVAL; + * } + * ... + * } + * + * ERRP_AUTO_PROPAGATE takes care of wrapping the original errp as needed, so + * that the rest of the function can directly use errp (including + * dereferencing), where any errors will then be propagated on to the original + * errp when leaving the function. + * + * In some cases, we need to check result of subcall, but do not want to + * propagate the Error object to our caller. In such cases we don't need + * ERRP_AUTO_PROPAGATE, but just a local Error object: + * + * Receive an error and not pass it: * Error *err = NULL; - * foo(arg, &err); + * subcall(arg, &err); * if (err) { * handle the error... + * error_free(err); * } * + * Note that older code that did not use ERRP_AUTO_PROPAGATE would instead need + * a local Error * variable and the use of error_propagate() to properly handle + * all possible caller values of errp. Now this is DEPRECATED* (see below). + * + * Note that any function that wants to modify an error object, such as by + * calling error_append_hint or error_prepend, must use ERRP_AUTO_PROPAGATE, in + * order for a caller's use of &error_fatal to see the additional information. + * + * In rare cases, we need to pass existing Error object to the caller by hand: + * error_propagate(errp, err); + * + * Pass an existing error to the caller with the message modified: + * error_propagate_prepend(errp, err); + * + * * Call a function ignoring errors: * foo(arg, NULL); * @@ -78,26 +143,6 @@ * Call a function treating errors as fatal: * foo(arg, &error_fatal); * - * Receive an error and pass it on to the caller: - * Error *err = NULL; - * foo(arg, &err); - * if (err) { - * handle the error... - * error_propagate(errp, err); - * } - * where Error **errp is a parameter, by convention the last one. - * - * Do *not* "optimize" this to - * foo(arg, errp); - * if (*errp) { // WRONG! - * handle the error... - * } - * because errp may be NULL! - * - * But when all you do with the error is pass it on, please use - * foo(arg, errp); - * for readability. - * * Receive and accumulate multiple errors (first one wins): * Error *err = NULL, *local_err = NULL; * foo(arg, &err); @@ -114,6 +159,61 @@ * handle the error... * } * because this may pass a non-null err to bar(). + * + * DEPRECATED* + * + * The following pattern of receiving, checking, and then forwarding an error + * to the caller by hand is now deprecated: + * + * Error *err = NULL; + * foo(arg, &err); + * if (err) { + * handle the error... + * error_propagate(errp, err); + * } + * + * Instead, use ERRP_AUTO_PROPAGATE macro. + * + * The old pattern is 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; + * } + * ... + * } */ #ifndef ERROR_H @@ -322,6 +422,47 @@ 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 exists to assist with proper error handling in a function which + * uses an Error **errp parameter. It must be used as the first line of a + * function which modifies an error (with error_prepend, error_append_hint, or + * similar) or which wants to dereference *errp. It is still safe (but + * useless) to use in other functions. + * + * 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}; \ + do { \ + if (!errp || errp == &error_fatal) { \ + errp = &_auto_errp_prop.local_err; \ + } \ + } while (0) + /* * Special error destination to abort on error. * See error_setg() and error_propagate() for details. -- 2.21.0