From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751285AbeDEXHX (ORCPT ); Thu, 5 Apr 2018 19:07:23 -0400 Received: from mail-co1nam03on0079.outbound.protection.outlook.com ([104.47.40.79]:6560 "EHLO NAM03-CO1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1750786AbeDEXHV (ORCPT ); Thu, 5 Apr 2018 19:07:21 -0400 From: Deepak Singh Rawat To: Daniel Vetter CC: "dri-devel@lists.freedesktop.org" , Thomas Hellstrom , Sinclair Yeh , linux-graphics-maintainer , "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 Thread-Topic: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane Thread-Index: AQHTzG/LKmgpUVY09ESOpEZ7duU7PKPxyHKAgAEAxkA= Date: Thu, 5 Apr 2018 23:07:19 +0000 Message-ID: References: <1522885748-67122-1-git-send-email-drawat@vmware.com> <1522885748-67122-2-git-send-email-drawat@vmware.com> <20180405073525.GP3881@phenom.ffwll.local> In-Reply-To: <20180405073525.GP3881@phenom.ffwll.local> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [66.170.99.1] x-ms-publictraffictype: Email x-microsoft-exchange-diagnostics: 1;MWHPR05MB2863;7:appQOUdpcjUxC0Bx+nbrw0t1pwTWDFuKq/amodTX4LvivA/1g3TwhY1pAgPLklU/7O7AqKXJnTgPLtBJZPTtTDU1E1ZRK4iwgPiwiSrb1JD14vlQomsU0iYWXCdjLLaNWoApoKpri9Cr6vQDPyGHoE9XQap7Kfp42P4j/hvOxZnfOJzGLaBwz+HyXLWyFJyYwlHulrNDyhqCi24f4FCw0ROftLgymnySLcWVivAHSDijFx7cQAPsc2Ql9F+gzCts;20:Dmdae6Jo3ogAWdxVuwrzeg/ZYZlSOPfHgVzVE9bTLwEeE9ClZ94Q3gdDb6WbBaT3UQ17Gr4QE1Yo83qGQgHGxe2RlXJGzqHKB9yg4ohwcwqiKxudD+fLLj8EzRWc6E3WgZA/LziM1Q9ki5ScYuXrX39ef47skV8SXOvUqwfkjp8= x-ms-exchange-antispam-srfa-diagnostics: SOS; x-ms-office365-filtering-correlation-id: 9d645880-d2f9-4522-f0f8-08d59b49fb93 x-microsoft-antispam: UriScan:;BCL:0;PCL:0;RULEID:(7020095)(4652020)(5600026)(4604075)(3008032)(4534165)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020);SRVR:MWHPR05MB2863; x-ms-traffictypediagnostic: MWHPR05MB2863: authentication-results: spf=none (sender IP is ) smtp.mailfrom=drawat@vmware.com; x-microsoft-antispam-prvs: x-exchange-antispam-report-test: UriScan:(61668805478150)(10436049006162); x-exchange-antispam-report-cfa-test: BCL:0;PCL:0;RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(3231221)(944501327)(52105095)(10201501046)(93006095)(93001095)(3002001)(6041310)(20161123560045)(20161123562045)(20161123564045)(20161123558120)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(6072148)(201708071742011);SRVR:MWHPR05MB2863;BCL:0;PCL:0;RULEID:;SRVR:MWHPR05MB2863; x-forefront-prvs: 06339BAE63 x-forefront-antispam-report: SFV:NSPM;SFS:(10009020)(376002)(39380400002)(39860400002)(346002)(396003)(366004)(199004)(189003)(33656002)(6116002)(81166006)(2900100001)(81156014)(3846002)(6436002)(7416002)(8936002)(6916009)(5660300001)(8676002)(97736004)(105586002)(7736002)(229853002)(6306002)(3660700001)(74316002)(305945005)(2906002)(966005)(39060400002)(55016002)(53936002)(26005)(575784001)(86362001)(7696005)(76176011)(6246003)(3280700002)(9686003)(68736007)(99286004)(478600001)(106356001)(66066001)(5250100002)(6506007)(102836004)(5890100001)(25786009)(486006)(54906003)(446003)(316002)(59450400001)(4326008)(476003)(186003)(14454004)(11346002);DIR:OUT;SFP:1101;SCL:1;SRVR:MWHPR05MB2863;H:MWHPR05MB3117.namprd05.prod.outlook.com;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;A:1;MX:1; x-microsoft-antispam-message-info: t0z0tCWoTaTejuMlnFa3ptpSyy2RoXHkY4714DCJwmdW4mxZeqT35tupI4kU1iTxzp4KjpfvVowfBaUbUTRtNc1b67AqHqaFpGjA9uOL+OrLJPZcPQAqMVFKkYHPu7z8b0PAau7NzcFXRL/C6bpZaBi0UgG+vv7Ao3U3KzVMGmz3omnmH8PjT9S4aQDz3kFUrkWIq8ygUcQEVMqGE1YR21VOyWN7ykIXfmvsAnN2ma7ht9+EFc+6eynv3oZsNq2uhF4xlfPJ6DJvfwpJs9N6xZHmouYkMZwpTaBz2AnU0RJBZPG/0j8/88uZAs3QbUxUNpgsXibhkvIgflR1HEj9HZg4f2nH2uCfd0SprG81tfG06N6kSXdJBhp8qZjaUEzluV82fauS1rzIMsVOQoqjBF+gd1fwAmETHiHUFUpmjtw= spamdiagnosticoutput: 1:99 spamdiagnosticmetadata: NSPM Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 X-OriginatorOrg: vmware.com X-MS-Exchange-CrossTenant-Network-Message-Id: 9d645880-d2f9-4522-f0f8-08d59b49fb93 X-MS-Exchange-CrossTenant-originalarrivaltime: 05 Apr 2018 23:07:19.5955 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: b39138ca-3cee-4b4a-a4d6-cd83d9dd62f0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR05MB2863 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from quoted-printable to 8bit by mail.home.local id w35N7SBI029244 > > 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=zOOG28inJK0762 > SxAf- > cyZdStnd2NQpRu98lJP2iYGw&m=ELAUsNTjD0ICwUEDFjPW4jsmy2A5AkhS5Q > z_3vlEC9Q&s=nH-HNXPczoJQMj1iwHiGfrhXz4-00b0M8-3kirjm-EY&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. Thanks Daniel for the review. I think not all compositor will be interested in sending damage, that was the reason to make this optional. Also when damage is not set that means user-space need full update just like eglSwapBuffersWithDamageKHR. I will add better documentation. > > 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. DRM_MODE_FB_DIRTY_MAX_CLIPS was used to just have an upper limit and its already exposed to user-space. IMHO there has to be an upper limit to avoid unnecessary overflow ? > > > + * > > + * 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. Yes will work on better documentation. > > > + */ > > + 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). > > Cheers, Daniel > > +}; > > + > > #if defined(__cplusplus) > > } > > #endif > > -- > > 2.7.4 > > > > -- > Daniel Vetter > Software Engineer, Intel Corporation > https://urldefense.proofpoint.com/v2/url?u=http- > 3A__blog.ffwll.ch&d=DwIBAg&c=uilaK90D4TOVoH58JNXRgQ&r=zOOG28inJK > 0762SxAf- > cyZdStnd2NQpRu98lJP2iYGw&m=ELAUsNTjD0ICwUEDFjPW4jsmy2A5AkhS5Q > z_3vlEC9Q&s=kLx5XCTMRYRoecNhwwwN2XItT4Rt0ib12-UP5VB4XLI&e= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Deepak Singh Rawat Subject: RE: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane Date: Thu, 5 Apr 2018 23:07:19 +0000 Message-ID: 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 NAM03-CO1-obe.outbound.protection.outlook.com (mail-co1nam03on0044.outbound.protection.outlook.com [104.47.40.44]) by gabe.freedesktop.org (Postfix) with ESMTPS id BECE36E0C4 for ; Thu, 5 Apr 2018 23:07:21 +0000 (UTC) In-Reply-To: <20180405073525.GP3881@phenom.ffwll.local> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Daniel Vetter Cc: Thomas Hellstrom , "airlied@linux.ie" , "linux-kernel@vger.kernel.org" , "dri-devel@lists.freedesktop.org" , linux-graphics-maintainer , "lukasz.spintzyk@displaylink.com" List-Id: dri-devel@lists.freedesktop.org PiAKPiBPbiBXZWQsIEFwciAwNCwgMjAxOCBhdCAwNDo0OTowNlBNIC0wNzAwLCBEZWVwYWsgUmF3 YXQgd3JvdGU6Cj4gPiBGcm9tOiBMdWthc3ogU3BpbnR6eWsgPGx1a2Fzei5zcGludHp5a0BkaXNw bGF5bGluay5jb20+Cj4gPgo+ID4gT3B0aW9uYWwgcGxhbmUgcHJvcGVydHkgdG8gbWFyayBkYW1h Z2VkIHJlZ2lvbnMgb24gdGhlIHBsYW5lIGluCj4gPiBmcmFtZWJ1ZmZlciBjb29yZGluYXRlcyBv ZiB0aGUgZnJhbWVidWZmZXIgYXR0YWNoZWQgdG8gdGhlIHBsYW5lLgo+ID4KPiA+IFRoZSBsYXlv dXQgb2YgYmxvYiBkYXRhIGlzIHNpbXBseSBhbiBhcnJheSBvZiBkcm1fbW9kZV9yZWN0IHdpdGgK PiBtYXhpbXVtCj4gPiBhcnJheSBzaXplIGxpbWl0ZWQgYnkgRFJNX01PREVfRkJfRElSVFlfTUFY X0NMSVBTLiBVbmxpa2UgcGxhbmUgc3JjCj4gPiBjb29yZGluYXRlcywgZGFtYWdlIGNsaXBzIGFy ZSBub3QgaW4gMTYuMTYgZml4ZWQgcG9pbnQuCj4gPgo+ID4gRGFtYWdlIGNsaXBzIGFyZSBhIGhp bnQgdG8ga2VybmVsIGFzIHdoaWNoIGFyZWEgb2YgZnJhbWVidWZmZXIgaGFzCj4gPiBjaGFuZ2Vk IHNpbmNlIGxhc3QgcGFnZS1mbGlwLiBUaGlzIHNob3VsZCBiZSBoZWxwZnVsIGZvciBzb21lIGRy aXZlcnMKPiA+IGVzcGVjaWFsbHkgZm9yIHZpcnR1YWwgZGV2aWNlcyB3aGVyZSBlYWNoIGZyYW1l YnVmZmVyIGNoYW5nZSBuZWVkcyB0bwo+ID4gYmUgdHJhbnNtaXR0ZWQgb3ZlciBuZXR3b3JrLCB1 c2IsIGV0Yy4KPiA+Cj4gPiBEcml2ZXIgd2hpY2ggYXJlIGludGVyZXN0ZWQgaW4gZW5hYmxpbmcg REFNQUdFX0NMSVBTIHByb3BlcnR5IGZvciBhCj4gPiBwbGFuZSBzaG91bGQgZW5hYmxlIHRoaXMg cHJvcGVydHkgdXNpbmcgZHJtX3BsYW5lX2VuYWJsZV9kYW1hZ2VfY2xpcHMuCj4gPgo+ID4gU2ln bmVkLW9mZi1ieTogTHVrYXN6IFNwaW50enlrIDxsdWthc3ouc3BpbnR6eWtAZGlzcGxheWxpbmsu Y29tPgo+ID4gU2lnbmVkLW9mZi1ieTogRGVlcGFrIFJhd2F0IDxkcmF3YXRAdm13YXJlLmNvbT4K PiAKPiBUaGUgcHJvcGVydHkgdWFwaSBzZWN0aW9uIGlzIG1pc3NpbmcsIHNlZToKPiAKPiBodHRw czovL3VybGRlZmVuc2UucHJvb2Zwb2ludC5jb20vdjIvdXJsP3U9aHR0cHMtCj4gM0FfX2RyaS5m cmVlZGVza3RvcC5vcmdfZG9jc19kcm1fZ3B1X2RybS0yRGttcy5odG1sLTIzcGxhbmUtCj4gMkRj b21wb3NpdGlvbi0KPiAyRHByb3BlcnRpZXMmZD1Ed0lCQWcmYz11aWxhSzkwRDRUT1ZvSDU4Sk5Y UmdRJnI9ek9PRzI4aW5KSzA3NjIKPiBTeEFmLQo+IGN5WmRTdG5kMk5RcFJ1OThsSlAyaVlHdyZt PUVMQVVzTlRqRDBJQ3dVRURGalBXNGpzbXkyQTVBa2hTNVEKPiB6XzN2bEVDOVEmcz1uSC1ITlhQ Y3pvSlFNajFpd0hpR2ZyaFh6NC0wMGIwTTgtM2tpcmptLUVZJmU9Cj4gCj4gUGxhbmUgY29tcG9z aXRpb24gZmVlbHMgbGlrZSB0aGUgYmVzdCBwbGFjZSB0byBwdXQgdGhpcy4gUGxlYXNlIHVzZSB0 aGF0Cj4gc2VjdGlvbiB0byB0aWUgYWxsIHRoZSB2YXJpb3VzIGJpdHMgdG9nZXRoZXIsIGluY2x1 ZGluZyB0aGUgaGVscGVycyB5b3UncmUKPiBhZGRpbmcgaW4gdGhlIGZvbGxvd2luZyBwYXRjaGVz IGZvciBkcml2ZXJzIHRvIHVzZS4KPiAKPiBCdW5jaCBvZiBuaXRwaWNrcyBiZWxvdywgYnV0IG92 ZXJhbGwgSSdtIGFncmVlaW5nIG5vdyB3aXRoIGp1c3QgZ29pbmcgd2l0aAo+IGZiIGNvb3JkaW5h dGUgZGFtYWdlIHJlY3RzLgo+IAo+IExpa2UgeW91IHNheSwgdGhlIHRoaW5nIG5lZWRlZCBoZXJl IG5vdyBpcyB1c2Vyc3BhY2UgKyBkcml2ZXIgYWN0dWFsbHkKPiBpbXBsZW1lbnRpbmcgdGhpcy4g SSdkIGFsc28gc2F5IHRoZSBjb21wYXQgaGVscGVyIHRvIG1hcCB0aGUgbGVnYWN5Cj4gZmItPmRp cnR5IHRvIHRoaXMgbmV3IGF0b21pYyB3YXkgb2YgZG9pbmcgdGhpbmdzIHNob3VsZCBiZSBpbmNs dWRlZCBoZXJlCj4gKGdpdmVzIHVzIGEgbG90IG1vcmUgdGVzdGluZyBmb3IgdGhlc2UgbmV3IHBh dGhzKS4KPiAKPiBJY2luZyBvbiB0aGUgY2FrZSB3b3VsZCBiZSBhbiBpZ3QgdG8gbWFrZSBzdXJl IGtlcm5lbCByZWplY3RzIGludmFsaWQgY2xpcAo+IHJlY3RzIGNvcnJlY3RseS4KPiAKPiA+IC0t LQo+ID4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMgICAgICAgIHwgNDIKPiArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gPiAgZHJpdmVycy9ncHUvZHJtL2RybV9h dG9taWNfaGVscGVyLmMgfCAgNCArKysrCj4gPiAgZHJpdmVycy9ncHUvZHJtL2RybV9tb2RlX2Nv bmZpZy5jICAgfCAgNSArKysrKwo+ID4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fcGxhbmUuYyAgICAg ICAgIHwgMTIgKysrKysrKysrKysKPiA+ICBpbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaCAg ICAgICB8IDE1ICsrKysrKysrKysrKysKPiA+ICBpbmNsdWRlL2RybS9kcm1fcGxhbmUuaCAgICAg ICAgICAgICB8IDE2ICsrKysrKysrKysrKysrCj4gPiAgaW5jbHVkZS91YXBpL2RybS9kcm1fbW9k ZS5oICAgICAgICAgfCAxNSArKysrKysrKysrKysrCj4gPiAgNyBmaWxlcyBjaGFuZ2VkLCAxMDkg aW5zZXJ0aW9ucygrKQo+ID4KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0 b21pYy5jCj4gYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jCj4gPiBpbmRleCA3ZDI1YzQy Li45MjI2ZDI0IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+ ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+ID4gQEAgLTY2OSw2ICs2Njks NDAgQEAgc3RhdGljIHZvaWQgZHJtX2F0b21pY19jcnRjX3ByaW50X3N0YXRlKHN0cnVjdAo+IGRy bV9wcmludGVyICpwLAo+ID4gIH0KPiA+Cj4gPiAgLyoqCj4gPiArICogZHJtX2F0b21pY19zZXRf ZGFtYWdlX2Zvcl9wbGFuZSAtIHNldHMgdGhlIGRhbWFnZSBjbGlwcyBwcm9wZXJ0eQo+IHRvIHBs YW5lCj4gPiArICogQHN0YXRlOiBwbGFuZSBzdGF0ZQo+ID4gKyAqIEBibG9iOiBkYW1hZ2UgY2xp cHMgaW4gZnJhbWVidWZmZXIgY29vcmRpbmF0ZXMKPiA+ICsgKgo+ID4gKyAqIFJldHVybnM6Cj4g PiArICoKPiA+ICsgKiBaZXJvIG9uIHN1Y2Nlc3MsIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiA+ ICsgKi8KPiA+ICtzdGF0aWMgaW50IGRybV9hdG9taWNfc2V0X2RhbWFnZV9mb3JfcGxhbmUoc3Ry dWN0IGRybV9wbGFuZV9zdGF0ZQo+ICpzdGF0ZSwKPiA+ICsJCQkJCSAgIHN0cnVjdCBkcm1fcHJv cGVydHlfYmxvYiAqYmxvYikKPiA+ICt7Cj4gPiArCWlmIChibG9iID09IHN0YXRlLT5kYW1hZ2Vf Y2xpcHMpCj4gPiArCQlyZXR1cm4gMDsKPiA+ICsKPiA+ICsJZHJtX3Byb3BlcnR5X2Jsb2JfcHV0 KHN0YXRlLT5kYW1hZ2VfY2xpcHMpOwo+ID4gKwlzdGF0ZS0+ZGFtYWdlX2NsaXBzID0gTlVMTDsK PiA+ICsKPiA+ICsJaWYgKGJsb2IpIHsKPiA+ICsJCXVpbnQzMl90IGNvdW50ID0gYmxvYi0+bGVu Z3RoL3NpemVvZihzdHJ1Y3QgZHJtX3JlY3QpOwo+ID4gKwo+ID4gKwkJaWYgKGNvdW50ID4gRFJN X01PREVfRkJfRElSVFlfTUFYX0NMSVBTKQo+ID4gKwkJCXJldHVybiAtRUlOVkFMOwo+ID4gKwo+ ID4gKwkJc3RhdGUtPmRhbWFnZV9jbGlwcyA9IGRybV9wcm9wZXJ0eV9ibG9iX2dldChibG9iKTsK PiA+ICsJCXN0YXRlLT5udW1fY2xpcHMgPSBjb3VudDsKPiA+ICsJfSBlbHNlIHsKPiA+ICsJCXN0 YXRlLT5kYW1hZ2VfY2xpcHMgPSBOVUxMOwo+ID4gKwkJc3RhdGUtPm51bV9jbGlwcyA9IDA7Cj4g PiArCX0KPiA+ICsKPiA+ICsJcmV0dXJuIDA7Cj4gPiArfQo+ID4gKwo+ID4gKy8qKgo+ID4gICAq IGRybV9hdG9taWNfZ2V0X3BsYW5lX3N0YXRlIC0gZ2V0IHBsYW5lIHN0YXRlCj4gPiAgICogQHN0 YXRlOiBnbG9iYWwgYXRvbWljIHN0YXRlIG9iamVjdAo+ID4gICAqIEBwbGFuZTogcGxhbmUgdG8g Z2V0IHN0YXRlIG9iamVjdCBmb3IKPiA+IEBAIC03OTMsNiArODI3LDEyIEBAIHN0YXRpYyBpbnQg ZHJtX2F0b21pY19wbGFuZV9zZXRfcHJvcGVydHkoc3RydWN0Cj4gZHJtX3BsYW5lICpwbGFuZSwK PiA+ICAJCXN0YXRlLT5jb2xvcl9lbmNvZGluZyA9IHZhbDsKPiA+ICAJfSBlbHNlIGlmIChwcm9w ZXJ0eSA9PSBwbGFuZS0+Y29sb3JfcmFuZ2VfcHJvcGVydHkpIHsKPiA+ICAJCXN0YXRlLT5jb2xv cl9yYW5nZSA9IHZhbDsKPiA+ICsJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBjb25maWctPnByb3Bf ZGFtYWdlX2NsaXBzKSB7Cj4gPiArCQlzdHJ1Y3QgZHJtX3Byb3BlcnR5X2Jsb2IgKmJsb2IgPQo+ ID4gKwkJCWRybV9wcm9wZXJ0eV9sb29rdXBfYmxvYihkZXYsIHZhbCk7Cj4gPiArCQlpbnQgcmV0 ID0gZHJtX2F0b21pY19zZXRfZGFtYWdlX2Zvcl9wbGFuZShzdGF0ZSwgYmxvYik7Cj4gCj4gVGhl cmUncyBhbHJlYWR5IGEgaGVscGVyIHdpdGggc2l6ZS1jaGVja2luZyBidWlsdC1pbiwgc2VlCj4g ZHJtX2F0b21pY19yZXBsYWNlX3Byb3BlcnR5X2Jsb2JfZnJvbV9pZCgpLiBXcnQgY29tcHV0aW5n IG51bV9jbGlwcwo+IEknZAo+IGp1c3QgcHJvdmlkZSBhIGxpdHRsZSBpbmxpbmUgaGVscGVyIHRo YXQgZG9lcyB0aGUKPiBibG9iLT5sZW5ndGgvc2l6ZW9mKGRybV9yZWN0KSBjb252ZXJzaW9uIChp dCdzIGp1c3QgYSBzaGlmdCwgc28gZmFzdCkuCj4gCj4gPiArCQlkcm1fcHJvcGVydHlfYmxvYl9w dXQoYmxvYik7Cj4gPiArCQlyZXR1cm4gcmV0Owo+ID4gIAl9IGVsc2UgaWYgKHBsYW5lLT5mdW5j cy0+YXRvbWljX3NldF9wcm9wZXJ0eSkgewo+ID4gIAkJcmV0dXJuIHBsYW5lLT5mdW5jcy0+YXRv bWljX3NldF9wcm9wZXJ0eShwbGFuZSwgc3RhdGUsCj4gPiAgCQkJCXByb3BlcnR5LCB2YWwpOwo+ ID4gQEAgLTg1Niw2ICs4OTYsOCBAQCBkcm1fYXRvbWljX3BsYW5lX2dldF9wcm9wZXJ0eShzdHJ1 Y3QgZHJtX3BsYW5lCj4gKnBsYW5lLAo+ID4gIAkJKnZhbCA9IHN0YXRlLT5jb2xvcl9lbmNvZGlu ZzsKPiA+ICAJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+Y29sb3JfcmFuZ2VfcHJvcGVy dHkpIHsKPiA+ICAJCSp2YWwgPSBzdGF0ZS0+Y29sb3JfcmFuZ2U7Cj4gPiArCX0gZWxzZSBpZiAo cHJvcGVydHkgPT0gY29uZmlnLT5wcm9wX2RhbWFnZV9jbGlwcykgewo+ID4gKwkJKnZhbCA9IChz dGF0ZS0+ZGFtYWdlX2NsaXBzKSA/IHN0YXRlLT5kYW1hZ2VfY2xpcHMtPmJhc2UuaWQKPiA6IDA7 Cj4gPiAgCX0gZWxzZSBpZiAocGxhbmUtPmZ1bmNzLT5hdG9taWNfZ2V0X3Byb3BlcnR5KSB7Cj4g PiAgCQlyZXR1cm4gcGxhbmUtPmZ1bmNzLT5hdG9taWNfZ2V0X3Byb3BlcnR5KHBsYW5lLCBzdGF0 ZSwKPiBwcm9wZXJ0eSwgdmFsKTsKPiA+ICAJfSBlbHNlIHsKPiA+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwo+IGIvZHJpdmVycy9ncHUvZHJtL2RybV9h dG9taWNfaGVscGVyLmMKPiA+IGluZGV4IGMzNTY1NDUuLjU1YjQ0ZTMgMTAwNjQ0Cj4gPiAtLS0g YS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwo+ID4gKysrIGIvZHJpdmVycy9n cHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMKPiA+IEBAIC0zNTA2LDYgKzM1MDYsOCBAQCB2b2lk Cj4gX19kcm1fYXRvbWljX2hlbHBlcl9wbGFuZV9kdXBsaWNhdGVfc3RhdGUoc3RydWN0IGRybV9w bGFuZSAqcGxhbmUsCj4gPgo+ID4gIAlzdGF0ZS0+ZmVuY2UgPSBOVUxMOwo+ID4gIAlzdGF0ZS0+ Y29tbWl0ID0gTlVMTDsKPiA+ICsJc3RhdGUtPmRhbWFnZV9jbGlwcyA9IE5VTEw7Cj4gPiArCXN0 YXRlLT5udW1fY2xpcHMgPSAwOwo+ID4gIH0KPiA+ICBFWFBPUlRfU1lNQk9MKF9fZHJtX2F0b21p Y19oZWxwZXJfcGxhbmVfZHVwbGljYXRlX3N0YXRlKTsKPiA+Cj4gPiBAQCAtMzU1MCw2ICszNTUy LDggQEAgdm9pZAo+IF9fZHJtX2F0b21pY19oZWxwZXJfcGxhbmVfZGVzdHJveV9zdGF0ZShzdHJ1 Y3QgZHJtX3BsYW5lX3N0YXRlICpzdGF0ZSkKPiA+Cj4gPiAgCWlmIChzdGF0ZS0+Y29tbWl0KQo+ ID4gIAkJZHJtX2NydGNfY29tbWl0X3B1dChzdGF0ZS0+Y29tbWl0KTsKPiA+ICsKPiA+ICsJZHJt X3Byb3BlcnR5X2Jsb2JfcHV0KHN0YXRlLT5kYW1hZ2VfY2xpcHMpOwo+ID4gIH0KPiA+ICBFWFBP UlRfU1lNQk9MKF9fZHJtX2F0b21pY19oZWxwZXJfcGxhbmVfZGVzdHJveV9zdGF0ZSk7Cj4gPgo+ ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fbW9kZV9jb25maWcuYwo+IGIvZHJp dmVycy9ncHUvZHJtL2RybV9tb2RlX2NvbmZpZy5jCj4gPiBpbmRleCBlNWM2NTMzLi5lOTNiMTI3 IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9tb2RlX2NvbmZpZy5jCj4gPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX21vZGVfY29uZmlnLmMKPiA+IEBAIC0yOTMsNiArMjkz LDExIEBAIHN0YXRpYyBpbnQKPiBkcm1fbW9kZV9jcmVhdGVfc3RhbmRhcmRfcHJvcGVydGllcyhz dHJ1Y3QgZHJtX2RldmljZSAqZGV2KQo+ID4gIAkJcmV0dXJuIC1FTk9NRU07Cj4gPiAgCWRldi0+ bW9kZV9jb25maWcucHJvcF9jcnRjX2lkID0gcHJvcDsKPiA+Cj4gPiArCXByb3AgPSBkcm1fcHJv cGVydHlfY3JlYXRlKGRldiwgRFJNX01PREVfUFJPUF9CTE9CLAo+ICJEQU1BR0VfQ0xJUFMiLCAw KTsKPiAKPiBCaXQgYSBiaWtlc2hlZCwgYnV0IHNpbmNlIHRoZSBjb29yZGluYXRlcyBhcmUgaW4g ZmIgcGl4ZWxzLCBub3QgcGxhbmUKPiBwaXhlbHMsIEknZCBjYWxsIHRoaXMgIkZCX0RBTUFHRV9D TElQUyIuCj4gCj4gPiArCWlmICghcHJvcCkKPiA+ICsJCXJldHVybiAtRU5PTUVNOwo+ID4gKwlk ZXYtPm1vZGVfY29uZmlnLnByb3BfZGFtYWdlX2NsaXBzID0gcHJvcDsKPiA+ICsKPiA+ICAJcHJv cCA9IGRybV9wcm9wZXJ0eV9jcmVhdGVfYm9vbChkZXYsCj4gRFJNX01PREVfUFJPUF9BVE9NSUMs Cj4gPiAgCQkJIkFDVElWRSIpOwo+ID4gIAlpZiAoIXByb3ApCj4gPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2RybV9wbGFuZS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9wbGFuZS5jCj4g PiBpbmRleCA2ZDJhNmU0Li4wNzEyMjFiIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2RybV9wbGFuZS5jCj4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3BsYW5lLmMKPiA+IEBA IC0xMTAxLDMgKzExMDEsMTUgQEAgaW50IGRybV9tb2RlX3BhZ2VfZmxpcF9pb2N0bChzdHJ1Y3QK PiBkcm1fZGV2aWNlICpkZXYsCj4gPgo+ID4gIAlyZXR1cm4gcmV0Owo+ID4gIH0KPiA+ICsKPiA+ ICsvKioKPiA+ICsgKiBkcm1fcGxhbmVfZW5hYmxlX2RhbWFnZV9jbGlwcyAtIGVuYWJsZSBkYW1h Z2UgY2xpcHMgcHJvcGVydHkKPiA+ICsgKiBAcGxhbmU6IHBsYW5lIG9uIHdoaWNoIHRoaXMgcHJv cGVydHkgdG8gZW5hYmxlLgo+ID4gKyAqLwo+ID4gK3ZvaWQgZHJtX3BsYW5lX2VuYWJsZV9kYW1h Z2VfY2xpcHMoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCj4gPiArewo+ID4gKwlzdHJ1Y3QgZHJt X2RldmljZSAqZGV2ID0gcGxhbmUtPmRldjsKPiA+ICsJc3RydWN0IGRybV9tb2RlX2NvbmZpZyAq Y29uZmlnID0gJmRldi0+bW9kZV9jb25maWc7Cj4gPiArCj4gPiArCWRybV9vYmplY3RfYXR0YWNo X3Byb3BlcnR5KCZwbGFuZS0+YmFzZSwgY29uZmlnLQo+ID5wcm9wX2RhbWFnZV9jbGlwcywgMCk7 Cj4gPiArfQo+ID4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCj4g Yi9pbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaAo+ID4gaW5kZXggNzU2OWYyMi4uZDg3Njdk YSAxMDA2NDQKPiA+IC0tLSBhL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCj4gPiArKysg Yi9pbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaAo+ID4gQEAgLTYyOCw2ICs2MjgsMjEgQEAg c3RydWN0IGRybV9tb2RlX2NvbmZpZyB7Cj4gPiAgCSAqLwo+ID4gIAlzdHJ1Y3QgZHJtX3Byb3Bl cnR5ICpwcm9wX2NydGNfaWQ7Cj4gPiAgCS8qKgo+ID4gKwkgKiBAcHJvcF9kYW1hZ2VfY2xpcHM6 IE9wdGlvbmFsIHBsYW5lIHByb3BlcnR5IHRvIG1hcmsgZGFtYWdlZAo+IHJlZ2lvbnMKPiA+ICsJ ICogb24gdGhlIHBsYW5lIGluIGZyYW1lYnVmZmVyIGNvb3JkaW5hdGVzIG9mIHRoZSBmcmFtZWJ1 ZmZlcgo+IGF0dGFjaGVkCj4gPiArCSAqIHRvIHRoZSBwbGFuZS4KPiAKPiBXaHkgc2hvdWxkIHdl IG1ha2UgdGhpcyBvcHRpb25hbD8gTG9va3MgbGlrZSBqdXN0IGFub3RoZXIgdGhpbmcgZHJpdmVy cwo+IG1pZ2h0IHNjcmV3IHVwLCBzaW5jZSB3ZSBoYXZlIG11bHRpcGxlIGNhbGxiYWNrcyBhbmQg dGhpbmdzIHRvIHNldCB1cCBmb3IKPiBwcm9wZXIgZGlydHkgdHJhY2tpbmcuCgpUaGFua3MgRGFu aWVsIGZvciB0aGUgcmV2aWV3LgoKSSB0aGluayBub3QgYWxsIGNvbXBvc2l0b3Igd2lsbCBiZSBp bnRlcmVzdGVkIGluIHNlbmRpbmcgZGFtYWdlLCB0aGF0IHdhcyB0aGUKcmVhc29uIHRvIG1ha2Ug dGhpcyBvcHRpb25hbC4gQWxzbyB3aGVuIGRhbWFnZSBpcyBub3Qgc2V0IHRoYXQgbWVhbnMKdXNl ci1zcGFjZSBuZWVkIGZ1bGwgdXBkYXRlIGp1c3QgbGlrZSBlZ2xTd2FwQnVmZmVyc1dpdGhEYW1h Z2VLSFIuCgpJIHdpbGwgYWRkIGJldHRlciBkb2N1bWVudGF0aW9uLgoKPiAKPiBPbmUgb3B0aW9u IEknbSBzZWVpbmcgaXMgdGhhdCBpZiB0aGlzIGlzIHNldCwgYW5kIGl0J3MgYW4gYXRvbWljIGRy aXZlciwKPiB0aGVuIHdlIGp1c3QgZGlyZWN0bHkgY2FsbCBpbnRvIHRoZSBkZWZhdWx0IGF0b21p YyBmYi0+ZGlydHkKPiBpbXBsZW1lbnRhdGlvbi4gVGhhdCB3YXkgdGhlcmUncyBvbmx5IDEgdGhp bmcgZHJpdmVycyBuZWVkIHRvIGRvIHRvIHNldCB1cAo+IGRpcnR5IHJlY3QgdHJhY2tpbmcsIGFu ZCB0aGV5J2xsIGdldCBhbGwgb2YgaXQuCj4gCj4gPiArCSAqCj4gPiArCSAqIFRoZSBsYXlvdXQg b2YgYmxvYiBkYXRhIGlzIHNpbXBseSBhbiBhcnJheSBvZiBkcm1fbW9kZV9yZWN0IHdpdGgKPiA+ ICsJICogbWF4aW11bSBhcnJheSBzaXplIGxpbWl0ZWQgYnkKPiBEUk1fTU9ERV9GQl9ESVJUWV9N QVhfQ0xJUFMuIFVubGlrZQo+ID4gKwkgKiBwbGFuZSBzcmMgY29vcmRpbmF0ZXMsIGRhbWFnZSBj bGlwcyBhcmUgbm90IGluIDE2LjE2IGZpeGVkIHBvaW50Lgo+IAo+IEkgaG9uZXN0bHkgaGF2ZSBu byBpZGVhIHdoZXJlIHRoaXMgbGltaXQgaXMgZnJvbS4gV29ydGgga2VlcGluZz8gSSBjYW4KPiBl YXNpbHkgaW1hZ2luZSB0aGF0IHVzZXJzcGFjZSBjb3VsZCB0cmlwIG92ZXIgdGhpcyAtIGl0J3Mg ZmFpcmx5IGhpZ2gsIGJ1dAo+IG5vdCB1bmxpbWl0ZWQuCgpEUk1fTU9ERV9GQl9ESVJUWV9NQVhf Q0xJUFMgd2FzIHVzZWQgdG8ganVzdCBoYXZlIGFuIHVwcGVyIGxpbWl0CmFuZCBpdHMgYWxyZWFk eSBleHBvc2VkIHRvIHVzZXItc3BhY2UuIElNSE8gdGhlcmUgaGFzIHRvIGJlIGFuIHVwcGVyIGxp bWl0CnRvIGF2b2lkIHVubmVjZXNzYXJ5IG92ZXJmbG93ID8KCj4gCj4gPiArCSAqCj4gPiArCSAq IERhbWFnZSBjbGlwcyBhcmUgYSBoaW50IHRvIGtlcm5lbCBhcyB3aGljaCBhcmVhIG9mIGZyYW1l YnVmZmVyIGhhcwo+ID4gKwkgKiBjaGFuZ2VkIHNpbmNlIGxhc3QgcGFnZS1mbGlwLiBUaGlzIHNo b3VsZCBiZSBoZWxwZnVsCj4gPiArCSAqIGZvciBzb21lIGRyaXZlcnMgZXNwZWNpYWxseSBmb3Ig dmlydHVhbCBkZXZpY2VzIHdoZXJlIGVhY2gKPiA+ICsJICogZnJhbWVidWZmZXIgY2hhbmdlIG5l ZWRzIHRvIGJlIHRyYW5zbWl0dGVkIG92ZXIgbmV0d29yaywgdXNiLAo+IGV0Yy4KPiAKPiBJJ2Qg YWxzbyBjbGFyaWZ5IHRoYXQgdXNlcnNwYWNlIHN0aWxsIG11c3QgcmVuZGVyIHRoZSBlbnRpcmUg c2NyZWVuLCBpLmUuCj4gbWFrZSBpdCBtb3JlIGNsZWFyIHRoYXQgaXQncyByZWFsbHkganVzdCBh IGhpbnQgYW5kIG5vdCBtYW5kYXRvcnkgdG8gb25seQo+IHNjYW4gb3V0IHRoZSBkYW1hZ2VkIHBh cnRzLgoKWWVzIHdpbGwgd29yayBvbiBiZXR0ZXIgZG9jdW1lbnRhdGlvbi4KCj4gCj4gPiArCSAq Lwo+ID4gKwlzdHJ1Y3QgZHJtX3Byb3BlcnR5ICpwcm9wX2RhbWFnZV9jbGlwczsKPiA+ICsJLyoq Cj4gPiAgCSAqIEBwcm9wX2FjdGl2ZTogRGVmYXVsdCBhdG9taWMgQ1JUQyBwcm9wZXJ0eSB0byBj b250cm9sIHRoZSBhY3RpdmUKPiA+ICAJICogc3RhdGUsIHdoaWNoIGlzIHRoZSBzaW1wbGlmaWVk IGltcGxlbWVudGF0aW9uIGZvciBEUE1TIGluIGF0b21pYwo+ID4gIAkgKiBkcml2ZXJzLgo+ID4g ZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9wbGFuZS5oIGIvaW5jbHVkZS9kcm0vZHJtX3Bs YW5lLmgKPiA+IGluZGV4IGY3YmY0YTQuLjlmMjQ1NDggMTAwNjQ0Cj4gPiAtLS0gYS9pbmNsdWRl L2RybS9kcm1fcGxhbmUuaAo+ID4gKysrIGIvaW5jbHVkZS9kcm0vZHJtX3BsYW5lLmgKPiA+IEBA IC0xNDYsNiArMTQ2LDIxIEBAIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgewo+ID4gIAkgKi8KPiA+ ICAJc3RydWN0IGRybV9jcnRjX2NvbW1pdCAqY29tbWl0Owo+ID4KPiA+ICsJLyoKPiA+ICsJICog QGRhbWFnZV9jbGlwcwo+ID4gKwkgKgo+ID4gKwkgKiBibG9iIHByb3BlcnR5IHdpdGggZGFtYWdl IGFzIGFycmF5IG9mIGRybV9yZWN0IGluIGZyYW1lYnVmZmVyCj4gCj4gJmRybV9yZWN0IGdpdmVz IHlvdSBhIG5pY2UgaHlwZXJsaW5rIGluIHRoZSBnZW5lcmF0ZWQgZG9jcy4KPiAKPiA+ICsJICog Y29vZGluYXRlcy4KPiA+ICsJICovCj4gPiArCXN0cnVjdCBkcm1fcHJvcGVydHlfYmxvYiAqZGFt YWdlX2NsaXBzOwo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBAbnVtX2NsaXBzCj4gPiArCSAqCj4g PiArCSAqIE51bWJlciBvZiBkcm1fcmVjdCBpbiBAZGFtYWdlX2NsaXBzLgo+ID4gKwkgKi8KPiA+ ICsJdWludDMyX3QgbnVtX2NsaXBzOwo+ID4gKwo+ID4gIAlzdHJ1Y3QgZHJtX2F0b21pY19zdGF0 ZSAqc3RhdGU7Cj4gPiAgfTsKPiA+Cj4gPiBAQCAtNjExLDYgKzYyNiw3IEBAIGludCBkcm1fcGxh bmVfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ID4gIAkJICAgY29uc3QgdWludDMyX3Qg KmZvcm1hdHMsIHVuc2lnbmVkIGludCBmb3JtYXRfY291bnQsCj4gPiAgCQkgICBib29sIGlzX3By aW1hcnkpOwo+ID4gIHZvaWQgZHJtX3BsYW5lX2NsZWFudXAoc3RydWN0IGRybV9wbGFuZSAqcGxh bmUpOwo+ID4gK3ZvaWQgZHJtX3BsYW5lX2VuYWJsZV9kYW1hZ2VfY2xpcHMoc3RydWN0IGRybV9w bGFuZSAqcGxhbmUpOwo+ID4KPiA+ICAvKioKPiA+ICAgKiBkcm1fcGxhbmVfaW5kZXggLSBmaW5k IHRoZSBpbmRleCBvZiBhIHJlZ2lzdGVyZWQgcGxhbmUKPiA+IGRpZmYgLS1naXQgYS9pbmNsdWRl L3VhcGkvZHJtL2RybV9tb2RlLmgKPiBiL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21vZGUuaAo+ID4g aW5kZXggNTBiY2Y0Mi4uMGFkMGQ1YiAxMDA2NDQKPiA+IC0tLSBhL2luY2x1ZGUvdWFwaS9kcm0v ZHJtX21vZGUuaAo+ID4gKysrIGIvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCj4gPiBAQCAt ODczLDYgKzg3MywyMSBAQCBzdHJ1Y3QgZHJtX21vZGVfcmV2b2tlX2xlYXNlIHsKPiA+ICAJX191 MzIgbGVzc2VlX2lkOwo+ID4gIH07Cj4gPgo+ID4gKy8qKgo+ID4gKyAqIHN0cnVjdCBkcm1fbW9k ZV9yZWN0IC0gdHdvIGRpbWVuc2lvbmFsIHJlY3RhbmdsZSBkcm1fcmVjdCBleHBvcnRlZAo+IHRv Cj4gPiArICogdXNlci1zcGFjZS4KPiA+ICsgKiBAeDE6IGhvcml6b250YWwgc3RhcnRpbmcgY29v cmRpbmF0ZSAoaW5jbHVzaXZlKQo+ID4gKyAqIEB5MTogdmVydGljYWwgc3RhcnRpbmcgY29vcmRp bmF0ZSAoaW5jbHVzaXZlKQo+ID4gKyAqIEB4MjogaG9yaXpvbnRhbCBlbmRpbmcgY29vcmRpbmF0 ZSAoZXhjbHVzaXZlKQo+ID4gKyAqIEB5MjogdmVydGljYWwgZW5kaW5nIGNvb3JkaW5hdGUgKGV4 Y2x1c2l2ZSkKPiA+ICsgKi8KPiA+ICtzdHJ1Y3QgZHJtX21vZGVfcmVjdCB7Cj4gPiArCV9fczMy IHgxOwo+ID4gKwlfX3MzMiB5MTsKPiA+ICsJX19zMzIgeDI7Cj4gPiArCV9fczMyIHkyOwo+IAo+ IFdoeSBzaWduZWQ/IE5lZ2F0aXZlIGRhbWFnZSByZWN0cyBvbiBhbiBmYiBkb24ndCBtYWtlIHNl bnNlIHRvIG1lLiBBbHNvLAo+IHBsZWFzZSBzcGVjaWZ5IHdoYXQgdGhpcyBpcyBleGFjdGx5ICh0 byBhdm9pZCBjb25mdXNpb24gd2l0aCB0aGUgMTYuMTYKPiBmaXhlZCBwb2ludCBzcmMgcmVjdHMp LCBhbmQgbWF5YmUgbWVudGlvbiBpbiB0aGUgY29tbWl0IG1lc3NhZ2Ugd2h5IHdlJ3JlCj4gbm90 IHVzaW5nIGRybV9jbGlwX3JlY3QgKGdvaW5nIHRvIHByb3BlciB1YXBpIHR5cGVzIGFuZCAzMmJp dCBtYWtlcyBzZW5zZQo+IHRvIG1lKS4KPiAKPiBDaGVlcnMsIERhbmllbAo+ID4gK307Cj4gPiAr Cj4gPiAgI2lmIGRlZmluZWQoX19jcGx1c3BsdXMpCj4gPiAgfQo+ID4gICNlbmRpZgo+ID4gLS0K PiA+IDIuNy40Cj4gPgo+IAo+IC0tCj4gRGFuaWVsIFZldHRlcgo+IFNvZnR3YXJlIEVuZ2luZWVy LCBJbnRlbCBDb3Jwb3JhdGlvbgo+IGh0dHBzOi8vdXJsZGVmZW5zZS5wcm9vZnBvaW50LmNvbS92 Mi91cmw/dT1odHRwLQo+IDNBX19ibG9nLmZmd2xsLmNoJmQ9RHdJQkFnJmM9dWlsYUs5MEQ0VE9W b0g1OEpOWFJnUSZyPXpPT0cyOGluSksKPiAwNzYyU3hBZi0KPiBjeVpkU3RuZDJOUXBSdTk4bEpQ MmlZR3cmbT1FTEFVc05UakQwSUN3VUVERmpQVzRqc215MkE1QWtoUzVRCj4gel8zdmxFQzlRJnM9 a0x4NVhDVE1SWVJvZWNOaHd3d04yWEl0VDRSdDBpYjEyLVVQNVZCNFhMSSZlPQpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBs aXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK