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=1.1 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,YOU_INHERIT autolearn=no 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 AC454C4332E for ; Thu, 19 Mar 2020 10:46:17 +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 7420320724 for ; Thu, 19 Mar 2020 10:46:17 +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="VOuTj7Mk" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7420320724 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1jEsgU-0004V4-90; Thu, 19 Mar 2020 10:45:54 +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 1jEsgT-0004Uz-57 for xen-devel@lists.xenproject.org; Thu, 19 Mar 2020 10:45:53 +0000 X-Inumbo-ID: ccceea78-69ce-11ea-bbe1-12813bfff9fa Received: from us-smtp-delivery-74.mimecast.com (unknown [216.205.24.74]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTP id ccceea78-69ce-11ea-bbe1-12813bfff9fa; Thu, 19 Mar 2020 10:45:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584614750; 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=W97N0/BhMj5VQnTpNBcqX2gvUKJva35QxWpCfIclmK0=; b=VOuTj7Mkc/SJW09h+6ht0Nc0F1LVieRjZElk/i9C1bID0wZABy3ilhLQUmz9gDBNSzD6Cg 9+xdkND/uhQhMKIVf9vOAlUUeHwMbImaBBIG+3A98wMeUuZMr2wLULz09FoMiDxcQ83TII dllCnw3/+reS4SOsArMCQut97LNx7og= 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-327-WDmxZiu1NFOvlcB7L8FNZA-1; Thu, 19 Mar 2020 06:45:38 -0400 X-MC-Unique: WDmxZiu1NFOvlcB7L8FNZA-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 892C1801A06; Thu, 19 Mar 2020 10:45:36 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-112-130.ams2.redhat.com [10.36.112.130]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 4076B9128E; Thu, 19 Mar 2020 10:45:30 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id C40351138404; Thu, 19 Mar 2020 11:45:28 +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> <87blozex9v.fsf@dusky.pond.sub.org> <87o8swk8wc.fsf@dusky.pond.sub.org> <87wo7jqn8m.fsf@dusky.pond.sub.org> Date: Thu, 19 Mar 2020 11:45:28 +0100 In-Reply-To: (Vladimir Sementsov-Ogievskiy's message of "Tue, 17 Mar 2020 14:35:15 +0300") Message-ID: <87wo7gd3nb.fsf@dusky.pond.sub.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.3 (gnu/linux) MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Subject: Re: [Xen-devel] [PATCH v9 02/10] scripts: Coccinelle script to use ERRP_AUTO_PROPAGATE() X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , Stefano Stabellini , 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+IDE3LjAzLjIwMjAgMTM6MzksIE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+PiBW bGFkaW1pciBTZW1lbnRzb3YtT2dpZXZza2l5IDx2c2VtZW50c292QHZpcnR1b3p6by5jb20+IHdy aXRlczoKPj4KPj4+IDE2LjAzLjIwMjAgMTE6MjEsIE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+ Pj4+IFZsYWRpbWlyIFNlbWVudHNvdi1PZ2lldnNraXkgPHZzZW1lbnRzb3ZAdmlydHVvenpvLmNv bT4gd3JpdGVzOgo+Pj4+Cj4+Pj4+IE9uIDE0LjAzLjIwMjAgMDA6NTQsIE1hcmt1cyBBcm1icnVz dGVyIHdyb3RlOgo+Pj4+Pj4gVmxhZGltaXIgU2VtZW50c292LU9naWV2c2tpeSA8dnNlbWVudHNv dkB2aXJ0dW96em8uY29tPiB3cml0ZXM6Cj4+Pj4+Pgo+Pj4+Pj4+IDEzLjAzLjIwMjAgMTg6NDIs IE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+Pj4+Pj4+PiBWbGFkaW1pciBTZW1lbnRzb3YtT2dp ZXZza2l5IDx2c2VtZW50c292QHZpcnR1b3p6by5jb20+IHdyaXRlczoKPj4+Pj4+Pj4KPj4+Pj4+ Pj4+IDEyLjAzLjIwMjAgMTk6MzYsIE1hcmt1cyBBcm1icnVzdGVyIHdyb3RlOgo+Pj4+Pj4+Pj4+ IEkgbWF5IGhhdmUgYSBzZWNvbmQgbG9vayB0b21vcnJvdyB3aXRoIGZyZXNoZXIgZXllcywgYnV0 IGxldCdzIGdldCB0aGlzCj4+Pj4+Pj4+Pj4gb3V0IG5vdyBhcyBpcy4KPj4+Pj4+Pj4+Pgo+Pj4+ Pj4+Pj4+IFZsYWRpbWlyIFNlbWVudHNvdi1PZ2lldnNraXkgPHZzZW1lbnRzb3ZAdmlydHVvenpv LmNvbT4gd3JpdGVzOgo+PiBbLi4uXQo+Pj4+Pj4+Pj4+PiArQEAKPj4+Pj4+Pj4+Pj4gKwo+Pj4+ Pj4+Pj4+PiArIGZuKC4uLiwgRXJyb3IgKiogX19fXywgLi4uKQo+Pj4+Pj4+Pj4+PiArIHsKPj4+ Pj4+Pj4+Pj4gKyAgICAgLi4uCj4+Pj4+Pj4+Pj4+ICsgICAgIEVycm9yICpsb2NhbF9lcnIgPSBO VUxMOwo+Pj4+Pj4+Pj4+PiArICAgICAuLi4gd2hlbiBhbnkKPj4+Pj4+Pj4+Pj4gKyAgICAgRXJy b3IgKmxvY2FsX2VycjIgPSBOVUxMOwo+Pj4+Pj4+Pj4+PiArICAgICAuLi4gd2hlbiBhbnkKPj4+ Pj4+Pj4+Pj4gKyB9Cj4+Pj4+Pgo+Pj4+Pj4gVGhpcyBmbGFncyBmdW5jdGlvbnMgdGhhdCBoYXZl IG1vcmUgdGhhbiBvbmUgZGVjbGFyYXRpb24gYWxvbmcgYW55Cj4+Pj4+PiBjb250cm9sIGZsb3cg cGF0aC4gIEl0IGRvZXNuJ3QgZmxhZyB0aGlzIG9uZToKPj4+Pj4+Cj4+Pj4+PiAgICAgICAgdm9p ZCBnbmF0KGJvb2wgYiwgRXJyb3IgKiplcnJwKQo+Pj4+Pj4gICAgICAgIHsKPj4+Pj4+ICAgICAg ICAgICAgaWYgKGIpIHsKPj4+Pj4+ICAgICAgICAgICAgICAgIEVycm9yICpsb2NhbF9lcnIgPSBO VUxMOwo+Pj4+Pj4gICAgICAgICAgICAgICAgZm9vKGFyZywgJmxvY2FsX2Vycik7Cj4+Pj4+PiAg ICAgICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKPj4+Pj4+ICAg ICAgICAgICAgfSBlbHNlIHsKPj4+Pj4+ICAgICAgICAgICAgICAgIEVycm9yICpsb2NhbF9lcnIg PSBOVUxMOwo+Pj4+Pj4gICAgICAgICAgICAgICAgYmFyKGFyZywgJmxvY2FsX2Vycik7Cj4+Pj4+ PiAgICAgICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKPj4+Pj4+ ICAgICAgICAgICAgfQo+Pj4+Pj4gICAgICAgIH0KPj4+Pj4+Cj4+Pj4+PiBUaGUgQ29jY2luZWxs ZSBzY3JpcHQgZG9lcyB0aGUgcmlnaHQgdGhpbmcgZm9yIHRoaXMgb25lIHJlZ2FyZGxlc3MuCj4+ Pj4+Pgo+Pj4+Pj4gSSdkIHByZWZlciB0byBoYXZlIHN1Y2ggZnVuY3Rpb25zIGZsYWdnZWQsIHRv by4gIEJ1dCBzcGVuZGluZyB0aW1lIG9uCj4+Pj4+PiBjb252aW5jaW5nIENvY2NpbmVsbGUgdG8g ZG8gaXQgZm9yIG1lIGlzIG5vdCB3b3J0aHdoaWxlOyBJIGNhbiBzaW1wbHkKPj4+Pj4+IHNlYXJj aCB0aGUgZGlmZiBwcm9kdWNlZCBieSBDb2NjaW5lbGxlIGZvciBkZWxldGlvbnMgb2YgZGVjbGFy YXRpb25zCj4+Pj4+PiB0aGF0IGFyZSBub3QgaW5kZW50ZWQgZXhhY3RseSBmb3VyIHNwYWNlcy4K Pj4+Pj4+Cj4+Pj4+PiBCdXQgaWYgd2Uga2VlcCB0aGlzIHJ1bGUsIHdlIHNob3VsZCBhZGp1c3Qg aXRzIGNvbW1lbnQKPj4+Pj4+Cj4+Pj4+PiAgICAgICAgLy8gV2FybiBzZXZlcmFsIEVycm9yICog ZGVmaW5pdGlvbnMuCj4+Pj4+Pgo+Pj4+Pj4gYmVjYXVzZSBpdCBzdXJlIHN1Z2dlc3RzIGl0IGFs c28gY2F0Y2hlcyBmdW5jdGlvbnMgbGlrZSB0aGUgb25lIEkgZ2F2ZQo+Pj4+Pj4gYWJvdmUuCj4+ Pj4+Cj4+Pj4+IEhtbSwgeWVzLi4gV2UgY2FuIHdyaXRlICJXYXJuIHNldmVyYWwgRXJyb3IgKiBk ZWZpbml0aW9ucyBpbiBfb25lXwo+Pj4+PiBjb250cm9sIGZsb3cgKGl0J3Mgbm90IHNvIHRyaXZp YWwgdG8gbWF0Y2ggX2FueV8gY2FzZSB3aXRoIHNldmVyYWwKPj4+Pj4gZGVmaW5pdGlvbnMgd2l0 aCBjb2NjaW5lbGxlKSIgb3Igc29tZXRoaW5nIGxpa2UgdGhpcy4KPj4+Pgo+Pj4+IEhhLCAidHJp dmlhbCIgcmVtaW5kcyBtZSBvZiBhIHN0b3J5LiAgVGhlIG1hdGggcHJvZmVzc29yLCBhZnRlciBo YXZpbmcKPj4+PiBzcGVudCBhIGdvb2QgY2h1bmsgb2YgaGlzIGxlY3R1cmUgZGV2ZWxvcGluZyBh IHByb29mIG9uIHRoZSBibGFja2JvYWQKPj4+PiB0dXJucyB0byB0aGUgYXVkaWVuY2UgdG8gZXhw bGFpbiB3aHkgdGhpcyBsaXR0bGUgcGFydCBkb2Vzbid0IHJlcXVpcmUKPj4+PiBwcm9vZiB3aXRo IHRoZSB3b3JkcyBmYW1pbGlhciB0byBhbnkgbWF0aCBzdHVkZW50ICJhbmQgdGhpcyBpcyB0cml2 aWFsLiIKPj4+PiBQYXVzZSwgcHV6emxlZCBsb29rLi4uICAiSXMgaXQgdHJpdmlhbD8iICBQYXVz ZSwgc3Rvcm1zIG91dCBvZiB0aGUKPj4+PiBsZWN0dXJlIGhhbGwuICBBIG1pbnV0ZSBvciB0aHJl ZSBwYXNzLiAgUHJvZmVzc29yIGNvbWVzIGJhY2sgYmVhbWluZywKPj4+PiAiaXQgaXMgdHJpdmlh bCEiLCBhbmQgcHJvY2VlZHMgd2l0aCB0aGUgcHJvb2YuCj4+Pj4KPj4+PiBNeSBwb2ludCBpczog aXQgbWlnaHQgYmUgdHJpdmlhbCB3aXRoIENvY2NpbmVsbGUgb25jZSB5b3Uga25vdyBob3cgdG8g ZG8KPj4+PiBpdC4gIFdlIGRvbid0Lgo+Pj4+Cj4+Pj4gU3VnZ2VzdCAiKGNhbid0IGZpZ3VyZSBv dXQgaG93IHRvIG1hdGNoIHNldmVyYWwgZGVmaW5pdGlvbnMgcmVnYXJkbGVzcwo+Pj4+IG9mIGNv bnRyb2wgZmxvdykiLgo+Pj4KPj4+IFdyb25nIHRvbywgYmVjYXVzZSBJIGNhbjopIGZvciBleGFt cGxlLCBjaGFpbmluZyB0d28gcnVsZXMsIGNhdGNoaW5nIHRoZQo+Pj4gcG9zaXRpb25zIG9mIGRl ZmluaXRpb24gYW5kIGNoZWNrIHRoYXQgdGhleSBhcmUgZGlmZmVyZW50Li4gT3IsIHNvbWUKPj4+ IGNoZWF0aW5nIHdpdGggcHl0aG9uIHNjcmlwdC4uIFRoYXQncyB3aHkgSSB3cm90ZSAibm90IHRy aXZpYWwiLAo+Pj4KPj4+IFNvLCBtb3N0IGNvcnJlY3Qgd291bGQgYmUgIihjYW4ndCBmaWd1cmUg b3V0IGhvdyB0byBzaW1wbHkgbWF0Y2ggc2V2ZXJhbCBkZWZpbml0aW9ucyByZWdhcmRsZXNzCj4+ Pj4gb2YgY29udHJvbCBmbG93KSIuCj4+Cj4+IFdvcmtzIGZvciBtZS4KPj4KPj4+IEJ1dCBhZ2Fp biwgY29jY2luZWxsZSBpcyBmb3IgbWF0Y2hpbmcgY29udHJvbCBmbG93cywgc28gaXRzIHByb2Jh Ymx5IGltcG9zc2libGUgdG8gbWF0Y2ggc3VjaCB0aGluZy4uCj4+IFsuLi5dCj4+Pj4+IE9LLCBJ IGFsbW9zdCBPSyB3aXRoIGl0LCB0aGUgb25seSB0aGluZyBJIGRvdWJ0IGEgYml0IGlzIHRoZSBm b2xsb3dpbmc6Cj4+Pj4+Cj4+Pj4+IFdlIHdhbnQgdG8ga2VlcCBydWxlMS5sb2NhbF9lcnIgaW5o ZXJpdGFuY2UgdG8ga2VlcCBjb25uZWN0aW9uIHdpdGgKPj4+Pj4gbG9jYWxfZXJyIGRlZmluaXRp b24uCj4+Pj4KPj4+PiBZZXMuCj4+Pj4KPj4+Pj4gSW50ZXJlc3RpbmcsIHdoZW4gd2UgaGF2ZSBi b3RoIHJ1bGUxLmZuIGFuZCBydWxlMS5sb2NhbF9lcnIgaW5oZXJpdGVkLAo+Pj4+PiBkbyB3ZSBp bmhlcml0IHRoZW0gaW4gc2VwYXJhdGUgKGkuZS4gYWxsIHBvc3NpYmxlIGNvbWJpbmF0aW9ucyBv ZiBmbgo+Pj4+PiBhbmQgbG9jYWxfZXJyIHN5bWJvbHMgZnJvbSBydWxlMSkgb3IgZG8gd2UgaW5o ZXJpdCBhIHBhaXIsIGkuZS4gb25seQo+Pj4+PiBmbi9sb2NhbF9lcnIgcGFpcnMsIGZvdW5kIGJ5 IHJ1bGUxPyBJZiB0aGUgbGF0dGVyIGlzIGNvcnJlY3QsIHRoYXQKPj4+Pj4gd2l0aCB5b3VyIHNj cmlwdCB3ZSBsb3NzIHRoaXMgcGFpciBpbmhlcml0YW5jZSwgYW5kIGdvIHRvIGFsbCBwb3NzaWJs ZQo+Pj4+PiBjb21iaW5hdGlvbnMgb2YgZm4gYW5kIGxvY2FsX2VyciBmcm9tIHJ1bGUxLCBwb3Nz aWJseSBhZGRpbmcgc29tZSB3cm9uZwo+Pj4+PiBjb252ZXJzaW9uIChPSywgeW91J3ZlIGNoZWNr ZWQgdGhhdCBubyBzdWNoIGNhc2VzIGluIGN1cnJlbnQgY29kZSB0cmVlKS4KPj4+Pgo+Pj4+IFRo ZSBjaGFpbmluZyAiaWRlbnRpZmllciBydWxlMS5GT08iIGlzIGJ5IG5hbWUuICBJdCdzIHJlbGlh YmxlIG9ubHkgYXMKPj4+PiBsb25nIGFzIHRoZXJlIGlzIGV4YWN0bHkgb25lIGluc3RhbmNlIG9m IHRoZSBuYW1lLgo+Pj4+Cj4+Pj4gV2UgYWxyZWFkeSBkaXNjdXNzZWQgdGhlIGNhc2Ugb2YgdGhl IGZ1bmN0aW9uIG5hbWU6IGlmIHRoZXJlIGFyZSB0d28KPj4+PiBpbnN0YW5jZXMgb2YgZm9vKCks IGFuZCBydWxlMSBtYXRjaGVzIG9ubHkgb25lIG9mIHRoZW0sIHRoZW4gd2UKPj4+PiBuZXZlcnRo ZWxlc3MgYXBwbHkgdGhlIHJ1bGVzIGNoYWluZWQgdG8gcnVsZTEgdG8gYm90aC4gIEJlY2F1c2Ug dGhhdCBjYW4KPj4+PiBiZSB3cm9uZywgeW91IGNhbWUgdXAgd2l0aCB0aGUgX19fIHRyaWNrLCB3 aGljaCBjaGFpbnMgcmVsaWFibHkuCj4+Pj4KPj4+PiBUaGUgc2FtZSBpc3N1ZSBleGlzdHMgd2l0 aCB0aGUgdmFyaWFibGUgbmFtZTogaWYgdGhlcmUgYXJlIHR3byBpbnN0YW5jZXMKPj4+PiBvZiBA bG9jYWxfZXJyLCBhbmQgcnVsZTEgbWF0Y2hlcyBvbmx5IG9uZSBvZiB0aGVtLCB0aGVuIHdlIG5l dmVydGhlbGVzcwo+Pj4+IGFwcGx5IHRoZSBydWxlcyBjaGFpbmVkIHRvIHJ1bGUxIHRvIGJvdGgu ICBDYW4gYWxzbyBiZSB3cm9uZy4KPj4+Pgo+Pj4+IFdoYXQgYXJlIHRoZSBjb25kaXRpb25zIGZv ciAid3JvbmciPwo+Pj4+Cj4+Pj4gQmVjYXVzZSB0aGUgX19fIGNoYWluaW5nIGlzIHJlbGlhYmxl LCB3ZSBrbm93IHJ1bGUxIG1hdGNoZWQgdGhlCj4+Pj4gZnVuY3Rpb24sIGkuZS4gaXQgaGFzIGEg cGFyYW1ldGVyIEVycm9yICoqZXJycCwgYW5kIGl0IGhhcyBhIGF1dG9tYXRpYwo+Pj4+IHZhcmlh YmxlIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMLgo+Pj4+Cj4+Pj4gV2UncmUgZ29vZCBhcyBsb25n IGFzICphbGwqIGlkZW50aWZpZXJzIEBsb2NhbF9lcnIgaW4gdGhpcyBmdW5jdGlvbiBhcmUKPj4+ PiBkZWNsYXJlZCB0aGF0IHdheS4gIFRoaXMgc2VlbXMgcXVpdGUgbGlrZWx5LiAgSXQncyBub3Qg Y2VydGFpbiwgdGhvdWdoLgo+Pj4+Cj4+Pj4gU2luY2UgbmVzdGVkIGRlY2xhcmF0aW9ucyBvZiBF cnJvciAqKiB2YXJpYWJsZXMgYXJlIHJhcmUsIHdlIGNhbiByZWx5IG9uCj4+Pj4gcmV2aWV3IHRv IGVuc3VyZSB3ZSB0cmFuc2Zvcm0gdGhlc2UgZnVuY3Rpb25zIGNvcnJlY3RseS4KPj4+Pgo+Pj4+ PiBTbywgZHJvcHBpbmcgaW5oZXJpdGFuY2UgaW4gY2hlY2stcnVsZXMgbWFrZXMgc2VuY2UsIGFz IGl0IG1heSBtYXRjaAo+Pj4+PiAoYW5kIHdhcm4pIG1vcmUgaW50ZXJlc3RpbmcgY2FzZXMuCj4+ Pj4+Cj4+Pj4+IEJ1dCBmb3Igb3RoZXIgcnVsZXMsIEknZCBwcmVmZXJlIHRvIGJlIHNhZmVyLCBh bmQgZXhwbGljdGx5IGluaGVyaXQgYWxsCj4+Pj4+IGFjdHVhbGx5IGluaGVyaXRlZCBpZGVudGlm aWVycy4uCj4+Pj4KPj4+PiBJIHN0aWxsIGNhbid0IHNlZSB3aGF0IGNoYWluaW5nIGJ5IGZ1bmN0 aW9uIG5hbWUgaW4gYWRkaXRpb24gdG8gdGhlIF9fXwo+Pj4+IGNoYWluaW5nIGJ1eXMgdXMuCj4+ Pgo+Pj4gSSdsbCBjaGVjayB0aGlzIHRoaW5nIHNvb24uIEFuZCByZXNlbmQgdG9kYXkuCj4KPiBD aGVja2VkLgo+Cj4gWWVzLCBpdCBpbmhlcml0cyBwYWlyIG9mIGZuIGFuZCBsb2NhbF9lcnIsIGFu ZCBpdCBkZWZpbml0ZWx5IG1ha2VzIHNlbnNlLiBJdCBtb3JlIHN0YWJsZS4KPgo+IENvbnNpZGVy IHRoZSBmb2xsb3dpbmcgZXhhbXBsZToKPgo+ICMgY2F0IGEuYwo+IGludCBmMShFcnJvciAqKmVy cnApCj4gewo+ICAgICBFcnJvciAqZXJyMSA9IE5VTEw7Cj4gICAgIGludCBlcnIyID0gMDsKPgo+ ICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgZXJyMSk7Cj4KPiAgICAgcmV0dXJuIGVycjI7Cj4g fQo+Cj4gaW50IGYyKEVycm9yICoqZXJycCkKPiB7Cj4gICAgIEVycm9yICplcnIyID0gTlVMTDsK PiAgICAgaW50IGVycjEgPSAwOwo+Cj4gICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIyKTsK Pgo+ICAgICByZXR1cm4gZXJyMTsKPiB9Cj4KPgo+IE15IHNjcmlwdCB3b3JrcyBjb3JyZWN0IGFu ZCBwcm9kdWNlcyB0aGlzIGNoYW5nZToKPiAtLS0gYS5jCj4gKysrIC90bXAvY29jY2ktb3V0cHV0 LTE3NTMtMTA4NDJhLWEuYwo+IEBAIC0xLDE5ICsxLDE1IEBACj4gIGludCBmMShFcnJvciAqKmVy cnApCj4gIHsKPiAtICAgIEVycm9yICplcnIxID0gTlVMTDsKPiArICAgIEVSUlBfQVVUT19QUk9Q QUdBVEUoKTsKPiAgICAgIGludCBlcnIyID0gMDsKPgo+IC0gICAgZXJyb3JfcHJvcGFnYXRlKGVy cnAsIGVycjEpOwo+IC0KPiAgICAgIHJldHVybiBlcnIyOwo+ICB9Cj4KPiAgaW50IGYyKEVycm9y ICoqZXJycCkKPiAgewo+IC0gICAgRXJyb3IgKmVycjIgPSBOVUxMOwo+ICsgICAgRVJSUF9BVVRP X1BST1BBR0FURSgpOwo+ICAgICAgaW50IGVycjEgPSAwOwo+Cj4gLSAgICBlcnJvcl9wcm9wYWdh dGUoZXJycCwgZXJyMik7Cj4gLQo+ICAgICAgcmV0dXJuIGVycjE7Cj4gIH0KPgo+Cj4gQnV0IHlv dXJzIHNjcmlwdCBpcyBjYXVnaHQ6Cj4gLS0tIGEuYwo+ICsrKyAvdG1wL2NvY2NpLW91dHB1dC0x ODE0LWI5YjY4MS1hLmMKPiBAQCAtMSwxOSArMSwxNSBAQAo+ICBpbnQgZjEoRXJyb3IgKiplcnJw KQo+ICB7Cj4gLSAgICBFcnJvciAqZXJyMSA9IE5VTEw7Cj4gKyAgICBFUlJQX0FVVE9fUFJPUEFH QVRFKCk7Cj4gICAgICBpbnQgZXJyMiA9IDA7Cj4KPiAtICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJw LCBlcnIxKTsKPiAtCj4gLSAgICByZXR1cm4gZXJyMjsKPiArICAgIHJldHVybiAqZXJycDsKPiAg fQo+Cj4gIGludCBmMihFcnJvciAqKmVycnApCj4gIHsKPiAtICAgIEVycm9yICplcnIyID0gTlVM TDsKPiArICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKPiAgICAgIGludCBlcnIxID0gMDsKPgo+ IC0gICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGVycjIpOwo+IC0KPiAtICAgIHJldHVybiBlcnIx Owo+ICsgICAgcmV0dXJuICplcnJwOwo+ICB9Cj4KPgo+IC0gc2VlLCBpdCB0b3VjaGVzIGVycjEs IHdoaWNoIGlzIHVucmVsYXRlZCB0byBFcnJvciBpbiBmMi4gSG1tLAo+IGludGVyZXN0aW5nIHRo YXQgaXQgZG9lc24ndCB3YW50IHRvIGNvbnZlcnQgZXJyMSBkZWNsYXJhdGlvbjopCj4KPiAtIHRo aXMgaXMgYmVjYXVzZSByZWxhdGlvbiBiZXR3ZWVuIGxvY2FsX2VyciBhbmQgZm4gaXMgbG9zdC4K CkxldCBtZSB0cnkgdG8gdGhpbmsgdGhpcyB0aHJvdWdoLgoKcnVsZTEgbWF0Y2hlcyBmdW5jdGlv bnMgdGhhdCBwcm9wYWdhdGUgZnJvbSBhIGxvY2FsIHZhcmlhYmxlIEBsb2NhbF9lcnIKdG8gcGFy YW1ldGVyIEBlcnJwLiAgSXQgdXNlcyB0aGUgX19fIGhhY2sgdG8gcmVsaWFibHkgdGFnIHRoZSBm dW5jdGlvbi4KTGF0ZXIgcnVsZXMgdGhhdCBzaG91bGQgb25seSBhcHBseSB0byB0aGVzZSBmdW5j dGlvbnMgY2FuIG1hdGNoIF9fXy4KClRoZXNlIGxhdGVyIHJ1bGVzIGVhY2ggcHJvdmlkZSBhIHBh cnQgb2YgdGhlIHRvdGFsIGVycm9yIHByb3BhZ2F0aW9uCnRyYW5zZm9ybWF0aW9uLiAgVGhleSBt dXN0IHRyYW5zZm9ybSBleGFjdGx5IHRoZSBAbG9jYWxfZXJyIGFuZCBAZXJycAptYXRjaGVkIGJ5 IHJ1bGUxIGluIGVhY2ggZnVuY3Rpb24uCgpZb3VyIHNvbHV0aW9uIGlzIHRvIGNvbnN0cmFpbiB0 aGUgaWRlbnRpZmllcnMsIGkuZS4KCiAgICBpZGVudGlmaWVyIHJ1bGUxLmZuLCBydWxlMS5sb2Nh bF9lcnI7CgpJZiBydWxlMSBtYXRjaGVzIG9ubHkgb25lIGZ1bmN0aW9uIG5hbWVkIGZvbygpLCBh bmQgd2l0aGluIHRoYXQgZm9vKCkKdGhlIGxvY2FsIHZhcmlhYmxlIEBsb2NhbF9lcnIgcnVsZTEg bWF0Y2hlcyBhY3R1YWxseSBiaW5kcyBhbGwKb2NjdXJlbmNlcyBvZiB0aGUgaWRlbnRpZmllciBA bG9jYWxfZXJyLCB0aGUgY29uc3RyYWludCBpcyByZWxpYWJsZS4KCkVsc2UsIHRoZSBjb25zdHJh aW50IG1heSBzdGlsbCBhY2NlcHQgb2NjdXJlbmNlcyBvZiBAbG9jYWxfZXJyIG5vdCBib3VuZAp0 byB0aGUgdmFyaWFibGUgbWF0Y2hlZCBieSBydWxlMS4KCkV4YW1wbGUgMToKCiAgICBpbnQgYmFy KEVycm9yICoqZXJycCkKICAgIHsKICAgICAgICBpZiAocHJlZCgpKSB7CiAgICAgICAgICAgIEVy cm9yICpsb2NhbF9lcnIgPSBOVUxMOwoKICAgICAgICAgICAgZXJyb3Jfc2V0ZygmbG9jYWxfZXJy LCAienp6dCIpOwogICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsK ICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBpbnQgbG9jYWxfZXJyID0gMDsKICAgICAgICAg ICAgcmV0dXJuIGxvY2FsX2VycjsKICAgICAgICB9CiAgICAgICAgcmV0dXJuIDA7CiAgICB9Cgpy dWxlMSBtYXRjaGVzIHRoZSBmaXJzdCBAbG9jYWxfZXJyIHZhcmlhYmxlLCBhbmQgbm90IHRoZSBz ZWNvbmQgb25lLiAgV2UKbXVzdCB0cmFuc2Zvcm0gb2NjdXJlbmNlcyBvZiB0aGUgZmlyc3Qgb25l LCBhbmQgbm90IG9jY3VyZW5jZXMgb2YgdGhlCnNlY29uZCBvbmUuICBXZSBkbyB0cmFuc2Zvcm0g YWxsOgoKICAgICBpbnQgYmFyKEVycm9yICoqZXJycCkKICAgICB7CiAgICArICAgIEVSUlBfQVVU T19QUk9QQUdBVEUoKTsKICAgICAgICAgaWYgKHByZWQoKSkgewogICAgLSAgICAgICAgRXJyb3Ig KmxvY2FsX2VyciA9IE5VTEw7CiAgICAtCiAgICAtICAgICAgICBlcnJvcl9zZXRnKCZsb2NhbF9l cnIsICJ6enp0Iik7CiAgICAtICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJy KTsKICAgICsgICAgICAgIGVycm9yX3NldGcoZXJycCwgInp6enQiKTsKICAgICAgICAgfSBlbHNl IHsKICAgICAgICAgICAgIGludCBsb2NhbF9lcnIgPSAwOwogICAgLSAgICAgICAgcmV0dXJuIGxv Y2FsX2VycjsKICAgICsgICAgICAgIHJldHVybiAqZXJycDsKICAgICAgICAgfQogICAgICAgICBy ZXR1cm4gMDsKICAgICB9CgpFeGFtcGxlIDI6CgogICAgaW50IGZvbyhFcnJvciAqKmVycnApCiAg ICB7CiAgICAgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7CgogICAgICAgIGVycm9yX3NldGco JmxvY2FsX2VyciwgInp6enQiKTsKICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxf ZXJyKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KCiAgICBpbnQgZm9vKEVycm9yICoqZXJycCkK ICAgIHsKICAgICAgICBFcnJvciAqZXJyID0gTlVMTDsKICAgICAgICBpbnQgbG9jYWxfZXJyID0g MDsKCiAgICAgICAgZXJyb3Jfc2V0ZygmbG9jYWxfZXJyLCAienp6dCIpOwogICAgICAgIGVycm9y X3Byb3BhZ2F0ZShlcnJwLCBlcnIpOwogICAgICAgIHJldHVybiBsb2NhbF9lcnI7CiAgICB9Cgpy dWxlMSBtYXRjaGVzIEBsb2NhbF9lcnIgaW4gdGhlIGZpcnN0IGZvbygpLCBhbmQgQGVyciBpbiB0 aGUgc2Vjb25kIG9uZS4KV2UgbXVzdCB0cmFuc2Zvcm0gQGxvY2FsX2VyciBpbiB0aGUgZmlyc3Qg b25lKCksIGFuZCBAZXJyIGluIHRoZSBzZWNvbmQKb25lLiAgV2UgZG8gdHJhbnNmb3JtIGJvdGgg aW4gYm90aDoKCiAgICAgaW50IGZvbyhFcnJvciAqKmVycnApCiAgICAgewogICAgLSAgICBFcnJv ciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICsgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwoKICAg IC0gICAgZXJyb3Jfc2V0ZygmbG9jYWxfZXJyLCAienp6dCIpOwogICAgLSAgICBlcnJvcl9wcm9w YWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKICAgICsgICAgZXJyb3Jfc2V0ZyhlcnJwLCAienp6dCIp OwogICAgICAgICByZXR1cm4gMDsKICAgICB9CgogICAgIGludCBmb28oRXJyb3IgKiplcnJwKQog ICAgIHsKICAgIC0gICAgRXJyb3IgKmVyciA9IE5VTEw7CiAgICArICAgIEVSUlBfQVVUT19QUk9Q QUdBVEUoKTsKICAgICAgICAgaW50IGxvY2FsX2VyciA9IDA7CgogICAgLSAgICBlcnJvcl9zZXRn KCZsb2NhbF9lcnIsICJ6enp0Iik7CiAgICAtICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIp OwogICAgLSAgICByZXR1cm4gbG9jYWxfZXJyOwogICAgKyAgICBlcnJvcl9zZXRnKGVycnAsICJ6 enp0Iik7CiAgICArICAgIHJldHVybiAqZXJycDsKICAgICB9CgpDb25zdHJhaW5pbmcgb25seSB0 aGUgdmFyaWFibGUgaWRlbnRpZmllciBsaWtlIEkgcHJvcG9zZWQgaXMgZXZlbiBsZXNzCnJlbGlh YmxlLCBhcyB5b3UgZGVtb25zdHJhdGVkOiB0aGVuIHRoZSBpc3N1ZSBpbiBleGFtcGxlIDIgZXhp c3RzIGV2ZW4KZm9yIGRpZmZlcmVudGx5IG5hbWVkIGZ1bmN0aW9ucy4KCkZvciBhIHJlbGlhYmxl IHNvbHV0aW9uLCB3ZSBjb3VsZCB1c2UgcGVyaGFwcyB1c2UgdGhlIF9fXyBoYWNrIGFnYWluOgpo YXZlIHJ1bGUxIHJlbmFtZSBAbG9jYWxfZXJyIGl0IGFjdHVhbGx5IG1hdGNoZXMuICBCdXQgdG8g YmUgaG9uZXN0LCBteQphcHBldGl0ZSBmb3IgYW5vdGhlciByb3VuZCBvZiB3cmVzdGxpbmcgd2l0 aCBDb2NjaW5lbGxlIGlzbid0IHdoYXQgaXQKdXNlZCB0byBiZS4KCkkgdGhpbmsgd2UgY2FuIGRv IHdpdGhvdXQgYXMgbG9uZyBhcyB3ZSdyZSB3ZWxsIGF3YXJlIG9mIHRoZSBzY3JpcHQncwpsaW1p dGF0aW9ucywgYW5kIHdlJ3JlIGNvbmZpZGVudCB3ZSBjYW4gZGV0ZWN0IHByb2JsZW1hdGljIGNh c2VzLgoKRGV0ZWN0aW5nIHRyYW5zZm9ybWF0aW9uIG9mIG11bHRpcGxlIGZ1bmN0aW9ucyB3aXRo IHRoZSBzYW1lIG5hbWUgc2hvdWxkCmJlIGVhc3kuCgpEZXRlY3Rpbmcgb2NjdXJlbmNlcyBvZiBp ZGVudGlmaWVycyBub3QgYm91bmQgYnkgYSBjZXJ0YWluIHZhcmlhYmxlCnNob3VsZCBiZSBmZWFz aWJsZTogd2UgZmluZCBhbmQgcmV2aWV3IGV2ZXJ5IHRyYW5zZm9ybWVkIGZ1bmN0aW9uIHRoYXQK ZG9lc24ndCBkZWNsYXJlIHRoZSB2YXJpYWJsZSBpbiBpdHMgb3V0ZXJtb3N0IHNjb3BlLgoKU2lu Y2UgIndlbGwgYXdhcmUiIGlzIGdvaW5nIHRvIGVyb2RlIHdpdGggdGltZSwgd2UgbWF5IHdhbnQg dG8gZGVsZXRlCnRoZSBzY3JpcHQgd2hlbiB3ZSdyZSBkb25lIGNvbnZlcnRpbmcuCgo+IFNvLCB1 bmRlcnN0YW5kaW5nIHRoYXQgdGhlcmUgbm8gc3VjaCBjYXNlcyBpbiB0aGUgd2hvbGUgdHJlZSwg YW5kIGV2ZW4KPiBpZiB5b3VyIHBhdGNoIHdvcmtzIGZhc3RlciBvbiB0aGUgd2hvbGUgdHJlZSwg SSBzdGlsbCBkb24ndCB3YW50IHRvCj4gZHJvcCBpbmhlcml0YW5jZSwgYmVjYXVzZSBpdCdzIGp1 c3QgYSBjb3JyZWN0IHRoaW5nIHRvIGRvLiBZZXMsIHdlJ3ZlCj4gYWRkZWQgX19fXyBoZWxwZXIu IEl0IGhlbHBzIHRvIGF2b2lkIHNvbWUgcHJvYmxlbXMuIFBhaXItaW5oZXJpdGFuY2UKPiBoZWxw cyB0byBhdm9pZCBhbm90aGVyIHByb2JsZW1zLiBJIHVuZGVyc3RhbmQsIHRoYXQgdGhlcmUgc3Rp bGwgbWF5Cj4gb3RoZXIsIG5vdC1jb3ZlcmVkIHByb2JsZW1zLCBidXQgYmV0dGVyIHRvIGJlIGFz IHNhZmUgYXMgcG9zc2libGUuIEFuZAo+IGluaGVyaXRhbmNlIGhlcmUgaXMgbmF0aXZlIGFuZCBj b3JyZWN0IHRoaW5nIHRvIGRvLCBldmVuIHdpdGggb3VyIF9fX18KPiBhZGRpdGlvbmFsIGhlbHBl ci4gV2hhdCBkbyB5b3UgdGhpbms/CgpJIHdvdWxkbid0IGNhbGwgaXQgY29ycmVjdC4gIEl0J3Mg c3RpbGwgdW5yZWxpYWJsZSwgYnV0IGxlc3Mgc28gdGhhbgp3aXRob3V0IHRoZSBmdW5jdGlvbiBu YW1lIGNvbnN0cmFpbnQuICBUaGF0IG1ha2VzIGl0IGxlc3Mgd3JvbmcuCgoxMDAlIHJlbGlhYmxl IHdvdWxkIGJlIG5pY2UsIGJ1dCBub3QgYXQgYW55IGNvc3QuICBTb21ldGhpbmcgd2UncmUKcmVh c29uYWJseSBjb25maWRlbnQgdG8gZ2V0IHJpZ2h0IHNob3VsZCBiZSBnb29kIGVub3VnaC4KClRv IGJlIGNvbmZpZGVudCwgd2UgbmVlZCB0byB1bmRlcnN0YW5kIHRoZSBzY3JpcHQncyBsaW1pdGF0 aW9ucywgYW5kIGhvdwp0byBjb21wZW5zYXRlIGZvciB0aGVtLiAgSSBmaWd1cmUgd2UgZG8gbm93 LiAgWW91IHRvbz8KClsuLi5dCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJv amVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hl bi1kZXZlbA== 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=1.1 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,YOU_INHERIT autolearn=no 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 1A6F4C4332B for ; Thu, 19 Mar 2020 10:46:59 +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 C8E1220724 for ; Thu, 19 Mar 2020 10:46:58 +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="VOuTj7Mk" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C8E1220724 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]:36016 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jEshW-00053W-0q for qemu-devel@archiver.kernel.org; Thu, 19 Mar 2020 06:46:58 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:59414) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jEsgT-0004Yy-EZ for qemu-devel@nongnu.org; Thu, 19 Mar 2020 06:45:55 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1jEsgR-0001lV-3o for qemu-devel@nongnu.org; Thu, 19 Mar 2020 06:45:53 -0400 Received: from us-smtp-delivery-74.mimecast.com ([216.205.24.74]:46040) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1jEsgQ-0001ky-Ux for qemu-devel@nongnu.org; Thu, 19 Mar 2020 06:45:51 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1584614750; 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=W97N0/BhMj5VQnTpNBcqX2gvUKJva35QxWpCfIclmK0=; b=VOuTj7Mkc/SJW09h+6ht0Nc0F1LVieRjZElk/i9C1bID0wZABy3ilhLQUmz9gDBNSzD6Cg 9+xdkND/uhQhMKIVf9vOAlUUeHwMbImaBBIG+3A98wMeUuZMr2wLULz09FoMiDxcQ83TII dllCnw3/+reS4SOsArMCQut97LNx7og= 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-327-WDmxZiu1NFOvlcB7L8FNZA-1; Thu, 19 Mar 2020 06:45:38 -0400 X-MC-Unique: WDmxZiu1NFOvlcB7L8FNZA-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 892C1801A06; Thu, 19 Mar 2020 10:45:36 +0000 (UTC) Received: from blackfin.pond.sub.org (ovpn-112-130.ams2.redhat.com [10.36.112.130]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 4076B9128E; Thu, 19 Mar 2020 10:45:30 +0000 (UTC) Received: by blackfin.pond.sub.org (Postfix, from userid 1000) id C40351138404; Thu, 19 Mar 2020 11:45:28 +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> <87blozex9v.fsf@dusky.pond.sub.org> <87o8swk8wc.fsf@dusky.pond.sub.org> <87wo7jqn8m.fsf@dusky.pond.sub.org> Date: Thu, 19 Mar 2020 11:45:28 +0100 In-Reply-To: (Vladimir Sementsov-Ogievskiy's message of "Tue, 17 Mar 2020 14:35:15 +0300") Message-ID: <87wo7gd3nb.fsf@dusky.pond.sub.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.3 (gnu/linux) MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain 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: 216.205.24.74 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , Stefano Stabellini , 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: > 17.03.2020 13:39, Markus Armbruster wrote: >> Vladimir Sementsov-Ogievskiy writes: >> >>> 16.03.2020 11:21, Markus Armbruster wrote: >>>> Vladimir Sementsov-Ogievskiy writes: >>>> >>>>> On 14.03.2020 00:54, Markus Armbruster wrote: >>>>>> 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 g= et this >>>>>>>>>> out now as is. >>>>>>>>>> >>>>>>>>>> Vladimir Sementsov-Ogievskiy writes: >> [...] >>>>>>>>>>> +@@ >>>>>>>>>>> + >>>>>>>>>>> + 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 o= n >>>>>> convincing Coccinelle to do it for me is not worthwhile; I can simpl= y >>>>>> 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 ga= ve >>>>>> above. >>>>> >>>>> Hmm, yes.. We can write "Warn several Error * definitions in _one_ >>>>> control flow (it's not so trivial to match _any_ case with several >>>>> definitions with coccinelle)" or something like this. >>>> >>>> Ha, "trivial" reminds me of a story. The math professor, after having >>>> spent a good chunk of his lecture developing a proof on the blackboad >>>> turns to the audience to explain why this little part doesn't require >>>> proof with the words familiar to any math student "and this is trivial= ." >>>> Pause, puzzled look... "Is it trivial?" Pause, storms out of the >>>> lecture hall. A minute or three pass. Professor comes back beaming, >>>> "it is trivial!", and proceeds with the proof. >>>> >>>> My point is: it might be trivial with Coccinelle once you know how to = do >>>> it. We don't. >>>> >>>> Suggest "(can't figure out how to match several definitions regardless >>>> of control flow)". >>> >>> Wrong too, because I can:) for example, chaining two rules, catching th= e >>> positions of definition and check that they are different.. Or, some >>> cheating with python script.. That's why I wrote "not trivial", >>> >>> So, most correct would be "(can't figure out how to simply match severa= l definitions regardless >>>> of control flow)". >> >> Works for me. >> >>> But again, coccinelle is for matching control flows, so its probably im= possible to match such thing.. >> [...] >>>>> OK, I almost OK with it, the only thing I doubt a bit is the followin= g: >>>>> >>>>> We want to keep rule1.local_err inheritance to keep connection with >>>>> local_err definition. >>>> >>>> Yes. >>>> >>>>> Interesting, when we have both rule1.fn and rule1.local_err inherited= , >>>>> do we inherit them in separate (i.e. all possible combinations of fn >>>>> and local_err symbols from rule1) or do we inherit a pair, i.e. only >>>>> fn/local_err pairs, found by rule1? If the latter is correct, that >>>>> with your script we loss this pair inheritance, and go to all possibl= e >>>>> combinations of fn and local_err from rule1, possibly adding some wro= ng >>>>> conversion (OK, you've checked that no such cases in current code tre= e). >>>> >>>> The chaining "identifier rule1.FOO" is by name. It's reliable only as >>>> long as there is exactly one instance of the name. >>>> >>>> We already discussed the case of the function name: if there are two >>>> instances of foo(), and rule1 matches only one of them, then we >>>> nevertheless apply the rules chained to rule1 to both. Because that c= an >>>> be wrong, you came up with the ___ trick, which chains reliably. >>>> >>>> The same issue exists with the variable name: if there are two instanc= es >>>> of @local_err, and rule1 matches only one of them, then we nevertheles= s >>>> apply the rules chained to rule1 to both. Can also be wrong. >>>> >>>> What are the conditions for "wrong"? >>>> >>>> Because the ___ chaining is reliable, we know rule1 matched the >>>> function, i.e. it has a parameter Error **errp, and it has a automatic >>>> variable Error *local_err =3D NULL. >>>> >>>> We're good as long as *all* identifiers @local_err in this function ar= e >>>> declared that way. This seems quite likely. It's not certain, though= . >>>> >>>> Since nested declarations of Error ** variables are rare, we can rely = on >>>> review to ensure we transform these functions correctly. >>>> >>>>> So, dropping inheritance in check-rules makes sence, as it may match >>>>> (and warn) more interesting cases. >>>>> >>>>> But for other rules, I'd prefere to be safer, and explictly inherit a= ll >>>>> actually inherited identifiers.. >>>> >>>> I still can't see what chaining by function name in addition to the __= _ >>>> chaining buys us. >>> >>> I'll check this thing soon. And resend today. > > Checked. > > Yes, it inherits pair of fn and local_err, and it definitely makes sense.= It more stable. > > Consider the following example: > > # cat a.c > int f1(Error **errp) > { > Error *err1 =3D NULL; > int err2 =3D 0; > > error_propagate(errp, err1); > > return err2; > } > > int f2(Error **errp) > { > Error *err2 =3D NULL; > int err1 =3D 0; > > error_propagate(errp, err2); > > return err1; > } > > > My script works correct and produces this change: > --- a.c > +++ /tmp/cocci-output-1753-10842a-a.c > @@ -1,19 +1,15 @@ > int f1(Error **errp) > { > - Error *err1 =3D NULL; > + ERRP_AUTO_PROPAGATE(); > int err2 =3D 0; > > - error_propagate(errp, err1); > - > return err2; > } > > int f2(Error **errp) > { > - Error *err2 =3D NULL; > + ERRP_AUTO_PROPAGATE(); > int err1 =3D 0; > > - error_propagate(errp, err2); > - > return err1; > } > > > But yours script is caught: > --- a.c > +++ /tmp/cocci-output-1814-b9b681-a.c > @@ -1,19 +1,15 @@ > int f1(Error **errp) > { > - Error *err1 =3D NULL; > + ERRP_AUTO_PROPAGATE(); > int err2 =3D 0; > > - error_propagate(errp, err1); > - > - return err2; > + return *errp; > } > > int f2(Error **errp) > { > - Error *err2 =3D NULL; > + ERRP_AUTO_PROPAGATE(); > int err1 =3D 0; > > - error_propagate(errp, err2); > - > - return err1; > + return *errp; > } > > > - see, it touches err1, which is unrelated to Error in f2. Hmm, > interesting that it doesn't want to convert err1 declaration:) > > - this is because relation between local_err and fn is lost. Let me try to think this through. rule1 matches functions that propagate from a local variable @local_err to parameter @errp. It uses the ___ hack to reliably tag the function. Later rules that should only apply to these functions can match ___. These later rules each provide a part of the total error propagation transformation. They must transform exactly the @local_err and @errp matched by rule1 in each function. Your solution is to constrain the identifiers, i.e. identifier rule1.fn, rule1.local_err; If rule1 matches only one function named foo(), and within that foo() the local variable @local_err rule1 matches actually binds all occurences of the identifier @local_err, the constraint is reliable. Else, the constraint may still accept occurences of @local_err not bound to the variable matched by rule1. Example 1: int bar(Error **errp) { if (pred()) { Error *local_err =3D NULL; error_setg(&local_err, "zzzt"); error_propagate(errp, local_err); } else { int local_err =3D 0; return local_err; } return 0; } rule1 matches the first @local_err variable, and not the second one. We must transform occurences of the first one, and not occurences of the second one. We do transform all: int bar(Error **errp) { + ERRP_AUTO_PROPAGATE(); if (pred()) { - Error *local_err =3D NULL; - - error_setg(&local_err, "zzzt"); - error_propagate(errp, local_err); + error_setg(errp, "zzzt"); } else { int local_err =3D 0; - return local_err; + return *errp; } return 0; } Example 2: int foo(Error **errp) { Error *local_err =3D NULL; error_setg(&local_err, "zzzt"); error_propagate(errp, local_err); return 0; } int foo(Error **errp) { Error *err =3D NULL; int local_err =3D 0; error_setg(&local_err, "zzzt"); error_propagate(errp, err); return local_err; } rule1 matches @local_err in the first foo(), and @err in the second one. We must transform @local_err in the first one(), and @err in the second one. We do transform both in both: int foo(Error **errp) { - Error *local_err =3D NULL; + ERRP_AUTO_PROPAGATE(); - error_setg(&local_err, "zzzt"); - error_propagate(errp, local_err); + error_setg(errp, "zzzt"); return 0; } int foo(Error **errp) { - Error *err =3D NULL; + ERRP_AUTO_PROPAGATE(); int local_err =3D 0; - error_setg(&local_err, "zzzt"); - error_propagate(errp, err); - return local_err; + error_setg(errp, "zzzt"); + return *errp; } Constraining only the variable identifier like I proposed is even less reliable, as you demonstrated: then the issue in example 2 exists even for differently named functions. For a reliable solution, we could use perhaps use the ___ hack again: have rule1 rename @local_err it actually matches. But to be honest, my appetite for another round of wrestling with Coccinelle isn't what it used to be. I think we can do without as long as we're well aware of the script's limitations, and we're confident we can detect problematic cases. Detecting transformation of multiple functions with the same name should be easy. Detecting occurences of identifiers not bound by a certain variable should be feasible: we find and review every transformed function that doesn't declare the variable in its outermost scope. Since "well aware" is going to erode with time, we may want to delete the script when we're done converting. > So, understanding that there no such cases in the whole tree, and even > if your patch works faster on the whole tree, I still don't want to > drop inheritance, because it's just a correct thing to do. Yes, we've > added ____ helper. It helps to avoid some problems. Pair-inheritance > helps to avoid another problems. I understand, that there still may > other, not-covered problems, but better to be as safe as possible. And > inheritance here is native and correct thing to do, even with our ____ > additional helper. What do you think? I wouldn't call it correct. It's still unreliable, but less so than without the function name constraint. That makes it less wrong. 100% reliable would be nice, but not at any cost. Something we're reasonably confident to get right should be good enough. To be confident, we need to understand the script's limitations, and how to compensate for them. I figure we do now. You too? [...]