From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm0-f41.google.com ([74.125.82.41]:38475 "EHLO mail-wm0-f41.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755645AbcBIJ4Q (ORCPT ); Tue, 9 Feb 2016 04:56:16 -0500 Received: by mail-wm0-f41.google.com with SMTP id p63so15445707wmp.1 for ; Tue, 09 Feb 2016 01:56:15 -0800 (PST) Date: Tue, 9 Feb 2016 10:56:38 +0100 From: Daniel Vetter To: Mario Kleiner Cc: dri-devel@lists.freedesktop.org, linux@bernd-steinhauser.de, stable@vger.kernel.org, michel@daenzer.net, vbabka@suse.cz, ville.syrjala@linux.intel.com, daniel.vetter@ffwll.ch, alexander.deucher@amd.com, christian.koenig@amd.com Subject: Re: [PATCH 2/6] drm: Prevent vblank counter bumps > 1 with active vblank clients. Message-ID: <20160209095638.GM11240@phenom.ffwll.local> References: <1454894009-15466-1-git-send-email-mario.kleiner.de@gmail.com> <1454894009-15466-3-git-send-email-mario.kleiner.de@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1454894009-15466-3-git-send-email-mario.kleiner.de@gmail.com> Sender: stable-owner@vger.kernel.org List-ID: On Mon, Feb 08, 2016 at 02:13:25AM +0100, Mario Kleiner wrote: > This fixes a regression introduced by the new drm_update_vblank_count() > implementation in Linux 4.4: > > Restrict the bump of the software vblank counter in drm_update_vblank_count() > to a safe maximum value of +1 whenever there is the possibility that > concurrent readers of vblank timestamps could be active at the moment, > as the current implementation of the timestamp caching and updating is > not safe against concurrent readers for calls to store_vblank() with a > bump of anything but +1. A bump != 1 would very likely return corrupted > timestamps to userspace, because the same slot in the cache could > be concurrently written by store_vblank() and read by one of those > readers in a non-atomic fashion and without the read-retry logic > detecting this collision. > > Concurrent readers can exist while drm_update_vblank_count() is called > from the drm_vblank_off() or drm_vblank_on() functions or other non-vblank- > irq callers. However, all those calls are happening with the vbl_lock > locked thereby preventing a drm_vblank_get(), so the vblank refcount > can't increase while drm_update_vblank_count() is executing. Therefore > a zero vblank refcount during execution of that function signals that > is safe for arbitrary counter bumps if called from outside vblank irq, > whereas a non-zero count is not safe. > > Whenever the function is called from vblank irq, we have to assume concurrent > readers could show up any time during its execution, even if the refcount > is currently zero, as vblank irqs are usually only enabled due to the > presence of readers, and because when it is called from vblank irq it > can't hold the vbl_lock to protect it from sudden bumps in vblank refcount. > Therefore also restrict bumps to +1 when the function is called from vblank > irq. > > Such bumps of more than +1 can happen at other times than reenabling > vblank irqs, e.g., when regular vblank interrupts get delayed by more > than 1 frame due to long held locks, long irq off periods, realtime > preemption on RT kernels, or system management interrupts. > > Signed-off-by: Mario Kleiner > Cc: # 4.4+ > Cc: michel@daenzer.net > Cc: vbabka@suse.cz > Cc: ville.syrjala@linux.intel.com > Cc: daniel.vetter@ffwll.ch > Cc: dri-devel@lists.freedesktop.org > Cc: alexander.deucher@amd.com > Cc: christian.koenig@amd.com Imo this is duct-tape. If we want to fix this up properly I think we should just use a full-blown seqlock instead of our hand-rolled one. And that could handle any increment at all. -Daniel > --- > drivers/gpu/drm/drm_irq.c | 41 +++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 41 insertions(+) > > diff --git a/drivers/gpu/drm/drm_irq.c b/drivers/gpu/drm/drm_irq.c > index bcb8528..aa2c74b 100644 > --- a/drivers/gpu/drm/drm_irq.c > +++ b/drivers/gpu/drm/drm_irq.c > @@ -221,6 +221,47 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe, > diff = (flags & DRM_CALLED_FROM_VBLIRQ) != 0; > } > > + /* > + * Restrict the bump of the software vblank counter to a safe maximum > + * value of +1 whenever there is the possibility that concurrent readers > + * of vblank timestamps could be active at the moment, as the current > + * implementation of the timestamp caching and updating is not safe > + * against concurrent readers for calls to store_vblank() with a bump > + * of anything but +1. A bump != 1 would very likely return corrupted > + * timestamps to userspace, because the same slot in the cache could > + * be concurrently written by store_vblank() and read by one of those > + * readers without the read-retry logic detecting the collision. > + * > + * Concurrent readers can exist when we are called from the > + * drm_vblank_off() or drm_vblank_on() functions and other non-vblank- > + * irq callers. However, all those calls to us are happening with the > + * vbl_lock locked to prevent drm_vblank_get(), so the vblank refcount > + * can't increase while we are executing. Therefore a zero refcount at > + * this point is safe for arbitrary counter bumps if we are called > + * outside vblank irq, a non-zero count is not 100% safe. Unfortunately > + * we must also accept a refcount of 1, as whenever we are called from > + * drm_vblank_get() -> drm_vblank_enable() the refcount will be 1 and > + * we must let that one pass through in order to not lose vblank counts > + * during vblank irq off - which would completely defeat the whole > + * point of this routine. > + * > + * Whenever we are called from vblank irq, we have to assume concurrent > + * readers exist or can show up any time during our execution, even if > + * the refcount is currently zero, as vblank irqs are usually only > + * enabled due to the presence of readers, and because when we are called > + * from vblank irq we can't hold the vbl_lock to protect us from sudden > + * bumps in vblank refcount. Therefore also restrict bumps to +1 when > + * called from vblank irq. > + */ > + if ((diff > 1) && (atomic_read(&vblank->refcount) > 1 || > + (flags & DRM_CALLED_FROM_VBLIRQ))) { > + DRM_DEBUG_VBL("clamping vblank bump to 1 on crtc %u: diffr=%u " > + "refcount %u, vblirq %u\n", pipe, diff, > + atomic_read(&vblank->refcount), > + (flags & DRM_CALLED_FROM_VBLIRQ) != 0); > + diff = 1; > + } > + > DRM_DEBUG_VBL("updating vblank count on crtc %u:" > " current=%u, diff=%u, hw=%u hw_last=%u\n", > pipe, vblank->count, diff, cur_vblank, vblank->last); > -- > 1.9.1 > -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 2/6] drm: Prevent vblank counter bumps > 1 with active vblank clients. Date: Tue, 9 Feb 2016 10:56:38 +0100 Message-ID: <20160209095638.GM11240@phenom.ffwll.local> References: <1454894009-15466-1-git-send-email-mario.kleiner.de@gmail.com> <1454894009-15466-3-git-send-email-mario.kleiner.de@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-f46.google.com (mail-wm0-f46.google.com [74.125.82.46]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5EEE26E532 for ; Tue, 9 Feb 2016 01:56:16 -0800 (PST) Received: by mail-wm0-f46.google.com with SMTP id p63so150222401wmp.1 for ; Tue, 09 Feb 2016 01:56:16 -0800 (PST) Content-Disposition: inline In-Reply-To: <1454894009-15466-3-git-send-email-mario.kleiner.de@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Mario Kleiner Cc: dri-devel@lists.freedesktop.org, daniel.vetter@ffwll.ch, michel@daenzer.net, linux@bernd-steinhauser.de, stable@vger.kernel.org, alexander.deucher@amd.com, christian.koenig@amd.com, vbabka@suse.cz List-Id: dri-devel@lists.freedesktop.org T24gTW9uLCBGZWIgMDgsIDIwMTYgYXQgMDI6MTM6MjVBTSArMDEwMCwgTWFyaW8gS2xlaW5lciB3 cm90ZToKPiBUaGlzIGZpeGVzIGEgcmVncmVzc2lvbiBpbnRyb2R1Y2VkIGJ5IHRoZSBuZXcgZHJt X3VwZGF0ZV92YmxhbmtfY291bnQoKQo+IGltcGxlbWVudGF0aW9uIGluIExpbnV4IDQuNDoKPiAK PiBSZXN0cmljdCB0aGUgYnVtcCBvZiB0aGUgc29mdHdhcmUgdmJsYW5rIGNvdW50ZXIgaW4gZHJt X3VwZGF0ZV92YmxhbmtfY291bnQoKQo+IHRvIGEgc2FmZSBtYXhpbXVtIHZhbHVlIG9mICsxIHdo ZW5ldmVyIHRoZXJlIGlzIHRoZSBwb3NzaWJpbGl0eSB0aGF0Cj4gY29uY3VycmVudCByZWFkZXJz IG9mIHZibGFuayB0aW1lc3RhbXBzIGNvdWxkIGJlIGFjdGl2ZSBhdCB0aGUgbW9tZW50LAo+IGFz IHRoZSBjdXJyZW50IGltcGxlbWVudGF0aW9uIG9mIHRoZSB0aW1lc3RhbXAgY2FjaGluZyBhbmQg dXBkYXRpbmcgaXMKPiBub3Qgc2FmZSBhZ2FpbnN0IGNvbmN1cnJlbnQgcmVhZGVycyBmb3IgY2Fs bHMgdG8gc3RvcmVfdmJsYW5rKCkgd2l0aCBhCj4gYnVtcCBvZiBhbnl0aGluZyBidXQgKzEuIEEg YnVtcCAhPSAxIHdvdWxkIHZlcnkgbGlrZWx5IHJldHVybiBjb3JydXB0ZWQKPiB0aW1lc3RhbXBz IHRvIHVzZXJzcGFjZSwgYmVjYXVzZSB0aGUgc2FtZSBzbG90IGluIHRoZSBjYWNoZSBjb3VsZAo+ IGJlIGNvbmN1cnJlbnRseSB3cml0dGVuIGJ5IHN0b3JlX3ZibGFuaygpIGFuZCByZWFkIGJ5IG9u ZSBvZiB0aG9zZQo+IHJlYWRlcnMgaW4gYSBub24tYXRvbWljIGZhc2hpb24gYW5kIHdpdGhvdXQg dGhlIHJlYWQtcmV0cnkgbG9naWMKPiBkZXRlY3RpbmcgdGhpcyBjb2xsaXNpb24uCj4gCj4gQ29u Y3VycmVudCByZWFkZXJzIGNhbiBleGlzdCB3aGlsZSBkcm1fdXBkYXRlX3ZibGFua19jb3VudCgp IGlzIGNhbGxlZAo+IGZyb20gdGhlIGRybV92Ymxhbmtfb2ZmKCkgb3IgZHJtX3ZibGFua19vbigp IGZ1bmN0aW9ucyBvciBvdGhlciBub24tdmJsYW5rLQo+IGlycSBjYWxsZXJzLiBIb3dldmVyLCBh bGwgdGhvc2UgY2FsbHMgYXJlIGhhcHBlbmluZyB3aXRoIHRoZSB2YmxfbG9jawo+IGxvY2tlZCB0 aGVyZWJ5IHByZXZlbnRpbmcgYSBkcm1fdmJsYW5rX2dldCgpLCBzbyB0aGUgdmJsYW5rIHJlZmNv dW50Cj4gY2FuJ3QgaW5jcmVhc2Ugd2hpbGUgZHJtX3VwZGF0ZV92YmxhbmtfY291bnQoKSBpcyBl eGVjdXRpbmcuIFRoZXJlZm9yZQo+IGEgemVybyB2YmxhbmsgcmVmY291bnQgZHVyaW5nIGV4ZWN1 dGlvbiBvZiB0aGF0IGZ1bmN0aW9uIHNpZ25hbHMgdGhhdAo+IGlzIHNhZmUgZm9yIGFyYml0cmFy eSBjb3VudGVyIGJ1bXBzIGlmIGNhbGxlZCBmcm9tIG91dHNpZGUgdmJsYW5rIGlycSwKPiB3aGVy ZWFzIGEgbm9uLXplcm8gY291bnQgaXMgbm90IHNhZmUuCj4gCj4gV2hlbmV2ZXIgdGhlIGZ1bmN0 aW9uIGlzIGNhbGxlZCBmcm9tIHZibGFuayBpcnEsIHdlIGhhdmUgdG8gYXNzdW1lIGNvbmN1cnJl bnQKPiByZWFkZXJzIGNvdWxkIHNob3cgdXAgYW55IHRpbWUgZHVyaW5nIGl0cyBleGVjdXRpb24s IGV2ZW4gaWYgdGhlIHJlZmNvdW50Cj4gaXMgY3VycmVudGx5IHplcm8sIGFzIHZibGFuayBpcnFz IGFyZSB1c3VhbGx5IG9ubHkgZW5hYmxlZCBkdWUgdG8gdGhlCj4gcHJlc2VuY2Ugb2YgcmVhZGVy cywgYW5kIGJlY2F1c2Ugd2hlbiBpdCBpcyBjYWxsZWQgZnJvbSB2YmxhbmsgaXJxIGl0Cj4gY2Fu J3QgaG9sZCB0aGUgdmJsX2xvY2sgdG8gcHJvdGVjdCBpdCBmcm9tIHN1ZGRlbiBidW1wcyBpbiB2 YmxhbmsgcmVmY291bnQuCj4gVGhlcmVmb3JlIGFsc28gcmVzdHJpY3QgYnVtcHMgdG8gKzEgd2hl biB0aGUgZnVuY3Rpb24gaXMgY2FsbGVkIGZyb20gdmJsYW5rCj4gaXJxLgo+IAo+IFN1Y2ggYnVt cHMgb2YgbW9yZSB0aGFuICsxIGNhbiBoYXBwZW4gYXQgb3RoZXIgdGltZXMgdGhhbiByZWVuYWJs aW5nCj4gdmJsYW5rIGlycXMsIGUuZy4sIHdoZW4gcmVndWxhciB2YmxhbmsgaW50ZXJydXB0cyBn ZXQgZGVsYXllZCBieSBtb3JlCj4gdGhhbiAxIGZyYW1lIGR1ZSB0byBsb25nIGhlbGQgbG9ja3Ms IGxvbmcgaXJxIG9mZiBwZXJpb2RzLCByZWFsdGltZQo+IHByZWVtcHRpb24gb24gUlQga2VybmVs cywgb3Igc3lzdGVtIG1hbmFnZW1lbnQgaW50ZXJydXB0cy4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBN YXJpbyBLbGVpbmVyIDxtYXJpby5rbGVpbmVyLmRlQGdtYWlsLmNvbT4KPiBDYzogPHN0YWJsZUB2 Z2VyLmtlcm5lbC5vcmc+ICMgNC40Kwo+IENjOiBtaWNoZWxAZGFlbnplci5uZXQKPiBDYzogdmJh YmthQHN1c2UuY3oKPiBDYzogdmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20KPiBDYzogZGFu aWVsLnZldHRlckBmZndsbC5jaAo+IENjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cj4gQ2M6IGFsZXhhbmRlci5kZXVjaGVyQGFtZC5jb20KPiBDYzogY2hyaXN0aWFuLmtvZW5pZ0Bh bWQuY29tCgpJbW8gdGhpcyBpcyBkdWN0LXRhcGUuIElmIHdlIHdhbnQgdG8gZml4IHRoaXMgdXAg cHJvcGVybHkgSSB0aGluayB3ZQpzaG91bGQganVzdCB1c2UgYSBmdWxsLWJsb3duIHNlcWxvY2sg aW5zdGVhZCBvZiBvdXIgaGFuZC1yb2xsZWQgb25lLiBBbmQKdGhhdCBjb3VsZCBoYW5kbGUgYW55 IGluY3JlbWVudCBhdCBhbGwuCi1EYW5pZWwKCj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1f aXJxLmMgfCA0MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICAx IGZpbGUgY2hhbmdlZCwgNDEgaW5zZXJ0aW9ucygrKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vZHJtX2lycS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9pcnEuYwo+IGluZGV4IGJj Yjg1MjguLmFhMmM3NGIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9pcnEuYwo+ ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1faXJxLmMKPiBAQCAtMjIxLDYgKzIyMSw0NyBAQCBz dGF0aWMgdm9pZCBkcm1fdXBkYXRlX3ZibGFua19jb3VudChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LCB1bnNpZ25lZCBpbnQgcGlwZSwKPiAgCQlkaWZmID0gKGZsYWdzICYgRFJNX0NBTExFRF9GUk9N X1ZCTElSUSkgIT0gMDsKPiAgCX0KPiAgCj4gKwkvKgo+ICsJICogUmVzdHJpY3QgdGhlIGJ1bXAg b2YgdGhlIHNvZnR3YXJlIHZibGFuayBjb3VudGVyIHRvIGEgc2FmZSBtYXhpbXVtCj4gKwkgKiB2 YWx1ZSBvZiArMSB3aGVuZXZlciB0aGVyZSBpcyB0aGUgcG9zc2liaWxpdHkgdGhhdCBjb25jdXJy ZW50IHJlYWRlcnMKPiArCSAqIG9mIHZibGFuayB0aW1lc3RhbXBzIGNvdWxkIGJlIGFjdGl2ZSBh dCB0aGUgbW9tZW50LCBhcyB0aGUgY3VycmVudAo+ICsJICogaW1wbGVtZW50YXRpb24gb2YgdGhl IHRpbWVzdGFtcCBjYWNoaW5nIGFuZCB1cGRhdGluZyBpcyBub3Qgc2FmZQo+ICsJICogYWdhaW5z dCBjb25jdXJyZW50IHJlYWRlcnMgZm9yIGNhbGxzIHRvIHN0b3JlX3ZibGFuaygpIHdpdGggYSBi dW1wCj4gKwkgKiBvZiBhbnl0aGluZyBidXQgKzEuIEEgYnVtcCAhPSAxIHdvdWxkIHZlcnkgbGlr ZWx5IHJldHVybiBjb3JydXB0ZWQKPiArCSAqIHRpbWVzdGFtcHMgdG8gdXNlcnNwYWNlLCBiZWNh dXNlIHRoZSBzYW1lIHNsb3QgaW4gdGhlIGNhY2hlIGNvdWxkCj4gKwkgKiBiZSBjb25jdXJyZW50 bHkgd3JpdHRlbiBieSBzdG9yZV92YmxhbmsoKSBhbmQgcmVhZCBieSBvbmUgb2YgdGhvc2UKPiAr CSAqIHJlYWRlcnMgd2l0aG91dCB0aGUgcmVhZC1yZXRyeSBsb2dpYyBkZXRlY3RpbmcgdGhlIGNv bGxpc2lvbi4KPiArCSAqCj4gKwkgKiBDb25jdXJyZW50IHJlYWRlcnMgY2FuIGV4aXN0IHdoZW4g d2UgYXJlIGNhbGxlZCBmcm9tIHRoZQo+ICsJICogZHJtX3ZibGFua19vZmYoKSBvciBkcm1fdmJs YW5rX29uKCkgZnVuY3Rpb25zIGFuZCBvdGhlciBub24tdmJsYW5rLQo+ICsJICogaXJxIGNhbGxl cnMuIEhvd2V2ZXIsIGFsbCB0aG9zZSBjYWxscyB0byB1cyBhcmUgaGFwcGVuaW5nIHdpdGggdGhl Cj4gKwkgKiB2YmxfbG9jayBsb2NrZWQgdG8gcHJldmVudCBkcm1fdmJsYW5rX2dldCgpLCBzbyB0 aGUgdmJsYW5rIHJlZmNvdW50Cj4gKwkgKiBjYW4ndCBpbmNyZWFzZSB3aGlsZSB3ZSBhcmUgZXhl Y3V0aW5nLiBUaGVyZWZvcmUgYSB6ZXJvIHJlZmNvdW50IGF0Cj4gKwkgKiB0aGlzIHBvaW50IGlz IHNhZmUgZm9yIGFyYml0cmFyeSBjb3VudGVyIGJ1bXBzIGlmIHdlIGFyZSBjYWxsZWQKPiArCSAq IG91dHNpZGUgdmJsYW5rIGlycSwgYSBub24temVybyBjb3VudCBpcyBub3QgMTAwJSBzYWZlLiBV bmZvcnR1bmF0ZWx5Cj4gKwkgKiB3ZSBtdXN0IGFsc28gYWNjZXB0IGEgcmVmY291bnQgb2YgMSwg YXMgd2hlbmV2ZXIgd2UgYXJlIGNhbGxlZCBmcm9tCj4gKwkgKiBkcm1fdmJsYW5rX2dldCgpIC0+ IGRybV92YmxhbmtfZW5hYmxlKCkgdGhlIHJlZmNvdW50IHdpbGwgYmUgMSBhbmQKPiArCSAqIHdl IG11c3QgbGV0IHRoYXQgb25lIHBhc3MgdGhyb3VnaCBpbiBvcmRlciB0byBub3QgbG9zZSB2Ymxh bmsgY291bnRzCj4gKwkgKiBkdXJpbmcgdmJsYW5rIGlycSBvZmYgLSB3aGljaCB3b3VsZCBjb21w bGV0ZWx5IGRlZmVhdCB0aGUgd2hvbGUKPiArCSAqIHBvaW50IG9mIHRoaXMgcm91dGluZS4KPiAr CSAqCj4gKwkgKiBXaGVuZXZlciB3ZSBhcmUgY2FsbGVkIGZyb20gdmJsYW5rIGlycSwgd2UgaGF2 ZSB0byBhc3N1bWUgY29uY3VycmVudAo+ICsJICogcmVhZGVycyBleGlzdCBvciBjYW4gc2hvdyB1 cCBhbnkgdGltZSBkdXJpbmcgb3VyIGV4ZWN1dGlvbiwgZXZlbiBpZgo+ICsJICogdGhlIHJlZmNv dW50IGlzIGN1cnJlbnRseSB6ZXJvLCBhcyB2YmxhbmsgaXJxcyBhcmUgdXN1YWxseSBvbmx5Cj4g KwkgKiBlbmFibGVkIGR1ZSB0byB0aGUgcHJlc2VuY2Ugb2YgcmVhZGVycywgYW5kIGJlY2F1c2Ug d2hlbiB3ZSBhcmUgY2FsbGVkCj4gKwkgKiBmcm9tIHZibGFuayBpcnEgd2UgY2FuJ3QgaG9sZCB0 aGUgdmJsX2xvY2sgdG8gcHJvdGVjdCB1cyBmcm9tIHN1ZGRlbgo+ICsJICogYnVtcHMgaW4gdmJs YW5rIHJlZmNvdW50LiBUaGVyZWZvcmUgYWxzbyByZXN0cmljdCBidW1wcyB0byArMSB3aGVuCj4g KwkgKiBjYWxsZWQgZnJvbSB2YmxhbmsgaXJxLgo+ICsJICovCj4gKwlpZiAoKGRpZmYgPiAxKSAm JiAoYXRvbWljX3JlYWQoJnZibGFuay0+cmVmY291bnQpID4gMSB8fAo+ICsJICAgIChmbGFncyAm IERSTV9DQUxMRURfRlJPTV9WQkxJUlEpKSkgewo+ICsJCURSTV9ERUJVR19WQkwoImNsYW1waW5n IHZibGFuayBidW1wIHRvIDEgb24gY3J0YyAldTogZGlmZnI9JXUgIgo+ICsJCQkgICAgICAicmVm Y291bnQgJXUsIHZibGlycSAldVxuIiwgcGlwZSwgZGlmZiwKPiArCQkJICAgICAgYXRvbWljX3Jl YWQoJnZibGFuay0+cmVmY291bnQpLAo+ICsJCQkgICAgICAoZmxhZ3MgJiBEUk1fQ0FMTEVEX0ZS T01fVkJMSVJRKSAhPSAwKTsKPiArCQlkaWZmID0gMTsKPiArCX0KPiArCj4gIAlEUk1fREVCVUdf VkJMKCJ1cGRhdGluZyB2YmxhbmsgY291bnQgb24gY3J0YyAldToiCj4gIAkJICAgICAgIiBjdXJy ZW50PSV1LCBkaWZmPSV1LCBodz0ldSBod19sYXN0PSV1XG4iLAo+ICAJCSAgICAgIHBpcGUsIHZi bGFuay0+Y291bnQsIGRpZmYsIGN1cl92YmxhbmssIHZibGFuay0+bGFzdCk7Cj4gLS0gCj4gMS45 LjEKPiAKCi0tIApEYW5pZWwgVmV0dGVyClNvZnR3YXJlIEVuZ2luZWVyLCBJbnRlbCBDb3Jwb3Jh dGlvbgpodHRwOi8vYmxvZy5mZndsbC5jaApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWwK