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.5 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 86CCDC4332D for ; Fri, 20 Mar 2020 16:19:10 +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 4966120724 for ; Fri, 20 Mar 2020 16:19:10 +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="d7drwkci" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4966120724 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass 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 1jFKMB-0002r3-Qa; Fri, 20 Mar 2020 16:18:47 +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 1jFKMB-0002qy-84 for xen-devel@lists.xenproject.org; Fri, 20 Mar 2020 16:18:47 +0000 X-Inumbo-ID: 7980f4a8-6ac6-11ea-bdbd-12813bfff9fa Received: from us-smtp-delivery-74.mimecast.com (unknown [63.128.21.74]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTP id 7980f4a8-6ac6-11ea-bdbd-12813bfff9fa; Fri, 20 Mar 2020 16:18:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584721126; 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=NZUMLUevxFLH08VSvN87F8sn7tYw+p30q0xUrtvYmJs=; b=d7drwkci5HLNZI8KKfgTfHxzkmIqStRQ4zaXc7h7/LevNTo+ztzd7enew+ReSn7xhEJIdK DUJAXoWxP5kOWjZ2tkHgP9+lWhmqGC0TZdyFnN1gcux2GVMCDr8LGtfYYoRhmIPdKwUj3M tNpPaB+vJQcFlgkBB7UvrOb6i4zNboY= 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-274-Xolm4TDuP8a2gNAOB2VUiA-1; Fri, 20 Mar 2020 12:18:42 -0400 X-MC-Unique: Xolm4TDuP8a2gNAOB2VUiA-1 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 8D996DB3B; Fri, 20 Mar 2020 16:18:40 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-112-130.ams2.redhat.com [10.36.112.130]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 84CE4F6E6; Fri, 20 Mar 2020 16:18:33 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id 52A841138404; Fri, 20 Mar 2020 17:18:32 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy References: <20200317151625.20797-1-vsementsov@virtuozzo.com> <20200317151625.20797-3-vsementsov@virtuozzo.com> Date: Fri, 20 Mar 2020 17:18:32 +0100 In-Reply-To: <20200317151625.20797-3-vsementsov@virtuozzo.com> (Vladimir Sementsov-Ogievskiy's message of "Tue, 17 Mar 2020 18:16:18 +0300") Message-ID: <875zezyp7r.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.84 on 10.5.11.23 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Subject: Re: [Xen-devel] [PATCH v10 2/9] 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" VmxhZGltaXIgU2VtZW50c292LU9naWV2c2tpeSA8dnNlbWVudHNvdkB2aXJ0dW96em8uY29tPiB3 cml0ZXM6Cgo+IFNjcmlwdCBhZGRzIEVSUlBfQVVUT19QUk9QQUdBVEUgbWFjcm8gaW52b2NhdGlv biB3aGVyZSBhcHByb3ByaWF0ZSBhbmQKPiBkb2VzIGNvcnJlc3BvbmRpbmcgY2hhbmdlcyBpbiBj b2RlIChsb29rIGZvciBkZXRhaWxzIGluCj4gaW5jbHVkZS9xYXBpL2Vycm9yLmgpCj4KPiBVc2Fn ZSBleGFtcGxlOgo+IHNwYXRjaCAtLXNwLWZpbGUgc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJv cGFnYXRlZC1lcnJwLmNvY2NpIFwKPiAgLS1tYWNyby1maWxlIHNjcmlwdHMvY29jY2ktbWFjcm8t ZmlsZS5oIC0taW4tcGxhY2UgLS1uby1zaG93LWRpZmYgXAo+ICAtLW1heC13aWR0aCA4MCBGSUxF Uy4uLgo+Cj4gU2lnbmVkLW9mZi1ieTogVmxhZGltaXIgU2VtZW50c292LU9naWV2c2tpeSA8dnNl bWVudHNvdkB2aXJ0dW96em8uY29tPgo+IC0tLQo+Cj4gQ2M6IEVyaWMgQmxha2UgPGVibGFrZUBy ZWRoYXQuY29tPgo+IENjOiBLZXZpbiBXb2xmIDxrd29sZkByZWRoYXQuY29tPgo+IENjOiBNYXgg UmVpdHogPG1yZWl0ekByZWRoYXQuY29tPgo+IENjOiBHcmVnIEt1cnogPGdyb3VnQGthb2Qub3Jn Pgo+IENjOiBDaHJpc3RpYW4gU2Nob2VuZWJlY2sgPHFlbXVfb3NzQGNydWRlYnl0ZS5jb20+Cj4g Q2M6IFN0ZWZhbiBIYWpub2N6aSA8c3RlZmFuaGFAcmVkaGF0LmNvbT4KPiBDYzogU3RlZmFubyBT dGFiZWxsaW5pIDxzc3RhYmVsbGluaUBrZXJuZWwub3JnPgo+IENjOiBBbnRob255IFBlcmFyZCA8 YW50aG9ueS5wZXJhcmRAY2l0cml4LmNvbT4KPiBDYzogUGF1bCBEdXJyYW50IDxwYXVsQHhlbi5v cmc+Cj4gQ2M6ICJQaGlsaXBwZSBNYXRoaWV1LURhdWTDqSIgPHBoaWxtZEByZWRoYXQuY29tPgo+ IENjOiBMYXN6bG8gRXJzZWsgPGxlcnNla0ByZWRoYXQuY29tPgo+IENjOiBHZXJkIEhvZmZtYW5u IDxrcmF4ZWxAcmVkaGF0LmNvbT4KPiBDYzogU3RlZmFuIEJlcmdlciA8c3RlZmFuYkBsaW51eC5p Ym0uY29tPgo+IENjOiBNYXJrdXMgQXJtYnJ1c3RlciA8YXJtYnJ1QHJlZGhhdC5jb20+Cj4gQ2M6 IE1pY2hhZWwgUm90aCA8bWRyb3RoQGxpbnV4LnZuZXQuaWJtLmNvbT4KPiBDYzogcWVtdS1kZXZl bEBub25nbnUub3JnCj4gQ2M6IHFlbXUtYmxvY2tAbm9uZ251Lm9yZwo+IENjOiB4ZW4tZGV2ZWxA bGlzdHMueGVucHJvamVjdC5vcmcKPgo+ICBzY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdh dGVkLWVycnAuY29jY2kgfCAzMzYgKysrKysrKysrKysrKysrKysrCj4gIGluY2x1ZGUvcWFwaS9l cnJvci5oICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMyArCj4gIE1BSU5UQUlORVJTICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMSArCj4gIDMgZmlsZXMgY2hhbmdl ZCwgMzQwIGluc2VydGlvbnMoKykKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IHNjcmlwdHMvY29jY2lu ZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaQo+Cj4gZGlmZiAtLWdpdCBhL3NjcmlwdHMv Y29jY2luZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSBiL3NjcmlwdHMvY29jY2luZWxs ZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaQo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5k ZXggMDAwMDAwMDAwMC4uNTE4OGIwNzAwNgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9zY3JpcHRz L2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kKPiBAQCAtMCwwICsxLDMzNiBA QAo+ICsvLyBVc2UgRVJSUF9BVVRPX1BST1BBR0FURSAoc2VlIGluY2x1ZGUvcWFwaS9lcnJvci5o KQo+ICsvLwo+ICsvLyBDb3B5cmlnaHQgKGMpIDIwMjAgVmlydHVvenpvIEludGVybmF0aW9uYWwg R21iSC4KPiArLy8KPiArLy8gVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgo+ICsvLyBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcwo+ICsvLyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUKPiArLy8g TGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KPiArLy8KPiAr Ly8gVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsCj4gKy8vIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCj4gKy8vIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKPiArLy8gR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArLy8KPiArLy8gWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKPiArLy8gYWxv bmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZQo+ICsvLyA8aHR0cDovL3d3dy5nbnUu b3JnL2xpY2Vuc2VzLz4uCj4gKy8vCj4gKy8vIFVzYWdlIGV4YW1wbGU6Cj4gKy8vIHNwYXRjaCAt LXNwLWZpbGUgc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2NpIFwK PiArLy8gIC0tbWFjcm8tZmlsZSBzY3JpcHRzL2NvY2NpLW1hY3JvLWZpbGUuaCAtLWluLXBsYWNl IFwKPiArLy8gIC0tbm8tc2hvdy1kaWZmIC0tbWF4LXdpZHRoIDgwIEZJTEVTLi4uCj4gKy8vCj4g Ky8vIE5vdGU6IC0tbWF4LXdpZHRoIDgwIGlzIG5lZWRlZCBiZWNhdXNlIGNvY2NpbmVsbGUgZGVm YXVsdCBpcyBsZXNzCj4gKy8vIHRoYW4gODAsIGFuZCB3aXRob3V0IHRoaXMgcGFyYW1ldGVyIGNv Y2NpbmVsbGUgbWF5IHJlaW5kZW50IHNvbWUKPiArLy8gbGluZXMgd2hpY2ggZml0IGludG8gODAg Y2hhcmFjdGVycyBidXQgbm90IHRvIGNvY2NpbmVsbGUgZGVmYXVsdCwKPiArLy8gd2hpY2ggaW4g dHVybiBwcm9kdWNlcyBleHRyYSBwYXRjaCBodW5rcyBmb3Igbm8gcmVhc29uLgo+ICsKPiArLy8g U3dpdGNoIHVudXN1YWwgRXJyb3IgKiogcGFyYW1ldGVyIG5hbWVzIHRvIGVycnAKPiArLy8gKHRo aXMgaXMgbmVjZXNzYXJ5IHRvIHVzZSBFUlJQX0FVVE9fUFJPUEFHQVRFKS4KPiArLy8KPiArLy8g RGlzYWJsZSBvcHRpb25hbF9xdWFsaWZpZXIgdG8gc2tpcCBmdW5jdGlvbnMgd2l0aAo+ICsvLyAi RXJyb3IgKmNvbnN0ICplcnJwIiBwYXJhbWV0ZXIuCj4gKy8vCj4gKy8vIFNraXAgZnVuY3Rpb25z IHdpdGggImFzc2VydChfZXJycCAmJiAqX2VycnApIiBzdGF0ZW1lbnQsIGJlY2F1c2UKPiArLy8g dGhhdCBzaWduYWxzIHVudXN1YWwgc2VtYW50aWNzLCBhbmQgdGhlIHBhcmFtZXRlciBuYW1lIG1h eSB3ZWxsCj4gKy8vIHNlcnZlIGEgcHVycG9zZS4gKGxpa2UgbmJkX2l0ZXJfY2hhbm5lbF9lcnJv cigpKS4KPiArLy8KPiArLy8gU2tpcCB1dGlsL2Vycm9yLmMgdG8gbm90IHRvdWNoLCBmb3IgZXhh bXBsZSwgZXJyb3JfcHJvcGFnYXRlKCkgYW5kCj4gKy8vIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5k KCkuCj4gK0AgZGVwZW5kcyBvbiAhKGZpbGUgaW4gInV0aWwvZXJyb3IuYyIpIGRpc2FibGUgb3B0 aW9uYWxfcXVhbGlmaWVyQAo+ICtpZGVudGlmaWVyIGZuOwo+ICtpZGVudGlmaWVyIF9lcnJwICE9 IGVycnA7Cj4gK0BACj4gKwo+ICsgZm4oLi4uLAo+ICstICAgRXJyb3IgKipfZXJycAo+ICsrICAg RXJyb3IgKiplcnJwCj4gKyAgICAsLi4uKQo+ICsgewo+ICsoCj4gKyAgICAgLi4uIHdoZW4gIT0g YXNzZXJ0KF9lcnJwICYmICpfZXJycCkKPiArJgo+ICsgICAgIDwuLi4KPiArLSAgICBfZXJycAo+ ICsrICAgIGVycnAKPiArICAgICAuLi4+Cj4gKykKPiArIH0KPiArCj4gKy8vIEFkZCBpbnZvY2F0 aW9uIG9mIEVSUlBfQVVUT19QUk9QQUdBVEUgdG8gZXJycC1mdW5jdGlvbnMgd2hlcmUKPiArLy8g bmVjZXNzYXJ5Cj4gKy8vCj4gKy8vIE5vdGUsIHRoYXQgd2l0aG91dCAid2hlbiBhbnkiIHRoZSBm aW5hbCAiLi4uIiBkb2VzIG5vdCBtYWNoCj4gKy8vIHNvbWV0aGluZyBtYXRjaGVkIGJ5IHByZXZp b3VzIHBhdHRlcm4sIGkuZS4gdGhlIHJ1bGUgd2lsbCBub3QgbWF0Y2gKPiArLy8gZG91YmxlIGVy cm9yX3ByZXBlbmQgaW4gY29udHJvbCBmbG93IGxpa2UgaW4KPiArLy8gdmZpb19zZXRfaXJxX3Np Z25hbGluZygpLgo+ICsvLwo+ICsvLyBOb3RlLCAiZXhpc3RzIiBzYXlzIHRoYXQgd2Ugd2FudCBh cHBseSBydWxlIGV2ZW4gaWYgaXQgZG9lcyBub3QKPiArLy8gbWF0Y2ggb24gYWxsIHBvc3NpYmxl IGNvbnRyb2wgZmxvd3MgKG90aGVyd2lzZSwgaXQgd2lsbCBub3QgbWF0Y2gKPiArLy8gc3RhbmRh cmQgcGF0dGVybiB3aGVuIGVycm9yX3Byb3BhZ2F0ZSgpIGNhbGwgaXMgaW4gaWYgYnJhbmNoKS4K PiArQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4gK2lkZW50aWZpZXIgZm4s IGxvY2FsX2VycjsKPiArc3ltYm9sIGVycnA7Cj4gK0BACj4gKwo+ICsgZm4oLi4uLCBFcnJvciAq KmVycnAsIC4uLikKPiArIHsKPiArKyAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKPiArICAgIC4u LiAgd2hlbiAhPSBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7Cj4gKygKPiArKAo+ICsgICAgZXJyb3Jf YXBwZW5kX2hpbnQoZXJycCwgLi4uKTsKPiArfAo+ICsgICAgZXJyb3JfcHJlcGVuZChlcnJwLCAu Li4pOwo+ICt8Cj4gKyAgICBlcnJvcl92cHJlcGVuZChlcnJwLCAuLi4pOwo+ICspCj4gKyAgICAu Li4gd2hlbiBhbnkKPiArfAo+ICsgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7Cj4gKyAgICAu Li4KPiArKAo+ICsgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLCAu Li4pOwo+ICt8Cj4gKyAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKPiArKQo+ ICsgICAgLi4uCj4gKykKPiArIH0KPiArCj4gKy8vIFdhcm4gd2hlbiBzZXZlcmFsIEVycm9yICog ZGVmaW5pdGlvbnMgYXJlIGluIHRoZSBjb250cm9sIGZsb3cuCj4gKy8vIFRoaXMgcnVsZSBpcyBu b3QgY2hhaW5lZCB0byBydWxlMSBhbmQgbGVzcyByZXN0cmljdGl2ZSwgdG8gY292ZXIgbW9yZQo+ ICsvLyBmdW5jdGlvbnMgdG8gd2FybiAoZXZlbiB0aG9zZSB3ZSBhcmUgbm90IGdvaW5nIHRvIGNv bnZlcnQpLgo+ICsvLwo+ICsvLyBOb3RlLCB0aGF0IGV2ZW4gd2l0aCBvbmUgKG9yIHplcm8pIEVy cm9yICogZGVmaW5pdGlvbiBpbiB0aGUgZWFjaAo+ICsvLyBjb250cm9sIGZsb3cgd2UgbWF5IGhh dmUgc2V2ZXJhbCAoaW4gdG90YWwpIEVycm9yICogZGVmaW5pdGlvbnMgaW4KPiArLy8gdGhlIGZ1 bmN0aW9uLiBUaGlzIGNhc2UgZGVzZXJ2ZXMgYXR0ZW50aW9uIHRvbywgYnV0IEkgZG9uJ3Qgc2Vl Cj4gKy8vIHNpbXBsZSB3YXkgdG8gbWF0Y2ggd2l0aCBoZWxwIG9mIGNvY2NpbmVsbGUuCj4gK0Bj aGVjazEgZGlzYWJsZSBvcHRpb25hbF9xdWFsaWZpZXIgZXhpc3RzQAo+ICtpZGVudGlmaWVyIGZu LCBfZXJycCwgbG9jYWxfZXJyLCBsb2NhbF9lcnIyOwo+ICtwb3NpdGlvbiBwMSwgcDI7Cj4gK0BA Cj4gKwo+ICsgZm4oLi4uLCBFcnJvciAqKl9lcnJwLCAuLi4pCj4gKyB7Cj4gKyAgICAgLi4uCj4g KyAgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7QHAxCj4gKyAgICAgLi4uIHdoZW4gYW55Cj4g KyAgICAgRXJyb3IgKmxvY2FsX2VycjIgPSBOVUxMO0BwMgo+ICsgICAgIC4uLiB3aGVuIGFueQo+ ICsgfQo+ICsKPiArQCBzY3JpcHQ6cHl0aG9uIEAKPiArZm4gPDwgY2hlY2sxLmZuOwo+ICtwMSA8 PCBjaGVjazEucDE7Cj4gK3AyIDw8IGNoZWNrMS5wMjsKPiArQEAKPiArCj4gK3ByaW50KCdXYXJu aW5nOiBmdW5jdGlvbiB7fSBoYXMgc2V2ZXJhbCBkZWZpbml0aW9ucyBvZiAnCj4gKyAgICAgICdF cnJvciAqIGxvY2FsIHZhcmlhYmxlOiBhdCB7fTp7fSBhbmQgdGhlbiBhdCB7fTp7fScuZm9ybWF0 KAo+ICsgICAgICAgICAgZm4sIHAxWzBdLmZpbGUsIHAxWzBdLmxpbmUsIHAyWzBdLmZpbGUsIHAy WzBdLmxpbmUpKQo+ICsKPiArLy8gV2FybiB3aGVuIHNldmVyYWwgcHJvcGFnYXRpb25zIGFyZSBp biB0aGUgY29udHJvbCBmbG93Lgo+ICtAY2hlY2syIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVy IGV4aXN0c0AKPiAraWRlbnRpZmllciBmbiwgX2VycnA7Cj4gK3Bvc2l0aW9uIHAxLCBwMjsKPiAr QEAKPiArCj4gKyBmbiguLi4sIEVycm9yICoqX2VycnAsIC4uLikKPiArIHsKPiArICAgICAuLi4K PiArKAo+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKF9lcnJwLCAuLi4pO0BwMQo+ICt8 Cj4gKyAgICAgZXJyb3JfcHJvcGFnYXRlKF9lcnJwLCAuLi4pO0BwMQo+ICspCj4gKyAgICAgLi4u Cj4gKygKPiArICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChfZXJycCwgLi4uKTtAcDIKPiAr fAo+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZShfZXJycCwgLi4uKTtAcDIKPiArKQo+ICsgICAgIC4u LiB3aGVuIGFueQo+ICsgfQo+ICsKPiArQCBzY3JpcHQ6cHl0aG9uIEAKPiArZm4gPDwgY2hlY2sy LmZuOwo+ICtwMSA8PCBjaGVjazIucDE7Cj4gK3AyIDw8IGNoZWNrMi5wMjsKPiArQEAKPiArCj4g K3ByaW50KCdXYXJuaW5nOiBmdW5jdGlvbiB7fSBwcm9wYWdhdGVzIHRvIGVycnAgc2V2ZXJhbCB0 aW1lcyBpbiAnCj4gKyAgICAgICdvbmUgY29udHJvbCBmbG93OiBhdCB7fTp7fSBhbmQgdGhlbiBh dCB7fTp7fScuZm9ybWF0KAo+ICsgICAgICAgICAgZm4sIHAxWzBdLmZpbGUsIHAxWzBdLmxpbmUs IHAyWzBdLmZpbGUsIHAyWzBdLmxpbmUpKQo+ICsKPiArLy8gTWF0Y2ggZnVuY3Rpb25zIHdpdGgg cHJvcGFnYXRpb24gb2YgbG9jYWwgZXJyb3IgdG8gZXJycC4KPiArLy8gV2Ugd2FudCB0byByZWZl ciB0aGVzZSBmdW5jdGlvbnMgaW4gc2V2ZXJhbCBmb2xsb3dpbmcgcnVsZXMsIGJ1dCBJCj4gKy8v IGRvbid0IGtub3cgYSBwcm9wZXIgd2F5IHRvIGluaGVyaXQgYSBmdW5jdGlvbiwgbm90IGp1c3Qg aXRzIG5hbWUKPiArLy8gKHRvIG5vdCBtYXRjaCBhbm90aGVyIGZ1bmN0aW9ucyB3aXRoIHNhbWUg bmFtZSBpbiBmb2xsb3dpbmcgcnVsZXMpLgo+ICsvLyBOb3QtcHJvcGVyIHdheSBpcyBhcyBmb2xs b3dzOiByZW5hbWUgZXJycCBwYXJhbWV0ZXIgaW4gZnVuY3Rpb25zCj4gKy8vIGhlYWRlciBhbmQg bWF0Y2ggaXQgaW4gZm9sbG93aW5nIHJ1bGVzLiBSZW5hbWUgaXQgYmFjayBhZnRlciBhbGwKPiAr Ly8gdHJhbnNmb3JtYXRpb25zLgo+ICsvLwo+ICsvLyBUaGUgY29tbW9uIGNhc2UgaXMgYSBzaW5n bGUgZGVmaW5pdGlvbiBvZiBsb2NhbF9lcnIgd2l0aCBhdCBtb3N0IG9uZQo+ICsvLyBlcnJvcl9w cm9wYWdhdGVfcHJlcGVuZCgpIG9yIGVycm9yX3Byb3BhZ2F0ZSgpIG9uIGVhY2ggY29udHJvbC1m bG93Cj4gKy8vIHBhdGguIEZ1bmN0aW9ucyB3aXRoIG11bHRpcGxlIGRlZmluaXRpb25zIG9yIHBy b3BhZ2F0ZXMgd2Ugd2FudCB0bwo+ICsvLyBleGFtaW5lIG1hbnVhbGx5LiBMYXRlciBydWxlcyBl bWl0IHdhcm5pbmdzIHRvIGd1aWRlIHVzIHRvIHRoZW0uCgoiTGF0ZXIgcnVsZXMiIGlzIG5vIGxv bmdlciBjb3JyZWN0LiAgU3VnZ2VzdCAiUnVsZXMgY2hlY2sxIGFuZCBjaGVjazIiLgoKPiArLy8K PiArLy8gTm90ZSB0aGF0IHdlIG1hdGNoIG5vdCBvbmx5IHRoaXMgImNvbW1vbiBjYXNlIiwgYnV0 IGFueSBmdW5jdGlvbiwKPiArLy8gd2hpY2ggaGFzIHRoZSAiY29tbW9uIGNvc2UiIG9uIGF0IGxl YXN0IG9uZSBjb250cm9sLWZsb3cgcGF0aC4KCkkgYXBwcmVjaWF0ZSB0aGlzIG5vdGUuCgpUeXBv OiBzL2Nvc2UvY2FzZS8KCj4gK0BydWxlMSBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlz dHNACj4gK2lkZW50aWZpZXIgZm4sIGxvY2FsX2VycjsKPiArc3ltYm9sIGVycnA7Cj4gK0BACj4g Kwo+ICsgZm4oLi4uLCBFcnJvciAqKgo+ICstICAgIGVycnAKPiArKyAgICBfX19fCj4gKyAgICAs IC4uLikKPiArIHsKPiArICAgICAuLi4KPiArICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsK PiArICAgICAuLi4KPiArKAo+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxv Y2FsX2VyciwgLi4uKTsKPiArfAo+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9l cnIpOwo+ICspCj4gKyAgICAgLi4uCj4gKyB9Cj4gKwo+ICsvLyBDb252ZXJ0IHNwZWNpYWwgY2Fz ZSB3aXRoIGdvdG8gc2VwYXJhdGVseS4KPiArLy8gSSB0cmllZCBtZXJnaW5nIHRoaXMgaW50byB0 aGUgZm9sbG93aW5nIHJ1bGUgdGhlIG9idmlvdXMgd2F5LCBidXQKPiArLy8gaXQgbWFkZSBDb2Nj aW5lbGxlIGhhbmcgb24gYmxvY2suYwo+ICsvLwo+ICsvLyBOb3RlIGludGVyZXN0aW5nIHRoaW5n OiBpZiB3ZSBkb24ndCBkbyBpdCBoZXJlLCBhbmQgdHJ5IHRvIGZpeHVwCj4gKy8vICJvdXQ6IH0i IHRoaW5ncyBsYXRlciBhZnRlciBhbGwgdHJhbnNmb3JtYXRpb25zICh0aGUgcnVsZSB3aWxsIGJl Cj4gKy8vIHRoZSBzYW1lLCBqdXN0IHdpdGhvdXQgZXJyb3JfcHJvcGFnYXRlKCkgY2FsbCksIGNv Y2NpbmVsbGUgZmFpbHMgdG8KPiArLy8gbWF0Y2ggdGhpcyAib3V0OiB9Ii4KPiArQCBkaXNhYmxl IG9wdGlvbmFsX3F1YWxpZmllckAKPiAraWRlbnRpZmllciBydWxlMS5mbiwgcnVsZTEubG9jYWxf ZXJyLCBvdXQ7Cj4gK3N5bWJvbCBlcnJwOwo+ICtAQAo+ICsKPiArIGZuKC4uLiwgRXJyb3IgKiog X19fXywgLi4uKQo+ICsgewo+ICsgICAgIDwuLi4KPiArLSAgICBnb3RvIG91dDsKPiArKyAgICBy ZXR1cm47Cj4gKyAgICAgLi4uPgo+ICstIG91dDoKPiArLSAgICBlcnJvcl9wcm9wYWdhdGUoZXJy cCwgbG9jYWxfZXJyKTsKPiArIH0KPiArCj4gKy8vIENvbnZlcnQgbW9zdCBvZiBsb2NhbF9lcnIg cmVsYXRlZCBzdHVmZi4KPiArLy8KPiArLy8gTm90ZSwgdGhhdCB3ZSBpbmhlcml0IHJ1bGUxLmZu IGFuZCBydWxlMS5sb2NhbF9lcnIgbmFtZXMsIG5vdAo+ICsvLyBvYmplY3RzIHRoZW1zZWx2ZXMu IFdlIG1heSBtYXRjaCBzb21ldGhpbmcgbm90IHJlbGF0ZWQgdG8gdGhlCj4gKy8vIHBhdHRlcm4g bWF0Y2hlZCBieSBydWxlMS4gRm9yIGV4YW1wbGUsIGxvY2FsX2VyciBtYXkgYmUgZGVmaW5lZCB3 aXRoCj4gKy8vIHRoZSBzYW1lIG5hbWUgaW4gZGlmZmVyZW50IGJsb2NrcyBpbnNpZGUgb25lIGZ1 bmN0aW9uLCBhbmQgaW4gb25lCj4gKy8vIGJsb2NrIGZvbGxvdyB0aGUgcHJvcGFnYXRpb24gcGF0 dGVybiBhbmQgaW4gb3RoZXIgYmxvY2sgZG9lc24ndC4KPiArLy8KPiArLy8gTm90ZSBhbHNvIHRo YXQgZXJycC1jbGVhbmluZyBmdW5jdGlvbnMKPiArLy8gICBlcnJvcl9mcmVlX2VycnAKPiArLy8g ICBlcnJvcl9yZXBvcnRfZXJycAo+ICsvLyAgIGVycm9yX3JlcG9ydGZfZXJycAo+ICsvLyAgIHdh cm5fcmVwb3J0X2VycnAKPiArLy8gICB3YXJuX3JlcG9ydGZfZXJycAo+ICsvLyBhcmUgbm90IHll dCBpbXBsZW1lbnRlZC4gVGhleSBtdXN0IGNhbGwgY29ycmVzcG9uZGluZyBFcnJvciogLQo+ICsv LyBmcmVlaW5nIGZ1bmN0aW9uIGFuZCB0aGVuIHNldCAqZXJycCB0byBOVUxMLCB0byBhdm9pZCBm dXJ0aGVyCj4gKy8vIHByb3BhZ2F0aW9uIHRvIG9yaWdpbmFsIGVycnAgKGNvbnNpZGVyIEVSUlBf QVVUT19QUk9QQUdBVEUgaW4gdXNlKS4KPiArLy8gRm9yIGV4YW1wbGUsIGVycm9yX2ZyZWVfZXJy cCBtYXkgbG9vayBsaWtlIHRoaXM6Cj4gKy8vCj4gKy8vICAgIHZvaWQgZXJyb3JfZnJlZV9lcnJw KEVycm9yICoqZXJycCkKPiArLy8gICAgewo+ICsvLyAgICAgICAgZXJyb3JfZnJlZSgqZXJycCk7 Cj4gKy8vICAgICAgICAqZXJycCA9IE5VTEw7Cj4gKy8vICAgIH0KPiArQCBkaXNhYmxlIG9wdGlv bmFsX3F1YWxpZmllciBleGlzdHNACj4gK2lkZW50aWZpZXIgcnVsZTEuZm4sIHJ1bGUxLmxvY2Fs X2VycjsKPiArZXhwcmVzc2lvbiBsaXN0IGFyZ3M7Cj4gK3N5bWJvbCBlcnJwOwo+ICtAQAo+ICsK PiArIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+ICsgewo+ICsgICAgIDwuLi4KPiArKAo+ ICstICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwo+ICt8Cj4gKwo+ICsvLyBDb252ZXJ0IGVy cm9yIGNsZWFyaW5nIGZ1bmN0aW9ucwo+ICsoCj4gKy0gICAgZXJyb3JfZnJlZShsb2NhbF9lcnIp Owo+ICsrICAgIGVycm9yX2ZyZWVfZXJycChlcnJwKTsKPiArfAo+ICstICAgIGVycm9yX3JlcG9y dF9lcnIobG9jYWxfZXJyKTsKPiArKyAgICBlcnJvcl9yZXBvcnRfZXJycChlcnJwKTsKPiArfAo+ ICstICAgIGVycm9yX3JlcG9ydGZfZXJyKGxvY2FsX2VyciwgYXJncyk7Cj4gKysgICAgZXJyb3Jf cmVwb3J0Zl9lcnJwKGVycnAsIGFyZ3MpOwo+ICt8Cj4gKy0gICAgd2Fybl9yZXBvcnRfZXJyKGxv Y2FsX2Vycik7Cj4gKysgICAgd2Fybl9yZXBvcnRfZXJycChlcnJwKTsKPiArfAo+ICstICAgIHdh cm5fcmVwb3J0Zl9lcnIobG9jYWxfZXJyLCBhcmdzKTsKPiArKyAgICB3YXJuX3JlcG9ydGZfZXJy cChlcnJwLCBhcmdzKTsKPiArKQo+ICs/LSAgICBsb2NhbF9lcnIgPSBOVUxMOwo+ICsKPiArfAo+ ICstICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgYXJncyk7Cj4g KysgICAgZXJyb3JfcHJlcGVuZChlcnJwLCBhcmdzKTsKPiArfAo+ICstICAgIGVycm9yX3Byb3Bh Z2F0ZShlcnJwLCBsb2NhbF9lcnIpOwo+ICt8Cj4gKy0gICAgJmxvY2FsX2Vycgo+ICsrICAgIGVy cnAKPiArKQo+ICsgICAgIC4uLj4KPiArIH0KPiArCj4gKy8vIENvbnZlcnQgcmVtYWluaW5nIGxv Y2FsX2VyciB1c2FnZS4gRm9yIGV4YW1wbGUsIGRpZmZlcmVudCBraW5kcyBvZgo+ICsvLyBlcnJv ciBjaGVja2luZyBpbiBpZiBjb25kaXRpb25hbHMuIFdlIGNhbid0IG1lcmdlIHRoaXMgaW50bwo+ ICsvLyBwcmV2aW91cyBodW5rLCBhcyB0aGlzIGNvbmZsaWN0cyB3aXRoIG90aGVyIHN1YnN0aXR1 dGlvbnMgaW4gaXQgKGF0Cj4gKy8vIGxlYXN0IHdpdGggIi0gbG9jYWxfZXJyID0gTlVMTCIpLgo+ ICtAIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyQAo+ICtpZGVudGlmaWVyIHJ1bGUxLmZuLCBy dWxlMS5sb2NhbF9lcnI7Cj4gK3N5bWJvbCBlcnJwOwo+ICtAQAo+ICsKPiArIGZuKC4uLiwgRXJy b3IgKiogX19fXywgLi4uKQo+ICsgewo+ICsgICAgIDwuLi4KPiArLSAgICBsb2NhbF9lcnIKPiAr KyAgICAqZXJycAo+ICsgICAgIC4uLj4KPiArIH0KPiArCj4gKy8vIEFsd2F5cyB1c2UgdGhlIHNh bWUgcGF0dGVybiBmb3IgY2hlY2tpbmcgZXJyb3IKPiArQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxp ZmllckAKPiAraWRlbnRpZmllciBydWxlMS5mbjsKPiArc3ltYm9sIGVycnA7Cj4gK0BACj4gKwo+ ICsgZm4oLi4uLCBFcnJvciAqKiBfX19fLCAuLi4pCj4gKyB7Cj4gKyAgICAgPC4uLgo+ICstICAg ICplcnJwICE9IE5VTEwKPiArKyAgICAqZXJycAo+ICsgICAgIC4uLj4KPiArIH0KPiArCj4gKy8v IFJldmVydCB0ZW1wb3JhcnkgX19fIGlkZW50aWZpZXIuCj4gK0AgZGlzYWJsZSBvcHRpb25hbF9x dWFsaWZpZXJACj4gK2lkZW50aWZpZXIgcnVsZTEuZm47Cj4gK0BACj4gKwo+ICsgZm4oLi4uLCBF cnJvciAqKgo+ICstICAgX19fXwo+ICsrICAgZXJycAo+ICsgICAgLCAuLi4pCj4gKyB7Cj4gKyAg ICAgLi4uCj4gKyB9Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvcWFwaS9lcnJvci5oIGIvaW5jbHVk ZS9xYXBpL2Vycm9yLmgKPiBpbmRleCAzMDE0MGQ5YmZlLi41NmMxMzM1MjBkIDEwMDY0NAo+IC0t LSBhL2luY2x1ZGUvcWFwaS9lcnJvci5oCj4gKysrIGIvaW5jbHVkZS9xYXBpL2Vycm9yLmgKPiBA QCAtMjE0LDYgKzIxNCw5IEBACj4gICAqICAgICAgICAgfQo+ICAgKiAgICAgICAgIC4uLgo+ICAg KiAgICAgfQo+ICsgKgo+ICsgKiBGb3IgbWFzcy1jb252ZXJzaW9uIHVzZSBzY3JpcHQKPiArICog ICBzY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kKPiAgICovCj4g IAo+ICAjaWZuZGVmIEVSUk9SX0gKPiBkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJ TkVSUwo+IGluZGV4IDMyODY3YmM2MzYuLjhiNzcxMjdjMzUgMTAwNjQ0Cj4gLS0tIGEvTUFJTlRB SU5FUlMKPiArKysgYi9NQUlOVEFJTkVSUwo+IEBAIC0yMDE2LDYgKzIwMTYsNyBAQCBGOiBpbmNs dWRlL3FlbXUvZXJyb3ItcmVwb3J0LmgKPiAgRjogcWFwaS9lcnJvci5qc29uCj4gIEY6IHV0aWwv ZXJyb3IuYwo+ICBGOiB1dGlsL3FlbXUtZXJyb3IuYwo+ICtGOiBzY3JpcHRzL2NvY2NpbmVsbGUv KmVyciouY29jY2kKPiAgCj4gIEdEQiBzdHViCj4gIE06IEFsZXggQmVubsOpZSA8YWxleC5iZW5u ZWVAbGluYXJvLm9yZz4KCldpdGggdGhlIG1pbm9yIGNvbW1lbnQgaXNzdWVzIGFkZHJlc3NlZDoK UmV2aWV3ZWQtYnk6IE1hcmt1cyBBcm1icnVzdGVyIDxhcm1icnVAcmVkaGF0LmNvbT4KCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFp bGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhl bnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs 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.5 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 BE558C4332B for ; Fri, 20 Mar 2020 16:20:06 +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 77A3F20724 for ; Fri, 20 Mar 2020 16:20:06 +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="I/eiWlo0" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 77A3F20724 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]:55652 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jFKNR-0005XV-L3 for qemu-devel@archiver.kernel.org; Fri, 20 Mar 2020 12:20:05 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:44027) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jFKMB-0004Br-Pv for qemu-devel@nongnu.org; Fri, 20 Mar 2020 12:18:50 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1jFKM8-0002jm-N7 for qemu-devel@nongnu.org; Fri, 20 Mar 2020 12:18:47 -0400 Received: from us-smtp-delivery-74.mimecast.com ([63.128.21.74]:59319) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1jFKM8-0002jN-Ii for qemu-devel@nongnu.org; Fri, 20 Mar 2020 12:18:44 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584721124; 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=NZUMLUevxFLH08VSvN87F8sn7tYw+p30q0xUrtvYmJs=; b=I/eiWlo0j098uX2hwF8ZE9NJVwNIeFnbJd0Lnf18U7aFi+xg2LZ19gQkaqAIP2H17pUUnH sgU6+HIu55/xi2daqGw/KnmSI6aB5ma09WOsJ9IPJBjbQJgZNijg/uE7n2ejc3cu2qt36s ThrtcBKaGRTu7GZ/Z9DLIwpDPNb9Mic= 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-274-Xolm4TDuP8a2gNAOB2VUiA-1; Fri, 20 Mar 2020 12:18:42 -0400 X-MC-Unique: Xolm4TDuP8a2gNAOB2VUiA-1 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 8D996DB3B; Fri, 20 Mar 2020 16:18:40 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-112-130.ams2.redhat.com [10.36.112.130]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 84CE4F6E6; Fri, 20 Mar 2020 16:18:33 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id 52A841138404; Fri, 20 Mar 2020 17:18:32 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy Subject: Re: [PATCH v10 2/9] scripts: Coccinelle script to use ERRP_AUTO_PROPAGATE() References: <20200317151625.20797-1-vsementsov@virtuozzo.com> <20200317151625.20797-3-vsementsov@virtuozzo.com> Date: Fri, 20 Mar 2020 17:18:32 +0100 In-Reply-To: <20200317151625.20797-3-vsementsov@virtuozzo.com> (Vladimir Sementsov-Ogievskiy's message of "Tue, 17 Mar 2020 18:16:18 +0300") Message-ID: <875zezyp7r.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.84 on 10.5.11.23 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] X-Received-From: 63.128.21.74 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" 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: Stefan Hajnoczi > Cc: Stefano Stabellini > Cc: Anthony Perard > Cc: Paul Durrant > 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 | 336 ++++++++++++++++++ > include/qapi/error.h | 3 + > MAINTAINERS | 1 + > 3 files changed, 340 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..5188b07006 > --- /dev/null > +++ b/scripts/coccinelle/auto-propagated-errp.cocci > @@ -0,0 +1,336 @@ > +// 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. > + > +// 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 does not > +// match 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); > +) > + ... > +) > + } > + > +// Warn when several Error * definitions are in the control flow. > +// This rule is not chained to rule1 and less restrictive, to cover more > +// functions to warn (even those we are not going to convert). > +// > +// Note, that even with one (or zero) Error * definition in the each > +// control flow we may have several (in total) Error * definitions in > +// the function. This case deserves attention too, but I don't see > +// simple way to match with help of coccinelle. > +@check1 disable optional_qualifier exists@ > +identifier fn, _errp, local_err, local_err2; > +position p1, p2; > +@@ > + > + fn(..., Error **_errp, ...) > + { > + ... > + Error *local_err =3D NULL;@p1 > + ... when any > + Error *local_err2 =3D NULL;@p2 > + ... when any > + } > + > +@ script:python @ > +fn << check1.fn; > +p1 << check1.p1; > +p2 << check1.p2; > +@@ > + > +print('Warning: function {} has several definitions of ' > + 'Error * local variable: at {}:{} and then at {}:{}'.format( > + fn, p1[0].file, p1[0].line, p2[0].file, p2[0].line)) > + > +// Warn when several propagations are in the control flow. > +@check2 disable optional_qualifier exists@ > +identifier fn, _errp; > +position p1, p2; > +@@ > + > + fn(..., Error **_errp, ...) > + { > + ... > +( > + error_propagate_prepend(_errp, ...);@p1 > +| > + error_propagate(_errp, ...);@p1 > +) > + ... > +( > + error_propagate_prepend(_errp, ...);@p2 > +| > + error_propagate(_errp, ...);@p2 > +) > + ... when any > + } > + > +@ 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)) > + > +// 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 common case is a single definition of local_err with at most one > +// error_propagate_prepend() or error_propagate() on each control-flow > +// path. Functions with multiple definitions or propagates we want to > +// examine manually. Later rules emit warnings to guide us to them. "Later rules" is no longer correct. Suggest "Rules check1 and check2". > +// > +// Note that we match not only this "common case", but any function, > +// which has the "common cose" on at least one control-flow path. I appreciate this note. Typo: s/cose/case/ > +@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); > +) > + ... > + } > + > +// 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; > +symbol errp; > +@@ > + > + fn(..., Error ** ____, ...) > + { > + <... > +- goto out; > ++ return; > + ...> > +- out: > +- error_propagate(errp, local_err); > + } > + > +// Convert most of local_err related stuff. > +// > +// Note, that we inherit rule1.fn and rule1.local_err names, not > +// objects themselves. 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. > +// > +// 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 32867bc636..8b77127c35 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -2016,6 +2016,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 With the minor comment issues addressed: Reviewed-by: Markus Armbruster