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 4BFF2C4CECE for ; Fri, 13 Mar 2020 21:55:27 +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 06B4A2074E for ; Fri, 13 Mar 2020 21:55:26 +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="FD2j9sA1" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 06B4A2074E 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 1jCsGP-0004op-Jj; Fri, 13 Mar 2020 21:54:41 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1jCsGO-0004oi-5S for xen-devel@lists.xenproject.org; Fri, 13 Mar 2020 21:54:40 +0000 X-Inumbo-ID: 3be2e94a-6575-11ea-bec1-bc764e2007e4 Received: from us-smtp-delivery-1.mimecast.com (unknown [205.139.110.61]) by us1-rack-iad1.inumbo.com (Halon) with ESMTP id 3be2e94a-6575-11ea-bec1-bc764e2007e4; Fri, 13 Mar 2020 21:54:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584136477; 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=NvrbxEp0ORNjN4T28u8DpDcF2uEiVqe5w/63L03txyY=; b=FD2j9sA1HsQ4AwrYvkCmYPr5cb42r+EhBK7EeQRnoaciiuds/bpDz5Xu3CrpoJotZT7yQg xWj43cvbSI1qE1M2BIsDQAUR0NBUsUNasw5ngXn8wH6/cpDxaj3jzbsIy4Szd4Px1hLSz+ ronyL4qbiAvibixQCd0guC7R4i9sU5I= 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-428-dbVRRJwyPVqPHVlfE5CTUg-1; Fri, 13 Mar 2020 17:54:30 -0400 X-MC-Unique: dbVRRJwyPVqPHVlfE5CTUg-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 6C7351060DF6; Fri, 13 Mar 2020 21:54:28 +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 293AA5C1B0; Fri, 13 Mar 2020 21:54:22 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id A69B611386A6; Fri, 13 Mar 2020 22:54:20 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy References: <20200312085936.9552-1-vsementsov@virtuozzo.com> <20200312085936.9552-3-vsementsov@virtuozzo.com> <874kuto7hq.fsf@dusky.pond.sub.org> <4a70c6ee-10a2-fdc3-f8df-88c05340398b@virtuozzo.com> <875zf8gt2m.fsf@dusky.pond.sub.org> <7c6f9a91-76cf-242d-8166-0693ec14b24d@virtuozzo.com> Date: Fri, 13 Mar 2020 22:54:20 +0100 In-Reply-To: <7c6f9a91-76cf-242d-8166-0693ec14b24d@virtuozzo.com> (Vladimir Sementsov-Ogievskiy's message of "Fri, 13 Mar 2020 19:12:17 +0300") Message-ID: <87blozex9v.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.16 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 , qemu-block@nongnu.org, Paul Durrant , qemu-devel@nongnu.org, Laszlo Ersek , Christian Schoenebeck , Markus Armbruster , Michael Roth , Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , 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+IDEzLjAzLjIwMjAgMTg6NDIsIE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+PiBW bGFkaW1pciBTZW1lbnRzb3YtT2dpZXZza2l5IDx2c2VtZW50c292QHZpcnR1b3p6by5jb20+IHdy aXRlczoKPj4KPj4+IDEyLjAzLjIwMjAgMTk6MzYsIE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+ Pj4+IEkgbWF5IGhhdmUgYSBzZWNvbmQgbG9vayB0b21vcnJvdyB3aXRoIGZyZXNoZXIgZXllcywg YnV0IGxldCdzIGdldCB0aGlzCj4+Pj4gb3V0IG5vdyBhcyBpcy4KPj4+Pgo+Pj4+IFZsYWRpbWly IFNlbWVudHNvdi1PZ2lldnNraXkgPHZzZW1lbnRzb3ZAdmlydHVvenpvLmNvbT4gd3JpdGVzOgo+ Pj4+Cj4+Pj4+IFNjcmlwdCBhZGRzIEVSUlBfQVVUT19QUk9QQUdBVEUgbWFjcm8gaW52b2NhdGlv biB3aGVyZSBhcHByb3ByaWF0ZSBhbmQKPj4+Pj4gZG9lcyBjb3JyZXNwb25kaW5nIGNoYW5nZXMg aW4gY29kZSAobG9vayBmb3IgZGV0YWlscyBpbgo+Pj4+PiBpbmNsdWRlL3FhcGkvZXJyb3IuaCkK Pj4+Pj4KPj4+Pj4gVXNhZ2UgZXhhbXBsZToKPj4+Pj4gc3BhdGNoIC0tc3AtZmlsZSBzY3JpcHRz L2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kgXAo+Pj4+PiAgICAtLW1hY3Jv LWZpbGUgc2NyaXB0cy9jb2NjaS1tYWNyby1maWxlLmggLS1pbi1wbGFjZSAtLW5vLXNob3ctZGlm ZiBcCj4+Pj4+ICAgIC0tbWF4LXdpZHRoIDgwIEZJTEVTLi4uCj4+Pj4+Cj4+Pj4+IFNpZ25lZC1v ZmYtYnk6IFZsYWRpbWlyIFNlbWVudHNvdi1PZ2lldnNraXkgPHZzZW1lbnRzb3ZAdmlydHVvenpv LmNvbT4KPj4+Pj4gLS0tCj4+Pj4+Cj4+Pj4+IENjOiBFcmljIEJsYWtlIDxlYmxha2VAcmVkaGF0 LmNvbT4KPj4+Pj4gQ2M6IEtldmluIFdvbGYgPGt3b2xmQHJlZGhhdC5jb20+Cj4+Pj4+IENjOiBN YXggUmVpdHogPG1yZWl0ekByZWRoYXQuY29tPgo+Pj4+PiBDYzogR3JlZyBLdXJ6IDxncm91Z0Br YW9kLm9yZz4KPj4+Pj4gQ2M6IENocmlzdGlhbiBTY2hvZW5lYmVjayA8cWVtdV9vc3NAY3J1ZGVi eXRlLmNvbT4KPj4+Pj4gQ2M6IFN0ZWZhbm8gU3RhYmVsbGluaSA8c3N0YWJlbGxpbmlAa2VybmVs Lm9yZz4KPj4+Pj4gQ2M6IEFudGhvbnkgUGVyYXJkIDxhbnRob255LnBlcmFyZEBjaXRyaXguY29t Pgo+Pj4+PiBDYzogUGF1bCBEdXJyYW50IDxwYXVsQHhlbi5vcmc+Cj4+Pj4+IENjOiBTdGVmYW4g SGFqbm9jemkgPHN0ZWZhbmhhQHJlZGhhdC5jb20+Cj4+Pj4+IENjOiAiUGhpbGlwcGUgTWF0aGll dS1EYXVkw6kiIDxwaGlsbWRAcmVkaGF0LmNvbT4KPj4+Pj4gQ2M6IExhc3psbyBFcnNlayA8bGVy c2VrQHJlZGhhdC5jb20+Cj4+Pj4+IENjOiBHZXJkIEhvZmZtYW5uIDxrcmF4ZWxAcmVkaGF0LmNv bT4KPj4+Pj4gQ2M6IFN0ZWZhbiBCZXJnZXIgPHN0ZWZhbmJAbGludXguaWJtLmNvbT4KPj4+Pj4g Q2M6IE1hcmt1cyBBcm1icnVzdGVyIDxhcm1icnVAcmVkaGF0LmNvbT4KPj4+Pj4gQ2M6IE1pY2hh ZWwgUm90aCA8bWRyb3RoQGxpbnV4LnZuZXQuaWJtLmNvbT4KPj4+Pj4gQ2M6IHFlbXUtZGV2ZWxA bm9uZ251Lm9yZwo+Pj4+PiBDYzogcWVtdS1ibG9ja0Bub25nbnUub3JnCj4+Pj4+IENjOiB4ZW4t ZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKPj4+Pj4KPj4+Pj4gICAgc2NyaXB0cy9jb2NjaW5l bGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2NpIHwgMzI3ICsrKysrKysrKysrKysrKysrKwo+ Pj4+PiAgICBpbmNsdWRlL3FhcGkvZXJyb3IuaCAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg IDMgKwo+Pj4+PiAgICBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgIDEgKwo+Pj4+PiAgICAzIGZpbGVzIGNoYW5nZWQsIDMzMSBpbnNlcnRpb25zKCspCj4+ Pj4+ICAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBzY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdh dGVkLWVycnAuY29jY2kKPj4+Pj4KPj4+Pj4gZGlmZiAtLWdpdCBhL3NjcmlwdHMvY29jY2luZWxs ZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSBiL3NjcmlwdHMvY29jY2luZWxsZS9hdXRvLXBy b3BhZ2F0ZWQtZXJycC5jb2NjaQo+Pj4+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+Pj4+PiBpbmRl eCAwMDAwMDAwMDAwLi43ZGFjMmRjZmE0Cj4+Pj4+IC0tLSAvZGV2L251bGwKPj4+Pj4gKysrIGIv c2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2NpCj4+Pj4+IEBAIC0w LDAgKzEsMzI3IEBACj4+Pj4+ICsvLyBVc2UgRVJSUF9BVVRPX1BST1BBR0FURSAoc2VlIGluY2x1 ZGUvcWFwaS9lcnJvci5oKQo+Pj4+PiArLy8KPj4+Pj4gKy8vIENvcHlyaWdodCAoYykgMjAyMCBW aXJ0dW96em8gSW50ZXJuYXRpb25hbCBHbWJILgo+Pj4+PiArLy8KPj4+Pj4gKy8vIFRoaXMgcHJv Z3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKPj4+ Pj4gKy8vIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGFzCj4+Pj4+ICsvLyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUKPj4+Pj4gKy8vIExpY2Vuc2UsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCj4+Pj4+ICsvLwo+Pj4+PiArLy8gVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCj4+Pj4+ICsvLyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgo+Pj4+PiArLy8gTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+Pj4+PiArLy8gR05VIEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPj4+Pj4gKy8vCj4+Pj4+ICsvLyBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQo+Pj4+PiArLy8gYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZQo+Pj4+ PiArLy8gPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+Lgo+Pj4+PiArLy8KPj4+Pj4gKy8v IFVzYWdlIGV4YW1wbGU6Cj4+Pj4+ICsvLyBzcGF0Y2ggLS1zcC1maWxlIHNjcmlwdHMvY29jY2lu ZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSBcCj4+Pj4+ICsvLyAgLS1tYWNyby1maWxl IHNjcmlwdHMvY29jY2ktbWFjcm8tZmlsZS5oIC0taW4tcGxhY2UgXAo+Pj4+PiArLy8gIC0tbm8t c2hvdy1kaWZmIC0tbWF4LXdpZHRoIDgwIEZJTEVTLi4uCj4+Pj4+ICsvLwo+Pj4+PiArLy8gTm90 ZTogLS1tYXgtd2lkdGggODAgaXMgbmVlZGVkIGJlY2F1c2UgY29jY2luZWxsZSBkZWZhdWx0IGlz IGxlc3MKPj4+Pj4gKy8vIHRoYW4gODAsIGFuZCB3aXRob3V0IHRoaXMgcGFyYW1ldGVyIGNvY2Np bmVsbGUgbWF5IHJlaW5kZW50IHNvbWUKPj4+Pj4gKy8vIGxpbmVzIHdoaWNoIGZpdCBpbnRvIDgw IGNoYXJhY3RlcnMgYnV0IG5vdCB0byBjb2NjaW5lbGxlIGRlZmF1bHQsCj4+Pj4+ICsvLyB3aGlj aCBpbiB0dXJuIHByb2R1Y2VzIGV4dHJhIHBhdGNoIGh1bmtzIGZvciBubyByZWFzb24uCj4+Pj4K Pj4+PiBUaGlzIGlzIGFib3V0IHVud2FudGVkIHJlZm9ybWF0dGluZyBvZiBwYXJhbWV0ZXIgbGlz dHMgZHVlIHRvIHRoZSBfX18KPj4+PiBjaGFpbmluZyBoYWNrLiAgLS1tYXgtd2lkdGggODAgbWFr ZXMgdGhhdCBsZXNzIGxpa2VseSwgYnV0IG5vdAo+Pj4+IGltcG9zc2libGUuCj4+Pj4KPj4+PiBX ZSBjYW4gc2VhcmNoIGZvciB1bndhbnRlZCByZWZvcm1hdHRpbmcgb2YgcGFyYW1ldGVyIGxpc3Rz LiAgSSB0aGluawo+Pj4+IGdyZXBwaW5nIGRpZmZzIGZvciAnXlwrLipFcnJvciBcKlwqJyBzaG91 bGQgZG8gdGhlIHRyaWNrLiAgRm9yIHRoZSB3aG9sZQo+Pj4+IHRyZWUsIEkgZ2V0IG9uZSBmYWxz ZSBwb3NpdGl2ZSAobm90IGEgcGFyYW1ldGVyIGxpc3QpLCBhbmQgb25lIGhpdDoKPj4+Pgo+Pj4+ ICAgICAgIEBAIC0zODgsOCArMzg4LDEwIEBAIHN0YXRpYyB2b2lkIG9iamVjdF9wb3N0X2luaXRf d2l0aF90eXBlKE8KPj4+PiAgICAgICAgICAgIH0KPj4+PiAgICAgICAgfQo+Pj4+Cj4+Pj4gICAg ICAgLXZvaWQgb2JqZWN0X2FwcGx5X2dsb2JhbF9wcm9wcyhPYmplY3QgKm9iaiwgY29uc3QgR1B0 ckFycmF5ICpwcm9wcywgRXJyb3IgKiplcnJwKQo+Pj4+ICAgICAgICt2b2lkIG9iamVjdF9hcHBs eV9nbG9iYWxfcHJvcHMoT2JqZWN0ICpvYmosIGNvbnN0IEdQdHJBcnJheSAqcHJvcHMsCj4+Pj4g ICAgICAgKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFcnJvciAqKmVycnApCj4+Pj4g ICAgICAgIHsKPj4+PiAgICAgICArICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKPj4+PiAgICAg ICAgICAgIGludCBpOwo+Pj4+Cj4+Pj4gICAgICAgICAgICBpZiAoIXByb3BzKSB7Cj4+Pj4KPj4+ PiBSZWZvcm1hdHRpbmcsIGJ1dCBub3QgdW53YW50ZWQuCj4+Pgo+Pj4gWWVzLCBJIHNhdyBpdC4g VGhpcyBsaW5lIGlzIDgxIGNoYXJhY3RlciBsZW5ndGgsIHNvIGl0J3MgT0sgdG8gZml4IGl0IGlu IG9uZSBodW5rIHdpdGgKPj4+IEVSUlBfQVVUT19QUk9QQUdBVEUgYWRkaXRpb24gZXZlbiBmb3Ig bm9uLWF1dG9tYXRpYyBwYXRjaC4KPj4KPj4gQWdyZWUuCj4+Cj4+Pj4KPj4+PiBUaGUgLS1tYXgt d2lkdGggODAgaGFjayBpcyBnb29kIGVub3VnaCBmb3IgbWUuCj4+Pj4KPj4+PiBJdCBkb2VzIHJl c3VsdCBpbiBzbGlnaHRseSBsb25nIHRyYW5zZm9ybWVkIGxpbmVzLCBlLmcuIHRoaXMgb25lIGlu Cj4+Pj4gcmVwbGljYXRpb24uYzoKPj4+Pgo+Pj4+ICAgICAgIEBAIC0xMTMsNyArMTEzLDcgQEAg c3RhdGljIGludCByZXBsaWNhdGlvbl9vcGVuKEJsb2NrRHJpdmVyUwo+Pj4+ICAgICAgICAgICAg ICAgIHMtPm1vZGUgPSBSRVBMSUNBVElPTl9NT0RFX1BSSU1BUlk7Cj4+Pj4gICAgICAgICAgICAg ICAgdG9wX2lkID0gcWVtdV9vcHRfZ2V0KG9wdHMsIFJFUExJQ0FUSU9OX1RPUF9JRCk7Cj4+Pj4g ICAgICAgICAgICAgICAgaWYgKHRvcF9pZCkgewo+Pj4+ICAgICAgIC0gICAgICAgICAgICBlcnJv cl9zZXRnKCZsb2NhbF9lcnIsICJUaGUgcHJpbWFyeSBzaWRlIGRvZXMgbm90IHN1cHBvcnQgb3B0 aW9uIHRvcC1pZCIpOwo+Pj4+ICAgICAgICsgICAgICAgICAgICBlcnJvcl9zZXRnKGVycnAsICJU aGUgcHJpbWFyeSBzaWRlIGRvZXMgbm90IHN1cHBvcnQgb3B0aW9uIHRvcC1pZCIpOwo+Pj4+ICAg ICAgICAgICAgICAgICAgICBnb3RvIGZhaWw7Cj4+Pj4gICAgICAgICAgICAgICAgfQo+Pj4+ICAg ICAgICAgICAgfSBlbHNlIGlmICghc3RyY21wKG1vZGUsICJzZWNvbmRhcnkiKSkgewo+Pj4+Cj4+ Pj4gdjggZGlkIGJyZWFrIHRoaXMgbGluZSAodGhhdCdzIGhvdyBJIGZvdW5kIGl0KS4gIEhvd2V2 ZXIsIHY5IHN0aWxsCj4+Pj4gc2hvcnRlbnMgdGhlIGxpbmUsIGp1c3Qgbm90IGJlbG93IHRoZSB0 YXJnZXQuICBBbGwgeW91ciArIGxpbmVzIGxvb2sKPj4+PiBxdWl0ZSB1bmxpa2VseSB0byBsZW5n dGhlbiBsaW5lcy4gIExldCdzIG5vdCB3b3JyeSBhYm91dCB0aGlzLgo+Pj4+Cj4+Pj4+ICsvLyBT d2l0Y2ggdW51c3VhbCBFcnJvciAqKiBwYXJhbWV0ZXIgbmFtZXMgdG8gZXJycAo+Pj4+PiArLy8g KHRoaXMgaXMgbmVjZXNzYXJ5IHRvIHVzZSBFUlJQX0FVVE9fUFJPUEFHQVRFKS4KPj4+Pj4gKy8v Cj4+Pj4+ICsvLyBEaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciB0byBza2lwIGZ1bmN0aW9ucyB3 aXRoCj4+Pj4+ICsvLyAiRXJyb3IgKmNvbnN0ICplcnJwIiBwYXJhbWV0ZXIuCj4+Pj4+ICsvLwo+ Pj4+PiArLy8gU2tpcCBmdW5jdGlvbnMgd2l0aCAiYXNzZXJ0KF9lcnJwICYmICpfZXJycCkiIHN0 YXRlbWVudCwgYmVjYXVzZQo+Pj4+PiArLy8gdGhhdCBzaWduYWxzIHVudXN1YWwgc2VtYW50aWNz LCBhbmQgdGhlIHBhcmFtZXRlciBuYW1lIG1heSB3ZWxsCj4+Pj4+ICsvLyBzZXJ2ZSBhIHB1cnBv c2UuIChsaWtlIG5iZF9pdGVyX2NoYW5uZWxfZXJyb3IoKSkuCj4+Pj4+ICsvLwo+Pj4+PiArLy8g U2tpcCB1dGlsL2Vycm9yLmMgdG8gbm90IHRvdWNoLCBmb3IgZXhhbXBsZSwgZXJyb3JfcHJvcGFn YXRlKCkgYW5kCj4+Pj4+ICsvLyBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZCgpLgo+Pj4+PiArQCBk ZXBlbmRzIG9uICEoZmlsZSBpbiAidXRpbC9lcnJvci5jIikgZGlzYWJsZSBvcHRpb25hbF9xdWFs aWZpZXJACj4+Pj4+ICtpZGVudGlmaWVyIGZuOwo+Pj4+PiAraWRlbnRpZmllciBfZXJycCAhPSBl cnJwOwo+Pj4+PiArQEAKPj4+Pj4gKwo+Pj4+PiArIGZuKC4uLiwKPj4+Pj4gKy0gICBFcnJvciAq Kl9lcnJwCj4+Pj4+ICsrICAgRXJyb3IgKiplcnJwCj4+Pj4+ICsgICAgLC4uLikKPj4+Pj4gKyB7 Cj4+Pj4+ICsoCj4+Pj4+ICsgICAgIC4uLiB3aGVuICE9IGFzc2VydChfZXJycCAmJiAqX2VycnAp Cj4+Pj4+ICsmCj4+Pj4+ICsgICAgIDwuLi4KPj4+Pj4gKy0gICAgX2VycnAKPj4+Pj4gKysgICAg ZXJycAo+Pj4+PiArICAgICAuLi4+Cj4+Pj4+ICspCj4+Pj4+ICsgfQo+Pj4+PiArCj4+Pj4+ICsv LyBBZGQgaW52b2NhdGlvbiBvZiBFUlJQX0FVVE9fUFJPUEFHQVRFIHRvIGVycnAtZnVuY3Rpb25z IHdoZXJlCj4+Pj4+ICsvLyBuZWNlc3NhcnkKPj4+Pj4gKy8vCj4+Pj4+ICsvLyBOb3RlLCB0aGF0 IHdpdGhvdXQgIndoZW4gYW55IiB0aGUgZmluYWwgIi4uLiIgZG9lcyBub3QgbWFjaAo+Pj4+PiAr Ly8gc29tZXRoaW5nIG1hdGNoZWQgYnkgcHJldmlvdXMgcGF0dGVybiwgaS5lLiB0aGUgcnVsZSB3 aWxsIG5vdCBtYXRjaAo+Pj4+PiArLy8gZG91YmxlIGVycm9yX3ByZXBlbmQgaW4gY29udHJvbCBm bG93IGxpa2UgaW4KPj4+Pj4gKy8vIHZmaW9fc2V0X2lycV9zaWduYWxpbmcoKS4KPj4+Pj4gKy8v Cj4+Pj4+ICsvLyBOb3RlLCAiZXhpc3RzIiBzYXlzIHRoYXQgd2Ugd2FudCBhcHBseSBydWxlIGV2 ZW4gaWYgaXQgbWF0Y2hlcyBub3QKPj4+Pj4gKy8vIG9uIGFsbCBwb3NzaWJsZSBjb250cm9sIGZs b3dzIChvdGhlcndpc2UsIGl0IHdpbGwgbm90IG1hdGNoCj4+Pj4+ICsvLyBzdGFuZGFyZCBwYXR0 ZXJuIHdoZW4gZXJyb3JfcHJvcGFnYXRlKCkgY2FsbCBpcyBpbiBpZiBicmFuY2gpLgo+Pj4+PiAr QCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4+Pj4+ICtpZGVudGlmaWVyIGZu LCBsb2NhbF9lcnI7Cj4+Pj4+ICtzeW1ib2wgZXJycDsKPj4+Pj4gK0BACj4+Pj4+ICsKPj4+Pj4g KyBmbiguLi4sIEVycm9yICoqZXJycCwgLi4uKQo+Pj4+PiArIHsKPj4+Pj4gKysgICBFUlJQX0FV VE9fUFJPUEFHQVRFKCk7Cj4+Pj4+ICsgICAgLi4uICB3aGVuICE9IEVSUlBfQVVUT19QUk9QQUdB VEUoKTsKPj4+Pj4gKygKPj4+Pj4gKygKPj4+Pj4gKyAgICBlcnJvcl9hcHBlbmRfaGludChlcnJw LCAuLi4pOwo+Pj4+PiArfAo+Pj4+PiArICAgIGVycm9yX3ByZXBlbmQoZXJycCwgLi4uKTsKPj4+ Pj4gK3wKPj4+Pj4gKyAgICBlcnJvcl92cHJlcGVuZChlcnJwLCAuLi4pOwo+Pj4+PiArKQo+Pj4+ PiArICAgIC4uLiB3aGVuIGFueQo+Pj4+PiArfAo+Pj4+PiArICAgIEVycm9yICpsb2NhbF9lcnIg PSBOVUxMOwo+Pj4+PiArICAgIC4uLgo+Pj4+PiArKAo+Pj4+PiArICAgIGVycm9yX3Byb3BhZ2F0 ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgLi4uKTsKPj4+Pj4gK3wKPj4+Pj4gKyAgICBlcnJv cl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKPj4+Pj4gKykKPj4+Pj4gKyAgICAuLi4KPj4+ Pj4gKykKPj4+Pj4gKyB9Cj4+Pj4+ICsKPj4+Pj4gKwo+Pj4+PiArLy8gTWF0Y2ggZnVuY3Rpb25z IHdpdGggcHJvcGFnYXRpb24gb2YgbG9jYWwgZXJyb3IgdG8gZXJycC4KPj4+Pj4gKy8vIFdlIHdh bnQgdG8gcmVmZXIgdGhlc2UgZnVuY3Rpb25zIGluIHNldmVyYWwgZm9sbG93aW5nIHJ1bGVzLCBi dXQgSQo+Pj4+PiArLy8gZG9uJ3Qga25vdyBhIHByb3BlciB3YXkgdG8gaW5oZXJpdCBhIGZ1bmN0 aW9uLCBub3QganVzdCBpdHMgbmFtZQo+Pj4+PiArLy8gKHRvIG5vdCBtYXRjaCBhbm90aGVyIGZ1 bmN0aW9ucyB3aXRoIHNhbWUgbmFtZSBpbiBmb2xsb3dpbmcgcnVsZXMpLgo+Pj4+PiArLy8gTm90 LXByb3BlciB3YXkgaXMgYXMgZm9sbG93czogcmVuYW1lIGVycnAgcGFyYW1ldGVyIGluIGZ1bmN0 aW9ucwo+Pj4+PiArLy8gaGVhZGVyIGFuZCBtYXRjaCBpdCBpbiBmb2xsb3dpbmcgcnVsZXMuIFJl bmFtZSBpdCBiYWNrIGFmdGVyIGFsbAo+Pj4+PiArLy8gdHJhbnNmb3JtYXRpb25zLgo+Pj4+PiAr Ly8KPj4+Pj4gKy8vIFRoZSBzaW1wbGVzdCBjYXNlIG9mIHByb3BhZ2F0aW9uIHNjaGVtZSBpcyBz aW5nbGUgZGVmaW5pdGlvbiBvZgo+Pj4+PiArLy8gbG9jYWxfZXJyIHdpdGggYXQgbW9zdCBvbmUg ZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQgb3IKPj4+Pj4gKy8vIGVycm9yX3Byb3BhZ2F0ZSBvbiBl YWNoIGNvbnRyb2wtZmxvdy4gU3RpbGwsIHdlIHdhbnQgdG8gbWF0Y2ggbW9yZQo+Pj4+PiArLy8g Y29tcGxleCBzY2hlbWVzIHRvby4gV2UnbGwgd2FybiB0aGVtIHdpdGggaGVscCBvZiBmdXJ0aGVy IHJ1bGVzLgo+Pj4+Cj4+Pj4gSSB0aGluayB3aGF0IHdlIGFjdHVhbGx5IHdhbnQgaXMgdG8gZXhh bWluZSBpbnN0YW5jZXMgb2YgdGhpcyBwYXR0ZXJuIHRvCj4+Pj4gZmlndXJlIG91dCB3aGV0aGVy IGFuZCBob3cgd2Ugd2FudCB0byB0cmFuc2Zvcm0gdGhlbS4gIFBlcmhhcHM6Cj4+Pj4KPj4+PiAg ICAgICAvLyBUaGUgY29tbW9uIGNhc2UgaXMgYSBzaW5nbGUgZGVmaW5pdGlvbiBvZiBsb2NhbF9l cnIgd2l0aCBhdCBtb3N0IG9uZQo+Pj4+ICAgICAgIC8vIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5k KCkgb3IgZXJyb3JfcHJvcGFnYXRlKCkgb24gZWFjaCBjb250cm9sLWZsb3cKPj4+PiAgICAgICAv LyBwYXRoLiBJbnN0YW5jZXMgb2YgdGhpcyBjYXNlIHdlIGNvbnZlcnQgd2l0aCB0aGlzIHNjcmlw dC4gRnVuY3Rpb25zCj4+Pgo+Pj4gRm9yIG1lLCBzb3VuZHMgYSBiaXQgbGlrZSAib3RoZXIgdGhp bmdzIHdlIGRvbid0IGNvbnZlcnQiLgo+Pj4gQWN0dWFsbHkgd2UgY29udmVydCBvdGhlciB0aGlu Z3MgdG9vLgo+Pgo+PiBXaGF0IG90aGVyIHBhdHRlcm5zIG9mIGVycm9yIHByb3BhZ2F0aW9uIGRv IHdlIGNvbnZlcnQ/Cj4KPiBTb21ldGhpbmcgbGlrZSBpbiB4ZW5fYmxvY2tfZGV2aWNlX2Rlc3Ry b3ksIHdoeSBub3Q/IE90aGVyd2lzZSwgaXQncyBiZXR0ZXIgdG8gYXZvaWQKPiBtYXRjaGluZyB0 aGluZ3MgbGlrZSB4ZW5fYmxvY2tfZGV2aWNlX2Rlc3Ryb3ksIG5vdCBqdXN0IHdhcm4gdGhlbS4K PiBCdXQgSSdkIHByZWZlciB0byBwcm9jZWVkIG5vdyBhcyBpcyB0byBmaXQgaW50byA1LjAuLiBU b28gbXVjaCB0aW1lIGFscmVhZHkKPiBzcGVudCBvbiB0aGlzLiBTbywgSSdtIE9LIHdpdGggeW91 ciB3b3JkaW5nIHRvby4KCkxldCdzIHNjcmF0Y2ggIkluc3RhbmNlcyBvZiB0aGlzIGNhc2Ugd2Ug Y29udmVydCB3aXRoIHRoaXMgc2NyaXB0LiIKCj4+Pj4gICAgICAgLy8gd2l0aCBtdWx0aXBsZSBk ZWZpbml0aW9ucyBvciBwcm9wYWdhdGVzIHdlIHdhbnQgdG8gZXhhbWluZQo+Pj4+ICAgICAgIC8v IG1hbnVhbGx5LiBMYXRlciBydWxlcyBlbWl0IHdhcm5pbmdzIHRvIGd1aWRlIHVzIHRvIHRoZW0u Cj4+Pj4KPj4+Pj4gK0BydWxlMSBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4+ Pj4+ICtpZGVudGlmaWVyIGZuLCBsb2NhbF9lcnI7Cj4+Pj4+ICtzeW1ib2wgZXJycDsKPj4+Pj4g K0BACj4+Pj4+ICsKPj4+Pj4gKyBmbiguLi4sIEVycm9yICoqCj4+Pj4+ICstICAgIGVycnAKPj4+ Pj4gKysgICAgX19fXwo+Pj4+PiArICAgICwgLi4uKQo+Pj4+PiArIHsKPj4+Pj4gKyAgICAgLi4u Cj4+Pj4+ICsgICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwo+Pj4+PiArICAgICAuLi4KPj4+ Pj4gKygKPj4+Pj4gKyAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJy LCAuLi4pOwo+Pj4+PiArfAo+Pj4+PiArICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxf ZXJyKTsKPj4+Pj4gKykKPj4+Pj4gKyAgICAgLi4uCj4+Pj4+ICsgfQo+Pj4+PiArCj4+Pj4+ICsK Pj4+Pj4gKy8vIFdhcm4gc2V2ZXJhbCBFcnJvciAqIGRlZmluaXRpb25zLgo+Pj4+PiArQGNoZWNr MSBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4+Pj4+ICtpZGVudGlmaWVyIGZu ID0gcnVsZTEuZm4sIGxvY2FsX2VyciwgbG9jYWxfZXJyMjsKPj4+Pgo+Pj4+IEVsc2V3aGVyZSwg eW91IHVzZSBqdXN0IHJ1bGUuZm4gaW5zdGVhZCBvZiBmbiA9IHJ1bGUxLmZuLiAgQW55Cj4+Pj4g cGFydGljdWxhciByZWFzb24gZm9yIHRoZSBkaWZmZXJlbmNlPwo+Pj4KPj4+IEkgZGlkbid0IGZp bmQgb3RoZXIgd2F5IHRvIHJlZiBjaGVjazEuZm4gaW4gbmV4dCBweXRob24gcnVsZS4gSXQganVz dCBkb24ndAo+Pj4gd29yayBpZiBJIHdyaXRlIGhlcmUganVzdCBydWxlMS5mbi4KPj4+Cj4+Pj4K Pj4+PiBXaXRoIHRoZSBfX18gY2hhaW5pbmcgaGFjaywgSSBkb3VidCB3ZSBzdGlsbCBuZWVkICI9 IHJ1bGUxLmZuIiBvcgo+Pj4+ICJydWxlMS5mbiIuICBJZiBJIHJlcGxhY2UgImZuID0gcnVsZTEu Zm4iIGFuZCAicnVsZS5mbiIgYnkganVzdCAiZm4iCj4+Pj4gZXZlcnl3aGVyZSwgdGhlbiBhcHBs eSB0aGUgc2NyaXB0IHRvIHRoZSBjb21wbGV0ZSB0cmVlLCBJIGdldCB0aGUgc2FtZQo+Pj4+IHJl c3VsdC4KPj4+Cj4+PiBJIHRoaW5rLCBpdCdzIG1vcmUgZWZmaWNpZW50IHRvIHJldXNlIG5hbWVz IGZyb20gcHJldmlvdXMgcnVsZXMuIEkgdGhpbmsgaXQgc2hvdWxkCj4+PiB3b3JrIGZhc3RlciAo bW9yZSBpbmZvcm1hdGlvbiwgbGVzcyBleHRyYSBtYXRjaGluZykuCj4+Cj4+IE5vcGUuICBXaXRo IG15IGhhY2tlZCB1cCBzY3JpcHQgKHBhdGNoIGFwcGVuZGVkKSBDb2NjaW5lbGxlIGlzIGFjdHVh bGx5Cj4+ICpmYXN0ZXIqIGZvciB0aGUgLltjaF0gdG91Y2hlZCBieSB0aGlzIHNlcmllczogd2l0 aCB5b3VyIHVubW9kaWZpZWQKPj4gc2NyaXB0LCBpdCB0YWtlcyBhIGJpdCBvdmVyIDEycyBvbiBt eSBib3gsIHdpdGggbWluZSBhcm91bmQgN3MuICBPdXRwdXQKPj4gaXMgaWRlbnRpY2FsLgo+Pgo+ PiBOZXZlciBndWVzcyBwZXJmb3JtYW5jZSwgYWx3YXlzIG1lYXN1cmUgaXQgOikKPgo+IEhtbSwg d2hvbGUgdHJlZSByZXN1bHRzIHdvdWxkIGJlIGJldHRlciBwcm9vZgo+Cj4+Cj4+IFR3byBub3Rl cyBvbiBteSBzY3JpcHQ6Cj4+Cj4+ICogVW5saWtlIHlvdXJzLCBpdCByZWNvZ25pemVzIGRvdWJs ZS1wcm9wYWdhdGlvbiBpbiBteSB0ZXN0IGNhc2UuCj4+ICAgIERpc2N1c3NlZCBiZWxvdy4KPj4K Pj4gKiBJdHMgInNldmVyYWwgZGVmaW5pdGlvbnMgb2YiIHdhcm5pbmcgaW5jbHVkZXMgcG9zaXRp b25zLiAgVGhhdCB0dXJuZWQKPj4gICAgb3V0IHRvIGJlIHVzZWxlc3MsIGJ1dCBJJ3ZlIGJlZW4g dG9vIGxhenkgdG8gdGFrZSB0aGF0IG91dCBhZ2Fpbi4KPj4KPj4+Pgo+Pj4+PiArQEAKPj4+Pj4g Kwo+Pj4+PiArIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+Pj4+PiArIHsKPj4+Pj4gKyAg ICAgLi4uCj4+Pj4+ICsgICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwo+Pj4+PiArICAgICAu Li4gd2hlbiBhbnkKPj4+Pj4gKyAgICAgRXJyb3IgKmxvY2FsX2VycjIgPSBOVUxMOwo+Pj4+PiAr ICAgICAuLi4gd2hlbiBhbnkKPj4+Pj4gKyB9CgpUaGlzIGZsYWdzIGZ1bmN0aW9ucyB0aGF0IGhh dmUgbW9yZSB0aGFuIG9uZSBkZWNsYXJhdGlvbiBhbG9uZyBhbnkKY29udHJvbCBmbG93IHBhdGgu ICBJdCBkb2Vzbid0IGZsYWcgdGhpcyBvbmU6CgogICAgdm9pZCBnbmF0KGJvb2wgYiwgRXJyb3Ig KiplcnJwKQogICAgewogICAgICAgIGlmIChiKSB7CiAgICAgICAgICAgIEVycm9yICpsb2NhbF9l cnIgPSBOVUxMOwogICAgICAgICAgICBmb28oYXJnLCAmbG9jYWxfZXJyKTsKICAgICAgICAgICAg ZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7CiAgICAgICAgfSBlbHNlIHsKICAgICAg ICAgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7CiAgICAgICAgICAgIGJhcihhcmcsICZsb2Nh bF9lcnIpOwogICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKICAg ICAgICB9CiAgICB9CgpUaGUgQ29jY2luZWxsZSBzY3JpcHQgZG9lcyB0aGUgcmlnaHQgdGhpbmcg Zm9yIHRoaXMgb25lIHJlZ2FyZGxlc3MuCgpJJ2QgcHJlZmVyIHRvIGhhdmUgc3VjaCBmdW5jdGlv bnMgZmxhZ2dlZCwgdG9vLiAgQnV0IHNwZW5kaW5nIHRpbWUgb24KY29udmluY2luZyBDb2NjaW5l bGxlIHRvIGRvIGl0IGZvciBtZSBpcyBub3Qgd29ydGh3aGlsZTsgSSBjYW4gc2ltcGx5CnNlYXJj aCB0aGUgZGlmZiBwcm9kdWNlZCBieSBDb2NjaW5lbGxlIGZvciBkZWxldGlvbnMgb2YgZGVjbGFy YXRpb25zCnRoYXQgYXJlIG5vdCBpbmRlbnRlZCBleGFjdGx5IGZvdXIgc3BhY2VzLgoKQnV0IGlm IHdlIGtlZXAgdGhpcyBydWxlLCB3ZSBzaG91bGQgYWRqdXN0IGl0cyBjb21tZW50CgogICAgLy8g V2FybiBzZXZlcmFsIEVycm9yICogZGVmaW5pdGlvbnMuCgpiZWNhdXNlIGl0IHN1cmUgc3VnZ2Vz dHMgaXQgYWxzbyBjYXRjaGVzIGZ1bmN0aW9ucyBsaWtlIHRoZSBvbmUgSSBnYXZlCmFib3ZlLgoK Pj4+Pj4gKwo+Pj4+PiArQCBzY3JpcHQ6cHl0aG9uIEAKPj4+Pj4gK2ZuIDw8IGNoZWNrMS5mbjsK Pj4+Pj4gK0BACj4+Pj4+ICsKPj4+Pj4gK3ByaW50KCdXYXJuaW5nOiBmdW5jdGlvbiB7fSBoYXMg c2V2ZXJhbCBkZWZpbml0aW9ucyBvZiAnCj4+Pj4+ICsgICAgICAnRXJyb3IgKiBsb2NhbCB2YXJp YWJsZScuZm9ybWF0KGZuKSkKPj4+Pj4gKwo+Pj4+PiArLy8gV2FybiBzZXZlcmFsIHByb3BhZ2F0 aW9ucyBpbiBjb250cm9sIGZsb3cuCj4+Pj4+ICtAY2hlY2syIGRpc2FibGUgb3B0aW9uYWxfcXVh bGlmaWVyIGV4aXN0c0AKPj4+Pj4gK2lkZW50aWZpZXIgZm4gPSBydWxlMS5mbjsKPj4+Pj4gK3N5 bWJvbCBlcnJwOwo+Pj4+PiArcG9zaXRpb24gcDEsIHAyOwo+Pj4+PiArQEAKPj4+Pj4gKwo+Pj4+ PiArIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+Pj4+PiArIHsKPj4+Pj4gKyAgICAgLi4u Cj4+Pj4+ICsoCj4+Pj4+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIC4uLik7 QHAxCj4+Pj4+ICt8Cj4+Pj4+ICsgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCAuLi4pO0BwMQo+ Pj4+PiArKQo+Pj4+PiArICAgICAuLi4KPj4+Pj4gKygKPj4+Pj4gKyAgICAgZXJyb3JfcHJvcGFn YXRlX3ByZXBlbmQoZXJycCwgLi4uKTtAcDIKPj4+Pj4gK3wKPj4+Pj4gKyAgICAgZXJyb3JfcHJv cGFnYXRlKGVycnAsIC4uLik7QHAyCj4+Pj4+ICspCj4+Pj4+ICsgICAgIC4uLiB3aGVuIGFueQo+ Pj4+PiArIH0KPj4+Pj4gKwo+Pj4+Cj4+Pj4gSG1tLCB3ZSBkb24ndCBjYXRjaCB0aGUgZXhhbXBs ZSBJIHVzZWQgaW4gcmV2aWV3IG9mIHY4Ogo+Pj4+Cj4+Pj4gICAgICAgZXh0ZXJuIGZvbyhpbnQs IEVycm9yICoqKTsKPj4+PiAgICAgICBleHRlcm4gYmFyKGludCwgRXJyb3IgKiopOwo+Pj4+Cj4+ Pj4gICAgICAgdm9pZCBmcm9iKEVycm9yICoqZXJycCkKPj4+PiAgICAgICB7Cj4+Pj4gICAgICAg ICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwo+Pj4+ICAgICAgICAgICBpbnQgYXJnOwo+Pj4+ Cj4+Pj4gICAgICAgICAgIGZvbyhhcmcsIGVycnApOwo+Pj4+ICAgICAgICAgICBiYXIoYXJnLCAm bG9jYWxfZXJyKTsKPj4+PiAgICAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vy cik7Cj4+Pj4gICAgICAgICAgIGJhcihhcmcgKyAxLCAmbG9jYWxfZXJyKTsKPj4+PiAgICAgICAg ICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Cj4+Pj4gICAgICAgfQo+Pj4+Cj4+ Pj4gSSBiZWxpZXZlIHRoaXMgaXMgYmVjYXVzZSBydWxlMSBkb2VzIG5vdCBtYXRjaCBoZXJlLgo+ Pj4KPj4+IFllcywgcnVsZTEgd2FudHMgYXQgbGVhc3Qgb25lIGNvZGUgZmxvdyB3aXRoIG5vbi1k b3VibGVkIHByb3BhZ2F0aW9uLgo+Pj4KPj4+Pgo+Pj4+IElmIEkgY2hhbmdlIHRoZSBydWxlIGFz IGZvbGxvd3MsIGl0IGNhdGNoZXMgdGhlIGV4YW1wbGU6Cj4+Pj4KPj4+PiAgICAgICBAQCAtMTU3 LDI0ICsxNTcsMjMgQEAgcHJpbnQoJ1dhcm5pbmc6IGZ1bmN0aW9uIHt9IGhhcyBzZXZlcmFsIGRl ZmluaXRpb25zIG9mICcKPj4+Pgo+Pj4+ICAgICAgICAvLyBXYXJuIHNldmVyYWwgcHJvcGFnYXRp b25zIGluIGNvbnRyb2wgZmxvdy4KPj4+PiAgICAgICAgQGNoZWNrMiBkaXNhYmxlIG9wdGlvbmFs X3F1YWxpZmllciBleGlzdHNACj4+Pj4gICAgICAgLWlkZW50aWZpZXIgZm4gPSBydWxlMS5mbjsK Pj4+PiAgICAgICAtc3ltYm9sIGVycnA7Cj4+Pj4gICAgICAgK2lkZW50aWZpZXIgZm4sIF9lcnJw Owo+Pj4+ICAgICAgICBwb3NpdGlvbiBwMSwgcDI7Cj4+Pj4gICAgICAgIEBACj4+Pj4KPj4+PiAg ICAgICAtIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+Pj4+ICAgICAgICsgZm4oLi4uLCBF cnJvciAqKl9lcnJwLCAuLi4pCj4+Pj4gICAgICAgICB7Cj4+Pj4gICAgICAgICAgICAgLi4uCj4+ Pj4gICAgICAgICgKPj4+PiAgICAgICAtICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJw LCAuLi4pO0BwMQo+Pj4+ICAgICAgICsgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKF9lcnJw LCAuLi4pO0BwMQo+Pj4+ICAgICAgICB8Cj4+Pj4gICAgICAgLSAgICAgZXJyb3JfcHJvcGFnYXRl KGVycnAsIC4uLik7QHAxCj4+Pj4gICAgICAgKyAgICAgZXJyb3JfcHJvcGFnYXRlKF9lcnJwLCAu Li4pO0BwMQo+Pj4+ICAgICAgICApCj4+Pj4gICAgICAgICAgICAgLi4uCj4+Pj4gICAgICAgICgK Pj4+PiAgICAgICAtICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCAuLi4pO0BwMgo+ Pj4+ICAgICAgICsgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKF9lcnJwLCAuLi4pO0BwMgo+ Pj4+ICAgICAgICB8Cj4+Pj4gICAgICAgLSAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIC4uLik7 QHAyCj4+Pj4gICAgICAgKyAgICAgZXJyb3JfcHJvcGFnYXRlKF9lcnJwLCAuLi4pO0BwMgo+Pj4+ ICAgICAgICApCj4+Pj4gICAgICAgICAgICAgLi4uIHdoZW4gYW55Cj4+Pj4gICAgICAgICB9Cj4+ Pj4KPj4+PiBUbyBteSBtaWxkIHN1cnByaXNlLCBpdCBzdGlsbCBkb2Vzbid0IGZpbmQgYW55dGhp bmcgaW4gb3VyIHRyZWUuCj4+Pj4KPj4+PiBTaG91bGQgd2UgZGVjb3VwbGUgdGhlIHByZXZpb3Vz IHJ1bGUgZnJvbSBydWxlMSwgdG9vPyAgSSB0ZXN0ZWQgdGhlCj4+Pj4gZm9sbG93aW5nIG9uIHRo ZSB3aG9sZSB0cmVlOgo+Pj4KPj4+IEkgZG9uJ3QgdGhpbmsgc28uIFdoeSB0byBjaGVjayB3aGF0 IHdlIGFyZSBub3QgZ29pbmcgdG8gY29udmVydD8gSWYgd2Ugd2FudAo+Pj4gdG8gY2hlY2sgc2lk ZSB0aGluZ3MsIGl0J3MgYmV0dGVyIHRvIGRvIGl0IGluIG90aGVyIGNvY2NpbmVsbGUgc2NyaXB0 Li4KPj4KPj4gTWlzdW5kZXJzdGFuZGluZz8gIFRoZSBydWxlcyBhcmUgc3RpbGwgY2hhaW5lZCB0 b2dldGhlciB2aWEgdGhlIF9fXwo+PiBoYWNrLCBqdXN0IG5vdCB2aWEgZnVuY3Rpb24gbmFtZSwg YmVjYXVzZSB0aGF0J3MgdW5yZWxpYWJsZSBhbmQKPj4gcmVkdW5kYW50Lgo+Cj4gU3RyYW5nZS4u IFRoZW4sIGhvdyBjYW4gaXQgbWF0Y2ggc29tZXRoaW5nIG5vdCBtYXRjaGVkIGJ5IHJ1bGUxPwoK SSB0aGluayBJIGdvdCBjb25mdXNlZCB3aGVuIEkgd3JvdGUgdGhlICJNaXN1bmRlcnN0YW5kaW5n PyIgcGFyYWdyYXBoLgoKTGV0IG1lIHRyeSBhZ2Fpbi4KCkZpcnN0IHJ1bGUgY2hlY2syLgoKVGhl IGNvbW1vbiBjYXNlIGlzIGEgYXQgbW9zdCBvbmUgcHJvcGFnYXRpb24gdG8gQGVycnAgYWxvbmcg YW55IGNvbnRyb2wKZmxvdyBwYXRoLiAgV2UgdHJ1c3QgeW91ciBDb2NjaW5lbGxlIHNjcmlwdCB0 byBjb252ZXJ0IHRoYXQgYWxyaWdodC4KCkFueSBvdGhlciBwcm9wYWdhdGlvbiB0byBAZXJycCBJ IHdhbnQgdG8gcmV2aWV3LiAgV2hldGhlciB0aGUgc2NyaXB0CmF0dGVtcHRzIGEgY29udmVyc2lv biBvciBub3QgaXMgdW5pbXBvcnRhbnQsIGFzIGxvbmcgYXMgaXQgcG9pbnRzIG1lIHRvCnRoZSBm dW5jdGlvbiB0byByZXZpZXcuCgpSdWxlIHJ1bGUxIG1hdGNoZXMgZnVuY3Rpb25zIHRoYXQgcHJv cGFnYXRlIHRvIEBlcnJwIG9uY2UgYWxvbmcgYXQgbGVhc3QKb25lIGNvbnRyb2wgZmxvdyBwYXRo LgoKVW5jaGFpbmVkIGZyb20gcnVsZSBydWxlMSwgcnVsZSBjaGVjazIgZmxhZ3MgYW55IGZ1bmN0 aW9uIHRoYXQKcHJvcGFnYXRlcyB0byBAZXJycCBtdWx0aXBsZSB0aW1lcyBhbG9uZyBhbnkgY29u dHJvbCBmbG93IHBhdGguCgpDaGFpbmVkIHRvIHJ1bGUxLCBpdCBmbGFncyBvbmx5IGZ1bmN0aW9u cyB0aGF0IGFsc28gaGF2ZSBhIHBhdGggd2l0aApzaW5nbGUgcHJvcGFnYXRpb24uCgpJbiBvdGhl ciB3b3JkcywgdGhlIHVuY2hhaW5lZCBydWxlIGZsYWdzICphbGwqIG11bHRpLXByb3BhZ2F0aW9u cyB0bwpAZXJycCwgd2hpbGUgdGhlIGNoYWluZWQgcnVsZSBmbGFncyBvbmx5IHRoZSBvbmVzIHRo ZSBzY3JpcHQgYXR0ZW1wdHMgdG8KY29udmVydC4gIFRoZSBmb3JtZXIgaXMgbXVjaCBtb3JlIHVz ZWZ1bCB0byBtZS4KCk5vdyBydWxlIGNoZWNrMS4gIEl0IGZsYWdzIGZ1bmN0aW9ucyB3aXRoIG11 bHRpcGxlIGRlY2xhcmF0aW9ucyBhbG9uZwphbnkgY29udHJvbCBmbG93IHBhdGguICBBZ2Fpbiwg Y2hhaW5pbmcgaXQgdG8gcnVsZTEgcmVzdHJpY3RzIGl0IHRvIHRoZQpmdW5jdGlvbnMgd2UgYXR0 ZW1wdCB0byBjb252ZXJ0LiAgTWFrZXMgaXQgbGVzcyB1c2VmdWwgdG8gbWUuICBIb3dldmVyLApi ZWNhdXNlIG15IGRlc2lyZSB0byByZXZpZXcgbXVsdGlwbGUgZGVjbGFyYXRpb25zIGluIGZ1bmN0 aW9uIHdlIGRvbid0CmF0dGVtcHQgdG8gY29udmVydCBpcyBsb3dlciB0aGFuIG15IGRlc2lyZSB0 byByZXZpZXcgbXVsdGlwbGUKcHJvcGFnYXRpb25zIHRvIEBlcnJwIGluIHN1Y2ggZnVuY3Rpb25z LCBjaGFpbmluZyBjaGVjazEgaXMgdG9sZXJhYmxlCmZvciBtZS4gIEJ1dCB3aHkgY2hhaW4gY2hl Y2sxIGlmIHdlIGRvbid0IGNoYWluIGNoZWNrMj8KCj4KPj4KPj4+Pgo+Pj4+ICAgICAgIEBAIC0x MzYsMTAgKzEzNiwxMCBAQCBzeW1ib2wgZXJycDsKPj4+Pgo+Pj4+ICAgICAgICAvLyBXYXJuIHNl dmVyYWwgRXJyb3IgKiBkZWZpbml0aW9ucy4KPj4+PiAgICAgICAgQGNoZWNrMSBkaXNhYmxlIG9w dGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4+Pj4gICAgICAgLWlkZW50aWZpZXIgZm4gPSBydWxl MS5mbiwgbG9jYWxfZXJyLCBsb2NhbF9lcnIyOwo+Pj4+ICAgICAgICtpZGVudGlmaWVyIGZuLCBf ZXJycCwgbG9jYWxfZXJyLCBsb2NhbF9lcnIyOwo+Pj4+ICAgICAgICBAQAo+Pj4+Cj4+Pj4gICAg ICAgLSBmbiguLi4sIEVycm9yICoqIF9fX18sIC4uLikKPj4+PiAgICAgICArIGZuKC4uLiwgRXJy b3IgKipfZXJycCwgLi4uKQo+Pj4+ICAgICAgICAgewo+Pj4+ICAgICAgICAgICAgIC4uLgo+Pj4+ ICAgICAgICAgICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwo+Pj4+Cj4+Pj4gV2FybmluZ3Mg cmVtYWluIHVuY2hhbmdlZC4KPj4+Pgo+Pj4+PiArQCBzY3JpcHQ6cHl0aG9uIEAKPj4+Pj4gK2Zu IDw8IGNoZWNrMi5mbjsKPj4+Pj4gK3AxIDw8IGNoZWNrMi5wMTsKPj4+Pj4gK3AyIDw8IGNoZWNr Mi5wMjsKPj4+Pj4gK0BACj4+Pj4+ICsKPj4+Pj4gK3ByaW50KCdXYXJuaW5nOiBmdW5jdGlvbiB7 fSBwcm9wYWdhdGVzIHRvIGVycnAgc2V2ZXJhbCB0aW1lcyBpbiAnCj4+Pj4+ICsgICAgICAnb25l IGNvbnRyb2wgZmxvdzogYXQge306e30gYW5kIHRoZW4gYXQge306e30nLmZvcm1hdCgKPj4+Pj4g KyAgICAgICAgICBmbiwgcDFbMF0uZmlsZSwgcDFbMF0ubGluZSwgcDJbMF0uZmlsZSwgcDJbMF0u bGluZSkpCj4+Pj4+ICsKPj4+Pj4gKy8vIENvbnZlcnQgc3BlY2lhbCBjYXNlIHdpdGggZ290byBz ZXBhcmF0ZWx5Lgo+Pj4+PiArLy8gSSB0cmllZCBtZXJnaW5nIHRoaXMgaW50byB0aGUgZm9sbG93 aW5nIHJ1bGUgdGhlIG9idmlvdXMgd2F5LCBidXQKPj4+Pj4gKy8vIGl0IG1hZGUgQ29jY2luZWxs ZSBoYW5nIG9uIGJsb2NrLmMKPj4+Pj4gKy8vCj4+Pj4+ICsvLyBOb3RlIGludGVyZXN0aW5nIHRo aW5nOiBpZiB3ZSBkb24ndCBkbyBpdCBoZXJlLCBhbmQgdHJ5IHRvIGZpeHVwCj4+Pj4+ICsvLyAi b3V0OiB9IiB0aGluZ3MgbGF0ZXIgYWZ0ZXIgYWxsIHRyYW5zZm9ybWF0aW9ucyAodGhlIHJ1bGUg d2lsbCBiZQo+Pj4+PiArLy8gdGhlIHNhbWUsIGp1c3Qgd2l0aG91dCBlcnJvcl9wcm9wYWdhdGUo KSBjYWxsKSwgY29jY2luZWxsZSBmYWlscyB0bwo+Pj4+PiArLy8gbWF0Y2ggdGhpcyAib3V0OiB9 Ii4KPj4+Pj4gK0AgZGlzYWJsZSBvcHRpb25hbF9xdWFsaWZpZXJACj4+Pj4+ICtpZGVudGlmaWVy IHJ1bGUxLmZuLCBydWxlMS5sb2NhbF9lcnIsIG91dDsKPj4+Pgo+Pj4+IEFzIGV4cGxhaW5lZCBh Ym92ZSwgSSBkb3VidCB0aGUgbmVlZCBmb3IgcnVsZTEuZm4uICBXZSBkbyBuZWVkCj4+Pj4gcnVs ZTEubG9jYWxfZXJyIHRvIGF2b2lkIHVud2FudGVkIHRyYW5zZm9ybWF0aW9ucy4gIE1vcmUgb2Yg dGhlIHNhbWUKPj4+PiBiZWxvdy4KPj4+Cj4+PiBMb2dpY2FsbHksIEkgd2FudCB0byBpbmhlcml0 IGZyb20gcnVsZTEuIFNvIHdoeSBub3QgdG8gc3RyZXNzIGl0IGJ5IGluaGVyaXRpbmcKPj4+IGZu IHZhcmlhYmxlPyBJdCdzIGp1c3QgYSBjb3JyZWN0IHRoaW5nIHRvIGRvLgo+Pj4gQW5kIEkgaG9w ZSBpdCBoZWxwcyBjb2NjaW5lbGxlIHRvIHdvcmsgbW9yZSBlZmZpY2llbnRseS4KPj4+Cj4+Pj4K Pj4+Pj4gK3N5bWJvbCBlcnJwOwo+Pj4+PiArQEAKPj4+Pj4gKwo+Pj4+PiArIGZuKC4uLiwgRXJy b3IgKiogX19fXywgLi4uKQo+Pj4+PiArIHsKPj4+Pj4gKyAgICAgPC4uLgo+Pj4+PiArLSAgICBn b3RvIG91dDsKPj4+Pj4gKysgICAgcmV0dXJuOwo+Pj4+PiArICAgICAuLi4+Cj4+Pj4+ICstIG91 dDoKPj4+Pj4gKy0gICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Cj4+Pj4+ICsg fQo+Pj4+PiArCj4+Pj4+ICsvLyBDb252ZXJ0IG1vc3Qgb2YgbG9jYWxfZXJyIHJlbGF0ZWQgc3R1 ZmYuCj4+Pj4+ICsvLwo+Pj4+PiArLy8gTm90ZSwgdGhhdCB3ZSB1cGRhdGUgZXZlcnl0aGluZyBy ZWxhdGVkIHRvIG1hdGNoZWQgYnkgcnVsZTEKPj4+Pj4gKy8vIGZ1bmN0aW9uIG5hbWUgYW5kIGxv Y2FsX2VyciBuYW1lLiBXZSBtYXkgbWF0Y2ggc29tZXRoaW5nIG5vdAo+Pj4+PiArLy8gcmVsYXRl ZCB0byB0aGUgcGF0dGVybiBtYXRjaGVkIGJ5IHJ1bGUxLiBGb3IgZXhhbXBsZSwgbG9jYWxfZXJy IG1heQo+Pj4+PiArLy8gYmUgZGVmaW5lZCB3aXRoIHRoZSBzYW1lIG5hbWUgaW4gZGlmZmVyZW50 IGJsb2NrcyBpbnNpZGUgb25lCj4+Pj4+ICsvLyBmdW5jdGlvbiwgYW5kIGluIG9uZSBibG9jayBm b2xsb3cgdGhlIHByb3BhZ2F0aW9uIHBhdHRlcm4gYW5kIGluCj4+Pj4+ICsvLyBvdGhlciBibG9j ayBkb2Vzbid0LiBPciB3ZSBtYXkgaGF2ZSBzZXZlcmFsIGZ1bmN0aW9ucyB3aXRoIHRoZSBzYW1l Cj4+Pj4+ICsvLyBuYW1lIChmb3IgZGlmZmVyZW50IGNvbmZpZ3VyYXRpb25zKS4KPj4+Pj4gKy8v Cj4+Pj4+ICsvLyBOb3RlIGFsc28gdGhhdCBlcnJwLWNsZWFuaW5nIGZ1bmN0aW9ucwo+Pj4+PiAr Ly8gICBlcnJvcl9mcmVlX2VycnAKPj4+Pj4gKy8vICAgZXJyb3JfcmVwb3J0X2VycnAKPj4+Pj4g Ky8vICAgZXJyb3JfcmVwb3J0Zl9lcnJwCj4+Pj4+ICsvLyAgIHdhcm5fcmVwb3J0X2VycnAKPj4+ Pj4gKy8vICAgd2Fybl9yZXBvcnRmX2VycnAKPj4+Pj4gKy8vIGFyZSBub3QgeWV0IGltcGxlbWVu dGVkLiBUaGV5IG11c3QgY2FsbCBjb3JyZXNwb25kaW5nIEVycm9yKiAtCj4+Pj4+ICsvLyBmcmVl aW5nIGZ1bmN0aW9uIGFuZCB0aGVuIHNldCAqZXJycCB0byBOVUxMLCB0byBhdm9pZCBmdXJ0aGVy Cj4+Pj4+ICsvLyBwcm9wYWdhdGlvbiB0byBvcmlnaW5hbCBlcnJwIChjb25zaWRlciBFUlJQX0FV VE9fUFJPUEFHQVRFIGluIHVzZSkuCj4+Pj4+ICsvLyBGb3IgZXhhbXBsZSwgZXJyb3JfZnJlZV9l cnJwIG1heSBsb29rIGxpa2UgdGhpczoKPj4+Pj4gKy8vCj4+Pj4+ICsvLyAgICB2b2lkIGVycm9y X2ZyZWVfZXJycChFcnJvciAqKmVycnApCj4+Pj4+ICsvLyAgICB7Cj4+Pj4+ICsvLyAgICAgICAg ZXJyb3JfZnJlZSgqZXJycCk7Cj4+Pj4+ICsvLyAgICAgICAgKmVycnAgPSBOVUxMOwo+Pj4+PiAr Ly8gICAgfQo+Pj4+PiArQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4+Pj4+ ICtpZGVudGlmaWVyIHJ1bGUxLmZuLCBydWxlMS5sb2NhbF9lcnI7Cj4+Pj4+ICtleHByZXNzaW9u IGxpc3QgYXJnczsKPj4+Pj4gK3N5bWJvbCBlcnJwOwo+Pj4+PiArQEAKPj4+Pj4gKwo+Pj4+PiAr IGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+Pj4+PiArIHsKPj4+Pj4gKyAgICAgPC4uLgo+ Pj4+PiArKAo+Pj4+PiArLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKPj4+Pj4gK3wKPj4+ Pj4gKwo+Pj4+PiArLy8gQ29udmVydCBlcnJvciBjbGVhcmluZyBmdW5jdGlvbnMKPj4+Pj4gKygK Pj4+Pj4gKy0gICAgZXJyb3JfZnJlZShsb2NhbF9lcnIpOwo+Pj4+PiArKyAgICBlcnJvcl9mcmVl X2VycnAoZXJycCk7Cj4+Pj4+ICt8Cj4+Pj4+ICstICAgIGVycm9yX3JlcG9ydF9lcnIobG9jYWxf ZXJyKTsKPj4+Pj4gKysgICAgZXJyb3JfcmVwb3J0X2VycnAoZXJycCk7Cj4+Pj4+ICt8Cj4+Pj4+ ICstICAgIGVycm9yX3JlcG9ydGZfZXJyKGxvY2FsX2VyciwgYXJncyk7Cj4+Pj4+ICsrICAgIGVy cm9yX3JlcG9ydGZfZXJycChlcnJwLCBhcmdzKTsKPj4+Pj4gK3wKPj4+Pj4gKy0gICAgd2Fybl9y ZXBvcnRfZXJyKGxvY2FsX2Vycik7Cj4+Pj4+ICsrICAgIHdhcm5fcmVwb3J0X2VycnAoZXJycCk7 Cj4+Pj4+ICt8Cj4+Pj4+ICstICAgIHdhcm5fcmVwb3J0Zl9lcnIobG9jYWxfZXJyLCBhcmdzKTsK Pj4+Pj4gKysgICAgd2Fybl9yZXBvcnRmX2VycnAoZXJycCwgYXJncyk7Cj4+Pj4+ICspCj4+Pj4+ ICs/LSAgICBsb2NhbF9lcnIgPSBOVUxMOwo+Pj4+PiArCj4+Pj4+ICt8Cj4+Pj4+ICstICAgIGVy cm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgYXJncyk7Cj4+Pj4+ICsrICAg IGVycm9yX3ByZXBlbmQoZXJycCwgYXJncyk7Cj4+Pj4+ICt8Cj4+Pj4+ICstICAgIGVycm9yX3By b3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwo+Pj4+PiArfAo+Pj4+PiArLSAgICAmbG9jYWxfZXJy Cj4+Pj4+ICsrICAgIGVycnAKPj4+Pj4gKykKPj4+Pj4gKyAgICAgLi4uPgo+Pj4+PiArIH0KPj4+ Pj4gKwo+Pj4+PiArLy8gQ29udmVydCByZW1haW5pbmcgbG9jYWxfZXJyIHVzYWdlLiBGb3IgZXhh bXBsZSwgZGlmZmVyZW50IGtpbmRzIG9mCj4+Pj4+ICsvLyBlcnJvciBjaGVja2luZyBpbiBpZiBj b25kaXRpb25hbHMuIFdlIGNhbid0IG1lcmdlIHRoaXMgaW50bwo+Pj4+PiArLy8gcHJldmlvdXMg aHVuaywgYXMgdGhpcyBjb25mbGljdHMgd2l0aCBvdGhlciBzdWJzdGl0dXRpb25zIGluIGl0IChh dAo+Pj4+PiArLy8gbGVhc3Qgd2l0aCAiLSBsb2NhbF9lcnIgPSBOVUxMIikuCj4+Pj4+ICtAIGRp c2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyQAo+Pj4+PiAraWRlbnRpZmllciBydWxlMS5mbiwgcnVs ZTEubG9jYWxfZXJyOwo+Pj4+PiArc3ltYm9sIGVycnA7Cj4+Pj4+ICtAQAo+Pj4+PiArCj4+Pj4+ ICsgZm4oLi4uLCBFcnJvciAqKiBfX19fLCAuLi4pCj4+Pj4+ICsgewo+Pj4+PiArICAgICA8Li4u Cj4+Pj4+ICstICAgIGxvY2FsX2Vycgo+Pj4+PiArKyAgICAqZXJycAo+Pj4+PiArICAgICAuLi4+ Cj4+Pj4+ICsgfQo+Pj4+PiArCj4+Pj4+ICsvLyBBbHdheXMgdXNlIHRoZSBzYW1lIHBhdHRlcm4g Zm9yIGNoZWNraW5nIGVycm9yCj4+Pj4+ICtAIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyQAo+ Pj4+PiAraWRlbnRpZmllciBydWxlMS5mbjsKPj4+Pj4gK3N5bWJvbCBlcnJwOwo+Pj4+PiArQEAK Pj4+Pj4gKwo+Pj4+PiArIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+Pj4+PiArIHsKPj4+ Pj4gKyAgICAgPC4uLgo+Pj4+PiArLSAgICAqZXJycCAhPSBOVUxMCj4+Pj4+ICsrICAgICplcnJw Cj4+Pj4+ICsgICAgIC4uLj4KPj4+Pj4gKyB9Cj4+Pj4+ICsKPj4+Pj4gKy8vIFJldmVydCB0ZW1w b3JhcnkgX19fIGlkZW50aWZpZXIuCj4+Pj4+ICtAIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVy QAo+Pj4+PiAraWRlbnRpZmllciBydWxlMS5mbjsKPj4+Pj4gK0BACj4+Pj4+ICsKPj4+Pj4gKyBm biguLi4sIEVycm9yICoqCj4+Pj4+ICstICAgX19fXwo+Pj4+PiArKyAgIGVycnAKPj4+Pj4gKyAg ICAsIC4uLikKPj4+Pj4gKyB7Cj4+Pj4+ICsgICAgIC4uLgo+Pj4+PiArIH0KPj4+Pj4gZGlmZiAt LWdpdCBhL2luY2x1ZGUvcWFwaS9lcnJvci5oIGIvaW5jbHVkZS9xYXBpL2Vycm9yLmgKPj4+Pj4g aW5kZXggMzAxNDBkOWJmZS4uNTZjMTMzNTIwZCAxMDA2NDQKPj4+Pj4gLS0tIGEvaW5jbHVkZS9x YXBpL2Vycm9yLmgKPj4+Pj4gKysrIGIvaW5jbHVkZS9xYXBpL2Vycm9yLmgKPj4+Pj4gQEAgLTIx NCw2ICsyMTQsOSBAQAo+Pj4+PiAgICAgKiAgICAgICAgIH0KPj4+Pj4gICAgICogICAgICAgICAu Li4KPj4+Pj4gICAgICogICAgIH0KPj4+Pj4gKyAqCj4+Pj4+ICsgKiBGb3IgbWFzcy1jb252ZXJz aW9uIHVzZSBzY3JpcHQKPj4+Pj4gKyAqICAgc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFn YXRlZC1lcnJwLmNvY2NpCj4+Pj4+ICAgICAqLwo+Pj4+PiAgICAgICNpZm5kZWYgRVJST1JfSAo+ Pj4+PiBkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwo+Pj4+PiBpbmRleCA4 NTdmOTY5YWExLi4wNDdmMWI5NzE0IDEwMDY0NAo+Pj4+PiAtLS0gYS9NQUlOVEFJTkVSUwo+Pj4+ PiArKysgYi9NQUlOVEFJTkVSUwo+Pj4+PiBAQCAtMTk5OCw2ICsxOTk4LDcgQEAgRjogaW5jbHVk ZS9xZW11L2Vycm9yLXJlcG9ydC5oCj4+Pj4+ICAgIEY6IHFhcGkvZXJyb3IuanNvbgo+Pj4+PiAg ICBGOiB1dGlsL2Vycm9yLmMKPj4+Pj4gICAgRjogdXRpbC9xZW11LWVycm9yLmMKPj4+Pj4gK0Y6 IHNjcmlwdHMvY29jY2luZWxsZS8qZXJyKi5jb2NjaQo+Pj4+PiAgICAgIEdEQiBzdHViCj4+Pj4+ ICAgIE06IEFsZXggQmVubsOpZSA8YWxleC5iZW5uZWVAbGluYXJvLm9yZz4KPj4+Pgo+Pgo+Pgo+ PiAgRnJvbSA0MmEwOGM1MjkwMjQzMzdkMWI4NTk4MzljOWNlN2Y3OTdmNzg0NTU1IE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQo+PiBGcm9tOiBNYXJrdXMgQXJtYnJ1c3RlciA8YXJtYnJ1QHJlZGhh dC5jb20+Cj4+IERhdGU6IEZyaSwgMTMgTWFyIDIwMjAgMTQ6Mjc6NTcgKzAxMDAKPj4gU3ViamVj dDogW1BBVENIXSBmaXh1cCEgc2NyaXB0czogQ29jY2luZWxsZSBzY3JpcHQgdG8gdXNlCj4+ICAg RVJSUF9BVVRPX1BST1BBR0FURSgpCj4+Cj4+IC0tLQo+PiAgIHNjcmlwdHMvY29jY2luZWxsZS9h dXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaSB8IDM3ICsrKysrKysrKystLS0tLS0tLS0KPj4gICAx IGZpbGUgY2hhbmdlZCwgMjAgaW5zZXJ0aW9ucygrKSwgMTcgZGVsZXRpb25zKC0pCj4+Cj4+IGRp ZmYgLS1naXQgYS9zY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kg Yi9zY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kKPj4gaW5kZXgg N2RhYzJkY2ZhNC4uNDNiMGIwZTYzYiAxMDA2NDQKPj4gLS0tIGEvc2NyaXB0cy9jb2NjaW5lbGxl L2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2NpCj4+ICsrKyBiL3NjcmlwdHMvY29jY2luZWxsZS9h dXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaQo+PiBAQCAtMTM2LDQ1ICsxMzYsNDggQEAgc3ltYm9s IGVycnA7Cj4+ICAgICAvLyBXYXJuIHNldmVyYWwgRXJyb3IgKiBkZWZpbml0aW9ucy4KPj4gICBA Y2hlY2sxIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIGV4aXN0c0AKPj4gLWlkZW50aWZpZXIg Zm4gPSBydWxlMS5mbiwgbG9jYWxfZXJyLCBsb2NhbF9lcnIyOwo+PiAraWRlbnRpZmllciBmbiwg X2VycnAsIGxvY2FsX2VyciwgbG9jYWxfZXJyMjsKPj4gK3Bvc2l0aW9uIHAxLCBwMjsKPgo+Cj4g SG1tLCBzZWVtcyBsaWtlIEkgZm9yZ2V0IHRvIGRlZmluZSBfX19fIGFzIHN5bWJvbCBpbiBteSBw YXRjaAoKQ29jY2luZWxsZSBkZWZhdWx0cyB0byBzeW1ib2wuCgo+PiAgIEBACj4+ICAgLSBmbigu Li4sIEVycm9yICoqIF9fX18sIC4uLikKPj4gKyBmbiguLi4sIEVycm9yICoqX2VycnAsIC4uLikK Pgo+IEFobW0uLiBpdCB3aWxsIGJyZWFrIGNvbXBpbGF0aW9uPwo+Cj4gT3IsIGhvdyB3aWxsIGl0 IHdvcmsgd2hlbiBfZXJycCBkZWZpbmVkIGFzIG1ldGEgdmFyaWFibGUgaXMgb25seSBpbiAiKy4u LiIgbGluZT8gU2hvdWxkIGl0IGJlIHN5bWJvbCBpbnN0ZWFkLCBvciBqdXN0IG5vdCBkZWZpbmVk PwoKTWlzdW5kZXJzdGFuZGluZz8gIEl0J3MgYSBkaWZmIGJldHdlZW4geW91ciAuY29jY2kgYW5k IG1pbmUuICBNeSB2ZXJzaW9uCmlzCgogICAgLy8gV2FybiBzZXZlcmFsIEVycm9yICogZGVmaW5p dGlvbnMuCiAgICBAY2hlY2sxIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIGV4aXN0c0AKICAg IGlkZW50aWZpZXIgZm4sIF9lcnJwLCBsb2NhbF9lcnIsIGxvY2FsX2VycjI7CiAgICBwb3NpdGlv biBwMSwgcDI7CiAgICBAQAoKICAgICBmbiguLi4sIEVycm9yICoqX2VycnAsIC4uLikKICAgICB7 CiAgICAgICAgIC4uLgogICAgICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDtAcDEKICAgICAg ICAgLi4uIHdoZW4gYW55CiAgICAgICAgIEVycm9yICpsb2NhbF9lcnIyID0gTlVMTDtAcDIKICAg ICAgICAgLi4uIHdoZW4gYW55CiAgICAgfQoKICAgIEAgc2NyaXB0OnB5dGhvbiBACiAgICBmbiA8 PCBjaGVjazEuZm47CiAgICBwMSA8PCBjaGVjazEucDE7CiAgICBwMiA8PCBjaGVjazEucDI7CiAg ICBAQAoKPj4gICAgewo+PiAgICAgICAgLi4uCj4+IC0gICAgIEVycm9yICpsb2NhbF9lcnIgPSBO VUxMOwo+PiArICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDtAcDEKPgo+IFdoeSB0byBkbyAt LysgaGVyZT8gTm90aGluZyBjaGFuZ2VkLi4KPgo+PiAgICAgICAgLi4uIHdoZW4gYW55Cj4+IC0g ICAgIEVycm9yICpsb2NhbF9lcnIyID0gTlVMTDsKPj4gKyAgICAgRXJyb3IgKmxvY2FsX2VycjIg PSBOVUxMO0BwMgo+PiAgICAgICAgLi4uIHdoZW4gYW55Cj4+ICAgIH0KPj4gICAgIEAgc2NyaXB0 OnB5dGhvbiBACj4+ICAgZm4gPDwgY2hlY2sxLmZuOwo+PiArcDEgPDwgY2hlY2sxLnAxOwo+PiAr cDIgPDwgY2hlY2sxLnAyOwo+PiAgIEBACj4+ICAgICBwcmludCgnV2FybmluZzogZnVuY3Rpb24g e30gaGFzIHNldmVyYWwgZGVmaW5pdGlvbnMgb2YgJwo+PiAtICAgICAgJ0Vycm9yICogbG9jYWwg dmFyaWFibGUnLmZvcm1hdChmbikpCj4+ICsgICAgICAnRXJyb3IgKiBsb2NhbCB2YXJpYWJsZTog YXQge306e30gYW5kIHRoZW4gYXQge306e30nLmZvcm1hdCgKPj4gKyAgICAgICAgICBmbiwgcDFb MF0uZmlsZSwgcDFbMF0ubGluZSwgcDJbMF0uZmlsZSwgcDJbMF0ubGluZSkpCj4+ICAgICAvLyBX YXJuIHNldmVyYWwgcHJvcGFnYXRpb25zIGluIGNvbnRyb2wgZmxvdy4KPj4gICBAY2hlY2syIGRp c2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIGV4aXN0c0AKPj4gLWlkZW50aWZpZXIgZm4gPSBydWxl MS5mbjsKPj4gLXN5bWJvbCBlcnJwOwo+PiAraWRlbnRpZmllciBmbiwgX2VycnA7Cj4+ICAgcG9z aXRpb24gcDEsIHAyOwo+PiAgIEBACj4+ICAgLSBmbiguLi4sIEVycm9yICoqIF9fX18sIC4uLikK Pj4gKyBmbiguLi4sIEVycm9yICoqX2VycnAsIC4uLikKPj4gICAgewo+PiAgICAgICAgLi4uCj4+ ICAgKAo+PiAtICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCAuLi4pO0BwMQo+PiAr ICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChfZXJycCwgLi4uKTtAcDEKPj4gICB8Cj4+IC0g ICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCAuLi4pO0BwMQo+PiArICAgICBlcnJvcl9wcm9wYWdh dGUoX2VycnAsIC4uLik7QHAxCj4+ICAgKQo+PiAgICAgICAgLi4uCj4+ICAgKAo+PiAtICAgICBl cnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCAuLi4pO0BwMgo+PiArICAgICBlcnJvcl9wcm9w YWdhdGVfcHJlcGVuZChfZXJycCwgLi4uKTtAcDIKPj4gICB8Cj4+IC0gICAgIGVycm9yX3Byb3Bh Z2F0ZShlcnJwLCAuLi4pO0BwMgo+PiArICAgICBlcnJvcl9wcm9wYWdhdGUoX2VycnAsIC4uLik7 QHAyCj4+ICAgKQo+Cj4gWW91IGNoYW5nZSBzb21lIG9jY3VycmVuY2VzIG9mIGVycnAgdG8gX2Vy cnAsIGJ1dCBub3QgYWxsLiBJdCBicmVha3MgY29tcGlsYXRpb24uCj4KPj4gICAgICAgIC4uLiB3 aGVuIGFueQo+PiAgICB9Cj4+IEBAIC0xOTgsNyArMjAxLDcgQEAgcHJpbnQoJ1dhcm5pbmc6IGZ1 bmN0aW9uIHt9IHByb3BhZ2F0ZXMgdG8gZXJycCBzZXZlcmFsIHRpbWVzIGluICcKPj4gICAvLyB0 aGUgc2FtZSwganVzdCB3aXRob3V0IGVycm9yX3Byb3BhZ2F0ZSgpIGNhbGwpLCBjb2NjaW5lbGxl IGZhaWxzIHRvCj4+ICAgLy8gbWF0Y2ggdGhpcyAib3V0OiB9Ii4KPj4gICBAIGRpc2FibGUgb3B0 aW9uYWxfcXVhbGlmaWVyQAo+PiAtaWRlbnRpZmllciBydWxlMS5mbiwgcnVsZTEubG9jYWxfZXJy LCBvdXQ7Cj4+ICtpZGVudGlmaWVyIGZuLCBydWxlMS5sb2NhbF9lcnIsIG91dDsKPgo+IEhtbS4g SWYgaXQgaW1wcm92ZXMgcGVyZm9ybWFuY2UgaXQgaXMgc3RyYW5nZS4uIEJ1dCBJIGNhbiBsaXZl IHdpdGggdGhpcyBjaGFuZ2UuCj4KPj4gICBzeW1ib2wgZXJycDsKPj4gICBAQAo+PiAgIEBAIC0y MzksNyArMjQyLDcgQEAgc3ltYm9sIGVycnA7Cj4+ICAgLy8gICAgICAgICplcnJwID0gTlVMTDsK Pj4gICAvLyAgICB9Cj4+ICAgQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4+ IC1pZGVudGlmaWVyIHJ1bGUxLmZuLCBydWxlMS5sb2NhbF9lcnI7Cj4+ICtpZGVudGlmaWVyIGZu LCBydWxlMS5sb2NhbF9lcnI7Cj4+ICAgZXhwcmVzc2lvbiBsaXN0IGFyZ3M7Cj4+ICAgc3ltYm9s IGVycnA7Cj4+ICAgQEAKPj4gQEAgLTI4Nyw3ICsyOTAsNyBAQCBzeW1ib2wgZXJycDsKPj4gICAv LyBwcmV2aW91cyBodW5rLCBhcyB0aGlzIGNvbmZsaWN0cyB3aXRoIG90aGVyIHN1YnN0aXR1dGlv bnMgaW4gaXQgKGF0Cj4+ICAgLy8gbGVhc3Qgd2l0aCAiLSBsb2NhbF9lcnIgPSBOVUxMIikuCj4+ ICAgQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllckAKPj4gLWlkZW50aWZpZXIgcnVsZTEuZm4s IHJ1bGUxLmxvY2FsX2VycjsKPj4gK2lkZW50aWZpZXIgZm4sIHJ1bGUxLmxvY2FsX2VycjsKPj4g ICBzeW1ib2wgZXJycDsKPj4gICBAQAo+PiAgIEBAIC0zMDEsNyArMzA0LDcgQEAgc3ltYm9sIGVy cnA7Cj4+ICAgICAvLyBBbHdheXMgdXNlIHRoZSBzYW1lIHBhdHRlcm4gZm9yIGNoZWNraW5nIGVy cm9yCj4+ICAgQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllckAKPj4gLWlkZW50aWZpZXIgcnVs ZTEuZm47Cj4+ICtpZGVudGlmaWVyIGZuOwo+PiAgIHN5bWJvbCBlcnJwOwo+PiAgIEBACj4+ICAg QEAgLTMxNSw3ICszMTgsNyBAQCBzeW1ib2wgZXJycDsKPj4gICAgIC8vIFJldmVydCB0ZW1wb3Jh cnkgX19fIGlkZW50aWZpZXIuCj4+ICAgQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllckAKPj4g LWlkZW50aWZpZXIgcnVsZTEuZm47Cj4+ICtpZGVudGlmaWVyIGZuOwo+PiAgIEBACj4+ICAgICAg Zm4oLi4uLCBFcnJvciAqKgo+PgoKSSBhcHBlbmQgbXkgaGFja2VkIHVwIHZlcnNpb24gb2YgYXV0 by1wcm9wYWdhdGVkLWVycnAuY29jY2kuICBJdApwcm9kdWNlcyB0aGUgc2FtZSBwYXRjaCBhcyB5 b3VycyBmb3IgdGhlIGNvbXBsZXRlIHRyZWUuCgoKCi8vIFVzZSBFUlJQX0FVVE9fUFJPUEFHQVRF IChzZWUgaW5jbHVkZS9xYXBpL2Vycm9yLmgpCi8vCi8vIENvcHlyaWdodCAoYykgMjAyMCBWaXJ0 dW96em8gSW50ZXJuYXRpb25hbCBHbWJILgovLwovLyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCi8vIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzCi8vIHB1Ymxpc2hl ZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRo ZQovLyBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgovLwov LyBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKLy8gYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKLy8gTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQovLyBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgovLwovLyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQovLyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3Jh bS4gIElmIG5vdCwgc2VlCi8vIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KLy8KLy8g VXNhZ2UgZXhhbXBsZToKLy8gc3BhdGNoIC0tc3AtZmlsZSBzY3JpcHRzL2NvY2NpbmVsbGUvYXV0 by1wcm9wYWdhdGVkLWVycnAuY29jY2kgXAovLyAgLS1tYWNyby1maWxlIHNjcmlwdHMvY29jY2kt bWFjcm8tZmlsZS5oIC0taW4tcGxhY2UgXAovLyAgLS1uby1zaG93LWRpZmYgLS1tYXgtd2lkdGgg ODAgRklMRVMuLi4KLy8KLy8gTm90ZTogLS1tYXgtd2lkdGggODAgaXMgbmVlZGVkIGJlY2F1c2Ug Y29jY2luZWxsZSBkZWZhdWx0IGlzIGxlc3MKLy8gdGhhbiA4MCwgYW5kIHdpdGhvdXQgdGhpcyBw YXJhbWV0ZXIgY29jY2luZWxsZSBtYXkgcmVpbmRlbnQgc29tZQovLyBsaW5lcyB3aGljaCBmaXQg aW50byA4MCBjaGFyYWN0ZXJzIGJ1dCBub3QgdG8gY29jY2luZWxsZSBkZWZhdWx0LAovLyB3aGlj aCBpbiB0dXJuIHByb2R1Y2VzIGV4dHJhIHBhdGNoIGh1bmtzIGZvciBubyByZWFzb24uCgovLyBT d2l0Y2ggdW51c3VhbCBFcnJvciAqKiBwYXJhbWV0ZXIgbmFtZXMgdG8gZXJycAovLyAodGhpcyBp cyBuZWNlc3NhcnkgdG8gdXNlIEVSUlBfQVVUT19QUk9QQUdBVEUpLgovLwovLyBEaXNhYmxlIG9w dGlvbmFsX3F1YWxpZmllciB0byBza2lwIGZ1bmN0aW9ucyB3aXRoCi8vICJFcnJvciAqY29uc3Qg KmVycnAiIHBhcmFtZXRlci4KLy8KLy8gU2tpcCBmdW5jdGlvbnMgd2l0aCAiYXNzZXJ0KF9lcnJw ICYmICpfZXJycCkiIHN0YXRlbWVudCwgYmVjYXVzZQovLyB0aGF0IHNpZ25hbHMgdW51c3VhbCBz ZW1hbnRpY3MsIGFuZCB0aGUgcGFyYW1ldGVyIG5hbWUgbWF5IHdlbGwKLy8gc2VydmUgYSBwdXJw b3NlLiAobGlrZSBuYmRfaXRlcl9jaGFubmVsX2Vycm9yKCkpLgovLwovLyBTa2lwIHV0aWwvZXJy b3IuYyB0byBub3QgdG91Y2gsIGZvciBleGFtcGxlLCBlcnJvcl9wcm9wYWdhdGUoKSBhbmQKLy8g ZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoKS4KQCBkZXBlbmRzIG9uICEoZmlsZSBpbiAidXRpbC9l cnJvci5jIikgZGlzYWJsZSBvcHRpb25hbF9xdWFsaWZpZXJACmlkZW50aWZpZXIgZm47CmlkZW50 aWZpZXIgX2VycnAgIT0gZXJycDsKQEAKCiBmbiguLi4sCi0gICBFcnJvciAqKl9lcnJwCisgICBF cnJvciAqKmVycnAKICAgICwuLi4pCiB7CigKICAgICAuLi4gd2hlbiAhPSBhc3NlcnQoX2VycnAg JiYgKl9lcnJwKQomCiAgICAgPC4uLgotICAgIF9lcnJwCisgICAgZXJycAogICAgIC4uLj4KKQog fQoKLy8gQWRkIGludm9jYXRpb24gb2YgRVJSUF9BVVRPX1BST1BBR0FURSB0byBlcnJwLWZ1bmN0 aW9ucyB3aGVyZQovLyBuZWNlc3NhcnkKLy8KLy8gTm90ZSwgdGhhdCB3aXRob3V0ICJ3aGVuIGFu eSIgdGhlIGZpbmFsICIuLi4iIGRvZXMgbm90IG1hY2gKLy8gc29tZXRoaW5nIG1hdGNoZWQgYnkg cHJldmlvdXMgcGF0dGVybiwgaS5lLiB0aGUgcnVsZSB3aWxsIG5vdCBtYXRjaAovLyBkb3VibGUg ZXJyb3JfcHJlcGVuZCBpbiBjb250cm9sIGZsb3cgbGlrZSBpbgovLyB2ZmlvX3NldF9pcnFfc2ln bmFsaW5nKCkuCi8vCi8vIE5vdGUsICJleGlzdHMiIHNheXMgdGhhdCB3ZSB3YW50IGFwcGx5IHJ1 bGUgZXZlbiBpZiBpdCBtYXRjaGVzIG5vdAovLyBvbiBhbGwgcG9zc2libGUgY29udHJvbCBmbG93 cyAob3RoZXJ3aXNlLCBpdCB3aWxsIG5vdCBtYXRjaAovLyBzdGFuZGFyZCBwYXR0ZXJuIHdoZW4g ZXJyb3JfcHJvcGFnYXRlKCkgY2FsbCBpcyBpbiBpZiBicmFuY2gpLgpAIGRpc2FibGUgb3B0aW9u YWxfcXVhbGlmaWVyIGV4aXN0c0AKaWRlbnRpZmllciBmbiwgbG9jYWxfZXJyOwpzeW1ib2wgZXJy cDsKQEAKCiBmbiguLi4sIEVycm9yICoqZXJycCwgLi4uKQogeworICAgRVJSUF9BVVRPX1BST1BB R0FURSgpOwogICAgLi4uICB3aGVuICE9IEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKKAooCiAgICBl cnJvcl9hcHBlbmRfaGludChlcnJwLCAuLi4pOwp8CiAgICBlcnJvcl9wcmVwZW5kKGVycnAsIC4u Lik7CnwKICAgIGVycm9yX3ZwcmVwZW5kKGVycnAsIC4uLik7CikKICAgIC4uLiB3aGVuIGFueQp8 CiAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgIC4uLgooCiAgICBlcnJvcl9wcm9wYWdh dGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsIC4uLik7CnwKICAgIGVycm9yX3Byb3BhZ2F0ZShl cnJwLCBsb2NhbF9lcnIpOwopCiAgICAuLi4KKQogfQoKCi8vIE1hdGNoIGZ1bmN0aW9ucyB3aXRo IHByb3BhZ2F0aW9uIG9mIGxvY2FsIGVycm9yIHRvIGVycnAuCi8vIFdlIHdhbnQgdG8gcmVmZXIg dGhlc2UgZnVuY3Rpb25zIGluIHNldmVyYWwgZm9sbG93aW5nIHJ1bGVzLCBidXQgSQovLyBkb24n dCBrbm93IGEgcHJvcGVyIHdheSB0byBpbmhlcml0IGEgZnVuY3Rpb24sIG5vdCBqdXN0IGl0cyBu YW1lCi8vICh0byBub3QgbWF0Y2ggYW5vdGhlciBmdW5jdGlvbnMgd2l0aCBzYW1lIG5hbWUgaW4g Zm9sbG93aW5nIHJ1bGVzKS4KLy8gTm90LXByb3BlciB3YXkgaXMgYXMgZm9sbG93czogcmVuYW1l IGVycnAgcGFyYW1ldGVyIGluIGZ1bmN0aW9ucwovLyBoZWFkZXIgYW5kIG1hdGNoIGl0IGluIGZv bGxvd2luZyBydWxlcy4gUmVuYW1lIGl0IGJhY2sgYWZ0ZXIgYWxsCi8vIHRyYW5zZm9ybWF0aW9u cy4KLy8KLy8gVGhlIHNpbXBsZXN0IGNhc2Ugb2YgcHJvcGFnYXRpb24gc2NoZW1lIGlzIHNpbmds ZSBkZWZpbml0aW9uIG9mCi8vIGxvY2FsX2VyciB3aXRoIGF0IG1vc3Qgb25lIGVycm9yX3Byb3Bh Z2F0ZV9wcmVwZW5kIG9yCi8vIGVycm9yX3Byb3BhZ2F0ZSBvbiBlYWNoIGNvbnRyb2wtZmxvdy4g U3RpbGwsIHdlIHdhbnQgdG8gbWF0Y2ggbW9yZQovLyBjb21wbGV4IHNjaGVtZXMgdG9vLiBXZSds bCB3YXJuIHRoZW0gd2l0aCBoZWxwIG9mIGZ1cnRoZXIgcnVsZXMuCkBydWxlMSBkaXNhYmxlIG9w dGlvbmFsX3F1YWxpZmllciBleGlzdHNACmlkZW50aWZpZXIgZm4sIGxvY2FsX2VycjsKc3ltYm9s IGVycnA7CkBACgogZm4oLi4uLCBFcnJvciAqKgotICAgIGVycnAKKyAgICBfX19fCiAgICAsIC4u LikKIHsKICAgICAuLi4KICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICAuLi4KKAog ICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgLi4uKTsKfAogICAg IGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwopCiAgICAgLi4uCiB9CgoKLy8gV2Fy biBzZXZlcmFsIEVycm9yICogZGVmaW5pdGlvbnMuCkBjaGVjazEgZGlzYWJsZSBvcHRpb25hbF9x dWFsaWZpZXIgZXhpc3RzQAppZGVudGlmaWVyIGZuLCBfZXJycCwgbG9jYWxfZXJyLCBsb2NhbF9l cnIyOwpwb3NpdGlvbiBwMSwgcDI7CkBACgogZm4oLi4uLCBFcnJvciAqKl9lcnJwLCAuLi4pCiB7 CiAgICAgLi4uCiAgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7QHAxCiAgICAgLi4uIHdoZW4g YW55CiAgICAgRXJyb3IgKmxvY2FsX2VycjIgPSBOVUxMO0BwMgogICAgIC4uLiB3aGVuIGFueQog fQoKQCBzY3JpcHQ6cHl0aG9uIEAKZm4gPDwgY2hlY2sxLmZuOwpwMSA8PCBjaGVjazEucDE7CnAy IDw8IGNoZWNrMS5wMjsKQEAKCnByaW50KCdXYXJuaW5nOiBmdW5jdGlvbiB7fSBoYXMgc2V2ZXJh bCBkZWZpbml0aW9ucyBvZiAnCiAgICAgICdFcnJvciAqIGxvY2FsIHZhcmlhYmxlOiBhdCB7fTp7 fSBhbmQgdGhlbiBhdCB7fTp7fScuZm9ybWF0KAogICAgICAgICAgZm4sIHAxWzBdLmZpbGUsIHAx WzBdLmxpbmUsIHAyWzBdLmZpbGUsIHAyWzBdLmxpbmUpKQoKLy8gV2FybiBzZXZlcmFsIHByb3Bh Z2F0aW9ucyBpbiBjb250cm9sIGZsb3cuCkBjaGVjazIgZGlzYWJsZSBvcHRpb25hbF9xdWFsaWZp ZXIgZXhpc3RzQAppZGVudGlmaWVyIGZuLCBfZXJycDsKcG9zaXRpb24gcDEsIHAyOwpAQAoKIGZu KC4uLiwgRXJyb3IgKipfZXJycCwgLi4uKQogewogICAgIC4uLgooCiAgICAgZXJyb3JfcHJvcGFn YXRlX3ByZXBlbmQoX2VycnAsIC4uLik7QHAxCnwKICAgICBlcnJvcl9wcm9wYWdhdGUoX2VycnAs IC4uLik7QHAxCikKICAgICAuLi4KKAogICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKF9lcnJw LCAuLi4pO0BwMgp8CiAgICAgZXJyb3JfcHJvcGFnYXRlKF9lcnJwLCAuLi4pO0BwMgopCiAgICAg Li4uIHdoZW4gYW55CiB9CgpAIHNjcmlwdDpweXRob24gQApmbiA8PCBjaGVjazIuZm47CnAxIDw8 IGNoZWNrMi5wMTsKcDIgPDwgY2hlY2syLnAyOwpAQAoKcHJpbnQoJ1dhcm5pbmc6IGZ1bmN0aW9u IHt9IHByb3BhZ2F0ZXMgdG8gZXJycCBzZXZlcmFsIHRpbWVzIGluICcKICAgICAgJ29uZSBjb250 cm9sIGZsb3c6IGF0IHt9Ont9IGFuZCB0aGVuIGF0IHt9Ont9Jy5mb3JtYXQoCiAgICAgICAgICBm biwgcDFbMF0uZmlsZSwgcDFbMF0ubGluZSwgcDJbMF0uZmlsZSwgcDJbMF0ubGluZSkpCgovLyBD b252ZXJ0IHNwZWNpYWwgY2FzZSB3aXRoIGdvdG8gc2VwYXJhdGVseS4KLy8gSSB0cmllZCBtZXJn aW5nIHRoaXMgaW50byB0aGUgZm9sbG93aW5nIHJ1bGUgdGhlIG9idmlvdXMgd2F5LCBidXQKLy8g aXQgbWFkZSBDb2NjaW5lbGxlIGhhbmcgb24gYmxvY2suYwovLwovLyBOb3RlIGludGVyZXN0aW5n IHRoaW5nOiBpZiB3ZSBkb24ndCBkbyBpdCBoZXJlLCBhbmQgdHJ5IHRvIGZpeHVwCi8vICJvdXQ6 IH0iIHRoaW5ncyBsYXRlciBhZnRlciBhbGwgdHJhbnNmb3JtYXRpb25zICh0aGUgcnVsZSB3aWxs IGJlCi8vIHRoZSBzYW1lLCBqdXN0IHdpdGhvdXQgZXJyb3JfcHJvcGFnYXRlKCkgY2FsbCksIGNv Y2NpbmVsbGUgZmFpbHMgdG8KLy8gbWF0Y2ggdGhpcyAib3V0OiB9Ii4KQCBkaXNhYmxlIG9wdGlv bmFsX3F1YWxpZmllckAKaWRlbnRpZmllciBmbiwgcnVsZTEubG9jYWxfZXJyLCBvdXQ7CnN5bWJv bCBlcnJwOwpAQAoKIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQogewogICAgIDwuLi4KLSAg ICBnb3RvIG91dDsKKyAgICByZXR1cm47CiAgICAgLi4uPgotIG91dDoKLSAgICBlcnJvcl9wcm9w YWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKIH0KCi8vIENvbnZlcnQgbW9zdCBvZiBsb2NhbF9lcnIg cmVsYXRlZCBzdHVmZi4KLy8KLy8gTm90ZSwgdGhhdCB3ZSB1cGRhdGUgZXZlcnl0aGluZyByZWxh dGVkIHRvIG1hdGNoZWQgYnkgcnVsZTEKLy8gZnVuY3Rpb24gbmFtZSBhbmQgbG9jYWxfZXJyIG5h bWUuIFdlIG1heSBtYXRjaCBzb21ldGhpbmcgbm90Ci8vIHJlbGF0ZWQgdG8gdGhlIHBhdHRlcm4g bWF0Y2hlZCBieSBydWxlMS4gRm9yIGV4YW1wbGUsIGxvY2FsX2VyciBtYXkKLy8gYmUgZGVmaW5l ZCB3aXRoIHRoZSBzYW1lIG5hbWUgaW4gZGlmZmVyZW50IGJsb2NrcyBpbnNpZGUgb25lCi8vIGZ1 bmN0aW9uLCBhbmQgaW4gb25lIGJsb2NrIGZvbGxvdyB0aGUgcHJvcGFnYXRpb24gcGF0dGVybiBh bmQgaW4KLy8gb3RoZXIgYmxvY2sgZG9lc24ndC4gT3Igd2UgbWF5IGhhdmUgc2V2ZXJhbCBmdW5j dGlvbnMgd2l0aCB0aGUgc2FtZQovLyBuYW1lIChmb3IgZGlmZmVyZW50IGNvbmZpZ3VyYXRpb25z KS4KLy8KLy8gTm90ZSBhbHNvIHRoYXQgZXJycC1jbGVhbmluZyBmdW5jdGlvbnMKLy8gICBlcnJv cl9mcmVlX2VycnAKLy8gICBlcnJvcl9yZXBvcnRfZXJycAovLyAgIGVycm9yX3JlcG9ydGZfZXJy cAovLyAgIHdhcm5fcmVwb3J0X2VycnAKLy8gICB3YXJuX3JlcG9ydGZfZXJycAovLyBhcmUgbm90 IHlldCBpbXBsZW1lbnRlZC4gVGhleSBtdXN0IGNhbGwgY29ycmVzcG9uZGluZyBFcnJvciogLQov LyBmcmVlaW5nIGZ1bmN0aW9uIGFuZCB0aGVuIHNldCAqZXJycCB0byBOVUxMLCB0byBhdm9pZCBm dXJ0aGVyCi8vIHByb3BhZ2F0aW9uIHRvIG9yaWdpbmFsIGVycnAgKGNvbnNpZGVyIEVSUlBfQVVU T19QUk9QQUdBVEUgaW4gdXNlKS4KLy8gRm9yIGV4YW1wbGUsIGVycm9yX2ZyZWVfZXJycCBtYXkg bG9vayBsaWtlIHRoaXM6Ci8vCi8vICAgIHZvaWQgZXJyb3JfZnJlZV9lcnJwKEVycm9yICoqZXJy cCkKLy8gICAgewovLyAgICAgICAgZXJyb3JfZnJlZSgqZXJycCk7Ci8vICAgICAgICAqZXJycCA9 IE5VTEw7Ci8vICAgIH0KQCBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACmlkZW50 aWZpZXIgZm4sIHJ1bGUxLmxvY2FsX2VycjsKZXhwcmVzc2lvbiBsaXN0IGFyZ3M7CnN5bWJvbCBl cnJwOwpAQAoKIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQogewogICAgIDwuLi4KKAotICAg IEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwp8CgovLyBDb252ZXJ0IGVycm9yIGNsZWFyaW5nIGZ1 bmN0aW9ucwooCi0gICAgZXJyb3JfZnJlZShsb2NhbF9lcnIpOworICAgIGVycm9yX2ZyZWVfZXJy cChlcnJwKTsKfAotICAgIGVycm9yX3JlcG9ydF9lcnIobG9jYWxfZXJyKTsKKyAgICBlcnJvcl9y ZXBvcnRfZXJycChlcnJwKTsKfAotICAgIGVycm9yX3JlcG9ydGZfZXJyKGxvY2FsX2VyciwgYXJn cyk7CisgICAgZXJyb3JfcmVwb3J0Zl9lcnJwKGVycnAsIGFyZ3MpOwp8Ci0gICAgd2Fybl9yZXBv cnRfZXJyKGxvY2FsX2Vycik7CisgICAgd2Fybl9yZXBvcnRfZXJycChlcnJwKTsKfAotICAgIHdh cm5fcmVwb3J0Zl9lcnIobG9jYWxfZXJyLCBhcmdzKTsKKyAgICB3YXJuX3JlcG9ydGZfZXJycChl cnJwLCBhcmdzKTsKKQo/LSAgICBsb2NhbF9lcnIgPSBOVUxMOwoKfAotICAgIGVycm9yX3Byb3Bh Z2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgYXJncyk7CisgICAgZXJyb3JfcHJlcGVuZChl cnJwLCBhcmdzKTsKfAotICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwp8Ci0g ICAgJmxvY2FsX2VycgorICAgIGVycnAKKQogICAgIC4uLj4KIH0KCi8vIENvbnZlcnQgcmVtYWlu aW5nIGxvY2FsX2VyciB1c2FnZS4gRm9yIGV4YW1wbGUsIGRpZmZlcmVudCBraW5kcyBvZgovLyBl cnJvciBjaGVja2luZyBpbiBpZiBjb25kaXRpb25hbHMuIFdlIGNhbid0IG1lcmdlIHRoaXMgaW50 bwovLyBwcmV2aW91cyBodW5rLCBhcyB0aGlzIGNvbmZsaWN0cyB3aXRoIG90aGVyIHN1YnN0aXR1 dGlvbnMgaW4gaXQgKGF0Ci8vIGxlYXN0IHdpdGggIi0gbG9jYWxfZXJyID0gTlVMTCIpLgpAIGRp c2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyQAppZGVudGlmaWVyIGZuLCBydWxlMS5sb2NhbF9lcnI7 CnN5bWJvbCBlcnJwOwpAQAoKIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQogewogICAgIDwu Li4KLSAgICBsb2NhbF9lcnIKKyAgICAqZXJycAogICAgIC4uLj4KIH0KCi8vIEFsd2F5cyB1c2Ug dGhlIHNhbWUgcGF0dGVybiBmb3IgY2hlY2tpbmcgZXJyb3IKQCBkaXNhYmxlIG9wdGlvbmFsX3F1 YWxpZmllckAKaWRlbnRpZmllciBmbjsKc3ltYm9sIGVycnA7CkBACgogZm4oLi4uLCBFcnJvciAq KiBfX19fLCAuLi4pCiB7CiAgICAgPC4uLgotICAgICplcnJwICE9IE5VTEwKKyAgICAqZXJycAog ICAgIC4uLj4KIH0KCi8vIFJldmVydCB0ZW1wb3JhcnkgX19fIGlkZW50aWZpZXIuCkAgZGlzYWJs ZSBvcHRpb25hbF9xdWFsaWZpZXJACmlkZW50aWZpZXIgZm47CkBACgogZm4oLi4uLCBFcnJvciAq KgotICAgX19fXworICAgZXJycAogICAgLCAuLi4pCiB7CiAgICAgLi4uCiB9CgoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcg bGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9q ZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA== 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 6BE51C10DCE for ; Fri, 13 Mar 2020 21:56:24 +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 27AC52074E for ; Fri, 13 Mar 2020 21:56:24 +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="FD2j9sA1" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 27AC52074E 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]:38238 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jCsI3-00006K-DR for qemu-devel@archiver.kernel.org; Fri, 13 Mar 2020 17:56:23 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:51773) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jCsGR-00077V-Ox for qemu-devel@nongnu.org; Fri, 13 Mar 2020 17:54:47 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1jCsGN-0004ve-2P for qemu-devel@nongnu.org; Fri, 13 Mar 2020 17:54:43 -0400 Received: from us-smtp-delivery-1.mimecast.com ([205.139.110.120]:31405 helo=us-smtp-1.mimecast.com) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1jCsGM-0004t6-Qq for qemu-devel@nongnu.org; Fri, 13 Mar 2020 17:54:39 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584136477; 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=NvrbxEp0ORNjN4T28u8DpDcF2uEiVqe5w/63L03txyY=; b=FD2j9sA1HsQ4AwrYvkCmYPr5cb42r+EhBK7EeQRnoaciiuds/bpDz5Xu3CrpoJotZT7yQg xWj43cvbSI1qE1M2BIsDQAUR0NBUsUNasw5ngXn8wH6/cpDxaj3jzbsIy4Szd4Px1hLSz+ ronyL4qbiAvibixQCd0guC7R4i9sU5I= 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-428-dbVRRJwyPVqPHVlfE5CTUg-1; Fri, 13 Mar 2020 17:54:30 -0400 X-MC-Unique: dbVRRJwyPVqPHVlfE5CTUg-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 6C7351060DF6; Fri, 13 Mar 2020 21:54:28 +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 293AA5C1B0; Fri, 13 Mar 2020 21:54:22 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id A69B611386A6; Fri, 13 Mar 2020 22:54:20 +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> <874kuto7hq.fsf@dusky.pond.sub.org> <4a70c6ee-10a2-fdc3-f8df-88c05340398b@virtuozzo.com> <875zf8gt2m.fsf@dusky.pond.sub.org> <7c6f9a91-76cf-242d-8166-0693ec14b24d@virtuozzo.com> Date: Fri, 13 Mar 2020 22:54:20 +0100 In-Reply-To: <7c6f9a91-76cf-242d-8166-0693ec14b24d@virtuozzo.com> (Vladimir Sementsov-Ogievskiy's message of "Fri, 13 Mar 2020 19:12:17 +0300") Message-ID: <87blozex9v.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.16 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: 205.139.110.120 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 , qemu-block@nongnu.org, Paul Durrant , qemu-devel@nongnu.org, Laszlo Ersek , Christian Schoenebeck , Markus Armbruster , Michael Roth , Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , Stefan Berger Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" Vladimir Sementsov-Ogievskiy writes: > 13.03.2020 18:42, Markus Armbruster wrote: >> Vladimir Sementsov-Ogievskiy writes: >> >>> 12.03.2020 19:36, Markus Armbruster wrote: >>>> I may have a second look tomorrow with fresher eyes, but let's get thi= s >>>> out now as is. >>>> >>>> Vladimir Sementsov-Ogievskiy writes: >>>> >>>>> Script adds ERRP_AUTO_PROPAGATE macro invocation where appropriate an= d >>>>> 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/= coccinelle/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 th= e >>>>> +// 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 who= le >>>> 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 *pr= ops, Error **errp) >>>> +void object_apply_global_props(Object *obj, const GPtrArray *pr= ops, >>>> + Error **errp) >>>> { >>>> + ERRP_AUTO_PROPAGATE(); >>>> int i; >>>> >>>> if (!props) { >>>> >>>> Reformatting, but not unwanted. >>> >>> Yes, I saw it. This line is 81 character length, so it's OK to fix it i= n one hunk with >>> ERRP_AUTO_PROPAGATE addition even for non-automatic patch. >> >> Agree. >> >>>> >>>> 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 s= upport 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() an= d >>>>> +// 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 mat= ch >>>>> +// double error_prepend in control flow like in >>>>> +// vfio_set_irq_signaling(). >>>>> +// >>>>> +// Note, "exists" says that we want apply rule even if it matches no= t >>>>> +// 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 mor= e >>>>> +// 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 m= ost one >>>> // error_propagate_prepend() or error_propagate() on each contro= l-flow >>>> // path. Instances of this case we convert with this script. Fun= ctions >>> >>> For me, sounds a bit like "other things we don't convert". >>> Actually we convert other things too. >> >> What other patterns of error propagation do we convert? > > Something like in xen_block_device_destroy, why not? Otherwise, it's bett= er to avoid > matching things like xen_block_device_destroy, not just warn them. > But I'd prefer to proceed now as is to fit into 5.0.. Too much time alrea= dy > spent on this. So, I'm OK with your wording too. Let's scratch "Instances of this case we convert with this script." >>>> // 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? >>> >>> I didn't find other way to ref check1.fn in next python rule. It just d= on't >>> work if I write here just rule1.fn. >>> >>>> >>>> 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. >>> >>> I think, it's more efficient to reuse names from previous rules. I thin= k it should >>> work faster (more information, less extra matching). >> >> Nope. With my hacked up script (patch appended) Coccinelle is actually >> *faster* for the .[ch] touched by this series: with your unmodified >> script, it takes a bit over 12s on my box, with mine around 7s. Output >> is identical. >> >> Never guess performance, always measure it :) > > Hmm, whole tree results would be better proof > >> >> Two notes on my script: >> >> * Unlike yours, it recognizes double-propagation in my test case. >> Discussed below. >> >> * Its "several definitions of" warning includes positions. That turned >> out to be useless, but I've been too lazy to take that out again. >> >>>> >>>>> +@@ >>>>> + >>>>> + fn(..., Error ** ____, ...) >>>>> + { >>>>> + ... >>>>> + Error *local_err =3D NULL; >>>>> + ... when any >>>>> + Error *local_err2 =3D NULL; >>>>> + ... when any >>>>> + } This flags functions that have more than one declaration along any control flow path. It doesn't flag this one: void gnat(bool b, Error **errp) { if (b) { Error *local_err =3D NULL; foo(arg, &local_err); error_propagate(errp, local_err); } else { Error *local_err =3D NULL; bar(arg, &local_err); error_propagate(errp, local_err); } } The Coccinelle script does the right thing for this one regardless. I'd prefer to have such functions flagged, too. But spending time on convincing Coccinelle to do it for me is not worthwhile; I can simply search the diff produced by Coccinelle for deletions of declarations that are not indented exactly four spaces. But if we keep this rule, we should adjust its comment // Warn several Error * definitions. because it sure suggests it also catches functions like the one I gave above. >>>>> + >>>>> +@ 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. >>> >>> Yes, rule1 wants at least one code flow with non-doubled propagation. >>> >>>> >>>> If I change the rule as follows, it catches the example: >>>> >>>> @@ -157,24 +157,23 @@ print('Warning: function {} has several de= finitions 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: >>> >>> I don't think so. Why to check what we are not going to convert? If we = want >>> to check side things, it's better to do it in other coccinelle script.. >> >> Misunderstanding? The rules are still chained together via the ___ >> hack, just not via function name, because that's unreliable and >> redundant. > > Strange.. Then, how can it match something not matched by rule1? I think I got confused when I wrote the "Misunderstanding?" paragraph. Let me try again. First rule check2. The common case is a at most one propagation to @errp along any control flow path. We trust your Coccinelle script to convert that alright. Any other propagation to @errp I want to review. Whether the script attempts a conversion or not is unimportant, as long as it points me to the function to review. Rule rule1 matches functions that propagate to @errp once along at least one control flow path. Unchained from rule rule1, rule check2 flags any function that propagates to @errp multiple times along any control flow path. Chained to rule1, it flags only functions that also have a path with single propagation. In other words, the unchained rule flags *all* multi-propagations to @errp, while the chained rule flags only the ones the script attempts to convert. The former is much more useful to me. Now rule check1. It flags functions with multiple declarations along any control flow path. Again, chaining it to rule1 restricts it to the functions we attempt to convert. Makes it less useful to me. However, because my desire to review multiple declarations in function we don't attempt to convert is lower than my desire to review multiple propagations to @errp in such functions, chaining check1 is tolerable for me. But why chain check1 if we don't chain check2? > >> >>>> >>>> @@ -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. >>> >>> Logically, I want to inherit from rule1. So why not to stress it by inh= eriting >>> fn variable? It's just a correct thing to do. >>> And I hope it helps coccinelle to work more efficiently. >>> >>>> >>>>> +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 m= ay >>>>> +// 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 sa= me >>>>> +// 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 o= f >>>>> +// 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 >>>>> */ >>>>> #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 >>>>> GDB stub >>>>> M: Alex Benn=C3=A9e >>>> >> >> >> From 42a08c529024337d1b859839c9ce7f797f784555 Mon Sep 17 00:00:00 2001 >> From: Markus Armbruster >> Date: Fri, 13 Mar 2020 14:27:57 +0100 >> Subject: [PATCH] fixup! scripts: Coccinelle script to use >> ERRP_AUTO_PROPAGATE() >> >> --- >> scripts/coccinelle/auto-propagated-errp.cocci | 37 ++++++++++--------- >> 1 file changed, 20 insertions(+), 17 deletions(-) >> >> diff --git a/scripts/coccinelle/auto-propagated-errp.cocci b/scripts/coc= cinelle/auto-propagated-errp.cocci >> index 7dac2dcfa4..43b0b0e63b 100644 >> --- a/scripts/coccinelle/auto-propagated-errp.cocci >> +++ b/scripts/coccinelle/auto-propagated-errp.cocci >> @@ -136,45 +136,48 @@ 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; >> +position p1, p2; > > > Hmm, seems like I forget to define ____ as symbol in my patch Coccinelle defaults to symbol. >> @@ >> - fn(..., Error ** ____, ...) >> + fn(..., Error **_errp, ...) > > Ahmm.. it will break compilation? > > Or, how will it work when _errp defined as meta variable is only in "+...= " line? Should it be symbol instead, or just not defined? Misunderstanding? It's a diff between your .cocci and mine. My version is // Warn several Error * definitions. @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; @@ >> { >> ... >> - Error *local_err =3D NULL; >> + Error *local_err =3D NULL;@p1 > > Why to do -/+ here? Nothing changed.. > >> ... when any >> - Error *local_err2 =3D NULL; >> + 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'.format(fn)) >> + 'Error * local variable: at {}:{} and then at {}:{}'.format( >> + fn, p1[0].file, p1[0].line, p2[0].file, p2[0].line)) >> // 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 >> ) > > You change some occurrences of errp to _errp, but not all. It breaks comp= ilation. > >> ... when any >> } >> @@ -198,7 +201,7 @@ print('Warning: function {} propagates to errp sever= al times in ' >> // the same, just without error_propagate() call), coccinelle fails to >> // match this "out: }". >> @ disable optional_qualifier@ >> -identifier rule1.fn, rule1.local_err, out; >> +identifier fn, rule1.local_err, out; > > Hmm. If it improves performance it is strange.. But I can live with this = change. > >> symbol errp; >> @@ >> @@ -239,7 +242,7 @@ symbol errp; >> // *errp =3D NULL; >> // } >> @ disable optional_qualifier exists@ >> -identifier rule1.fn, rule1.local_err; >> +identifier fn, rule1.local_err; >> expression list args; >> symbol errp; >> @@ >> @@ -287,7 +290,7 @@ symbol errp; >> // 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; >> +identifier fn, rule1.local_err; >> symbol errp; >> @@ >> @@ -301,7 +304,7 @@ symbol errp; >> // Always use the same pattern for checking error >> @ disable optional_qualifier@ >> -identifier rule1.fn; >> +identifier fn; >> symbol errp; >> @@ >> @@ -315,7 +318,7 @@ symbol errp; >> // Revert temporary ___ identifier. >> @ disable optional_qualifier@ >> -identifier rule1.fn; >> +identifier fn; >> @@ >> fn(..., Error ** >> I append my hacked up version of auto-propagated-errp.cocci. It produces the same patch as yours for the complete tree. // 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 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. @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, _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 several propagations in 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)) // 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 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 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 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 fn, rule1.local_err; symbol errp; @@ fn(..., Error ** ____, ...) { <... - local_err + *errp ...> } // Always use the same pattern for checking error @ disable optional_qualifier@ identifier fn; symbol errp; @@ fn(..., Error ** ____, ...) { <... - *errp !=3D NULL + *errp ...> } // Revert temporary ___ identifier. @ disable optional_qualifier@ identifier fn; @@ fn(..., Error ** - ____ + errp , ...) { ... }