From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751946AbeDEKDZ (ORCPT ); Thu, 5 Apr 2018 06:03:25 -0400 Received: from mail-wm0-f41.google.com ([74.125.82.41]:52100 "EHLO mail-wm0-f41.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751535AbeDEKDY (ORCPT ); Thu, 5 Apr 2018 06:03:24 -0400 X-Google-Smtp-Source: AIpwx4/lhOLReJ49wSvN4UYLJsDz1b8B0EMGajc8/PIuhAVSqsWWXhsNMCcpz+yoysT99iMmyVEtVg== Date: Thu, 5 Apr 2018 12:03:19 +0200 From: Daniel Vetter To: Thomas Hellstrom Cc: Deepak Rawat , dri-devel@lists.freedesktop.org, syeh@vmware.com, linux-graphics-maintainer@vmware.com, ville.syrjala@linux.intel.com, lukasz.spintzyk@displaylink.com, noralf@tronnes.org, robdclark@gmail.com, gustavo@padovan.org, maarten.lankhorst@linux.intel.com, seanpaul@chromium.org, airlied@linux.ie, linux-kernel@vger.kernel.org Subject: Re: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane Message-ID: <20180405100319.GT3881@phenom.ffwll.local> Mail-Followup-To: Thomas Hellstrom , Deepak Rawat , dri-devel@lists.freedesktop.org, syeh@vmware.com, linux-graphics-maintainer@vmware.com, ville.syrjala@linux.intel.com, lukasz.spintzyk@displaylink.com, noralf@tronnes.org, robdclark@gmail.com, gustavo@padovan.org, maarten.lankhorst@linux.intel.com, seanpaul@chromium.org, airlied@linux.ie, linux-kernel@vger.kernel.org References: <1522885748-67122-1-git-send-email-drawat@vmware.com> <1522885748-67122-2-git-send-email-drawat@vmware.com> <20180405073525.GP3881@phenom.ffwll.local> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: X-Operating-System: Linux phenom 4.15.0-1-amd64 User-Agent: Mutt/1.9.4 (2018-02-28) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, Apr 05, 2018 at 11:00:15AM +0200, Thomas Hellstrom wrote: > On 04/05/2018 09:35 AM, Daniel Vetter wrote: > > On Wed, Apr 04, 2018 at 04:49:06PM -0700, Deepak Rawat wrote: > > > From: Lukasz Spintzyk > > > > > > Optional plane property to mark damaged regions on the plane in > > > framebuffer coordinates of the framebuffer attached to the plane. > > > > > > The layout of blob data is simply an array of drm_mode_rect with maximum > > > array size limited by DRM_MODE_FB_DIRTY_MAX_CLIPS. Unlike plane src > > > coordinates, damage clips are not in 16.16 fixed point. > > > > > > Damage clips are a hint to kernel as which area of framebuffer has > > > changed since last page-flip. This should be helpful for some drivers > > > especially for virtual devices where each framebuffer change needs to > > > be transmitted over network, usb, etc. > > > > > > Driver which are interested in enabling DAMAGE_CLIPS property for a > > > plane should enable this property using drm_plane_enable_damage_clips. > > > > > > Signed-off-by: Lukasz Spintzyk > > > Signed-off-by: Deepak Rawat > > The property uapi section is missing, see: > > > > https://urldefense.proofpoint.com/v2/url?u=https-3A__dri.freedesktop.org_docs_drm_gpu_drm-2Dkms.html-23plane-2Dcomposition-2Dproperties&d=DwIBAg&c=uilaK90D4TOVoH58JNXRgQ&r=wnSlgOCqfpNS4d02vP68_E9q2BNMCwfD2OZ_6dCFVQQ&m=J31YNV1uz3IVRaorM-eo48msi9__sQurqRZrig2UE1s&s=vzsuquF1agbOw54HSC_18Kk2k9j83m8RusmDCtPAFWQ&e= > > > > Plane composition feels like the best place to put this. Please use that > > section to tie all the various bits together, including the helpers you're > > adding in the following patches for drivers to use. > > > > Bunch of nitpicks below, but overall I'm agreeing now with just going with > > fb coordinate damage rects. > > > > Like you say, the thing needed here now is userspace + driver actually > > implementing this. I'd also say the compat helper to map the legacy > > fb->dirty to this new atomic way of doing things should be included here > > (gives us a lot more testing for these new paths). > > > > Icing on the cake would be an igt to make sure kernel rejects invalid clip > > rects correctly. > > > > > --- > > > drivers/gpu/drm/drm_atomic.c | 42 +++++++++++++++++++++++++++++++++++++ > > > drivers/gpu/drm/drm_atomic_helper.c | 4 ++++ > > > drivers/gpu/drm/drm_mode_config.c | 5 +++++ > > > drivers/gpu/drm/drm_plane.c | 12 +++++++++++ > > > include/drm/drm_mode_config.h | 15 +++++++++++++ > > > include/drm/drm_plane.h | 16 ++++++++++++++ > > > include/uapi/drm/drm_mode.h | 15 +++++++++++++ > > > 7 files changed, 109 insertions(+) > > > > > > diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c > > > index 7d25c42..9226d24 100644 > > > --- a/drivers/gpu/drm/drm_atomic.c > > > +++ b/drivers/gpu/drm/drm_atomic.c > > > @@ -669,6 +669,40 @@ static void drm_atomic_crtc_print_state(struct drm_printer *p, > > > } > > > /** > > > + * drm_atomic_set_damage_for_plane - sets the damage clips property to plane > > > + * @state: plane state > > > + * @blob: damage clips in framebuffer coordinates > > > + * > > > + * Returns: > > > + * > > > + * Zero on success, error code on failure. > > > + */ > > > +static int drm_atomic_set_damage_for_plane(struct drm_plane_state *state, > > > + struct drm_property_blob *blob) > > > +{ > > > + if (blob == state->damage_clips) > > > + return 0; > > > + > > > + drm_property_blob_put(state->damage_clips); > > > + state->damage_clips = NULL; > > > + > > > + if (blob) { > > > + uint32_t count = blob->length/sizeof(struct drm_rect); > > > + > > > + if (count > DRM_MODE_FB_DIRTY_MAX_CLIPS) > > > + return -EINVAL; > > > + > > > + state->damage_clips = drm_property_blob_get(blob); > > > + state->num_clips = count; > > > + } else { > > > + state->damage_clips = NULL; > > > + state->num_clips = 0; > > > + } > > > + > > > + return 0; > > > +} > > > + > > > +/** > > > * drm_atomic_get_plane_state - get plane state > > > * @state: global atomic state object > > > * @plane: plane to get state object for > > > @@ -793,6 +827,12 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane, > > > state->color_encoding = val; > > > } else if (property == plane->color_range_property) { > > > state->color_range = val; > > > + } else if (property == config->prop_damage_clips) { > > > + struct drm_property_blob *blob = > > > + drm_property_lookup_blob(dev, val); > > > + int ret = drm_atomic_set_damage_for_plane(state, blob); > > There's already a helper with size-checking built-in, see > > drm_atomic_replace_property_blob_from_id(). Wrt computing num_clips I'd > > just provide a little inline helper that does the > > blob->length/sizeof(drm_rect) conversion (it's just a shift, so fast). > > > > > + drm_property_blob_put(blob); > > > + return ret; > > > } else if (plane->funcs->atomic_set_property) { > > > return plane->funcs->atomic_set_property(plane, state, > > > property, val); > > > @@ -856,6 +896,8 @@ drm_atomic_plane_get_property(struct drm_plane *plane, > > > *val = state->color_encoding; > > > } else if (property == plane->color_range_property) { > > > *val = state->color_range; > > > + } else if (property == config->prop_damage_clips) { > > > + *val = (state->damage_clips) ? state->damage_clips->base.id : 0; > > > } else if (plane->funcs->atomic_get_property) { > > > return plane->funcs->atomic_get_property(plane, state, property, val); > > > } else { > > > diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c > > > index c356545..55b44e3 100644 > > > --- a/drivers/gpu/drm/drm_atomic_helper.c > > > +++ b/drivers/gpu/drm/drm_atomic_helper.c > > > @@ -3506,6 +3506,8 @@ void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, > > > state->fence = NULL; > > > state->commit = NULL; > > > + state->damage_clips = NULL; > > > + state->num_clips = 0; > > > } > > > EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state); > > > @@ -3550,6 +3552,8 @@ void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state) > > > if (state->commit) > > > drm_crtc_commit_put(state->commit); > > > + > > > + drm_property_blob_put(state->damage_clips); > > > } > > > EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state); > > > diff --git a/drivers/gpu/drm/drm_mode_config.c b/drivers/gpu/drm/drm_mode_config.c > > > index e5c6533..e93b127 100644 > > > --- a/drivers/gpu/drm/drm_mode_config.c > > > +++ b/drivers/gpu/drm/drm_mode_config.c > > > @@ -293,6 +293,11 @@ static int drm_mode_create_standard_properties(struct drm_device *dev) > > > return -ENOMEM; > > > dev->mode_config.prop_crtc_id = prop; > > > + prop = drm_property_create(dev, DRM_MODE_PROP_BLOB, "DAMAGE_CLIPS", 0); > > Bit a bikeshed, but since the coordinates are in fb pixels, not plane > > pixels, I'd call this "FB_DAMAGE_CLIPS". > > > > > + if (!prop) > > > + return -ENOMEM; > > > + dev->mode_config.prop_damage_clips = prop; > > > + > > > prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC, > > > "ACTIVE"); > > > if (!prop) > > > diff --git a/drivers/gpu/drm/drm_plane.c b/drivers/gpu/drm/drm_plane.c > > > index 6d2a6e4..071221b 100644 > > > --- a/drivers/gpu/drm/drm_plane.c > > > +++ b/drivers/gpu/drm/drm_plane.c > > > @@ -1101,3 +1101,15 @@ int drm_mode_page_flip_ioctl(struct drm_device *dev, > > > return ret; > > > } > > > + > > > +/** > > > + * drm_plane_enable_damage_clips - enable damage clips property > > > + * @plane: plane on which this property to enable. > > > + */ > > > +void drm_plane_enable_damage_clips(struct drm_plane *plane) > > > +{ > > > + struct drm_device *dev = plane->dev; > > > + struct drm_mode_config *config = &dev->mode_config; > > > + > > > + drm_object_attach_property(&plane->base, config->prop_damage_clips, 0); > > > +} > > > diff --git a/include/drm/drm_mode_config.h b/include/drm/drm_mode_config.h > > > index 7569f22..d8767da 100644 > > > --- a/include/drm/drm_mode_config.h > > > +++ b/include/drm/drm_mode_config.h > > > @@ -628,6 +628,21 @@ struct drm_mode_config { > > > */ > > > struct drm_property *prop_crtc_id; > > > /** > > > + * @prop_damage_clips: Optional plane property to mark damaged regions > > > + * on the plane in framebuffer coordinates of the framebuffer attached > > > + * to the plane. > > Why should we make this optional? Looks like just another thing drivers > > might screw up, since we have multiple callbacks and things to set up for > > proper dirty tracking. > > > > One option I'm seeing is that if this is set, and it's an atomic driver, > > then we just directly call into the default atomic fb->dirty > > implementation. That way there's only 1 thing drivers need to do to set up > > dirty rect tracking, and they'll get all of it. > > > > > + * > > > + * The layout of blob data is simply an array of drm_mode_rect with > > > + * maximum array size limited by DRM_MODE_FB_DIRTY_MAX_CLIPS. Unlike > > > + * plane src coordinates, damage clips are not in 16.16 fixed point. > > I honestly have no idea where this limit is from. Worth keeping? I can > > easily imagine that userspace could trip over this - it's fairly high, but > > not unlimited. > > > > > + * > > > + * Damage clips are a hint to kernel as which area of framebuffer has > > > + * changed since last page-flip. This should be helpful > > > + * for some drivers especially for virtual devices where each > > > + * framebuffer change needs to be transmitted over network, usb, etc. > > I'd also clarify that userspace still must render the entire screen, i.e. > > make it more clear that it's really just a hint and not mandatory to only > > scan out the damaged parts. > > > > > + */ > > > + struct drm_property *prop_damage_clips; > > > + /** > > > * @prop_active: Default atomic CRTC property to control the active > > > * state, which is the simplified implementation for DPMS in atomic > > > * drivers. > > > diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h > > > index f7bf4a4..9f24548 100644 > > > --- a/include/drm/drm_plane.h > > > +++ b/include/drm/drm_plane.h > > > @@ -146,6 +146,21 @@ struct drm_plane_state { > > > */ > > > struct drm_crtc_commit *commit; > > > + /* > > > + * @damage_clips > > > + * > > > + * blob property with damage as array of drm_rect in framebuffer > > &drm_rect gives you a nice hyperlink in the generated docs. > > > > > + * coodinates. > > > + */ > > > + struct drm_property_blob *damage_clips; > > > + > > > + /* > > > + * @num_clips > > > + * > > > + * Number of drm_rect in @damage_clips. > > > + */ > > > + uint32_t num_clips; > > > + > > > struct drm_atomic_state *state; > > > }; > > > @@ -611,6 +626,7 @@ int drm_plane_init(struct drm_device *dev, > > > const uint32_t *formats, unsigned int format_count, > > > bool is_primary); > > > void drm_plane_cleanup(struct drm_plane *plane); > > > +void drm_plane_enable_damage_clips(struct drm_plane *plane); > > > /** > > > * drm_plane_index - find the index of a registered plane > > > diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h > > > index 50bcf42..0ad0d5b 100644 > > > --- a/include/uapi/drm/drm_mode.h > > > +++ b/include/uapi/drm/drm_mode.h > > > @@ -873,6 +873,21 @@ struct drm_mode_revoke_lease { > > > __u32 lessee_id; > > > }; > > > +/** > > > + * struct drm_mode_rect - two dimensional rectangle drm_rect exported to > > > + * user-space. > > > + * @x1: horizontal starting coordinate (inclusive) > > > + * @y1: vertical starting coordinate (inclusive) > > > + * @x2: horizontal ending coordinate (exclusive) > > > + * @y2: vertical ending coordinate (exclusive) > > > + */ > > > +struct drm_mode_rect { > > > + __s32 x1; > > > + __s32 y1; > > > + __s32 x2; > > > + __s32 y2; > > Why signed? Negative damage rects on an fb don't make sense to me. Also, > > please specify what this is exactly (to avoid confusion with the 16.16 > > fixed point src rects), and maybe mention in the commit message why we're > > not using drm_clip_rect (going to proper uapi types and 32bit makes sense > > to me). > > IMO, while we don't expect negative damage coordinates, > to avoid yet another drm uapi rect in the future when we actually need > negative numbers signed is a good choice... Makes sense. Another thing I realized: Since src rect are 16.16 fixed point, do we really need s32? drm_clip_rect is a bit meh, but it gives us s16 already. That would avoid having to sprinkle the code with tons of overflow checks for input validation. On the topic of input validation: Should the kernel check in shared code that all the clip rects are sensible, i.e. within the dimensions of the fb? Relying on drivers for that seems like a bad idea. That could be done in core code in drm_atomic_plane_check(). -Daniel > > /Thomas > > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- 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: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane Date: Thu, 5 Apr 2018 12:03:19 +0200 Message-ID: <20180405100319.GT3881@phenom.ffwll.local> References: <1522885748-67122-1-git-send-email-drawat@vmware.com> <1522885748-67122-2-git-send-email-drawat@vmware.com> <20180405073525.GP3881@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x230.google.com (mail-wm0-x230.google.com [IPv6:2a00:1450:400c:c09::230]) by gabe.freedesktop.org (Postfix) with ESMTPS id 61D466E715 for ; Thu, 5 Apr 2018 10:03:24 +0000 (UTC) Received: by mail-wm0-x230.google.com with SMTP id p9so4150456wmc.3 for ; Thu, 05 Apr 2018 03:03:24 -0700 (PDT) Content-Disposition: inline In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Thomas Hellstrom Cc: airlied@linux.ie, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-graphics-maintainer@vmware.com, Deepak Rawat , lukasz.spintzyk@displaylink.com List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCBBcHIgMDUsIDIwMTggYXQgMTE6MDA6MTVBTSArMDIwMCwgVGhvbWFzIEhlbGxzdHJv bSB3cm90ZToKPiBPbiAwNC8wNS8yMDE4IDA5OjM1IEFNLCBEYW5pZWwgVmV0dGVyIHdyb3RlOgo+ ID4gT24gV2VkLCBBcHIgMDQsIDIwMTggYXQgMDQ6NDk6MDZQTSAtMDcwMCwgRGVlcGFrIFJhd2F0 IHdyb3RlOgo+ID4gPiBGcm9tOiBMdWthc3ogU3BpbnR6eWsgPGx1a2Fzei5zcGludHp5a0BkaXNw bGF5bGluay5jb20+Cj4gPiA+IAo+ID4gPiBPcHRpb25hbCBwbGFuZSBwcm9wZXJ0eSB0byBtYXJr IGRhbWFnZWQgcmVnaW9ucyBvbiB0aGUgcGxhbmUgaW4KPiA+ID4gZnJhbWVidWZmZXIgY29vcmRp bmF0ZXMgb2YgdGhlIGZyYW1lYnVmZmVyIGF0dGFjaGVkIHRvIHRoZSBwbGFuZS4KPiA+ID4gCj4g PiA+IFRoZSBsYXlvdXQgb2YgYmxvYiBkYXRhIGlzIHNpbXBseSBhbiBhcnJheSBvZiBkcm1fbW9k ZV9yZWN0IHdpdGggbWF4aW11bQo+ID4gPiBhcnJheSBzaXplIGxpbWl0ZWQgYnkgRFJNX01PREVf RkJfRElSVFlfTUFYX0NMSVBTLiBVbmxpa2UgcGxhbmUgc3JjCj4gPiA+IGNvb3JkaW5hdGVzLCBk YW1hZ2UgY2xpcHMgYXJlIG5vdCBpbiAxNi4xNiBmaXhlZCBwb2ludC4KPiA+ID4gCj4gPiA+IERh bWFnZSBjbGlwcyBhcmUgYSBoaW50IHRvIGtlcm5lbCBhcyB3aGljaCBhcmVhIG9mIGZyYW1lYnVm ZmVyIGhhcwo+ID4gPiBjaGFuZ2VkIHNpbmNlIGxhc3QgcGFnZS1mbGlwLiBUaGlzIHNob3VsZCBi ZSBoZWxwZnVsIGZvciBzb21lIGRyaXZlcnMKPiA+ID4gZXNwZWNpYWxseSBmb3IgdmlydHVhbCBk ZXZpY2VzIHdoZXJlIGVhY2ggZnJhbWVidWZmZXIgY2hhbmdlIG5lZWRzIHRvCj4gPiA+IGJlIHRy YW5zbWl0dGVkIG92ZXIgbmV0d29yaywgdXNiLCBldGMuCj4gPiA+IAo+ID4gPiBEcml2ZXIgd2hp Y2ggYXJlIGludGVyZXN0ZWQgaW4gZW5hYmxpbmcgREFNQUdFX0NMSVBTIHByb3BlcnR5IGZvciBh Cj4gPiA+IHBsYW5lIHNob3VsZCBlbmFibGUgdGhpcyBwcm9wZXJ0eSB1c2luZyBkcm1fcGxhbmVf ZW5hYmxlX2RhbWFnZV9jbGlwcy4KPiA+ID4gCj4gPiA+IFNpZ25lZC1vZmYtYnk6IEx1a2FzeiBT cGludHp5ayA8bHVrYXN6LnNwaW50enlrQGRpc3BsYXlsaW5rLmNvbT4KPiA+ID4gU2lnbmVkLW9m Zi1ieTogRGVlcGFrIFJhd2F0IDxkcmF3YXRAdm13YXJlLmNvbT4KPiA+IFRoZSBwcm9wZXJ0eSB1 YXBpIHNlY3Rpb24gaXMgbWlzc2luZywgc2VlOgo+ID4gCj4gPiBodHRwczovL3VybGRlZmVuc2Uu cHJvb2Zwb2ludC5jb20vdjIvdXJsP3U9aHR0cHMtM0FfX2RyaS5mcmVlZGVza3RvcC5vcmdfZG9j c19kcm1fZ3B1X2RybS0yRGttcy5odG1sLTIzcGxhbmUtMkRjb21wb3NpdGlvbi0yRHByb3BlcnRp ZXMmZD1Ed0lCQWcmYz11aWxhSzkwRDRUT1ZvSDU4Sk5YUmdRJnI9d25TbGdPQ3FmcE5TNGQwMnZQ NjhfRTlxMkJOTUN3ZkQyT1pfNmRDRlZRUSZtPUozMVlOVjF1ejNJVlJhb3JNLWVvNDhtc2k5X19z UXVycVJacmlnMlVFMXMmcz12enN1cXVGMWFnYk93NTRIU0NfMThLazJrOWo4M204UnVzbURDdFBB RldRJmU9Cj4gPiAKPiA+IFBsYW5lIGNvbXBvc2l0aW9uIGZlZWxzIGxpa2UgdGhlIGJlc3QgcGxh Y2UgdG8gcHV0IHRoaXMuIFBsZWFzZSB1c2UgdGhhdAo+ID4gc2VjdGlvbiB0byB0aWUgYWxsIHRo ZSB2YXJpb3VzIGJpdHMgdG9nZXRoZXIsIGluY2x1ZGluZyB0aGUgaGVscGVycyB5b3UncmUKPiA+ IGFkZGluZyBpbiB0aGUgZm9sbG93aW5nIHBhdGNoZXMgZm9yIGRyaXZlcnMgdG8gdXNlLgo+ID4g Cj4gPiBCdW5jaCBvZiBuaXRwaWNrcyBiZWxvdywgYnV0IG92ZXJhbGwgSSdtIGFncmVlaW5nIG5v dyB3aXRoIGp1c3QgZ29pbmcgd2l0aAo+ID4gZmIgY29vcmRpbmF0ZSBkYW1hZ2UgcmVjdHMuCj4g PiAKPiA+IExpa2UgeW91IHNheSwgdGhlIHRoaW5nIG5lZWRlZCBoZXJlIG5vdyBpcyB1c2Vyc3Bh Y2UgKyBkcml2ZXIgYWN0dWFsbHkKPiA+IGltcGxlbWVudGluZyB0aGlzLiBJJ2QgYWxzbyBzYXkg dGhlIGNvbXBhdCBoZWxwZXIgdG8gbWFwIHRoZSBsZWdhY3kKPiA+IGZiLT5kaXJ0eSB0byB0aGlz IG5ldyBhdG9taWMgd2F5IG9mIGRvaW5nIHRoaW5ncyBzaG91bGQgYmUgaW5jbHVkZWQgaGVyZQo+ ID4gKGdpdmVzIHVzIGEgbG90IG1vcmUgdGVzdGluZyBmb3IgdGhlc2UgbmV3IHBhdGhzKS4KPiA+ IAo+ID4gSWNpbmcgb24gdGhlIGNha2Ugd291bGQgYmUgYW4gaWd0IHRvIG1ha2Ugc3VyZSBrZXJu ZWwgcmVqZWN0cyBpbnZhbGlkIGNsaXAKPiA+IHJlY3RzIGNvcnJlY3RseS4KPiA+IAo+ID4gPiAt LS0KPiA+ID4gICBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jICAgICAgICB8IDQyICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiA+ID4gICBkcml2ZXJzL2dwdS9kcm0v ZHJtX2F0b21pY19oZWxwZXIuYyB8ICA0ICsrKysKPiA+ID4gICBkcml2ZXJzL2dwdS9kcm0vZHJt X21vZGVfY29uZmlnLmMgICB8ICA1ICsrKysrCj4gPiA+ICAgZHJpdmVycy9ncHUvZHJtL2RybV9w bGFuZS5jICAgICAgICAgfCAxMiArKysrKysrKysrKwo+ID4gPiAgIGluY2x1ZGUvZHJtL2RybV9t b2RlX2NvbmZpZy5oICAgICAgIHwgMTUgKysrKysrKysrKysrKwo+ID4gPiAgIGluY2x1ZGUvZHJt L2RybV9wbGFuZS5oICAgICAgICAgICAgIHwgMTYgKysrKysrKysrKysrKysKPiA+ID4gICBpbmNs dWRlL3VhcGkvZHJtL2RybV9tb2RlLmggICAgICAgICB8IDE1ICsrKysrKysrKysrKysKPiA+ID4g ICA3IGZpbGVzIGNoYW5nZWQsIDEwOSBpbnNlcnRpb25zKCspCj4gPiA+IAo+ID4gPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1f YXRvbWljLmMKPiA+ID4gaW5kZXggN2QyNWM0Mi4uOTIyNmQyNCAxMDA2NDQKPiA+ID4gLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+ID4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX2F0b21pYy5jCj4gPiA+IEBAIC02NjksNiArNjY5LDQwIEBAIHN0YXRpYyB2b2lkIGRybV9h dG9taWNfY3J0Y19wcmludF9zdGF0ZShzdHJ1Y3QgZHJtX3ByaW50ZXIgKnAsCj4gPiA+ICAgfQo+ ID4gPiAgIC8qKgo+ID4gPiArICogZHJtX2F0b21pY19zZXRfZGFtYWdlX2Zvcl9wbGFuZSAtIHNl dHMgdGhlIGRhbWFnZSBjbGlwcyBwcm9wZXJ0eSB0byBwbGFuZQo+ID4gPiArICogQHN0YXRlOiBw bGFuZSBzdGF0ZQo+ID4gPiArICogQGJsb2I6IGRhbWFnZSBjbGlwcyBpbiBmcmFtZWJ1ZmZlciBj b29yZGluYXRlcwo+ID4gPiArICoKPiA+ID4gKyAqIFJldHVybnM6Cj4gPiA+ICsgKgo+ID4gPiAr ICogWmVybyBvbiBzdWNjZXNzLCBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gPiA+ICsgKi8KPiA+ ID4gK3N0YXRpYyBpbnQgZHJtX2F0b21pY19zZXRfZGFtYWdlX2Zvcl9wbGFuZShzdHJ1Y3QgZHJt X3BsYW5lX3N0YXRlICpzdGF0ZSwKPiA+ID4gKwkJCQkJICAgc3RydWN0IGRybV9wcm9wZXJ0eV9i bG9iICpibG9iKQo+ID4gPiArewo+ID4gPiArCWlmIChibG9iID09IHN0YXRlLT5kYW1hZ2VfY2xp cHMpCj4gPiA+ICsJCXJldHVybiAwOwo+ID4gPiArCj4gPiA+ICsJZHJtX3Byb3BlcnR5X2Jsb2Jf cHV0KHN0YXRlLT5kYW1hZ2VfY2xpcHMpOwo+ID4gPiArCXN0YXRlLT5kYW1hZ2VfY2xpcHMgPSBO VUxMOwo+ID4gPiArCj4gPiA+ICsJaWYgKGJsb2IpIHsKPiA+ID4gKwkJdWludDMyX3QgY291bnQg PSBibG9iLT5sZW5ndGgvc2l6ZW9mKHN0cnVjdCBkcm1fcmVjdCk7Cj4gPiA+ICsKPiA+ID4gKwkJ aWYgKGNvdW50ID4gRFJNX01PREVfRkJfRElSVFlfTUFYX0NMSVBTKQo+ID4gPiArCQkJcmV0dXJu IC1FSU5WQUw7Cj4gPiA+ICsKPiA+ID4gKwkJc3RhdGUtPmRhbWFnZV9jbGlwcyA9IGRybV9wcm9w ZXJ0eV9ibG9iX2dldChibG9iKTsKPiA+ID4gKwkJc3RhdGUtPm51bV9jbGlwcyA9IGNvdW50Owo+ ID4gPiArCX0gZWxzZSB7Cj4gPiA+ICsJCXN0YXRlLT5kYW1hZ2VfY2xpcHMgPSBOVUxMOwo+ID4g PiArCQlzdGF0ZS0+bnVtX2NsaXBzID0gMDsKPiA+ID4gKwl9Cj4gPiA+ICsKPiA+ID4gKwlyZXR1 cm4gMDsKPiA+ID4gK30KPiA+ID4gKwo+ID4gPiArLyoqCj4gPiA+ICAgICogZHJtX2F0b21pY19n ZXRfcGxhbmVfc3RhdGUgLSBnZXQgcGxhbmUgc3RhdGUKPiA+ID4gICAgKiBAc3RhdGU6IGdsb2Jh bCBhdG9taWMgc3RhdGUgb2JqZWN0Cj4gPiA+ICAgICogQHBsYW5lOiBwbGFuZSB0byBnZXQgc3Rh dGUgb2JqZWN0IGZvcgo+ID4gPiBAQCAtNzkzLDYgKzgyNywxMiBAQCBzdGF0aWMgaW50IGRybV9h dG9taWNfcGxhbmVfc2V0X3Byb3BlcnR5KHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ID4gPiAg IAkJc3RhdGUtPmNvbG9yX2VuY29kaW5nID0gdmFsOwo+ID4gPiAgIAl9IGVsc2UgaWYgKHByb3Bl cnR5ID09IHBsYW5lLT5jb2xvcl9yYW5nZV9wcm9wZXJ0eSkgewo+ID4gPiAgIAkJc3RhdGUtPmNv bG9yX3JhbmdlID0gdmFsOwo+ID4gPiArCX0gZWxzZSBpZiAocHJvcGVydHkgPT0gY29uZmlnLT5w cm9wX2RhbWFnZV9jbGlwcykgewo+ID4gPiArCQlzdHJ1Y3QgZHJtX3Byb3BlcnR5X2Jsb2IgKmJs b2IgPQo+ID4gPiArCQkJZHJtX3Byb3BlcnR5X2xvb2t1cF9ibG9iKGRldiwgdmFsKTsKPiA+ID4g KwkJaW50IHJldCA9IGRybV9hdG9taWNfc2V0X2RhbWFnZV9mb3JfcGxhbmUoc3RhdGUsIGJsb2Ip Owo+ID4gVGhlcmUncyBhbHJlYWR5IGEgaGVscGVyIHdpdGggc2l6ZS1jaGVja2luZyBidWlsdC1p biwgc2VlCj4gPiBkcm1fYXRvbWljX3JlcGxhY2VfcHJvcGVydHlfYmxvYl9mcm9tX2lkKCkuIFdy dCBjb21wdXRpbmcgbnVtX2NsaXBzIEknZAo+ID4ganVzdCBwcm92aWRlIGEgbGl0dGxlIGlubGlu ZSBoZWxwZXIgdGhhdCBkb2VzIHRoZQo+ID4gYmxvYi0+bGVuZ3RoL3NpemVvZihkcm1fcmVjdCkg Y29udmVyc2lvbiAoaXQncyBqdXN0IGEgc2hpZnQsIHNvIGZhc3QpLgo+ID4gCj4gPiA+ICsJCWRy bV9wcm9wZXJ0eV9ibG9iX3B1dChibG9iKTsKPiA+ID4gKwkJcmV0dXJuIHJldDsKPiA+ID4gICAJ fSBlbHNlIGlmIChwbGFuZS0+ZnVuY3MtPmF0b21pY19zZXRfcHJvcGVydHkpIHsKPiA+ID4gICAJ CXJldHVybiBwbGFuZS0+ZnVuY3MtPmF0b21pY19zZXRfcHJvcGVydHkocGxhbmUsIHN0YXRlLAo+ ID4gPiAgIAkJCQlwcm9wZXJ0eSwgdmFsKTsKPiA+ID4gQEAgLTg1Niw2ICs4OTYsOCBAQCBkcm1f YXRvbWljX3BsYW5lX2dldF9wcm9wZXJ0eShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiA+ID4g ICAJCSp2YWwgPSBzdGF0ZS0+Y29sb3JfZW5jb2Rpbmc7Cj4gPiA+ICAgCX0gZWxzZSBpZiAocHJv cGVydHkgPT0gcGxhbmUtPmNvbG9yX3JhbmdlX3Byb3BlcnR5KSB7Cj4gPiA+ICAgCQkqdmFsID0g c3RhdGUtPmNvbG9yX3JhbmdlOwo+ID4gPiArCX0gZWxzZSBpZiAocHJvcGVydHkgPT0gY29uZmln LT5wcm9wX2RhbWFnZV9jbGlwcykgewo+ID4gPiArCQkqdmFsID0gKHN0YXRlLT5kYW1hZ2VfY2xp cHMpID8gc3RhdGUtPmRhbWFnZV9jbGlwcy0+YmFzZS5pZCA6IDA7Cj4gPiA+ICAgCX0gZWxzZSBp ZiAocGxhbmUtPmZ1bmNzLT5hdG9taWNfZ2V0X3Byb3BlcnR5KSB7Cj4gPiA+ICAgCQlyZXR1cm4g cGxhbmUtPmZ1bmNzLT5hdG9taWNfZ2V0X3Byb3BlcnR5KHBsYW5lLCBzdGF0ZSwgcHJvcGVydHks IHZhbCk7Cj4gPiA+ICAgCX0gZWxzZSB7Cj4gPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vZHJtX2F0b21pY19oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX2hlbHBl ci5jCj4gPiA+IGluZGV4IGMzNTY1NDUuLjU1YjQ0ZTMgMTAwNjQ0Cj4gPiA+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9kcm1fYXRvbWljX2hlbHBlci5jCj4gPiA+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9kcm1fYXRvbWljX2hlbHBlci5jCj4gPiA+IEBAIC0zNTA2LDYgKzM1MDYsOCBAQCB2b2lkIF9f ZHJtX2F0b21pY19oZWxwZXJfcGxhbmVfZHVwbGljYXRlX3N0YXRlKHN0cnVjdCBkcm1fcGxhbmUg KnBsYW5lLAo+ID4gPiAgIAlzdGF0ZS0+ZmVuY2UgPSBOVUxMOwo+ID4gPiAgIAlzdGF0ZS0+Y29t bWl0ID0gTlVMTDsKPiA+ID4gKwlzdGF0ZS0+ZGFtYWdlX2NsaXBzID0gTlVMTDsKPiA+ID4gKwlz dGF0ZS0+bnVtX2NsaXBzID0gMDsKPiA+ID4gICB9Cj4gPiA+ICAgRVhQT1JUX1NZTUJPTChfX2Ry bV9hdG9taWNfaGVscGVyX3BsYW5lX2R1cGxpY2F0ZV9zdGF0ZSk7Cj4gPiA+IEBAIC0zNTUwLDYg KzM1NTIsOCBAQCB2b2lkIF9fZHJtX2F0b21pY19oZWxwZXJfcGxhbmVfZGVzdHJveV9zdGF0ZShz dHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpzdGF0ZSkKPiA+ID4gICAJaWYgKHN0YXRlLT5jb21taXQp Cj4gPiA+ICAgCQlkcm1fY3J0Y19jb21taXRfcHV0KHN0YXRlLT5jb21taXQpOwo+ID4gPiArCj4g PiA+ICsJZHJtX3Byb3BlcnR5X2Jsb2JfcHV0KHN0YXRlLT5kYW1hZ2VfY2xpcHMpOwo+ID4gPiAg IH0KPiA+ID4gICBFWFBPUlRfU1lNQk9MKF9fZHJtX2F0b21pY19oZWxwZXJfcGxhbmVfZGVzdHJv eV9zdGF0ZSk7Cj4gPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX21vZGVfY29u ZmlnLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX21vZGVfY29uZmlnLmMKPiA+ID4gaW5kZXggZTVj NjUzMy4uZTkzYjEyNyAxMDA2NDQKPiA+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9tb2Rl X2NvbmZpZy5jCj4gPiA+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fbW9kZV9jb25maWcuYwo+ ID4gPiBAQCAtMjkzLDYgKzI5MywxMSBAQCBzdGF0aWMgaW50IGRybV9tb2RlX2NyZWF0ZV9zdGFu ZGFyZF9wcm9wZXJ0aWVzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gPiA+ICAgCQlyZXR1cm4g LUVOT01FTTsKPiA+ID4gICAJZGV2LT5tb2RlX2NvbmZpZy5wcm9wX2NydGNfaWQgPSBwcm9wOwo+ ID4gPiArCXByb3AgPSBkcm1fcHJvcGVydHlfY3JlYXRlKGRldiwgRFJNX01PREVfUFJPUF9CTE9C LCAiREFNQUdFX0NMSVBTIiwgMCk7Cj4gPiBCaXQgYSBiaWtlc2hlZCwgYnV0IHNpbmNlIHRoZSBj b29yZGluYXRlcyBhcmUgaW4gZmIgcGl4ZWxzLCBub3QgcGxhbmUKPiA+IHBpeGVscywgSSdkIGNh bGwgdGhpcyAiRkJfREFNQUdFX0NMSVBTIi4KPiA+IAo+ID4gPiArCWlmICghcHJvcCkKPiA+ID4g KwkJcmV0dXJuIC1FTk9NRU07Cj4gPiA+ICsJZGV2LT5tb2RlX2NvbmZpZy5wcm9wX2RhbWFnZV9j bGlwcyA9IHByb3A7Cj4gPiA+ICsKPiA+ID4gICAJcHJvcCA9IGRybV9wcm9wZXJ0eV9jcmVhdGVf Ym9vbChkZXYsIERSTV9NT0RFX1BST1BfQVRPTUlDLAo+ID4gPiAgIAkJCSJBQ1RJVkUiKTsKPiA+ ID4gICAJaWYgKCFwcm9wKQo+ID4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9w bGFuZS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9wbGFuZS5jCj4gPiA+IGluZGV4IDZkMmE2ZTQu LjA3MTIyMWIgMTAwNjQ0Cj4gPiA+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcGxhbmUuYwo+ ID4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3BsYW5lLmMKPiA+ID4gQEAgLTExMDEsMyAr MTEwMSwxNSBAQCBpbnQgZHJtX21vZGVfcGFnZV9mbGlwX2lvY3RsKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYsCj4gPiA+ICAgCXJldHVybiByZXQ7Cj4gPiA+ICAgfQo+ID4gPiArCj4gPiA+ICsvKioK PiA+ID4gKyAqIGRybV9wbGFuZV9lbmFibGVfZGFtYWdlX2NsaXBzIC0gZW5hYmxlIGRhbWFnZSBj bGlwcyBwcm9wZXJ0eQo+ID4gPiArICogQHBsYW5lOiBwbGFuZSBvbiB3aGljaCB0aGlzIHByb3Bl cnR5IHRvIGVuYWJsZS4KPiA+ID4gKyAqLwo+ID4gPiArdm9pZCBkcm1fcGxhbmVfZW5hYmxlX2Rh bWFnZV9jbGlwcyhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSkKPiA+ID4gK3sKPiA+ID4gKwlzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2ID0gcGxhbmUtPmRldjsKPiA+ID4gKwlzdHJ1Y3QgZHJtX21vZGVf Y29uZmlnICpjb25maWcgPSAmZGV2LT5tb2RlX2NvbmZpZzsKPiA+ID4gKwo+ID4gPiArCWRybV9v YmplY3RfYXR0YWNoX3Byb3BlcnR5KCZwbGFuZS0+YmFzZSwgY29uZmlnLT5wcm9wX2RhbWFnZV9j bGlwcywgMCk7Cj4gPiA+ICt9Cj4gPiA+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fbW9k ZV9jb25maWcuaCBiL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCj4gPiA+IGluZGV4IDc1 NjlmMjIuLmQ4NzY3ZGEgMTAwNjQ0Cj4gPiA+IC0tLSBhL2luY2x1ZGUvZHJtL2RybV9tb2RlX2Nv bmZpZy5oCj4gPiA+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCj4gPiA+IEBA IC02MjgsNiArNjI4LDIxIEBAIHN0cnVjdCBkcm1fbW9kZV9jb25maWcgewo+ID4gPiAgIAkgKi8K PiA+ID4gICAJc3RydWN0IGRybV9wcm9wZXJ0eSAqcHJvcF9jcnRjX2lkOwo+ID4gPiAgIAkvKioK PiA+ID4gKwkgKiBAcHJvcF9kYW1hZ2VfY2xpcHM6IE9wdGlvbmFsIHBsYW5lIHByb3BlcnR5IHRv IG1hcmsgZGFtYWdlZCByZWdpb25zCj4gPiA+ICsJICogb24gdGhlIHBsYW5lIGluIGZyYW1lYnVm ZmVyIGNvb3JkaW5hdGVzIG9mIHRoZSBmcmFtZWJ1ZmZlciBhdHRhY2hlZAo+ID4gPiArCSAqIHRv IHRoZSBwbGFuZS4KPiA+IFdoeSBzaG91bGQgd2UgbWFrZSB0aGlzIG9wdGlvbmFsPyBMb29rcyBs aWtlIGp1c3QgYW5vdGhlciB0aGluZyBkcml2ZXJzCj4gPiBtaWdodCBzY3JldyB1cCwgc2luY2Ug d2UgaGF2ZSBtdWx0aXBsZSBjYWxsYmFja3MgYW5kIHRoaW5ncyB0byBzZXQgdXAgZm9yCj4gPiBw cm9wZXIgZGlydHkgdHJhY2tpbmcuCj4gPiAKPiA+IE9uZSBvcHRpb24gSSdtIHNlZWluZyBpcyB0 aGF0IGlmIHRoaXMgaXMgc2V0LCBhbmQgaXQncyBhbiBhdG9taWMgZHJpdmVyLAo+ID4gdGhlbiB3 ZSBqdXN0IGRpcmVjdGx5IGNhbGwgaW50byB0aGUgZGVmYXVsdCBhdG9taWMgZmItPmRpcnR5Cj4g PiBpbXBsZW1lbnRhdGlvbi4gVGhhdCB3YXkgdGhlcmUncyBvbmx5IDEgdGhpbmcgZHJpdmVycyBu ZWVkIHRvIGRvIHRvIHNldCB1cAo+ID4gZGlydHkgcmVjdCB0cmFja2luZywgYW5kIHRoZXknbGwg Z2V0IGFsbCBvZiBpdC4KPiA+IAo+ID4gPiArCSAqCj4gPiA+ICsJICogVGhlIGxheW91dCBvZiBi bG9iIGRhdGEgaXMgc2ltcGx5IGFuIGFycmF5IG9mIGRybV9tb2RlX3JlY3Qgd2l0aAo+ID4gPiAr CSAqIG1heGltdW0gYXJyYXkgc2l6ZSBsaW1pdGVkIGJ5IERSTV9NT0RFX0ZCX0RJUlRZX01BWF9D TElQUy4gVW5saWtlCj4gPiA+ICsJICogcGxhbmUgc3JjIGNvb3JkaW5hdGVzLCBkYW1hZ2UgY2xp cHMgYXJlIG5vdCBpbiAxNi4xNiBmaXhlZCBwb2ludC4KPiA+IEkgaG9uZXN0bHkgaGF2ZSBubyBp ZGVhIHdoZXJlIHRoaXMgbGltaXQgaXMgZnJvbS4gV29ydGgga2VlcGluZz8gSSBjYW4KPiA+IGVh c2lseSBpbWFnaW5lIHRoYXQgdXNlcnNwYWNlIGNvdWxkIHRyaXAgb3ZlciB0aGlzIC0gaXQncyBm YWlybHkgaGlnaCwgYnV0Cj4gPiBub3QgdW5saW1pdGVkLgo+ID4gCj4gPiA+ICsJICoKPiA+ID4g KwkgKiBEYW1hZ2UgY2xpcHMgYXJlIGEgaGludCB0byBrZXJuZWwgYXMgd2hpY2ggYXJlYSBvZiBm cmFtZWJ1ZmZlciBoYXMKPiA+ID4gKwkgKiBjaGFuZ2VkIHNpbmNlIGxhc3QgcGFnZS1mbGlwLiBU aGlzIHNob3VsZCBiZSBoZWxwZnVsCj4gPiA+ICsJICogZm9yIHNvbWUgZHJpdmVycyBlc3BlY2lh bGx5IGZvciB2aXJ0dWFsIGRldmljZXMgd2hlcmUgZWFjaAo+ID4gPiArCSAqIGZyYW1lYnVmZmVy IGNoYW5nZSBuZWVkcyB0byBiZSB0cmFuc21pdHRlZCBvdmVyIG5ldHdvcmssIHVzYiwgZXRjLgo+ ID4gSSdkIGFsc28gY2xhcmlmeSB0aGF0IHVzZXJzcGFjZSBzdGlsbCBtdXN0IHJlbmRlciB0aGUg ZW50aXJlIHNjcmVlbiwgaS5lLgo+ID4gbWFrZSBpdCBtb3JlIGNsZWFyIHRoYXQgaXQncyByZWFs bHkganVzdCBhIGhpbnQgYW5kIG5vdCBtYW5kYXRvcnkgdG8gb25seQo+ID4gc2NhbiBvdXQgdGhl IGRhbWFnZWQgcGFydHMuCj4gPiAKPiA+ID4gKwkgKi8KPiA+ID4gKwlzdHJ1Y3QgZHJtX3Byb3Bl cnR5ICpwcm9wX2RhbWFnZV9jbGlwczsKPiA+ID4gKwkvKioKPiA+ID4gICAJICogQHByb3BfYWN0 aXZlOiBEZWZhdWx0IGF0b21pYyBDUlRDIHByb3BlcnR5IHRvIGNvbnRyb2wgdGhlIGFjdGl2ZQo+ ID4gPiAgIAkgKiBzdGF0ZSwgd2hpY2ggaXMgdGhlIHNpbXBsaWZpZWQgaW1wbGVtZW50YXRpb24g Zm9yIERQTVMgaW4gYXRvbWljCj4gPiA+ICAgCSAqIGRyaXZlcnMuCj4gPiA+IGRpZmYgLS1naXQg YS9pbmNsdWRlL2RybS9kcm1fcGxhbmUuaCBiL2luY2x1ZGUvZHJtL2RybV9wbGFuZS5oCj4gPiA+ IGluZGV4IGY3YmY0YTQuLjlmMjQ1NDggMTAwNjQ0Cj4gPiA+IC0tLSBhL2luY2x1ZGUvZHJtL2Ry bV9wbGFuZS5oCj4gPiA+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9wbGFuZS5oCj4gPiA+IEBAIC0x NDYsNiArMTQ2LDIxIEBAIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgewo+ID4gPiAgIAkgKi8KPiA+ ID4gICAJc3RydWN0IGRybV9jcnRjX2NvbW1pdCAqY29tbWl0Owo+ID4gPiArCS8qCj4gPiA+ICsJ ICogQGRhbWFnZV9jbGlwcwo+ID4gPiArCSAqCj4gPiA+ICsJICogYmxvYiBwcm9wZXJ0eSB3aXRo IGRhbWFnZSBhcyBhcnJheSBvZiBkcm1fcmVjdCBpbiBmcmFtZWJ1ZmZlcgo+ID4gJmRybV9yZWN0 IGdpdmVzIHlvdSBhIG5pY2UgaHlwZXJsaW5rIGluIHRoZSBnZW5lcmF0ZWQgZG9jcy4KPiA+IAo+ ID4gPiArCSAqIGNvb2RpbmF0ZXMuCj4gPiA+ICsJICovCj4gPiA+ICsJc3RydWN0IGRybV9wcm9w ZXJ0eV9ibG9iICpkYW1hZ2VfY2xpcHM7Cj4gPiA+ICsKPiA+ID4gKwkvKgo+ID4gPiArCSAqIEBu dW1fY2xpcHMKPiA+ID4gKwkgKgo+ID4gPiArCSAqIE51bWJlciBvZiBkcm1fcmVjdCBpbiBAZGFt YWdlX2NsaXBzLgo+ID4gPiArCSAqLwo+ID4gPiArCXVpbnQzMl90IG51bV9jbGlwczsKPiA+ID4g Kwo+ID4gPiAgIAlzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGU7Cj4gPiA+ICAgfTsKPiA+ ID4gQEAgLTYxMSw2ICs2MjYsNyBAQCBpbnQgZHJtX3BsYW5lX2luaXQoc3RydWN0IGRybV9kZXZp Y2UgKmRldiwKPiA+ID4gICAJCSAgIGNvbnN0IHVpbnQzMl90ICpmb3JtYXRzLCB1bnNpZ25lZCBp bnQgZm9ybWF0X2NvdW50LAo+ID4gPiAgIAkJICAgYm9vbCBpc19wcmltYXJ5KTsKPiA+ID4gICB2 b2lkIGRybV9wbGFuZV9jbGVhbnVwKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lKTsKPiA+ID4gK3Zv aWQgZHJtX3BsYW5lX2VuYWJsZV9kYW1hZ2VfY2xpcHMoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUp Owo+ID4gPiAgIC8qKgo+ID4gPiAgICAqIGRybV9wbGFuZV9pbmRleCAtIGZpbmQgdGhlIGluZGV4 IG9mIGEgcmVnaXN0ZXJlZCBwbGFuZQo+ID4gPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2Ry bS9kcm1fbW9kZS5oIGIvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCj4gPiA+IGluZGV4IDUw YmNmNDIuLjBhZDBkNWIgMTAwNjQ0Cj4gPiA+IC0tLSBhL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21v ZGUuaAo+ID4gPiArKysgYi9pbmNsdWRlL3VhcGkvZHJtL2RybV9tb2RlLmgKPiA+ID4gQEAgLTg3 Myw2ICs4NzMsMjEgQEAgc3RydWN0IGRybV9tb2RlX3Jldm9rZV9sZWFzZSB7Cj4gPiA+ICAgCV9f dTMyIGxlc3NlZV9pZDsKPiA+ID4gICB9Owo+ID4gPiArLyoqCj4gPiA+ICsgKiBzdHJ1Y3QgZHJt X21vZGVfcmVjdCAtIHR3byBkaW1lbnNpb25hbCByZWN0YW5nbGUgZHJtX3JlY3QgZXhwb3J0ZWQg dG8KPiA+ID4gKyAqIHVzZXItc3BhY2UuCj4gPiA+ICsgKiBAeDE6IGhvcml6b250YWwgc3RhcnRp bmcgY29vcmRpbmF0ZSAoaW5jbHVzaXZlKQo+ID4gPiArICogQHkxOiB2ZXJ0aWNhbCBzdGFydGlu ZyBjb29yZGluYXRlIChpbmNsdXNpdmUpCj4gPiA+ICsgKiBAeDI6IGhvcml6b250YWwgZW5kaW5n IGNvb3JkaW5hdGUgKGV4Y2x1c2l2ZSkKPiA+ID4gKyAqIEB5MjogdmVydGljYWwgZW5kaW5nIGNv b3JkaW5hdGUgKGV4Y2x1c2l2ZSkKPiA+ID4gKyAqLwo+ID4gPiArc3RydWN0IGRybV9tb2RlX3Jl Y3Qgewo+ID4gPiArCV9fczMyIHgxOwo+ID4gPiArCV9fczMyIHkxOwo+ID4gPiArCV9fczMyIHgy Owo+ID4gPiArCV9fczMyIHkyOwo+ID4gV2h5IHNpZ25lZD8gTmVnYXRpdmUgZGFtYWdlIHJlY3Rz IG9uIGFuIGZiIGRvbid0IG1ha2Ugc2Vuc2UgdG8gbWUuIEFsc28sCj4gPiBwbGVhc2Ugc3BlY2lm eSB3aGF0IHRoaXMgaXMgZXhhY3RseSAodG8gYXZvaWQgY29uZnVzaW9uIHdpdGggdGhlIDE2LjE2 Cj4gPiBmaXhlZCBwb2ludCBzcmMgcmVjdHMpLCBhbmQgbWF5YmUgbWVudGlvbiBpbiB0aGUgY29t bWl0IG1lc3NhZ2Ugd2h5IHdlJ3JlCj4gPiBub3QgdXNpbmcgZHJtX2NsaXBfcmVjdCAoZ29pbmcg dG8gcHJvcGVyIHVhcGkgdHlwZXMgYW5kIDMyYml0IG1ha2VzIHNlbnNlCj4gPiB0byBtZSkuCj4g Cj4gSU1PLCB3aGlsZSB3ZSBkb24ndCBleHBlY3QgbmVnYXRpdmUgZGFtYWdlIGNvb3JkaW5hdGVz LAo+IHRvIGF2b2lkIHlldCBhbm90aGVyIGRybSB1YXBpIHJlY3QgaW4gdGhlIGZ1dHVyZSB3aGVu IHdlIGFjdHVhbGx5IG5lZWQKPiBuZWdhdGl2ZSBudW1iZXJzIHNpZ25lZCBpcyBhIGdvb2QgY2hv aWNlLi4uCgpNYWtlcyBzZW5zZS4gQW5vdGhlciB0aGluZyBJIHJlYWxpemVkOiBTaW5jZSBzcmMg cmVjdCBhcmUgMTYuMTYgZml4ZWQKcG9pbnQsIGRvIHdlIHJlYWxseSBuZWVkIHMzMj8gZHJtX2Ns aXBfcmVjdCBpcyBhIGJpdCBtZWgsIGJ1dCBpdCBnaXZlcyB1cwpzMTYgYWxyZWFkeS4gVGhhdCB3 b3VsZCBhdm9pZCBoYXZpbmcgdG8gc3ByaW5rbGUgdGhlIGNvZGUgd2l0aCB0b25zIG9mCm92ZXJm bG93IGNoZWNrcyBmb3IgaW5wdXQgdmFsaWRhdGlvbi4KCk9uIHRoZSB0b3BpYyBvZiBpbnB1dCB2 YWxpZGF0aW9uOiBTaG91bGQgdGhlIGtlcm5lbCBjaGVjayBpbiBzaGFyZWQgY29kZQp0aGF0IGFs bCB0aGUgY2xpcCByZWN0cyBhcmUgc2Vuc2libGUsIGkuZS4gd2l0aGluIHRoZSBkaW1lbnNpb25z IG9mIHRoZQpmYj8gUmVseWluZyBvbiBkcml2ZXJzIGZvciB0aGF0IHNlZW1zIGxpa2UgYSBiYWQg aWRlYS4KClRoYXQgY291bGQgYmUgZG9uZSBpbiBjb3JlIGNvZGUgaW4gZHJtX2F0b21pY19wbGFu ZV9jaGVjaygpLgotRGFuaWVsCj4gCj4gL1Rob21hcwo+IAo+IAo+IF9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCj4gZHJpLWRldmVsIG1haWxpbmcgbGlzdAo+ IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiBodHRwczovL2xpc3RzLmZyZWVkZXNr dG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAoKLS0gCkRhbmllbCBWZXR0ZXIKU29m dHdhcmUgRW5naW5lZXIsIEludGVsIENvcnBvcmF0aW9uCmh0dHA6Ly9ibG9nLmZmd2xsLmNoCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBt YWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3Rz LmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=