From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 20918C432C3 for ; Sun, 24 Nov 2019 13:58:05 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D19D720748 for ; Sun, 24 Nov 2019 13:58:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="mIfdPJGq" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726767AbfKXN6E (ORCPT ); Sun, 24 Nov 2019 08:58:04 -0500 Received: from perceval.ideasonboard.com ([213.167.242.64]:42650 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726744AbfKXN6D (ORCPT ); Sun, 24 Nov 2019 08:58:03 -0500 Received: from pendragon.ideasonboard.com (fs96f9c64d.tkyc509.ap.nuro.jp [150.249.198.77]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id E54ADD4B; Sun, 24 Nov 2019 14:57:57 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1574603878; bh=T65IYwS0CouJyX+FDACVteAClrdDP3GCAgQksUyvPao=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=mIfdPJGqW6OHdU9IvOshVinNxPeCFhv2gxqnoTjbqoHxMmDokB2lY5GOAU2KluauH bI6cXHKxHIS7euY26KxnT58xWt52SeuICI0C4HVpzACAlhuzMhBJScnEjgdDWNWWy6 nJLg7gTI+0qCTHpMMVd/LXsuqDeQL2f8o42s4/JQ= Date: Sun, 24 Nov 2019 15:57:49 +0200 From: Laurent Pinchart To: Boris Brezillon Cc: dri-devel@lists.freedesktop.org, Lucas Stach , Chris Healy , Andrey Smirnov , Nikita Yushchenko , kernel@collabora.com, Daniel Vetter , Inki Dae , Joonyoung Shim , Seung-Woo Kim , Kyungmin Park , Thierry Reding , Sam Ravnborg , Philipp Zabel , Rob Clark , Andrzej Hajda , Neil Armstrong , Jonas Karlman , Jernej Skrabec , Rob Herring , Mark Rutland , devicetree@vger.kernel.org Subject: Re: [PATCH v3 07/21] drm/bridge: Make the bridge chain a double-linked list Message-ID: <20191124135749.GH4727@pendragon.ideasonboard.com> References: <20191023154512.9762-1-boris.brezillon@collabora.com> <20191023154512.9762-8-boris.brezillon@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <20191023154512.9762-8-boris.brezillon@collabora.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Hi Boris, Thank you for the patch. On Wed, Oct 23, 2019 at 05:44:58PM +0200, Boris Brezillon wrote: > So that each element in the chain can easily access its predecessor. > This will be needed to support bus format negotiation between elements > of the bridge chain. > > Signed-off-by: Boris Brezillon > --- > Changes in v3: > * None > > Changes in v2: > * Adjust things to the "dummy encoder bridge" change (patch 2 in this > series) > --- > drivers/gpu/drm/drm_bridge.c | 171 ++++++++++++++++++++++------------ > drivers/gpu/drm/drm_encoder.c | 16 +--- > include/drm/drm_bridge.h | 12 ++- > include/drm/drm_encoder.h | 9 +- > 4 files changed, 135 insertions(+), 73 deletions(-) > > diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c > index 54c874493c57..c5cf8a9c4237 100644 > --- a/drivers/gpu/drm/drm_bridge.c > +++ b/drivers/gpu/drm/drm_bridge.c > @@ -55,7 +55,7 @@ > * just provide additional hooks to get the desired output at the end of the > * encoder chain. > * > - * Bridges can also be chained up using the &drm_bridge.next pointer. > + * Bridges can also be chained up using the &drm_bridge.chain_node field. > * > * Both legacy CRTC helpers and the new atomic modeset helpers support bridges. > */ > @@ -114,6 +114,7 @@ EXPORT_SYMBOL(drm_bridge_remove); > int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, > struct drm_bridge *previous) > { > + LIST_HEAD(tmp_list); > int ret; > > if (!encoder || !bridge) > @@ -127,6 +128,7 @@ int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, > > bridge->dev = encoder->dev; > bridge->encoder = encoder; > + list_add_tail(&bridge->chain_node, &tmp_list); Couldn't we simplify this by adding the bridge to the list here ? We would need to remove it in the error path of the attach operation though, but wouldn't it make the code easier to read, and more efficient in the most likely path ? > > if (bridge->funcs->attach) { > ret = bridge->funcs->attach(bridge); > @@ -138,9 +140,9 @@ int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, > } > > if (previous) > - previous->next = bridge; > + list_splice(&tmp_list, &previous->chain_node); > else > - encoder->bridge = bridge; > + list_splice(&tmp_list, &encoder->bridge_chain); > > return 0; > } > @@ -157,6 +159,7 @@ void drm_bridge_detach(struct drm_bridge *bridge) > if (bridge->funcs->detach) > bridge->funcs->detach(bridge); > > + list_del(&bridge->chain_node); > bridge->dev = NULL; > } > > @@ -190,18 +193,22 @@ bool drm_bridge_chain_mode_fixup(struct drm_bridge *bridge, > const struct drm_display_mode *mode, > struct drm_display_mode *adjusted_mode) > { > - bool ret = true; > + struct drm_encoder *encoder; > > if (!bridge) > return true; > > - if (bridge->funcs->mode_fixup) > - ret = bridge->funcs->mode_fixup(bridge, mode, adjusted_mode); > + encoder = bridge->encoder; > + list_for_each_entry_from(bridge, &encoder->bridge_chain, > + chain_node) { > + if (!bridge->funcs->mode_fixup) > + continue; > > - ret = ret && drm_bridge_chain_mode_fixup(bridge->next, mode, > - adjusted_mode); > + if (!bridge->funcs->mode_fixup(bridge, mode, adjusted_mode)) > + return false; > + } > > - return ret; > + return true; > } > EXPORT_SYMBOL(drm_bridge_chain_mode_fixup); > > @@ -224,18 +231,24 @@ enum drm_mode_status > drm_bridge_chain_mode_valid(struct drm_bridge *bridge, > const struct drm_display_mode *mode) > { > - enum drm_mode_status ret = MODE_OK; > + struct drm_encoder *encoder; > > if (!bridge) > - return ret; > + return MODE_OK; > + > + encoder = bridge->encoder; > + list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { > + enum drm_mode_status ret; > + > + if (!bridge->funcs->mode_valid) > + continue; > > - if (bridge->funcs->mode_valid) > ret = bridge->funcs->mode_valid(bridge, mode); > + if (ret != MODE_OK) > + return ret; > + } > > - if (ret != MODE_OK) > - return ret; > - > - return drm_bridge_chain_mode_valid(bridge->next, mode); > + return MODE_OK; > } > EXPORT_SYMBOL(drm_bridge_chain_mode_valid); > > @@ -251,13 +264,20 @@ EXPORT_SYMBOL(drm_bridge_chain_mode_valid); > */ > void drm_bridge_chain_disable(struct drm_bridge *bridge) > { > + struct drm_encoder *encoder; > + struct drm_bridge *iter; > + > if (!bridge) > return; > > - drm_bridge_chain_disable(bridge->next); > + encoder = bridge->encoder; > + list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { > + if (iter->funcs->disable) > + iter->funcs->disable(iter); > > - if (bridge->funcs->disable) > - bridge->funcs->disable(bridge); > + if (iter == bridge) > + break; > + } > } > EXPORT_SYMBOL(drm_bridge_chain_disable); > > @@ -274,13 +294,16 @@ EXPORT_SYMBOL(drm_bridge_chain_disable); > */ > void drm_bridge_chain_post_disable(struct drm_bridge *bridge) > { > + struct drm_encoder *encoder; > + > if (!bridge) > return; > > - if (bridge->funcs->post_disable) > - bridge->funcs->post_disable(bridge); > - > - drm_bridge_chain_post_disable(bridge->next); > + encoder = bridge->encoder; > + list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { > + if (bridge->funcs->post_disable) > + bridge->funcs->post_disable(bridge); > + } > } > EXPORT_SYMBOL(drm_bridge_chain_post_disable); > > @@ -300,13 +323,16 @@ void drm_bridge_chain_mode_set(struct drm_bridge *bridge, > const struct drm_display_mode *mode, > const struct drm_display_mode *adjusted_mode) > { > + struct drm_encoder *encoder; > + > if (!bridge) > return; > > - if (bridge->funcs->mode_set) > - bridge->funcs->mode_set(bridge, mode, adjusted_mode); > - > - drm_bridge_chain_mode_set(bridge->next, mode, adjusted_mode); > + encoder = bridge->encoder; > + list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { > + if (bridge->funcs->mode_set) > + bridge->funcs->mode_set(bridge, mode, adjusted_mode); > + } > } > EXPORT_SYMBOL(drm_bridge_chain_mode_set); > > @@ -323,13 +349,17 @@ EXPORT_SYMBOL(drm_bridge_chain_mode_set); > */ > void drm_bridge_chain_pre_enable(struct drm_bridge *bridge) > { > + struct drm_encoder *encoder; > + struct drm_bridge *iter; You could reuse the bridge parameter instead of declaring a local variable, the same way you do in drm_atomic_bridge_chain_enable(). > + > if (!bridge) > return; > > - drm_bridge_chain_pre_enable(bridge->next); > - > - if (bridge->funcs->pre_enable) > - bridge->funcs->pre_enable(bridge); > + encoder = bridge->encoder; > + list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { > + if (iter->funcs->pre_enable) > + iter->funcs->pre_enable(iter); Or are you missing the iter == bridge check ? > + } > } > EXPORT_SYMBOL(drm_bridge_chain_pre_enable); > > @@ -345,13 +375,16 @@ EXPORT_SYMBOL(drm_bridge_chain_pre_enable); > */ > void drm_bridge_chain_enable(struct drm_bridge *bridge) > { > + struct drm_encoder *encoder; > + > if (!bridge) > return; > > - if (bridge->funcs->enable) > - bridge->funcs->enable(bridge); > - > - drm_bridge_chain_enable(bridge->next); > + encoder = bridge->encoder; > + list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { > + if (bridge->funcs->enable) > + bridge->funcs->enable(bridge); > + } > } > EXPORT_SYMBOL(drm_bridge_chain_enable); > > @@ -370,15 +403,23 @@ EXPORT_SYMBOL(drm_bridge_chain_enable); > void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge, > struct drm_atomic_state *state) > { > + struct drm_encoder *encoder; > + struct drm_bridge *iter; > + > if (!bridge) > return; > > - drm_atomic_bridge_chain_disable(bridge->next, state); > + encoder = bridge->encoder; > + list_for_each_entry_reverse(iter, &encoder->bridge_chain, > + chain_node) { This can hold on a single line. > + if (iter->funcs->atomic_disable) > + iter->funcs->atomic_disable(iter, state); > + else if (iter->funcs->disable) > + iter->funcs->disable(iter); > > - if (bridge->funcs->atomic_disable) > - bridge->funcs->atomic_disable(bridge, state); > - else if (bridge->funcs->disable) > - bridge->funcs->disable(bridge); > + if (iter == bridge) > + break; > + } > } > EXPORT_SYMBOL(drm_atomic_bridge_chain_disable); > > @@ -398,15 +439,19 @@ EXPORT_SYMBOL(drm_atomic_bridge_chain_disable); > void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge, > struct drm_atomic_state *state) > { > + struct drm_encoder *encoder; > + > if (!bridge) > return; > > - if (bridge->funcs->atomic_post_disable) > - bridge->funcs->atomic_post_disable(bridge, state); > - else if (bridge->funcs->post_disable) > - bridge->funcs->post_disable(bridge); > - > - drm_atomic_bridge_chain_post_disable(bridge->next, state); > + encoder = bridge->encoder; > + list_for_each_entry_from(bridge, &encoder->bridge_chain, > + chain_node) { This too can hold on a single line. > + if (bridge->funcs->atomic_post_disable) > + bridge->funcs->atomic_post_disable(bridge, state); > + else if (bridge->funcs->post_disable) > + bridge->funcs->post_disable(bridge); > + } > } > EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable); > > @@ -426,15 +471,23 @@ EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable); > void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge, > struct drm_atomic_state *state) > { > + struct drm_encoder *encoder; > + struct drm_bridge *iter; > + > if (!bridge) > return; > > - drm_atomic_bridge_chain_pre_enable(bridge->next, state); > + encoder = bridge->encoder; > + list_for_each_entry_reverse(iter, &bridge->encoder->bridge_chain, > + chain_node) { As Neil pointed out, &encoder->bridge_chain. > + if (iter->funcs->atomic_pre_enable) > + iter->funcs->atomic_pre_enable(iter, state); > + else if (iter->funcs->pre_enable) > + iter->funcs->pre_enable(iter); > > - if (bridge->funcs->atomic_pre_enable) > - bridge->funcs->atomic_pre_enable(bridge, state); > - else if (bridge->funcs->pre_enable) > - bridge->funcs->pre_enable(bridge); > + if (iter == bridge) > + break; > + } > } > EXPORT_SYMBOL(drm_atomic_bridge_chain_pre_enable); > > @@ -453,15 +506,19 @@ EXPORT_SYMBOL(drm_atomic_bridge_chain_pre_enable); > void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, > struct drm_atomic_state *state) > { > + struct drm_encoder *encoder; > + > if (!bridge) > return; > > - if (bridge->funcs->atomic_enable) > - bridge->funcs->atomic_enable(bridge, state); > - else if (bridge->funcs->enable) > - bridge->funcs->enable(bridge); > - > - drm_atomic_bridge_chain_enable(bridge->next, state); > + encoder = bridge->encoder; > + list_for_each_entry_from(bridge, &bridge->encoder->bridge_chain, Here too. By the way, should these bridge chain functions take an encoder instead of a bridge (in a separate patch series probably) ? > + chain_node) { > + if (bridge->funcs->atomic_enable) > + bridge->funcs->atomic_enable(bridge, state); > + else if (bridge->funcs->enable) > + bridge->funcs->enable(bridge); > + } > } > EXPORT_SYMBOL(drm_atomic_bridge_chain_enable); > > diff --git a/drivers/gpu/drm/drm_encoder.c b/drivers/gpu/drm/drm_encoder.c > index 4fe9e723e227..e555281f43d4 100644 > --- a/drivers/gpu/drm/drm_encoder.c > +++ b/drivers/gpu/drm/drm_encoder.c > @@ -140,6 +140,7 @@ int drm_encoder_init(struct drm_device *dev, > goto out_put; > } > > + INIT_LIST_HEAD(&encoder->bridge_chain); > list_add_tail(&encoder->head, &dev->mode_config.encoder_list); > encoder->index = dev->mode_config.num_encoder++; > > @@ -160,23 +161,16 @@ EXPORT_SYMBOL(drm_encoder_init); > void drm_encoder_cleanup(struct drm_encoder *encoder) > { > struct drm_device *dev = encoder->dev; > + struct drm_bridge *bridge, *next; > > /* Note that the encoder_list is considered to be static; should we > * remove the drm_encoder at runtime we would have to decrement all > * the indices on the drm_encoder after us in the encoder_list. > */ > > - if (encoder->bridge) { > - struct drm_bridge *bridge; > - struct drm_bridge *next; > - > - bridge = drm_bridge_chain_get_first_bridge(encoder); > - while (bridge) { > - next = bridge->next; > - drm_bridge_detach(bridge); > - bridge = next; > - } > - } > + list_for_each_entry_safe(bridge, next, &encoder->bridge_chain, > + chain_node) > + drm_bridge_detach(bridge); > > drm_mode_object_unregister(dev, &encoder->base); > kfree(encoder->name); > diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h > index 27eef63ce0ff..3ab16c95e59e 100644 > --- a/include/drm/drm_bridge.h > +++ b/include/drm/drm_bridge.h > @@ -384,8 +384,8 @@ struct drm_bridge { > struct drm_device *dev; > /** @encoder: encoder to which this bridge is connected */ > struct drm_encoder *encoder; > - /** @next: the next bridge in the encoder chain */ > - struct drm_bridge *next; > + /** @chain_node: used to form a bridge chain */ > + struct list_head chain_node; > #ifdef CONFIG_OF > /** @of_node: device node pointer to the bridge */ > struct device_node *of_node; > @@ -420,7 +420,10 @@ int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, > static inline struct drm_bridge * > drm_bridge_chain_get_next_bridge(struct drm_bridge *bridge) > { > - return bridge->next; > + if (list_is_last(&bridge->chain_node, &bridge->encoder->bridge_chain)) > + return NULL; > + > + return list_next_entry(bridge, chain_node); A list_next_entry_or_null() would be useful in list.h I think (of course not as a mandatory part of this series :-)). > } > > /** > @@ -434,7 +437,8 @@ drm_bridge_chain_get_next_bridge(struct drm_bridge *bridge) > static inline struct drm_bridge * > drm_bridge_chain_get_first_bridge(struct drm_encoder *encoder) > { > - return encoder->bridge; > + return list_first_entry_or_null(&encoder->bridge_chain, > + struct drm_bridge, chain_node); > } > > bool drm_bridge_chain_mode_fixup(struct drm_bridge *bridge, > diff --git a/include/drm/drm_encoder.h b/include/drm/drm_encoder.h > index f06164f44efe..9b3dde177c81 100644 > --- a/include/drm/drm_encoder.h > +++ b/include/drm/drm_encoder.h > @@ -172,7 +172,14 @@ struct drm_encoder { > * &drm_connector_state.crtc. > */ > struct drm_crtc *crtc; > - struct drm_bridge *bridge; > + > + /** > + * @bridge_chain: Bridges attached to this encoder. The first entry of > + * this list is always &drm_encoder.bridge. It may be followed by other There's no &drm_encoder.bridge anymore :-) With all those small issues fixed, Reviewed-by: Laurent Pinchart > + * bridge entities. > + */ > + struct list_head bridge_chain; > + > const struct drm_encoder_funcs *funcs; > const struct drm_encoder_helper_funcs *helper_private; > }; -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v3 07/21] drm/bridge: Make the bridge chain a double-linked list Date: Sun, 24 Nov 2019 15:57:49 +0200 Message-ID: <20191124135749.GH4727@pendragon.ideasonboard.com> References: <20191023154512.9762-1-boris.brezillon@collabora.com> <20191023154512.9762-8-boris.brezillon@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5689389CDF for ; Sun, 24 Nov 2019 13:58:02 +0000 (UTC) Content-Disposition: inline In-Reply-To: <20191023154512.9762-8-boris.brezillon@collabora.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Boris Brezillon Cc: Mark Rutland , Neil Armstrong , dri-devel@lists.freedesktop.org, Thierry Reding , kernel@collabora.com, Sam Ravnborg , Nikita Yushchenko , Andrey Smirnov , Kyungmin Park , Chris Healy , devicetree@vger.kernel.org, Jonas Karlman , Rob Herring , Jernej Skrabec , Seung-Woo Kim List-Id: dri-devel@lists.freedesktop.org SGkgQm9yaXMsCgpUaGFuayB5b3UgZm9yIHRoZSBwYXRjaC4KCk9uIFdlZCwgT2N0IDIzLCAyMDE5 IGF0IDA1OjQ0OjU4UE0gKzAyMDAsIEJvcmlzIEJyZXppbGxvbiB3cm90ZToKPiBTbyB0aGF0IGVh Y2ggZWxlbWVudCBpbiB0aGUgY2hhaW4gY2FuIGVhc2lseSBhY2Nlc3MgaXRzIHByZWRlY2Vzc29y Lgo+IFRoaXMgd2lsbCBiZSBuZWVkZWQgdG8gc3VwcG9ydCBidXMgZm9ybWF0IG5lZ290aWF0aW9u IGJldHdlZW4gZWxlbWVudHMKPiBvZiB0aGUgYnJpZGdlIGNoYWluLgo+IAo+IFNpZ25lZC1vZmYt Ynk6IEJvcmlzIEJyZXppbGxvbiA8Ym9yaXMuYnJlemlsbG9uQGNvbGxhYm9yYS5jb20+Cj4gLS0t Cj4gQ2hhbmdlcyBpbiB2MzoKPiAqIE5vbmUKPiAKPiBDaGFuZ2VzIGluIHYyOgo+ICogQWRqdXN0 IHRoaW5ncyB0byB0aGUgImR1bW15IGVuY29kZXIgYnJpZGdlIiBjaGFuZ2UgKHBhdGNoIDIgaW4g dGhpcwo+ICAgc2VyaWVzKQo+IC0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vZHJtX2JyaWRnZS5jICB8 IDE3MSArKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvZ3B1L2Ry bS9kcm1fZW5jb2Rlci5jIHwgIDE2ICstLS0KPiAgaW5jbHVkZS9kcm0vZHJtX2JyaWRnZS5oICAg ICAgfCAgMTIgKystCj4gIGluY2x1ZGUvZHJtL2RybV9lbmNvZGVyLmggICAgIHwgICA5ICstCj4g IDQgZmlsZXMgY2hhbmdlZCwgMTM1IGluc2VydGlvbnMoKyksIDczIGRlbGV0aW9ucygtKQo+IAo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2JyaWRnZS5jIGIvZHJpdmVycy9ncHUv ZHJtL2RybV9icmlkZ2UuYwo+IGluZGV4IDU0Yzg3NDQ5M2M1Ny4uYzVjZjhhOWM0MjM3IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYnJpZGdlLmMKPiArKysgYi9kcml2ZXJzL2dw dS9kcm0vZHJtX2JyaWRnZS5jCj4gQEAgLTU1LDcgKzU1LDcgQEAKPiAgICoganVzdCBwcm92aWRl IGFkZGl0aW9uYWwgaG9va3MgdG8gZ2V0IHRoZSBkZXNpcmVkIG91dHB1dCBhdCB0aGUgZW5kIG9m IHRoZQo+ICAgKiBlbmNvZGVyIGNoYWluLgo+ICAgKgo+IC0gKiBCcmlkZ2VzIGNhbiBhbHNvIGJl IGNoYWluZWQgdXAgdXNpbmcgdGhlICZkcm1fYnJpZGdlLm5leHQgcG9pbnRlci4KPiArICogQnJp ZGdlcyBjYW4gYWxzbyBiZSBjaGFpbmVkIHVwIHVzaW5nIHRoZSAmZHJtX2JyaWRnZS5jaGFpbl9u b2RlIGZpZWxkLgo+ICAgKgo+ICAgKiBCb3RoIGxlZ2FjeSBDUlRDIGhlbHBlcnMgYW5kIHRoZSBu ZXcgYXRvbWljIG1vZGVzZXQgaGVscGVycyBzdXBwb3J0IGJyaWRnZXMuCj4gICAqLwo+IEBAIC0x MTQsNiArMTE0LDcgQEAgRVhQT1JUX1NZTUJPTChkcm1fYnJpZGdlX3JlbW92ZSk7Cj4gIGludCBk cm1fYnJpZGdlX2F0dGFjaChzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVjdCBkcm1f YnJpZGdlICpicmlkZ2UsCj4gIAkJICAgICAgc3RydWN0IGRybV9icmlkZ2UgKnByZXZpb3VzKQo+ ICB7Cj4gKwlMSVNUX0hFQUQodG1wX2xpc3QpOwo+ICAJaW50IHJldDsKPiAgCj4gIAlpZiAoIWVu Y29kZXIgfHwgIWJyaWRnZSkKPiBAQCAtMTI3LDYgKzEyOCw3IEBAIGludCBkcm1fYnJpZGdlX2F0 dGFjaChzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVjdCBkcm1fYnJpZGdlICpicmlk Z2UsCj4gIAo+ICAJYnJpZGdlLT5kZXYgPSBlbmNvZGVyLT5kZXY7Cj4gIAlicmlkZ2UtPmVuY29k ZXIgPSBlbmNvZGVyOwo+ICsJbGlzdF9hZGRfdGFpbCgmYnJpZGdlLT5jaGFpbl9ub2RlLCAmdG1w X2xpc3QpOwoKQ291bGRuJ3Qgd2Ugc2ltcGxpZnkgdGhpcyBieSBhZGRpbmcgdGhlIGJyaWRnZSB0 byB0aGUgbGlzdCBoZXJlID8gV2UKd291bGQgbmVlZCB0byByZW1vdmUgaXQgaW4gdGhlIGVycm9y IHBhdGggb2YgdGhlIGF0dGFjaCBvcGVyYXRpb24KdGhvdWdoLCBidXQgd291bGRuJ3QgaXQgbWFr ZSB0aGUgY29kZSBlYXNpZXIgdG8gcmVhZCwgYW5kIG1vcmUgZWZmaWNpZW50CmluIHRoZSBtb3N0 IGxpa2VseSBwYXRoID8KCj4gIAo+ICAJaWYgKGJyaWRnZS0+ZnVuY3MtPmF0dGFjaCkgewo+ICAJ CXJldCA9IGJyaWRnZS0+ZnVuY3MtPmF0dGFjaChicmlkZ2UpOwo+IEBAIC0xMzgsOSArMTQwLDkg QEAgaW50IGRybV9icmlkZ2VfYXR0YWNoKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlciwgc3Ry dWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKPiAgCX0KPiAgCj4gIAlpZiAocHJldmlvdXMpCj4gLQkJ cHJldmlvdXMtPm5leHQgPSBicmlkZ2U7Cj4gKwkJbGlzdF9zcGxpY2UoJnRtcF9saXN0LCAmcHJl dmlvdXMtPmNoYWluX25vZGUpOwo+ICAJZWxzZQo+IC0JCWVuY29kZXItPmJyaWRnZSA9IGJyaWRn ZTsKPiArCQlsaXN0X3NwbGljZSgmdG1wX2xpc3QsICZlbmNvZGVyLT5icmlkZ2VfY2hhaW4pOwo+ ICAKPiAgCXJldHVybiAwOwo+ICB9Cj4gQEAgLTE1Nyw2ICsxNTksNyBAQCB2b2lkIGRybV9icmlk Z2VfZGV0YWNoKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpCj4gIAlpZiAoYnJpZGdlLT5mdW5j cy0+ZGV0YWNoKQo+ICAJCWJyaWRnZS0+ZnVuY3MtPmRldGFjaChicmlkZ2UpOwo+ICAKPiArCWxp c3RfZGVsKCZicmlkZ2UtPmNoYWluX25vZGUpOwo+ICAJYnJpZGdlLT5kZXYgPSBOVUxMOwo+ICB9 Cj4gIAo+IEBAIC0xOTAsMTggKzE5MywyMiBAQCBib29sIGRybV9icmlkZ2VfY2hhaW5fbW9kZV9m aXh1cChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICAJCQkJIGNvbnN0IHN0cnVjdCBkcm1f ZGlzcGxheV9tb2RlICptb2RlLAo+ICAJCQkJIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1 c3RlZF9tb2RlKQo+ICB7Cj4gLQlib29sIHJldCA9IHRydWU7Cj4gKwlzdHJ1Y3QgZHJtX2VuY29k ZXIgKmVuY29kZXI7Cj4gIAo+ICAJaWYgKCFicmlkZ2UpCj4gIAkJcmV0dXJuIHRydWU7Cj4gIAo+ IC0JaWYgKGJyaWRnZS0+ZnVuY3MtPm1vZGVfZml4dXApCj4gLQkJcmV0ID0gYnJpZGdlLT5mdW5j cy0+bW9kZV9maXh1cChicmlkZ2UsIG1vZGUsIGFkanVzdGVkX21vZGUpOwo+ICsJZW5jb2RlciA9 IGJyaWRnZS0+ZW5jb2RlcjsKPiArCWxpc3RfZm9yX2VhY2hfZW50cnlfZnJvbShicmlkZ2UsICZl bmNvZGVyLT5icmlkZ2VfY2hhaW4sCj4gKwkJCQkgY2hhaW5fbm9kZSkgewo+ICsJCWlmICghYnJp ZGdlLT5mdW5jcy0+bW9kZV9maXh1cCkKPiArCQkJY29udGludWU7Cj4gIAo+IC0JcmV0ID0gcmV0 ICYmIGRybV9icmlkZ2VfY2hhaW5fbW9kZV9maXh1cChicmlkZ2UtPm5leHQsIG1vZGUsCj4gLQkJ CQkJCSBhZGp1c3RlZF9tb2RlKTsKPiArCQlpZiAoIWJyaWRnZS0+ZnVuY3MtPm1vZGVfZml4dXAo YnJpZGdlLCBtb2RlLCBhZGp1c3RlZF9tb2RlKSkKPiArCQkJcmV0dXJuIGZhbHNlOwo+ICsJfQo+ ICAKPiAtCXJldHVybiByZXQ7Cj4gKwlyZXR1cm4gdHJ1ZTsKPiAgfQo+ICBFWFBPUlRfU1lNQk9M KGRybV9icmlkZ2VfY2hhaW5fbW9kZV9maXh1cCk7Cj4gIAo+IEBAIC0yMjQsMTggKzIzMSwyNCBA QCBlbnVtIGRybV9tb2RlX3N0YXR1cwo+ICBkcm1fYnJpZGdlX2NoYWluX21vZGVfdmFsaWQoc3Ry dWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKPiAgCQkJICAgIGNvbnN0IHN0cnVjdCBkcm1fZGlzcGxh eV9tb2RlICptb2RlKQo+ICB7Cj4gLQllbnVtIGRybV9tb2RlX3N0YXR1cyByZXQgPSBNT0RFX09L Owo+ICsJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyOwo+ICAKPiAgCWlmICghYnJpZGdlKQo+ IC0JCXJldHVybiByZXQ7Cj4gKwkJcmV0dXJuIE1PREVfT0s7Cj4gKwo+ICsJZW5jb2RlciA9IGJy aWRnZS0+ZW5jb2RlcjsKPiArCWxpc3RfZm9yX2VhY2hfZW50cnlfZnJvbShicmlkZ2UsICZlbmNv ZGVyLT5icmlkZ2VfY2hhaW4sIGNoYWluX25vZGUpIHsKPiArCQllbnVtIGRybV9tb2RlX3N0YXR1 cyByZXQ7Cj4gKwo+ICsJCWlmICghYnJpZGdlLT5mdW5jcy0+bW9kZV92YWxpZCkKPiArCQkJY29u dGludWU7Cj4gIAo+IC0JaWYgKGJyaWRnZS0+ZnVuY3MtPm1vZGVfdmFsaWQpCj4gIAkJcmV0ID0g YnJpZGdlLT5mdW5jcy0+bW9kZV92YWxpZChicmlkZ2UsIG1vZGUpOwo+ICsJCWlmIChyZXQgIT0g TU9ERV9PSykKPiArCQkJcmV0dXJuIHJldDsKPiArCX0KPiAgCj4gLQlpZiAocmV0ICE9IE1PREVf T0spCj4gLQkJcmV0dXJuIHJldDsKPiAtCj4gLQlyZXR1cm4gZHJtX2JyaWRnZV9jaGFpbl9tb2Rl X3ZhbGlkKGJyaWRnZS0+bmV4dCwgbW9kZSk7Cj4gKwlyZXR1cm4gTU9ERV9PSzsKPiAgfQo+ICBF WFBPUlRfU1lNQk9MKGRybV9icmlkZ2VfY2hhaW5fbW9kZV92YWxpZCk7Cj4gIAo+IEBAIC0yNTEs MTMgKzI2NCwyMCBAQCBFWFBPUlRfU1lNQk9MKGRybV9icmlkZ2VfY2hhaW5fbW9kZV92YWxpZCk7 Cj4gICAqLwo+ICB2b2lkIGRybV9icmlkZ2VfY2hhaW5fZGlzYWJsZShzdHJ1Y3QgZHJtX2JyaWRn ZSAqYnJpZGdlKQo+ICB7Cj4gKwlzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXI7Cj4gKwlzdHJ1 Y3QgZHJtX2JyaWRnZSAqaXRlcjsKPiArCj4gIAlpZiAoIWJyaWRnZSkKPiAgCQlyZXR1cm47Cj4g IAo+IC0JZHJtX2JyaWRnZV9jaGFpbl9kaXNhYmxlKGJyaWRnZS0+bmV4dCk7Cj4gKwllbmNvZGVy ID0gYnJpZGdlLT5lbmNvZGVyOwo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeV9yZXZlcnNlKGl0ZXIs ICZlbmNvZGVyLT5icmlkZ2VfY2hhaW4sIGNoYWluX25vZGUpIHsKPiArCQlpZiAoaXRlci0+ZnVu Y3MtPmRpc2FibGUpCj4gKwkJCWl0ZXItPmZ1bmNzLT5kaXNhYmxlKGl0ZXIpOwo+ICAKPiAtCWlm IChicmlkZ2UtPmZ1bmNzLT5kaXNhYmxlKQo+IC0JCWJyaWRnZS0+ZnVuY3MtPmRpc2FibGUoYnJp ZGdlKTsKPiArCQlpZiAoaXRlciA9PSBicmlkZ2UpCj4gKwkJCWJyZWFrOwo+ICsJfQo+ICB9Cj4g IEVYUE9SVF9TWU1CT0woZHJtX2JyaWRnZV9jaGFpbl9kaXNhYmxlKTsKPiAgCj4gQEAgLTI3NCwx MyArMjk0LDE2IEBAIEVYUE9SVF9TWU1CT0woZHJtX2JyaWRnZV9jaGFpbl9kaXNhYmxlKTsKPiAg ICovCj4gIHZvaWQgZHJtX2JyaWRnZV9jaGFpbl9wb3N0X2Rpc2FibGUoc3RydWN0IGRybV9icmlk Z2UgKmJyaWRnZSkKPiAgewo+ICsJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyOwo+ICsKPiAg CWlmICghYnJpZGdlKQo+ICAJCXJldHVybjsKPiAgCj4gLQlpZiAoYnJpZGdlLT5mdW5jcy0+cG9z dF9kaXNhYmxlKQo+IC0JCWJyaWRnZS0+ZnVuY3MtPnBvc3RfZGlzYWJsZShicmlkZ2UpOwo+IC0K PiAtCWRybV9icmlkZ2VfY2hhaW5fcG9zdF9kaXNhYmxlKGJyaWRnZS0+bmV4dCk7Cj4gKwllbmNv ZGVyID0gYnJpZGdlLT5lbmNvZGVyOwo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeV9mcm9tKGJyaWRn ZSwgJmVuY29kZXItPmJyaWRnZV9jaGFpbiwgY2hhaW5fbm9kZSkgewo+ICsJCWlmIChicmlkZ2Ut PmZ1bmNzLT5wb3N0X2Rpc2FibGUpCj4gKwkJCWJyaWRnZS0+ZnVuY3MtPnBvc3RfZGlzYWJsZShi cmlkZ2UpOwo+ICsJfQo+ICB9Cj4gIEVYUE9SVF9TWU1CT0woZHJtX2JyaWRnZV9jaGFpbl9wb3N0 X2Rpc2FibGUpOwo+ICAKPiBAQCAtMzAwLDEzICszMjMsMTYgQEAgdm9pZCBkcm1fYnJpZGdlX2No YWluX21vZGVfc2V0KHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4gIAkJCSAgICAgICBjb25z dCBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSwKPiAgCQkJICAgICAgIGNvbnN0IHN0cnVj dCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9tb2RlKQo+ICB7Cj4gKwlzdHJ1Y3QgZHJtX2Vu Y29kZXIgKmVuY29kZXI7Cj4gKwo+ICAJaWYgKCFicmlkZ2UpCj4gIAkJcmV0dXJuOwo+ICAKPiAt CWlmIChicmlkZ2UtPmZ1bmNzLT5tb2RlX3NldCkKPiAtCQlicmlkZ2UtPmZ1bmNzLT5tb2RlX3Nl dChicmlkZ2UsIG1vZGUsIGFkanVzdGVkX21vZGUpOwo+IC0KPiAtCWRybV9icmlkZ2VfY2hhaW5f bW9kZV9zZXQoYnJpZGdlLT5uZXh0LCBtb2RlLCBhZGp1c3RlZF9tb2RlKTsKPiArCWVuY29kZXIg PSBicmlkZ2UtPmVuY29kZXI7Cj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X2Zyb20oYnJpZGdlLCAm ZW5jb2Rlci0+YnJpZGdlX2NoYWluLCBjaGFpbl9ub2RlKSB7Cj4gKwkJaWYgKGJyaWRnZS0+ZnVu Y3MtPm1vZGVfc2V0KQo+ICsJCQlicmlkZ2UtPmZ1bmNzLT5tb2RlX3NldChicmlkZ2UsIG1vZGUs IGFkanVzdGVkX21vZGUpOwo+ICsJfQo+ICB9Cj4gIEVYUE9SVF9TWU1CT0woZHJtX2JyaWRnZV9j aGFpbl9tb2RlX3NldCk7Cj4gIAo+IEBAIC0zMjMsMTMgKzM0OSwxNyBAQCBFWFBPUlRfU1lNQk9M KGRybV9icmlkZ2VfY2hhaW5fbW9kZV9zZXQpOwo+ICAgKi8KPiAgdm9pZCBkcm1fYnJpZGdlX2No YWluX3ByZV9lbmFibGUoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSkKPiAgewo+ICsJc3RydWN0 IGRybV9lbmNvZGVyICplbmNvZGVyOwo+ICsJc3RydWN0IGRybV9icmlkZ2UgKml0ZXI7CgpZb3Ug Y291bGQgcmV1c2UgdGhlIGJyaWRnZSBwYXJhbWV0ZXIgaW5zdGVhZCBvZiBkZWNsYXJpbmcgYSBs b2NhbAp2YXJpYWJsZSwgdGhlIHNhbWUgd2F5IHlvdSBkbyBpbiBkcm1fYXRvbWljX2JyaWRnZV9j aGFpbl9lbmFibGUoKS4KCj4gKwo+ICAJaWYgKCFicmlkZ2UpCj4gIAkJcmV0dXJuOwo+ICAKPiAt CWRybV9icmlkZ2VfY2hhaW5fcHJlX2VuYWJsZShicmlkZ2UtPm5leHQpOwo+IC0KPiAtCWlmIChi cmlkZ2UtPmZ1bmNzLT5wcmVfZW5hYmxlKQo+IC0JCWJyaWRnZS0+ZnVuY3MtPnByZV9lbmFibGUo YnJpZGdlKTsKPiArCWVuY29kZXIgPSBicmlkZ2UtPmVuY29kZXI7Cj4gKwlsaXN0X2Zvcl9lYWNo X2VudHJ5X3JldmVyc2UoaXRlciwgJmVuY29kZXItPmJyaWRnZV9jaGFpbiwgY2hhaW5fbm9kZSkg ewo+ICsJCWlmIChpdGVyLT5mdW5jcy0+cHJlX2VuYWJsZSkKPiArCQkJaXRlci0+ZnVuY3MtPnBy ZV9lbmFibGUoaXRlcik7CgpPciBhcmUgeW91IG1pc3NpbmcgdGhlIGl0ZXIgPT0gYnJpZGdlIGNo ZWNrID8KCj4gKwl9Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChkcm1fYnJpZGdlX2NoYWluX3ByZV9l bmFibGUpOwo+ICAKPiBAQCAtMzQ1LDEzICszNzUsMTYgQEAgRVhQT1JUX1NZTUJPTChkcm1fYnJp ZGdlX2NoYWluX3ByZV9lbmFibGUpOwo+ICAgKi8KPiAgdm9pZCBkcm1fYnJpZGdlX2NoYWluX2Vu YWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQo+ICB7Cj4gKwlzdHJ1Y3QgZHJtX2VuY29k ZXIgKmVuY29kZXI7Cj4gKwo+ICAJaWYgKCFicmlkZ2UpCj4gIAkJcmV0dXJuOwo+ICAKPiAtCWlm IChicmlkZ2UtPmZ1bmNzLT5lbmFibGUpCj4gLQkJYnJpZGdlLT5mdW5jcy0+ZW5hYmxlKGJyaWRn ZSk7Cj4gLQo+IC0JZHJtX2JyaWRnZV9jaGFpbl9lbmFibGUoYnJpZGdlLT5uZXh0KTsKPiArCWVu Y29kZXIgPSBicmlkZ2UtPmVuY29kZXI7Cj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X2Zyb20oYnJp ZGdlLCAmZW5jb2Rlci0+YnJpZGdlX2NoYWluLCBjaGFpbl9ub2RlKSB7Cj4gKwkJaWYgKGJyaWRn ZS0+ZnVuY3MtPmVuYWJsZSkKPiArCQkJYnJpZGdlLT5mdW5jcy0+ZW5hYmxlKGJyaWRnZSk7Cj4g Kwl9Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChkcm1fYnJpZGdlX2NoYWluX2VuYWJsZSk7Cj4gIAo+ IEBAIC0zNzAsMTUgKzQwMywyMyBAQCBFWFBPUlRfU1lNQk9MKGRybV9icmlkZ2VfY2hhaW5fZW5h YmxlKTsKPiAgdm9pZCBkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9kaXNhYmxlKHN0cnVjdCBkcm1f YnJpZGdlICpicmlkZ2UsCj4gIAkJCQkgICAgIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0 ZSkKPiAgewo+ICsJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyOwo+ICsJc3RydWN0IGRybV9i cmlkZ2UgKml0ZXI7Cj4gKwo+ICAJaWYgKCFicmlkZ2UpCj4gIAkJcmV0dXJuOwo+ICAKPiAtCWRy bV9hdG9taWNfYnJpZGdlX2NoYWluX2Rpc2FibGUoYnJpZGdlLT5uZXh0LCBzdGF0ZSk7Cj4gKwll bmNvZGVyID0gYnJpZGdlLT5lbmNvZGVyOwo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeV9yZXZlcnNl KGl0ZXIsICZlbmNvZGVyLT5icmlkZ2VfY2hhaW4sCj4gKwkJCQkgICAgY2hhaW5fbm9kZSkgewoK VGhpcyBjYW4gaG9sZCBvbiBhIHNpbmdsZSBsaW5lLgoKPiArCQlpZiAoaXRlci0+ZnVuY3MtPmF0 b21pY19kaXNhYmxlKQo+ICsJCQlpdGVyLT5mdW5jcy0+YXRvbWljX2Rpc2FibGUoaXRlciwgc3Rh dGUpOwo+ICsJCWVsc2UgaWYgKGl0ZXItPmZ1bmNzLT5kaXNhYmxlKQo+ICsJCQlpdGVyLT5mdW5j cy0+ZGlzYWJsZShpdGVyKTsKPiAgCj4gLQlpZiAoYnJpZGdlLT5mdW5jcy0+YXRvbWljX2Rpc2Fi bGUpCj4gLQkJYnJpZGdlLT5mdW5jcy0+YXRvbWljX2Rpc2FibGUoYnJpZGdlLCBzdGF0ZSk7Cj4g LQllbHNlIGlmIChicmlkZ2UtPmZ1bmNzLT5kaXNhYmxlKQo+IC0JCWJyaWRnZS0+ZnVuY3MtPmRp c2FibGUoYnJpZGdlKTsKPiArCQlpZiAoaXRlciA9PSBicmlkZ2UpCj4gKwkJCWJyZWFrOwo+ICsJ fQo+ICB9Cj4gIEVYUE9SVF9TWU1CT0woZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fZGlzYWJsZSk7 Cj4gIAo+IEBAIC0zOTgsMTUgKzQzOSwxOSBAQCBFWFBPUlRfU1lNQk9MKGRybV9hdG9taWNfYnJp ZGdlX2NoYWluX2Rpc2FibGUpOwo+ICB2b2lkIGRybV9hdG9taWNfYnJpZGdlX2NoYWluX3Bvc3Rf ZGlzYWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICAJCQkJCSAgc3RydWN0IGRybV9h dG9taWNfc3RhdGUgKnN0YXRlKQo+ICB7Cj4gKwlzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXI7 Cj4gKwo+ICAJaWYgKCFicmlkZ2UpCj4gIAkJcmV0dXJuOwo+ICAKPiAtCWlmIChicmlkZ2UtPmZ1 bmNzLT5hdG9taWNfcG9zdF9kaXNhYmxlKQo+IC0JCWJyaWRnZS0+ZnVuY3MtPmF0b21pY19wb3N0 X2Rpc2FibGUoYnJpZGdlLCBzdGF0ZSk7Cj4gLQllbHNlIGlmIChicmlkZ2UtPmZ1bmNzLT5wb3N0 X2Rpc2FibGUpCj4gLQkJYnJpZGdlLT5mdW5jcy0+cG9zdF9kaXNhYmxlKGJyaWRnZSk7Cj4gLQo+ IC0JZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fcG9zdF9kaXNhYmxlKGJyaWRnZS0+bmV4dCwgc3Rh dGUpOwo+ICsJZW5jb2RlciA9IGJyaWRnZS0+ZW5jb2RlcjsKPiArCWxpc3RfZm9yX2VhY2hfZW50 cnlfZnJvbShicmlkZ2UsICZlbmNvZGVyLT5icmlkZ2VfY2hhaW4sCj4gKwkJCQkgY2hhaW5fbm9k ZSkgewoKVGhpcyB0b28gY2FuIGhvbGQgb24gYSBzaW5nbGUgbGluZS4KCj4gKwkJaWYgKGJyaWRn ZS0+ZnVuY3MtPmF0b21pY19wb3N0X2Rpc2FibGUpCj4gKwkJCWJyaWRnZS0+ZnVuY3MtPmF0b21p Y19wb3N0X2Rpc2FibGUoYnJpZGdlLCBzdGF0ZSk7Cj4gKwkJZWxzZSBpZiAoYnJpZGdlLT5mdW5j cy0+cG9zdF9kaXNhYmxlKQo+ICsJCQlicmlkZ2UtPmZ1bmNzLT5wb3N0X2Rpc2FibGUoYnJpZGdl KTsKPiArCX0KPiAgfQo+ICBFWFBPUlRfU1lNQk9MKGRybV9hdG9taWNfYnJpZGdlX2NoYWluX3Bv c3RfZGlzYWJsZSk7Cj4gIAo+IEBAIC00MjYsMTUgKzQ3MSwyMyBAQCBFWFBPUlRfU1lNQk9MKGRy bV9hdG9taWNfYnJpZGdlX2NoYWluX3Bvc3RfZGlzYWJsZSk7Cj4gIHZvaWQgZHJtX2F0b21pY19i cmlkZ2VfY2hhaW5fcHJlX2VuYWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICAJCQkJ CXN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKPiAgewo+ICsJc3RydWN0IGRybV9lbmNv ZGVyICplbmNvZGVyOwo+ICsJc3RydWN0IGRybV9icmlkZ2UgKml0ZXI7Cj4gKwo+ICAJaWYgKCFi cmlkZ2UpCj4gIAkJcmV0dXJuOwo+ICAKPiAtCWRybV9hdG9taWNfYnJpZGdlX2NoYWluX3ByZV9l bmFibGUoYnJpZGdlLT5uZXh0LCBzdGF0ZSk7Cj4gKwllbmNvZGVyID0gYnJpZGdlLT5lbmNvZGVy Owo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeV9yZXZlcnNlKGl0ZXIsICZicmlkZ2UtPmVuY29kZXIt PmJyaWRnZV9jaGFpbiwKPiArCQkJCSAgICBjaGFpbl9ub2RlKSB7CgpBcyBOZWlsIHBvaW50ZWQg b3V0LCAmZW5jb2Rlci0+YnJpZGdlX2NoYWluLgoKPiArCQlpZiAoaXRlci0+ZnVuY3MtPmF0b21p Y19wcmVfZW5hYmxlKQo+ICsJCQlpdGVyLT5mdW5jcy0+YXRvbWljX3ByZV9lbmFibGUoaXRlciwg c3RhdGUpOwo+ICsJCWVsc2UgaWYgKGl0ZXItPmZ1bmNzLT5wcmVfZW5hYmxlKQo+ICsJCQlpdGVy LT5mdW5jcy0+cHJlX2VuYWJsZShpdGVyKTsKPiAgCj4gLQlpZiAoYnJpZGdlLT5mdW5jcy0+YXRv bWljX3ByZV9lbmFibGUpCj4gLQkJYnJpZGdlLT5mdW5jcy0+YXRvbWljX3ByZV9lbmFibGUoYnJp ZGdlLCBzdGF0ZSk7Cj4gLQllbHNlIGlmIChicmlkZ2UtPmZ1bmNzLT5wcmVfZW5hYmxlKQo+IC0J CWJyaWRnZS0+ZnVuY3MtPnByZV9lbmFibGUoYnJpZGdlKTsKPiArCQlpZiAoaXRlciA9PSBicmlk Z2UpCj4gKwkJCWJyZWFrOwo+ICsJfQo+ICB9Cj4gIEVYUE9SVF9TWU1CT0woZHJtX2F0b21pY19i cmlkZ2VfY2hhaW5fcHJlX2VuYWJsZSk7Cj4gIAo+IEBAIC00NTMsMTUgKzUwNiwxOSBAQCBFWFBP UlRfU1lNQk9MKGRybV9hdG9taWNfYnJpZGdlX2NoYWluX3ByZV9lbmFibGUpOwo+ICB2b2lkIGRy bV9hdG9taWNfYnJpZGdlX2NoYWluX2VuYWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ ICAJCQkJICAgIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKPiAgewo+ICsJc3RydWN0 IGRybV9lbmNvZGVyICplbmNvZGVyOwo+ICsKPiAgCWlmICghYnJpZGdlKQo+ICAJCXJldHVybjsK PiAgCj4gLQlpZiAoYnJpZGdlLT5mdW5jcy0+YXRvbWljX2VuYWJsZSkKPiAtCQlicmlkZ2UtPmZ1 bmNzLT5hdG9taWNfZW5hYmxlKGJyaWRnZSwgc3RhdGUpOwo+IC0JZWxzZSBpZiAoYnJpZGdlLT5m dW5jcy0+ZW5hYmxlKQo+IC0JCWJyaWRnZS0+ZnVuY3MtPmVuYWJsZShicmlkZ2UpOwo+IC0KPiAt CWRybV9hdG9taWNfYnJpZGdlX2NoYWluX2VuYWJsZShicmlkZ2UtPm5leHQsIHN0YXRlKTsKPiAr CWVuY29kZXIgPSBicmlkZ2UtPmVuY29kZXI7Cj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X2Zyb20o YnJpZGdlLCAmYnJpZGdlLT5lbmNvZGVyLT5icmlkZ2VfY2hhaW4sCgpIZXJlIHRvby4KCkJ5IHRo ZSB3YXksIHNob3VsZCB0aGVzZSBicmlkZ2UgY2hhaW4gZnVuY3Rpb25zIHRha2UgYW4gZW5jb2Rl ciBpbnN0ZWFkCm9mIGEgYnJpZGdlIChpbiBhIHNlcGFyYXRlIHBhdGNoIHNlcmllcyBwcm9iYWJs eSkgPwoKPiArCQkJCSBjaGFpbl9ub2RlKSB7Cj4gKwkJaWYgKGJyaWRnZS0+ZnVuY3MtPmF0b21p Y19lbmFibGUpCj4gKwkJCWJyaWRnZS0+ZnVuY3MtPmF0b21pY19lbmFibGUoYnJpZGdlLCBzdGF0 ZSk7Cj4gKwkJZWxzZSBpZiAoYnJpZGdlLT5mdW5jcy0+ZW5hYmxlKQo+ICsJCQlicmlkZ2UtPmZ1 bmNzLT5lbmFibGUoYnJpZGdlKTsKPiArCX0KPiAgfQo+ICBFWFBPUlRfU1lNQk9MKGRybV9hdG9t aWNfYnJpZGdlX2NoYWluX2VuYWJsZSk7Cj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vZHJtX2VuY29kZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZW5jb2Rlci5jCj4gaW5kZXgg NGZlOWU3MjNlMjI3Li5lNTU1MjgxZjQzZDQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2RybV9lbmNvZGVyLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2VuY29kZXIuYwo+IEBA IC0xNDAsNiArMTQwLDcgQEAgaW50IGRybV9lbmNvZGVyX2luaXQoc3RydWN0IGRybV9kZXZpY2Ug KmRldiwKPiAgCQlnb3RvIG91dF9wdXQ7Cj4gIAl9Cj4gIAo+ICsJSU5JVF9MSVNUX0hFQUQoJmVu Y29kZXItPmJyaWRnZV9jaGFpbik7Cj4gIAlsaXN0X2FkZF90YWlsKCZlbmNvZGVyLT5oZWFkLCAm ZGV2LT5tb2RlX2NvbmZpZy5lbmNvZGVyX2xpc3QpOwo+ICAJZW5jb2Rlci0+aW5kZXggPSBkZXYt Pm1vZGVfY29uZmlnLm51bV9lbmNvZGVyKys7Cj4gIAo+IEBAIC0xNjAsMjMgKzE2MSwxNiBAQCBF WFBPUlRfU1lNQk9MKGRybV9lbmNvZGVyX2luaXQpOwo+ICB2b2lkIGRybV9lbmNvZGVyX2NsZWFu dXAoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyKQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2ID0gZW5jb2Rlci0+ZGV2Owo+ICsJc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSwgKm5l eHQ7Cj4gIAo+ICAJLyogTm90ZSB0aGF0IHRoZSBlbmNvZGVyX2xpc3QgaXMgY29uc2lkZXJlZCB0 byBiZSBzdGF0aWM7IHNob3VsZCB3ZQo+ICAJICogcmVtb3ZlIHRoZSBkcm1fZW5jb2RlciBhdCBy dW50aW1lIHdlIHdvdWxkIGhhdmUgdG8gZGVjcmVtZW50IGFsbAo+ICAJICogdGhlIGluZGljZXMg b24gdGhlIGRybV9lbmNvZGVyIGFmdGVyIHVzIGluIHRoZSBlbmNvZGVyX2xpc3QuCj4gIAkgKi8K PiAgCj4gLQlpZiAoZW5jb2Rlci0+YnJpZGdlKSB7Cj4gLQkJc3RydWN0IGRybV9icmlkZ2UgKmJy aWRnZTsKPiAtCQlzdHJ1Y3QgZHJtX2JyaWRnZSAqbmV4dDsKPiAtCj4gLQkJYnJpZGdlID0gZHJt X2JyaWRnZV9jaGFpbl9nZXRfZmlyc3RfYnJpZGdlKGVuY29kZXIpOwo+IC0JCXdoaWxlIChicmlk Z2UpIHsKPiAtCQkJbmV4dCA9IGJyaWRnZS0+bmV4dDsKPiAtCQkJZHJtX2JyaWRnZV9kZXRhY2go YnJpZGdlKTsKPiAtCQkJYnJpZGdlID0gbmV4dDsKPiAtCQl9Cj4gLQl9Cj4gKwlsaXN0X2Zvcl9l YWNoX2VudHJ5X3NhZmUoYnJpZGdlLCBuZXh0LCAmZW5jb2Rlci0+YnJpZGdlX2NoYWluLAo+ICsJ CQkJIGNoYWluX25vZGUpCj4gKwkJZHJtX2JyaWRnZV9kZXRhY2goYnJpZGdlKTsKPiAgCj4gIAlk cm1fbW9kZV9vYmplY3RfdW5yZWdpc3RlcihkZXYsICZlbmNvZGVyLT5iYXNlKTsKPiAgCWtmcmVl KGVuY29kZXItPm5hbWUpOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgg Yi9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgKPiBpbmRleCAyN2VlZjYzY2UwZmYuLjNhYjE2Yzk1 ZTU5ZSAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgKPiArKysgYi9pbmNs dWRlL2RybS9kcm1fYnJpZGdlLmgKPiBAQCAtMzg0LDggKzM4NCw4IEBAIHN0cnVjdCBkcm1fYnJp ZGdlIHsKPiAgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXY7Cj4gIAkvKiogQGVuY29kZXI6IGVuY29k ZXIgdG8gd2hpY2ggdGhpcyBicmlkZ2UgaXMgY29ubmVjdGVkICovCj4gIAlzdHJ1Y3QgZHJtX2Vu Y29kZXIgKmVuY29kZXI7Cj4gLQkvKiogQG5leHQ6IHRoZSBuZXh0IGJyaWRnZSBpbiB0aGUgZW5j b2RlciBjaGFpbiAqLwo+IC0Jc3RydWN0IGRybV9icmlkZ2UgKm5leHQ7Cj4gKwkvKiogQGNoYWlu X25vZGU6IHVzZWQgdG8gZm9ybSBhIGJyaWRnZSBjaGFpbiAqLwo+ICsJc3RydWN0IGxpc3RfaGVh ZCBjaGFpbl9ub2RlOwo+ICAjaWZkZWYgQ09ORklHX09GCj4gIAkvKiogQG9mX25vZGU6IGRldmlj ZSBub2RlIHBvaW50ZXIgdG8gdGhlIGJyaWRnZSAqLwo+ICAJc3RydWN0IGRldmljZV9ub2RlICpv Zl9ub2RlOwo+IEBAIC00MjAsNyArNDIwLDEwIEBAIGludCBkcm1fYnJpZGdlX2F0dGFjaChzdHJ1 Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsIHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4gIHN0 YXRpYyBpbmxpbmUgc3RydWN0IGRybV9icmlkZ2UgKgo+ICBkcm1fYnJpZGdlX2NoYWluX2dldF9u ZXh0X2JyaWRnZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQo+ICB7Cj4gLQlyZXR1cm4gYnJp ZGdlLT5uZXh0Owo+ICsJaWYgKGxpc3RfaXNfbGFzdCgmYnJpZGdlLT5jaGFpbl9ub2RlLCAmYnJp ZGdlLT5lbmNvZGVyLT5icmlkZ2VfY2hhaW4pKQo+ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCXJl dHVybiBsaXN0X25leHRfZW50cnkoYnJpZGdlLCBjaGFpbl9ub2RlKTsKCkEgbGlzdF9uZXh0X2Vu dHJ5X29yX251bGwoKSB3b3VsZCBiZSB1c2VmdWwgaW4gbGlzdC5oIEkgdGhpbmsgKG9mIGNvdXJz ZQpub3QgYXMgYSBtYW5kYXRvcnkgcGFydCBvZiB0aGlzIHNlcmllcyA6LSkpLgoKPiAgfQo+ICAK PiAgLyoqCj4gQEAgLTQzNCw3ICs0MzcsOCBAQCBkcm1fYnJpZGdlX2NoYWluX2dldF9uZXh0X2Jy aWRnZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQo+ICBzdGF0aWMgaW5saW5lIHN0cnVjdCBk cm1fYnJpZGdlICoKPiAgZHJtX2JyaWRnZV9jaGFpbl9nZXRfZmlyc3RfYnJpZGdlKHN0cnVjdCBk cm1fZW5jb2RlciAqZW5jb2RlcikKPiAgewo+IC0JcmV0dXJuIGVuY29kZXItPmJyaWRnZTsKPiAr CXJldHVybiBsaXN0X2ZpcnN0X2VudHJ5X29yX251bGwoJmVuY29kZXItPmJyaWRnZV9jaGFpbiwK PiArCQkJCQlzdHJ1Y3QgZHJtX2JyaWRnZSwgY2hhaW5fbm9kZSk7Cj4gIH0KPiAgCj4gIGJvb2wg ZHJtX2JyaWRnZV9jaGFpbl9tb2RlX2ZpeHVwKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4g ZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9lbmNvZGVyLmggYi9pbmNsdWRlL2RybS9kcm1f ZW5jb2Rlci5oCj4gaW5kZXggZjA2MTY0ZjQ0ZWZlLi45YjNkZGUxNzdjODEgMTAwNjQ0Cj4gLS0t IGEvaW5jbHVkZS9kcm0vZHJtX2VuY29kZXIuaAo+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9lbmNv ZGVyLmgKPiBAQCAtMTcyLDcgKzE3MiwxNCBAQCBzdHJ1Y3QgZHJtX2VuY29kZXIgewo+ICAJICog JmRybV9jb25uZWN0b3Jfc3RhdGUuY3J0Yy4KPiAgCSAqLwo+ICAJc3RydWN0IGRybV9jcnRjICpj cnRjOwo+IC0Jc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZTsKPiArCj4gKwkvKioKPiArCSAqIEBi cmlkZ2VfY2hhaW46IEJyaWRnZXMgYXR0YWNoZWQgdG8gdGhpcyBlbmNvZGVyLiBUaGUgZmlyc3Qg ZW50cnkgb2YKPiArCSAqIHRoaXMgbGlzdCBpcyBhbHdheXMgJmRybV9lbmNvZGVyLmJyaWRnZS4g SXQgbWF5IGJlIGZvbGxvd2VkIGJ5IG90aGVyCgpUaGVyZSdzIG5vICZkcm1fZW5jb2Rlci5icmlk Z2UgYW55bW9yZSA6LSkKCldpdGggYWxsIHRob3NlIHNtYWxsIGlzc3VlcyBmaXhlZCwKClJldmll d2VkLWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0QGlkZWFzb25ib2FyZC5j b20+Cgo+ICsJICogYnJpZGdlIGVudGl0aWVzLgo+ICsJICovCj4gKwlzdHJ1Y3QgbGlzdF9oZWFk IGJyaWRnZV9jaGFpbjsKPiArCj4gIAljb25zdCBzdHJ1Y3QgZHJtX2VuY29kZXJfZnVuY3MgKmZ1 bmNzOwo+ICAJY29uc3Qgc3RydWN0IGRybV9lbmNvZGVyX2hlbHBlcl9mdW5jcyAqaGVscGVyX3By aXZhdGU7Cj4gIH07CgotLSAKUmVnYXJkcywKCkxhdXJlbnQgUGluY2hhcnQKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlz dApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs