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=-6.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS 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 1938BC10DCE for ; Thu, 12 Mar 2020 16:37:21 +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 D33CD2067C for ; Thu, 12 Mar 2020 16:37:20 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="LsM/VQPd" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D33CD2067C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.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 1jCQpO-0004Hq-Bj; Thu, 12 Mar 2020 16:36:58 +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 1jCQpM-0004Hh-9a for xen-devel@lists.xenproject.org; Thu, 12 Mar 2020 16:36:56 +0000 X-Inumbo-ID: aef42d0b-647f-11ea-b1d8-12813bfff9fa Received: from us-smtp-1.mimecast.com (unknown [207.211.31.120]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTP id aef42d0b-647f-11ea-b1d8-12813bfff9fa; Thu, 12 Mar 2020 16:36:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584031014; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=BRQCQPh/dzQo+naMawCQ0skDcQhN3Y2gStxLEo2Ml58=; b=LsM/VQPdfwmIvFZeM7sadpi/N31x4X8GV3Vp4x0lTvvO6kV8fhdrNYL+32kAy3RNcAUKbO zw6+Nse0nB2SYkcfv/i6CXNUlDQsbe23YMeXGjk7T/7lovb0yPYDJW22GXnzVcRct5nWCE 0SCdmbTbFW7sgv9ydDkb8bftYtqsncA= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-453-qx6OiUWbNKi4-2iyASGY2g-1; Thu, 12 Mar 2020 12:36:43 -0400 X-MC-Unique: qx6OiUWbNKi4-2iyASGY2g-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id E45111005509; Thu, 12 Mar 2020 16:36:40 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-116-34.ams2.redhat.com [10.36.116.34]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 31BFC9CA3; Thu, 12 Mar 2020 16:36:35 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id B05D811386A6; Thu, 12 Mar 2020 17:36:33 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy References: <20200312085936.9552-1-vsementsov@virtuozzo.com> <20200312085936.9552-3-vsementsov@virtuozzo.com> Date: Thu, 12 Mar 2020 17:36:33 +0100 In-Reply-To: <20200312085936.9552-3-vsementsov@virtuozzo.com> (Vladimir Sementsov-Ogievskiy's message of "Thu, 12 Mar 2020 11:59:28 +0300") Message-ID: <874kuto7hq.fsf@dusky.pond.sub.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.3 (gnu/linux) MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Subject: Re: [Xen-devel] [PATCH v9 02/10] scripts: Coccinelle script to use ERRP_AUTO_PROPAGATE() 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 , Stefano Stabellini , Michael Roth , qemu-block@nongnu.org, Paul Durrant , Laszlo Ersek , Christian Schoenebeck , qemu-devel@nongnu.org, Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , armbru@redhat.com, Stefan Berger Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" SSBtYXkgaGF2ZSBhIHNlY29uZCBsb29rIHRvbW9ycm93IHdpdGggZnJlc2hlciBleWVzLCBidXQg bGV0J3MgZ2V0IHRoaXMKb3V0IG5vdyBhcyBpcy4KClZsYWRpbWlyIFNlbWVudHNvdi1PZ2lldnNr aXkgPHZzZW1lbnRzb3ZAdmlydHVvenpvLmNvbT4gd3JpdGVzOgoKPiBTY3JpcHQgYWRkcyBFUlJQ X0FVVE9fUFJPUEFHQVRFIG1hY3JvIGludm9jYXRpb24gd2hlcmUgYXBwcm9wcmlhdGUgYW5kCj4g ZG9lcyBjb3JyZXNwb25kaW5nIGNoYW5nZXMgaW4gY29kZSAobG9vayBmb3IgZGV0YWlscyBpbgo+ IGluY2x1ZGUvcWFwaS9lcnJvci5oKQo+Cj4gVXNhZ2UgZXhhbXBsZToKPiBzcGF0Y2ggLS1zcC1m aWxlIHNjcmlwdHMvY29jY2luZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSBcCj4gIC0t bWFjcm8tZmlsZSBzY3JpcHRzL2NvY2NpLW1hY3JvLWZpbGUuaCAtLWluLXBsYWNlIC0tbm8tc2hv dy1kaWZmIFwKPiAgLS1tYXgtd2lkdGggODAgRklMRVMuLi4KPgo+IFNpZ25lZC1vZmYtYnk6IFZs YWRpbWlyIFNlbWVudHNvdi1PZ2lldnNraXkgPHZzZW1lbnRzb3ZAdmlydHVvenpvLmNvbT4KPiAt LS0KPgo+IENjOiBFcmljIEJsYWtlIDxlYmxha2VAcmVkaGF0LmNvbT4KPiBDYzogS2V2aW4gV29s ZiA8a3dvbGZAcmVkaGF0LmNvbT4KPiBDYzogTWF4IFJlaXR6IDxtcmVpdHpAcmVkaGF0LmNvbT4K PiBDYzogR3JlZyBLdXJ6IDxncm91Z0BrYW9kLm9yZz4KPiBDYzogQ2hyaXN0aWFuIFNjaG9lbmVi ZWNrIDxxZW11X29zc0BjcnVkZWJ5dGUuY29tPgo+IENjOiBTdGVmYW5vIFN0YWJlbGxpbmkgPHNz dGFiZWxsaW5pQGtlcm5lbC5vcmc+Cj4gQ2M6IEFudGhvbnkgUGVyYXJkIDxhbnRob255LnBlcmFy ZEBjaXRyaXguY29tPgo+IENjOiBQYXVsIER1cnJhbnQgPHBhdWxAeGVuLm9yZz4KPiBDYzogU3Rl ZmFuIEhham5vY3ppIDxzdGVmYW5oYUByZWRoYXQuY29tPgo+IENjOiAiUGhpbGlwcGUgTWF0aGll dS1EYXVkw6kiIDxwaGlsbWRAcmVkaGF0LmNvbT4KPiBDYzogTGFzemxvIEVyc2VrIDxsZXJzZWtA cmVkaGF0LmNvbT4KPiBDYzogR2VyZCBIb2ZmbWFubiA8a3JheGVsQHJlZGhhdC5jb20+Cj4gQ2M6 IFN0ZWZhbiBCZXJnZXIgPHN0ZWZhbmJAbGludXguaWJtLmNvbT4KPiBDYzogTWFya3VzIEFybWJy dXN0ZXIgPGFybWJydUByZWRoYXQuY29tPgo+IENjOiBNaWNoYWVsIFJvdGggPG1kcm90aEBsaW51 eC52bmV0LmlibS5jb20+Cj4gQ2M6IHFlbXUtZGV2ZWxAbm9uZ251Lm9yZwo+IENjOiBxZW11LWJs b2NrQG5vbmdudS5vcmcKPiBDYzogeGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCj4KPiAg c2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2NpIHwgMzI3ICsrKysr KysrKysrKysrKysrKwo+ICBpbmNsdWRlL3FhcGkvZXJyb3IuaCAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgIDMgKwo+ICBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgIDEgKwo+ICAzIGZpbGVzIGNoYW5nZWQsIDMzMSBpbnNlcnRpb25zKCspCj4gIGNy ZWF0ZSBtb2RlIDEwMDY0NCBzY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAu Y29jY2kKPgo+IGRpZmYgLS1naXQgYS9zY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVk LWVycnAuY29jY2kgYi9zY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29j Y2kKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAuLjdkYWMyZGNmYTQK PiAtLS0gL2Rldi9udWxsCj4gKysrIGIvc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRl ZC1lcnJwLmNvY2NpCj4gQEAgLTAsMCArMSwzMjcgQEAKPiArLy8gVXNlIEVSUlBfQVVUT19QUk9Q QUdBVEUgKHNlZSBpbmNsdWRlL3FhcGkvZXJyb3IuaCkKPiArLy8KPiArLy8gQ29weXJpZ2h0IChj KSAyMDIwIFZpcnR1b3p6byBJbnRlcm5hdGlvbmFsIEdtYkguCj4gKy8vCj4gKy8vIFRoaXMgcHJv Z3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKPiAr Ly8gbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgYXMKPiArLy8gcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlCj4gKy8vIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCj4gKy8vCj4gKy8vIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAo+ICsvLyBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsv LyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBT ZWUgdGhlCj4gKy8vIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu Cj4gKy8vCj4gKy8vIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCj4gKy8vIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYg bm90LCBzZWUKPiArLy8gPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+Lgo+ICsvLwo+ICsv LyBVc2FnZSBleGFtcGxlOgo+ICsvLyBzcGF0Y2ggLS1zcC1maWxlIHNjcmlwdHMvY29jY2luZWxs ZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSBcCj4gKy8vICAtLW1hY3JvLWZpbGUgc2NyaXB0 cy9jb2NjaS1tYWNyby1maWxlLmggLS1pbi1wbGFjZSBcCj4gKy8vICAtLW5vLXNob3ctZGlmZiAt LW1heC13aWR0aCA4MCBGSUxFUy4uLgo+ICsvLwo+ICsvLyBOb3RlOiAtLW1heC13aWR0aCA4MCBp cyBuZWVkZWQgYmVjYXVzZSBjb2NjaW5lbGxlIGRlZmF1bHQgaXMgbGVzcwo+ICsvLyB0aGFuIDgw LCBhbmQgd2l0aG91dCB0aGlzIHBhcmFtZXRlciBjb2NjaW5lbGxlIG1heSByZWluZGVudCBzb21l Cj4gKy8vIGxpbmVzIHdoaWNoIGZpdCBpbnRvIDgwIGNoYXJhY3RlcnMgYnV0IG5vdCB0byBjb2Nj aW5lbGxlIGRlZmF1bHQsCj4gKy8vIHdoaWNoIGluIHR1cm4gcHJvZHVjZXMgZXh0cmEgcGF0Y2gg aHVua3MgZm9yIG5vIHJlYXNvbi4KClRoaXMgaXMgYWJvdXQgdW53YW50ZWQgcmVmb3JtYXR0aW5n IG9mIHBhcmFtZXRlciBsaXN0cyBkdWUgdG8gdGhlIF9fXwpjaGFpbmluZyBoYWNrLiAgLS1tYXgt d2lkdGggODAgbWFrZXMgdGhhdCBsZXNzIGxpa2VseSwgYnV0IG5vdAppbXBvc3NpYmxlLgoKV2Ug Y2FuIHNlYXJjaCBmb3IgdW53YW50ZWQgcmVmb3JtYXR0aW5nIG9mIHBhcmFtZXRlciBsaXN0cy4g IEkgdGhpbmsKZ3JlcHBpbmcgZGlmZnMgZm9yICdeXCsuKkVycm9yIFwqXConIHNob3VsZCBkbyB0 aGUgdHJpY2suICBGb3IgdGhlIHdob2xlCnRyZWUsIEkgZ2V0IG9uZSBmYWxzZSBwb3NpdGl2ZSAo bm90IGEgcGFyYW1ldGVyIGxpc3QpLCBhbmQgb25lIGhpdDoKCiAgICBAQCAtMzg4LDggKzM4OCwx MCBAQCBzdGF0aWMgdm9pZCBvYmplY3RfcG9zdF9pbml0X3dpdGhfdHlwZShPCiAgICAgICAgIH0K ICAgICB9CgogICAgLXZvaWQgb2JqZWN0X2FwcGx5X2dsb2JhbF9wcm9wcyhPYmplY3QgKm9iaiwg Y29uc3QgR1B0ckFycmF5ICpwcm9wcywgRXJyb3IgKiplcnJwKQogICAgK3ZvaWQgb2JqZWN0X2Fw cGx5X2dsb2JhbF9wcm9wcyhPYmplY3QgKm9iaiwgY29uc3QgR1B0ckFycmF5ICpwcm9wcywKICAg ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRXJyb3IgKiplcnJwKQogICAgIHsKICAg ICsgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgICAgICBpbnQgaTsKCiAgICAgICAgIGlm ICghcHJvcHMpIHsKClJlZm9ybWF0dGluZywgYnV0IG5vdCB1bndhbnRlZC4KClRoZSAtLW1heC13 aWR0aCA4MCBoYWNrIGlzIGdvb2QgZW5vdWdoIGZvciBtZS4KCkl0IGRvZXMgcmVzdWx0IGluIHNs aWdodGx5IGxvbmcgdHJhbnNmb3JtZWQgbGluZXMsIGUuZy4gdGhpcyBvbmUgaW4KcmVwbGljYXRp b24uYzoKCiAgICBAQCAtMTEzLDcgKzExMyw3IEBAIHN0YXRpYyBpbnQgcmVwbGljYXRpb25fb3Bl bihCbG9ja0RyaXZlclMKICAgICAgICAgICAgIHMtPm1vZGUgPSBSRVBMSUNBVElPTl9NT0RFX1BS SU1BUlk7CiAgICAgICAgICAgICB0b3BfaWQgPSBxZW11X29wdF9nZXQob3B0cywgUkVQTElDQVRJ T05fVE9QX0lEKTsKICAgICAgICAgICAgIGlmICh0b3BfaWQpIHsKICAgIC0gICAgICAgICAgICBl cnJvcl9zZXRnKCZsb2NhbF9lcnIsICJUaGUgcHJpbWFyeSBzaWRlIGRvZXMgbm90IHN1cHBvcnQg b3B0aW9uIHRvcC1pZCIpOwogICAgKyAgICAgICAgICAgIGVycm9yX3NldGcoZXJycCwgIlRoZSBw cmltYXJ5IHNpZGUgZG9lcyBub3Qgc3VwcG9ydCBvcHRpb24gdG9wLWlkIik7CiAgICAgICAgICAg ICAgICAgZ290byBmYWlsOwogICAgICAgICAgICAgfQogICAgICAgICB9IGVsc2UgaWYgKCFzdHJj bXAobW9kZSwgInNlY29uZGFyeSIpKSB7Cgp2OCBkaWQgYnJlYWsgdGhpcyBsaW5lICh0aGF0J3Mg aG93IEkgZm91bmQgaXQpLiAgSG93ZXZlciwgdjkgc3RpbGwKc2hvcnRlbnMgdGhlIGxpbmUsIGp1 c3Qgbm90IGJlbG93IHRoZSB0YXJnZXQuICBBbGwgeW91ciArIGxpbmVzIGxvb2sKcXVpdGUgdW5s aWtlbHkgdG8gbGVuZ3RoZW4gbGluZXMuICBMZXQncyBub3Qgd29ycnkgYWJvdXQgdGhpcy4KCj4g Ky8vIFN3aXRjaCB1bnVzdWFsIEVycm9yICoqIHBhcmFtZXRlciBuYW1lcyB0byBlcnJwCj4gKy8v ICh0aGlzIGlzIG5lY2Vzc2FyeSB0byB1c2UgRVJSUF9BVVRPX1BST1BBR0FURSkuCj4gKy8vCj4g Ky8vIERpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIHRvIHNraXAgZnVuY3Rpb25zIHdpdGgKPiAr Ly8gIkVycm9yICpjb25zdCAqZXJycCIgcGFyYW1ldGVyLgo+ICsvLwo+ICsvLyBTa2lwIGZ1bmN0 aW9ucyB3aXRoICJhc3NlcnQoX2VycnAgJiYgKl9lcnJwKSIgc3RhdGVtZW50LCBiZWNhdXNlCj4g Ky8vIHRoYXQgc2lnbmFscyB1bnVzdWFsIHNlbWFudGljcywgYW5kIHRoZSBwYXJhbWV0ZXIgbmFt ZSBtYXkgd2VsbAo+ICsvLyBzZXJ2ZSBhIHB1cnBvc2UuIChsaWtlIG5iZF9pdGVyX2NoYW5uZWxf ZXJyb3IoKSkuCj4gKy8vCj4gKy8vIFNraXAgdXRpbC9lcnJvci5jIHRvIG5vdCB0b3VjaCwgZm9y IGV4YW1wbGUsIGVycm9yX3Byb3BhZ2F0ZSgpIGFuZAo+ICsvLyBlcnJvcl9wcm9wYWdhdGVfcHJl cGVuZCgpLgo+ICtAIGRlcGVuZHMgb24gIShmaWxlIGluICJ1dGlsL2Vycm9yLmMiKSBkaXNhYmxl IG9wdGlvbmFsX3F1YWxpZmllckAKPiAraWRlbnRpZmllciBmbjsKPiAraWRlbnRpZmllciBfZXJy cCAhPSBlcnJwOwo+ICtAQAo+ICsKPiArIGZuKC4uLiwKPiArLSAgIEVycm9yICoqX2VycnAKPiAr KyAgIEVycm9yICoqZXJycAo+ICsgICAgLC4uLikKPiArIHsKPiArKAo+ICsgICAgIC4uLiB3aGVu ICE9IGFzc2VydChfZXJycCAmJiAqX2VycnApCj4gKyYKPiArICAgICA8Li4uCj4gKy0gICAgX2Vy cnAKPiArKyAgICBlcnJwCj4gKyAgICAgLi4uPgo+ICspCj4gKyB9Cj4gKwo+ICsvLyBBZGQgaW52 b2NhdGlvbiBvZiBFUlJQX0FVVE9fUFJPUEFHQVRFIHRvIGVycnAtZnVuY3Rpb25zIHdoZXJlCj4g Ky8vIG5lY2Vzc2FyeQo+ICsvLwo+ICsvLyBOb3RlLCB0aGF0IHdpdGhvdXQgIndoZW4gYW55IiB0 aGUgZmluYWwgIi4uLiIgZG9lcyBub3QgbWFjaAo+ICsvLyBzb21ldGhpbmcgbWF0Y2hlZCBieSBw cmV2aW91cyBwYXR0ZXJuLCBpLmUuIHRoZSBydWxlIHdpbGwgbm90IG1hdGNoCj4gKy8vIGRvdWJs ZSBlcnJvcl9wcmVwZW5kIGluIGNvbnRyb2wgZmxvdyBsaWtlIGluCj4gKy8vIHZmaW9fc2V0X2ly cV9zaWduYWxpbmcoKS4KPiArLy8KPiArLy8gTm90ZSwgImV4aXN0cyIgc2F5cyB0aGF0IHdlIHdh bnQgYXBwbHkgcnVsZSBldmVuIGlmIGl0IG1hdGNoZXMgbm90Cj4gKy8vIG9uIGFsbCBwb3NzaWJs ZSBjb250cm9sIGZsb3dzIChvdGhlcndpc2UsIGl0IHdpbGwgbm90IG1hdGNoCj4gKy8vIHN0YW5k YXJkIHBhdHRlcm4gd2hlbiBlcnJvcl9wcm9wYWdhdGUoKSBjYWxsIGlzIGluIGlmIGJyYW5jaCku Cj4gK0AgZGlzYWJsZSBvcHRpb25hbF9xdWFsaWZpZXIgZXhpc3RzQAo+ICtpZGVudGlmaWVyIGZu LCBsb2NhbF9lcnI7Cj4gK3N5bWJvbCBlcnJwOwo+ICtAQAo+ICsKPiArIGZuKC4uLiwgRXJyb3Ig KiplcnJwLCAuLi4pCj4gKyB7Cj4gKysgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7Cj4gKyAgICAu Li4gIHdoZW4gIT0gRVJSUF9BVVRPX1BST1BBR0FURSgpOwo+ICsoCj4gKygKPiArICAgIGVycm9y X2FwcGVuZF9oaW50KGVycnAsIC4uLik7Cj4gK3wKPiArICAgIGVycm9yX3ByZXBlbmQoZXJycCwg Li4uKTsKPiArfAo+ICsgICAgZXJyb3JfdnByZXBlbmQoZXJycCwgLi4uKTsKPiArKQo+ICsgICAg Li4uIHdoZW4gYW55Cj4gK3wKPiArICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwo+ICsgICAg Li4uCj4gKygKPiArICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2Vyciwg Li4uKTsKPiArfAo+ICsgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Cj4gKykK PiArICAgIC4uLgo+ICspCj4gKyB9Cj4gKwo+ICsKPiArLy8gTWF0Y2ggZnVuY3Rpb25zIHdpdGgg cHJvcGFnYXRpb24gb2YgbG9jYWwgZXJyb3IgdG8gZXJycC4KPiArLy8gV2Ugd2FudCB0byByZWZl ciB0aGVzZSBmdW5jdGlvbnMgaW4gc2V2ZXJhbCBmb2xsb3dpbmcgcnVsZXMsIGJ1dCBJCj4gKy8v IGRvbid0IGtub3cgYSBwcm9wZXIgd2F5IHRvIGluaGVyaXQgYSBmdW5jdGlvbiwgbm90IGp1c3Qg aXRzIG5hbWUKPiArLy8gKHRvIG5vdCBtYXRjaCBhbm90aGVyIGZ1bmN0aW9ucyB3aXRoIHNhbWUg bmFtZSBpbiBmb2xsb3dpbmcgcnVsZXMpLgo+ICsvLyBOb3QtcHJvcGVyIHdheSBpcyBhcyBmb2xs b3dzOiByZW5hbWUgZXJycCBwYXJhbWV0ZXIgaW4gZnVuY3Rpb25zCj4gKy8vIGhlYWRlciBhbmQg bWF0Y2ggaXQgaW4gZm9sbG93aW5nIHJ1bGVzLiBSZW5hbWUgaXQgYmFjayBhZnRlciBhbGwKPiAr Ly8gdHJhbnNmb3JtYXRpb25zLgo+ICsvLwo+ICsvLyBUaGUgc2ltcGxlc3QgY2FzZSBvZiBwcm9w YWdhdGlvbiBzY2hlbWUgaXMgc2luZ2xlIGRlZmluaXRpb24gb2YKPiArLy8gbG9jYWxfZXJyIHdp dGggYXQgbW9zdCBvbmUgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQgb3IKPiArLy8gZXJyb3JfcHJv cGFnYXRlIG9uIGVhY2ggY29udHJvbC1mbG93LiBTdGlsbCwgd2Ugd2FudCB0byBtYXRjaCBtb3Jl Cj4gKy8vIGNvbXBsZXggc2NoZW1lcyB0b28uIFdlJ2xsIHdhcm4gdGhlbSB3aXRoIGhlbHAgb2Yg ZnVydGhlciBydWxlcy4KCkkgdGhpbmsgd2hhdCB3ZSBhY3R1YWxseSB3YW50IGlzIHRvIGV4YW1p bmUgaW5zdGFuY2VzIG9mIHRoaXMgcGF0dGVybiB0bwpmaWd1cmUgb3V0IHdoZXRoZXIgYW5kIGhv dyB3ZSB3YW50IHRvIHRyYW5zZm9ybSB0aGVtLiAgUGVyaGFwczoKCiAgICAvLyBUaGUgY29tbW9u IGNhc2UgaXMgYSBzaW5nbGUgZGVmaW5pdGlvbiBvZiBsb2NhbF9lcnIgd2l0aCBhdCBtb3N0IG9u ZQogICAgLy8gZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoKSBvciBlcnJvcl9wcm9wYWdhdGUoKSBv biBlYWNoIGNvbnRyb2wtZmxvdwogICAgLy8gcGF0aC4gSW5zdGFuY2VzIG9mIHRoaXMgY2FzZSB3 ZSBjb252ZXJ0IHdpdGggdGhpcyBzY3JpcHQuIEZ1bmN0aW9ucwogICAgLy8gd2l0aCBtdWx0aXBs ZSBkZWZpbml0aW9ucyBvciBwcm9wYWdhdGVzIHdlIHdhbnQgdG8gZXhhbWluZQogICAgLy8gbWFu dWFsbHkuIExhdGVyIHJ1bGVzIGVtaXQgd2FybmluZ3MgdG8gZ3VpZGUgdXMgdG8gdGhlbS4KCj4g K0BydWxlMSBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4gK2lkZW50aWZpZXIg Zm4sIGxvY2FsX2VycjsKPiArc3ltYm9sIGVycnA7Cj4gK0BACj4gKwo+ICsgZm4oLi4uLCBFcnJv ciAqKgo+ICstICAgIGVycnAKPiArKyAgICBfX19fCj4gKyAgICAsIC4uLikKPiArIHsKPiArICAg ICAuLi4KPiArICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKPiArICAgICAuLi4KPiArKAo+ ICsgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgLi4uKTsKPiAr fAo+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwo+ICspCj4gKyAgICAg Li4uCj4gKyB9Cj4gKwo+ICsKPiArLy8gV2FybiBzZXZlcmFsIEVycm9yICogZGVmaW5pdGlvbnMu Cj4gK0BjaGVjazEgZGlzYWJsZSBvcHRpb25hbF9xdWFsaWZpZXIgZXhpc3RzQAo+ICtpZGVudGlm aWVyIGZuID0gcnVsZTEuZm4sIGxvY2FsX2VyciwgbG9jYWxfZXJyMjsKCkVsc2V3aGVyZSwgeW91 IHVzZSBqdXN0IHJ1bGUuZm4gaW5zdGVhZCBvZiBmbiA9IHJ1bGUxLmZuLiAgQW55CnBhcnRpY3Vs YXIgcmVhc29uIGZvciB0aGUgZGlmZmVyZW5jZT8KCldpdGggdGhlIF9fXyBjaGFpbmluZyBoYWNr LCBJIGRvdWJ0IHdlIHN0aWxsIG5lZWQgIj0gcnVsZTEuZm4iIG9yCiJydWxlMS5mbiIuICBJZiBJ IHJlcGxhY2UgImZuID0gcnVsZTEuZm4iIGFuZCAicnVsZS5mbiIgYnkganVzdCAiZm4iCmV2ZXJ5 d2hlcmUsIHRoZW4gYXBwbHkgdGhlIHNjcmlwdCB0byB0aGUgY29tcGxldGUgdHJlZSwgSSBnZXQg dGhlIHNhbWUKcmVzdWx0LgoKPiArQEAKPiArCj4gKyBmbiguLi4sIEVycm9yICoqIF9fX18sIC4u LikKPiArIHsKPiArICAgICAuLi4KPiArICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKPiAr ICAgICAuLi4gd2hlbiBhbnkKPiArICAgICBFcnJvciAqbG9jYWxfZXJyMiA9IE5VTEw7Cj4gKyAg ICAgLi4uIHdoZW4gYW55Cj4gKyB9Cj4gKwo+ICtAIHNjcmlwdDpweXRob24gQAo+ICtmbiA8PCBj aGVjazEuZm47Cj4gK0BACj4gKwo+ICtwcmludCgnV2FybmluZzogZnVuY3Rpb24ge30gaGFzIHNl dmVyYWwgZGVmaW5pdGlvbnMgb2YgJwo+ICsgICAgICAnRXJyb3IgKiBsb2NhbCB2YXJpYWJsZScu Zm9ybWF0KGZuKSkKPiArCj4gKy8vIFdhcm4gc2V2ZXJhbCBwcm9wYWdhdGlvbnMgaW4gY29udHJv bCBmbG93Lgo+ICtAY2hlY2syIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIGV4aXN0c0AKPiAr aWRlbnRpZmllciBmbiA9IHJ1bGUxLmZuOwo+ICtzeW1ib2wgZXJycDsKPiArcG9zaXRpb24gcDEs IHAyOwo+ICtAQAo+ICsKPiArIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+ICsgewo+ICsg ICAgIC4uLgo+ICsoCj4gKyAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgLi4uKTtA cDEKPiArfAo+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCAuLi4pO0BwMQo+ICspCj4gKyAg ICAgLi4uCj4gKygKPiArICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCAuLi4pO0Bw Mgo+ICt8Cj4gKyAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIC4uLik7QHAyCj4gKykKPiArICAg ICAuLi4gd2hlbiBhbnkKPiArIH0KPiArCgpIbW0sIHdlIGRvbid0IGNhdGNoIHRoZSBleGFtcGxl IEkgdXNlZCBpbiByZXZpZXcgb2Ygdjg6CgogICAgZXh0ZXJuIGZvbyhpbnQsIEVycm9yICoqKTsK ICAgIGV4dGVybiBiYXIoaW50LCBFcnJvciAqKik7CgogICAgdm9pZCBmcm9iKEVycm9yICoqZXJy cCkKICAgIHsKICAgICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICAgICBpbnQgYXJn OwoKICAgICAgICBmb28oYXJnLCBlcnJwKTsKICAgICAgICBiYXIoYXJnLCAmbG9jYWxfZXJyKTsK ICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKICAgICAgICBiYXIoYXJn ICsgMSwgJmxvY2FsX2Vycik7CiAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vy cik7CiAgICB9CgpJIGJlbGlldmUgdGhpcyBpcyBiZWNhdXNlIHJ1bGUxIGRvZXMgbm90IG1hdGNo IGhlcmUuCgpJZiBJIGNoYW5nZSB0aGUgcnVsZSBhcyBmb2xsb3dzLCBpdCBjYXRjaGVzIHRoZSBl eGFtcGxlOgoKICAgIEBAIC0xNTcsMjQgKzE1NywyMyBAQCBwcmludCgnV2FybmluZzogZnVuY3Rp b24ge30gaGFzIHNldmVyYWwgZGVmaW5pdGlvbnMgb2YgJwoKICAgICAvLyBXYXJuIHNldmVyYWwg cHJvcGFnYXRpb25zIGluIGNvbnRyb2wgZmxvdy4KICAgICBAY2hlY2syIGRpc2FibGUgb3B0aW9u YWxfcXVhbGlmaWVyIGV4aXN0c0AKICAgIC1pZGVudGlmaWVyIGZuID0gcnVsZTEuZm47CiAgICAt c3ltYm9sIGVycnA7CiAgICAraWRlbnRpZmllciBmbiwgX2VycnA7CiAgICAgcG9zaXRpb24gcDEs IHAyOwogICAgIEBACgogICAgLSBmbiguLi4sIEVycm9yICoqIF9fX18sIC4uLikKICAgICsgZm4o Li4uLCBFcnJvciAqKl9lcnJwLCAuLi4pCiAgICAgIHsKICAgICAgICAgIC4uLgogICAgICgKICAg IC0gICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIC4uLik7QHAxCiAgICArICAgICBl cnJvcl9wcm9wYWdhdGVfcHJlcGVuZChfZXJycCwgLi4uKTtAcDEKICAgICB8CiAgICAtICAgICBl cnJvcl9wcm9wYWdhdGUoZXJycCwgLi4uKTtAcDEKICAgICsgICAgIGVycm9yX3Byb3BhZ2F0ZShf ZXJycCwgLi4uKTtAcDEKICAgICApCiAgICAgICAgICAuLi4KICAgICAoCiAgICAtICAgICBlcnJv cl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCAuLi4pO0BwMgogICAgKyAgICAgZXJyb3JfcHJvcGFn YXRlX3ByZXBlbmQoX2VycnAsIC4uLik7QHAyCiAgICAgfAogICAgLSAgICAgZXJyb3JfcHJvcGFn YXRlKGVycnAsIC4uLik7QHAyCiAgICArICAgICBlcnJvcl9wcm9wYWdhdGUoX2VycnAsIC4uLik7 QHAyCiAgICAgKQogICAgICAgICAgLi4uIHdoZW4gYW55CiAgICAgIH0KClRvIG15IG1pbGQgc3Vy cHJpc2UsIGl0IHN0aWxsIGRvZXNuJ3QgZmluZCBhbnl0aGluZyBpbiBvdXIgdHJlZS4KClNob3Vs ZCB3ZSBkZWNvdXBsZSB0aGUgcHJldmlvdXMgcnVsZSBmcm9tIHJ1bGUxLCB0b28/ICBJIHRlc3Rl ZCB0aGUKZm9sbG93aW5nIG9uIHRoZSB3aG9sZSB0cmVlOgoKICAgIEBAIC0xMzYsMTAgKzEzNiwx MCBAQCBzeW1ib2wgZXJycDsKCiAgICAgLy8gV2FybiBzZXZlcmFsIEVycm9yICogZGVmaW5pdGlv bnMuCiAgICAgQGNoZWNrMSBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACiAgICAt aWRlbnRpZmllciBmbiA9IHJ1bGUxLmZuLCBsb2NhbF9lcnIsIGxvY2FsX2VycjI7CiAgICAraWRl bnRpZmllciBmbiwgX2VycnAsIGxvY2FsX2VyciwgbG9jYWxfZXJyMjsKICAgICBAQAoKICAgIC0g Zm4oLi4uLCBFcnJvciAqKiBfX19fLCAuLi4pCiAgICArIGZuKC4uLiwgRXJyb3IgKipfZXJycCwg Li4uKQogICAgICB7CiAgICAgICAgICAuLi4KICAgICAgICAgIEVycm9yICpsb2NhbF9lcnIgPSBO VUxMOwoKV2FybmluZ3MgcmVtYWluIHVuY2hhbmdlZC4KCj4gK0Agc2NyaXB0OnB5dGhvbiBACj4g K2ZuIDw8IGNoZWNrMi5mbjsKPiArcDEgPDwgY2hlY2syLnAxOwo+ICtwMiA8PCBjaGVjazIucDI7 Cj4gK0BACj4gKwo+ICtwcmludCgnV2FybmluZzogZnVuY3Rpb24ge30gcHJvcGFnYXRlcyB0byBl cnJwIHNldmVyYWwgdGltZXMgaW4gJwo+ICsgICAgICAnb25lIGNvbnRyb2wgZmxvdzogYXQge306 e30gYW5kIHRoZW4gYXQge306e30nLmZvcm1hdCgKPiArICAgICAgICAgIGZuLCBwMVswXS5maWxl LCBwMVswXS5saW5lLCBwMlswXS5maWxlLCBwMlswXS5saW5lKSkKPiArCj4gKy8vIENvbnZlcnQg c3BlY2lhbCBjYXNlIHdpdGggZ290byBzZXBhcmF0ZWx5Lgo+ICsvLyBJIHRyaWVkIG1lcmdpbmcg dGhpcyBpbnRvIHRoZSBmb2xsb3dpbmcgcnVsZSB0aGUgb2J2aW91cyB3YXksIGJ1dAo+ICsvLyBp dCBtYWRlIENvY2NpbmVsbGUgaGFuZyBvbiBibG9jay5jCj4gKy8vCj4gKy8vIE5vdGUgaW50ZXJl c3RpbmcgdGhpbmc6IGlmIHdlIGRvbid0IGRvIGl0IGhlcmUsIGFuZCB0cnkgdG8gZml4dXAKPiAr Ly8gIm91dDogfSIgdGhpbmdzIGxhdGVyIGFmdGVyIGFsbCB0cmFuc2Zvcm1hdGlvbnMgKHRoZSBy dWxlIHdpbGwgYmUKPiArLy8gdGhlIHNhbWUsIGp1c3Qgd2l0aG91dCBlcnJvcl9wcm9wYWdhdGUo KSBjYWxsKSwgY29jY2luZWxsZSBmYWlscyB0bwo+ICsvLyBtYXRjaCB0aGlzICJvdXQ6IH0iLgo+ ICtAIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyQAo+ICtpZGVudGlmaWVyIHJ1bGUxLmZuLCBy dWxlMS5sb2NhbF9lcnIsIG91dDsKCkFzIGV4cGxhaW5lZCBhYm92ZSwgSSBkb3VidCB0aGUgbmVl ZCBmb3IgcnVsZTEuZm4uICBXZSBkbyBuZWVkCnJ1bGUxLmxvY2FsX2VyciB0byBhdm9pZCB1bndh bnRlZCB0cmFuc2Zvcm1hdGlvbnMuICBNb3JlIG9mIHRoZSBzYW1lCmJlbG93LgoKPiArc3ltYm9s IGVycnA7Cj4gK0BACj4gKwo+ICsgZm4oLi4uLCBFcnJvciAqKiBfX19fLCAuLi4pCj4gKyB7Cj4g KyAgICAgPC4uLgo+ICstICAgIGdvdG8gb3V0Owo+ICsrICAgIHJldHVybjsKPiArICAgICAuLi4+ Cj4gKy0gb3V0Ogo+ICstICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwo+ICsg fQo+ICsKPiArLy8gQ29udmVydCBtb3N0IG9mIGxvY2FsX2VyciByZWxhdGVkIHN0dWZmLgo+ICsv Lwo+ICsvLyBOb3RlLCB0aGF0IHdlIHVwZGF0ZSBldmVyeXRoaW5nIHJlbGF0ZWQgdG8gbWF0Y2hl ZCBieSBydWxlMQo+ICsvLyBmdW5jdGlvbiBuYW1lIGFuZCBsb2NhbF9lcnIgbmFtZS4gV2UgbWF5 IG1hdGNoIHNvbWV0aGluZyBub3QKPiArLy8gcmVsYXRlZCB0byB0aGUgcGF0dGVybiBtYXRjaGVk IGJ5IHJ1bGUxLiBGb3IgZXhhbXBsZSwgbG9jYWxfZXJyIG1heQo+ICsvLyBiZSBkZWZpbmVkIHdp dGggdGhlIHNhbWUgbmFtZSBpbiBkaWZmZXJlbnQgYmxvY2tzIGluc2lkZSBvbmUKPiArLy8gZnVu Y3Rpb24sIGFuZCBpbiBvbmUgYmxvY2sgZm9sbG93IHRoZSBwcm9wYWdhdGlvbiBwYXR0ZXJuIGFu ZCBpbgo+ICsvLyBvdGhlciBibG9jayBkb2Vzbid0LiBPciB3ZSBtYXkgaGF2ZSBzZXZlcmFsIGZ1 bmN0aW9ucyB3aXRoIHRoZSBzYW1lCj4gKy8vIG5hbWUgKGZvciBkaWZmZXJlbnQgY29uZmlndXJh dGlvbnMpLgo+ICsvLwo+ICsvLyBOb3RlIGFsc28gdGhhdCBlcnJwLWNsZWFuaW5nIGZ1bmN0aW9u cwo+ICsvLyAgIGVycm9yX2ZyZWVfZXJycAo+ICsvLyAgIGVycm9yX3JlcG9ydF9lcnJwCj4gKy8v ICAgZXJyb3JfcmVwb3J0Zl9lcnJwCj4gKy8vICAgd2Fybl9yZXBvcnRfZXJycAo+ICsvLyAgIHdh cm5fcmVwb3J0Zl9lcnJwCj4gKy8vIGFyZSBub3QgeWV0IGltcGxlbWVudGVkLiBUaGV5IG11c3Qg Y2FsbCBjb3JyZXNwb25kaW5nIEVycm9yKiAtCj4gKy8vIGZyZWVpbmcgZnVuY3Rpb24gYW5kIHRo ZW4gc2V0ICplcnJwIHRvIE5VTEwsIHRvIGF2b2lkIGZ1cnRoZXIKPiArLy8gcHJvcGFnYXRpb24g dG8gb3JpZ2luYWwgZXJycCAoY29uc2lkZXIgRVJSUF9BVVRPX1BST1BBR0FURSBpbiB1c2UpLgo+ ICsvLyBGb3IgZXhhbXBsZSwgZXJyb3JfZnJlZV9lcnJwIG1heSBsb29rIGxpa2UgdGhpczoKPiAr Ly8KPiArLy8gICAgdm9pZCBlcnJvcl9mcmVlX2VycnAoRXJyb3IgKiplcnJwKQo+ICsvLyAgICB7 Cj4gKy8vICAgICAgICBlcnJvcl9mcmVlKCplcnJwKTsKPiArLy8gICAgICAgICplcnJwID0gTlVM TDsKPiArLy8gICAgfQo+ICtAIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIGV4aXN0c0AKPiAr aWRlbnRpZmllciBydWxlMS5mbiwgcnVsZTEubG9jYWxfZXJyOwo+ICtleHByZXNzaW9uIGxpc3Qg YXJnczsKPiArc3ltYm9sIGVycnA7Cj4gK0BACj4gKwo+ICsgZm4oLi4uLCBFcnJvciAqKiBfX19f LCAuLi4pCj4gKyB7Cj4gKyAgICAgPC4uLgo+ICsoCj4gKy0gICAgRXJyb3IgKmxvY2FsX2VyciA9 IE5VTEw7Cj4gK3wKPiArCj4gKy8vIENvbnZlcnQgZXJyb3IgY2xlYXJpbmcgZnVuY3Rpb25zCj4g KygKPiArLSAgICBlcnJvcl9mcmVlKGxvY2FsX2Vycik7Cj4gKysgICAgZXJyb3JfZnJlZV9lcnJw KGVycnApOwo+ICt8Cj4gKy0gICAgZXJyb3JfcmVwb3J0X2Vycihsb2NhbF9lcnIpOwo+ICsrICAg IGVycm9yX3JlcG9ydF9lcnJwKGVycnApOwo+ICt8Cj4gKy0gICAgZXJyb3JfcmVwb3J0Zl9lcnIo bG9jYWxfZXJyLCBhcmdzKTsKPiArKyAgICBlcnJvcl9yZXBvcnRmX2VycnAoZXJycCwgYXJncyk7 Cj4gK3wKPiArLSAgICB3YXJuX3JlcG9ydF9lcnIobG9jYWxfZXJyKTsKPiArKyAgICB3YXJuX3Jl cG9ydF9lcnJwKGVycnApOwo+ICt8Cj4gKy0gICAgd2Fybl9yZXBvcnRmX2Vycihsb2NhbF9lcnIs IGFyZ3MpOwo+ICsrICAgIHdhcm5fcmVwb3J0Zl9lcnJwKGVycnAsIGFyZ3MpOwo+ICspCj4gKz8t ICAgIGxvY2FsX2VyciA9IE5VTEw7Cj4gKwo+ICt8Cj4gKy0gICAgZXJyb3JfcHJvcGFnYXRlX3By ZXBlbmQoZXJycCwgbG9jYWxfZXJyLCBhcmdzKTsKPiArKyAgICBlcnJvcl9wcmVwZW5kKGVycnAs IGFyZ3MpOwo+ICt8Cj4gKy0gICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Cj4g K3wKPiArLSAgICAmbG9jYWxfZXJyCj4gKysgICAgZXJycAo+ICspCj4gKyAgICAgLi4uPgo+ICsg fQo+ICsKPiArLy8gQ29udmVydCByZW1haW5pbmcgbG9jYWxfZXJyIHVzYWdlLiBGb3IgZXhhbXBs ZSwgZGlmZmVyZW50IGtpbmRzIG9mCj4gKy8vIGVycm9yIGNoZWNraW5nIGluIGlmIGNvbmRpdGlv bmFscy4gV2UgY2FuJ3QgbWVyZ2UgdGhpcyBpbnRvCj4gKy8vIHByZXZpb3VzIGh1bmssIGFzIHRo aXMgY29uZmxpY3RzIHdpdGggb3RoZXIgc3Vic3RpdHV0aW9ucyBpbiBpdCAoYXQKPiArLy8gbGVh c3Qgd2l0aCAiLSBsb2NhbF9lcnIgPSBOVUxMIikuCj4gK0AgZGlzYWJsZSBvcHRpb25hbF9xdWFs aWZpZXJACj4gK2lkZW50aWZpZXIgcnVsZTEuZm4sIHJ1bGUxLmxvY2FsX2VycjsKPiArc3ltYm9s IGVycnA7Cj4gK0BACj4gKwo+ICsgZm4oLi4uLCBFcnJvciAqKiBfX19fLCAuLi4pCj4gKyB7Cj4g KyAgICAgPC4uLgo+ICstICAgIGxvY2FsX2Vycgo+ICsrICAgICplcnJwCj4gKyAgICAgLi4uPgo+ ICsgfQo+ICsKPiArLy8gQWx3YXlzIHVzZSB0aGUgc2FtZSBwYXR0ZXJuIGZvciBjaGVja2luZyBl cnJvcgo+ICtAIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyQAo+ICtpZGVudGlmaWVyIHJ1bGUx LmZuOwo+ICtzeW1ib2wgZXJycDsKPiArQEAKPiArCj4gKyBmbiguLi4sIEVycm9yICoqIF9fX18s IC4uLikKPiArIHsKPiArICAgICA8Li4uCj4gKy0gICAgKmVycnAgIT0gTlVMTAo+ICsrICAgICpl cnJwCj4gKyAgICAgLi4uPgo+ICsgfQo+ICsKPiArLy8gUmV2ZXJ0IHRlbXBvcmFyeSBfX18gaWRl bnRpZmllci4KPiArQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllckAKPiAraWRlbnRpZmllciBy dWxlMS5mbjsKPiArQEAKPiArCj4gKyBmbiguLi4sIEVycm9yICoqCj4gKy0gICBfX19fCj4gKysg ICBlcnJwCj4gKyAgICAsIC4uLikKPiArIHsKPiArICAgICAuLi4KPiArIH0KPiBkaWZmIC0tZ2l0 IGEvaW5jbHVkZS9xYXBpL2Vycm9yLmggYi9pbmNsdWRlL3FhcGkvZXJyb3IuaAo+IGluZGV4IDMw MTQwZDliZmUuLjU2YzEzMzUyMGQgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9xYXBpL2Vycm9yLmgK PiArKysgYi9pbmNsdWRlL3FhcGkvZXJyb3IuaAo+IEBAIC0yMTQsNiArMjE0LDkgQEAKPiAgICog ICAgICAgICB9Cj4gICAqICAgICAgICAgLi4uCj4gICAqICAgICB9Cj4gKyAqCj4gKyAqIEZvciBt YXNzLWNvbnZlcnNpb24gdXNlIHNjcmlwdAo+ICsgKiAgIHNjcmlwdHMvY29jY2luZWxsZS9hdXRv LXByb3BhZ2F0ZWQtZXJycC5jb2NjaQo+ICAgKi8KPiAgCj4gICNpZm5kZWYgRVJST1JfSAo+IGRp ZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCj4gaW5kZXggODU3Zjk2OWFhMS4u MDQ3ZjFiOTcxNCAxMDA2NDQKPiAtLS0gYS9NQUlOVEFJTkVSUwo+ICsrKyBiL01BSU5UQUlORVJT Cj4gQEAgLTE5OTgsNiArMTk5OCw3IEBAIEY6IGluY2x1ZGUvcWVtdS9lcnJvci1yZXBvcnQuaAo+ ICBGOiBxYXBpL2Vycm9yLmpzb24KPiAgRjogdXRpbC9lcnJvci5jCj4gIEY6IHV0aWwvcWVtdS1l cnJvci5jCj4gK0Y6IHNjcmlwdHMvY29jY2luZWxsZS8qZXJyKi5jb2NjaQo+ICAKPiAgR0RCIHN0 dWIKPiAgTTogQWxleCBCZW5uw6llIDxhbGV4LmJlbm5lZUBsaW5hcm8ub3JnPgoKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5n IGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJv amVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw= 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=-6.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS 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 9247EC10DCE for ; Thu, 12 Mar 2020 16:37:48 +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 4EF522067C for ; Thu, 12 Mar 2020 16:37:48 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="bGTZmfsQ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4EF522067C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Received: from localhost ([::1]:45010 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jCQqB-0007jv-Fl for qemu-devel@archiver.kernel.org; Thu, 12 Mar 2020 12:37:47 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:34093) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jCQpI-0005XL-Kt for qemu-devel@nongnu.org; Thu, 12 Mar 2020 12:36:56 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1jCQpG-00084Q-06 for qemu-devel@nongnu.org; Thu, 12 Mar 2020 12:36:52 -0400 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:27871 helo=us-smtp-delivery-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1jCQpF-00083a-Qr for qemu-devel@nongnu.org; Thu, 12 Mar 2020 12:36:49 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584031009; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=BRQCQPh/dzQo+naMawCQ0skDcQhN3Y2gStxLEo2Ml58=; b=bGTZmfsQuujpkyxVG2Mni1fDr/Sqql7ooGAcSVuZHcQb5eluWzC6V/SCW3N2sR218bWI9N 693eereIk0zFkTGqeMzah9H/zv/ZR7BhTjpi+d5/AXfadO5HXlb09X6u7eYkTLTpzS4Jdi UCth663x7eBVwlXKjWT+DNDDp7CAjRg= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-453-qx6OiUWbNKi4-2iyASGY2g-1; Thu, 12 Mar 2020 12:36:43 -0400 X-MC-Unique: qx6OiUWbNKi4-2iyASGY2g-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id E45111005509; Thu, 12 Mar 2020 16:36:40 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-116-34.ams2.redhat.com [10.36.116.34]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 31BFC9CA3; Thu, 12 Mar 2020 16:36:35 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id B05D811386A6; Thu, 12 Mar 2020 17:36:33 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy Subject: Re: [PATCH v9 02/10] scripts: Coccinelle script to use ERRP_AUTO_PROPAGATE() References: <20200312085936.9552-1-vsementsov@virtuozzo.com> <20200312085936.9552-3-vsementsov@virtuozzo.com> Date: Thu, 12 Mar 2020 17:36:33 +0100 In-Reply-To: <20200312085936.9552-3-vsementsov@virtuozzo.com> (Vladimir Sementsov-Ogievskiy's message of "Thu, 12 Mar 2020 11:59:28 +0300") Message-ID: <874kuto7hq.fsf@dusky.pond.sub.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.3 (gnu/linux) MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] [fuzzy] X-Received-From: 207.211.31.81 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 , Stefano Stabellini , Michael Roth , qemu-block@nongnu.org, Paul Durrant , Laszlo Ersek , Christian Schoenebeck , qemu-devel@nongnu.org, Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , armbru@redhat.com, Stefan Berger Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" I may have a second look tomorrow with fresher eyes, but let's get this out now as is. Vladimir Sementsov-Ogievskiy writes: > Script 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 \ > --max-width 80 FILES... > > Signed-off-by: Vladimir Sementsov-Ogievskiy > --- > > 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=C3=A9" > 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 > > scripts/coccinelle/auto-propagated-errp.cocci | 327 ++++++++++++++++++ > include/qapi/error.h | 3 + > MAINTAINERS | 1 + > 3 files changed, 331 insertions(+) > create mode 100644 scripts/coccinelle/auto-propagated-errp.cocci > > diff --git a/scripts/coccinelle/auto-propagated-errp.cocci b/scripts/cocc= inelle/auto-propagated-errp.cocci > new file mode 100644 > index 0000000000..7dac2dcfa4 > --- /dev/null > +++ b/scripts/coccinelle/auto-propagated-errp.cocci > @@ -0,0 +1,327 @@ > +// 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 > +// . > +// > +// Usage example: > +// spatch --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ > +// --macro-file scripts/cocci-macro-file.h --in-place \ > +// --no-show-diff --max-width 80 FILES... > +// > +// Note: --max-width 80 is needed because coccinelle default is less > +// than 80, and without this parameter coccinelle may reindent some > +// lines which fit into 80 characters but not to coccinelle default, > +// which in turn produces extra patch hunks for no reason. This is about unwanted reformatting of parameter lists due to the ___ chaining hack. --max-width 80 makes that less likely, but not impossible. We can search for unwanted reformatting of parameter lists. I think grepping diffs for '^\+.*Error \*\*' should do the trick. For the whole tree, I get one false positive (not a parameter list), and one hit: @@ -388,8 +388,10 @@ static void object_post_init_with_type(O } } -void object_apply_global_props(Object *obj, const GPtrArray *props, Er= ror **errp) +void object_apply_global_props(Object *obj, const GPtrArray *props, + Error **errp) { + ERRP_AUTO_PROPAGATE(); int i; if (!props) { Reformatting, but not unwanted. The --max-width 80 hack is good enough for me. It does result in slightly long transformed lines, e.g. this one in replication.c: @@ -113,7 +113,7 @@ static int replication_open(BlockDriverS s->mode =3D REPLICATION_MODE_PRIMARY; top_id =3D qemu_opt_get(opts, REPLICATION_TOP_ID); if (top_id) { - error_setg(&local_err, "The primary side does not support = option top-id"); + error_setg(errp, "The primary side does not support option= top-id"); goto fail; } } else if (!strcmp(mode, "secondary")) { v8 did break this line (that's how I found it). However, v9 still shortens the line, just not below the target. All your + lines look quite unlikely to lengthen lines. Let's not worry about this. > +// Switch unusual Error ** parameter names to errp > +// (this is necessary to use ERRP_AUTO_PROPAGATE). > +// > +// Disable optional_qualifier to skip functions with > +// "Error *const *errp" parameter. > +// > +// Skip functions with "assert(_errp && *_errp)" statement, because > +// that signals unusual semantics, and the parameter name may well > +// serve a purpose. (like nbd_iter_channel_error()). > +// > +// Skip util/error.c to not touch, for example, error_propagate() and > +// error_propagate_prepend(). > +@ depends on !(file in "util/error.c") disable optional_qualifier@ > +identifier fn; > +identifier _errp !=3D errp; > +@@ > + > + fn(..., > +- Error **_errp > ++ Error **errp > + ,...) > + { > +( > + ... when !=3D assert(_errp && *_errp) > +& > + <... > +- _errp > ++ errp > + ...> > +) > + } > + > +// Add invocation of ERRP_AUTO_PROPAGATE to errp-functions where > +// necessary > +// > +// Note, that without "when any" the final "..." does not mach > +// something matched by previous pattern, i.e. the rule will not match > +// double error_prepend in control flow like in > +// vfio_set_irq_signaling(). > +// > +// Note, "exists" says that we want apply rule even if it matches not > +// on all possible control flows (otherwise, it will not match > +// standard pattern when error_propagate() call is in if branch). > +@ disable optional_qualifier exists@ > +identifier fn, local_err; > +symbol errp; > +@@ > + > + fn(..., Error **errp, ...) > + { > ++ ERRP_AUTO_PROPAGATE(); > + ... when !=3D ERRP_AUTO_PROPAGATE(); > +( > +( > + error_append_hint(errp, ...); > +| > + error_prepend(errp, ...); > +| > + error_vprepend(errp, ...); > +) > + ... when any > +| > + Error *local_err =3D NULL; > + ... > +( > + error_propagate_prepend(errp, local_err, ...); > +| > + error_propagate(errp, local_err); > +) > + ... > +) > + } > + > + > +// Match functions with propagation of local error to errp. > +// We want to refer these functions in several following rules, but I > +// don't know a proper way to inherit a function, not just its name > +// (to not match another functions with same name in following rules). > +// Not-proper way is as follows: rename errp parameter in functions > +// header and match it in following rules. Rename it back after all > +// transformations. > +// > +// The simplest case of propagation scheme is single definition of > +// local_err with at most one error_propagate_prepend or > +// error_propagate on each control-flow. Still, we want to match more > +// complex schemes too. We'll warn them with help of further rules. I think what we actually want is to examine instances of this pattern to figure out whether and how we want to transform them. Perhaps: // The common case is a single definition of local_err with at most one // error_propagate_prepend() or error_propagate() on each control-flow // path. Instances of this case we convert with this script. Functions // with multiple definitions or propagates we want to examine // manually. Later rules emit warnings to guide us to them. > +@rule1 disable optional_qualifier exists@ > +identifier fn, local_err; > +symbol errp; > +@@ > + > + fn(..., Error ** > +- errp > ++ ____ > + , ...) > + { > + ... > + Error *local_err =3D NULL; > + ... > +( > + error_propagate_prepend(errp, local_err, ...); > +| > + error_propagate(errp, local_err); > +) > + ... > + } > + > + > +// Warn several Error * definitions. > +@check1 disable optional_qualifier exists@ > +identifier fn =3D rule1.fn, local_err, local_err2; Elsewhere, you use just rule.fn instead of fn =3D rule1.fn. Any particular reason for the difference? With the ___ chaining hack, I doubt we still need "=3D rule1.fn" or "rule1.fn". If I replace "fn =3D rule1.fn" and "rule.fn" by just "fn" everywhere, then apply the script to the complete tree, I get the same result. > +@@ > + > + fn(..., Error ** ____, ...) > + { > + ... > + Error *local_err =3D NULL; > + ... when any > + Error *local_err2 =3D NULL; > + ... when any > + } > + > +@ script:python @ > +fn << check1.fn; > +@@ > + > +print('Warning: function {} has several definitions of ' > + 'Error * local variable'.format(fn)) > + > +// Warn several propagations in control flow. > +@check2 disable optional_qualifier exists@ > +identifier fn =3D rule1.fn; > +symbol errp; > +position p1, p2; > +@@ > + > + fn(..., Error ** ____, ...) > + { > + ... > +( > + error_propagate_prepend(errp, ...);@p1 > +| > + error_propagate(errp, ...);@p1 > +) > + ... > +( > + error_propagate_prepend(errp, ...);@p2 > +| > + error_propagate(errp, ...);@p2 > +) > + ... when any > + } > + Hmm, we don't catch the example I used in review of v8: extern foo(int, Error **); extern bar(int, Error **); void frob(Error **errp) { Error *local_err =3D NULL; int arg; foo(arg, errp); bar(arg, &local_err); error_propagate(errp, local_err); bar(arg + 1, &local_err); error_propagate(errp, local_err); } I believe this is because rule1 does not match here. If I change the rule as follows, it catches the example: @@ -157,24 +157,23 @@ print('Warning: function {} has several definitio= ns of ' // Warn several propagations in control flow. @check2 disable optional_qualifier exists@ -identifier fn =3D rule1.fn; -symbol errp; +identifier fn, _errp; position p1, p2; @@ - fn(..., Error ** ____, ...) + fn(..., Error **_errp, ...) { ... ( - error_propagate_prepend(errp, ...);@p1 + error_propagate_prepend(_errp, ...);@p1 | - error_propagate(errp, ...);@p1 + error_propagate(_errp, ...);@p1 ) ... ( - error_propagate_prepend(errp, ...);@p2 + error_propagate_prepend(_errp, ...);@p2 | - error_propagate(errp, ...);@p2 + error_propagate(_errp, ...);@p2 ) ... when any } To my mild surprise, it still doesn't find anything in our tree. Should we decouple the previous rule from rule1, too? I tested the following on the whole tree: @@ -136,10 +136,10 @@ symbol errp; // Warn several Error * definitions. @check1 disable optional_qualifier exists@ -identifier fn =3D rule1.fn, local_err, local_err2; +identifier fn, _errp, local_err, local_err2; @@ - fn(..., Error ** ____, ...) + fn(..., Error **_errp, ...) { ... Error *local_err =3D NULL; Warnings remain unchanged. > +@ script:python @ > +fn << check2.fn; > +p1 << check2.p1; > +p2 << check2.p2; > +@@ > + > +print('Warning: function {} propagates to errp several times in ' > + 'one control flow: at {}:{} and then at {}:{}'.format( > + fn, p1[0].file, p1[0].line, p2[0].file, p2[0].line)) > + > +// Convert special case with goto separately. > +// I tried merging this into the following rule the obvious way, but > +// it made Coccinelle hang on block.c > +// > +// Note interesting thing: if we don't do it here, and try to fixup > +// "out: }" things later after all transformations (the rule will be > +// the same, just without error_propagate() call), coccinelle fails to > +// match this "out: }". > +@ disable optional_qualifier@ > +identifier rule1.fn, rule1.local_err, out; As explained above, I doubt the need for rule1.fn. We do need rule1.local_err to avoid unwanted transformations. More of the same below. > +symbol errp; > +@@ > + > + fn(..., Error ** ____, ...) > + { > + <... > +- goto out; > ++ return; > + ...> > +- out: > +- error_propagate(errp, local_err); > + } > + > +// Convert most of local_err related stuff. > +// > +// Note, that we update everything related to matched by rule1 > +// function name and local_err name. We may match something not > +// related to the pattern matched by rule1. For example, local_err may > +// be defined with the same name in different blocks inside one > +// function, and in one block follow the propagation pattern and in > +// other block doesn't. Or we may have several functions with the same > +// name (for different configurations). > +// > +// Note also that errp-cleaning functions > +// error_free_errp > +// error_report_errp > +// error_reportf_errp > +// warn_report_errp > +// warn_reportf_errp > +// are not yet implemented. They must call corresponding Error* - > +// freeing function and then set *errp to NULL, to avoid further > +// propagation to original errp (consider ERRP_AUTO_PROPAGATE in use). > +// For example, error_free_errp may look like this: > +// > +// void error_free_errp(Error **errp) > +// { > +// error_free(*errp); > +// *errp =3D NULL; > +// } > +@ disable optional_qualifier exists@ > +identifier rule1.fn, rule1.local_err; > +expression list args; > +symbol errp; > +@@ > + > + fn(..., Error ** ____, ...) > + { > + <... > +( > +- Error *local_err =3D NULL; > +| > + > +// Convert error clearing functions > +( > +- error_free(local_err); > ++ error_free_errp(errp); > +| > +- error_report_err(local_err); > ++ error_report_errp(errp); > +| > +- error_reportf_err(local_err, args); > ++ error_reportf_errp(errp, args); > +| > +- warn_report_err(local_err); > ++ warn_report_errp(errp); > +| > +- warn_reportf_err(local_err, args); > ++ warn_reportf_errp(errp, args); > +) > +?- local_err =3D NULL; > + > +| > +- error_propagate_prepend(errp, local_err, args); > ++ error_prepend(errp, args); > +| > +- error_propagate(errp, local_err); > +| > +- &local_err > ++ errp > +) > + ...> > + } > + > +// Convert remaining local_err usage. For example, different kinds of > +// error checking in if conditionals. We can't merge this into > +// previous hunk, as this conflicts with other substitutions in it (at > +// least with "- local_err =3D NULL"). > +@ disable optional_qualifier@ > +identifier rule1.fn, rule1.local_err; > +symbol errp; > +@@ > + > + fn(..., Error ** ____, ...) > + { > + <... > +- local_err > ++ *errp > + ...> > + } > + > +// Always use the same pattern for checking error > +@ disable optional_qualifier@ > +identifier rule1.fn; > +symbol errp; > +@@ > + > + fn(..., Error ** ____, ...) > + { > + <... > +- *errp !=3D NULL > ++ *errp > + ...> > + } > + > +// Revert temporary ___ identifier. > +@ disable optional_qualifier@ > +identifier rule1.fn; > +@@ > + > + fn(..., Error ** > +- ____ > ++ errp > + , ...) > + { > + ... > + } > diff --git a/include/qapi/error.h b/include/qapi/error.h > index 30140d9bfe..56c133520d 100644 > --- a/include/qapi/error.h > +++ b/include/qapi/error.h > @@ -214,6 +214,9 @@ > * } > * ... > * } > + * > + * For mass-conversion use script > + * scripts/coccinelle/auto-propagated-errp.cocci > */ > =20 > #ifndef ERROR_H > diff --git a/MAINTAINERS b/MAINTAINERS > index 857f969aa1..047f1b9714 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -1998,6 +1998,7 @@ F: include/qemu/error-report.h > F: qapi/error.json > F: util/error.c > F: util/qemu-error.c > +F: scripts/coccinelle/*err*.cocci > =20 > GDB stub > M: Alex Benn=C3=A9e