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=-8.6 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FAKE_REPLY_C,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,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 A0ED1C388F3 for ; Fri, 27 Sep 2019 21:42:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 702D72146E for ; Fri, 27 Sep 2019 21:42:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1569620577; bh=woe0ZidU/l62b9rCpbymA++FhqsxoRS+ZiXvjj9sMeE=; h=Date:From:To:Cc:Subject:In-Reply-To:List-ID:From; b=AUpXosCqaTB3XUUL6+vB4r+qJnesnsgEmjRNXv1N0pJ+s0l5CVZNMMsUt+FhSIM+d BDqFUWRSkdlr2Phnm1wp7APgi5zsGjWGQiWvjg6KawPo/shpxrrk4t2nD5OugekRRV AQWOJZKMXauoLXTsDxo8867882GjNddL76LEsMHk= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728077AbfI0Vm4 (ORCPT ); Fri, 27 Sep 2019 17:42:56 -0400 Received: from mail.kernel.org ([198.145.29.99]:58002 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725990AbfI0Vm4 (ORCPT ); Fri, 27 Sep 2019 17:42:56 -0400 Received: from localhost (unknown [69.71.4.100]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 4CA2621655; Fri, 27 Sep 2019 21:42:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1569620574; bh=woe0ZidU/l62b9rCpbymA++FhqsxoRS+ZiXvjj9sMeE=; h=Date:From:To:Cc:Subject:In-Reply-To:From; b=bA51B+GY3JK+tXvmbY6GN1FvBXIECJHNatpEzzJbjStASusXSlvaNiwNoX2vTIST/ hFmLxZlQt+6FXLDpvWSdX5kwq+dAgthqeEm2fFhAvkbKAPIE0SApGkoR2e1ZEFZmr5 WgISIXqeBL0G1IOgIHtFmF1ooPEF4YJ4dSWZMm1E= Date: Fri, 27 Sep 2019 16:42:53 -0500 From: Bjorn Helgaas To: Karol Herbst Cc: linux-kernel@vger.kernel.org, Lyude Paul , linux-pci@vger.kernel.org, dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org, "Rafael J. Wysocki" , linux-pm@vger.kernel.org, Mika Westerberg Subject: Re: [RFC PATCH] pci: prevent putting pcie devices into lower device states on certain intel bridges Message-ID: <20190927214252.GA65801@google.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20190927144421.22608-1-kherbst@redhat.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org [+cc Rafael, Mika, linux-pm] On Fri, Sep 27, 2019 at 04:44:21PM +0200, Karol Herbst wrote: > Fixes runpm breakage mainly on Nvidia GPUs as they are not able to resume. I don't know what runpm is. Some userspace utility? Module parameter? > Works perfectly with this workaround applied. > > RFC comment: > We are quite sure that there is a higher amount of bridges affected by this, > but I was only testing it on my own machine for now. > > I've stresstested runpm by doing 5000 runpm cycles with that patch applied > and never saw it fail. > > I mainly wanted to get a discussion going on if that's a feasable workaround > indeed or if we need something better. > > I am also sure, that the nouveau driver itself isn't at fault as I am able > to reproduce the same issue by poking into some PCI registers on the PCIe > bridge to put the GPU into D3cold as it's done in ACPI code. > > I've written a little python script to reproduce this issue without the need > of loading nouveau: > https://raw.githubusercontent.com/karolherbst/pci-stub-runpm/master/nv_runpm_bug_test.py Nice script, thanks for sharing it :) I could learn a lot of useful python by studying it. > Signed-off-by: Karol Herbst > Cc: Bjorn Helgaas > Cc: Lyude Paul > Cc: linux-pci@vger.kernel.org > Cc: dri-devel@lists.freedesktop.org > Cc: nouveau@lists.freedesktop.org > --- > drivers/pci/pci.c | 39 +++++++++++++++++++++++++++++++++++++++ > 1 file changed, 39 insertions(+) > > diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c > index 088fcdc8d2b4..9dbd29ced1ac 100644 > --- a/drivers/pci/pci.c > +++ b/drivers/pci/pci.c > @@ -799,6 +799,42 @@ static inline bool platform_pci_bridge_d3(struct pci_dev *dev) > return pci_platform_pm ? pci_platform_pm->bridge_d3(dev) : false; > } > > +/* > + * some intel bridges cause serious issues with runpm if the client device > + * is put into D1/D2/D3hot before putting the client into D3cold via > + * platform means (generally ACPI). You mention Nvidia GPUs above, but I guess the same issue may affect other devices? I would really like to chase this down to a more specific issue, e.g., a hardware defect with erratum, an ACPI defect, or a Linux defect. Without the specifics, this is just a band-aid. I don't see any relevant requirements in the _OFF description, but I don't know much about ACPI power control. Your script allows several scenarios; I *guess* the one that causes the problem is: - write 3 (D3hot) to GPU PowerState (PCIE_PM_REG == 0x64, I assume PM Capability Control Register) - write 3 (D3hot) to bridge PowerState (0x84, I assume PM Capability Control Register) - run _OFF on the power resource for the bridge >From your script I assume you do: - run _ON on the power resource for the bridge - write 0 (D0) to the bridge PowerState You do *not* write the GPU PowerState (which we can't do if the GPU is in D3cold). Is there some assumption that it comes out of D3cold via some other mechanism, e.g., is the _ON supposed to wake up the GPU? What exactly is the serious issue? I guess it's that the rescan doesn't detect the GPU, which means it's not responding to config accesses? Is there any timing component here, e.g., maybe we're missing some delay like the ones Mika is adding to the reset paths? > + * > + * skipping this makes runpm work perfectly fine on such devices. > + * > + * As far as we know only skylake and kaby lake SoCs are affected. > + */ > +static unsigned short intel_broken_d3_bridges[] = { > + /* kbl */ > + 0x1901, > +}; > + > +static inline bool intel_broken_pci_pm(struct pci_bus *bus) > +{ > + struct pci_dev *bridge; > + int i; > + > + if (!bus || !bus->self) > + return false; > + > + bridge = bus->self; > + if (bridge->vendor != PCI_VENDOR_ID_INTEL) > + return false; > + > + for (i = 0; i < ARRAY_SIZE(intel_broken_d3_bridges); i++) { > + if (bridge->device == intel_broken_d3_bridges[i]) { > + pci_err(bridge, "found broken intel bridge\n"); If this ends up being a hardware defect, we should use a quirk to set a bit in the pci_dev once, as we do for broken_intx_masking and similar bits. > + return true; > + } > + } > + > + return false; > +} > + > /** > * pci_raw_set_power_state - Use PCI PM registers to set the power state of > * given PCI device > @@ -827,6 +863,9 @@ static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state) > if (state < PCI_D0 || state > PCI_D3hot) > return -EINVAL; > > + if (state != PCI_D0 && intel_broken_pci_pm(dev->bus)) > + return 0; > + > /* > * Validate current state: > * Can enter D0 from any state, but if we can only go deeper > -- > 2.21.0 > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bjorn Helgaas Subject: Re: [RFC PATCH] pci: prevent putting pcie devices into lower device states on certain intel bridges Date: Fri, 27 Sep 2019 16:42:53 -0500 Message-ID: <20190927214252.GA65801@google.com> References: <20190927144421.22608-1-kherbst@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20190927144421.22608-1-kherbst-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: nouveau-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Nouveau" To: Karol Herbst Cc: linux-pm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-pci-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Mika Westerberg , "Rafael J. Wysocki" , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org List-Id: nouveau.vger.kernel.org WytjYyBSYWZhZWwsIE1pa2EsIGxpbnV4LXBtXQoKT24gRnJpLCBTZXAgMjcsIDIwMTkgYXQgMDQ6 NDQ6MjFQTSArMDIwMCwgS2Fyb2wgSGVyYnN0IHdyb3RlOgo+IEZpeGVzIHJ1bnBtIGJyZWFrYWdl IG1haW5seSBvbiBOdmlkaWEgR1BVcyBhcyB0aGV5IGFyZSBub3QgYWJsZSB0byByZXN1bWUuCgpJ IGRvbid0IGtub3cgd2hhdCBydW5wbSBpcy4gIFNvbWUgdXNlcnNwYWNlIHV0aWxpdHk/ICBNb2R1 bGUKcGFyYW1ldGVyPwoKPiBXb3JrcyBwZXJmZWN0bHkgd2l0aCB0aGlzIHdvcmthcm91bmQgYXBw bGllZC4KPiAKPiBSRkMgY29tbWVudDoKPiBXZSBhcmUgcXVpdGUgc3VyZSB0aGF0IHRoZXJlIGlz IGEgaGlnaGVyIGFtb3VudCBvZiBicmlkZ2VzIGFmZmVjdGVkIGJ5IHRoaXMsCj4gYnV0IEkgd2Fz IG9ubHkgdGVzdGluZyBpdCBvbiBteSBvd24gbWFjaGluZSBmb3Igbm93Lgo+IAo+IEkndmUgc3Ry ZXNzdGVzdGVkIHJ1bnBtIGJ5IGRvaW5nIDUwMDAgcnVucG0gY3ljbGVzIHdpdGggdGhhdCBwYXRj aCBhcHBsaWVkCj4gYW5kIG5ldmVyIHNhdyBpdCBmYWlsLgo+IAo+IEkgbWFpbmx5IHdhbnRlZCB0 byBnZXQgYSBkaXNjdXNzaW9uIGdvaW5nIG9uIGlmIHRoYXQncyBhIGZlYXNhYmxlIHdvcmthcm91 bmQKPiBpbmRlZWQgb3IgaWYgd2UgbmVlZCBzb21ldGhpbmcgYmV0dGVyLgo+IAo+IEkgYW0gYWxz byBzdXJlLCB0aGF0IHRoZSBub3V2ZWF1IGRyaXZlciBpdHNlbGYgaXNuJ3QgYXQgZmF1bHQgYXMg SSBhbSBhYmxlCj4gdG8gcmVwcm9kdWNlIHRoZSBzYW1lIGlzc3VlIGJ5IHBva2luZyBpbnRvIHNv bWUgUENJIHJlZ2lzdGVycyBvbiB0aGUgUENJZQo+IGJyaWRnZSB0byBwdXQgdGhlIEdQVSBpbnRv IEQzY29sZCBhcyBpdCdzIGRvbmUgaW4gQUNQSSBjb2RlLgo+IAo+IEkndmUgd3JpdHRlbiBhIGxp dHRsZSBweXRob24gc2NyaXB0IHRvIHJlcHJvZHVjZSB0aGlzIGlzc3VlIHdpdGhvdXQgdGhlIG5l ZWQKPiBvZiBsb2FkaW5nIG5vdXZlYXU6Cj4gaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQu Y29tL2thcm9saGVyYnN0L3BjaS1zdHViLXJ1bnBtL21hc3Rlci9udl9ydW5wbV9idWdfdGVzdC5w eQoKTmljZSBzY3JpcHQsIHRoYW5rcyBmb3Igc2hhcmluZyBpdCA6KSAgSSBjb3VsZCBsZWFybiBh IGxvdCBvZiB1c2VmdWwKcHl0aG9uIGJ5IHN0dWR5aW5nIGl0LgoKPiBTaWduZWQtb2ZmLWJ5OiBL YXJvbCBIZXJic3QgPGtoZXJic3RAcmVkaGF0LmNvbT4KPiBDYzogQmpvcm4gSGVsZ2FhcyA8Ymhl bGdhYXNAZ29vZ2xlLmNvbT4KPiBDYzogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4KPiBD YzogbGludXgtcGNpQHZnZXIua2VybmVsLm9yZwo+IENjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCj4gQ2M6IG5vdXZlYXVAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gLS0tCj4gIGRy aXZlcnMvcGNpL3BjaS5jIHwgMzkgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrCj4gIDEgZmlsZSBjaGFuZ2VkLCAzOSBpbnNlcnRpb25zKCspCj4gCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvcGNpL3BjaS5jIGIvZHJpdmVycy9wY2kvcGNpLmMKPiBpbmRleCAwODhmY2RjOGQy YjQuLjlkYmQyOWNlZDFhYyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3BjaS9wY2kuYwo+ICsrKyBi L2RyaXZlcnMvcGNpL3BjaS5jCj4gQEAgLTc5OSw2ICs3OTksNDIgQEAgc3RhdGljIGlubGluZSBi b29sIHBsYXRmb3JtX3BjaV9icmlkZ2VfZDMoc3RydWN0IHBjaV9kZXYgKmRldikKPiAgCXJldHVy biBwY2lfcGxhdGZvcm1fcG0gPyBwY2lfcGxhdGZvcm1fcG0tPmJyaWRnZV9kMyhkZXYpIDogZmFs c2U7Cj4gIH0KPiAgCj4gKy8qCj4gKyAqIHNvbWUgaW50ZWwgYnJpZGdlcyBjYXVzZSBzZXJpb3Vz IGlzc3VlcyB3aXRoIHJ1bnBtIGlmIHRoZSBjbGllbnQgZGV2aWNlCj4gKyAqIGlzIHB1dCBpbnRv IEQxL0QyL0QzaG90IGJlZm9yZSBwdXR0aW5nIHRoZSBjbGllbnQgaW50byBEM2NvbGQgdmlhCj4g KyAqIHBsYXRmb3JtIG1lYW5zIChnZW5lcmFsbHkgQUNQSSkuCgpZb3UgbWVudGlvbiBOdmlkaWEg R1BVcyBhYm92ZSwgYnV0IEkgZ3Vlc3MgdGhlIHNhbWUgaXNzdWUgbWF5IGFmZmVjdApvdGhlciBk ZXZpY2VzPyAgSSB3b3VsZCByZWFsbHkgbGlrZSB0byBjaGFzZSB0aGlzIGRvd24gdG8gYSBtb3Jl CnNwZWNpZmljIGlzc3VlLCBlLmcuLCBhIGhhcmR3YXJlIGRlZmVjdCB3aXRoIGVycmF0dW0sIGFu IEFDUEkgZGVmZWN0LApvciBhIExpbnV4IGRlZmVjdC4gIFdpdGhvdXQgdGhlIHNwZWNpZmljcywg dGhpcyBpcyBqdXN0IGEgYmFuZC1haWQuCgpJIGRvbid0IHNlZSBhbnkgcmVsZXZhbnQgcmVxdWly ZW1lbnRzIGluIHRoZSBfT0ZGIGRlc2NyaXB0aW9uLCBidXQgSQpkb24ndCBrbm93IG11Y2ggYWJv dXQgQUNQSSBwb3dlciBjb250cm9sLgoKWW91ciBzY3JpcHQgYWxsb3dzIHNldmVyYWwgc2NlbmFy aW9zOyBJICpndWVzcyogdGhlIG9uZSB0aGF0IGNhdXNlcwp0aGUgcHJvYmxlbSBpczoKCiAgLSB3 cml0ZSAzIChEM2hvdCkgdG8gR1BVIFBvd2VyU3RhdGUgKFBDSUVfUE1fUkVHID09IDB4NjQsIEkg YXNzdW1lCiAgICBQTSBDYXBhYmlsaXR5IENvbnRyb2wgUmVnaXN0ZXIpCiAgLSB3cml0ZSAzIChE M2hvdCkgdG8gYnJpZGdlIFBvd2VyU3RhdGUgKDB4ODQsIEkgYXNzdW1lIFBNIENhcGFiaWxpdHkK ICAgIENvbnRyb2wgUmVnaXN0ZXIpCiAgLSBydW4gX09GRiBvbiB0aGUgcG93ZXIgcmVzb3VyY2Ug Zm9yIHRoZSBicmlkZ2UKCkZyb20geW91ciBzY3JpcHQgSSBhc3N1bWUgeW91IGRvOgoKICAtIHJ1 biBfT04gb24gdGhlIHBvd2VyIHJlc291cmNlIGZvciB0aGUgYnJpZGdlCiAgLSB3cml0ZSAwIChE MCkgdG8gdGhlIGJyaWRnZSBQb3dlclN0YXRlCgpZb3UgZG8gKm5vdCogd3JpdGUgdGhlIEdQVSBQ b3dlclN0YXRlICh3aGljaCB3ZSBjYW4ndCBkbyBpZiB0aGUgR1BVIGlzCmluIEQzY29sZCkuICBJ cyB0aGVyZSBzb21lIGFzc3VtcHRpb24gdGhhdCBpdCBjb21lcyBvdXQgb2YgRDNjb2xkIHZpYQpz b21lIG90aGVyIG1lY2hhbmlzbSwgZS5nLiwgaXMgdGhlIF9PTiBzdXBwb3NlZCB0byB3YWtlIHVw IHRoZSBHUFU/CgpXaGF0IGV4YWN0bHkgaXMgdGhlIHNlcmlvdXMgaXNzdWU/ICBJIGd1ZXNzIGl0 J3MgdGhhdCB0aGUgcmVzY2FuCmRvZXNuJ3QgZGV0ZWN0IHRoZSBHUFUsIHdoaWNoIG1lYW5zIGl0 J3Mgbm90IHJlc3BvbmRpbmcgdG8gY29uZmlnCmFjY2Vzc2VzPyAgSXMgdGhlcmUgYW55IHRpbWlu ZyBjb21wb25lbnQgaGVyZSwgZS5nLiwgbWF5YmUgd2UncmUKbWlzc2luZyBzb21lIGRlbGF5IGxp a2UgdGhlIG9uZXMgTWlrYSBpcyBhZGRpbmcgdG8gdGhlIHJlc2V0IHBhdGhzPwoKPiArICoKPiAr ICogc2tpcHBpbmcgdGhpcyBtYWtlcyBydW5wbSB3b3JrIHBlcmZlY3RseSBmaW5lIG9uIHN1Y2gg ZGV2aWNlcy4KPiArICoKPiArICogQXMgZmFyIGFzIHdlIGtub3cgb25seSBza3lsYWtlIGFuZCBr YWJ5IGxha2UgU29DcyBhcmUgYWZmZWN0ZWQuCj4gKyAqLwo+ICtzdGF0aWMgdW5zaWduZWQgc2hv cnQgaW50ZWxfYnJva2VuX2QzX2JyaWRnZXNbXSA9IHsKPiArCS8qIGtibCAqLwo+ICsJMHgxOTAx LAo+ICt9Owo+ICsKPiArc3RhdGljIGlubGluZSBib29sIGludGVsX2Jyb2tlbl9wY2lfcG0oc3Ry dWN0IHBjaV9idXMgKmJ1cykKPiArewo+ICsJc3RydWN0IHBjaV9kZXYgKmJyaWRnZTsKPiArCWlu dCBpOwo+ICsKPiArCWlmICghYnVzIHx8ICFidXMtPnNlbGYpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ ICsKPiArCWJyaWRnZSA9IGJ1cy0+c2VsZjsKPiArCWlmIChicmlkZ2UtPnZlbmRvciAhPSBQQ0lf VkVORE9SX0lEX0lOVEVMKQo+ICsJCXJldHVybiBmYWxzZTsKPiArCj4gKwlmb3IgKGkgPSAwOyBp IDwgQVJSQVlfU0laRShpbnRlbF9icm9rZW5fZDNfYnJpZGdlcyk7IGkrKykgewo+ICsJCWlmIChi cmlkZ2UtPmRldmljZSA9PSBpbnRlbF9icm9rZW5fZDNfYnJpZGdlc1tpXSkgewo+ICsJCQlwY2lf ZXJyKGJyaWRnZSwgImZvdW5kIGJyb2tlbiBpbnRlbCBicmlkZ2VcbiIpOwoKSWYgdGhpcyBlbmRz IHVwIGJlaW5nIGEgaGFyZHdhcmUgZGVmZWN0LCB3ZSBzaG91bGQgdXNlIGEgcXVpcmsgdG8gc2V0 CmEgYml0IGluIHRoZSBwY2lfZGV2IG9uY2UsIGFzIHdlIGRvIGZvciBicm9rZW5faW50eF9tYXNr aW5nIGFuZApzaW1pbGFyIGJpdHMuCgo+ICsJCQlyZXR1cm4gdHJ1ZTsKPiArCQl9Cj4gKwl9Cj4g Kwo+ICsJcmV0dXJuIGZhbHNlOwo+ICt9Cj4gKwo+ICAvKioKPiAgICogcGNpX3Jhd19zZXRfcG93 ZXJfc3RhdGUgLSBVc2UgUENJIFBNIHJlZ2lzdGVycyB0byBzZXQgdGhlIHBvd2VyIHN0YXRlIG9m Cj4gICAqCQkJICAgICBnaXZlbiBQQ0kgZGV2aWNlCj4gQEAgLTgyNyw2ICs4NjMsOSBAQCBzdGF0 aWMgaW50IHBjaV9yYXdfc2V0X3Bvd2VyX3N0YXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIHBjaV9w b3dlcl90IHN0YXRlKQo+ICAJaWYgKHN0YXRlIDwgUENJX0QwIHx8IHN0YXRlID4gUENJX0QzaG90 KQo+ICAJCXJldHVybiAtRUlOVkFMOwo+ICAKPiArCWlmIChzdGF0ZSAhPSBQQ0lfRDAgJiYgaW50 ZWxfYnJva2VuX3BjaV9wbShkZXYtPmJ1cykpCj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICAJLyoKPiAg CSAqIFZhbGlkYXRlIGN1cnJlbnQgc3RhdGU6Cj4gIAkgKiBDYW4gZW50ZXIgRDAgZnJvbSBhbnkg c3RhdGUsIGJ1dCBpZiB3ZSBjYW4gb25seSBnbyBkZWVwZXIKPiAtLSAKPiAyLjIxLjAKPiAKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTm91dmVhdSBtYWls aW5nIGxpc3QKTm91dmVhdUBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9ub3V2ZWF1