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=-7.3 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, HK_RANDOM_FROM,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE, SPF_PASS,USER_AGENT_SANE_1 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 F2C6CC433DF for ; Wed, 10 Jun 2020 14:22:03 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 D287E2067B for ; Wed, 10 Jun 2020 14:22:03 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D287E2067B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=amd-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 8058989B67; Wed, 10 Jun 2020 14:22:03 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id F3D3E89B67; Wed, 10 Jun 2020 14:22:02 +0000 (UTC) IronPort-SDR: 2BSiRpH+SklxWdy78cRGjm97kFpYYmCrrwZRmP3phftxHcnGZjfJspim3WvU21KE5ALPk4hOEV EhOVS/yQswVA== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:22:02 -0700 IronPort-SDR: ZXI7uPl/+gFtBOCO1ezzY/adZkhBrl05LWKKuG3izz+Rz/KzHBkHO1DHUyRtRF1+HN/H5NIQyj NDLjlxGdWGKg== X-IronPort-AV: E=Sophos;i="5.73,496,1583222400"; d="scan'208";a="418759078" Received: from unknown (HELO [10.214.244.237]) ([10.214.244.237]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:21:56 -0700 Subject: Re: [Intel-gfx] [PATCH 03/18] dma-fence: basic lockdep annotations To: Daniel Vetter , DRI Development References: <20200604081224.863494-1-daniel.vetter@ffwll.ch> <20200604081224.863494-4-daniel.vetter@ffwll.ch> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: Date: Wed, 10 Jun 2020 15:21:53 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.7.0 MIME-Version: 1.0 In-Reply-To: <20200604081224.863494-4-daniel.vetter@ffwll.ch> Content-Language: en-US X-BeenThere: amd-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-rdma@vger.kernel.org, Intel Graphics Development , LKML , amd-gfx@lists.freedesktop.org, Chris Wilson , linaro-mm-sig@lists.linaro.org, Thomas Hellstrom , Daniel Vetter , Mika Kuoppala , =?UTF-8?Q?Christian_K=c3=b6nig?= , linux-media@vger.kernel.org Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: amd-gfx-bounces@lists.freedesktop.org Sender: "amd-gfx" Ck9uIDA0LzA2LzIwMjAgMDk6MTIsIERhbmllbCBWZXR0ZXIgd3JvdGU6Cj4gRGVzaWduIGlzIHNp bWlsYXIgdG8gdGhlIGxvY2tkZXAgYW5ub3RhdGlvbnMgZm9yIHdvcmtlcnMsIGJ1dCB3aXRoCj4g c29tZSB0d2lzdHM6Cj4gCj4gLSBXZSB1c2UgYSByZWFkLWxvY2sgZm9yIHRoZSBleGVjdXRpb24v d29ya2VyL2NvbXBsZXRpb24gc2lkZSwgc28gdGhhdAo+ICAgIHRoaXMgZXhwbGljaXQgYW5ub3Rh dGlvbiBjYW4gYmUgbW9yZSBsaWJlcmFsbHkgc3ByaW5rbGVkIGFyb3VuZC4KPiAgICBXaXRoIHJl YWQgbG9ja3MgbG9ja2RlcCBpc24ndCBnb2luZyB0byBjb21wbGFpbiBpZiB0aGUgcmVhZC1zaWRl Cj4gICAgaXNuJ3QgbmVzdGVkIHRoZSBzYW1lIHdheSB1bmRlciBhbGwgY2lyY3Vtc3RhbmNlcywg c28gQUJCQSBkZWFkbG9ja3MKPiAgICBhcmUgb2suIFdoaWNoIHRoZXkgYXJlLCBzaW5jZSB0aGlz IGlzIGFuIGFubm90YXRpb24gb25seS4KPiAKPiAtIFdlJ3JlIHVzaW5nIG5vbi1yZWN1cnNpdmUg bG9ja2RlcCByZWFkIGxvY2sgbW9kZSwgc2luY2UgaW4gcmVjdXJzaXZlCj4gICAgcmVhZCBsb2Nr IG1vZGUgbG9ja2RlcCBkb2VzIG5vdCBjYXRjaCByZWFkIHNpZGUgaGF6YXJkcy4gQW5kIHdlCj4g ICAgX3ZlcnlfIG11Y2ggd2FudCByZWFkIHNpZGUgaGF6YXJkcyB0byBiZSBjYXVnaHQuIEZvciBm dWxsIGRldGFpbHMgb2YKPiAgICB0aGlzIGxpbWl0YXRpb24gc2VlCj4gCj4gICAgY29tbWl0IGU5 MTQ5ODU4OTc0NjA2NWUzYWU5NWQ5YTAwYjA2OGU1MjVlZWMzNGYKPiAgICBBdXRob3I6IFBldGVy IFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFkLm9yZz4KPiAgICBEYXRlOiAgIFdlZCBBdWcgMjMg MTM6MTM6MTEgMjAxNyArMDIwMAo+IAo+ICAgICAgICBsb2NraW5nL2xvY2tkZXAvc2VsZnRlc3Rz OiBBZGQgbWl4ZWQgcmVhZC13cml0ZSBBQkJBIHRlc3RzCj4gCj4gLSBUbyBhbGxvdyBuZXN0aW5n IG9mIHRoZSByZWFkLXNpZGUgZXhwbGljaXQgYW5ub3RhdGlvbnMgd2UgZXhwbGljaXRseQo+ICAg IGtlZXAgdHJhY2sgb2YgdGhlIG5lc3RpbmcuIGxvY2tfaXNfaGVsZCgpIGFsbG93cyB1cyB0byBk byB0aGF0Lgo+IAo+IC0gVGhlIHdhaXQtc2lkZSBhbm5vdGF0aW9uIGlzIGEgd3JpdGUgbG9jaywg YW5kIGVudGlyZWx5IGRvbmUgd2l0aGluCj4gICAgZG1hX2ZlbmNlX3dhaXQoKSBmb3IgZXZlcnlv bmUgYnkgZGVmYXVsdC4KPiAKPiAtIFRvIGJlIGFibGUgdG8gZnJlZWx5IGFubm90YXRlIGhlbHBl ciBmdW5jdGlvbnMgSSB3YW50IHRvIG1ha2UgaXQgb2sKPiAgICB0byBjYWxsIGRtYV9mZW5jZV9i ZWdpbi9lbmRfc2lnbmFsbGluZyBmcm9tIHNvZnQvaGFyZGlycSBjb250ZXh0Lgo+ICAgIEZpcnN0 IGF0dGVtcHQgd2FzIHVzaW5nIHRoZSBoYXJkaXJxIGxvY2tpbmcgY29udGV4dCBmb3IgdGhlIHdy aXRlCj4gICAgc2lkZSBpbiBsb2NrZGVwLCBidXQgdGhpcyBmb3JjZXMgYWxsIG5vcm1hbCBzcGlu bG9ja3MgbmVzdGVkIHdpdGhpbgo+ICAgIGRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZyB0 byBiZSBzcGlubG9ja3MuIFRoYXQgYm9sbG9ja3MuCj4gCj4gICAgVGhlIGFwcHJvYWNoIG5vdyBp cyB0byBzaW1wbGUgY2hlY2sgaW5fYXRvbWljKCksIGFuZCBmb3IgdGhlc2UgY2FzZXMKPiAgICBl bnRpcmVseSByZWx5IG9uIHRoZSBtaWdodF9zbGVlcCgpIGNoZWNrIGluIGRtYV9mZW5jZV93YWl0 KCkuIFRoYXQKPiAgICB3aWxsIGNhdGNoIGFueSB3cm9uZyBuZXN0aW5nIGFnYWluc3Qgc3Bpbmxv Y2tzIGZyb20gc29mdC9oYXJkaXJxCj4gICAgY29udGV4dHMuCj4gCj4gVGhlIGlkZWEgaGVyZSBp cyB0aGF0IGV2ZXJ5IGNvZGUgcGF0aCB0aGF0J3MgY3JpdGljYWwgZm9yIGV2ZW50dWFsbHkKPiBz aWduYWxsaW5nIGEgZG1hX2ZlbmNlIHNob3VsZCBiZSBhbm5vdGF0ZWQgd2l0aAo+IGRtYV9mZW5j ZV9iZWdpbi9lbmRfc2lnbmFsbGluZy4gVGhlIGFubm90YXRpb24gaWRlYWxseSBzdGFydHMgcmln aHQKPiBhZnRlciBhIGRtYV9mZW5jZSBpcyBwdWJsaXNoZWQgKGFkZGVkIHRvIGEgZG1hX3Jlc3Ys IGV4cG9zZWQgYXMgYQo+IHN5bmNfZmlsZSBmZCwgYXR0YWNoZWQgdG8gYSBkcm1fc3luY29iaiBm ZCwgb3IgYW55dGhpbmcgZWxzZSB0aGF0Cj4gbWFrZXMgdGhlIGRtYV9mZW5jZSB2aXNpYmxlIHRv IG90aGVyIGtlcm5lbCB0aHJlYWRzKSwgdXAgdG8gYW5kCj4gaW5jbHVkaW5nIHRoZSBkbWFfZmVu Y2Vfd2FpdCgpLiBFeGFtcGxlcyBhcmUgaXJxIGhhbmRsZXJzLCB0aGUKPiBzY2hlZHVsZXIgcnQg dGhyZWFkcywgdGhlIHRhaWwgb2YgZXhlY2J1ZiAoYWZ0ZXIgdGhlIGNvcnJlc3BvbmRpbmcKPiBm ZW5jZXMgYXJlIHZpc2libGUpLCBhbnkgd29ya2VycyB0aGF0IGVuZCB1cCBzaWduYWxsaW5nIGRt YV9mZW5jZXMgYW5kCj4gcmVhbGx5IGFueXRoaW5nIGVsc2UuIE5vdCBhbm5vdGF0ZWQgc2hvdWxk IGJlIGNvZGUgcGF0aHMgdGhhdCBvbmx5Cj4gY29tcGxldGUgZmVuY2VzIG9wcG9ydHVuaXN0aWNh bGx5IGFzIHRoZSBncHUgcHJvZ3Jlc3NlcywgbGlrZSBlLmcuCj4gc2hyaW5rZXIvZXZpY3Rpb24g Y29kZS4KPiAKPiBUaGUgbWFpbiBjbGFzcyBvZiBkZWFkbG9ja3MgdGhpcyBpcyBzdXBwb3NlZCB0 byBjYXRjaCBhcmU6Cj4gCj4gVGhyZWFkIEE6Cj4gCj4gCW11dGV4X2xvY2soQSk7Cj4gCW11dGV4 X3VubG9jayhBKTsKPiAKPiAJZG1hX2ZlbmNlX3NpZ25hbCgpOwo+IAo+IFRocmVhZCBCOgo+IAo+ IAltdXRleF9sb2NrKEEpOwo+IAlkbWFfZmVuY2Vfd2FpdCgpOwo+IAltdXRleF91bmxvY2soQSk7 Cj4gCj4gVGhyZWFkIEIgaXMgYmxvY2tlZCBvbiBBIHNpZ25hbGxpbmcgdGhlIGZlbmNlLCBidXQg QSBuZXZlciBnZXRzIGFyb3VuZAo+IHRvIHRoYXQgYmVjYXVzZSBpdCBjYW5ub3QgYWNxdWlyZSB0 aGUgbG9jayBBLgo+IAo+IE5vdGUgdGhhdCBkbWFfZmVuY2Vfd2FpdCgpIGlzIGFsbG93ZWQgdG8g YmUgbmVzdGVkIHdpdGhpbgo+IGRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZyBzZWN0aW9u cy4gVG8gYWxsb3cgdGhpcyB0byBoYXBwZW4gdGhlCj4gcmVhZCBsb2NrIG5lZWRzIHRvIGJlIHVw Z3JhZGVkIHRvIGEgd3JpdGUgbG9jaywgd2hpY2ggbWVhbnMgdGhhdCBhbnkKPiBvdGhlciBsb2Nr IGlzIGFjcXVpcmVkIGJldHdlZW4gdGhlIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkgY2Fs bCBhbmQKPiB0aGUgY2FsbCB0byBkbWFfZmVuY2Vfd2FpdCgpLCBhbmQgc3RpbGwgaGVsZCwgdGhp cyB3aWxsIHJlc3VsdCBpbiBhbgo+IGltbWVkaWF0ZSBsb2NrZGVwIGNvbXBsYWludC4gVGhlIG9u bHkgb3RoZXIgb3B0aW9uIHdvdWxkIGJlIHRvIG5vdAo+IGFubm90YXRlIHN1Y2ggY2FsbHMsIGRl ZmVhdGluZyB0aGUgcG9pbnQuIFRoZXJlZm9yZSB0aGVzZSBhbm5vdGF0aW9ucwo+IGNhbm5vdCBi ZSBzcHJpbmtsZWQgb3ZlciB0aGUgY29kZSBlbnRpcmVseSBtaW5kbGVzcyB0byBhdm9pZCBmYWxz ZQo+IHBvc2l0aXZlcy4KPiAKPiB2MjogaGFuZGxlIHNvZnQvaGFyZGlycSBjdHggYmV0dGVyIGFn YWluc3Qgd3JpdGUgc2lkZSBhbmQgZG9udCBmb3JnZXQKPiBFWFBPUlRfU1lNQk9MLCBkcml2ZXJz IGNhbid0IHVzZSB0aGlzIG90aGVyd2lzZS4KPiAKPiB2MzogS2VybmVsZG9jLgo+IAo+IHY0OiBT b21lIHNwZWxsaW5nIGZpeGVzIGZyb20gTWlrYQo+IAo+IENjOiBNaWthIEt1b3BwYWxhIDxtaWth Lmt1b3BwYWxhQGludGVsLmNvbT4KPiBDYzogVGhvbWFzIEhlbGxzdHJvbSA8dGhvbWFzLmhlbGxz dHJvbUBpbnRlbC5jb20+Cj4gQ2M6IGxpbnV4LW1lZGlhQHZnZXIua2VybmVsLm9yZwo+IENjOiBs aW5hcm8tbW0tc2lnQGxpc3RzLmxpbmFyby5vcmcKPiBDYzogbGludXgtcmRtYUB2Z2VyLmtlcm5l bC5vcmcKPiBDYzogYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBDYzogaW50ZWwtZ2Z4 QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IENjOiBDaHJpcyBXaWxzb24gPGNocmlzQGNocmlzLXdp bHNvbi5jby51az4KPiBDYzogTWFhcnRlbiBMYW5raG9yc3QgPG1hYXJ0ZW4ubGFua2hvcnN0QGxp bnV4LmludGVsLmNvbT4KPiBDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0Bh bWQuY29tPgo+IFNpZ25lZC1vZmYtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50 ZWwuY29tPgo+IC0tLQo+ICAgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IHwg IDEyICstCj4gICBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMgICAgICAgICAgfCAxNjEgKysr KysrKysrKysrKysrKysrKysrKysrKysrCj4gICBpbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oICAg ICAgICAgICAgfCAgMTIgKysKPiAgIDMgZmlsZXMgY2hhbmdlZCwgMTgyIGluc2VydGlvbnMoKyks IDMgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFw aS9kbWEtYnVmLnJzdCBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdAo+IGlu ZGV4IDYzZGVjNzZkMWQ4ZC4uMDVkODU2MTMxMTQwIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRp b24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFw aS9kbWEtYnVmLnJzdAo+IEBAIC0xMDAsMTEgKzEwMCwxMSBAQCBDUFUgQWNjZXNzIHRvIERNQSBC dWZmZXIgT2JqZWN0cwo+ICAgLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVm LmMKPiAgICAgIDpkb2M6IGNwdSBhY2Nlc3MKPiAgIAo+IC1GZW5jZSBQb2xsIFN1cHBvcnQKPiAt fn5+fn5+fn5+fn5+fn5+fn5+Cj4gK0ltcGxpY2l0IEZlbmNlIFBvbGwgU3VwcG9ydAo+ICt+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KPiAgIAo+ICAgLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMv ZG1hLWJ1Zi9kbWEtYnVmLmMKPiAtICAgOmRvYzogZmVuY2UgcG9sbGluZwo+ICsgICA6ZG9jOiBp bXBsaWNpdCBmZW5jZSBwb2xsaW5nCj4gICAKPiAgIEtlcm5lbCBGdW5jdGlvbnMgYW5kIFN0cnVj dHVyZXMgUmVmZXJlbmNlCj4gICB+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fgo+IEBAIC0xMzMsNiArMTMzLDEyIEBAIERNQSBGZW5jZXMKPiAgIC4uIGtlcm5lbC1kb2M6 OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKPiAgICAgIDpkb2M6IERNQSBmZW5jZXMgb3Zl cnZpZXcKPiAgIAo+ICtETUEgRmVuY2UgU2lnbmFsbGluZyBBbm5vdGF0aW9ucwo+ICt+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgo+ICsKPiArLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMv ZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+ICsgICA6ZG9jOiBmZW5jZSBzaWduYWxsaW5nIGFubm90YXRp b24KPiArCj4gICBETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKPiAgIH5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fgo+ICAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9k bWEtZmVuY2UuYyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+IGluZGV4IDY1NmU5YWMy ZDAyOC4uMDAwNWJjMDAyNTI5IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVu Y2UuYwo+ICsrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+IEBAIC0xMTAsNiArMTEw LDE2MCBAQCB1NjQgZG1hX2ZlbmNlX2NvbnRleHRfYWxsb2ModW5zaWduZWQgbnVtKQo+ICAgfQo+ ICAgRVhQT1JUX1NZTUJPTChkbWFfZmVuY2VfY29udGV4dF9hbGxvYyk7Cj4gICAKPiArLyoqCj4g KyAqIERPQzogZmVuY2Ugc2lnbmFsbGluZyBhbm5vdGF0aW9uCj4gKyAqCj4gKyAqIFByb3Zpbmcg Y29ycmVjdG5lc3Mgb2YgYWxsIHRoZSBrZXJuZWwgY29kZSBhcm91bmQgJmRtYV9mZW5jZSB0aHJv dWdoIGNvZGUKPiArICogcmV2aWV3IGFuZCB0ZXN0aW5nIGlzIHRyaWNreSBmb3IgYSBmZXcgcmVh c29uczoKPiArICoKPiArICogKiBJdCBpcyBhIGNyb3NzLWRyaXZlciBjb250cmFjdCwgYW5kIHRo ZXJlZm9yZSBhbGwgZHJpdmVycyBtdXN0IGZvbGxvdyB0aGUKPiArICogICBzYW1lIHJ1bGVzIGZv ciBsb2NrIG5lc3Rpbmcgb3JkZXIsIGNhbGxpbmcgY29udGV4dHMgZm9yIHZhcmlvdXMgZnVuY3Rp b25zCj4gKyAqICAgYW5kIGFueXRoaW5nIGVsc2Ugc2lnbmlmaWNhbnQgZm9yIGluLWtlcm5lbCBp bnRlcmZhY2VzLiBCdXQgaXQgaXMgYWxzbwo+ICsgKiAgIGltcG9zc2libGUgdG8gdGVzdCBhbGwg ZHJpdmVycyBpbiBhIHNpbmdsZSBtYWNoaW5lLCBoZW5jZSBicnV0ZS1mb3JjZSBOIHZzLgo+ICsg KiAgIE4gdGVzdGluZyBvZiBhbGwgY29tYmluYXRpb25zIGlzIGltcG9zc2libGUuIEV2ZW4ganVz dCBsaW1pdGluZyB0byB0aGUKPiArICogICBwb3NzaWJsZSBjb21iaW5hdGlvbnMgaXMgaW5mZWFz aWJsZS4KPiArICoKPiArICogKiBUaGVyZSBpcyBhbiBlbm9ybW91cyBhbW91bnQgb2YgZHJpdmVy IGNvZGUgaW52b2x2ZWQuIEZvciByZW5kZXIgZHJpdmVycwo+ICsgKiAgIHRoZXJlJ3MgdGhlIHRh aWwgb2YgY29tbWFuZCBzdWJtaXNzaW9uLCBhZnRlciBmZW5jZXMgYXJlIHB1Ymxpc2hlZCwKPiAr ICogICBzY2hlZHVsZXIgY29kZSwgaW50ZXJydXB0IGFuZCB3b3JrZXJzIHRvIHByb2Nlc3Mgam9i IGNvbXBsZXRpb24sCj4gKyAqICAgYW5kIHRpbWVvdXQsIGdwdSByZXNldCBhbmQgZ3B1IGhhbmcg cmVjb3ZlcnkgY29kZS4gUGx1cyBmb3IgaW50ZWdyYXRpb24KPiArICogICB3aXRoIGNvcmUgbW0g d2l0aCBoYXZlICZtbXVfbm90aWZpZXIsIHJlc3BlY3RpdmVseSAmbW11X2ludGVydmFsX25vdGlm aWVyLAo+ICsgKiAgIGFuZCAmc2hyaW5rZXIuIEZvciBtb2Rlc2V0dGluZyBkcml2ZXJzIHRoZXJl J3MgdGhlIGNvbW1pdCB0YWlsIGZ1bmN0aW9ucwo+ICsgKiAgIGJldHdlZW4gd2hlbiBmZW5jZXMg Zm9yIGFuIGF0b21pYyBtb2Rlc2V0IGFyZSBwdWJsaXNoZWQsIGFuZCB3aGVuIHRoZQo+ICsgKiAg IGNvcnJlc3BvbmRpbmcgdmJsYW5rIGNvbXBsZXRlcywgaW5jbHVkaW5nIGFueSBpbnRlcnJ1cHQg cHJvY2Vzc2luZyBhbmQKPiArICogICByZWxhdGVkIHdvcmtlcnMuIEF1ZGl0aW5nIGFsbCB0aGF0 IGNvZGUsIGFjcm9zcyBhbGwgZHJpdmVycywgaXMgbm90Cj4gKyAqICAgZmVhc2libGUuCj4gKyAq Cj4gKyAqICogRHVlIHRvIGhvdyBtYW55IG90aGVyIHN1YnN5c3RlbXMgYXJlIGludm9sdmVkIGFu ZCB0aGUgbG9ja2luZyBoaWVyYXJjaGllcwo+ICsgKiAgIHRoaXMgcHVsbHMgaW4gdGhlcmUgaXMg ZXh0cmVtZWx5IHRoaW4gd2lnZ2xlLXJvb20gZm9yIGRyaXZlci1zcGVjaWZpYwo+ICsgKiAgIGRp ZmZlcmVuY2VzLiAmZG1hX2ZlbmNlIGludGVyYWN0cyB3aXRoIGFsbW9zdCBhbGwgb2YgdGhlIGNv cmUgbWVtb3J5Cj4gKyAqICAgaGFuZGxpbmcgdGhyb3VnaCBwYWdlIGZhdWx0IGhhbmRsZXJzIHZp YSAmZG1hX3Jlc3YsIGRtYV9yZXN2X2xvY2soKSBhbmQKPiArICogICBkbWFfcmVzdl91bmxvY2so KS4gT24gdGhlIG90aGVyIHNpZGUgaXQgYWxzbyBpbnRlcmFjdHMgdGhyb3VnaCBhbGwKPiArICog ICBhbGxvY2F0aW9uIHNpdGVzIHRocm91Z2ggJm1tdV9ub3RpZmllciBhbmQgJnNocmlua2VyLgo+ ICsgKgo+ICsgKiBGdXJ0aGVybW9yZSBsb2NrZGVwIGRvZXMgbm90IGhhbmRsZSBjcm9zcy1yZWxl YXNlIGRlcGVuZGVuY2llcywgd2hpY2ggbWVhbnMKPiArICogYW55IGRlYWRsb2NrcyBiZXR3ZWVu IGRtYV9mZW5jZV93YWl0KCkgYW5kIGRtYV9mZW5jZV9zaWduYWwoKSBjYW4ndCBiZSBjYXVnaHQK PiArICogYXQgcnVudGltZSB3aXRoIHNvbWUgcXVpY2sgdGVzdGluZy4gVGhlIHNpbXBsZXN0IGV4 YW1wbGUgaXMgb25lIHRocmVhZAo+ICsgKiB3YWl0aW5nIG9uIGEgJmRtYV9mZW5jZSB3aGlsZSBo b2xkaW5nIGEgbG9jazo6Cj4gKyAqCj4gKyAqICAgICBsb2NrKEEpOwo+ICsgKiAgICAgZG1hX2Zl bmNlX3dhaXQoQik7Cj4gKyAqICAgICB1bmxvY2soQSk7Cj4gKyAqCj4gKyAqIHdoaWxlIHRoZSBv dGhlciB0aHJlYWQgaXMgc3R1Y2sgdHJ5aW5nIHRvIGFjcXVpcmUgdGhlIHNhbWUgbG9jaywgd2hp Y2gKPiArICogcHJldmVudHMgaXQgZnJvbSBzaWduYWxsaW5nIHRoZSBmZW5jZSB0aGUgcHJldmlv dXMgdGhyZWFkIGlzIHN0dWNrIHdhaXRpbmcKPiArICogb246Ogo+ICsgKgo+ICsgKiAgICAgbG9j ayhBKTsKPiArICogICAgIHVubG9jayhBKTsKPiArICogICAgIGRtYV9mZW5jZV9zaWduYWwoQik7 Cj4gKyAqCj4gKyAqIEJ5IG1hbnVhbGx5IGFubm90YXRpbmcgYWxsIGNvZGUgcmVsZXZhbnQgdG8g c2lnbmFsbGluZyBhICZkbWFfZmVuY2Ugd2UgY2FuCj4gKyAqIHRlYWNoIGxvY2tkZXAgYWJvdXQg dGhlc2UgZGVwZW5kZW5jaWVzLCB3aGljaCBhbHNvIGhlbHBzIHdpdGggdGhlIHZhbGlkYXRpb24K PiArICogaGVhZGFjaGUgc2luY2Ugbm93IGxvY2tkZXAgY2FuIGNoZWNrIGFsbCB0aGUgcnVsZXMg Zm9yIHVzOjoKPiArICoKPiArICogICAgY29va2llID0gZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxp bmcoKTsKPiArICogICAgbG9jayhBKTsKPiArICogICAgdW5sb2NrKEEpOwo+ICsgKiAgICBkbWFf ZmVuY2Vfc2lnbmFsKEIpOwo+ICsgKiAgICBkbWFfZmVuY2VfZW5kX3NpZ25hbGxpbmcoY29va2ll KTsKPiArICoKPiArICogRm9yIHVzaW5nIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkgYW5k IGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpIHRvCj4gKyAqIGFubm90YXRlIGNyaXRpY2FsIHNl Y3Rpb25zIHRoZSBmb2xsb3dpbmcgcnVsZXMgbmVlZCB0byBiZSBvYnNlcnZlZDoKPiArICoKPiAr ICogKiBBbGwgY29kZSBuZWNlc3NhcnkgdG8gY29tcGxldGUgYSAmZG1hX2ZlbmNlIG11c3QgYmUg YW5ub3RhdGVkLCBmcm9tIHRoZQo+ICsgKiAgIHBvaW50IHdoZXJlIGEgZmVuY2UgaXMgYWNjZXNz aWJsZSB0byBvdGhlciB0aHJlYWRzLCB0byB0aGUgcG9pbnQgd2hlcmUKPiArICogICBkbWFfZmVu Y2Vfc2lnbmFsKCkgaXMgY2FsbGVkLiBVbi1hbm5vdGF0ZWQgY29kZSBjYW4gY29udGFpbiBkZWFk bG9jayBpc3N1ZXMsCj4gKyAqICAgYW5kIGR1ZSB0byB0aGUgdmVyeSBzdHJpY3QgcnVsZXMgYW5k IG1hbnkgY29ybmVyIGNhc2VzIGl0IGlzIGluZmVhc2libGUgdG8KPiArICogICBjYXRjaCB0aGVz ZSBqdXN0IHdpdGggcmV2aWV3IG9yIG5vcm1hbCBzdHJlc3MgdGVzdGluZy4KPiArICoKPiArICog KiAmc3RydWN0IGRtYV9yZXN2IGRlc2VydmVzIGEgc3BlY2lhbCBub3RlLCBzaW5jZSB0aGUgcmVh ZGVycyBhcmUgb25seQo+ICsgKiAgIHByb3RlY3RlZCBieSByY3UuIFRoaXMgbWVhbnMgdGhlIHNp Z25hbGxpbmcgY3JpdGljYWwgc2VjdGlvbiBzdGFydHMgYXMgc29vbgo+ICsgKiAgIGFzIHRoZSBu ZXcgZmVuY2VzIGFyZSBpbnN0YWxsZWQsIGV2ZW4gYmVmb3JlIGRtYV9yZXN2X3VubG9jaygpIGlz IGNhbGxlZC4KPiArICoKPiArICogKiBUaGUgb25seSBleGNlcHRpb24gYXJlIGZhc3QgcGF0aHMg YW5kIG9wcG9ydHVuaXN0aWMgc2lnbmFsbGluZyBjb2RlLCB3aGljaAo+ICsgKiAgIGNhbGxzIGRt YV9mZW5jZV9zaWduYWwoKSBwdXJlbHkgYXMgYW4gb3B0aW1pemF0aW9uLCBidXQgaXMgbm90IHJl cXVpcmVkIHRvCj4gKyAqICAgZ3VhcmFudGVlIGNvbXBsZXRpb24gb2YgYSAmZG1hX2ZlbmNlLiBU aGUgdXN1YWwgZXhhbXBsZSBpcyBhIHdhaXQgSU9DVEwKPiArICogICB3aGljaCBjYWxscyBkbWFf ZmVuY2Vfc2lnbmFsKCksIHdoaWxlIHRoZSBtYW5kYXRvcnkgY29tcGxldGlvbiBwYXRoIGdvZXMK PiArICogICB0aHJvdWdoIGEgaGFyZHdhcmUgaW50ZXJydXB0IGFuZCBwb3NzaWJsZSBqb2IgY29t cGxldGlvbiB3b3JrZXIuCj4gKyAqCj4gKyAqICogVG8gYWlkIGNvbXBvc2FiaWxpdHkgb2YgY29k ZSwgdGhlIGFubm90YXRpb25zIGNhbiBiZSBmcmVlbHkgbmVzdGVkLCBhcyBsb25nCj4gKyAqICAg YXMgdGhlIG92ZXJhbGwgbG9ja2luZyBoaWVyYXJjaHkgaXMgY29uc2lzdGVudC4gVGhlIGFubm90 YXRpb25zIGFsc28gd29yawo+ICsgKiAgIGJvdGggaW4gaW50ZXJydXB0IGFuZCBwcm9jZXNzIGNv bnRleHQuIER1ZSB0byBpbXBsZW1lbnRhdGlvbiBkZXRhaWxzIHRoaXMKPiArICogICByZXF1aXJl cyB0aGF0IGNhbGxlcnMgcGFzcyBhbiBvcGFxdWUgY29va2llIGZyb20KPiArICogICBkbWFfZmVu Y2VfYmVnaW5fc2lnbmFsbGluZygpIHRvIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgo+ICsg Kgo+ICsgKiAqIFZhbGlkYXRpb24gYWdhaW5zdCB0aGUgY3Jvc3MgZHJpdmVyIGNvbnRyYWN0IGlz IGltcGxlbWVudGVkIGJ5IHByaW1pbmcKPiArICogICBsb2NrZGVwIHdpdGggdGhlIHJlbGV2YW50 IGhpZXJhcmNoeSBhdCBib290LXVwLiBUaGlzIG1lYW5zIGV2ZW4ganVzdAo+ICsgKiAgIHRlc3Rp bmcgd2l0aCBhIHNpbmdsZSBkZXZpY2UgaXMgZW5vdWdoIHRvIHZhbGlkYXRlIGEgZHJpdmVyLCBh dCBsZWFzdCBhcwo+ICsgKiAgIGZhciBhcyBkZWFkbG9ja3Mgd2l0aCBkbWFfZmVuY2Vfd2FpdCgp IGFnYWluc3QgZG1hX2ZlbmNlX3NpZ25hbCgpIGFyZQo+ICsgKiAgIGNvbmNlcm5lZC4KPiArICov Cj4gKyNpZmRlZiBDT05GSUdfTE9DS0RFUAo+ICtzdHJ1Y3QgbG9ja2RlcF9tYXAJZG1hX2ZlbmNl X2xvY2tkZXBfbWFwID0gewo+ICsJLm5hbWUgPSAiZG1hX2ZlbmNlX21hcCIKPiArfTsKCk1heWJl IGEgc3R1cGlkIHF1ZXN0aW9uIGJlY2F1c2UgdGhpcyBpcyBkZWZpbml0ZWx5IGNvbXBsaWNhdGVk LCBidXQuLiBJZiAKeW91IGhhdmUgYSBzaW5nbGUvc3RhdGljL2dsb2JhbCBsb2NrZGVwIG1hcCwg ZG9lc24ndCB0aGlzIG1lYW4gX2FsbF8gCmxvY2tzLCBmcm9tIF9hbGxfIGRyaXZlcnMgaGFwcGVu aW5nIHRvIHVzZSBkbWEtZmVuY2VzIHdpbGwgZ2V0IHJlY29yZGVkIAppbiBpdC4gV2lsbCB0aGlz IHdvcmsgYW5kIG5vdCBjYXVzZSBmYWxzZSBwb3NpdGl2ZXM/CgpTb3VuZHMgbGlrZSBpdCBjb3Vs ZCBjcmVhdGUgYSBjb21tb24gbGluayBiZXR3ZWVuIHR3byBjb21wbGV0ZWx5IAp1bmNvbm5lY3Rl ZCB1c2FnZXMuIEJlY2F1c2UgYmVsb3cgeW91IGRvIGFkZCBhbm5vdGF0aW9ucyB0byBnZW5lcmlj IApkbWFfZmVuY2Vfc2lnbmFsIGFuZCBkbWFfZmVuY2Vfd2FpdC4KCj4gKwo+ICsvKioKPiArICog ZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxpbmcgLSBiZWdpbiBhIGNyaXRpY2FsIERNQSBmZW5jZSBz aWduYWxsaW5nIHNlY3Rpb24KPiArICoKPiArICogRHJpdmVycyBzaG91bGQgdXNlIHRoaXMgdG8g YW5ub3RhdGUgdGhlIGJlZ2lubmluZyBvZiBhbnkgY29kZSBzZWN0aW9uCj4gKyAqIHJlcXVpcmVk IHRvIGV2ZW50dWFsbHkgY29tcGxldGUgJmRtYV9mZW5jZSBieSBjYWxsaW5nIGRtYV9mZW5jZV9z aWduYWwoKS4KPiArICoKPiArICogVGhlIGVuZCBvZiB0aGVzZSBjcml0aWNhbCBzZWN0aW9ucyBh cmUgYW5ub3RhdGVkIHdpdGgKPiArICogZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKCkuCj4gKyAq Cj4gKyAqIFJldHVybnM6Cj4gKyAqCj4gKyAqIE9wYXF1ZSBjb29raWUgbmVlZGVkIGJ5IHRoZSBp bXBsZW1lbnRhdGlvbiwgd2hpY2ggbmVlZHMgdG8gYmUgcGFzc2VkIHRvCj4gKyAqIGRtYV9mZW5j ZV9lbmRfc2lnbmFsbGluZygpLgo+ICsgKi8KPiArYm9vbCBkbWFfZmVuY2VfYmVnaW5fc2lnbmFs bGluZyh2b2lkKQo+ICt7Cj4gKwkvKiBleHBsaWNpdGx5IG5lc3RpbmcgLi4uICovCj4gKwlpZiAo bG9ja19pc19oZWxkX3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSkpCj4gKwkJcmV0dXJu IHRydWU7Cj4gKwo+ICsJLyogcmVseSBvbiBtaWdodF9zbGVlcCBjaGVjayBmb3Igc29mdC9oYXJk aXJxIGxvY2tzICovCj4gKwlpZiAoaW5fYXRvbWljKCkpCj4gKwkJcmV0dXJuIHRydWU7Cj4gKwo+ ICsJLyogLi4uIGFuZCBub24tcmVjdXJzaXZlIHJlYWRsb2NrICovCj4gKwlsb2NrX2FjcXVpcmUo JmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMCwgMCwgMSwgMSwgTlVMTCwgX1JFVF9JUF8pOwoKV291 bGQgaXQgd29yayBpZiBzaWduYWxsaW5nIHBhdGggd291bGQgbWFyayBpdHNlbGYgYXMgYSB3cml0 ZSBsb2NrPyBJIGFtIAp0aGlua2luZyBpdCB3b3VsZCBiZSBuaWNlIHRvIHNlZSBpbiBsb2NrZGVw IHNwbGF0cyB3aGF0IGFyZSBzaWduYWxzIGFuZCAKd2hhdCBhcmUgd2FpdHMuCgpUaGUgcmVjdXJz aXZlIHVzYWdlIHdvdWxkbid0IHdvcmsgdGhlbiByaWdodD8gV291bGQgd3JpdGUgYW5ub3RhdGlv biBvbiAKdGhlIHdhaXQgcGF0aCB3b3JrPwoKUmVnYXJkcywKClR2cnRrbwoKPiArCj4gKwlyZXR1 cm4gZmFsc2U7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGlu Zyk7Cj4gKwo+ICsvKioKPiArICogZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nIC0gZW5kIGEgY3Jp dGljYWwgRE1BIGZlbmNlIHNpZ25hbGxpbmcgc2VjdGlvbgo+ICsgKgo+ICsgKiBDbG9zZXMgYSBj cml0aWNhbCBzZWN0aW9uIGFubm90YXRpb24gb3BlbmVkIGJ5IGRtYV9mZW5jZV9iZWdpbl9zaWdu YWxsaW5nKCkuCj4gKyAqLwo+ICt2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhib29sIGNv b2tpZSkKPiArewo+ICsJaWYgKGNvb2tpZSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJbG9ja19yZWxl YXNlKCZkbWFfZmVuY2VfbG9ja2RlcF9tYXAsIF9SRVRfSVBfKTsKPiArfQo+ICtFWFBPUlRfU1lN Qk9MKGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyk7Cj4gKwo+ICt2b2lkIF9fZG1hX2ZlbmNlX21p Z2h0X3dhaXQodm9pZCkKPiArewo+ICsJYm9vbCB0bXA7Cj4gKwo+ICsJdG1wID0gbG9ja19pc19o ZWxkX3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSk7Cj4gKwlpZiAodG1wKQo+ICsJCWxv Y2tfcmVsZWFzZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCBfVEhJU19JUF8pOwo+ICsJbG9ja19t YXBfYWNxdWlyZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwKTsKPiArCWxvY2tfbWFwX3JlbGVhc2Uo JmRtYV9mZW5jZV9sb2NrZGVwX21hcCk7Cj4gKwlpZiAodG1wKQo+ICsJCWxvY2tfYWNxdWlyZSgm ZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCAwLCAwLCAxLCAxLCBOVUxMLCBfVEhJU19JUF8pOwo+ICt9 Cj4gKyNlbmRpZgo+ICsKPiArCj4gICAvKioKPiAgICAqIGRtYV9mZW5jZV9zaWduYWxfbG9ja2Vk IC0gc2lnbmFsIGNvbXBsZXRpb24gb2YgYSBmZW5jZQo+ICAgICogQGZlbmNlOiB0aGUgZmVuY2Ug dG8gc2lnbmFsCj4gQEAgLTE3MCwxNCArMzI0LDE5IEBAIGludCBkbWFfZmVuY2Vfc2lnbmFsKHN0 cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQo+ICAgewo+ICAgCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4g ICAJaW50IHJldDsKPiArCWJvb2wgdG1wOwo+ICAgCj4gICAJaWYgKCFmZW5jZSkKPiAgIAkJcmV0 dXJuIC1FSU5WQUw7Cj4gICAKPiArCXRtcCA9IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCk7 Cj4gKwo+ICAgCXNwaW5fbG9ja19pcnFzYXZlKGZlbmNlLT5sb2NrLCBmbGFncyk7Cj4gICAJcmV0 ID0gZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoZmVuY2UpOwo+ICAgCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoZmVuY2UtPmxvY2ssIGZsYWdzKTsKPiAgIAo+ICsJZG1hX2ZlbmNlX2VuZF9zaWduYWxs aW5nKHRtcCk7Cj4gKwo+ICAgCXJldHVybiByZXQ7Cj4gICB9Cj4gICBFWFBPUlRfU1lNQk9MKGRt YV9mZW5jZV9zaWduYWwpOwo+IEBAIC0yMTAsNiArMzY5LDggQEAgZG1hX2ZlbmNlX3dhaXRfdGlt ZW91dChzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwgYm9vbCBpbnRyLCBzaWduZWQgbG9uZyB0aW1l b3V0KQo+ICAgCj4gICAJbWlnaHRfc2xlZXAoKTsKPiAgIAo+ICsJX19kbWFfZmVuY2VfbWlnaHRf d2FpdCgpOwo+ICsKPiAgIAl0cmFjZV9kbWFfZmVuY2Vfd2FpdF9zdGFydChmZW5jZSk7Cj4gICAJ aWYgKGZlbmNlLT5vcHMtPndhaXQpCj4gICAJCXJldCA9IGZlbmNlLT5vcHMtPndhaXQoZmVuY2Us IGludHIsIHRpbWVvdXQpOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5o IGIvaW5jbHVkZS9saW51eC9kbWEtZmVuY2UuaAo+IGluZGV4IDMzNDdjNTRmM2E4Ny4uM2YyODhm N2RiMmVmIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvZG1hLWZlbmNlLmgKPiArKysgYi9p bmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCj4gQEAgLTM1Nyw2ICszNTcsMTggQEAgZG1hX2ZlbmNl X2dldF9yY3Vfc2FmZShzdHJ1Y3QgZG1hX2ZlbmNlIF9fcmN1ICoqZmVuY2VwKQo+ICAgCX0gd2hp bGUgKDEpOwo+ICAgfQo+ICAgCj4gKyNpZmRlZiBDT05GSUdfTE9DS0RFUAo+ICtib29sIGRtYV9m ZW5jZV9iZWdpbl9zaWduYWxsaW5nKHZvaWQpOwo+ICt2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFs bGluZyhib29sIGNvb2tpZSk7Cj4gKyNlbHNlCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBkbWFfZmVu Y2VfYmVnaW5fc2lnbmFsbGluZyh2b2lkKQo+ICt7Cj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICtz dGF0aWMgaW5saW5lIHZvaWQgZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKGJvb2wgY29va2llKSB7 fQo+ICtzdGF0aWMgaW5saW5lIHZvaWQgX19kbWFfZmVuY2VfbWlnaHRfd2FpdCh2b2lkKSB7fQo+ ICsjZW5kaWYKPiArCj4gICBpbnQgZG1hX2ZlbmNlX3NpZ25hbChzdHJ1Y3QgZG1hX2ZlbmNlICpm ZW5jZSk7Cj4gICBpbnQgZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoc3RydWN0IGRtYV9mZW5jZSAq ZmVuY2UpOwo+ICAgc2lnbmVkIGxvbmcgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdChzdHJ1Y3QgZG1h X2ZlbmNlICpmZW5jZSwKPiAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KYW1kLWdmeCBtYWlsaW5nIGxpc3QKYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5v cmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9hbWQtZ2Z4 Cg== 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=-7.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, HK_RANDOM_FROM,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable 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 B0CF9C433DF for ; Wed, 10 Jun 2020 14:22:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8DFC02067B for ; Wed, 10 Jun 2020 14:22:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729816AbgFJOWM (ORCPT ); Wed, 10 Jun 2020 10:22:12 -0400 Received: from mga01.intel.com ([192.55.52.88]:60429 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726157AbgFJOWL (ORCPT ); Wed, 10 Jun 2020 10:22:11 -0400 IronPort-SDR: hjD/05lVNceHh5AMtpYqj7z/EYd7eBJfy/PvqylNu60/O9grXYC1ULdbyfmxSMpHmFFkysHl/9 WeOXmO9fpjqw== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:22:02 -0700 IronPort-SDR: ZXI7uPl/+gFtBOCO1ezzY/adZkhBrl05LWKKuG3izz+Rz/KzHBkHO1DHUyRtRF1+HN/H5NIQyj NDLjlxGdWGKg== X-IronPort-AV: E=Sophos;i="5.73,496,1583222400"; d="scan'208";a="418759078" Received: from unknown (HELO [10.214.244.237]) ([10.214.244.237]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:21:56 -0700 Subject: Re: [Intel-gfx] [PATCH 03/18] dma-fence: basic lockdep annotations To: Daniel Vetter , DRI Development Cc: linux-rdma@vger.kernel.org, Intel Graphics Development , LKML , amd-gfx@lists.freedesktop.org, Chris Wilson , linaro-mm-sig@lists.linaro.org, Thomas Hellstrom , Daniel Vetter , linux-media@vger.kernel.org, =?UTF-8?Q?Christian_K=c3=b6nig?= , Mika Kuoppala References: <20200604081224.863494-1-daniel.vetter@ffwll.ch> <20200604081224.863494-4-daniel.vetter@ffwll.ch> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: Date: Wed, 10 Jun 2020 15:21:53 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.7.0 MIME-Version: 1.0 In-Reply-To: <20200604081224.863494-4-daniel.vetter@ffwll.ch> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org On 04/06/2020 09:12, Daniel Vetter wrote: > Design is similar to the lockdep annotations for workers, but with > some twists: > > - We use a read-lock for the execution/worker/completion side, so that > this explicit annotation can be more liberally sprinkled around. > With read locks lockdep isn't going to complain if the read-side > isn't nested the same way under all circumstances, so ABBA deadlocks > are ok. Which they are, since this is an annotation only. > > - We're using non-recursive lockdep read lock mode, since in recursive > read lock mode lockdep does not catch read side hazards. And we > _very_ much want read side hazards to be caught. For full details of > this limitation see > > commit e91498589746065e3ae95d9a00b068e525eec34f > Author: Peter Zijlstra > Date: Wed Aug 23 13:13:11 2017 +0200 > > locking/lockdep/selftests: Add mixed read-write ABBA tests > > - To allow nesting of the read-side explicit annotations we explicitly > keep track of the nesting. lock_is_held() allows us to do that. > > - The wait-side annotation is a write lock, and entirely done within > dma_fence_wait() for everyone by default. > > - To be able to freely annotate helper functions I want to make it ok > to call dma_fence_begin/end_signalling from soft/hardirq context. > First attempt was using the hardirq locking context for the write > side in lockdep, but this forces all normal spinlocks nested within > dma_fence_begin/end_signalling to be spinlocks. That bollocks. > > The approach now is to simple check in_atomic(), and for these cases > entirely rely on the might_sleep() check in dma_fence_wait(). That > will catch any wrong nesting against spinlocks from soft/hardirq > contexts. > > The idea here is that every code path that's critical for eventually > signalling a dma_fence should be annotated with > dma_fence_begin/end_signalling. The annotation ideally starts right > after a dma_fence is published (added to a dma_resv, exposed as a > sync_file fd, attached to a drm_syncobj fd, or anything else that > makes the dma_fence visible to other kernel threads), up to and > including the dma_fence_wait(). Examples are irq handlers, the > scheduler rt threads, the tail of execbuf (after the corresponding > fences are visible), any workers that end up signalling dma_fences and > really anything else. Not annotated should be code paths that only > complete fences opportunistically as the gpu progresses, like e.g. > shrinker/eviction code. > > The main class of deadlocks this is supposed to catch are: > > Thread A: > > mutex_lock(A); > mutex_unlock(A); > > dma_fence_signal(); > > Thread B: > > mutex_lock(A); > dma_fence_wait(); > mutex_unlock(A); > > Thread B is blocked on A signalling the fence, but A never gets around > to that because it cannot acquire the lock A. > > Note that dma_fence_wait() is allowed to be nested within > dma_fence_begin/end_signalling sections. To allow this to happen the > read lock needs to be upgraded to a write lock, which means that any > other lock is acquired between the dma_fence_begin_signalling() call and > the call to dma_fence_wait(), and still held, this will result in an > immediate lockdep complaint. The only other option would be to not > annotate such calls, defeating the point. Therefore these annotations > cannot be sprinkled over the code entirely mindless to avoid false > positives. > > v2: handle soft/hardirq ctx better against write side and dont forget > EXPORT_SYMBOL, drivers can't use this otherwise. > > v3: Kerneldoc. > > v4: Some spelling fixes from Mika > > Cc: Mika Kuoppala > Cc: Thomas Hellstrom > Cc: linux-media@vger.kernel.org > Cc: linaro-mm-sig@lists.linaro.org > Cc: linux-rdma@vger.kernel.org > Cc: amd-gfx@lists.freedesktop.org > Cc: intel-gfx@lists.freedesktop.org > Cc: Chris Wilson > Cc: Maarten Lankhorst > Cc: Christian König > Signed-off-by: Daniel Vetter > --- > Documentation/driver-api/dma-buf.rst | 12 +- > drivers/dma-buf/dma-fence.c | 161 +++++++++++++++++++++++++++ > include/linux/dma-fence.h | 12 ++ > 3 files changed, 182 insertions(+), 3 deletions(-) > > diff --git a/Documentation/driver-api/dma-buf.rst b/Documentation/driver-api/dma-buf.rst > index 63dec76d1d8d..05d856131140 100644 > --- a/Documentation/driver-api/dma-buf.rst > +++ b/Documentation/driver-api/dma-buf.rst > @@ -100,11 +100,11 @@ CPU Access to DMA Buffer Objects > .. kernel-doc:: drivers/dma-buf/dma-buf.c > :doc: cpu access > > -Fence Poll Support > -~~~~~~~~~~~~~~~~~~ > +Implicit Fence Poll Support > +~~~~~~~~~~~~~~~~~~~~~~~~~~~ > > .. kernel-doc:: drivers/dma-buf/dma-buf.c > - :doc: fence polling > + :doc: implicit fence polling > > Kernel Functions and Structures Reference > ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > @@ -133,6 +133,12 @@ DMA Fences > .. kernel-doc:: drivers/dma-buf/dma-fence.c > :doc: DMA fences overview > > +DMA Fence Signalling Annotations > +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > + > +.. kernel-doc:: drivers/dma-buf/dma-fence.c > + :doc: fence signalling annotation > + > DMA Fences Functions Reference > ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > > diff --git a/drivers/dma-buf/dma-fence.c b/drivers/dma-buf/dma-fence.c > index 656e9ac2d028..0005bc002529 100644 > --- a/drivers/dma-buf/dma-fence.c > +++ b/drivers/dma-buf/dma-fence.c > @@ -110,6 +110,160 @@ u64 dma_fence_context_alloc(unsigned num) > } > EXPORT_SYMBOL(dma_fence_context_alloc); > > +/** > + * DOC: fence signalling annotation > + * > + * Proving correctness of all the kernel code around &dma_fence through code > + * review and testing is tricky for a few reasons: > + * > + * * It is a cross-driver contract, and therefore all drivers must follow the > + * same rules for lock nesting order, calling contexts for various functions > + * and anything else significant for in-kernel interfaces. But it is also > + * impossible to test all drivers in a single machine, hence brute-force N vs. > + * N testing of all combinations is impossible. Even just limiting to the > + * possible combinations is infeasible. > + * > + * * There is an enormous amount of driver code involved. For render drivers > + * there's the tail of command submission, after fences are published, > + * scheduler code, interrupt and workers to process job completion, > + * and timeout, gpu reset and gpu hang recovery code. Plus for integration > + * with core mm with have &mmu_notifier, respectively &mmu_interval_notifier, > + * and &shrinker. For modesetting drivers there's the commit tail functions > + * between when fences for an atomic modeset are published, and when the > + * corresponding vblank completes, including any interrupt processing and > + * related workers. Auditing all that code, across all drivers, is not > + * feasible. > + * > + * * Due to how many other subsystems are involved and the locking hierarchies > + * this pulls in there is extremely thin wiggle-room for driver-specific > + * differences. &dma_fence interacts with almost all of the core memory > + * handling through page fault handlers via &dma_resv, dma_resv_lock() and > + * dma_resv_unlock(). On the other side it also interacts through all > + * allocation sites through &mmu_notifier and &shrinker. > + * > + * Furthermore lockdep does not handle cross-release dependencies, which means > + * any deadlocks between dma_fence_wait() and dma_fence_signal() can't be caught > + * at runtime with some quick testing. The simplest example is one thread > + * waiting on a &dma_fence while holding a lock:: > + * > + * lock(A); > + * dma_fence_wait(B); > + * unlock(A); > + * > + * while the other thread is stuck trying to acquire the same lock, which > + * prevents it from signalling the fence the previous thread is stuck waiting > + * on:: > + * > + * lock(A); > + * unlock(A); > + * dma_fence_signal(B); > + * > + * By manually annotating all code relevant to signalling a &dma_fence we can > + * teach lockdep about these dependencies, which also helps with the validation > + * headache since now lockdep can check all the rules for us:: > + * > + * cookie = dma_fence_begin_signalling(); > + * lock(A); > + * unlock(A); > + * dma_fence_signal(B); > + * dma_fence_end_signalling(cookie); > + * > + * For using dma_fence_begin_signalling() and dma_fence_end_signalling() to > + * annotate critical sections the following rules need to be observed: > + * > + * * All code necessary to complete a &dma_fence must be annotated, from the > + * point where a fence is accessible to other threads, to the point where > + * dma_fence_signal() is called. Un-annotated code can contain deadlock issues, > + * and due to the very strict rules and many corner cases it is infeasible to > + * catch these just with review or normal stress testing. > + * > + * * &struct dma_resv deserves a special note, since the readers are only > + * protected by rcu. This means the signalling critical section starts as soon > + * as the new fences are installed, even before dma_resv_unlock() is called. > + * > + * * The only exception are fast paths and opportunistic signalling code, which > + * calls dma_fence_signal() purely as an optimization, but is not required to > + * guarantee completion of a &dma_fence. The usual example is a wait IOCTL > + * which calls dma_fence_signal(), while the mandatory completion path goes > + * through a hardware interrupt and possible job completion worker. > + * > + * * To aid composability of code, the annotations can be freely nested, as long > + * as the overall locking hierarchy is consistent. The annotations also work > + * both in interrupt and process context. Due to implementation details this > + * requires that callers pass an opaque cookie from > + * dma_fence_begin_signalling() to dma_fence_end_signalling(). > + * > + * * Validation against the cross driver contract is implemented by priming > + * lockdep with the relevant hierarchy at boot-up. This means even just > + * testing with a single device is enough to validate a driver, at least as > + * far as deadlocks with dma_fence_wait() against dma_fence_signal() are > + * concerned. > + */ > +#ifdef CONFIG_LOCKDEP > +struct lockdep_map dma_fence_lockdep_map = { > + .name = "dma_fence_map" > +}; Maybe a stupid question because this is definitely complicated, but.. If you have a single/static/global lockdep map, doesn't this mean _all_ locks, from _all_ drivers happening to use dma-fences will get recorded in it. Will this work and not cause false positives? Sounds like it could create a common link between two completely unconnected usages. Because below you do add annotations to generic dma_fence_signal and dma_fence_wait. > + > +/** > + * dma_fence_begin_signalling - begin a critical DMA fence signalling section > + * > + * Drivers should use this to annotate the beginning of any code section > + * required to eventually complete &dma_fence by calling dma_fence_signal(). > + * > + * The end of these critical sections are annotated with > + * dma_fence_end_signalling(). > + * > + * Returns: > + * > + * Opaque cookie needed by the implementation, which needs to be passed to > + * dma_fence_end_signalling(). > + */ > +bool dma_fence_begin_signalling(void) > +{ > + /* explicitly nesting ... */ > + if (lock_is_held_type(&dma_fence_lockdep_map, 1)) > + return true; > + > + /* rely on might_sleep check for soft/hardirq locks */ > + if (in_atomic()) > + return true; > + > + /* ... and non-recursive readlock */ > + lock_acquire(&dma_fence_lockdep_map, 0, 0, 1, 1, NULL, _RET_IP_); Would it work if signalling path would mark itself as a write lock? I am thinking it would be nice to see in lockdep splats what are signals and what are waits. The recursive usage wouldn't work then right? Would write annotation on the wait path work? Regards, Tvrtko > + > + return false; > +} > +EXPORT_SYMBOL(dma_fence_begin_signalling); > + > +/** > + * dma_fence_end_signalling - end a critical DMA fence signalling section > + * > + * Closes a critical section annotation opened by dma_fence_begin_signalling(). > + */ > +void dma_fence_end_signalling(bool cookie) > +{ > + if (cookie) > + return; > + > + lock_release(&dma_fence_lockdep_map, _RET_IP_); > +} > +EXPORT_SYMBOL(dma_fence_end_signalling); > + > +void __dma_fence_might_wait(void) > +{ > + bool tmp; > + > + tmp = lock_is_held_type(&dma_fence_lockdep_map, 1); > + if (tmp) > + lock_release(&dma_fence_lockdep_map, _THIS_IP_); > + lock_map_acquire(&dma_fence_lockdep_map); > + lock_map_release(&dma_fence_lockdep_map); > + if (tmp) > + lock_acquire(&dma_fence_lockdep_map, 0, 0, 1, 1, NULL, _THIS_IP_); > +} > +#endif > + > + > /** > * dma_fence_signal_locked - signal completion of a fence > * @fence: the fence to signal > @@ -170,14 +324,19 @@ int dma_fence_signal(struct dma_fence *fence) > { > unsigned long flags; > int ret; > + bool tmp; > > if (!fence) > return -EINVAL; > > + tmp = dma_fence_begin_signalling(); > + > spin_lock_irqsave(fence->lock, flags); > ret = dma_fence_signal_locked(fence); > spin_unlock_irqrestore(fence->lock, flags); > > + dma_fence_end_signalling(tmp); > + > return ret; > } > EXPORT_SYMBOL(dma_fence_signal); > @@ -210,6 +369,8 @@ dma_fence_wait_timeout(struct dma_fence *fence, bool intr, signed long timeout) > > might_sleep(); > > + __dma_fence_might_wait(); > + > trace_dma_fence_wait_start(fence); > if (fence->ops->wait) > ret = fence->ops->wait(fence, intr, timeout); > diff --git a/include/linux/dma-fence.h b/include/linux/dma-fence.h > index 3347c54f3a87..3f288f7db2ef 100644 > --- a/include/linux/dma-fence.h > +++ b/include/linux/dma-fence.h > @@ -357,6 +357,18 @@ dma_fence_get_rcu_safe(struct dma_fence __rcu **fencep) > } while (1); > } > > +#ifdef CONFIG_LOCKDEP > +bool dma_fence_begin_signalling(void); > +void dma_fence_end_signalling(bool cookie); > +#else > +static inline bool dma_fence_begin_signalling(void) > +{ > + return true; > +} > +static inline void dma_fence_end_signalling(bool cookie) {} > +static inline void __dma_fence_might_wait(void) {} > +#endif > + > int dma_fence_signal(struct dma_fence *fence); > int dma_fence_signal_locked(struct dma_fence *fence); > signed long dma_fence_default_wait(struct dma_fence *fence, > 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=-7.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, HK_RANDOM_FROM,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable 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 E4476C433DF for ; Wed, 10 Jun 2020 14:22:08 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 C38932067B for ; Wed, 10 Jun 2020 14:22:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C38932067B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id C3EC66E5C3; Wed, 10 Jun 2020 14:22:04 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id F3D3E89B67; Wed, 10 Jun 2020 14:22:02 +0000 (UTC) IronPort-SDR: 2BSiRpH+SklxWdy78cRGjm97kFpYYmCrrwZRmP3phftxHcnGZjfJspim3WvU21KE5ALPk4hOEV EhOVS/yQswVA== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:22:02 -0700 IronPort-SDR: ZXI7uPl/+gFtBOCO1ezzY/adZkhBrl05LWKKuG3izz+Rz/KzHBkHO1DHUyRtRF1+HN/H5NIQyj NDLjlxGdWGKg== X-IronPort-AV: E=Sophos;i="5.73,496,1583222400"; d="scan'208";a="418759078" Received: from unknown (HELO [10.214.244.237]) ([10.214.244.237]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:21:56 -0700 Subject: Re: [Intel-gfx] [PATCH 03/18] dma-fence: basic lockdep annotations To: Daniel Vetter , DRI Development References: <20200604081224.863494-1-daniel.vetter@ffwll.ch> <20200604081224.863494-4-daniel.vetter@ffwll.ch> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: Date: Wed, 10 Jun 2020 15:21:53 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.7.0 MIME-Version: 1.0 In-Reply-To: <20200604081224.863494-4-daniel.vetter@ffwll.ch> Content-Language: en-US X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-rdma@vger.kernel.org, Intel Graphics Development , LKML , amd-gfx@lists.freedesktop.org, Chris Wilson , linaro-mm-sig@lists.linaro.org, Thomas Hellstrom , Daniel Vetter , Mika Kuoppala , =?UTF-8?Q?Christian_K=c3=b6nig?= , linux-media@vger.kernel.org Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Ck9uIDA0LzA2LzIwMjAgMDk6MTIsIERhbmllbCBWZXR0ZXIgd3JvdGU6Cj4gRGVzaWduIGlzIHNp bWlsYXIgdG8gdGhlIGxvY2tkZXAgYW5ub3RhdGlvbnMgZm9yIHdvcmtlcnMsIGJ1dCB3aXRoCj4g c29tZSB0d2lzdHM6Cj4gCj4gLSBXZSB1c2UgYSByZWFkLWxvY2sgZm9yIHRoZSBleGVjdXRpb24v d29ya2VyL2NvbXBsZXRpb24gc2lkZSwgc28gdGhhdAo+ICAgIHRoaXMgZXhwbGljaXQgYW5ub3Rh dGlvbiBjYW4gYmUgbW9yZSBsaWJlcmFsbHkgc3ByaW5rbGVkIGFyb3VuZC4KPiAgICBXaXRoIHJl YWQgbG9ja3MgbG9ja2RlcCBpc24ndCBnb2luZyB0byBjb21wbGFpbiBpZiB0aGUgcmVhZC1zaWRl Cj4gICAgaXNuJ3QgbmVzdGVkIHRoZSBzYW1lIHdheSB1bmRlciBhbGwgY2lyY3Vtc3RhbmNlcywg c28gQUJCQSBkZWFkbG9ja3MKPiAgICBhcmUgb2suIFdoaWNoIHRoZXkgYXJlLCBzaW5jZSB0aGlz IGlzIGFuIGFubm90YXRpb24gb25seS4KPiAKPiAtIFdlJ3JlIHVzaW5nIG5vbi1yZWN1cnNpdmUg bG9ja2RlcCByZWFkIGxvY2sgbW9kZSwgc2luY2UgaW4gcmVjdXJzaXZlCj4gICAgcmVhZCBsb2Nr IG1vZGUgbG9ja2RlcCBkb2VzIG5vdCBjYXRjaCByZWFkIHNpZGUgaGF6YXJkcy4gQW5kIHdlCj4g ICAgX3ZlcnlfIG11Y2ggd2FudCByZWFkIHNpZGUgaGF6YXJkcyB0byBiZSBjYXVnaHQuIEZvciBm dWxsIGRldGFpbHMgb2YKPiAgICB0aGlzIGxpbWl0YXRpb24gc2VlCj4gCj4gICAgY29tbWl0IGU5 MTQ5ODU4OTc0NjA2NWUzYWU5NWQ5YTAwYjA2OGU1MjVlZWMzNGYKPiAgICBBdXRob3I6IFBldGVy IFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFkLm9yZz4KPiAgICBEYXRlOiAgIFdlZCBBdWcgMjMg MTM6MTM6MTEgMjAxNyArMDIwMAo+IAo+ICAgICAgICBsb2NraW5nL2xvY2tkZXAvc2VsZnRlc3Rz OiBBZGQgbWl4ZWQgcmVhZC13cml0ZSBBQkJBIHRlc3RzCj4gCj4gLSBUbyBhbGxvdyBuZXN0aW5n IG9mIHRoZSByZWFkLXNpZGUgZXhwbGljaXQgYW5ub3RhdGlvbnMgd2UgZXhwbGljaXRseQo+ICAg IGtlZXAgdHJhY2sgb2YgdGhlIG5lc3RpbmcuIGxvY2tfaXNfaGVsZCgpIGFsbG93cyB1cyB0byBk byB0aGF0Lgo+IAo+IC0gVGhlIHdhaXQtc2lkZSBhbm5vdGF0aW9uIGlzIGEgd3JpdGUgbG9jaywg YW5kIGVudGlyZWx5IGRvbmUgd2l0aGluCj4gICAgZG1hX2ZlbmNlX3dhaXQoKSBmb3IgZXZlcnlv bmUgYnkgZGVmYXVsdC4KPiAKPiAtIFRvIGJlIGFibGUgdG8gZnJlZWx5IGFubm90YXRlIGhlbHBl ciBmdW5jdGlvbnMgSSB3YW50IHRvIG1ha2UgaXQgb2sKPiAgICB0byBjYWxsIGRtYV9mZW5jZV9i ZWdpbi9lbmRfc2lnbmFsbGluZyBmcm9tIHNvZnQvaGFyZGlycSBjb250ZXh0Lgo+ICAgIEZpcnN0 IGF0dGVtcHQgd2FzIHVzaW5nIHRoZSBoYXJkaXJxIGxvY2tpbmcgY29udGV4dCBmb3IgdGhlIHdy aXRlCj4gICAgc2lkZSBpbiBsb2NrZGVwLCBidXQgdGhpcyBmb3JjZXMgYWxsIG5vcm1hbCBzcGlu bG9ja3MgbmVzdGVkIHdpdGhpbgo+ICAgIGRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZyB0 byBiZSBzcGlubG9ja3MuIFRoYXQgYm9sbG9ja3MuCj4gCj4gICAgVGhlIGFwcHJvYWNoIG5vdyBp cyB0byBzaW1wbGUgY2hlY2sgaW5fYXRvbWljKCksIGFuZCBmb3IgdGhlc2UgY2FzZXMKPiAgICBl bnRpcmVseSByZWx5IG9uIHRoZSBtaWdodF9zbGVlcCgpIGNoZWNrIGluIGRtYV9mZW5jZV93YWl0 KCkuIFRoYXQKPiAgICB3aWxsIGNhdGNoIGFueSB3cm9uZyBuZXN0aW5nIGFnYWluc3Qgc3Bpbmxv Y2tzIGZyb20gc29mdC9oYXJkaXJxCj4gICAgY29udGV4dHMuCj4gCj4gVGhlIGlkZWEgaGVyZSBp cyB0aGF0IGV2ZXJ5IGNvZGUgcGF0aCB0aGF0J3MgY3JpdGljYWwgZm9yIGV2ZW50dWFsbHkKPiBz aWduYWxsaW5nIGEgZG1hX2ZlbmNlIHNob3VsZCBiZSBhbm5vdGF0ZWQgd2l0aAo+IGRtYV9mZW5j ZV9iZWdpbi9lbmRfc2lnbmFsbGluZy4gVGhlIGFubm90YXRpb24gaWRlYWxseSBzdGFydHMgcmln aHQKPiBhZnRlciBhIGRtYV9mZW5jZSBpcyBwdWJsaXNoZWQgKGFkZGVkIHRvIGEgZG1hX3Jlc3Ys IGV4cG9zZWQgYXMgYQo+IHN5bmNfZmlsZSBmZCwgYXR0YWNoZWQgdG8gYSBkcm1fc3luY29iaiBm ZCwgb3IgYW55dGhpbmcgZWxzZSB0aGF0Cj4gbWFrZXMgdGhlIGRtYV9mZW5jZSB2aXNpYmxlIHRv IG90aGVyIGtlcm5lbCB0aHJlYWRzKSwgdXAgdG8gYW5kCj4gaW5jbHVkaW5nIHRoZSBkbWFfZmVu Y2Vfd2FpdCgpLiBFeGFtcGxlcyBhcmUgaXJxIGhhbmRsZXJzLCB0aGUKPiBzY2hlZHVsZXIgcnQg dGhyZWFkcywgdGhlIHRhaWwgb2YgZXhlY2J1ZiAoYWZ0ZXIgdGhlIGNvcnJlc3BvbmRpbmcKPiBm ZW5jZXMgYXJlIHZpc2libGUpLCBhbnkgd29ya2VycyB0aGF0IGVuZCB1cCBzaWduYWxsaW5nIGRt YV9mZW5jZXMgYW5kCj4gcmVhbGx5IGFueXRoaW5nIGVsc2UuIE5vdCBhbm5vdGF0ZWQgc2hvdWxk IGJlIGNvZGUgcGF0aHMgdGhhdCBvbmx5Cj4gY29tcGxldGUgZmVuY2VzIG9wcG9ydHVuaXN0aWNh bGx5IGFzIHRoZSBncHUgcHJvZ3Jlc3NlcywgbGlrZSBlLmcuCj4gc2hyaW5rZXIvZXZpY3Rpb24g Y29kZS4KPiAKPiBUaGUgbWFpbiBjbGFzcyBvZiBkZWFkbG9ja3MgdGhpcyBpcyBzdXBwb3NlZCB0 byBjYXRjaCBhcmU6Cj4gCj4gVGhyZWFkIEE6Cj4gCj4gCW11dGV4X2xvY2soQSk7Cj4gCW11dGV4 X3VubG9jayhBKTsKPiAKPiAJZG1hX2ZlbmNlX3NpZ25hbCgpOwo+IAo+IFRocmVhZCBCOgo+IAo+ IAltdXRleF9sb2NrKEEpOwo+IAlkbWFfZmVuY2Vfd2FpdCgpOwo+IAltdXRleF91bmxvY2soQSk7 Cj4gCj4gVGhyZWFkIEIgaXMgYmxvY2tlZCBvbiBBIHNpZ25hbGxpbmcgdGhlIGZlbmNlLCBidXQg QSBuZXZlciBnZXRzIGFyb3VuZAo+IHRvIHRoYXQgYmVjYXVzZSBpdCBjYW5ub3QgYWNxdWlyZSB0 aGUgbG9jayBBLgo+IAo+IE5vdGUgdGhhdCBkbWFfZmVuY2Vfd2FpdCgpIGlzIGFsbG93ZWQgdG8g YmUgbmVzdGVkIHdpdGhpbgo+IGRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZyBzZWN0aW9u cy4gVG8gYWxsb3cgdGhpcyB0byBoYXBwZW4gdGhlCj4gcmVhZCBsb2NrIG5lZWRzIHRvIGJlIHVw Z3JhZGVkIHRvIGEgd3JpdGUgbG9jaywgd2hpY2ggbWVhbnMgdGhhdCBhbnkKPiBvdGhlciBsb2Nr IGlzIGFjcXVpcmVkIGJldHdlZW4gdGhlIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkgY2Fs bCBhbmQKPiB0aGUgY2FsbCB0byBkbWFfZmVuY2Vfd2FpdCgpLCBhbmQgc3RpbGwgaGVsZCwgdGhp cyB3aWxsIHJlc3VsdCBpbiBhbgo+IGltbWVkaWF0ZSBsb2NrZGVwIGNvbXBsYWludC4gVGhlIG9u bHkgb3RoZXIgb3B0aW9uIHdvdWxkIGJlIHRvIG5vdAo+IGFubm90YXRlIHN1Y2ggY2FsbHMsIGRl ZmVhdGluZyB0aGUgcG9pbnQuIFRoZXJlZm9yZSB0aGVzZSBhbm5vdGF0aW9ucwo+IGNhbm5vdCBi ZSBzcHJpbmtsZWQgb3ZlciB0aGUgY29kZSBlbnRpcmVseSBtaW5kbGVzcyB0byBhdm9pZCBmYWxz ZQo+IHBvc2l0aXZlcy4KPiAKPiB2MjogaGFuZGxlIHNvZnQvaGFyZGlycSBjdHggYmV0dGVyIGFn YWluc3Qgd3JpdGUgc2lkZSBhbmQgZG9udCBmb3JnZXQKPiBFWFBPUlRfU1lNQk9MLCBkcml2ZXJz IGNhbid0IHVzZSB0aGlzIG90aGVyd2lzZS4KPiAKPiB2MzogS2VybmVsZG9jLgo+IAo+IHY0OiBT b21lIHNwZWxsaW5nIGZpeGVzIGZyb20gTWlrYQo+IAo+IENjOiBNaWthIEt1b3BwYWxhIDxtaWth Lmt1b3BwYWxhQGludGVsLmNvbT4KPiBDYzogVGhvbWFzIEhlbGxzdHJvbSA8dGhvbWFzLmhlbGxz dHJvbUBpbnRlbC5jb20+Cj4gQ2M6IGxpbnV4LW1lZGlhQHZnZXIua2VybmVsLm9yZwo+IENjOiBs aW5hcm8tbW0tc2lnQGxpc3RzLmxpbmFyby5vcmcKPiBDYzogbGludXgtcmRtYUB2Z2VyLmtlcm5l bC5vcmcKPiBDYzogYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBDYzogaW50ZWwtZ2Z4 QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IENjOiBDaHJpcyBXaWxzb24gPGNocmlzQGNocmlzLXdp bHNvbi5jby51az4KPiBDYzogTWFhcnRlbiBMYW5raG9yc3QgPG1hYXJ0ZW4ubGFua2hvcnN0QGxp bnV4LmludGVsLmNvbT4KPiBDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0Bh bWQuY29tPgo+IFNpZ25lZC1vZmYtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50 ZWwuY29tPgo+IC0tLQo+ICAgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IHwg IDEyICstCj4gICBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMgICAgICAgICAgfCAxNjEgKysr KysrKysrKysrKysrKysrKysrKysrKysrCj4gICBpbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oICAg ICAgICAgICAgfCAgMTIgKysKPiAgIDMgZmlsZXMgY2hhbmdlZCwgMTgyIGluc2VydGlvbnMoKyks IDMgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFw aS9kbWEtYnVmLnJzdCBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdAo+IGlu ZGV4IDYzZGVjNzZkMWQ4ZC4uMDVkODU2MTMxMTQwIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRp b24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFw aS9kbWEtYnVmLnJzdAo+IEBAIC0xMDAsMTEgKzEwMCwxMSBAQCBDUFUgQWNjZXNzIHRvIERNQSBC dWZmZXIgT2JqZWN0cwo+ICAgLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVm LmMKPiAgICAgIDpkb2M6IGNwdSBhY2Nlc3MKPiAgIAo+IC1GZW5jZSBQb2xsIFN1cHBvcnQKPiAt fn5+fn5+fn5+fn5+fn5+fn5+Cj4gK0ltcGxpY2l0IEZlbmNlIFBvbGwgU3VwcG9ydAo+ICt+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KPiAgIAo+ICAgLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMv ZG1hLWJ1Zi9kbWEtYnVmLmMKPiAtICAgOmRvYzogZmVuY2UgcG9sbGluZwo+ICsgICA6ZG9jOiBp bXBsaWNpdCBmZW5jZSBwb2xsaW5nCj4gICAKPiAgIEtlcm5lbCBGdW5jdGlvbnMgYW5kIFN0cnVj dHVyZXMgUmVmZXJlbmNlCj4gICB+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fgo+IEBAIC0xMzMsNiArMTMzLDEyIEBAIERNQSBGZW5jZXMKPiAgIC4uIGtlcm5lbC1kb2M6 OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKPiAgICAgIDpkb2M6IERNQSBmZW5jZXMgb3Zl cnZpZXcKPiAgIAo+ICtETUEgRmVuY2UgU2lnbmFsbGluZyBBbm5vdGF0aW9ucwo+ICt+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgo+ICsKPiArLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMv ZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+ICsgICA6ZG9jOiBmZW5jZSBzaWduYWxsaW5nIGFubm90YXRp b24KPiArCj4gICBETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKPiAgIH5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fgo+ICAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9k bWEtZmVuY2UuYyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+IGluZGV4IDY1NmU5YWMy ZDAyOC4uMDAwNWJjMDAyNTI5IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVu Y2UuYwo+ICsrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+IEBAIC0xMTAsNiArMTEw LDE2MCBAQCB1NjQgZG1hX2ZlbmNlX2NvbnRleHRfYWxsb2ModW5zaWduZWQgbnVtKQo+ICAgfQo+ ICAgRVhQT1JUX1NZTUJPTChkbWFfZmVuY2VfY29udGV4dF9hbGxvYyk7Cj4gICAKPiArLyoqCj4g KyAqIERPQzogZmVuY2Ugc2lnbmFsbGluZyBhbm5vdGF0aW9uCj4gKyAqCj4gKyAqIFByb3Zpbmcg Y29ycmVjdG5lc3Mgb2YgYWxsIHRoZSBrZXJuZWwgY29kZSBhcm91bmQgJmRtYV9mZW5jZSB0aHJv dWdoIGNvZGUKPiArICogcmV2aWV3IGFuZCB0ZXN0aW5nIGlzIHRyaWNreSBmb3IgYSBmZXcgcmVh c29uczoKPiArICoKPiArICogKiBJdCBpcyBhIGNyb3NzLWRyaXZlciBjb250cmFjdCwgYW5kIHRo ZXJlZm9yZSBhbGwgZHJpdmVycyBtdXN0IGZvbGxvdyB0aGUKPiArICogICBzYW1lIHJ1bGVzIGZv ciBsb2NrIG5lc3Rpbmcgb3JkZXIsIGNhbGxpbmcgY29udGV4dHMgZm9yIHZhcmlvdXMgZnVuY3Rp b25zCj4gKyAqICAgYW5kIGFueXRoaW5nIGVsc2Ugc2lnbmlmaWNhbnQgZm9yIGluLWtlcm5lbCBp bnRlcmZhY2VzLiBCdXQgaXQgaXMgYWxzbwo+ICsgKiAgIGltcG9zc2libGUgdG8gdGVzdCBhbGwg ZHJpdmVycyBpbiBhIHNpbmdsZSBtYWNoaW5lLCBoZW5jZSBicnV0ZS1mb3JjZSBOIHZzLgo+ICsg KiAgIE4gdGVzdGluZyBvZiBhbGwgY29tYmluYXRpb25zIGlzIGltcG9zc2libGUuIEV2ZW4ganVz dCBsaW1pdGluZyB0byB0aGUKPiArICogICBwb3NzaWJsZSBjb21iaW5hdGlvbnMgaXMgaW5mZWFz aWJsZS4KPiArICoKPiArICogKiBUaGVyZSBpcyBhbiBlbm9ybW91cyBhbW91bnQgb2YgZHJpdmVy IGNvZGUgaW52b2x2ZWQuIEZvciByZW5kZXIgZHJpdmVycwo+ICsgKiAgIHRoZXJlJ3MgdGhlIHRh aWwgb2YgY29tbWFuZCBzdWJtaXNzaW9uLCBhZnRlciBmZW5jZXMgYXJlIHB1Ymxpc2hlZCwKPiAr ICogICBzY2hlZHVsZXIgY29kZSwgaW50ZXJydXB0IGFuZCB3b3JrZXJzIHRvIHByb2Nlc3Mgam9i IGNvbXBsZXRpb24sCj4gKyAqICAgYW5kIHRpbWVvdXQsIGdwdSByZXNldCBhbmQgZ3B1IGhhbmcg cmVjb3ZlcnkgY29kZS4gUGx1cyBmb3IgaW50ZWdyYXRpb24KPiArICogICB3aXRoIGNvcmUgbW0g d2l0aCBoYXZlICZtbXVfbm90aWZpZXIsIHJlc3BlY3RpdmVseSAmbW11X2ludGVydmFsX25vdGlm aWVyLAo+ICsgKiAgIGFuZCAmc2hyaW5rZXIuIEZvciBtb2Rlc2V0dGluZyBkcml2ZXJzIHRoZXJl J3MgdGhlIGNvbW1pdCB0YWlsIGZ1bmN0aW9ucwo+ICsgKiAgIGJldHdlZW4gd2hlbiBmZW5jZXMg Zm9yIGFuIGF0b21pYyBtb2Rlc2V0IGFyZSBwdWJsaXNoZWQsIGFuZCB3aGVuIHRoZQo+ICsgKiAg IGNvcnJlc3BvbmRpbmcgdmJsYW5rIGNvbXBsZXRlcywgaW5jbHVkaW5nIGFueSBpbnRlcnJ1cHQg cHJvY2Vzc2luZyBhbmQKPiArICogICByZWxhdGVkIHdvcmtlcnMuIEF1ZGl0aW5nIGFsbCB0aGF0 IGNvZGUsIGFjcm9zcyBhbGwgZHJpdmVycywgaXMgbm90Cj4gKyAqICAgZmVhc2libGUuCj4gKyAq Cj4gKyAqICogRHVlIHRvIGhvdyBtYW55IG90aGVyIHN1YnN5c3RlbXMgYXJlIGludm9sdmVkIGFu ZCB0aGUgbG9ja2luZyBoaWVyYXJjaGllcwo+ICsgKiAgIHRoaXMgcHVsbHMgaW4gdGhlcmUgaXMg ZXh0cmVtZWx5IHRoaW4gd2lnZ2xlLXJvb20gZm9yIGRyaXZlci1zcGVjaWZpYwo+ICsgKiAgIGRp ZmZlcmVuY2VzLiAmZG1hX2ZlbmNlIGludGVyYWN0cyB3aXRoIGFsbW9zdCBhbGwgb2YgdGhlIGNv cmUgbWVtb3J5Cj4gKyAqICAgaGFuZGxpbmcgdGhyb3VnaCBwYWdlIGZhdWx0IGhhbmRsZXJzIHZp YSAmZG1hX3Jlc3YsIGRtYV9yZXN2X2xvY2soKSBhbmQKPiArICogICBkbWFfcmVzdl91bmxvY2so KS4gT24gdGhlIG90aGVyIHNpZGUgaXQgYWxzbyBpbnRlcmFjdHMgdGhyb3VnaCBhbGwKPiArICog ICBhbGxvY2F0aW9uIHNpdGVzIHRocm91Z2ggJm1tdV9ub3RpZmllciBhbmQgJnNocmlua2VyLgo+ ICsgKgo+ICsgKiBGdXJ0aGVybW9yZSBsb2NrZGVwIGRvZXMgbm90IGhhbmRsZSBjcm9zcy1yZWxl YXNlIGRlcGVuZGVuY2llcywgd2hpY2ggbWVhbnMKPiArICogYW55IGRlYWRsb2NrcyBiZXR3ZWVu IGRtYV9mZW5jZV93YWl0KCkgYW5kIGRtYV9mZW5jZV9zaWduYWwoKSBjYW4ndCBiZSBjYXVnaHQK PiArICogYXQgcnVudGltZSB3aXRoIHNvbWUgcXVpY2sgdGVzdGluZy4gVGhlIHNpbXBsZXN0IGV4 YW1wbGUgaXMgb25lIHRocmVhZAo+ICsgKiB3YWl0aW5nIG9uIGEgJmRtYV9mZW5jZSB3aGlsZSBo b2xkaW5nIGEgbG9jazo6Cj4gKyAqCj4gKyAqICAgICBsb2NrKEEpOwo+ICsgKiAgICAgZG1hX2Zl bmNlX3dhaXQoQik7Cj4gKyAqICAgICB1bmxvY2soQSk7Cj4gKyAqCj4gKyAqIHdoaWxlIHRoZSBv dGhlciB0aHJlYWQgaXMgc3R1Y2sgdHJ5aW5nIHRvIGFjcXVpcmUgdGhlIHNhbWUgbG9jaywgd2hp Y2gKPiArICogcHJldmVudHMgaXQgZnJvbSBzaWduYWxsaW5nIHRoZSBmZW5jZSB0aGUgcHJldmlv dXMgdGhyZWFkIGlzIHN0dWNrIHdhaXRpbmcKPiArICogb246Ogo+ICsgKgo+ICsgKiAgICAgbG9j ayhBKTsKPiArICogICAgIHVubG9jayhBKTsKPiArICogICAgIGRtYV9mZW5jZV9zaWduYWwoQik7 Cj4gKyAqCj4gKyAqIEJ5IG1hbnVhbGx5IGFubm90YXRpbmcgYWxsIGNvZGUgcmVsZXZhbnQgdG8g c2lnbmFsbGluZyBhICZkbWFfZmVuY2Ugd2UgY2FuCj4gKyAqIHRlYWNoIGxvY2tkZXAgYWJvdXQg dGhlc2UgZGVwZW5kZW5jaWVzLCB3aGljaCBhbHNvIGhlbHBzIHdpdGggdGhlIHZhbGlkYXRpb24K PiArICogaGVhZGFjaGUgc2luY2Ugbm93IGxvY2tkZXAgY2FuIGNoZWNrIGFsbCB0aGUgcnVsZXMg Zm9yIHVzOjoKPiArICoKPiArICogICAgY29va2llID0gZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxp bmcoKTsKPiArICogICAgbG9jayhBKTsKPiArICogICAgdW5sb2NrKEEpOwo+ICsgKiAgICBkbWFf ZmVuY2Vfc2lnbmFsKEIpOwo+ICsgKiAgICBkbWFfZmVuY2VfZW5kX3NpZ25hbGxpbmcoY29va2ll KTsKPiArICoKPiArICogRm9yIHVzaW5nIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkgYW5k IGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpIHRvCj4gKyAqIGFubm90YXRlIGNyaXRpY2FsIHNl Y3Rpb25zIHRoZSBmb2xsb3dpbmcgcnVsZXMgbmVlZCB0byBiZSBvYnNlcnZlZDoKPiArICoKPiAr ICogKiBBbGwgY29kZSBuZWNlc3NhcnkgdG8gY29tcGxldGUgYSAmZG1hX2ZlbmNlIG11c3QgYmUg YW5ub3RhdGVkLCBmcm9tIHRoZQo+ICsgKiAgIHBvaW50IHdoZXJlIGEgZmVuY2UgaXMgYWNjZXNz aWJsZSB0byBvdGhlciB0aHJlYWRzLCB0byB0aGUgcG9pbnQgd2hlcmUKPiArICogICBkbWFfZmVu Y2Vfc2lnbmFsKCkgaXMgY2FsbGVkLiBVbi1hbm5vdGF0ZWQgY29kZSBjYW4gY29udGFpbiBkZWFk bG9jayBpc3N1ZXMsCj4gKyAqICAgYW5kIGR1ZSB0byB0aGUgdmVyeSBzdHJpY3QgcnVsZXMgYW5k IG1hbnkgY29ybmVyIGNhc2VzIGl0IGlzIGluZmVhc2libGUgdG8KPiArICogICBjYXRjaCB0aGVz ZSBqdXN0IHdpdGggcmV2aWV3IG9yIG5vcm1hbCBzdHJlc3MgdGVzdGluZy4KPiArICoKPiArICog KiAmc3RydWN0IGRtYV9yZXN2IGRlc2VydmVzIGEgc3BlY2lhbCBub3RlLCBzaW5jZSB0aGUgcmVh ZGVycyBhcmUgb25seQo+ICsgKiAgIHByb3RlY3RlZCBieSByY3UuIFRoaXMgbWVhbnMgdGhlIHNp Z25hbGxpbmcgY3JpdGljYWwgc2VjdGlvbiBzdGFydHMgYXMgc29vbgo+ICsgKiAgIGFzIHRoZSBu ZXcgZmVuY2VzIGFyZSBpbnN0YWxsZWQsIGV2ZW4gYmVmb3JlIGRtYV9yZXN2X3VubG9jaygpIGlz IGNhbGxlZC4KPiArICoKPiArICogKiBUaGUgb25seSBleGNlcHRpb24gYXJlIGZhc3QgcGF0aHMg YW5kIG9wcG9ydHVuaXN0aWMgc2lnbmFsbGluZyBjb2RlLCB3aGljaAo+ICsgKiAgIGNhbGxzIGRt YV9mZW5jZV9zaWduYWwoKSBwdXJlbHkgYXMgYW4gb3B0aW1pemF0aW9uLCBidXQgaXMgbm90IHJl cXVpcmVkIHRvCj4gKyAqICAgZ3VhcmFudGVlIGNvbXBsZXRpb24gb2YgYSAmZG1hX2ZlbmNlLiBU aGUgdXN1YWwgZXhhbXBsZSBpcyBhIHdhaXQgSU9DVEwKPiArICogICB3aGljaCBjYWxscyBkbWFf ZmVuY2Vfc2lnbmFsKCksIHdoaWxlIHRoZSBtYW5kYXRvcnkgY29tcGxldGlvbiBwYXRoIGdvZXMK PiArICogICB0aHJvdWdoIGEgaGFyZHdhcmUgaW50ZXJydXB0IGFuZCBwb3NzaWJsZSBqb2IgY29t cGxldGlvbiB3b3JrZXIuCj4gKyAqCj4gKyAqICogVG8gYWlkIGNvbXBvc2FiaWxpdHkgb2YgY29k ZSwgdGhlIGFubm90YXRpb25zIGNhbiBiZSBmcmVlbHkgbmVzdGVkLCBhcyBsb25nCj4gKyAqICAg YXMgdGhlIG92ZXJhbGwgbG9ja2luZyBoaWVyYXJjaHkgaXMgY29uc2lzdGVudC4gVGhlIGFubm90 YXRpb25zIGFsc28gd29yawo+ICsgKiAgIGJvdGggaW4gaW50ZXJydXB0IGFuZCBwcm9jZXNzIGNv bnRleHQuIER1ZSB0byBpbXBsZW1lbnRhdGlvbiBkZXRhaWxzIHRoaXMKPiArICogICByZXF1aXJl cyB0aGF0IGNhbGxlcnMgcGFzcyBhbiBvcGFxdWUgY29va2llIGZyb20KPiArICogICBkbWFfZmVu Y2VfYmVnaW5fc2lnbmFsbGluZygpIHRvIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgo+ICsg Kgo+ICsgKiAqIFZhbGlkYXRpb24gYWdhaW5zdCB0aGUgY3Jvc3MgZHJpdmVyIGNvbnRyYWN0IGlz IGltcGxlbWVudGVkIGJ5IHByaW1pbmcKPiArICogICBsb2NrZGVwIHdpdGggdGhlIHJlbGV2YW50 IGhpZXJhcmNoeSBhdCBib290LXVwLiBUaGlzIG1lYW5zIGV2ZW4ganVzdAo+ICsgKiAgIHRlc3Rp bmcgd2l0aCBhIHNpbmdsZSBkZXZpY2UgaXMgZW5vdWdoIHRvIHZhbGlkYXRlIGEgZHJpdmVyLCBh dCBsZWFzdCBhcwo+ICsgKiAgIGZhciBhcyBkZWFkbG9ja3Mgd2l0aCBkbWFfZmVuY2Vfd2FpdCgp IGFnYWluc3QgZG1hX2ZlbmNlX3NpZ25hbCgpIGFyZQo+ICsgKiAgIGNvbmNlcm5lZC4KPiArICov Cj4gKyNpZmRlZiBDT05GSUdfTE9DS0RFUAo+ICtzdHJ1Y3QgbG9ja2RlcF9tYXAJZG1hX2ZlbmNl X2xvY2tkZXBfbWFwID0gewo+ICsJLm5hbWUgPSAiZG1hX2ZlbmNlX21hcCIKPiArfTsKCk1heWJl IGEgc3R1cGlkIHF1ZXN0aW9uIGJlY2F1c2UgdGhpcyBpcyBkZWZpbml0ZWx5IGNvbXBsaWNhdGVk LCBidXQuLiBJZiAKeW91IGhhdmUgYSBzaW5nbGUvc3RhdGljL2dsb2JhbCBsb2NrZGVwIG1hcCwg ZG9lc24ndCB0aGlzIG1lYW4gX2FsbF8gCmxvY2tzLCBmcm9tIF9hbGxfIGRyaXZlcnMgaGFwcGVu aW5nIHRvIHVzZSBkbWEtZmVuY2VzIHdpbGwgZ2V0IHJlY29yZGVkIAppbiBpdC4gV2lsbCB0aGlz IHdvcmsgYW5kIG5vdCBjYXVzZSBmYWxzZSBwb3NpdGl2ZXM/CgpTb3VuZHMgbGlrZSBpdCBjb3Vs ZCBjcmVhdGUgYSBjb21tb24gbGluayBiZXR3ZWVuIHR3byBjb21wbGV0ZWx5IAp1bmNvbm5lY3Rl ZCB1c2FnZXMuIEJlY2F1c2UgYmVsb3cgeW91IGRvIGFkZCBhbm5vdGF0aW9ucyB0byBnZW5lcmlj IApkbWFfZmVuY2Vfc2lnbmFsIGFuZCBkbWFfZmVuY2Vfd2FpdC4KCj4gKwo+ICsvKioKPiArICog ZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxpbmcgLSBiZWdpbiBhIGNyaXRpY2FsIERNQSBmZW5jZSBz aWduYWxsaW5nIHNlY3Rpb24KPiArICoKPiArICogRHJpdmVycyBzaG91bGQgdXNlIHRoaXMgdG8g YW5ub3RhdGUgdGhlIGJlZ2lubmluZyBvZiBhbnkgY29kZSBzZWN0aW9uCj4gKyAqIHJlcXVpcmVk IHRvIGV2ZW50dWFsbHkgY29tcGxldGUgJmRtYV9mZW5jZSBieSBjYWxsaW5nIGRtYV9mZW5jZV9z aWduYWwoKS4KPiArICoKPiArICogVGhlIGVuZCBvZiB0aGVzZSBjcml0aWNhbCBzZWN0aW9ucyBh cmUgYW5ub3RhdGVkIHdpdGgKPiArICogZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKCkuCj4gKyAq Cj4gKyAqIFJldHVybnM6Cj4gKyAqCj4gKyAqIE9wYXF1ZSBjb29raWUgbmVlZGVkIGJ5IHRoZSBp bXBsZW1lbnRhdGlvbiwgd2hpY2ggbmVlZHMgdG8gYmUgcGFzc2VkIHRvCj4gKyAqIGRtYV9mZW5j ZV9lbmRfc2lnbmFsbGluZygpLgo+ICsgKi8KPiArYm9vbCBkbWFfZmVuY2VfYmVnaW5fc2lnbmFs bGluZyh2b2lkKQo+ICt7Cj4gKwkvKiBleHBsaWNpdGx5IG5lc3RpbmcgLi4uICovCj4gKwlpZiAo bG9ja19pc19oZWxkX3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSkpCj4gKwkJcmV0dXJu IHRydWU7Cj4gKwo+ICsJLyogcmVseSBvbiBtaWdodF9zbGVlcCBjaGVjayBmb3Igc29mdC9oYXJk aXJxIGxvY2tzICovCj4gKwlpZiAoaW5fYXRvbWljKCkpCj4gKwkJcmV0dXJuIHRydWU7Cj4gKwo+ ICsJLyogLi4uIGFuZCBub24tcmVjdXJzaXZlIHJlYWRsb2NrICovCj4gKwlsb2NrX2FjcXVpcmUo JmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMCwgMCwgMSwgMSwgTlVMTCwgX1JFVF9JUF8pOwoKV291 bGQgaXQgd29yayBpZiBzaWduYWxsaW5nIHBhdGggd291bGQgbWFyayBpdHNlbGYgYXMgYSB3cml0 ZSBsb2NrPyBJIGFtIAp0aGlua2luZyBpdCB3b3VsZCBiZSBuaWNlIHRvIHNlZSBpbiBsb2NrZGVw IHNwbGF0cyB3aGF0IGFyZSBzaWduYWxzIGFuZCAKd2hhdCBhcmUgd2FpdHMuCgpUaGUgcmVjdXJz aXZlIHVzYWdlIHdvdWxkbid0IHdvcmsgdGhlbiByaWdodD8gV291bGQgd3JpdGUgYW5ub3RhdGlv biBvbiAKdGhlIHdhaXQgcGF0aCB3b3JrPwoKUmVnYXJkcywKClR2cnRrbwoKPiArCj4gKwlyZXR1 cm4gZmFsc2U7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGlu Zyk7Cj4gKwo+ICsvKioKPiArICogZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nIC0gZW5kIGEgY3Jp dGljYWwgRE1BIGZlbmNlIHNpZ25hbGxpbmcgc2VjdGlvbgo+ICsgKgo+ICsgKiBDbG9zZXMgYSBj cml0aWNhbCBzZWN0aW9uIGFubm90YXRpb24gb3BlbmVkIGJ5IGRtYV9mZW5jZV9iZWdpbl9zaWdu YWxsaW5nKCkuCj4gKyAqLwo+ICt2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhib29sIGNv b2tpZSkKPiArewo+ICsJaWYgKGNvb2tpZSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJbG9ja19yZWxl YXNlKCZkbWFfZmVuY2VfbG9ja2RlcF9tYXAsIF9SRVRfSVBfKTsKPiArfQo+ICtFWFBPUlRfU1lN Qk9MKGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyk7Cj4gKwo+ICt2b2lkIF9fZG1hX2ZlbmNlX21p Z2h0X3dhaXQodm9pZCkKPiArewo+ICsJYm9vbCB0bXA7Cj4gKwo+ICsJdG1wID0gbG9ja19pc19o ZWxkX3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSk7Cj4gKwlpZiAodG1wKQo+ICsJCWxv Y2tfcmVsZWFzZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCBfVEhJU19JUF8pOwo+ICsJbG9ja19t YXBfYWNxdWlyZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwKTsKPiArCWxvY2tfbWFwX3JlbGVhc2Uo JmRtYV9mZW5jZV9sb2NrZGVwX21hcCk7Cj4gKwlpZiAodG1wKQo+ICsJCWxvY2tfYWNxdWlyZSgm ZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCAwLCAwLCAxLCAxLCBOVUxMLCBfVEhJU19JUF8pOwo+ICt9 Cj4gKyNlbmRpZgo+ICsKPiArCj4gICAvKioKPiAgICAqIGRtYV9mZW5jZV9zaWduYWxfbG9ja2Vk IC0gc2lnbmFsIGNvbXBsZXRpb24gb2YgYSBmZW5jZQo+ICAgICogQGZlbmNlOiB0aGUgZmVuY2Ug dG8gc2lnbmFsCj4gQEAgLTE3MCwxNCArMzI0LDE5IEBAIGludCBkbWFfZmVuY2Vfc2lnbmFsKHN0 cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQo+ICAgewo+ICAgCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4g ICAJaW50IHJldDsKPiArCWJvb2wgdG1wOwo+ICAgCj4gICAJaWYgKCFmZW5jZSkKPiAgIAkJcmV0 dXJuIC1FSU5WQUw7Cj4gICAKPiArCXRtcCA9IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCk7 Cj4gKwo+ICAgCXNwaW5fbG9ja19pcnFzYXZlKGZlbmNlLT5sb2NrLCBmbGFncyk7Cj4gICAJcmV0 ID0gZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoZmVuY2UpOwo+ICAgCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoZmVuY2UtPmxvY2ssIGZsYWdzKTsKPiAgIAo+ICsJZG1hX2ZlbmNlX2VuZF9zaWduYWxs aW5nKHRtcCk7Cj4gKwo+ICAgCXJldHVybiByZXQ7Cj4gICB9Cj4gICBFWFBPUlRfU1lNQk9MKGRt YV9mZW5jZV9zaWduYWwpOwo+IEBAIC0yMTAsNiArMzY5LDggQEAgZG1hX2ZlbmNlX3dhaXRfdGlt ZW91dChzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwgYm9vbCBpbnRyLCBzaWduZWQgbG9uZyB0aW1l b3V0KQo+ICAgCj4gICAJbWlnaHRfc2xlZXAoKTsKPiAgIAo+ICsJX19kbWFfZmVuY2VfbWlnaHRf d2FpdCgpOwo+ICsKPiAgIAl0cmFjZV9kbWFfZmVuY2Vfd2FpdF9zdGFydChmZW5jZSk7Cj4gICAJ aWYgKGZlbmNlLT5vcHMtPndhaXQpCj4gICAJCXJldCA9IGZlbmNlLT5vcHMtPndhaXQoZmVuY2Us IGludHIsIHRpbWVvdXQpOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5o IGIvaW5jbHVkZS9saW51eC9kbWEtZmVuY2UuaAo+IGluZGV4IDMzNDdjNTRmM2E4Ny4uM2YyODhm N2RiMmVmIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvZG1hLWZlbmNlLmgKPiArKysgYi9p bmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCj4gQEAgLTM1Nyw2ICszNTcsMTggQEAgZG1hX2ZlbmNl X2dldF9yY3Vfc2FmZShzdHJ1Y3QgZG1hX2ZlbmNlIF9fcmN1ICoqZmVuY2VwKQo+ICAgCX0gd2hp bGUgKDEpOwo+ICAgfQo+ICAgCj4gKyNpZmRlZiBDT05GSUdfTE9DS0RFUAo+ICtib29sIGRtYV9m ZW5jZV9iZWdpbl9zaWduYWxsaW5nKHZvaWQpOwo+ICt2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFs bGluZyhib29sIGNvb2tpZSk7Cj4gKyNlbHNlCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBkbWFfZmVu Y2VfYmVnaW5fc2lnbmFsbGluZyh2b2lkKQo+ICt7Cj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICtz dGF0aWMgaW5saW5lIHZvaWQgZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKGJvb2wgY29va2llKSB7 fQo+ICtzdGF0aWMgaW5saW5lIHZvaWQgX19kbWFfZmVuY2VfbWlnaHRfd2FpdCh2b2lkKSB7fQo+ ICsjZW5kaWYKPiArCj4gICBpbnQgZG1hX2ZlbmNlX3NpZ25hbChzdHJ1Y3QgZG1hX2ZlbmNlICpm ZW5jZSk7Cj4gICBpbnQgZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoc3RydWN0IGRtYV9mZW5jZSAq ZmVuY2UpOwo+ICAgc2lnbmVkIGxvbmcgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdChzdHJ1Y3QgZG1h X2ZlbmNlICpmZW5jZSwKPiAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0 b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJp LWRldmVsCg== 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=-7.3 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, HK_RANDOM_FROM,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE, SPF_PASS,USER_AGENT_SANE_1 autolearn=unavailable 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 229FAC433E0 for ; Wed, 10 Jun 2020 14:22:06 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 EA3812067B for ; Wed, 10 Jun 2020 14:22:05 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org EA3812067B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 4C1296E52A; Wed, 10 Jun 2020 14:22:04 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id F3D3E89B67; Wed, 10 Jun 2020 14:22:02 +0000 (UTC) IronPort-SDR: 2BSiRpH+SklxWdy78cRGjm97kFpYYmCrrwZRmP3phftxHcnGZjfJspim3WvU21KE5ALPk4hOEV EhOVS/yQswVA== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:22:02 -0700 IronPort-SDR: ZXI7uPl/+gFtBOCO1ezzY/adZkhBrl05LWKKuG3izz+Rz/KzHBkHO1DHUyRtRF1+HN/H5NIQyj NDLjlxGdWGKg== X-IronPort-AV: E=Sophos;i="5.73,496,1583222400"; d="scan'208";a="418759078" Received: from unknown (HELO [10.214.244.237]) ([10.214.244.237]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jun 2020 07:21:56 -0700 To: Daniel Vetter , DRI Development References: <20200604081224.863494-1-daniel.vetter@ffwll.ch> <20200604081224.863494-4-daniel.vetter@ffwll.ch> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: Date: Wed, 10 Jun 2020 15:21:53 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.7.0 MIME-Version: 1.0 In-Reply-To: <20200604081224.863494-4-daniel.vetter@ffwll.ch> Content-Language: en-US Subject: Re: [Intel-gfx] [PATCH 03/18] dma-fence: basic lockdep annotations X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-rdma@vger.kernel.org, Intel Graphics Development , LKML , amd-gfx@lists.freedesktop.org, Chris Wilson , linaro-mm-sig@lists.linaro.org, Thomas Hellstrom , Daniel Vetter , Mika Kuoppala , =?UTF-8?Q?Christian_K=c3=b6nig?= , linux-media@vger.kernel.org Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Ck9uIDA0LzA2LzIwMjAgMDk6MTIsIERhbmllbCBWZXR0ZXIgd3JvdGU6Cj4gRGVzaWduIGlzIHNp bWlsYXIgdG8gdGhlIGxvY2tkZXAgYW5ub3RhdGlvbnMgZm9yIHdvcmtlcnMsIGJ1dCB3aXRoCj4g c29tZSB0d2lzdHM6Cj4gCj4gLSBXZSB1c2UgYSByZWFkLWxvY2sgZm9yIHRoZSBleGVjdXRpb24v d29ya2VyL2NvbXBsZXRpb24gc2lkZSwgc28gdGhhdAo+ICAgIHRoaXMgZXhwbGljaXQgYW5ub3Rh dGlvbiBjYW4gYmUgbW9yZSBsaWJlcmFsbHkgc3ByaW5rbGVkIGFyb3VuZC4KPiAgICBXaXRoIHJl YWQgbG9ja3MgbG9ja2RlcCBpc24ndCBnb2luZyB0byBjb21wbGFpbiBpZiB0aGUgcmVhZC1zaWRl Cj4gICAgaXNuJ3QgbmVzdGVkIHRoZSBzYW1lIHdheSB1bmRlciBhbGwgY2lyY3Vtc3RhbmNlcywg c28gQUJCQSBkZWFkbG9ja3MKPiAgICBhcmUgb2suIFdoaWNoIHRoZXkgYXJlLCBzaW5jZSB0aGlz IGlzIGFuIGFubm90YXRpb24gb25seS4KPiAKPiAtIFdlJ3JlIHVzaW5nIG5vbi1yZWN1cnNpdmUg bG9ja2RlcCByZWFkIGxvY2sgbW9kZSwgc2luY2UgaW4gcmVjdXJzaXZlCj4gICAgcmVhZCBsb2Nr IG1vZGUgbG9ja2RlcCBkb2VzIG5vdCBjYXRjaCByZWFkIHNpZGUgaGF6YXJkcy4gQW5kIHdlCj4g ICAgX3ZlcnlfIG11Y2ggd2FudCByZWFkIHNpZGUgaGF6YXJkcyB0byBiZSBjYXVnaHQuIEZvciBm dWxsIGRldGFpbHMgb2YKPiAgICB0aGlzIGxpbWl0YXRpb24gc2VlCj4gCj4gICAgY29tbWl0IGU5 MTQ5ODU4OTc0NjA2NWUzYWU5NWQ5YTAwYjA2OGU1MjVlZWMzNGYKPiAgICBBdXRob3I6IFBldGVy IFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFkLm9yZz4KPiAgICBEYXRlOiAgIFdlZCBBdWcgMjMg MTM6MTM6MTEgMjAxNyArMDIwMAo+IAo+ICAgICAgICBsb2NraW5nL2xvY2tkZXAvc2VsZnRlc3Rz OiBBZGQgbWl4ZWQgcmVhZC13cml0ZSBBQkJBIHRlc3RzCj4gCj4gLSBUbyBhbGxvdyBuZXN0aW5n IG9mIHRoZSByZWFkLXNpZGUgZXhwbGljaXQgYW5ub3RhdGlvbnMgd2UgZXhwbGljaXRseQo+ICAg IGtlZXAgdHJhY2sgb2YgdGhlIG5lc3RpbmcuIGxvY2tfaXNfaGVsZCgpIGFsbG93cyB1cyB0byBk byB0aGF0Lgo+IAo+IC0gVGhlIHdhaXQtc2lkZSBhbm5vdGF0aW9uIGlzIGEgd3JpdGUgbG9jaywg YW5kIGVudGlyZWx5IGRvbmUgd2l0aGluCj4gICAgZG1hX2ZlbmNlX3dhaXQoKSBmb3IgZXZlcnlv bmUgYnkgZGVmYXVsdC4KPiAKPiAtIFRvIGJlIGFibGUgdG8gZnJlZWx5IGFubm90YXRlIGhlbHBl ciBmdW5jdGlvbnMgSSB3YW50IHRvIG1ha2UgaXQgb2sKPiAgICB0byBjYWxsIGRtYV9mZW5jZV9i ZWdpbi9lbmRfc2lnbmFsbGluZyBmcm9tIHNvZnQvaGFyZGlycSBjb250ZXh0Lgo+ICAgIEZpcnN0 IGF0dGVtcHQgd2FzIHVzaW5nIHRoZSBoYXJkaXJxIGxvY2tpbmcgY29udGV4dCBmb3IgdGhlIHdy aXRlCj4gICAgc2lkZSBpbiBsb2NrZGVwLCBidXQgdGhpcyBmb3JjZXMgYWxsIG5vcm1hbCBzcGlu bG9ja3MgbmVzdGVkIHdpdGhpbgo+ICAgIGRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZyB0 byBiZSBzcGlubG9ja3MuIFRoYXQgYm9sbG9ja3MuCj4gCj4gICAgVGhlIGFwcHJvYWNoIG5vdyBp cyB0byBzaW1wbGUgY2hlY2sgaW5fYXRvbWljKCksIGFuZCBmb3IgdGhlc2UgY2FzZXMKPiAgICBl bnRpcmVseSByZWx5IG9uIHRoZSBtaWdodF9zbGVlcCgpIGNoZWNrIGluIGRtYV9mZW5jZV93YWl0 KCkuIFRoYXQKPiAgICB3aWxsIGNhdGNoIGFueSB3cm9uZyBuZXN0aW5nIGFnYWluc3Qgc3Bpbmxv Y2tzIGZyb20gc29mdC9oYXJkaXJxCj4gICAgY29udGV4dHMuCj4gCj4gVGhlIGlkZWEgaGVyZSBp cyB0aGF0IGV2ZXJ5IGNvZGUgcGF0aCB0aGF0J3MgY3JpdGljYWwgZm9yIGV2ZW50dWFsbHkKPiBz aWduYWxsaW5nIGEgZG1hX2ZlbmNlIHNob3VsZCBiZSBhbm5vdGF0ZWQgd2l0aAo+IGRtYV9mZW5j ZV9iZWdpbi9lbmRfc2lnbmFsbGluZy4gVGhlIGFubm90YXRpb24gaWRlYWxseSBzdGFydHMgcmln aHQKPiBhZnRlciBhIGRtYV9mZW5jZSBpcyBwdWJsaXNoZWQgKGFkZGVkIHRvIGEgZG1hX3Jlc3Ys IGV4cG9zZWQgYXMgYQo+IHN5bmNfZmlsZSBmZCwgYXR0YWNoZWQgdG8gYSBkcm1fc3luY29iaiBm ZCwgb3IgYW55dGhpbmcgZWxzZSB0aGF0Cj4gbWFrZXMgdGhlIGRtYV9mZW5jZSB2aXNpYmxlIHRv IG90aGVyIGtlcm5lbCB0aHJlYWRzKSwgdXAgdG8gYW5kCj4gaW5jbHVkaW5nIHRoZSBkbWFfZmVu Y2Vfd2FpdCgpLiBFeGFtcGxlcyBhcmUgaXJxIGhhbmRsZXJzLCB0aGUKPiBzY2hlZHVsZXIgcnQg dGhyZWFkcywgdGhlIHRhaWwgb2YgZXhlY2J1ZiAoYWZ0ZXIgdGhlIGNvcnJlc3BvbmRpbmcKPiBm ZW5jZXMgYXJlIHZpc2libGUpLCBhbnkgd29ya2VycyB0aGF0IGVuZCB1cCBzaWduYWxsaW5nIGRt YV9mZW5jZXMgYW5kCj4gcmVhbGx5IGFueXRoaW5nIGVsc2UuIE5vdCBhbm5vdGF0ZWQgc2hvdWxk IGJlIGNvZGUgcGF0aHMgdGhhdCBvbmx5Cj4gY29tcGxldGUgZmVuY2VzIG9wcG9ydHVuaXN0aWNh bGx5IGFzIHRoZSBncHUgcHJvZ3Jlc3NlcywgbGlrZSBlLmcuCj4gc2hyaW5rZXIvZXZpY3Rpb24g Y29kZS4KPiAKPiBUaGUgbWFpbiBjbGFzcyBvZiBkZWFkbG9ja3MgdGhpcyBpcyBzdXBwb3NlZCB0 byBjYXRjaCBhcmU6Cj4gCj4gVGhyZWFkIEE6Cj4gCj4gCW11dGV4X2xvY2soQSk7Cj4gCW11dGV4 X3VubG9jayhBKTsKPiAKPiAJZG1hX2ZlbmNlX3NpZ25hbCgpOwo+IAo+IFRocmVhZCBCOgo+IAo+ IAltdXRleF9sb2NrKEEpOwo+IAlkbWFfZmVuY2Vfd2FpdCgpOwo+IAltdXRleF91bmxvY2soQSk7 Cj4gCj4gVGhyZWFkIEIgaXMgYmxvY2tlZCBvbiBBIHNpZ25hbGxpbmcgdGhlIGZlbmNlLCBidXQg QSBuZXZlciBnZXRzIGFyb3VuZAo+IHRvIHRoYXQgYmVjYXVzZSBpdCBjYW5ub3QgYWNxdWlyZSB0 aGUgbG9jayBBLgo+IAo+IE5vdGUgdGhhdCBkbWFfZmVuY2Vfd2FpdCgpIGlzIGFsbG93ZWQgdG8g YmUgbmVzdGVkIHdpdGhpbgo+IGRtYV9mZW5jZV9iZWdpbi9lbmRfc2lnbmFsbGluZyBzZWN0aW9u cy4gVG8gYWxsb3cgdGhpcyB0byBoYXBwZW4gdGhlCj4gcmVhZCBsb2NrIG5lZWRzIHRvIGJlIHVw Z3JhZGVkIHRvIGEgd3JpdGUgbG9jaywgd2hpY2ggbWVhbnMgdGhhdCBhbnkKPiBvdGhlciBsb2Nr IGlzIGFjcXVpcmVkIGJldHdlZW4gdGhlIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkgY2Fs bCBhbmQKPiB0aGUgY2FsbCB0byBkbWFfZmVuY2Vfd2FpdCgpLCBhbmQgc3RpbGwgaGVsZCwgdGhp cyB3aWxsIHJlc3VsdCBpbiBhbgo+IGltbWVkaWF0ZSBsb2NrZGVwIGNvbXBsYWludC4gVGhlIG9u bHkgb3RoZXIgb3B0aW9uIHdvdWxkIGJlIHRvIG5vdAo+IGFubm90YXRlIHN1Y2ggY2FsbHMsIGRl ZmVhdGluZyB0aGUgcG9pbnQuIFRoZXJlZm9yZSB0aGVzZSBhbm5vdGF0aW9ucwo+IGNhbm5vdCBi ZSBzcHJpbmtsZWQgb3ZlciB0aGUgY29kZSBlbnRpcmVseSBtaW5kbGVzcyB0byBhdm9pZCBmYWxz ZQo+IHBvc2l0aXZlcy4KPiAKPiB2MjogaGFuZGxlIHNvZnQvaGFyZGlycSBjdHggYmV0dGVyIGFn YWluc3Qgd3JpdGUgc2lkZSBhbmQgZG9udCBmb3JnZXQKPiBFWFBPUlRfU1lNQk9MLCBkcml2ZXJz IGNhbid0IHVzZSB0aGlzIG90aGVyd2lzZS4KPiAKPiB2MzogS2VybmVsZG9jLgo+IAo+IHY0OiBT b21lIHNwZWxsaW5nIGZpeGVzIGZyb20gTWlrYQo+IAo+IENjOiBNaWthIEt1b3BwYWxhIDxtaWth Lmt1b3BwYWxhQGludGVsLmNvbT4KPiBDYzogVGhvbWFzIEhlbGxzdHJvbSA8dGhvbWFzLmhlbGxz dHJvbUBpbnRlbC5jb20+Cj4gQ2M6IGxpbnV4LW1lZGlhQHZnZXIua2VybmVsLm9yZwo+IENjOiBs aW5hcm8tbW0tc2lnQGxpc3RzLmxpbmFyby5vcmcKPiBDYzogbGludXgtcmRtYUB2Z2VyLmtlcm5l bC5vcmcKPiBDYzogYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBDYzogaW50ZWwtZ2Z4 QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IENjOiBDaHJpcyBXaWxzb24gPGNocmlzQGNocmlzLXdp bHNvbi5jby51az4KPiBDYzogTWFhcnRlbiBMYW5raG9yc3QgPG1hYXJ0ZW4ubGFua2hvcnN0QGxp bnV4LmludGVsLmNvbT4KPiBDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0Bh bWQuY29tPgo+IFNpZ25lZC1vZmYtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50 ZWwuY29tPgo+IC0tLQo+ICAgRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0IHwg IDEyICstCj4gICBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMgICAgICAgICAgfCAxNjEgKysr KysrKysrKysrKysrKysrKysrKysrKysrCj4gICBpbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oICAg ICAgICAgICAgfCAgMTIgKysKPiAgIDMgZmlsZXMgY2hhbmdlZCwgMTgyIGluc2VydGlvbnMoKyks IDMgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFw aS9kbWEtYnVmLnJzdCBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdAo+IGlu ZGV4IDYzZGVjNzZkMWQ4ZC4uMDVkODU2MTMxMTQwIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRp b24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFw aS9kbWEtYnVmLnJzdAo+IEBAIC0xMDAsMTEgKzEwMCwxMSBAQCBDUFUgQWNjZXNzIHRvIERNQSBC dWZmZXIgT2JqZWN0cwo+ICAgLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVm LmMKPiAgICAgIDpkb2M6IGNwdSBhY2Nlc3MKPiAgIAo+IC1GZW5jZSBQb2xsIFN1cHBvcnQKPiAt fn5+fn5+fn5+fn5+fn5+fn5+Cj4gK0ltcGxpY2l0IEZlbmNlIFBvbGwgU3VwcG9ydAo+ICt+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KPiAgIAo+ICAgLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMv ZG1hLWJ1Zi9kbWEtYnVmLmMKPiAtICAgOmRvYzogZmVuY2UgcG9sbGluZwo+ICsgICA6ZG9jOiBp bXBsaWNpdCBmZW5jZSBwb2xsaW5nCj4gICAKPiAgIEtlcm5lbCBGdW5jdGlvbnMgYW5kIFN0cnVj dHVyZXMgUmVmZXJlbmNlCj4gICB+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+ fn5+fgo+IEBAIC0xMzMsNiArMTMzLDEyIEBAIERNQSBGZW5jZXMKPiAgIC4uIGtlcm5lbC1kb2M6 OiBkcml2ZXJzL2RtYS1idWYvZG1hLWZlbmNlLmMKPiAgICAgIDpkb2M6IERNQSBmZW5jZXMgb3Zl cnZpZXcKPiAgIAo+ICtETUEgRmVuY2UgU2lnbmFsbGluZyBBbm5vdGF0aW9ucwo+ICt+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgo+ICsKPiArLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMv ZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+ICsgICA6ZG9jOiBmZW5jZSBzaWduYWxsaW5nIGFubm90YXRp b24KPiArCj4gICBETUEgRmVuY2VzIEZ1bmN0aW9ucyBSZWZlcmVuY2UKPiAgIH5+fn5+fn5+fn5+ fn5+fn5+fn5+fn5+fn5+fn5+fgo+ICAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9k bWEtZmVuY2UuYyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+IGluZGV4IDY1NmU5YWMy ZDAyOC4uMDAwNWJjMDAyNTI5IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVu Y2UuYwo+ICsrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtZmVuY2UuYwo+IEBAIC0xMTAsNiArMTEw LDE2MCBAQCB1NjQgZG1hX2ZlbmNlX2NvbnRleHRfYWxsb2ModW5zaWduZWQgbnVtKQo+ICAgfQo+ ICAgRVhQT1JUX1NZTUJPTChkbWFfZmVuY2VfY29udGV4dF9hbGxvYyk7Cj4gICAKPiArLyoqCj4g KyAqIERPQzogZmVuY2Ugc2lnbmFsbGluZyBhbm5vdGF0aW9uCj4gKyAqCj4gKyAqIFByb3Zpbmcg Y29ycmVjdG5lc3Mgb2YgYWxsIHRoZSBrZXJuZWwgY29kZSBhcm91bmQgJmRtYV9mZW5jZSB0aHJv dWdoIGNvZGUKPiArICogcmV2aWV3IGFuZCB0ZXN0aW5nIGlzIHRyaWNreSBmb3IgYSBmZXcgcmVh c29uczoKPiArICoKPiArICogKiBJdCBpcyBhIGNyb3NzLWRyaXZlciBjb250cmFjdCwgYW5kIHRo ZXJlZm9yZSBhbGwgZHJpdmVycyBtdXN0IGZvbGxvdyB0aGUKPiArICogICBzYW1lIHJ1bGVzIGZv ciBsb2NrIG5lc3Rpbmcgb3JkZXIsIGNhbGxpbmcgY29udGV4dHMgZm9yIHZhcmlvdXMgZnVuY3Rp b25zCj4gKyAqICAgYW5kIGFueXRoaW5nIGVsc2Ugc2lnbmlmaWNhbnQgZm9yIGluLWtlcm5lbCBp bnRlcmZhY2VzLiBCdXQgaXQgaXMgYWxzbwo+ICsgKiAgIGltcG9zc2libGUgdG8gdGVzdCBhbGwg ZHJpdmVycyBpbiBhIHNpbmdsZSBtYWNoaW5lLCBoZW5jZSBicnV0ZS1mb3JjZSBOIHZzLgo+ICsg KiAgIE4gdGVzdGluZyBvZiBhbGwgY29tYmluYXRpb25zIGlzIGltcG9zc2libGUuIEV2ZW4ganVz dCBsaW1pdGluZyB0byB0aGUKPiArICogICBwb3NzaWJsZSBjb21iaW5hdGlvbnMgaXMgaW5mZWFz aWJsZS4KPiArICoKPiArICogKiBUaGVyZSBpcyBhbiBlbm9ybW91cyBhbW91bnQgb2YgZHJpdmVy IGNvZGUgaW52b2x2ZWQuIEZvciByZW5kZXIgZHJpdmVycwo+ICsgKiAgIHRoZXJlJ3MgdGhlIHRh aWwgb2YgY29tbWFuZCBzdWJtaXNzaW9uLCBhZnRlciBmZW5jZXMgYXJlIHB1Ymxpc2hlZCwKPiAr ICogICBzY2hlZHVsZXIgY29kZSwgaW50ZXJydXB0IGFuZCB3b3JrZXJzIHRvIHByb2Nlc3Mgam9i IGNvbXBsZXRpb24sCj4gKyAqICAgYW5kIHRpbWVvdXQsIGdwdSByZXNldCBhbmQgZ3B1IGhhbmcg cmVjb3ZlcnkgY29kZS4gUGx1cyBmb3IgaW50ZWdyYXRpb24KPiArICogICB3aXRoIGNvcmUgbW0g d2l0aCBoYXZlICZtbXVfbm90aWZpZXIsIHJlc3BlY3RpdmVseSAmbW11X2ludGVydmFsX25vdGlm aWVyLAo+ICsgKiAgIGFuZCAmc2hyaW5rZXIuIEZvciBtb2Rlc2V0dGluZyBkcml2ZXJzIHRoZXJl J3MgdGhlIGNvbW1pdCB0YWlsIGZ1bmN0aW9ucwo+ICsgKiAgIGJldHdlZW4gd2hlbiBmZW5jZXMg Zm9yIGFuIGF0b21pYyBtb2Rlc2V0IGFyZSBwdWJsaXNoZWQsIGFuZCB3aGVuIHRoZQo+ICsgKiAg IGNvcnJlc3BvbmRpbmcgdmJsYW5rIGNvbXBsZXRlcywgaW5jbHVkaW5nIGFueSBpbnRlcnJ1cHQg cHJvY2Vzc2luZyBhbmQKPiArICogICByZWxhdGVkIHdvcmtlcnMuIEF1ZGl0aW5nIGFsbCB0aGF0 IGNvZGUsIGFjcm9zcyBhbGwgZHJpdmVycywgaXMgbm90Cj4gKyAqICAgZmVhc2libGUuCj4gKyAq Cj4gKyAqICogRHVlIHRvIGhvdyBtYW55IG90aGVyIHN1YnN5c3RlbXMgYXJlIGludm9sdmVkIGFu ZCB0aGUgbG9ja2luZyBoaWVyYXJjaGllcwo+ICsgKiAgIHRoaXMgcHVsbHMgaW4gdGhlcmUgaXMg ZXh0cmVtZWx5IHRoaW4gd2lnZ2xlLXJvb20gZm9yIGRyaXZlci1zcGVjaWZpYwo+ICsgKiAgIGRp ZmZlcmVuY2VzLiAmZG1hX2ZlbmNlIGludGVyYWN0cyB3aXRoIGFsbW9zdCBhbGwgb2YgdGhlIGNv cmUgbWVtb3J5Cj4gKyAqICAgaGFuZGxpbmcgdGhyb3VnaCBwYWdlIGZhdWx0IGhhbmRsZXJzIHZp YSAmZG1hX3Jlc3YsIGRtYV9yZXN2X2xvY2soKSBhbmQKPiArICogICBkbWFfcmVzdl91bmxvY2so KS4gT24gdGhlIG90aGVyIHNpZGUgaXQgYWxzbyBpbnRlcmFjdHMgdGhyb3VnaCBhbGwKPiArICog ICBhbGxvY2F0aW9uIHNpdGVzIHRocm91Z2ggJm1tdV9ub3RpZmllciBhbmQgJnNocmlua2VyLgo+ ICsgKgo+ICsgKiBGdXJ0aGVybW9yZSBsb2NrZGVwIGRvZXMgbm90IGhhbmRsZSBjcm9zcy1yZWxl YXNlIGRlcGVuZGVuY2llcywgd2hpY2ggbWVhbnMKPiArICogYW55IGRlYWRsb2NrcyBiZXR3ZWVu IGRtYV9mZW5jZV93YWl0KCkgYW5kIGRtYV9mZW5jZV9zaWduYWwoKSBjYW4ndCBiZSBjYXVnaHQK PiArICogYXQgcnVudGltZSB3aXRoIHNvbWUgcXVpY2sgdGVzdGluZy4gVGhlIHNpbXBsZXN0IGV4 YW1wbGUgaXMgb25lIHRocmVhZAo+ICsgKiB3YWl0aW5nIG9uIGEgJmRtYV9mZW5jZSB3aGlsZSBo b2xkaW5nIGEgbG9jazo6Cj4gKyAqCj4gKyAqICAgICBsb2NrKEEpOwo+ICsgKiAgICAgZG1hX2Zl bmNlX3dhaXQoQik7Cj4gKyAqICAgICB1bmxvY2soQSk7Cj4gKyAqCj4gKyAqIHdoaWxlIHRoZSBv dGhlciB0aHJlYWQgaXMgc3R1Y2sgdHJ5aW5nIHRvIGFjcXVpcmUgdGhlIHNhbWUgbG9jaywgd2hp Y2gKPiArICogcHJldmVudHMgaXQgZnJvbSBzaWduYWxsaW5nIHRoZSBmZW5jZSB0aGUgcHJldmlv dXMgdGhyZWFkIGlzIHN0dWNrIHdhaXRpbmcKPiArICogb246Ogo+ICsgKgo+ICsgKiAgICAgbG9j ayhBKTsKPiArICogICAgIHVubG9jayhBKTsKPiArICogICAgIGRtYV9mZW5jZV9zaWduYWwoQik7 Cj4gKyAqCj4gKyAqIEJ5IG1hbnVhbGx5IGFubm90YXRpbmcgYWxsIGNvZGUgcmVsZXZhbnQgdG8g c2lnbmFsbGluZyBhICZkbWFfZmVuY2Ugd2UgY2FuCj4gKyAqIHRlYWNoIGxvY2tkZXAgYWJvdXQg dGhlc2UgZGVwZW5kZW5jaWVzLCB3aGljaCBhbHNvIGhlbHBzIHdpdGggdGhlIHZhbGlkYXRpb24K PiArICogaGVhZGFjaGUgc2luY2Ugbm93IGxvY2tkZXAgY2FuIGNoZWNrIGFsbCB0aGUgcnVsZXMg Zm9yIHVzOjoKPiArICoKPiArICogICAgY29va2llID0gZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxp bmcoKTsKPiArICogICAgbG9jayhBKTsKPiArICogICAgdW5sb2NrKEEpOwo+ICsgKiAgICBkbWFf ZmVuY2Vfc2lnbmFsKEIpOwo+ICsgKiAgICBkbWFfZmVuY2VfZW5kX3NpZ25hbGxpbmcoY29va2ll KTsKPiArICoKPiArICogRm9yIHVzaW5nIGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCkgYW5k IGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpIHRvCj4gKyAqIGFubm90YXRlIGNyaXRpY2FsIHNl Y3Rpb25zIHRoZSBmb2xsb3dpbmcgcnVsZXMgbmVlZCB0byBiZSBvYnNlcnZlZDoKPiArICoKPiAr ICogKiBBbGwgY29kZSBuZWNlc3NhcnkgdG8gY29tcGxldGUgYSAmZG1hX2ZlbmNlIG11c3QgYmUg YW5ub3RhdGVkLCBmcm9tIHRoZQo+ICsgKiAgIHBvaW50IHdoZXJlIGEgZmVuY2UgaXMgYWNjZXNz aWJsZSB0byBvdGhlciB0aHJlYWRzLCB0byB0aGUgcG9pbnQgd2hlcmUKPiArICogICBkbWFfZmVu Y2Vfc2lnbmFsKCkgaXMgY2FsbGVkLiBVbi1hbm5vdGF0ZWQgY29kZSBjYW4gY29udGFpbiBkZWFk bG9jayBpc3N1ZXMsCj4gKyAqICAgYW5kIGR1ZSB0byB0aGUgdmVyeSBzdHJpY3QgcnVsZXMgYW5k IG1hbnkgY29ybmVyIGNhc2VzIGl0IGlzIGluZmVhc2libGUgdG8KPiArICogICBjYXRjaCB0aGVz ZSBqdXN0IHdpdGggcmV2aWV3IG9yIG5vcm1hbCBzdHJlc3MgdGVzdGluZy4KPiArICoKPiArICog KiAmc3RydWN0IGRtYV9yZXN2IGRlc2VydmVzIGEgc3BlY2lhbCBub3RlLCBzaW5jZSB0aGUgcmVh ZGVycyBhcmUgb25seQo+ICsgKiAgIHByb3RlY3RlZCBieSByY3UuIFRoaXMgbWVhbnMgdGhlIHNp Z25hbGxpbmcgY3JpdGljYWwgc2VjdGlvbiBzdGFydHMgYXMgc29vbgo+ICsgKiAgIGFzIHRoZSBu ZXcgZmVuY2VzIGFyZSBpbnN0YWxsZWQsIGV2ZW4gYmVmb3JlIGRtYV9yZXN2X3VubG9jaygpIGlz IGNhbGxlZC4KPiArICoKPiArICogKiBUaGUgb25seSBleGNlcHRpb24gYXJlIGZhc3QgcGF0aHMg YW5kIG9wcG9ydHVuaXN0aWMgc2lnbmFsbGluZyBjb2RlLCB3aGljaAo+ICsgKiAgIGNhbGxzIGRt YV9mZW5jZV9zaWduYWwoKSBwdXJlbHkgYXMgYW4gb3B0aW1pemF0aW9uLCBidXQgaXMgbm90IHJl cXVpcmVkIHRvCj4gKyAqICAgZ3VhcmFudGVlIGNvbXBsZXRpb24gb2YgYSAmZG1hX2ZlbmNlLiBU aGUgdXN1YWwgZXhhbXBsZSBpcyBhIHdhaXQgSU9DVEwKPiArICogICB3aGljaCBjYWxscyBkbWFf ZmVuY2Vfc2lnbmFsKCksIHdoaWxlIHRoZSBtYW5kYXRvcnkgY29tcGxldGlvbiBwYXRoIGdvZXMK PiArICogICB0aHJvdWdoIGEgaGFyZHdhcmUgaW50ZXJydXB0IGFuZCBwb3NzaWJsZSBqb2IgY29t cGxldGlvbiB3b3JrZXIuCj4gKyAqCj4gKyAqICogVG8gYWlkIGNvbXBvc2FiaWxpdHkgb2YgY29k ZSwgdGhlIGFubm90YXRpb25zIGNhbiBiZSBmcmVlbHkgbmVzdGVkLCBhcyBsb25nCj4gKyAqICAg YXMgdGhlIG92ZXJhbGwgbG9ja2luZyBoaWVyYXJjaHkgaXMgY29uc2lzdGVudC4gVGhlIGFubm90 YXRpb25zIGFsc28gd29yawo+ICsgKiAgIGJvdGggaW4gaW50ZXJydXB0IGFuZCBwcm9jZXNzIGNv bnRleHQuIER1ZSB0byBpbXBsZW1lbnRhdGlvbiBkZXRhaWxzIHRoaXMKPiArICogICByZXF1aXJl cyB0aGF0IGNhbGxlcnMgcGFzcyBhbiBvcGFxdWUgY29va2llIGZyb20KPiArICogICBkbWFfZmVu Y2VfYmVnaW5fc2lnbmFsbGluZygpIHRvIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZygpLgo+ICsg Kgo+ICsgKiAqIFZhbGlkYXRpb24gYWdhaW5zdCB0aGUgY3Jvc3MgZHJpdmVyIGNvbnRyYWN0IGlz IGltcGxlbWVudGVkIGJ5IHByaW1pbmcKPiArICogICBsb2NrZGVwIHdpdGggdGhlIHJlbGV2YW50 IGhpZXJhcmNoeSBhdCBib290LXVwLiBUaGlzIG1lYW5zIGV2ZW4ganVzdAo+ICsgKiAgIHRlc3Rp bmcgd2l0aCBhIHNpbmdsZSBkZXZpY2UgaXMgZW5vdWdoIHRvIHZhbGlkYXRlIGEgZHJpdmVyLCBh dCBsZWFzdCBhcwo+ICsgKiAgIGZhciBhcyBkZWFkbG9ja3Mgd2l0aCBkbWFfZmVuY2Vfd2FpdCgp IGFnYWluc3QgZG1hX2ZlbmNlX3NpZ25hbCgpIGFyZQo+ICsgKiAgIGNvbmNlcm5lZC4KPiArICov Cj4gKyNpZmRlZiBDT05GSUdfTE9DS0RFUAo+ICtzdHJ1Y3QgbG9ja2RlcF9tYXAJZG1hX2ZlbmNl X2xvY2tkZXBfbWFwID0gewo+ICsJLm5hbWUgPSAiZG1hX2ZlbmNlX21hcCIKPiArfTsKCk1heWJl IGEgc3R1cGlkIHF1ZXN0aW9uIGJlY2F1c2UgdGhpcyBpcyBkZWZpbml0ZWx5IGNvbXBsaWNhdGVk LCBidXQuLiBJZiAKeW91IGhhdmUgYSBzaW5nbGUvc3RhdGljL2dsb2JhbCBsb2NrZGVwIG1hcCwg ZG9lc24ndCB0aGlzIG1lYW4gX2FsbF8gCmxvY2tzLCBmcm9tIF9hbGxfIGRyaXZlcnMgaGFwcGVu aW5nIHRvIHVzZSBkbWEtZmVuY2VzIHdpbGwgZ2V0IHJlY29yZGVkIAppbiBpdC4gV2lsbCB0aGlz IHdvcmsgYW5kIG5vdCBjYXVzZSBmYWxzZSBwb3NpdGl2ZXM/CgpTb3VuZHMgbGlrZSBpdCBjb3Vs ZCBjcmVhdGUgYSBjb21tb24gbGluayBiZXR3ZWVuIHR3byBjb21wbGV0ZWx5IAp1bmNvbm5lY3Rl ZCB1c2FnZXMuIEJlY2F1c2UgYmVsb3cgeW91IGRvIGFkZCBhbm5vdGF0aW9ucyB0byBnZW5lcmlj IApkbWFfZmVuY2Vfc2lnbmFsIGFuZCBkbWFfZmVuY2Vfd2FpdC4KCj4gKwo+ICsvKioKPiArICog ZG1hX2ZlbmNlX2JlZ2luX3NpZ25hbGxpbmcgLSBiZWdpbiBhIGNyaXRpY2FsIERNQSBmZW5jZSBz aWduYWxsaW5nIHNlY3Rpb24KPiArICoKPiArICogRHJpdmVycyBzaG91bGQgdXNlIHRoaXMgdG8g YW5ub3RhdGUgdGhlIGJlZ2lubmluZyBvZiBhbnkgY29kZSBzZWN0aW9uCj4gKyAqIHJlcXVpcmVk IHRvIGV2ZW50dWFsbHkgY29tcGxldGUgJmRtYV9mZW5jZSBieSBjYWxsaW5nIGRtYV9mZW5jZV9z aWduYWwoKS4KPiArICoKPiArICogVGhlIGVuZCBvZiB0aGVzZSBjcml0aWNhbCBzZWN0aW9ucyBh cmUgYW5ub3RhdGVkIHdpdGgKPiArICogZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKCkuCj4gKyAq Cj4gKyAqIFJldHVybnM6Cj4gKyAqCj4gKyAqIE9wYXF1ZSBjb29raWUgbmVlZGVkIGJ5IHRoZSBp bXBsZW1lbnRhdGlvbiwgd2hpY2ggbmVlZHMgdG8gYmUgcGFzc2VkIHRvCj4gKyAqIGRtYV9mZW5j ZV9lbmRfc2lnbmFsbGluZygpLgo+ICsgKi8KPiArYm9vbCBkbWFfZmVuY2VfYmVnaW5fc2lnbmFs bGluZyh2b2lkKQo+ICt7Cj4gKwkvKiBleHBsaWNpdGx5IG5lc3RpbmcgLi4uICovCj4gKwlpZiAo bG9ja19pc19oZWxkX3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSkpCj4gKwkJcmV0dXJu IHRydWU7Cj4gKwo+ICsJLyogcmVseSBvbiBtaWdodF9zbGVlcCBjaGVjayBmb3Igc29mdC9oYXJk aXJxIGxvY2tzICovCj4gKwlpZiAoaW5fYXRvbWljKCkpCj4gKwkJcmV0dXJuIHRydWU7Cj4gKwo+ ICsJLyogLi4uIGFuZCBub24tcmVjdXJzaXZlIHJlYWRsb2NrICovCj4gKwlsb2NrX2FjcXVpcmUo JmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMCwgMCwgMSwgMSwgTlVMTCwgX1JFVF9JUF8pOwoKV291 bGQgaXQgd29yayBpZiBzaWduYWxsaW5nIHBhdGggd291bGQgbWFyayBpdHNlbGYgYXMgYSB3cml0 ZSBsb2NrPyBJIGFtIAp0aGlua2luZyBpdCB3b3VsZCBiZSBuaWNlIHRvIHNlZSBpbiBsb2NrZGVw IHNwbGF0cyB3aGF0IGFyZSBzaWduYWxzIGFuZCAKd2hhdCBhcmUgd2FpdHMuCgpUaGUgcmVjdXJz aXZlIHVzYWdlIHdvdWxkbid0IHdvcmsgdGhlbiByaWdodD8gV291bGQgd3JpdGUgYW5ub3RhdGlv biBvbiAKdGhlIHdhaXQgcGF0aCB3b3JrPwoKUmVnYXJkcywKClR2cnRrbwoKPiArCj4gKwlyZXR1 cm4gZmFsc2U7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChkbWFfZmVuY2VfYmVnaW5fc2lnbmFsbGlu Zyk7Cj4gKwo+ICsvKioKPiArICogZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nIC0gZW5kIGEgY3Jp dGljYWwgRE1BIGZlbmNlIHNpZ25hbGxpbmcgc2VjdGlvbgo+ICsgKgo+ICsgKiBDbG9zZXMgYSBj cml0aWNhbCBzZWN0aW9uIGFubm90YXRpb24gb3BlbmVkIGJ5IGRtYV9mZW5jZV9iZWdpbl9zaWdu YWxsaW5nKCkuCj4gKyAqLwo+ICt2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyhib29sIGNv b2tpZSkKPiArewo+ICsJaWYgKGNvb2tpZSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJbG9ja19yZWxl YXNlKCZkbWFfZmVuY2VfbG9ja2RlcF9tYXAsIF9SRVRfSVBfKTsKPiArfQo+ICtFWFBPUlRfU1lN Qk9MKGRtYV9mZW5jZV9lbmRfc2lnbmFsbGluZyk7Cj4gKwo+ICt2b2lkIF9fZG1hX2ZlbmNlX21p Z2h0X3dhaXQodm9pZCkKPiArewo+ICsJYm9vbCB0bXA7Cj4gKwo+ICsJdG1wID0gbG9ja19pc19o ZWxkX3R5cGUoJmRtYV9mZW5jZV9sb2NrZGVwX21hcCwgMSk7Cj4gKwlpZiAodG1wKQo+ICsJCWxv Y2tfcmVsZWFzZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCBfVEhJU19JUF8pOwo+ICsJbG9ja19t YXBfYWNxdWlyZSgmZG1hX2ZlbmNlX2xvY2tkZXBfbWFwKTsKPiArCWxvY2tfbWFwX3JlbGVhc2Uo JmRtYV9mZW5jZV9sb2NrZGVwX21hcCk7Cj4gKwlpZiAodG1wKQo+ICsJCWxvY2tfYWNxdWlyZSgm ZG1hX2ZlbmNlX2xvY2tkZXBfbWFwLCAwLCAwLCAxLCAxLCBOVUxMLCBfVEhJU19JUF8pOwo+ICt9 Cj4gKyNlbmRpZgo+ICsKPiArCj4gICAvKioKPiAgICAqIGRtYV9mZW5jZV9zaWduYWxfbG9ja2Vk IC0gc2lnbmFsIGNvbXBsZXRpb24gb2YgYSBmZW5jZQo+ICAgICogQGZlbmNlOiB0aGUgZmVuY2Ug dG8gc2lnbmFsCj4gQEAgLTE3MCwxNCArMzI0LDE5IEBAIGludCBkbWFfZmVuY2Vfc2lnbmFsKHN0 cnVjdCBkbWFfZmVuY2UgKmZlbmNlKQo+ICAgewo+ICAgCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4g ICAJaW50IHJldDsKPiArCWJvb2wgdG1wOwo+ICAgCj4gICAJaWYgKCFmZW5jZSkKPiAgIAkJcmV0 dXJuIC1FSU5WQUw7Cj4gICAKPiArCXRtcCA9IGRtYV9mZW5jZV9iZWdpbl9zaWduYWxsaW5nKCk7 Cj4gKwo+ICAgCXNwaW5fbG9ja19pcnFzYXZlKGZlbmNlLT5sb2NrLCBmbGFncyk7Cj4gICAJcmV0 ID0gZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoZmVuY2UpOwo+ICAgCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoZmVuY2UtPmxvY2ssIGZsYWdzKTsKPiAgIAo+ICsJZG1hX2ZlbmNlX2VuZF9zaWduYWxs aW5nKHRtcCk7Cj4gKwo+ICAgCXJldHVybiByZXQ7Cj4gICB9Cj4gICBFWFBPUlRfU1lNQk9MKGRt YV9mZW5jZV9zaWduYWwpOwo+IEBAIC0yMTAsNiArMzY5LDggQEAgZG1hX2ZlbmNlX3dhaXRfdGlt ZW91dChzdHJ1Y3QgZG1hX2ZlbmNlICpmZW5jZSwgYm9vbCBpbnRyLCBzaWduZWQgbG9uZyB0aW1l b3V0KQo+ICAgCj4gICAJbWlnaHRfc2xlZXAoKTsKPiAgIAo+ICsJX19kbWFfZmVuY2VfbWlnaHRf d2FpdCgpOwo+ICsKPiAgIAl0cmFjZV9kbWFfZmVuY2Vfd2FpdF9zdGFydChmZW5jZSk7Cj4gICAJ aWYgKGZlbmNlLT5vcHMtPndhaXQpCj4gICAJCXJldCA9IGZlbmNlLT5vcHMtPndhaXQoZmVuY2Us IGludHIsIHRpbWVvdXQpOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5o IGIvaW5jbHVkZS9saW51eC9kbWEtZmVuY2UuaAo+IGluZGV4IDMzNDdjNTRmM2E4Ny4uM2YyODhm N2RiMmVmIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvZG1hLWZlbmNlLmgKPiArKysgYi9p bmNsdWRlL2xpbnV4L2RtYS1mZW5jZS5oCj4gQEAgLTM1Nyw2ICszNTcsMTggQEAgZG1hX2ZlbmNl X2dldF9yY3Vfc2FmZShzdHJ1Y3QgZG1hX2ZlbmNlIF9fcmN1ICoqZmVuY2VwKQo+ICAgCX0gd2hp bGUgKDEpOwo+ICAgfQo+ICAgCj4gKyNpZmRlZiBDT05GSUdfTE9DS0RFUAo+ICtib29sIGRtYV9m ZW5jZV9iZWdpbl9zaWduYWxsaW5nKHZvaWQpOwo+ICt2b2lkIGRtYV9mZW5jZV9lbmRfc2lnbmFs bGluZyhib29sIGNvb2tpZSk7Cj4gKyNlbHNlCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBkbWFfZmVu Y2VfYmVnaW5fc2lnbmFsbGluZyh2b2lkKQo+ICt7Cj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICtz dGF0aWMgaW5saW5lIHZvaWQgZG1hX2ZlbmNlX2VuZF9zaWduYWxsaW5nKGJvb2wgY29va2llKSB7 fQo+ICtzdGF0aWMgaW5saW5lIHZvaWQgX19kbWFfZmVuY2VfbWlnaHRfd2FpdCh2b2lkKSB7fQo+ ICsjZW5kaWYKPiArCj4gICBpbnQgZG1hX2ZlbmNlX3NpZ25hbChzdHJ1Y3QgZG1hX2ZlbmNlICpm ZW5jZSk7Cj4gICBpbnQgZG1hX2ZlbmNlX3NpZ25hbF9sb2NrZWQoc3RydWN0IGRtYV9mZW5jZSAq ZmVuY2UpOwo+ICAgc2lnbmVkIGxvbmcgZG1hX2ZlbmNlX2RlZmF1bHRfd2FpdChzdHJ1Y3QgZG1h X2ZlbmNlICpmZW5jZSwKPiAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0 b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50 ZWwtZ2Z4Cg==