From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm0-f48.google.com ([74.125.82.48]:38408 "EHLO mail-wm0-f48.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755723AbcBIKWk (ORCPT ); Tue, 9 Feb 2016 05:22:40 -0500 Received: by mail-wm0-f48.google.com with SMTP id p63so16429115wmp.1 for ; Tue, 09 Feb 2016 02:22:39 -0800 (PST) Date: Tue, 9 Feb 2016 11:23:02 +0100 From: Daniel Vetter To: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Cc: Daniel Vetter , Mario Kleiner , dri-devel@lists.freedesktop.org, linux@bernd-steinhauser.de, stable@vger.kernel.org, michel@daenzer.net, vbabka@suse.cz, 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: <20160209102302.GT11240@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> <20160209095638.GM11240@phenom.ffwll.local> <20160209100727.GG23290@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20160209100727.GG23290@intel.com> Sender: stable-owner@vger.kernel.org List-ID: On Tue, Feb 09, 2016 at 12:07:27PM +0200, Ville Syrj�l� wrote: > On Tue, Feb 09, 2016 at 10:56:38AM +0100, Daniel Vetter wrote: > > 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. > > And I even fixed this [1] almost a half a year ago when I sent the > original series, but that part got held hostage to the same seqlock > argument. Perfect is the enemy of good. > > [1] https://lists.freedesktop.org/archives/intel-gfx/2015-September/075879.html Hm yeah, that does suffer from reinventing seqlocks. But I'd prefer your patch over Mario's hack here tbh. Your patch with seqlock would be even more awesome. -Daniel > > > -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 > > -- > Ville Syrj�l� > Intel OTC -- 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 11:23:02 +0100 Message-ID: <20160209102302.GT11240@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> <20160209095638.GM11240@phenom.ffwll.local> <20160209100727.GG23290@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-f52.google.com (mail-wm0-f52.google.com [74.125.82.52]) by gabe.freedesktop.org (Postfix) with ESMTPS id A633C6E542 for ; Tue, 9 Feb 2016 02:22:40 -0800 (PST) Received: by mail-wm0-f52.google.com with SMTP id c200so53355073wme.0 for ; Tue, 09 Feb 2016 02:22:40 -0800 (PST) Content-Disposition: inline In-Reply-To: <20160209100727.GG23290@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Cc: daniel.vetter@ffwll.ch, michel@daenzer.net, linux@bernd-steinhauser.de, stable@vger.kernel.org, dri-devel@lists.freedesktop.org, alexander.deucher@amd.com, christian.koenig@amd.com, vbabka@suse.cz List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBGZWIgMDksIDIwMTYgYXQgMTI6MDc6MjdQTSArMDIwMCwgVmlsbGUgU3lyasOkbMOk IHdyb3RlOgo+IE9uIFR1ZSwgRmViIDA5LCAyMDE2IGF0IDEwOjU2OjM4QU0gKzAxMDAsIERhbmll bCBWZXR0ZXIgd3JvdGU6Cj4gPiBPbiBNb24sIEZlYiAwOCwgMjAxNiBhdCAwMjoxMzoyNUFNICsw MTAwLCBNYXJpbyBLbGVpbmVyIHdyb3RlOgo+ID4gPiBUaGlzIGZpeGVzIGEgcmVncmVzc2lvbiBp bnRyb2R1Y2VkIGJ5IHRoZSBuZXcgZHJtX3VwZGF0ZV92YmxhbmtfY291bnQoKQo+ID4gPiBpbXBs ZW1lbnRhdGlvbiBpbiBMaW51eCA0LjQ6Cj4gPiA+IAo+ID4gPiBSZXN0cmljdCB0aGUgYnVtcCBv ZiB0aGUgc29mdHdhcmUgdmJsYW5rIGNvdW50ZXIgaW4gZHJtX3VwZGF0ZV92YmxhbmtfY291bnQo KQo+ID4gPiB0byBhIHNhZmUgbWF4aW11bSB2YWx1ZSBvZiArMSB3aGVuZXZlciB0aGVyZSBpcyB0 aGUgcG9zc2liaWxpdHkgdGhhdAo+ID4gPiBjb25jdXJyZW50IHJlYWRlcnMgb2YgdmJsYW5rIHRp bWVzdGFtcHMgY291bGQgYmUgYWN0aXZlIGF0IHRoZSBtb21lbnQsCj4gPiA+IGFzIHRoZSBjdXJy ZW50IGltcGxlbWVudGF0aW9uIG9mIHRoZSB0aW1lc3RhbXAgY2FjaGluZyBhbmQgdXBkYXRpbmcg aXMKPiA+ID4gbm90IHNhZmUgYWdhaW5zdCBjb25jdXJyZW50IHJlYWRlcnMgZm9yIGNhbGxzIHRv IHN0b3JlX3ZibGFuaygpIHdpdGggYQo+ID4gPiBidW1wIG9mIGFueXRoaW5nIGJ1dCArMS4gQSBi dW1wICE9IDEgd291bGQgdmVyeSBsaWtlbHkgcmV0dXJuIGNvcnJ1cHRlZAo+ID4gPiB0aW1lc3Rh bXBzIHRvIHVzZXJzcGFjZSwgYmVjYXVzZSB0aGUgc2FtZSBzbG90IGluIHRoZSBjYWNoZSBjb3Vs ZAo+ID4gPiBiZSBjb25jdXJyZW50bHkgd3JpdHRlbiBieSBzdG9yZV92YmxhbmsoKSBhbmQgcmVh ZCBieSBvbmUgb2YgdGhvc2UKPiA+ID4gcmVhZGVycyBpbiBhIG5vbi1hdG9taWMgZmFzaGlvbiBh bmQgd2l0aG91dCB0aGUgcmVhZC1yZXRyeSBsb2dpYwo+ID4gPiBkZXRlY3RpbmcgdGhpcyBjb2xs aXNpb24uCj4gPiA+IAo+ID4gPiBDb25jdXJyZW50IHJlYWRlcnMgY2FuIGV4aXN0IHdoaWxlIGRy bV91cGRhdGVfdmJsYW5rX2NvdW50KCkgaXMgY2FsbGVkCj4gPiA+IGZyb20gdGhlIGRybV92Ymxh bmtfb2ZmKCkgb3IgZHJtX3ZibGFua19vbigpIGZ1bmN0aW9ucyBvciBvdGhlciBub24tdmJsYW5r LQo+ID4gPiBpcnEgY2FsbGVycy4gSG93ZXZlciwgYWxsIHRob3NlIGNhbGxzIGFyZSBoYXBwZW5p bmcgd2l0aCB0aGUgdmJsX2xvY2sKPiA+ID4gbG9ja2VkIHRoZXJlYnkgcHJldmVudGluZyBhIGRy bV92YmxhbmtfZ2V0KCksIHNvIHRoZSB2YmxhbmsgcmVmY291bnQKPiA+ID4gY2FuJ3QgaW5jcmVh c2Ugd2hpbGUgZHJtX3VwZGF0ZV92YmxhbmtfY291bnQoKSBpcyBleGVjdXRpbmcuIFRoZXJlZm9y ZQo+ID4gPiBhIHplcm8gdmJsYW5rIHJlZmNvdW50IGR1cmluZyBleGVjdXRpb24gb2YgdGhhdCBm dW5jdGlvbiBzaWduYWxzIHRoYXQKPiA+ID4gaXMgc2FmZSBmb3IgYXJiaXRyYXJ5IGNvdW50ZXIg YnVtcHMgaWYgY2FsbGVkIGZyb20gb3V0c2lkZSB2YmxhbmsgaXJxLAo+ID4gPiB3aGVyZWFzIGEg bm9uLXplcm8gY291bnQgaXMgbm90IHNhZmUuCj4gPiA+IAo+ID4gPiBXaGVuZXZlciB0aGUgZnVu Y3Rpb24gaXMgY2FsbGVkIGZyb20gdmJsYW5rIGlycSwgd2UgaGF2ZSB0byBhc3N1bWUgY29uY3Vy cmVudAo+ID4gPiByZWFkZXJzIGNvdWxkIHNob3cgdXAgYW55IHRpbWUgZHVyaW5nIGl0cyBleGVj dXRpb24sIGV2ZW4gaWYgdGhlIHJlZmNvdW50Cj4gPiA+IGlzIGN1cnJlbnRseSB6ZXJvLCBhcyB2 YmxhbmsgaXJxcyBhcmUgdXN1YWxseSBvbmx5IGVuYWJsZWQgZHVlIHRvIHRoZQo+ID4gPiBwcmVz ZW5jZSBvZiByZWFkZXJzLCBhbmQgYmVjYXVzZSB3aGVuIGl0IGlzIGNhbGxlZCBmcm9tIHZibGFu ayBpcnEgaXQKPiA+ID4gY2FuJ3QgaG9sZCB0aGUgdmJsX2xvY2sgdG8gcHJvdGVjdCBpdCBmcm9t IHN1ZGRlbiBidW1wcyBpbiB2YmxhbmsgcmVmY291bnQuCj4gPiA+IFRoZXJlZm9yZSBhbHNvIHJl c3RyaWN0IGJ1bXBzIHRvICsxIHdoZW4gdGhlIGZ1bmN0aW9uIGlzIGNhbGxlZCBmcm9tIHZibGFu awo+ID4gPiBpcnEuCj4gPiA+IAo+ID4gPiBTdWNoIGJ1bXBzIG9mIG1vcmUgdGhhbiArMSBjYW4g aGFwcGVuIGF0IG90aGVyIHRpbWVzIHRoYW4gcmVlbmFibGluZwo+ID4gPiB2YmxhbmsgaXJxcywg ZS5nLiwgd2hlbiByZWd1bGFyIHZibGFuayBpbnRlcnJ1cHRzIGdldCBkZWxheWVkIGJ5IG1vcmUK PiA+ID4gdGhhbiAxIGZyYW1lIGR1ZSB0byBsb25nIGhlbGQgbG9ja3MsIGxvbmcgaXJxIG9mZiBw ZXJpb2RzLCByZWFsdGltZQo+ID4gPiBwcmVlbXB0aW9uIG9uIFJUIGtlcm5lbHMsIG9yIHN5c3Rl bSBtYW5hZ2VtZW50IGludGVycnVwdHMuCj4gPiA+IAo+ID4gPiBTaWduZWQtb2ZmLWJ5OiBNYXJp byBLbGVpbmVyIDxtYXJpby5rbGVpbmVyLmRlQGdtYWlsLmNvbT4KPiA+ID4gQ2M6IDxzdGFibGVA dmdlci5rZXJuZWwub3JnPiAjIDQuNCsKPiA+ID4gQ2M6IG1pY2hlbEBkYWVuemVyLm5ldAo+ID4g PiBDYzogdmJhYmthQHN1c2UuY3oKPiA+ID4gQ2M6IHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwu Y29tCj4gPiA+IENjOiBkYW5pZWwudmV0dGVyQGZmd2xsLmNoCj4gPiA+IENjOiBkcmktZGV2ZWxA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gPiA+IENjOiBhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29t Cj4gPiA+IENjOiBjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20KPiA+IAo+ID4gSW1vIHRoaXMgaXMg ZHVjdC10YXBlLiBJZiB3ZSB3YW50IHRvIGZpeCB0aGlzIHVwIHByb3Blcmx5IEkgdGhpbmsgd2UK PiA+IHNob3VsZCBqdXN0IHVzZSBhIGZ1bGwtYmxvd24gc2VxbG9jayBpbnN0ZWFkIG9mIG91ciBo YW5kLXJvbGxlZCBvbmUuIEFuZAo+ID4gdGhhdCBjb3VsZCBoYW5kbGUgYW55IGluY3JlbWVudCBh dCBhbGwuCj4gCj4gQW5kIEkgZXZlbiBmaXhlZCB0aGlzIFsxXSBhbG1vc3QgYSBoYWxmIGEgeWVh ciBhZ28gd2hlbiBJIHNlbnQgdGhlCj4gb3JpZ2luYWwgc2VyaWVzLCBidXQgdGhhdCBwYXJ0IGdv dCBoZWxkIGhvc3RhZ2UgdG8gdGhlIHNhbWUgc2VxbG9jawo+IGFyZ3VtZW50LiBQZXJmZWN0IGlz IHRoZSBlbmVteSBvZiBnb29kLgo+IAo+IFsxXSBodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9hcmNoaXZlcy9pbnRlbC1nZngvMjAxNS1TZXB0ZW1iZXIvMDc1ODc5Lmh0bWwKCkhtIHllYWgs IHRoYXQgZG9lcyBzdWZmZXIgZnJvbSByZWludmVudGluZyBzZXFsb2Nrcy4gQnV0IEknZCBwcmVm ZXIgeW91cgpwYXRjaCBvdmVyIE1hcmlvJ3MgaGFjayBoZXJlIHRiaC4gWW91ciBwYXRjaCB3aXRo IHNlcWxvY2sgd291bGQgYmUgZXZlbgptb3JlIGF3ZXNvbWUuCi1EYW5pZWwKCj4gCj4gPiAtRGFu aWVsCj4gPiAKPiA+ID4gLS0tCj4gPiA+ICBkcml2ZXJzL2dwdS9kcm0vZHJtX2lycS5jIHwgNDEg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiA+ID4gIDEgZmlsZSBj aGFuZ2VkLCA0MSBpbnNlcnRpb25zKCspCj4gPiA+IAo+ID4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL2RybV9pcnEuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1faXJxLmMKPiA+ID4gaW5k ZXggYmNiODUyOC4uYWEyYzc0YiAxMDA2NDQKPiA+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2Ry bV9pcnEuYwo+ID4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2lycS5jCj4gPiA+IEBAIC0y MjEsNiArMjIxLDQ3IEBAIHN0YXRpYyB2b2lkIGRybV91cGRhdGVfdmJsYW5rX2NvdW50KHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsIHVuc2lnbmVkIGludCBwaXBlLAo+ID4gPiAgCQlkaWZmID0gKGZs YWdzICYgRFJNX0NBTExFRF9GUk9NX1ZCTElSUSkgIT0gMDsKPiA+ID4gIAl9Cj4gPiA+ICAKPiA+ ID4gKwkvKgo+ID4gPiArCSAqIFJlc3RyaWN0IHRoZSBidW1wIG9mIHRoZSBzb2Z0d2FyZSB2Ymxh bmsgY291bnRlciB0byBhIHNhZmUgbWF4aW11bQo+ID4gPiArCSAqIHZhbHVlIG9mICsxIHdoZW5l dmVyIHRoZXJlIGlzIHRoZSBwb3NzaWJpbGl0eSB0aGF0IGNvbmN1cnJlbnQgcmVhZGVycwo+ID4g PiArCSAqIG9mIHZibGFuayB0aW1lc3RhbXBzIGNvdWxkIGJlIGFjdGl2ZSBhdCB0aGUgbW9tZW50 LCBhcyB0aGUgY3VycmVudAo+ID4gPiArCSAqIGltcGxlbWVudGF0aW9uIG9mIHRoZSB0aW1lc3Rh bXAgY2FjaGluZyBhbmQgdXBkYXRpbmcgaXMgbm90IHNhZmUKPiA+ID4gKwkgKiBhZ2FpbnN0IGNv bmN1cnJlbnQgcmVhZGVycyBmb3IgY2FsbHMgdG8gc3RvcmVfdmJsYW5rKCkgd2l0aCBhIGJ1bXAK PiA+ID4gKwkgKiBvZiBhbnl0aGluZyBidXQgKzEuIEEgYnVtcCAhPSAxIHdvdWxkIHZlcnkgbGlr ZWx5IHJldHVybiBjb3JydXB0ZWQKPiA+ID4gKwkgKiB0aW1lc3RhbXBzIHRvIHVzZXJzcGFjZSwg YmVjYXVzZSB0aGUgc2FtZSBzbG90IGluIHRoZSBjYWNoZSBjb3VsZAo+ID4gPiArCSAqIGJlIGNv bmN1cnJlbnRseSB3cml0dGVuIGJ5IHN0b3JlX3ZibGFuaygpIGFuZCByZWFkIGJ5IG9uZSBvZiB0 aG9zZQo+ID4gPiArCSAqIHJlYWRlcnMgd2l0aG91dCB0aGUgcmVhZC1yZXRyeSBsb2dpYyBkZXRl Y3RpbmcgdGhlIGNvbGxpc2lvbi4KPiA+ID4gKwkgKgo+ID4gPiArCSAqIENvbmN1cnJlbnQgcmVh ZGVycyBjYW4gZXhpc3Qgd2hlbiB3ZSBhcmUgY2FsbGVkIGZyb20gdGhlCj4gPiA+ICsJICogZHJt X3ZibGFua19vZmYoKSBvciBkcm1fdmJsYW5rX29uKCkgZnVuY3Rpb25zIGFuZCBvdGhlciBub24t dmJsYW5rLQo+ID4gPiArCSAqIGlycSBjYWxsZXJzLiBIb3dldmVyLCBhbGwgdGhvc2UgY2FsbHMg dG8gdXMgYXJlIGhhcHBlbmluZyB3aXRoIHRoZQo+ID4gPiArCSAqIHZibF9sb2NrIGxvY2tlZCB0 byBwcmV2ZW50IGRybV92YmxhbmtfZ2V0KCksIHNvIHRoZSB2YmxhbmsgcmVmY291bnQKPiA+ID4g KwkgKiBjYW4ndCBpbmNyZWFzZSB3aGlsZSB3ZSBhcmUgZXhlY3V0aW5nLiBUaGVyZWZvcmUgYSB6 ZXJvIHJlZmNvdW50IGF0Cj4gPiA+ICsJICogdGhpcyBwb2ludCBpcyBzYWZlIGZvciBhcmJpdHJh cnkgY291bnRlciBidW1wcyBpZiB3ZSBhcmUgY2FsbGVkCj4gPiA+ICsJICogb3V0c2lkZSB2Ymxh bmsgaXJxLCBhIG5vbi16ZXJvIGNvdW50IGlzIG5vdCAxMDAlIHNhZmUuIFVuZm9ydHVuYXRlbHkK PiA+ID4gKwkgKiB3ZSBtdXN0IGFsc28gYWNjZXB0IGEgcmVmY291bnQgb2YgMSwgYXMgd2hlbmV2 ZXIgd2UgYXJlIGNhbGxlZCBmcm9tCj4gPiA+ICsJICogZHJtX3ZibGFua19nZXQoKSAtPiBkcm1f dmJsYW5rX2VuYWJsZSgpIHRoZSByZWZjb3VudCB3aWxsIGJlIDEgYW5kCj4gPiA+ICsJICogd2Ug bXVzdCBsZXQgdGhhdCBvbmUgcGFzcyB0aHJvdWdoIGluIG9yZGVyIHRvIG5vdCBsb3NlIHZibGFu ayBjb3VudHMKPiA+ID4gKwkgKiBkdXJpbmcgdmJsYW5rIGlycSBvZmYgLSB3aGljaCB3b3VsZCBj b21wbGV0ZWx5IGRlZmVhdCB0aGUgd2hvbGUKPiA+ID4gKwkgKiBwb2ludCBvZiB0aGlzIHJvdXRp bmUuCj4gPiA+ICsJICoKPiA+ID4gKwkgKiBXaGVuZXZlciB3ZSBhcmUgY2FsbGVkIGZyb20gdmJs YW5rIGlycSwgd2UgaGF2ZSB0byBhc3N1bWUgY29uY3VycmVudAo+ID4gPiArCSAqIHJlYWRlcnMg ZXhpc3Qgb3IgY2FuIHNob3cgdXAgYW55IHRpbWUgZHVyaW5nIG91ciBleGVjdXRpb24sIGV2ZW4g aWYKPiA+ID4gKwkgKiB0aGUgcmVmY291bnQgaXMgY3VycmVudGx5IHplcm8sIGFzIHZibGFuayBp cnFzIGFyZSB1c3VhbGx5IG9ubHkKPiA+ID4gKwkgKiBlbmFibGVkIGR1ZSB0byB0aGUgcHJlc2Vu Y2Ugb2YgcmVhZGVycywgYW5kIGJlY2F1c2Ugd2hlbiB3ZSBhcmUgY2FsbGVkCj4gPiA+ICsJICog ZnJvbSB2YmxhbmsgaXJxIHdlIGNhbid0IGhvbGQgdGhlIHZibF9sb2NrIHRvIHByb3RlY3QgdXMg ZnJvbSBzdWRkZW4KPiA+ID4gKwkgKiBidW1wcyBpbiB2YmxhbmsgcmVmY291bnQuIFRoZXJlZm9y ZSBhbHNvIHJlc3RyaWN0IGJ1bXBzIHRvICsxIHdoZW4KPiA+ID4gKwkgKiBjYWxsZWQgZnJvbSB2 YmxhbmsgaXJxLgo+ID4gPiArCSAqLwo+ID4gPiArCWlmICgoZGlmZiA+IDEpICYmIChhdG9taWNf cmVhZCgmdmJsYW5rLT5yZWZjb3VudCkgPiAxIHx8Cj4gPiA+ICsJICAgIChmbGFncyAmIERSTV9D QUxMRURfRlJPTV9WQkxJUlEpKSkgewo+ID4gPiArCQlEUk1fREVCVUdfVkJMKCJjbGFtcGluZyB2 YmxhbmsgYnVtcCB0byAxIG9uIGNydGMgJXU6IGRpZmZyPSV1ICIKPiA+ID4gKwkJCSAgICAgICJy ZWZjb3VudCAldSwgdmJsaXJxICV1XG4iLCBwaXBlLCBkaWZmLAo+ID4gPiArCQkJICAgICAgYXRv bWljX3JlYWQoJnZibGFuay0+cmVmY291bnQpLAo+ID4gPiArCQkJICAgICAgKGZsYWdzICYgRFJN X0NBTExFRF9GUk9NX1ZCTElSUSkgIT0gMCk7Cj4gPiA+ICsJCWRpZmYgPSAxOwo+ID4gPiArCX0K PiA+ID4gKwo+ID4gPiAgCURSTV9ERUJVR19WQkwoInVwZGF0aW5nIHZibGFuayBjb3VudCBvbiBj cnRjICV1OiIKPiA+ID4gIAkJICAgICAgIiBjdXJyZW50PSV1LCBkaWZmPSV1LCBodz0ldSBod19s YXN0PSV1XG4iLAo+ID4gPiAgCQkgICAgICBwaXBlLCB2YmxhbmstPmNvdW50LCBkaWZmLCBjdXJf dmJsYW5rLCB2YmxhbmstPmxhc3QpOwo+ID4gPiAtLSAKPiA+ID4gMS45LjEKPiA+ID4gCj4gPiAK PiA+IC0tIAo+ID4gRGFuaWVsIFZldHRlcgo+ID4gU29mdHdhcmUgRW5naW5lZXIsIEludGVsIENv cnBvcmF0aW9uCj4gPiBodHRwOi8vYmxvZy5mZndsbC5jaAo+IAo+IC0tIAo+IFZpbGxlIFN5cmrD pGzDpAo+IEludGVsIE9UQwoKLS0gCkRhbmllbCBWZXR0ZXIKU29mdHdhcmUgRW5naW5lZXIsIElu dGVsIENvcnBvcmF0aW9uCmh0dHA6Ly9ibG9nLmZmd2xsLmNoCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRl dmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=