From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.5 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 20E6DC10F27 for ; Tue, 10 Mar 2020 15:48:23 +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 DD86720866 for ; Tue, 10 Mar 2020 15:48:22 +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="D5XDWbxT" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DD86720866 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 1jBh6z-0002Gq-I6; Tue, 10 Mar 2020 15:48:05 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1jBh6y-0002Gi-CC for xen-devel@lists.xenproject.org; Tue, 10 Mar 2020 15:48:04 +0000 X-Inumbo-ID: 86210276-62e6-11ea-add4-12813bfff9fa Received: from us-smtp-1.mimecast.com (unknown [207.211.31.81]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTP id 86210276-62e6-11ea-add4-12813bfff9fa; Tue, 10 Mar 2020 15:48:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1583855281; 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=llDx5f/9wcs3vbiatzh0myHKONfdDXiTM5J6AYYnUJM=; b=D5XDWbxT6PT56bDcEECsoR+xQBsxUUEjcZX99ITtBBCwjPkCH/o3u/25BWm9aQ3BJZHTdK w1yRc2AAdUTReyFPQKaK7gN/chylNpG6oGF9TNrrLdtVK8CYGTDOClzY0D8ivMKiw/fQ3H g4+ujhzdRrx4vFtQqVzs/zQOtpT86K8= 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-43-aRqdc__hM86O2bD4Qkxjvg-1; Tue, 10 Mar 2020 11:47:58 -0400 X-MC-Unique: aRqdc__hM86O2bD4Qkxjvg-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 9F164800D50; Tue, 10 Mar 2020 15:47:55 +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 4D3F75D9C5; Tue, 10 Mar 2020 15:47:49 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id C2C9511386A6; Tue, 10 Mar 2020 16:47:47 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy References: <20200306051536.27803-1-vsementsov@virtuozzo.com> <20200306051536.27803-3-vsementsov@virtuozzo.com> <87lfo997hs.fsf@dusky.pond.sub.org> Date: Tue, 10 Mar 2020 16:47:47 +0100 In-Reply-To: (Vladimir Sementsov-Ogievskiy's message of "Tue, 10 Mar 2020 10:44:22 +0300") Message-ID: <87lfo8nrdo.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.14 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Subject: Re: [Xen-devel] [PATCH v8 02/10] scripts: add coccinelle script to use auto propagated errp 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 , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , Christian Schoenebeck , Michael Roth , qemu-devel@nongnu.org, Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Laszlo Ersek , 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+IDA5LjAzLjIwMjAgMTI6NTYsIE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+PiBT dWdnZXN0Cj4+Cj4+ICAgICAgc2NyaXB0czogQ29jY2luZWxsZSBzY3JpcHQgdG8gdXNlIGF1dG8t cHJvcGFnYXRlZCBlcnJwCj4+Cj4+IG9yCj4+Cj4+ICAgICAgc2NyaXB0czogQ29jY2luZWxsZSBz Y3JpcHQgdG8gdXNlIEVSUlBfQVVUT19QUk9QQUdBVEUoKQo+Pgo+PiBWbGFkaW1pciBTZW1lbnRz b3YtT2dpZXZza2l5IDx2c2VtZW50c292QHZpcnR1b3p6by5jb20+IHdyaXRlczoKPj4KPj4+IFNj cmlwdCBhZGRzIEVSUlBfQVVUT19QUk9QQUdBVEUgbWFjcm8gaW52b2NhdGlvbiB3aGVyZSBhcHBy b3ByaWF0ZSBhbmQKPj4+IGRvZXMgY29ycmVzcG9uZGluZyBjaGFuZ2VzIGluIGNvZGUgKGxvb2sg Zm9yIGRldGFpbHMgaW4KPj4+IGluY2x1ZGUvcWFwaS9lcnJvci5oKQo+Pj4KPj4+IFVzYWdlIGV4 YW1wbGU6Cj4+PiBzcGF0Y2ggLS1zcC1maWxlIHNjcmlwdHMvY29jY2luZWxsZS9hdXRvLXByb3Bh Z2F0ZWQtZXJycC5jb2NjaSBcCj4+PiAgIC0tbWFjcm8tZmlsZSBzY3JpcHRzL2NvY2NpLW1hY3Jv LWZpbGUuaCAtLWluLXBsYWNlIC0tbm8tc2hvdy1kaWZmIFwKPj4+ICAgYmxvY2tkZXYtbmJkLmMg cWVtdS1uYmQuYyB7YmxvY2svbmJkKixuYmQvKixpbmNsdWRlL2Jsb2NrL25iZCp9LltoY10KPj4K Pj4gU3VnZ2VzdCBGSUxFUy4uLiBpbnN0ZWFkIG9mIGEgc3BlY2lmaWMgc2V0IG9mIGZpbGVzLgo+ Pgo+Pj4gU2lnbmVkLW9mZi1ieTogVmxhZGltaXIgU2VtZW50c292LU9naWV2c2tpeSA8dnNlbWVu dHNvdkB2aXJ0dW96em8uY29tPgo+Pj4gLS0tCj4+Pgo+Pj4gQ2M6IEVyaWMgQmxha2UgPGVibGFr ZUByZWRoYXQuY29tPgo+Pj4gQ2M6IEtldmluIFdvbGYgPGt3b2xmQHJlZGhhdC5jb20+Cj4+PiBD YzogTWF4IFJlaXR6IDxtcmVpdHpAcmVkaGF0LmNvbT4KPj4+IENjOiBHcmVnIEt1cnogPGdyb3Vn QGthb2Qub3JnPgo+Pj4gQ2M6IENocmlzdGlhbiBTY2hvZW5lYmVjayA8cWVtdV9vc3NAY3J1ZGVi eXRlLmNvbT4KPj4+IENjOiBTdGVmYW5vIFN0YWJlbGxpbmkgPHNzdGFiZWxsaW5pQGtlcm5lbC5v cmc+Cj4+PiBDYzogQW50aG9ueSBQZXJhcmQgPGFudGhvbnkucGVyYXJkQGNpdHJpeC5jb20+Cj4+ PiBDYzogUGF1bCBEdXJyYW50IDxwYXVsQHhlbi5vcmc+Cj4+PiBDYzogU3RlZmFuIEhham5vY3pp IDxzdGVmYW5oYUByZWRoYXQuY29tPgo+Pj4gQ2M6ICJQaGlsaXBwZSBNYXRoaWV1LURhdWTDqSIg PHBoaWxtZEByZWRoYXQuY29tPgo+Pj4gQ2M6IExhc3psbyBFcnNlayA8bGVyc2VrQHJlZGhhdC5j b20+Cj4+PiBDYzogR2VyZCBIb2ZmbWFubiA8a3JheGVsQHJlZGhhdC5jb20+Cj4+PiBDYzogU3Rl ZmFuIEJlcmdlciA8c3RlZmFuYkBsaW51eC5pYm0uY29tPgo+Pj4gQ2M6IE1hcmt1cyBBcm1icnVz dGVyIDxhcm1icnVAcmVkaGF0LmNvbT4KPj4+IENjOiBNaWNoYWVsIFJvdGggPG1kcm90aEBsaW51 eC52bmV0LmlibS5jb20+Cj4+PiBDYzogcWVtdS1ibG9ja0Bub25nbnUub3JnCj4+PiBDYzogcWVt dS1kZXZlbEBub25nbnUub3JnCj4+PiBDYzogeGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3Jn Cj4+Pgo+Pj4gICBpbmNsdWRlL3FhcGkvZXJyb3IuaCAgICAgICAgICAgICAgICAgICAgICAgICAg fCAgIDMgKwo+Pj4gICBzY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29j Y2kgfCAyMzEgKysrKysrKysrKysrKysrKysrCj4+PiAgIDIgZmlsZXMgY2hhbmdlZCwgMjM0IGlu c2VydGlvbnMoKykKPj4+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IHNjcmlwdHMvY29jY2luZWxsZS9h dXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaQo+Pj4KPj4+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3Fh cGkvZXJyb3IuaCBiL2luY2x1ZGUvcWFwaS9lcnJvci5oCj4+PiBpbmRleCBiYjliY2YwMmZiLi5m YmZjNmYxYzBiIDEwMDY0NAo+Pj4gLS0tIGEvaW5jbHVkZS9xYXBpL2Vycm9yLmgKPj4+ICsrKyBi L2luY2x1ZGUvcWFwaS9lcnJvci5oCj4+PiBAQCAtMjExLDYgKzIxMSw5IEBACj4+PiAgICAqICAg ICAgICAgfQo+Pj4gICAgKiAgICAgICAgIC4uLgo+Pj4gICAgKiAgICAgfQo+Pj4gKyAqCj4+PiAr ICogRm9yIG1hc3MgY29udmVyc2lvbiB1c2Ugc2NyaXB0Cj4+Cj4+IG1hc3MtY29udmVyc2lvbiAo d2UncmUgbm90IGNvbnZlcnRpbmcgbWFzcywgd2UncmUgY29udmVydGluZyBlbiBtYXNzZSkKPj4K Pj4+ICsgKiAgIHNjcmlwdHMvY29jY2luZWxsZS9hdXRvLXByb3BhZ2F0ZWQtZXJycC5jb2NjaQo+ Pj4gICAgKi8KPj4+ICAgICAjaWZuZGVmIEVSUk9SX0gKPj4+IGRpZmYgLS1naXQgYS9zY3JpcHRz L2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kgYi9zY3JpcHRzL2NvY2NpbmVs bGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kKPj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+ PiBpbmRleCAwMDAwMDAwMDAwLi5iZmYyNzRiZDZkCj4+PiAtLS0gL2Rldi9udWxsCj4+PiArKysg Yi9zY3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kKPj4KPj4gUHJl ZmFjZSB0byBteSByZXZpZXcgb2YgdGhpcyBzY3JpcHQ6IG1heSBhaW0gaXNuJ3QgdG8gbWFrZSBp dAo+PiBidWxsZXQtcHJvb2YuICBJIHdhbnQgdG8gKDEpIG1ha2UgaXQgZ29vZCBlbm91Z2ggKGV4 cGxhaW5lZCBpbiBhCj4+IGppZmZpZSksIGFuZCAoMikgYXV0b21hdGljYWxseSBpZGVudGlmeSB0 aGUgc3BvdHMgd2hlcmUgaXQgc3RpbGwgaXNuJ3QKPj4gb2J2aW91c2x5IHNhZmUgZm9yIG1hbnVh bCByZXZpZXcuCj4+Cj4+IFRoZSBsYXR0ZXIgbWF5IGludm9sdmUgYWRkaXRpb25hbCBzY3JpcHRp bmcuICBUaGF0J3Mgb2theS4KPj4KPj4gVGhlIHNjcmlwdCBpcyBnb29kIGVub3VnaCB3aGVuIHRo ZSBudW1iZXIgb2YgcG9zc2libHkgdW5zYWZlIHNwb3RzIGlzCj4+IGxvdyBlbm91Z2ggZm9yIGNh cmVmdWwgbWFudWFsIHJldmlldy4KPj4KPj4gV2hlbiBJIGFzayBmb3IgaW1wcm92ZW1lbnRzIHRo YXQsIGluIHlvdXIgb3BpbmlvbiwgZ28gYmV5b25kICJnb29kCj4+IGVub3VnaCIsIHBsZWFzZSBw dXNoIGJhY2suICBJJ20gc3VyZSB3ZSBjYW4gd29yayBpdCBvdXQgdG9nZXRoZXIuCj4+Cj4+PiBA QCAtMCwwICsxLDIzMSBAQAo+Pj4gKy8vIFVzZSBFUlJQX0FVVE9fUFJPUEFHQVRFIChzZWUgaW5j bHVkZS9xYXBpL2Vycm9yLmgpCj4+PiArLy8KPj4+ICsvLyBDb3B5cmlnaHQgKGMpIDIwMjAgVmly dHVvenpvIEludGVybmF0aW9uYWwgR21iSC4KPj4+ICsvLwo+Pj4gKy8vIFRoaXMgcHJvZ3JhbSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4+ PiArLy8gaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBhcyBwdWJsaXNoZWQgYnkKPj4+ICsvLyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBl aXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgo+Pj4gKy8vIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCj4+PiArLy8KPj4+ICsvLyBUaGlzIHByb2dyYW0gaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKPj4+ICsvLyBidXQg V0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv Zgo+Pj4gKy8vIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUKPj4+ICsvLyBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgo+Pj4gKy8vCj4+PiArLy8gWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKPj4+ICsvLyBhbG9uZyB3aXRoIHRo aXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4K Pj4+ICsvLwo+Pj4gKy8vIFVzYWdlIGV4YW1wbGU6Cj4+PiArLy8gc3BhdGNoIC0tc3AtZmlsZSBz Y3JpcHRzL2NvY2NpbmVsbGUvYXV0by1wcm9wYWdhdGVkLWVycnAuY29jY2kgXAo+Pj4gKy8vICAt LW1hY3JvLWZpbGUgc2NyaXB0cy9jb2NjaS1tYWNyby1maWxlLmggLS1pbi1wbGFjZSAtLW5vLXNo b3ctZGlmZiBcCj4+PiArLy8gIC0tbWF4LXdpZHRoIDgwIGJsb2NrZGV2LW5iZC5jIHFlbXUtbmJk LmMgXAo+Pgo+PiBZb3UgaGF2ZSAtLW1heC13aWR0aCA4MCBoZXJlLCBidXQgbm90IGluIHRoZSBj b21taXQgbWVzc2FnZS4gIERlZmF1bHQKPj4gc2VlbXMgdG8gYmUgNzguICBBbnkgcGFydGljdWxh ciByZWFzb24gdG8gY2hhbmdlIGl0IHRvIDgwPwo+Cj4gSG1tLiBBcyBJIHJlbWVtYmVyLCB3aXRo b3V0IHRoaXMgcGFyYW1ldGVyLCByZWluZGVudGluZyBkb2Vzbid0IHdvcmsgY29ycmVjdGx5Lgo+ IFNvLCBJJ20gT0sgd2l0aCAiLS1tYXgtd2lkdGggNzgiLCBidXQgSSBkb3VidCB0aGF0IGl0IHdp bGwgd29yayB3aXRob3V0IGEgcGFyYW1ldGVyLgo+IFN0aWxsLCBtYXkgYmUgSSdtIHdyb25nLCB3 ZSBjYW4gY2hlY2sgaXQuCgpJZiB5b3UgY2FuIHBvaW50IHRvIGFuIGV4YW1wbGUgd2hlcmUgLS1t YXgtd2lkdGggaGVscHMsIGtlZXAgaXQsIGFuZAp1cGRhdGUgdGhlIGNvbW1pdCBtZXNzYWdlIHRv IG1hdGNoLiAgRWxzZSwgZHJvcCBpdC4KCj4+Cj4+PiArLy8gIHtibG9jay9uYmQqLG5iZC8qLGlu Y2x1ZGUvYmxvY2svbmJkKn0uW2hjXQo+Pj4gKwo+Pj4gKy8vIFN3aXRjaCB1bnVzdWFsIChFcnJv ciAqKikgcGFyYW1ldGVyIG5hbWVzIHRvIGVycnAKPj4KPj4gTGV0J3MgZHJvcCB0aGUgcGFyZW50 aGVzaXMgYXJvdW5kIEVycm9yICoqCj4+Cj4+PiArLy8gKHRoaXMgaXMgbmVjZXNzYXJ5IHRvIHVz ZSBFUlJQX0FVVE9fUFJPUEFHQVRFKS4KPj4KPj4gUGVyaGFwcyBFUlJQX0FVVE9fUFJPUEFHQVRF KCkgc2hvdWxkIGJlIEVSUlBfQVVUT19QUk9QQUdBVEUoZXJycCkgdG8KPj4gbWFrZSB0aGUgZmFj dCB3ZSdyZSBtZXNzaW5nIHdpdGggQGVycnAgbW9yZSBvYnZpb3VzLiAgVG9vIGxhdGU7IEkKPj4g c2hvdWxkbid0IHJvY2sgdGhlIGJvYXQgdGhhdCBtdWNoIG5vdy4KPj4KPj4+ICsvLwo+Pj4gKy8v IERpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIHRvIHNraXAgZnVuY3Rpb25zIHdpdGggIkVycm9y ICpjb25zdCAqZXJycCIKPj4+ICsvLyBwYXJhbWV0ZXIuCj4+PiArLy8KPj4+ICsvLyBTa2lwIGZ1 bmN0aW9ucyB3aXRoICJhc3NlcnQoX2VycnAgJiYgKl9lcnJwKSIgc3RhdGVtZW50LCBhcyB0aGV5 IGhhdmUKPj4+ICsvLyBub24gZ2VuZXJpYyBzZW1hbnRpY3MgYW5kIG1heSBoYXZlIHVudXN1YWwg RXJyb3IgKiogYXJndW1lbnQgbmFtZSBmb3IgcHVycG9zZQo+Pgo+PiBub24tZ2VuZXJpYwo+Pgo+ PiBmb3IgYSBwdXJwb3NlCj4+Cj4+IFdyYXAgY29tbWVudCBsaW5lcyBhcm91bmQgY29sdW1uIDcw LCBwbGVhc2UuICBJdCdzIGVhc2llciB0byByZWFkLgo+Pgo+PiBNYXliZQo+Pgo+PiAgICAgLy8g U2tpcCBmdW5jdGlvbnMgd2l0aCAiYXNzZXJ0KF9lcnJwICYmICpfZXJycCkiIHN0YXRlbWVudCwg YmVjYXVzZSB0aGF0Cj4+ICAgICAvLyBzaWduYWxzIHVudXN1YWwgc2VtYW50aWNzLCBhbmQgdGhl IHBhcmFtZXRlciBuYW1lIG1heSB3ZWxsIHNlcnZlIGEKPj4gICAgIC8vIHB1cnBvc2UuCj4KPiBT b3VuZHMgZ29vZC4KPgo+Pgo+Pj4gKy8vIChsaWtlIG5iZF9pdGVyX2NoYW5uZWxfZXJyb3IoKSku Cj4+PiArLy8KPj4+ICsvLyBTa2lwIHV0aWwvZXJyb3IuYyB0byBub3QgdG91Y2gsIGZvciBleGFt cGxlLCBlcnJvcl9wcm9wYWdhdGUgYW5kCj4+PiArLy8gZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQo KS4KPj4KPj4gZXJyb3JfcHJvcGFnYXRlKCkKPj4KPj4gSSBtdWNoIGFwcHJlY2lhdGUgeW91ciBt ZXRpY3Vsb3VzIGV4cGxhbmF0aW9uIG9mIHdoYXQgeW91IHNraXAgYW5kIHdoeS4KPj4KPj4+ICtA IGRlcGVuZHMgb24gIShmaWxlIGluICJ1dGlsL2Vycm9yLmMiKSBkaXNhYmxlIG9wdGlvbmFsX3F1 YWxpZmllckAKPj4+ICtpZGVudGlmaWVyIGZuOwo+Pj4gK2lkZW50aWZpZXIgX2VycnAgIT0gZXJy cDsKPj4+ICtAQAo+Pj4gKwo+Pj4gKyBmbiguLi4sCj4+PiArLSAgIEVycm9yICoqX2VycnAKPj4+ ICsrICAgRXJyb3IgKiplcnJwCj4+PiArICAgICwuLi4pCj4+PiArIHsKPj4+ICsoCj4+PiArICAg ICAuLi4gd2hlbiAhPSBhc3NlcnQoX2VycnAgJiYgKl9lcnJwKQo+Pj4gKyYKPj4+ICsgICAgIDwu Li4KPj4+ICstICAgIF9lcnJwCj4+PiArKyAgICBlcnJwCj4+PiArICAgICAuLi4+Cj4+PiArKQo+ Pj4gKyB9Cj4+Cj4+IFRoaXMgcnVsZSBpcyByZXF1aXJlZCB0byBtYWtlIHRoZSBhY3R1YWwgdHJh bnNmb3JtYXRpb25zIChiZWxvdykgd29yawo+PiBldmVuIGZvciBwYXJhbWV0ZXJzIHdpdGggbmFt ZXMgb3RoZXIgdGhhbiBAZXJycC4gIEkgYmVsaWV2ZSBpdCdzIG5vdAo+PiB1c2VkIGluIHRoaXMg c2VyaWVzLiAgSW4gZmFjdCwgSSBjYW4ndCBzZWUgYSB1c2UgZm9yIGl0IGluIHRoZSBlbnRpcmUK Pj4gdHJlZSByaWdodCBub3cuICBPa2F5IGFueXdheS4KPj4KPj4+ICsKPj4+ICsvLyBBZGQgaW52 b2NhdGlvbiBvZiBFUlJQX0FVVE9fUFJPUEFHQVRFIHRvIGVycnAtZnVuY3Rpb25zIHdoZXJlIG5l Y2Vzc2FyeQo+Pj4gKy8vCj4+PiArLy8gTm90ZSwgdGhhdCB3aXRob3V0ICJ3aGVuIGFueSIgZmlu YWwgIi4uLiIgbWF5IG5vdCB3YW50IHRvIG1hY2ggc29tZXRoaW5nCj4+Cj4+IHMvZmluYWwgIi4u LiIgbWF5IG5vdCBtYWNoL3RoZSBmaW5hbCAiLi4uIiBkb2VzIG5vdCBtYXRjaC8KPj4KPj4+ICsv LyBtYXRjaGVkIGJ5IHByZXZpb3VzIHBhdHRlcm4sIGkuZS4gdGhlIHJ1bGUgd2lsbCBub3QgbWF0 Y2ggZG91YmxlCj4+PiArLy8gZXJyb3JfcHJlcGVuZCBpbiBjb250cm9sIGZsb3cgbGlrZSBpbiB2 ZmlvX3NldF9pcnFfc2lnbmFsaW5nKCkuCj4+Cj4+IENhbid0IHNheSBJIGZ1bGx5IHVuZGVyc3Rh bmQgQ29jY2luZWxsZSB0aGVyZS4gIEkgZmlndXJlIHlvdSBjYW1lIHRvCj4+IHRoaXMga25vd2xl ZGdlIHRoZSBoYXJkIHdheS4KPgo+IEl0J3MgZm9sbG93cyBmcm9tIHNtcGwgZ3JhbW1hciBkb2N1 bWVudDoKPgo+ICJJbXBsaWNpdGx5LCDigJwuLi7igJ0gbWF0Y2hlcyB0aGUgc2hvcnRlc3QgcGF0 aCBiZXR3ZWVuIHNvbWV0aGluZyB0aGF0IG1hdGNoZXMgdGhlIHBhdHRlcm4gYmVmb3JlIHRoZSBk b3RzIChvciB0aGUgYmVnaW5uaW5nIG9mIHRoZSBmdW5jdGlvbiwgaWYgdGhlcmUgaXMgbm90aGlu ZyBiZWZvcmUgdGhlIGRvdHMpIGFuZCBzb21ldGhpbmcgdGhhdCBtYXRjaGVzIHRoZSBwYXR0ZXJu IGFmdGVyIHRoZSBkb3RzIChvciB0aGUgZW5kIG9mIHRoZSBmdW5jdGlvbiwgaWYgdGhlcmUgaXMg bm90aGluZyBhZnRlciB0aGUgZG90cykuIgo+IC4uLgo+ICJfd2hlbiBhbnlfIHJlbW92ZXMgdGhl IGFmb3JlbWVudGlvbmVkIGNvbnN0cmFpbnQgdGhhdCDigJwuLi7igJ0gbWF0Y2hlcyB0aGUgc2hv cnRlc3QgcGF0aCIKCkxldCBtZSB0aGluayB0aGF0IHRocm91Z2guCgpUaGUgcGF0dGVybiB3aXRo IHRoZSBjYXNlcyBvdGhlciB0aGFuIGVycm9yX3ByZXBlbmQoKSBvbWl0dGVkOgoKICAgICBmbigu Li4sIEVycm9yICoqZXJycCwgLi4uKQogICAgIHsKICAgICsgICBFUlJQX0FVVE9fUFJPUEFHQVRF KCk7CiAgICAgICAgLi4uICB3aGVuICE9IEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICAgICBl cnJvcl9wcmVwZW5kKGVycnAsIC4uLik7CiAgICAgICAgLi4uIHdoZW4gYW55CiAgICAgfQoKVGFp bCBvZiB2ZmlvX3NldF9pcnFfc2lnbmFsaW5nKCk6CgogICAgICAgIG5hbWUgPSBpbmRleF90b19z dHIodmJhc2VkZXYsIGluZGV4KTsKICAgICAgICBpZiAobmFtZSkgewogICAgICAgICAgICBlcnJv cl9wcmVwZW5kKGVycnAsICIlcy0lZDogIiwgbmFtZSwgc3ViaW5kZXgpOwogICAgICAgIH0gZWxz ZSB7CiAgICAgICAgICAgIGVycm9yX3ByZXBlbmQoZXJycCwgImluZGV4ICVkLSVkOiAiLCBpbmRl eCwgc3ViaW5kZXgpOwogICAgICAgIH0KICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsCiAgICAg ICAgICAgICAgICAgICAgICAiRmFpbGVkIHRvICVzICVzIGV2ZW50ZmQgc2lnbmFsaW5nIGZvciBp bnRlcnJ1cHQgIiwKICAgICAgICAgICAgICAgICAgICAgIGZkIDwgMCA/ICJ0ZWFyIGRvd24iIDog InNldCB1cCIsIGFjdGlvbl90b19zdHIoYWN0aW9uKSk7CiAgICAgICAgcmV0dXJuIHJldDsKICAg IH0KClRoZSBwYXR0ZXJuJ3MgZmlyc3QgLi4uIG1hdGNoZXMgYSAic2hvcnRlc3QiIHBhdGggdG8g YW4gZXJyb3JfcHJlcGVuZCgpLAp3aGVyZSAic2hvcnRlc3QiIG1lYW5zICJkb2VzIG5vdCBjcm9z cyBhbiBlcnJvcl9wcmVwZW5kKCkuICBJdHMgd2hlbgpjbGF1c2UgbWFrZXMgdXMgaWdub3JlIGZ1 bmN0aW9ucyB0aGF0IGFscmVhZHkgdXNlIEVSUlBfQVVUT19QUk9QQUdBVEUoKS4KClRoZXJlIGFy ZSB0d28gc3VjaCAic2hvcnRlc3QiIHBhdGhzLCBvbmUgdG8gdGhlIGZpcnN0IGVycm9yX3ByZXBl bmQoKSBpbgp2ZmlvX3NldF9pcnFfc2lnbmFsaW5nKCksIGFuZCBvbmUgdG8gdGhlIHNlY29uZC4g IE5laXRoZXIgcGF0aCB0byB0aGUKdGhpcmQgb25lIGlzIG5vdCAic2hvcnRlc3QiOiB0aGV5IGJv dGggY3Jvc3Mgb25lIG9mIHRoZSBvdGhlciB0d28KZXJyb3JfcHJlcGVuZCgpLgoKVGhlIHBhdHRl cm4nIHMgc2Vjb25kIC4uLiBtYXRjaGVzIGEgcGF0aCBmcm9tIGEgbWF0Y2hlZCBlcnJvcl9wcmVw ZW5kKCkKdG8gdGhlIGVuZCBvZiB0aGUgZnVuY3Rpb24uICBUaGVyZSBhcmUgdHdvIHBhdGhzLiAg Qm90aCBjcm9zcyB0aGUgdGhpcmQKZXJyb3JfcHJlcGVuZCgpLiAgWW91IG5lZWQgIndoZW4gYW55 IiB0byBtYWtlIHRoZSBwYXR0ZXJuIG1hdGNoIGFueXdheS4KCkFscmlnaHQsIEkgdGhpbmsgSSBn b3QgaXQuICBCdXQgbm93IEknbSBwYXJhbm9pZCBhYm91dCAuLi4gZWxzZXdoZXJlLgpGb3IgaW5z dGFuY2UsIGhlcmUncyBydWxlMSB3aXRoIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKCkgb21pdHRl ZDoKCiAgICAvLyBNYXRjaCBzY2VuYXJpb3Mgd2l0aCBwcm9wYWdhdGlvbiBvZiBsb2NhbCBlcnJv ciB0byBlcnJwLgogICAgQHJ1bGUxIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIGV4aXN0c0AK ICAgIGlkZW50aWZpZXIgZm4sIGxvY2FsX2VycjsKICAgIHN5bWJvbCBlcnJwOwogICAgQEAKCiAg ICAgZm4oLi4uLCBFcnJvciAqKmVycnAsIC4uLikKICAgICB7CiAgICAgICAgIC4uLgogICAgICAg ICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICAgICAgLi4uCiAgICAgICAgIGVycm9yX3By b3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwogICAgICAgICAuLi4KICAgICB9CgpUaGUgc2Vjb25k IGFuZCB0aGlyZCAuLi4gd29uJ3QgbWF0Y2ggYW55dGhpbmcgY29udGFpbmluZwplcnJvcl9wcm9w YWdhdGUoKS4gIFdoYXQgaWYgYSBmdW5jdGlvbiBoYXMgbXVsdGlwbGUgZXJyb3JfcHJvcGFnYXRl KCkgb24KYWxsIHBhdGhzPyAgTGlrZSB0aGlzIG9uZToKCiAgICBleHRlcm4gZm9vKGludCwgRXJy b3IgKiopOwogICAgZXh0ZXJuIGJhcihpbnQsIEVycm9yICoqKTsKCiAgICB2b2lkIGZyb2IoRXJy b3IgKiplcnJwKQogICAgewogICAgICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwogICAgICAg IGludCBhcmc7CgogICAgICAgIGZvbyhhcmcsIGVycnApOwogICAgICAgIGJhcihhcmcsICZsb2Nh bF9lcnIpOwogICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwogICAgICAg IGJhcihhcmcgKyAxLCAmbG9jYWxfZXJyKTsKICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwg bG9jYWxfZXJyKTsKICAgIH0KClRoaXMgaXMgYWN0dWFsbHkgYSB2YXJpYXRpb24gb2YgZXJyb3Iu aCdzICJSZWNlaXZlIGFuZCBhY2N1bXVsYXRlCm11bHRpcGxlIGVycm9ycyAoZmlyc3Qgb25lIHdp bnMpIiBjb2RlIHNuaXBwZXQuCgpUaGUgQ29jY2luZWxsZSBzY3JpcHQgdHJhbnNmb3JtcyBpdCBs aWtlIHRoaXM6CgogICAgIHZvaWQgZnJvYihFcnJvciAqKmVycnApCiAgICAgewogICAgKyAgICBF UlJQX0FVVE9fUFJPUEFHQVRFKCk7CiAgICAgICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwog ICAgICAgICBpbnQgYXJnOwoKVGhlIHJ1bGUgdGhhdCBhZGRzIEVSUlBfQVVUT19QUk9QQUdBVEUo KSBtYXRjaGVzIChpdCBoYXMgLi4uIHdoZW4gYW55KSwKYnV0IHJ1bGUxIGRvZXMgbm90LCBhbmQg d2UgdGhlcmVmb3JlIGRvbid0IGNvbnZlcnQgYW55IG9mIHRoZQplcnJvcl9wcm9wYWdhdGUoKS4K ClRoZSByZXN1bHQgaXNuJ3Qgd3JvbmcsIGp1c3QgdXNlbGVzcy4KCklzIHRoaXMgdGhlIHdvcnN0 IGNhc2U/CgpQb3NzaWJsZSBpbXByb3ZlbWVudCB0byB0aGUgRVJSUF9BVVRPX1BST1BBR0FURSgp IHJ1bGU6IGRvbid0IHVzZQoiLi4uIHdoZW4gYW55IiBpbiB0aGUgZXJyb3JfcHJvcGFnYXRlKCkg Y2FzZSwgb25seSBpbiB0aGUgb3RoZXIgY2FzZXMuCldvdWxkIHRoYXQgaGVscD8KCkkgdGhpbmsg dGhpcyBpcyB0aGUgb25seSBvdGhlciBydWxlIHdpdGggIi4uLiIgbWF0Y2hpbmcgY29udHJvbCBm bG93LgoKPj4KPj4+ICsvLwo+Pj4gKy8vIE5vdGUsICJleGlzdHMiIHNheXMgdGhhdCB3ZSB3YW50 IGFwcGx5IHJ1bGUgZXZlbiBpZiBpdCBtYXRjaGVzIG5vdCBvbgo+Pj4gKy8vIGFsbCBwb3NzaWJs ZSBjb250cm9sIGZsb3dzIChvdGhlcndpc2UsIGl0IHdpbGwgbm90IG1hdGNoIHN0YW5kYXJkIHBh dHRlcm4KPj4+ICsvLyB3aGVuIGVycm9yX3Byb3BhZ2F0ZSgpIGNhbGwgaXMgaW4gaWYgYnJhbmNo KS4KPj4KPj4gTGVhcm5lZCBzb21ldGhpbmcgbmV3LiAgRXhhbXBsZToga3ZtX3NldF9rdm1fc2hh ZG93X21lbSgpLgo+Pgo+PiBTcGVsbGluZyBpdCAiZXhpc3RzIGRpc2FibGUgb3B0aW9uYWxfcXVh bGlmaWVyIiB3b3VsZCBhdm9pZCBnaXZpbmcKPj4gcmVhZGVycyB0aGUgaWRlYSB3ZSdyZSBkaXNh YmxpbmcgImV4aXN0cyIsIGJ1dCBDb2NjaW5lbGxlIGRvZXNuJ3QgbGV0Cj4+IHVzLiAgT2ggd2Vs bC4KPj4KPj4+ICtAIGRpc2FibGUgb3B0aW9uYWxfcXVhbGlmaWVyIGV4aXN0c0AKPj4+ICtpZGVu dGlmaWVyIGZuLCBsb2NhbF9lcnIsIGVycnA7Cj4+Cj4+IEkgYmVsaWV2ZSB0aGlzIGNhdXNlcwo+ Pgo+PiAgICAgIHdhcm5pbmc6IGxpbmUgOTg6IGVycnAsIHByZXZpb3VzbHkgZGVjbGFyZWQgYXMg YSBtZXRhdmFyaWFibGUsIGlzIHVzZWQgYXMgYW4gaWRlbnRpZmllcgo+PiAgICAgIHdhcm5pbmc6 IGxpbmUgMTA0OiBlcnJwLCBwcmV2aW91c2x5IGRlY2xhcmVkIGFzIGEgbWV0YXZhcmlhYmxlLCBp cyB1c2VkIGFzIGFuIGlkZW50aWZpZXIKPj4gICAgICB3YXJuaW5nOiBsaW5lIDEwNjogZXJycCwg cHJldmlvdXNseSBkZWNsYXJlZCBhcyBhIG1ldGF2YXJpYWJsZSwgaXMgdXNlZCBhcyBhbiBpZGVu dGlmaWVyCj4+ICAgICAgd2FybmluZzogbGluZSAxMzE6IGVycnAsIHByZXZpb3VzbHkgZGVjbGFy ZWQgYXMgYSBtZXRhdmFyaWFibGUsIGlzIHVzZWQgYXMgYW4gaWRlbnRpZmllcgo+PiAgICAgIHdh cm5pbmc6IGxpbmUgMTkyOiBlcnJwLCBwcmV2aW91c2x5IGRlY2xhcmVkIGFzIGEgbWV0YXZhcmlh YmxlLCBpcyB1c2VkIGFzIGFuIGlkZW50aWZpZXIKPj4gICAgICB3YXJuaW5nOiBsaW5lIDE5NTog ZXJycCwgcHJldmlvdXNseSBkZWNsYXJlZCBhcyBhIG1ldGF2YXJpYWJsZSwgaXMgdXNlZCBhcyBh biBpZGVudGlmaWVyCj4+ICAgICAgd2FybmluZzogbGluZSAyMjg6IGVycnAsIHByZXZpb3VzbHkg ZGVjbGFyZWQgYXMgYSBtZXRhdmFyaWFibGUsIGlzIHVzZWQgYXMgYW4gaWRlbnRpZmllcgo+Pgo+ PiBNYWtpbmcgQGVycnAgc3ltYm9sIGluc3RlYWQgb2YgaWRlbnRpZmllciBzaG91bGQgZml4IHRo aXMuCj4KPiBIbW0sIEkgZGlkbid0IHNlZSB0aGVzZSB3YXJuaW5ncy4uIEJ1dCB5ZXMsIGl0IHNo b3VsZCBiZSBzeW1ib2wuCj4KPj4KPj4+ICtAQAo+Pj4gKwo+Pj4gKyBmbiguLi4sIEVycm9yICoq ZXJycCwgLi4uKQo+Pj4gKyB7Cj4+PiArKyAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKPj4+ICsg ICAgLi4uICB3aGVuICE9IEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKPj4+ICsoCj4+PiArICAgIGVy cm9yX2FwcGVuZF9oaW50KGVycnAsIC4uLik7Cj4+PiArfAo+Pj4gKyAgICBlcnJvcl9wcmVwZW5k KGVycnAsIC4uLik7Cj4+PiArfAo+Pj4gKyAgICBlcnJvcl92cHJlcGVuZChlcnJwLCAuLi4pOwo+ Pj4gK3wKPj4+ICsgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7Cj4+PiArICAgIC4uLgo+Pj4g KygKPj4+ICsgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLCAuLi4p Owo+Pj4gK3wKPj4+ICsgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Cj4+PiAr KQo+Pj4gKykKPj4+ICsgICAgLi4uIHdoZW4gYW55Cj4+PiArIH0KPj4+ICsKPj4+ICsKPj4+ICsv LyBNYXRjaCBzY2VuYXJpb3Mgd2l0aCBwcm9wYWdhdGlvbiBvZiBsb2NhbCBlcnJvciB0byBlcnJw Lgo+Pj4gK0BydWxlMSBkaXNhYmxlIG9wdGlvbmFsX3F1YWxpZmllciBleGlzdHNACj4+PiAraWRl bnRpZmllciBmbiwgbG9jYWxfZXJyOwo+Pj4gK3N5bWJvbCBlcnJwOwo+Pj4gK0BACj4+PiArCj4+ PiArIGZuKC4uLiwgRXJyb3IgKiplcnJwLCAuLi4pCj4+PiArIHsKPj4+ICsgICAgIC4uLgo+Pj4g KyAgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7Cj4+PiArICAgICAuLi4KPj4+ICsoCj4+PiAr ICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgLi4uKTsKPj4+ICt8 Cj4+PiArICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwo+Pj4gKykKPj4KPj4g SW5kZW50YXRpb24gb2ZmIGJ5IG9uZS4KPj4KPj4+ICsgICAgIC4uLgo+Pj4gKyB9Cj4+PiArCj4+ PiArLy8gQ29udmVydCBzcGVjaWFsIGNhc2Ugd2l0aCBnb3RvIGluIHNlcGFyYXRlLgo+Pgo+PiBz L2luIHNlcGFyYXRlL3NlcGFyYXRlbHkvCj4+Cj4+PiArLy8gV2UgY2FuIHByb2JhYmx5IG1lcmdl IHRoaXMgaW50byB0aGUgZm9sbG93aW5nIGh1bmsgd2l0aCBoZWxwIG9mICggfCApCj4+PiArLy8g b3BlcmF0b3IsIGJ1dCBpdCBzaWduaWZpY2FudGx5IHJlZHVjZSBwZXJmb3JtYW5jZSBvbiBibG9j ay5jIHBhcnNpbmcgKG9yIGl0Cj4+Cj4+IHMvcmVkdWNlL3JlZHVjZXMvCj4+Cj4+PiArLy8gaGFu Z3MsIEkgZG9uJ3Qga25vdykKPj4KPj4gU291bmRzIGxpa2UgeW91IHRyaWVkIHRvIG1lcmdlIHRo aXMgaW50byB0aGUgZm9sbG93aW5nIGh1bmssIGJ1dCB0aGVuCj4+IHNwYXRjaCB0b29rIHNvIGxv bmcgb24gYmxvY2suYyB0aGF0IHlvdSBraWxsZWQgaXQuICBDb3JyZWN0Pwo+Cj4gWWVzLgoKSSdk IHNheSBzb21ldGhpbmcgbGlrZSAiSSB0cmllZCBtZXJnaW5nIHRoaXMgaW50byB0aGUgZm9sbG93 aW5nIHJ1bGUgdGhlCm9idmlvdXMgd2F5LCBidXQgaXQgbWFkZSBDb2NjaW5lbGxlIGhhbmcgb24g YmxvY2suYy4iCgo+Pgo+Pj4gKy8vCj4+PiArLy8gTm90ZSBpbnRlcmVzdGluZyB0aGluZzogaWYg d2UgZG9uJ3QgZG8gaXQgaGVyZSwgYW5kIHRyeSB0byBmaXh1cCAib3V0OiB9Igo+Pj4gKy8vIHRo aW5ncyBsYXRlciBhZnRlciBhbGwgdHJhbnNmb3JtYXRpb25zICh0aGUgcnVsZSB3aWxsIGJlIHRo ZSBzYW1lLCBqdXN0Cj4+PiArLy8gd2l0aG91dCBlcnJvcl9wcm9wYWdhdGUoKSBjYWxsKSwgY29j Y2luZWxsZSBmYWlscyB0byBtYXRjaCB0aGlzICJvdXQ6IH0iLgo+Pgo+PiBXZWlyZCwgYnV0IG5v dCB3b3J0aCBmdXJ0aGVyIGludmVzdGlnYXRpb24uCj4KPiBJdCBwYXJ0aWFsbHkgbWF0Y2ggdG8g dGhlIGlkZWEgd2hpY2ggSSBzYXcgc29tZXdoZXJlIGluIGNvY2NpbmVsbGUgZG9jdW1lbnRhdGlv biwKPiB0aGF0IGNvY2NpbmVsbGUgY29udmVydHMgY29ycmVjdCBDIGNvZGUgdG8gY29ycmVjdCBD IGNvZGUuICJvdXQ6IH0iIGlzIGFuIGV4YW1wbGUKPiBvZiBpbmNvcnJlY3QsIGltcG9zc2libGUg Y29kZSBmbG93LCBhbmQgY29jY2luZWxsZSBjYW4ndCB3b3JrIHdpdGggaXQuLi4gQnV0IGl0J3MK PiBqdXN0IGEgdGhvdWdodC4KPgo+Pgo+Pj4gK0BACj4+PiAraWRlbnRpZmllciBydWxlMS5mbiwg cnVsZTEubG9jYWxfZXJyLCBvdXQ7Cj4+PiArc3ltYm9sIGVycnA7Cj4+PiArQEAKPj4+ICsKPj4+ ICsgZm4oLi4uKQo+Pj4gKyB7Cj4+PiArICAgICA8Li4uCj4+PiArLSAgICBnb3RvIG91dDsKPj4+ ICsrICAgIHJldHVybjsKPj4+ICsgICAgIC4uLj4KPj4+ICstIG91dDoKPj4+ICstICAgIGVycm9y X3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwo+Pgo+PiBZb3UgbmVnbGVjdCB0byBtYXRjaCBl cnJvcl9wcm9wYWdhdGVfcHJlcGVuZCgpLiAgT2theSwgYmVjYXVzZSAoMSkgdGhhdAo+PiBwYXR0 ZXJuIGRvZXNuJ3Qgb2NjdXIgaW4gdGhlIHRyZWUgcmlnaHQgbm93LCBhbmQgKDIpIGlmIGl0IGdl dHMgYWRkZWQsCj4+IGdjYyB3aWxsIGNvbXBsYWluLgo+Cj4gTm8sIGJlY2F1c2UgaXQgc2hvdWxk IG5vdCByZW1vdmVkLiBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZCBzaG91bGQgYmUgY29udmVydGVk Cj4gdG8gcHJlcGVuZCwgbm90IHJlbW92ZWQuIFNvLCBjb3JyZXNwb25kaW5nIGdvdG9zIHNob3Vs ZCBub3QgYmUgcmVtb3ZlZCBhcyB3ZWxsLgoKWW91J3JlIHJpZ2h0LgoKPj4KPj4+ICsgfQo+Pj4g Kwo+Pj4gKy8vIENvbnZlcnQgbW9zdCBvZiBsb2NhbF9lcnIgcmVsYXRlZCBzdGFmZi4KPj4KPj4g cy9zdGFmZi9zdHVmZi8KPj4KPj4+ICsvLwo+Pj4gKy8vIE5vdGUsIHRoYXQgd2UgdXBkYXRlIGV2 ZXJ5dGhpbmcgcmVsYXRlZCB0byBtYXRjaGVkIGJ5IHJ1bGUxIGZ1bmN0aW9uIG5hbWUKPj4+ICsv LyBhbmQgbG9jYWxfZXJyIG5hbWUuIFdlIG1heSBtYXRjaCBzb21ldGhpbmcgbm90IHJlbGF0ZWQg dG8gdGhlIHBhdHRlcm4KPj4+ICsvLyBtYXRjaGVkIGJ5IHJ1bGUxLiBGb3IgZXhhbXBsZSwgbG9j YWxfZXJyIG1heSBiZSBkZWZpbmVkIHdpdGggdGhlIHNhbWUgbmFtZQo+Pj4gKy8vIGluIGRpZmZl cmVudCBibG9ja3MgaW5zaWRlIG9uZSBmdW5jdGlvbiwgYW5kIGluIG9uZSBibG9jayBmb2xsb3cg dGhlCj4+PiArLy8gcHJvcGFnYXRpb24gcGF0dGVybiBhbmQgaW4gb3RoZXIgYmxvY2sgZG9lc24n dC4gT3Igd2UgbWF5IGhhdmUgc2V2ZXJhbAo+Pj4gKy8vIGZ1bmN0aW9ucyB3aXRoIHRoZSBzYW1l IG5hbWUgKGZvciBkaWZmZXJlbnQgY29uZmlndXJhdGlvbnMpLgo+Pgo+PiBDb250ZXh0OiBydWxl MSBtYXRjaGVzIGZ1bmN0aW9ucyB0aGF0IGhhdmUgYWxsIHRocmVlIG9mCj4+Cj4+ICogYW4gRXJy b3IgKiplcnJwIHBhcmFtZXRlcgo+Pgo+PiAqIGFuIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMIHZh cmlhYmxlIGRlY2xhcmF0aW9uCj4+Cj4+ICogYW4gZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2Fs X2Vycikgb3IgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwKPj4gICAgbG9jYWxfZXJyLCAu Li4pIGV4cHJlc3Npb24sIHdoZXJlIEBlcnJwIGlzIHRoZSBwYXJhbWV0ZXIgYW5kCj4+ICAgIEBs b2NhbF9lcnIgaXMgdGhlIHZhcmlhYmxlLgo+Pgo+PiBJZiBJIHVuZGVyc3RhbmQgeW91IGNvcnJl Y3RseSwgeW91J3JlIHBvaW50aW5nIG91dCB0d28gcG90ZW50aWFsIGlzc3VlczoKPj4KPj4gMS4g VGhpcyBydWxlIGNhbiBtYXRjaCBmdW5jdGlvbnMgcnVsZTEgZG9lcyBub3QgbWF0Y2ggaWYgdGhl cmUgaXMKPj4gYW5vdGhlciBmdW5jdGlvbiB3aXRoIHRoZSBzYW1lIG5hbWUgdGhhdCBydWxlMSBk b2VzIG1hdGNoLgo+Pgo+PiAyLiBUaGlzIHJ1bGUgbWF0Y2hlcyBpbiB0aGUgZW50aXJlIGZ1bmN0 aW9uIG1hdGNoZWQgYnkgcnVsZTEsIGV2ZW4gd2hlbgo+PiBwYXJ0cyBvZiB0aGF0IGZ1bmN0aW9u IHVzZSBhIGRpZmZlcmVudCBAZXJycCBvciBAbG9jYWxfZXJyLgo+Pgo+PiBJIGZpZ3VyZSB0aGVz ZSBhcHBseSB0byBhbGwgcnVsZXMgd2l0aCBpZGVudGlmaWVyIHJ1bGUxLmZuLCBub3QganVzdAo+ PiB0aGlzIG9uZS4gIENvcnJlY3Q/Cj4KPiBZZXMuCgpUaGFua3MhCgo+Pgo+PiBSZWdhcmRpbmcg MS4gIFRoZXJlIG11c3QgYmUgYSBiZXR0ZXIgd2F5IHRvIGNoYWluIHJ1bGVzIHRvZ2V0aGVyLCBi dXQgSQo+PiBkb24ndCBrbm93IGl0Lgo+PiAgQ2FuIHdlIG1ha2UgQ29jY2luZWxsZSBhdCBsZWFz dCB3YXJuIHVzIHdoZW4gaXQgY29udmVydHMKPj4gbXVsdGlwbGUgZnVuY3Rpb25zIHdpdGggdGhl IHNhbWUgbmFtZT8gIFdoYXQgYWJvdXQgdGhpczoKPj4KPj4gICAgIEBpbml0aWFsaXplOnB5dGhv bkAKPj4gICAgIEBACj4+ICAgICBmbnByZXYgPSB7fQo+Pgo+PiAgICAgZGVmIHByKGZuLCBwKToK Pj4gICAgICAgICBwcmludCgiIyMjICVzOiVzOiAlcygpIiAlIChwWzBdLmZpbGUsIHBbMF0ubGlu ZSwgZm4pKQo+Pgo+PiAgICAgQHJACj4+ICAgICBpZGVudGlmaWVyIHJ1bGUxLmZuOwo+PiAgICAg cG9zaXRpb24gcDsKPj4gICAgIEBACj4+ICAgICAgZm4oLi4uKUBwCj4+ICAgICAgewo+PiAgICAg ICAgICAuLi4KPj4gICAgICB9Cj4+ICAgICBAc2NyaXB0OnB5dGhvbkAKPj4gICAgICAgICBmbiA8 PCBydWxlMS5mbjsKPj4gICAgICAgICBwIDw8IHIucDsKPj4gICAgIEBACj4+ICAgICBpZiBmbiBu b3QgaW4gZm5wcmV2Ogo+PiAgICAgICAgIGZucHJldltmbl0gPSBwCj4+ICAgICBlbHNlOgo+PiAg ICAgICAgIGlmIGZucHJldltmbl06Cj4KPiBobW0sIHRoZSBjb25kaXRpb24gY2FuJ3QgYmUgZmFs c2UKPgo+PiAgICAgICAgICAgICBwcihmbiwgZm5wcmV2W2ZuXSkKPj4gICAgICAgICAgICAgZm5w cmV2W2ZuXSA9IE5vbmUKPj4gICAgICAgICBwcihmbiwgcCkKPgo+IGFuZCB3ZSdsbCBtaXNzIG5l eHQgZHVwbGljYXRpb24uLgoKVGhlIGlkZWEgaXMKCiAgICBmaXJzdCBpbnN0YW5jZSBvZiBmbjoK ICAgICAgICBmbiBub3QgaW4gZm5wcmV2CiAgICAgICAgZm5wcmV2W2ZuXSA9IHBvc2l0aW9uIG9m IGluc3RhbmNlCiAgICAgICAgZG9uJ3QgcHJpbnQKICAgIHNlY29uZCBpbnN0YW5jZToKICAgICAg ICBmbnByZXZbZm5dIGlzIHRoZSBwb3NpdGlvbiBvZiB0aGUgZmlyc3QgaW5zdGFuY2UKICAgICAg ICBwcmludCBmaXJzdCB0d28gaW5zdGFuY2VzCiAgICBzdWJzZXF1ZW50IGluc3RhbmNlczogZm5w cmV2W2ZuXSBpcyBOb25lCiAgICAgICAgcHJpbnQgdGhpcyBpbnN0YW5jZQoKSSBtaWdodCBoYXZl IHNjcmV3ZWQgdXAgdGhlIGNvZGluZywgb2YgY291cnNlIDopCgo+IEJ1dCBJIGxpa2UgdGhlIGlk ZWEuCj4KPj4KPj4gRm9yIGVhY2ggZnVuY3Rpb24gQGZuIG1hdGNoZWQgYnkgcnVsZTEsIGZuY250 W2ZuXSBpcyBhbiB1cHBlciBsaW1pdCBvZgo+PiB0aGUgbnVtYmVyIG9mIGZ1bmN0aW9ucyB3aXRo IHRoZSBzYW1lIG5hbWUgd2UgdG91Y2guICBJZiBpdCdzIG1vcmUgdGhhbgo+PiBvbmUsIHdlIHBy aW50Lgo+Pgo+PiBSZXBvcnRzIGFib3V0IGEgZG96ZW4gZnVuY3Rpb24gbmFtZXMgZm9yIHRoZSB3 aG9sZSB0cmVlIGluIG15IHRlc3RpbmcuCj4+IEluc3BlY3RpbmcgdGhlIGNoYW5nZXMgdG8gdGhl bSBtYW51YWxseSBpcyBmZWFzaWJsZS4gIE5vbmUgb2YgdGhlbSBhcmUKPj4gaW4gZmlsZXMgdG91 Y2hlZCBieSB0aGlzIHNlcmllcy4KPj4KPj4gVGhlIGxpbmUgcHJpbnRlZCBmb3IgdGhlIGZpcnN0 IG1hdGNoIGlzIHByZXR0eSB1c2VsZXNzIGZvciBtZTogaXQgcG9pbnRzCj4+IHRvIGEgQ29jY2lu ZWxsZSB0ZW1wb3JhcnkgZmlsZSAqc2hydWcqLgo+Pgo+PiBSZWdhcmRpbmcgMi4gIFNoYWRvd2lu ZyBAZXJycCBvciBAbG9jYWxfZXJyIHdvdWxkIGJlIGluIGJhZCB0YXN0ZSwgYW5kIEkKPj4gc3Vy ZSBob3BlIHdlIGRvbid0IGRvIHRoYXQuICBNdWx0aXBsZSBAbG9jYWxfZXJyIHZhcmlhYmxlcy4u LiBobW0uCj4+IFBlcmhhcHMgd2UgY291bGQgYWdhaW4gY29uY29jdCBzb21lIHNjcmlwdCBydWxl cyB0byBsZWFkIHVzIHRvIHNwb3RzIHRvCj4+IGNoZWNrIG1hbnVhbGx5LiAgU2VlIGJlbG93IGZv ciBteSBhdHRlbXB0Lgo+Pgo+PiBXaGF0J3MgdGhlIHdvcnN0IHRoYXQgY291bGQgaGFwcGVuIGlm IHdlIGJsaW5kbHkgY29udmVydGVkIHN1Y2ggY29kZT8KPj4gVGhlIGFuc3dlciB0byB0aGF0IHF1 ZXN0aW9uIHRlbGxzIHVzIGhvdyBoYXJkIHRvIHdvcmsgb24gZmluZGluZyBhbmQKPj4gY2hlY2tp bmcgdGhlc2UgZ3V5cy4KPj4KPj4+ICsvLwo+Pj4gKy8vIE5vdGUgYWxzbyB0aGF0IGVycnAtY2xl YW5pbmcgZnVuY3Rpb25zCj4+PiArLy8gICBlcnJvcl9mcmVlX2VycnAKPj4+ICsvLyAgIGVycm9y X3JlcG9ydF9lcnJwCj4+PiArLy8gICBlcnJvcl9yZXBvcnRmX2VycnAKPj4+ICsvLyAgIHdhcm5f cmVwb3J0X2VycnAKPj4+ICsvLyAgIHdhcm5fcmVwb3J0Zl9lcnJwCj4+PiArLy8gYXJlIG5vdCB5 ZXQgaW1wbGVtZW50ZWQuIFRoZXkgbXVzdCBjYWxsIGNvcnJlc3BvbmRpbmcgRXJyb3IqIC0gZnJl ZWluZwo+Pj4gKy8vIGZ1bmN0aW9uIGFuZCB0aGVuIHNldCAqZXJycCB0byBOVUxMLCB0byBhdm9p ZCBmdXJ0aGVyIHByb3BhZ2F0aW9uIHRvCj4+PiArLy8gb3JpZ2luYWwgZXJycCAoY29uc2lkZXIg RVJSUF9BVVRPX1BST1BBR0FURSBpbiB1c2UpLgo+Pj4gKy8vIEZvciBleGFtcGxlLCBlcnJvcl9m cmVlX2VycnAgbWF5IGxvb2sgbGlrZSB0aGlzOgo+Pj4gKy8vCj4+PiArLy8gICAgdm9pZCBlcnJv cl9mcmVlX2VycnAoRXJyb3IgKiplcnJwKQo+Pj4gKy8vICAgIHsKPj4+ICsvLyAgICAgICAgZXJy b3JfZnJlZSgqZXJycCk7Cj4+PiArLy8gICAgICAgICplcnJwID0gTlVMTDsKPj4+ICsvLyAgICB9 Cj4+PiArQCBleGlzdHNACj4+PiAraWRlbnRpZmllciBydWxlMS5mbiwgcnVsZTEubG9jYWxfZXJy Owo+Pj4gK2V4cHJlc3Npb24gbGlzdCBhcmdzOwo+Pj4gK3N5bWJvbCBlcnJwOwo+Pj4gK0BACj4+ PiArCj4+PiArIGZuKC4uLikKPj4+ICsgewo+Pj4gKyAgICAgPC4uLgo+Pj4gKygKPj4KPj4gRWFj aCBvZiB0aGUgZm9sbG93aW5nIHBhdHRlcm5zIGFwcGxpZXMgYW55d2hlcmUgaW4gdGhlIGZ1bmN0 aW9uLgo+Pgo+PiBGaXJzdCBwYXR0ZXJuOiBkZWxldGUgQGxvY2FsX2Vycgo+Pgo+Pj4gKy0gICAg RXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7Cj4+Cj4+IENvbW1vbiBjYXNlOiBvY2N1cnMganVzdCBv bmNlLCBub3QgbmVzdGVkLiAgQW55dGhpbmcgZWxzZSBpcyBzdXNwaWNpb3VzLgo+Pgo+PiBCb3Ro IGNhbiBiZSBkZXRlY3RlZCBpbiB0aGUgcmVzdWx0aW5nIHBhdGNoZXMgd2l0aCBhIGJpdCBvZiBB V0sKPj4gd2l6YXJkcnk6Cj4+Cj4+ICAgICAgJCBnaXQtZGlmZiAtVTAgbWFzdGVyLi5yZXZpZXct ZXJyb3ItdjggfCBhd2sgJy9eQEAgLyB7IGN0eCA9ICQ1OyBmb3IgKGkgPSA2OyBpIDw9IE5GOyBp KyspIGN0eCA9IGN0eCAiICIgJGk7IGlmIChjdHggIT0gb2N0eCkgeyBvY3R4ID0gY3R4OyBuID0g MCB9IH0gL14tICpFcnJvciAqXCogKltBLVphLXowLTlfXSsgKj0gKk5VTEw7LyB7IGlmIChpbmRl eCgkMCwgIkUiKSA+IDYpIHByaW50ICJuZXN0ZWRcbiAgICAiIGN0eDsgaWYgKG4pIHByaW50ICJt b3JlIHRoYW4gb25lXG4gICAgIiBjdHg7IG4rKyB9Jwo+PiAgICAgIG5lc3RlZAo+PiAgICAgICAg ICBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZHJpdmVfZGVzdHJveShYZW5CbG9ja0RyaXZlICpkcml2 ZSwgRXJyb3IgKiplcnJwKQo+PiAgICAgIG5lc3RlZAo+PiAgICAgICAgICBzdGF0aWMgdm9pZCB4 ZW5fYmxvY2tfZGV2aWNlX2Rlc3Ryb3koWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kLAo+PiAg ICAgIG5lc3RlZAo+PiAgICAgICAgICBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZGV2aWNlX2Rlc3Ry b3koWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kLAo+PiAgICAgIG1vcmUgdGhhbiBvbmUKPj4g ICAgICAgICAgc3RhdGljIHZvaWQgeGVuX2Jsb2NrX2RldmljZV9kZXN0cm95KFhlbkJhY2tlbmRJ bnN0YW5jZSAqYmFja2VuZCwKPj4KPj4gT2guCj4+Cj4+IHhlbl9ibG9ja19kcml2ZV9kZXN0cm95 KCkgbmVzdHMgaXRzIEVycm9yICpsb2NhbF9lcnIgaW4gYSBjb25kaXRpb25hbC4KPj4KPj4geGVu X2Jsb2NrX2RldmljZV9kZXN0cm95KCkgaGFzIG11bHRpcGxlIEVycm9yICpsb2NhbF9lcnIuCj4+ Cj4+IEluIGJvdGggY2FzZXMsIG1hbnVhbCByZXZpZXcgaXMgcmVxdWlyZWQgdG8gZW5zdXJlIHRo ZSBjb252ZXJzaW9uIGlzCj4+IG9rYXkuICBJIGJlbGlldmUgaXQgaXMuCj4+Cj4+IE5vdGUgdGhh dCB0aGUgQVdLIHNjcmlwdCByZWxpZXMgb24gZGlmZiBzaG93aW5nIHRoZSBmdW5jdGlvbiBuYW1l IGluIEBACj4+IGxpbmVzLCB3aGljaCBkb2Vzbid0IGFsd2F5cyB3b3JrIGR1ZSB0byBvdXIgY29k aW5nIHN0eWxlLgo+Pgo+PiBGb3IgdGhlIHdob2xlIHRyZWUsIEkgZ2V0IHNvbWUgMzAgc3BvdHMu ICBGZWFzaWJsZS4KPj4KPj4+ICt8Cj4+Cj4+IFNlY29uZCBwYXR0ZXJuOiBjbGVhciBAZXJycCBh ZnRlciBmcmVlaW5nIGl0Cj4+Cj4+PiArCj4+PiArLy8gQ29udmVydCBlcnJvciBjbGVhcmluZyBm dW5jdGlvbnMKPj4KPj4gU3VnZ2VzdDogRW5zdXJlIEBsb2NhbF9lcnIgaXMgY2xlYXJlZCBvbiBm cmVlCj4+Cj4+PiArKAo+Pj4gKy0gICAgZXJyb3JfZnJlZShsb2NhbF9lcnIpOwo+Pj4gKysgICAg ZXJyb3JfZnJlZV9lcnJwKGVycnApOwo+Pj4gK3wKPj4+ICstICAgIGVycm9yX3JlcG9ydF9lcnIo bG9jYWxfZXJyKTsKPj4+ICsrICAgIGVycm9yX3JlcG9ydF9lcnJwKGVycnApOwo+Pj4gK3wKPj4+ ICstICAgIGVycm9yX3JlcG9ydGZfZXJyKGxvY2FsX2VyciwgYXJncyk7Cj4+PiArKyAgICBlcnJv cl9yZXBvcnRmX2VycnAoZXJycCwgYXJncyk7Cj4+PiArfAo+Pj4gKy0gICAgd2Fybl9yZXBvcnRf ZXJyKGxvY2FsX2Vycik7Cj4+PiArKyAgICB3YXJuX3JlcG9ydF9lcnJwKGVycnApOwo+Pj4gK3wK Pj4+ICstICAgIHdhcm5fcmVwb3J0Zl9lcnIobG9jYWxfZXJyLCBhcmdzKTsKPj4+ICsrICAgIHdh cm5fcmVwb3J0Zl9lcnJwKGVycnAsIGFyZ3MpOwo+Pj4gKykKPj4KPj4gQXMgeW91IG1lbnRpb24g YWJvdmUsIHRoZXNlIGd1eXMgZG9uJ3QgZXhpc3QsIHlldC4gIEJ1aWxkcyBhbnl3YXksCj4+IGJl Y2F1c2UgdGhpcyBwYXJ0IG9mIHRoZSBydWxlIGlzIG5vdCB1c2VkIGluIHRoaXMgcGF0Y2ggc2Vy aWVzLiAgWW91Cj4+IGRvbid0IHdhbnQgdG8gb21pdCBpdCwgYmVjYXVzZSB0aGVuIHRoZSBzY3Jp cHQgYmVjb21lcyB1bnNhZmUgdG8gdXNlLgo+Pgo+PiBXZSBjb3VsZCBhbHNvIG9wZW4tY29kZToK Pj4KPj4gICAgIC8vIENvbnZlcnQgZXJyb3IgY2xlYXJpbmcgZnVuY3Rpb25zCj4+ICAgICAoCj4+ ICAgICAtICAgIGVycm9yX2ZyZWUobG9jYWxfZXJyKTsKPj4gICAgICsgICAgZXJyb3JfZnJlZSgq ZXJycCk7Cj4+ICAgICArICAgICplcnJwID0gTlVMTDsKPj4gICAgIHwKPj4gICAgIC4uLiBhbmQg c28gZm9ydGggLi4uCj4+ICAgICApCj4+Cj4+IE1hdHRlciBvZiB0YXN0ZS4gIFdoYXRldmVyIGlz IGVhc2llciB0byBleHBsYWluIGluIHRoZSBjb21tZW50cy4gIFNpbmNlCj4+IHlvdSBhbHJlYWR5 IHdyb3RlIG9uZS4uLgo+Cj4gSSBqdXN0IGZlZWwgdGhhdCB1c2luZyBoZWxwZXIgZnVuY3Rpb25z IGlzIHNhZmVyIHdheS4uCj4KPj4KPj4gV2UgdGFsa2VkIGFib3V0IGV4dGVuZGluZyB0aGlzIHNl cmllcyBzbGlnaHRseSBzbyB0aGVzZSBndXlzIGFyZSB1c2VkLgo+PiBJIG1heSBzdGlsbCBsb29r IGludG8gdGhhdC4KPj4KPj4+ICs/LSAgICBsb2NhbF9lcnIgPSBOVUxMOwo+Pj4gKwo+Pgo+PiBU aGUgbmV3IGhlbHBlcnMgY2xlYXIgQGxvY2FsX2Vyci4gIEFzc2lnbm1lbnQgbm93IHJlZHVuZGFu dCwgZGVsZXRlLgo+PiBPa2F5Lgo+Pgo+Pj4gK3wKPj4KPj4gVGhpcmQgYW5kIGZvdXJ0aCBwYXR0 ZXJuOiBkZWxldGUgZXJyb3JfcHJvcGFnYXRlKCkKPj4KPj4+ICstICAgIGVycm9yX3Byb3BhZ2F0 ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwgYXJncyk7Cj4+PiArKyAgICBlcnJvcl9wcmVwZW5k KGVycnAsIGFyZ3MpOwo+Pj4gK3wKPj4+ICstICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2Nh bF9lcnIpOwo+Pj4gK3wKPj4KPj4gRmlmdGggcGF0dGVybjogdXNlIEBlcnJwIGRpcmVjdGx5Cj4+ Cj4+PiArLSAgICAmbG9jYWxfZXJyCj4+PiArKyAgICBlcnJwCj4+PiArKQo+Pj4gKyAgICAgLi4u Pgo+Pj4gKyB9Cj4+PiArCj4+PiArLy8gQ29udmVydCByZW1haW5pbmcgbG9jYWxfZXJyIHVzYWdl LiBJdCBzaG91bGQgYmUgZGlmZmVyZW50IGtpbmRzIG9mIGVycm9yCj4+PiArLy8gY2hlY2tpbmcg aW4gaWYgb3BlcmF0b3JzLiBXZSBjYW4ndCBtZXJnZSB0aGlzIGludG8gcHJldmlvdXMgaHVuaywg YXMgdGhpcwo+Pgo+PiBJbiBpZiBjb25kaXRpb25hbHMsIEkgc3VwcG9zZS4gIEl0J3MgdGhlIGNh c2UgZm9yIHRoaXMgcGF0Y2guICBJZiBJCj4+IGFwcGx5IHRoZSBzY3JpcHQgdG8gdGhlIHdob2xl IHRyZWUsIHRoZSBydWxlIGdldHMgYWxzbyBhcHBsaWVkIGluIG90aGVyCj4+IGNvbnRleHRzLiAg VGhlIHNlbnRlbmNlIG1pZ2h0IG1pc2xlYWQgYXMgbXVjaCBhcyBpdCBoZWxwcy4gIEtlZXAgaXQg b3IKPj4gZGVsZXRlIGl0Pwo+Cj4gTWF5YmUsIGp1c3QgYmUgbW9yZSBob25lc3Q6ICJJdCBzaG91 bGQgYmUgLi4uLCBidXQgaXQgbWF5IGJlIGFueSBvdGhlciBwYXR0ZXJuLCBiZSBjYXJlZnVsIgoK Ik5lZWQgdG8gYmUgY2FyZWZ1bCIgbWVhbnMgIm5lZWRzIGNhcmVmdWwgbWFudWFsIHJldmlldyIs IHdoaWNoIEkKYmVsaWV2ZSBpcyBub3QgZmVhc2libGU7IHNlZSAiUHJlZmFjZSB0byBteSByZXZp ZXcgb2YgdGhpcyBzY3JpcHQiCmFib3ZlLgoKQnV0IGRvIHdlIHJlYWxseSBuZWVkIHRvIGJlIGNh cmVmdWwgaGVyZT8KClRoaXMgcnVsZSBzaG91bGQgYXBwbHkgb25seSB3aGVyZSB3ZSBhZGRlZCBF UlJQX0FVVE9fUFJPUEFHQVRFKCkuCgpFeGNlcHQgd2hlbiBydWxlIGNoYWluaW5nIHZpYSBmdW5j dGlvbiBuYW1lIGZhaWxzIHVzLCBidXQgd2UgcGxhbiB0bwpkZXRlY3QgdGhhdCBhbmQgcmV2aWV3 IG1hbnVhbGx5LCBzbyBsZXQncyBpZ25vcmUgdGhpcyBpc3N1ZSBoZXJlLgoKVGhhbmtzIHRvIEVS UlBfQVVUT19QUk9QQUdBVEUoKSwgQGVycnAgaXMgbm90IG51bGwuICBFbmFibGluZwpyZXBsYWNl bWVudCBvZiBAbG9jYWxfZXJyIGJ5IEBlcnJwIGlzIGl0cyB3aG9sZSBwb2ludC4KCldoYXQgZXhh Y3RseSBkbyB3ZSBuZWVkIHRvIGJlIGNhcmVmdWwgYWJvdXQ/Cgo+Cj4+Cj4+PiArLy8gY29uZmxp Y3RzIHdpdGggb3RoZXIgc3Vic3RpdHV0aW9ucyBpbiBpdCAoYXQgbGVhc3Qgd2l0aCAiLSBsb2Nh bF9lcnIgPSBOVUxMIikuCj4+PiArQEAKPj4+ICtpZGVudGlmaWVyIHJ1bGUxLmZuLCBydWxlMS5s b2NhbF9lcnI7Cj4+PiArc3ltYm9sIGVycnA7Cj4+PiArQEAKPj4+ICsKPj4+ICsgZm4oLi4uKQo+ Pj4gKyB7Cj4+PiArICAgICA8Li4uCj4+PiArLSAgICBsb2NhbF9lcnIKPj4+ICsrICAgICplcnJw Cj4+PiArICAgICAuLi4+Cj4+PiArIH0KPj4+ICsKPj4+ICsvLyBBbHdheXMgdXNlIHRoZSBzYW1l IHBhdHRlciBmb3IgY2hlY2tpbmcgZXJyb3IKPj4KPj4gcy9wYXR0ZXIvcGF0dGVybi8KPj4KPj4+ ICtAQAo+Pj4gK2lkZW50aWZpZXIgcnVsZTEuZm47Cj4+PiArc3ltYm9sIGVycnA7Cj4+PiArQEAK Pj4+ICsKPj4+ICsgZm4oLi4uKQo+Pj4gKyB7Cj4+PiArICAgICA8Li4uCj4+PiArLSAgICAqZXJy cCAhPSBOVUxMCj4+PiArKyAgICAqZXJycAo+Pj4gKyAgICAgLi4uPgo+Pj4gKyB9Cj4+CgoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1h aWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6Ly9saXN0cy54 ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.5 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 11137C3F2C6 for ; Tue, 10 Mar 2020 15:49:10 +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 C511020866 for ; Tue, 10 Mar 2020 15:49:09 +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="D5XDWbxT" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C511020866 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]:35986 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jBh81-0007gr-36 for qemu-devel@archiver.kernel.org; Tue, 10 Mar 2020 11:49:09 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:50453) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jBh70-0006Ut-RJ for qemu-devel@nongnu.org; Tue, 10 Mar 2020 11:48:10 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1jBh6x-0005Dm-3I for qemu-devel@nongnu.org; Tue, 10 Mar 2020 11:48:06 -0400 Received: from us-smtp-delivery-1.mimecast.com ([207.211.31.120]:32346 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 1jBh6w-00059w-UL for qemu-devel@nongnu.org; Tue, 10 Mar 2020 11:48:03 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1583855281; 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=llDx5f/9wcs3vbiatzh0myHKONfdDXiTM5J6AYYnUJM=; b=D5XDWbxT6PT56bDcEECsoR+xQBsxUUEjcZX99ITtBBCwjPkCH/o3u/25BWm9aQ3BJZHTdK w1yRc2AAdUTReyFPQKaK7gN/chylNpG6oGF9TNrrLdtVK8CYGTDOClzY0D8ivMKiw/fQ3H g4+ujhzdRrx4vFtQqVzs/zQOtpT86K8= 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-43-aRqdc__hM86O2bD4Qkxjvg-1; Tue, 10 Mar 2020 11:47:58 -0400 X-MC-Unique: aRqdc__hM86O2bD4Qkxjvg-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 9F164800D50; Tue, 10 Mar 2020 15:47:55 +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 4D3F75D9C5; Tue, 10 Mar 2020 15:47:49 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id C2C9511386A6; Tue, 10 Mar 2020 16:47:47 +0100 (CET) From: Markus Armbruster To: Vladimir Sementsov-Ogievskiy Subject: Re: [PATCH v8 02/10] scripts: add coccinelle script to use auto propagated errp References: <20200306051536.27803-1-vsementsov@virtuozzo.com> <20200306051536.27803-3-vsementsov@virtuozzo.com> <87lfo997hs.fsf@dusky.pond.sub.org> Date: Tue, 10 Mar 2020 16:47:47 +0100 In-Reply-To: (Vladimir Sementsov-Ogievskiy's message of "Tue, 10 Mar 2020 10:44:22 +0300") Message-ID: <87lfo8nrdo.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.14 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] [fuzzy] X-Received-From: 207.211.31.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 , Philippe =?utf-8?Q?Mathieu-Daud=C3=A9?= , Christian Schoenebeck , Michael Roth , qemu-devel@nongnu.org, Greg Kurz , Gerd Hoffmann , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz , Laszlo Ersek , Stefan Berger Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" Vladimir Sementsov-Ogievskiy writes: > 09.03.2020 12:56, Markus Armbruster wrote: >> Suggest >> >> scripts: Coccinelle script to use auto-propagated errp >> >> or >> >> scripts: Coccinelle script to use ERRP_AUTO_PROPAGATE() >> >> Vladimir Sementsov-Ogievskiy writes: >> >>> Script adds ERRP_AUTO_PROPAGATE macro invocation where appropriate and >>> does corresponding changes in code (look for details in >>> include/qapi/error.h) >>> >>> Usage example: >>> spatch --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ >>> --macro-file scripts/cocci-macro-file.h --in-place --no-show-diff \ >>> blockdev-nbd.c qemu-nbd.c {block/nbd*,nbd/*,include/block/nbd*}.[hc] >> >> Suggest FILES... instead of a specific set of 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-block@nongnu.org >>> Cc: qemu-devel@nongnu.org >>> Cc: xen-devel@lists.xenproject.org >>> >>> include/qapi/error.h | 3 + >>> scripts/coccinelle/auto-propagated-errp.cocci | 231 +++++++++++++++++= + >>> 2 files changed, 234 insertions(+) >>> create mode 100644 scripts/coccinelle/auto-propagated-errp.cocci >>> >>> diff --git a/include/qapi/error.h b/include/qapi/error.h >>> index bb9bcf02fb..fbfc6f1c0b 100644 >>> --- a/include/qapi/error.h >>> +++ b/include/qapi/error.h >>> @@ -211,6 +211,9 @@ >>> * } >>> * ... >>> * } >>> + * >>> + * For mass conversion use script >> >> mass-conversion (we're not converting mass, we're converting en masse) >> >>> + * scripts/coccinelle/auto-propagated-errp.cocci >>> */ >>> #ifndef ERROR_H >>> diff --git a/scripts/coccinelle/auto-propagated-errp.cocci b/scripts/co= ccinelle/auto-propagated-errp.cocci >>> new file mode 100644 >>> index 0000000000..bff274bd6d >>> --- /dev/null >>> +++ b/scripts/coccinelle/auto-propagated-errp.cocci >> >> Preface to my review of this script: may aim isn't to make it >> bullet-proof. I want to (1) make it good enough (explained in a >> jiffie), and (2) automatically identify the spots where it still isn't >> obviously safe for manual review. >> >> The latter may involve additional scripting. That's okay. >> >> The script is good enough when the number of possibly unsafe spots is >> low enough for careful manual review. >> >> When I ask for improvements that, in your opinion, go beyond "good >> enough", please push back. I'm sure we can work it out together. >> >>> @@ -0,0 +1,231 @@ >>> +// 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 modif= y >>> +// it under the terms of the GNU General Public License as published b= y >>> +// 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 blockdev-nbd.c qemu-nbd.c \ >> >> You have --max-width 80 here, but not in the commit message. Default >> seems to be 78. Any particular reason to change it to 80? > > Hmm. As I remember, without this parameter, reindenting doesn't work corr= ectly. > So, I'm OK with "--max-width 78", but I doubt that it will work without a= parameter. > Still, may be I'm wrong, we can check it. If you can point to an example where --max-width helps, keep it, and update the commit message to match. Else, drop it. >> >>> +// {block/nbd*,nbd/*,include/block/nbd*}.[hc] >>> + >>> +// Switch unusual (Error **) parameter names to errp >> >> Let's drop the parenthesis around Error ** >> >>> +// (this is necessary to use ERRP_AUTO_PROPAGATE). >> >> Perhaps ERRP_AUTO_PROPAGATE() should be ERRP_AUTO_PROPAGATE(errp) to >> make the fact we're messing with @errp more obvious. Too late; I >> shouldn't rock the boat that much now. >> >>> +// >>> +// Disable optional_qualifier to skip functions with "Error *const *er= rp" >>> +// parameter. >>> +// >>> +// Skip functions with "assert(_errp && *_errp)" statement, as they ha= ve >>> +// non generic semantics and may have unusual Error ** argument name f= or purpose >> >> non-generic >> >> for a purpose >> >> Wrap comment lines around column 70, please. It's easier to read. >> >> Maybe >> >> // Skip functions with "assert(_errp && *_errp)" statement, because = that >> // signals unusual semantics, and the parameter name may well serve = a >> // purpose. > > Sounds good. > >> >>> +// (like nbd_iter_channel_error()). >>> +// >>> +// Skip util/error.c to not touch, for example, error_propagate and >>> +// error_propagate_prepend(). >> >> error_propagate() >> >> I much appreciate your meticulous explanation of what you skip and why. >> >>> +@ 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 >>> + ...> >>> +) >>> + } >> >> This rule is required to make the actual transformations (below) work >> even for parameters with names other than @errp. I believe it's not >> used in this series. In fact, I can't see a use for it in the entire >> tree right now. Okay anyway. >> >>> + >>> +// Add invocation of ERRP_AUTO_PROPAGATE to errp-functions where neces= sary >>> +// >>> +// Note, that without "when any" final "..." may not want to mach some= thing >> >> s/final "..." may not mach/the final "..." does not match/ >> >>> +// matched by previous pattern, i.e. the rule will not match double >>> +// error_prepend in control flow like in vfio_set_irq_signaling(). >> >> Can't say I fully understand Coccinelle there. I figure you came to >> this knowledge the hard way. > > It's follows from smpl grammar document: > > "Implicitly, =E2=80=9C...=E2=80=9D matches the shortest path between some= thing that matches the pattern before the dots (or the beginning of the fun= ction, if there is nothing before the dots) and something that matches the = pattern after the dots (or the end of the function, if there is nothing aft= er the dots)." > ... > "_when any_ removes the aforementioned constraint that =E2=80=9C...=E2=80= =9D matches the shortest path" Let me think that through. The pattern with the cases other than error_prepend() omitted: fn(..., Error **errp, ...) { + ERRP_AUTO_PROPAGATE(); ... when !=3D ERRP_AUTO_PROPAGATE(); error_prepend(errp, ...); ... when any } Tail of vfio_set_irq_signaling(): name =3D index_to_str(vbasedev, index); if (name) { error_prepend(errp, "%s-%d: ", name, subindex); } else { error_prepend(errp, "index %d-%d: ", index, subindex); } error_prepend(errp, "Failed to %s %s eventfd signaling for interrupt ", fd < 0 ? "tear down" : "set up", action_to_str(action= )); return ret; } The pattern's first ... matches a "shortest" path to an error_prepend(), where "shortest" means "does not cross an error_prepend(). Its when clause makes us ignore functions that already use ERRP_AUTO_PROPAGATE(). There are two such "shortest" paths, one to the first error_prepend() in vfio_set_irq_signaling(), and one to the second. Neither path to the third one is not "shortest": they both cross one of the other two error_prepend(). The pattern' s second ... matches a path from a matched error_prepend() to the end of the function. There are two paths. Both cross the third error_prepend(). You need "when any" to make the pattern match anyway. Alright, I think I got it. But now I'm paranoid about ... elsewhere. For instance, here's rule1 with error_propagate_prepend() omitted: // Match scenarios with propagation of local error to errp. @rule1 disable optional_qualifier exists@ identifier fn, local_err; symbol errp; @@ fn(..., Error **errp, ...) { ... Error *local_err =3D NULL; ... error_propagate(errp, local_err); ... } The second and third ... won't match anything containing error_propagate(). What if a function has multiple error_propagate() on all paths? Like this one: 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); } This is actually a variation of error.h's "Receive and accumulate multiple errors (first one wins)" code snippet. The Coccinelle script transforms it like this: void frob(Error **errp) { + ERRP_AUTO_PROPAGATE(); Error *local_err =3D NULL; int arg; The rule that adds ERRP_AUTO_PROPAGATE() matches (it has ... when any), but rule1 does not, and we therefore don't convert any of the error_propagate(). The result isn't wrong, just useless. Is this the worst case? Possible improvement to the ERRP_AUTO_PROPAGATE() rule: don't use "... when any" in the error_propagate() case, only in the other cases. Would that help? I think this is the only other rule with "..." matching control flow. >> >>> +// >>> +// Note, "exists" says that we want apply rule even if it matches not = on >>> +// all possible control flows (otherwise, it will not match standard p= attern >>> +// when error_propagate() call is in if branch). >> >> Learned something new. Example: kvm_set_kvm_shadow_mem(). >> >> Spelling it "exists disable optional_qualifier" would avoid giving >> readers the idea we're disabling "exists", but Coccinelle doesn't let >> us. Oh well. >> >>> +@ disable optional_qualifier exists@ >>> +identifier fn, local_err, errp; >> >> I believe this causes >> >> warning: line 98: errp, previously declared as a metavariable, is u= sed as an identifier >> warning: line 104: errp, previously declared as a metavariable, is = used as an identifier >> warning: line 106: errp, previously declared as a metavariable, is = used as an identifier >> warning: line 131: errp, previously declared as a metavariable, is = used as an identifier >> warning: line 192: errp, previously declared as a metavariable, is = used as an identifier >> warning: line 195: errp, previously declared as a metavariable, is = used as an identifier >> warning: line 228: errp, previously declared as a metavariable, is = used as an identifier >> >> Making @errp symbol instead of identifier should fix this. > > Hmm, I didn't see these warnings.. But yes, it should be symbol. > >> >>> +@@ >>> + >>> + fn(..., Error **errp, ...) >>> + { >>> ++ ERRP_AUTO_PROPAGATE(); >>> + ... when !=3D ERRP_AUTO_PROPAGATE(); >>> +( >>> + error_append_hint(errp, ...); >>> +| >>> + error_prepend(errp, ...); >>> +| >>> + error_vprepend(errp, ...); >>> +| >>> + Error *local_err =3D NULL; >>> + ... >>> +( >>> + error_propagate_prepend(errp, local_err, ...); >>> +| >>> + error_propagate(errp, local_err); >>> +) >>> +) >>> + ... when any >>> + } >>> + >>> + >>> +// Match scenarios with propagation of local error to errp. >>> +@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); >>> +) >> >> Indentation off by one. >> >>> + ... >>> + } >>> + >>> +// Convert special case with goto in separate. >> >> s/in separate/separately/ >> >>> +// We can probably merge this into the following hunk with help of ( |= ) >>> +// operator, but it significantly reduce performance on block.c parsin= g (or it >> >> s/reduce/reduces/ >> >>> +// hangs, I don't know) >> >> Sounds like you tried to merge this into the following hunk, but then >> spatch took so long on block.c that you killed it. Correct? > > Yes. I'd say something like "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 "o= ut: }" >>> +// things later after all transformations (the rule will be the same, = just >>> +// without error_propagate() call), coccinelle fails to match this "ou= t: }". >> >> Weird, but not worth further investigation. > > It partially match to the idea which I saw somewhere in coccinelle docume= ntation, > that coccinelle converts correct C code to correct C code. "out: }" is an= example > of incorrect, impossible code flow, and coccinelle can't work with it... = But it's > just a thought. > >> >>> +@@ >>> +identifier rule1.fn, rule1.local_err, out; >>> +symbol errp; >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +- goto out; >>> ++ return; >>> + ...> >>> +- out: >>> +- error_propagate(errp, local_err); >> >> You neglect to match error_propagate_prepend(). Okay, because (1) that >> pattern doesn't occur in the tree right now, and (2) if it gets added, >> gcc will complain. > > No, because it should not removed. error_propagate_prepend should be conv= erted > to prepend, not removed. So, corresponding gotos should not be removed as= well. You're right. >> >>> + } >>> + >>> +// Convert most of local_err related staff. >> >> s/staff/stuff/ >> >>> +// >>> +// Note, that we update everything related to matched by rule1 functio= n name >>> +// and local_err name. We may match something not related to the patte= rn >>> +// matched by rule1. For example, local_err may be defined with the sa= me name >>> +// in different blocks inside one function, and in one block follow th= e >>> +// propagation pattern and in other block doesn't. Or we may have seve= ral >>> +// functions with the same name (for different configurations). >> >> Context: rule1 matches functions that have all three of >> >> * an Error **errp parameter >> >> * an Error *local_err =3D NULL variable declaration >> >> * an error_propagate(errp, local_err) or error_propagate_prepend(errp, >> local_err, ...) expression, where @errp is the parameter and >> @local_err is the variable. >> >> If I understand you correctly, you're pointing out two potential issues: >> >> 1. This rule can match functions rule1 does not match if there is >> another function with the same name that rule1 does match. >> >> 2. This rule matches in the entire function matched by rule1, even when >> parts of that function use a different @errp or @local_err. >> >> I figure these apply to all rules with identifier rule1.fn, not just >> this one. Correct? > > Yes. Thanks! >> >> Regarding 1. There must be a better way to chain rules together, but I >> don't know it. >> Can we make Coccinelle at least warn us when it converts >> multiple functions with the same name? What about this: >> >> @initialize:python@ >> @@ >> fnprev =3D {} >> >> def pr(fn, p): >> print("### %s:%s: %s()" % (p[0].file, p[0].line, fn)) >> >> @r@ >> identifier rule1.fn; >> position p; >> @@ >> fn(...)@p >> { >> ... >> } >> @script:python@ >> fn << rule1.fn; >> p << r.p; >> @@ >> if fn not in fnprev: >> fnprev[fn] =3D p >> else: >> if fnprev[fn]: > > hmm, the condition can't be false > >> pr(fn, fnprev[fn]) >> fnprev[fn] =3D None >> pr(fn, p) > > and we'll miss next duplication.. The idea is first instance of fn: fn not in fnprev fnprev[fn] =3D position of instance don't print second instance: fnprev[fn] is the position of the first instance print first two instances subsequent instances: fnprev[fn] is None print this instance I might have screwed up the coding, of course :) > But I like the idea. > >> >> For each function @fn matched by rule1, fncnt[fn] is an upper limit of >> the number of functions with the same name we touch. If it's more than >> one, we print. >> >> Reports about a dozen function names for the whole tree in my testing. >> Inspecting the changes to them manually is feasible. None of them are >> in files touched by this series. >> >> The line printed for the first match is pretty useless for me: it points >> to a Coccinelle temporary file *shrug*. >> >> Regarding 2. Shadowing @errp or @local_err would be in bad taste, and I >> sure hope we don't do that. Multiple @local_err variables... hmm. >> Perhaps we could again concoct some script rules to lead us to spots to >> check manually. See below for my attempt. >> >> What's the worst that could happen if we blindly converted such code? >> The answer to that question tells us how hard to work on finding and >> checking these guys. >> >>> +// >>> +// 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* - free= ing >>> +// function and then set *errp to NULL, to avoid further propagation t= o >>> +// 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; >>> +// } >>> +@ exists@ >>> +identifier rule1.fn, rule1.local_err; >>> +expression list args; >>> +symbol errp; >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +( >> >> Each of the following patterns applies anywhere in the function. >> >> First pattern: delete @local_err >> >>> +- Error *local_err =3D NULL; >> >> Common case: occurs just once, not nested. Anything else is suspicious. >> >> Both can be detected in the resulting patches with a bit of AWK >> wizardry: >> >> $ git-diff -U0 master..review-error-v8 | awk '/^@@ / { ctx =3D $5; = for (i =3D 6; i <=3D NF; i++) ctx =3D ctx " " $i; if (ctx !=3D octx) { octx= =3D ctx; n =3D 0 } } /^- *Error *\* *[A-Za-z0-9_]+ *=3D *NULL;/ { if (inde= x($0, "E") > 6) print "nested\n " ctx; if (n) print "more than one\n = " ctx; n++ }' >> nested >> static void xen_block_drive_destroy(XenBlockDrive *drive, Error= **errp) >> nested >> static void xen_block_device_destroy(XenBackendInstance *backen= d, >> nested >> static void xen_block_device_destroy(XenBackendInstance *backen= d, >> more than one >> static void xen_block_device_destroy(XenBackendInstance *backen= d, >> >> Oh. >> >> xen_block_drive_destroy() nests its Error *local_err in a conditional. >> >> xen_block_device_destroy() has multiple Error *local_err. >> >> In both cases, manual review is required to ensure the conversion is >> okay. I believe it is. >> >> Note that the AWK script relies on diff showing the function name in @@ >> lines, which doesn't always work due to our coding style. >> >> For the whole tree, I get some 30 spots. Feasible. >> >>> +| >> >> Second pattern: clear @errp after freeing it >> >>> + >>> +// Convert error clearing functions >> >> Suggest: Ensure @local_err is cleared on free >> >>> +( >>> +- 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); >>> +) >> >> As you mention above, these guys don't exist, yet. Builds anyway, >> because this part of the rule is not used in this patch series. You >> don't want to omit it, because then the script becomes unsafe to use. >> >> We could also open-code: >> >> // Convert error clearing functions >> ( >> - error_free(local_err); >> + error_free(*errp); >> + *errp =3D NULL; >> | >> ... and so forth ... >> ) >> >> Matter of taste. Whatever is easier to explain in the comments. Since >> you already wrote one... > > I just feel that using helper functions is safer way.. > >> >> We talked about extending this series slightly so these guys are used. >> I may still look into that. >> >>> +?- local_err =3D NULL; >>> + >> >> The new helpers clear @local_err. Assignment now redundant, delete. >> Okay. >> >>> +| >> >> Third and fourth pattern: delete error_propagate() >> >>> +- error_propagate_prepend(errp, local_err, args); >>> ++ error_prepend(errp, args); >>> +| >>> +- error_propagate(errp, local_err); >>> +| >> >> Fifth pattern: use @errp directly >> >>> +- &local_err >>> ++ errp >>> +) >>> + ...> >>> + } >>> + >>> +// Convert remaining local_err usage. It should be different kinds of = error >>> +// checking in if operators. We can't merge this into previous hunk, a= s this >> >> In if conditionals, I suppose. It's the case for this patch. If I >> apply the script to the whole tree, the rule gets also applied in other >> contexts. The sentence might mislead as much as it helps. Keep it or >> delete it? > > Maybe, just be more honest: "It should be ..., but it may be any other pa= ttern, be careful" "Need to be careful" means "needs careful manual review", which I believe is not feasible; see "Preface to my review of this script" above. But do we really need to be careful here? This rule should apply only where we added ERRP_AUTO_PROPAGATE(). Except when rule chaining via function name fails us, but we plan to detect that and review manually, so let's ignore this issue here. Thanks to ERRP_AUTO_PROPAGATE(), @errp is not null. Enabling replacement of @local_err by @errp is its whole point. What exactly do we need to be careful about? > >> >>> +// conflicts with other substitutions in it (at least with "- local_er= r =3D NULL"). >>> +@@ >>> +identifier rule1.fn, rule1.local_err; >>> +symbol errp; >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +- local_err >>> ++ *errp >>> + ...> >>> + } >>> + >>> +// Always use the same patter for checking error >> >> s/patter/pattern/ >> >>> +@@ >>> +identifier rule1.fn; >>> +symbol errp; >>> +@@ >>> + >>> + fn(...) >>> + { >>> + <... >>> +- *errp !=3D NULL >>> ++ *errp >>> + ...> >>> + } >>