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,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 E1C3DC432C3 for ; Tue, 3 Dec 2019 10:03:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9B54A206F0 for ; Tue, 3 Dec 2019 10:03:58 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="DJY8ufkN" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725829AbfLCKD6 (ORCPT ); Tue, 3 Dec 2019 05:03:58 -0500 Received: from perceval.ideasonboard.com ([213.167.242.64]:60786 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725774AbfLCKD5 (ORCPT ); Tue, 3 Dec 2019 05:03:57 -0500 Received: from pendragon.ideasonboard.com (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 11E68309; Tue, 3 Dec 2019 11:03:53 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1575367433; bh=3/xLxChbo21d7njmNVO3dxO/AVqF8OHA6a8m+W0+s4c=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=DJY8ufkNWZc9kjhvZgga8dKeicr9DGr6/FCJ48UhFhxgbIxKhgXfuUswHRakyQNOM 8AIGgk8bAUo1dzXGQXmF0KBFRDPxnF9a9uX7sn8aW2BVpkTf5sgED9UT5XzZ5WP+Zl Jk+/IHdCvob+VCxVEn0kpXOYu2qzPS8wU1s87tQ8= Date: Tue, 3 Dec 2019 12:03:45 +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 14/21] drm/bridge: Add the necessary bits to support bus format negotiation Message-ID: <20191203100345.GM4730@pendragon.ideasonboard.com> References: <20191023154512.9762-1-boris.brezillon@collabora.com> <20191023154512.9762-15-boris.brezillon@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <20191023154512.9762-15-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:45:05PM +0200, Boris Brezillon wrote: > drm_bridge_state is extended to describe the input and output bus > configuration. This bus configuration is exposed through the s/configuration/configurations/ s/This bus configuration is/These bus configurations are/ > drm_bus_cfg struct which contains 2 properties: the bus format and > the bus flags. > > Bus format negotiation is automated by the core, drivers just have > to implement the ->atomic_get_{output,input}_bus_fmts() hooks if they > want to take part to this negotiation. Negotiation happens in reserve s/reserve/reverse/ > order, starting from the last element of the chain (the one directly > connected to the display) up to the first element of the chain (the one > connected to the encoder). > During this negotiation all supported formats are tested until we find > one that works, meaning that the formats array should be in decreasing > preference order (assuming the driver has a preference order). > > Note that the bus format negotiation works even if some elements in the > chain don't implement the ->atomic_get_{output,input}_bus_fmts() hooks. > In that case, the core advertises only MEDIA_BUS_FMT_FIXED and let s/let/lets/ > the previous bridge element decide what to do (most of the time, bridge > drivers will pick a default bus format of extract this piece of s/of extract/or extract/ > information from somewhere else, like a FW property). > > Bus flags negotiation is left to drivers which can simply propagate the > flags from the input of the next bridge element if there's no conversion > done inside the bridge, or tweak them if the bridge does some kind of > signal inversion. > > Signed-off-by: Boris Brezillon > --- > Changes in v3: > * Fix the commit message (Reported by Laurent) > * Document the fact that bus formats should not be directly modified by > drivers (Suggested by Laurent) > * Document the fact that format order matters (Suggested by Laurent) > * Propagate bus flags by default > * Document the fact that drivers can tweak bus flags if needed > * Let ->atomic_get_{output,input}_bus_fmts() allocate the bus format > array (Suggested by Laurent) > * Add a drm_atomic_helper_bridge_propagate_bus_fmt() > * Mandate that bridge drivers return accurate input_fmts even if they > are known to be the first element in the bridge chain > > Changes in v2: > * Rework things to support more complex use cases > --- > drivers/gpu/drm/drm_bridge.c | 257 ++++++++++++++++++++++++++++++++++- > include/drm/drm_bridge.h | 106 +++++++++++++++ > 2 files changed, 362 insertions(+), 1 deletion(-) > > diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c > index 990e056296bd..6022fb3d406a 100644 > --- a/drivers/gpu/drm/drm_bridge.c > +++ b/drivers/gpu/drm/drm_bridge.c > @@ -641,13 +641,251 @@ static int drm_atomic_bridge_check(struct drm_bridge *bridge, > return 0; > } > > +static int select_bus_fmt_recursive(struct drm_bridge *first, s/first/first_bridge/ to make the code more explicit ? > + struct drm_bridge *cur, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 out_bus_fmt) > +{ > + struct drm_bridge_state *cur_state; > + unsigned int num_in_bus_fmts, i; > + struct drm_bridge *prev; > + u32 *in_bus_fmts; > + int ret; > + > + prev = drm_bridge_chain_get_prev_bridge(cur); > + cur_state = drm_atomic_get_new_bridge_state(crtc_state->state, cur); > + if (WARN_ON(!cur_state)) > + return -EINVAL; > + > + /* > + * Bus format negotiation is not supported by this bridge, let's pass s/Bus format/If bus format/ or move the comment within the if () block. > + * MEDIA_BUS_FMT_FIXED to the previous bridge in the chain and hope > + * that it can handle this situation gracefully (by providing > + * appropriate default values). > + */ > + if (!cur->funcs->atomic_get_input_bus_fmts) { > + if (cur != first) { > + ret = select_bus_fmt_recursive(first, prev, crtc_state, > + conn_state, > + MEDIA_BUS_FMT_FIXED); > + if (ret) > + return ret; > + } > + > + cur_state->input_bus_cfg.fmt = MEDIA_BUS_FMT_FIXED; > + cur_state->output_bus_cfg.fmt = out_bus_fmt; > + return 0; > + } > + > + in_bus_fmts = cur->funcs->atomic_get_input_bus_fmts(cur, cur_state, > + crtc_state, > + conn_state, > + out_bus_fmt, > + &num_in_bus_fmts); > + if (!num_in_bus_fmts) > + return -ENOTSUPP; > + else if (!in_bus_fmts) > + return -ENOMEM; > + > + if (first == cur) { > + cur_state->input_bus_cfg.fmt = in_bus_fmts[0]; > + cur_state->output_bus_cfg.fmt = out_bus_fmt; > + kfree(in_bus_fmts); > + return 0; > + } > + > + for (i = 0; i < num_in_bus_fmts; i++) { > + ret = select_bus_fmt_recursive(first, prev, crtc_state, > + conn_state, in_bus_fmts[i]); > + if (ret != -ENOTSUPP) > + break; > + } > + > + if (!ret) { > + cur_state->input_bus_cfg.fmt = in_bus_fmts[i]; > + cur_state->output_bus_cfg.fmt = out_bus_fmt; > + } > + > + kfree(in_bus_fmts); > + return ret; > +} > + > +/* > + * This function is called by &drm_atomic_bridge_chain_check() just before > + * calling &drm_bridge_funcs.atomic_check() on all elements of the chain. > + * It's providing bus format negotiation between bridge elements. The s/It's providing/It performs/ > + * negotiation happens in reverse order, starting from the last element in > + * the chain up to @bridge. > + * > + * Negotiation starts by retrieving supported output bus formats on the last > + * bridge element and testing them one by one. The test is recursive, meaning > + * that for each tested output format, the whole chain will be walked backward, > + * and each element will have to choose an input bus format that can be > + * transcoded to the requested output format. When a bridge element does not > + * support transcoding into a specific output format -ENOTSUPP is returned and > + * the next bridge element will have to try a different format. If none of the > + * combinations worked, -ENOTSUPP is returned and the atomic modeset will fail. > + * > + * This implementation is relying on > + * &drm_bridge_funcs.atomic_get_output_bus_fmts() and > + * &drm_bridge_funcs.atomic_get_input_bus_fmts() to gather supported > + * input/output formats. Blank line or reflow. > + * When &drm_bridge_funcs.atomic_get_output_bus_fmts() is not implemented by > + * the last element of the chain, &drm_atomic_bridge_chain_select_bus_fmts() > + * tries a single format: &drm_connector.display_info.bus_formats[0] if > + * available, MEDIA_BUS_FMT_FIXED otherwise. Blank line or reflow. > + * When &drm_bridge_funcs.atomic_get_input_bus_fmts() is not implemented, > + * &drm_atomic_bridge_chain_select_bus_fmts() skips the negotiation on the > + * bridge element that lacks this hook and asks the previous element in the > + * chain to try MEDIA_BUS_FMT_FIXED. It's up to bridge drivers to decide what > + * to do in that case (fail if they want to enforce bus format negotiation, or > + * provide a reasonable default if they need to support pipelines where not > + * all elements support bus format negotiation). > + */ > +static int > +drm_atomic_bridge_chain_select_bus_fmts(struct drm_bridge *bridge, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state) > +{ > + struct drm_connector *conn = conn_state->connector; > + struct drm_encoder *encoder = bridge->encoder; > + struct drm_bridge_state *last_bridge_state; > + unsigned int i, num_out_bus_fmts; > + struct drm_bridge *last_bridge; > + u32 *out_bus_fmts; > + int ret = 0; > + > + last_bridge = list_last_entry(&encoder->bridge_chain, > + struct drm_bridge, chain_node); > + last_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, > + last_bridge); > + if (WARN_ON(!last_bridge_state)) > + return -EINVAL; > + > + if (last_bridge->funcs->atomic_get_output_bus_fmts) { > + const struct drm_bridge_funcs *funcs = last_bridge->funcs; > + > + out_bus_fmts = funcs->atomic_get_output_bus_fmts(last_bridge, > + last_bridge_state, > + crtc_state, > + conn_state, > + &num_out_bus_fmts); > + if (!num_out_bus_fmts) > + return -ENOTSUPP; > + else if (!out_bus_fmts) > + return -ENOMEM; > + } else { > + num_out_bus_fmts = 1; > + out_bus_fmts = kzalloc(sizeof(*out_bus_fmts), GFP_KERNEL); kmalloc would do. > + if (!out_bus_fmts) > + return -ENOMEM; > + > + if (conn->display_info.num_bus_formats && > + conn->display_info.bus_formats) > + out_bus_fmts[0] = conn->display_info.bus_formats[0]; > + else > + out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED; > + } > + > + for (i = 0; i < num_out_bus_fmts; i++) { > + ret = select_bus_fmt_recursive(bridge, last_bridge, crtc_state, > + conn_state, out_bus_fmts[i]); > + if (ret != -ENOTSUPP) > + break; > + } > + > + kfree(out_bus_fmts); > + > + return ret; > +} > + > +static void > +drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge, > + struct drm_connector *conn, > + struct drm_atomic_state *state) > +{ > + struct drm_bridge_state *bridge_state, *next_bridge_state; > + struct drm_bridge *next_bridge; > + u32 output_flags; > + > + bridge_state = drm_atomic_get_new_bridge_state(state, bridge); > + next_bridge = drm_bridge_chain_get_next_bridge(bridge); > + > + /* > + * Let's try to apply the most common case here, that is, propagate > + * display_info flags for the last bridge, and propagate the input > + * flags of the next bridge element to the output end of the current > + * bridge when the bridge is not the last one. > + * There are exceptions to this rule, like when signal inversion is > + * happening at the board level, but that's something drivers can deal > + * with from their &drm_bridge_funcs.atomic_check() implementation by > + * simply overriding the flags value we've set here. > + */ > + if (!next_bridge) { > + output_flags = conn->display_info.bus_flags; > + } else { > + next_bridge_state = drm_atomic_get_new_bridge_state(state, > + next_bridge); > + output_flags = next_bridge_state->input_bus_cfg.flags; > + } > + > + bridge_state->output_bus_cfg.flags = output_flags; > + > + /* > + * Propage the output flags to the input end of the bridge. Again, it's > + * not necessarily what all bridges want, but that's what most of them > + * do, and by doing that by default we avoid forcing drivers to > + * duplicate the "dummy propagation" logic. > + */ > + bridge_state->input_bus_cfg.flags = output_flags; > +} > + > +/** > + * drm_atomic_helper_bridge_propagate_bus_fmt() - Propagate output format to > + * the input end of a bridge I would move this function above select_bus_fmt_recursive() to avoid putting it in-between functions that are related to each other. > + * @bridge: bridge control structure > + * @bridge_state: new bridge state > + * @crtc_state: new CRTC state > + * @conn_state: new connector state > + * @output_fmt: tested output bus format > + * @num_input_fmts: will contain the size of the returned array > + * > + * Helper that propagate the output format to the input end of bridge. > + * Particularly useful for dummy bridge elements like the panel_bridge. I think this needs to be clarified. * This helper is a pluggable implementation of the * &drm_bridge_funcs.atomic_get_input_bus_fmts operation for bridges that don't * modify the bus configuration between their input and their output. It returns * an array of input formats with a single element set to @output_fmt. > + * > + * RETURNS: > + * a valid format array of size @num_input_fmts, or NULL if the allocation > + * failed or if @num_input_fmts is set to 0 s/0/NULL/ and that's actually not true, you just crash if num_input_fmts == NULL :-) That's fine as num_input_fmts can't be NULL, so just drop the last part of the sentence. > + */ > +u32 * > +drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 output_fmt, > + unsigned int *num_input_fmts) > +{ > + u32 *input_fmts; > + > + *num_input_fmts = 1; > + input_fmts = kzalloc(sizeof(*input_fmts), GFP_KERNEL); > + if (!input_fmts) > + return NULL; > + > + input_fmts[0] = output_fmt; > + return input_fmts; > +} > +EXPORT_SYMBOL(drm_atomic_helper_bridge_propagate_bus_fmt); > + > /** > * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain > * @bridge: bridge control structure > * @crtc_state: new CRTC state > * @conn_state: new connector state > * > - * Calls &drm_bridge_funcs.atomic_check() (falls back on > + * First trigger a bus format negotiation before calling > + * &drm_bridge_funcs.atomic_check() (falls back on > * &drm_bridge_funcs.mode_fixup()) op for all the bridges in the encoder chain, > * starting from the last bridge to the first. These are called before calling > * &drm_encoder_helper_funcs.atomic_check() > @@ -659,12 +897,29 @@ int drm_atomic_bridge_chain_check(struct drm_bridge *bridge, > struct drm_crtc_state *crtc_state, > struct drm_connector_state *conn_state) > { > + struct drm_connector *conn = conn_state->connector; > struct drm_encoder *encoder = bridge->encoder; > struct drm_bridge *iter; > + int ret; > + > + ret = drm_atomic_bridge_chain_select_bus_fmts(bridge, crtc_state, > + conn_state); > + if (ret) > + return ret; > > list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { > int ret; > > + /* > + * Bus flags are propagated by default. If a bridge needs to > + * tweak the input bus flags for any reason, it should happen > + * in its &drm_bridge_funcs.atomic_check() implementation such > + * that preceding bridges in the chain can propagate the new > + * bus flags. > + */ > + drm_atomic_bridge_propagate_bus_flags(iter, conn, > + crtc_state->state); > + > ret = drm_atomic_bridge_check(iter, crtc_state, conn_state); > if (ret) > return ret; > diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h > index 3fb518494640..d37aaf34b882 100644 > --- a/include/drm/drm_bridge.h > +++ b/include/drm/drm_bridge.h > @@ -34,15 +34,43 @@ struct drm_bridge; > struct drm_bridge_timings; > struct drm_panel; > > +/** > + * struct drm_bus_cfg - bus configuration > + * @fmt: format used on this bus. This field should not be directly modified > + * by drivers (&drm_atomic_bridge_chain_select_bus_fmts() takes care of > + * the bus format negotiation). I would mention that the value stored here is one of MEDIA_BUS_FMT_*. > + * @flags: DRM_BUS_ flags used on this bus. Drivers should set the output bus > + * flags to the input bus flags of the next bridge element (unless they > + * have a good reason not to, like a passive signal inversion between > + * those 2 elements). Input bus flags can be different from the output > + * ones if there's some kind of conversion happening inside the bridge, > + * but most of the times it's safe to just propagate the output bus > + * flags to the input end. > + * This bus flags selection/propagation should be done in the driver > + * &drm_bridge_funcs.atomic_check() hook. > + * > + * Encodes the bus format and bus flags used by one end of the bridge or > + * by the encoder output. I think this needs to be extended a little bit. I have no trouble understanding what this structure describes, but it may be less evident for someone who hasn't followed the development. The commit message suffers from the same issue, perhaps even more. How about * This structure stores the configuration of a physical bus between two * components in an output pipeline, usually between two bridges, an encoder and * a bridge, or a bridge and a connector. * * The bus configuration is stored in &drm_bridge_state separately for the input * and output buses, as seen from the point of view of each bridge. The bus * configuration of a bridge output is usually identical to the configuration of * the next bridge's input, but may differ if the signals are modified between * the two bridges, for instance by an inverter on the board. The input and * output configurations of a bridge may differ if the bridge modifies the * signals internally, for instance by performing format conversion, or * modifying signals polarities. With this I would also simplify the description of the flags field as it would otherwise contain redundant information. > + */ > +struct drm_bus_cfg { > + u32 fmt; How about spelling this out as format instead of abbreviating it ? > + u32 flags; > +}; > + > /** > * struct drm_bridge_state - Atomic bridge state object > * @base: inherit from &drm_private_state > * @bridge: the bridge this state refers to > + * @input_bus_info: input bus information > + * @output_bus_info: output bus information The fields are named s/info/cfg/ > */ > struct drm_bridge_state { > struct drm_private_state base; > > struct drm_bridge *bridge; > + > + struct drm_bus_cfg input_bus_cfg; > + struct drm_bus_cfg output_bus_cfg; > }; > > static inline struct drm_bridge_state * > @@ -393,6 +421,69 @@ struct drm_bridge_funcs { > void (*atomic_destroy_state)(struct drm_bridge *bridge, > struct drm_bridge_state *state); > > + /** > + * @atomic_get_output_bus_fmts: > + * > + * Return the supported bus formats on the output end of a bridge. > + * The returned array must be allocated with kmalloc() and will be > + * freed by the caller, if the allocation fails, NULL should be s/caller,/caller;/ or s/caller, if/caller if/ > + * returned. num_output_fmts must be set to the returned array size. > + * Formats listed in the returned array should be listed in decreasing > + * preference order (the core will try all formats until it finds one > + * that works). > + * > + * This method is only called on the last element of the bridge chain > + * as part of the bus format negotiation process that happens in > + * &drm_atomic_bridge_chain_select_bus_fmts(). > + * This method is optional. When not implemented, the core will > + * fallback to &drm_connector.display_info.bus_formats[0] if s/fallback/fall back/ > + * &drm_connector.display_info.num_bus_formats > 0, > + * MEDIA_BUS_FMT_FIXED otherwise. s/MEDIA_BUS_FMT_FIXED/or to MEDIA_BUS_FMT_FIXED/ > + */ > + u32 *(*atomic_get_output_bus_fmts)(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + unsigned int *num_output_fmts); > + > + /** > + * @atomic_get_input_bus_fmts: > + * > + * Return the supported bus formats on the input end of a bridge for > + * a specific output bus format. You need either a blank line, or a reflow of the paragraph. > + * The returned array must be allocated with kmalloc() and will be > + * freed by the caller, if the allocation fails, NULL should be s/caller,/caller;/ or s/caller, if/caller if/ > + * returned. num_output_fmts must be set to the returned array size. > + * Formats listed in the returned array should be listed in decreasing > + * preference order (the core will try all formats until it finds one > + * that works). You need to describe what happens if the output_fmt isn't supported. Should this return an allocated array of zero size or NULL ? > + * > + * This method is called on all element of the bridge chain as part of s/element/elements/ > + * the bus format negotiation process that happens in > + * &drm_atomic_bridge_chain_select_bus_fmts(). > + * This method is optional. When not implemented, the core will bypass > + * bus format negotiation on this element of the bridge without > + * failing, and the previous element in the chain will be passed > + * MEDIA_BUS_FMT_FIXED as its output bus format. > + * > + * Bridge drivers that need to support being linked to bridges that are > + * not supporting bus format negotiation should handle the > + * output_fmt == MEDIA_BUS_FMT_FIXED case appropriately, by selecting a > + * sensible default value or extracting this information from somewhere > + * else (FW property, &drm_display_mode, &drm_display_info, ...) > + * > + * Note: even if input format selection on the first bridge has no s/even/Even/ > + * impact on the negotiation process (bus format negotiation stops once > + * we reach the first element of the chain), drivers are expected to > + * return accurate input formats. I would add "as the input format may be used to configure the CRTC output appropriately.". > + */ > + u32 *(*atomic_get_input_bus_fmts)(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 output_fmt, > + unsigned int *num_input_fmts); > + > /** > * @atomic_check: > * > @@ -407,6 +498,13 @@ struct drm_bridge_funcs { > * called when &drm_bridge_funcs.atomic_check() is implemented, so only > * one of them should be provided. > * > + * If drivers need to tweak &drm_bridge_state.input_bus_cfg.flags or > + * &drm_bridge_state.input_bus_cfg.flags it should should happen in That's twice the same field, did you mean output_bus_cfg.flags for the second one ? > + * this function. By default those fields are set to the next bridge s/those fields are set/the &drm_bridge_state.output_bus_cfg.flags field is set/ > + * &drm_bridge_state.input_bus_cfg.flags value or > + * &drm_connector.display_info.bus_flags if the bridge is the last > + * element in the chain. > + * > * RETURNS: > * zero if the check passed, a negative error code otherwise. > */ > @@ -594,6 +692,14 @@ void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge, > void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, > struct drm_atomic_state *state); > > +u32 * > +drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 output_fmt, > + unsigned int *num_input_fmts); > + > void __drm_atomic_helper_bridge_reset(struct drm_bridge *bridge, > struct drm_bridge_state *state); > struct drm_bridge_state * -- Regards, Laurent Pinchart 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.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, 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 D93FCC432C0 for ; Tue, 3 Dec 2019 10:03:58 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id B72A92073F for ; Tue, 3 Dec 2019 10:03:58 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B72A92073F Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 4CC976E44F; Tue, 3 Dec 2019 10:03:58 +0000 (UTC) Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id F31EA6E44F for ; Tue, 3 Dec 2019 10:03:56 +0000 (UTC) Received: from pendragon.ideasonboard.com (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 11E68309; Tue, 3 Dec 2019 11:03:53 +0100 (CET) Date: Tue, 3 Dec 2019 12:03:45 +0200 From: Laurent Pinchart To: Boris Brezillon Subject: Re: [PATCH v3 14/21] drm/bridge: Add the necessary bits to support bus format negotiation Message-ID: <20191203100345.GM4730@pendragon.ideasonboard.com> References: <20191023154512.9762-1-boris.brezillon@collabora.com> <20191023154512.9762-15-boris.brezillon@collabora.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20191023154512.9762-15-boris.brezillon@collabora.com> User-Agent: Mutt/1.10.1 (2018-07-13) X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1575367433; bh=3/xLxChbo21d7njmNVO3dxO/AVqF8OHA6a8m+W0+s4c=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=DJY8ufkNWZc9kjhvZgga8dKeicr9DGr6/FCJ48UhFhxgbIxKhgXfuUswHRakyQNOM 8AIGgk8bAUo1dzXGQXmF0KBFRDPxnF9a9uX7sn8aW2BVpkTf5sgED9UT5XzZ5WP+Zl Jk+/IHdCvob+VCxVEn0kpXOYu2qzPS8wU1s87tQ8= X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , 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 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" SGkgQm9yaXMsCgpUaGFuayB5b3UgZm9yIHRoZSBwYXRjaC4KCk9uIFdlZCwgT2N0IDIzLCAyMDE5 IGF0IDA1OjQ1OjA1UE0gKzAyMDAsIEJvcmlzIEJyZXppbGxvbiB3cm90ZToKPiBkcm1fYnJpZGdl X3N0YXRlIGlzIGV4dGVuZGVkIHRvIGRlc2NyaWJlIHRoZSBpbnB1dCBhbmQgb3V0cHV0IGJ1cwo+ IGNvbmZpZ3VyYXRpb24uIFRoaXMgYnVzIGNvbmZpZ3VyYXRpb24gaXMgZXhwb3NlZCB0aHJvdWdo IHRoZQoKcy9jb25maWd1cmF0aW9uL2NvbmZpZ3VyYXRpb25zLwpzL1RoaXMgYnVzIGNvbmZpZ3Vy YXRpb24gaXMvVGhlc2UgYnVzIGNvbmZpZ3VyYXRpb25zIGFyZS8KCj4gZHJtX2J1c19jZmcgc3Ry dWN0IHdoaWNoIGNvbnRhaW5zIDIgcHJvcGVydGllczogdGhlIGJ1cyBmb3JtYXQgYW5kCj4gdGhl IGJ1cyBmbGFncy4KPiAKPiBCdXMgZm9ybWF0IG5lZ290aWF0aW9uIGlzIGF1dG9tYXRlZCBieSB0 aGUgY29yZSwgZHJpdmVycyBqdXN0IGhhdmUKPiB0byBpbXBsZW1lbnQgdGhlIC0+YXRvbWljX2dl dF97b3V0cHV0LGlucHV0fV9idXNfZm10cygpIGhvb2tzIGlmIHRoZXkKPiB3YW50IHRvIHRha2Ug cGFydCB0byB0aGlzIG5lZ290aWF0aW9uLiBOZWdvdGlhdGlvbiBoYXBwZW5zIGluIHJlc2VydmUK CnMvcmVzZXJ2ZS9yZXZlcnNlLwoKPiBvcmRlciwgc3RhcnRpbmcgZnJvbSB0aGUgbGFzdCBlbGVt ZW50IG9mIHRoZSBjaGFpbiAodGhlIG9uZSBkaXJlY3RseQo+IGNvbm5lY3RlZCB0byB0aGUgZGlz cGxheSkgdXAgdG8gdGhlIGZpcnN0IGVsZW1lbnQgb2YgdGhlIGNoYWluICh0aGUgb25lCj4gY29u bmVjdGVkIHRvIHRoZSBlbmNvZGVyKS4KPiBEdXJpbmcgdGhpcyBuZWdvdGlhdGlvbiBhbGwgc3Vw cG9ydGVkIGZvcm1hdHMgYXJlIHRlc3RlZCB1bnRpbCB3ZSBmaW5kCj4gb25lIHRoYXQgd29ya3Ms IG1lYW5pbmcgdGhhdCB0aGUgZm9ybWF0cyBhcnJheSBzaG91bGQgYmUgaW4gZGVjcmVhc2luZwo+ IHByZWZlcmVuY2Ugb3JkZXIgKGFzc3VtaW5nIHRoZSBkcml2ZXIgaGFzIGEgcHJlZmVyZW5jZSBv cmRlcikuCj4gCj4gTm90ZSB0aGF0IHRoZSBidXMgZm9ybWF0IG5lZ290aWF0aW9uIHdvcmtzIGV2 ZW4gaWYgc29tZSBlbGVtZW50cyBpbiB0aGUKPiBjaGFpbiBkb24ndCBpbXBsZW1lbnQgdGhlIC0+ YXRvbWljX2dldF97b3V0cHV0LGlucHV0fV9idXNfZm10cygpIGhvb2tzLgo+IEluIHRoYXQgY2Fz ZSwgdGhlIGNvcmUgYWR2ZXJ0aXNlcyBvbmx5IE1FRElBX0JVU19GTVRfRklYRUQgYW5kIGxldAoK cy9sZXQvbGV0cy8KCj4gdGhlIHByZXZpb3VzIGJyaWRnZSBlbGVtZW50IGRlY2lkZSB3aGF0IHRv IGRvIChtb3N0IG9mIHRoZSB0aW1lLCBicmlkZ2UKPiBkcml2ZXJzIHdpbGwgcGljayBhIGRlZmF1 bHQgYnVzIGZvcm1hdCBvZiBleHRyYWN0IHRoaXMgcGllY2Ugb2YKCnMvb2YgZXh0cmFjdC9vciBl eHRyYWN0LwoKPiBpbmZvcm1hdGlvbiBmcm9tIHNvbWV3aGVyZSBlbHNlLCBsaWtlIGEgRlcgcHJv cGVydHkpLgo+IAo+IEJ1cyBmbGFncyBuZWdvdGlhdGlvbiBpcyBsZWZ0IHRvIGRyaXZlcnMgd2hp Y2ggY2FuIHNpbXBseSBwcm9wYWdhdGUgdGhlCj4gZmxhZ3MgZnJvbSB0aGUgaW5wdXQgb2YgdGhl IG5leHQgYnJpZGdlIGVsZW1lbnQgaWYgdGhlcmUncyBubyBjb252ZXJzaW9uCj4gZG9uZSBpbnNp ZGUgdGhlIGJyaWRnZSwgb3IgdHdlYWsgdGhlbSBpZiB0aGUgYnJpZGdlIGRvZXMgc29tZSBraW5k IG9mCj4gc2lnbmFsIGludmVyc2lvbi4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBCb3JpcyBCcmV6aWxs b24gPGJvcmlzLmJyZXppbGxvbkBjb2xsYWJvcmEuY29tPgo+IC0tLQo+IENoYW5nZXMgaW4gdjM6 Cj4gKiBGaXggdGhlIGNvbW1pdCBtZXNzYWdlIChSZXBvcnRlZCBieSBMYXVyZW50KQo+ICogRG9j dW1lbnQgdGhlIGZhY3QgdGhhdCBidXMgZm9ybWF0cyBzaG91bGQgbm90IGJlIGRpcmVjdGx5IG1v ZGlmaWVkIGJ5Cj4gICBkcml2ZXJzIChTdWdnZXN0ZWQgYnkgTGF1cmVudCkKPiAqIERvY3VtZW50 IHRoZSBmYWN0IHRoYXQgZm9ybWF0IG9yZGVyIG1hdHRlcnMgKFN1Z2dlc3RlZCBieSBMYXVyZW50 KQo+ICogUHJvcGFnYXRlIGJ1cyBmbGFncyBieSBkZWZhdWx0Cj4gKiBEb2N1bWVudCB0aGUgZmFj dCB0aGF0IGRyaXZlcnMgY2FuIHR3ZWFrIGJ1cyBmbGFncyBpZiBuZWVkZWQKPiAqIExldCAtPmF0 b21pY19nZXRfe291dHB1dCxpbnB1dH1fYnVzX2ZtdHMoKSBhbGxvY2F0ZSB0aGUgYnVzIGZvcm1h dAo+ICAgYXJyYXkgKFN1Z2dlc3RlZCBieSBMYXVyZW50KQo+ICogQWRkIGEgZHJtX2F0b21pY19o ZWxwZXJfYnJpZGdlX3Byb3BhZ2F0ZV9idXNfZm10KCkKPiAqIE1hbmRhdGUgdGhhdCBicmlkZ2Ug ZHJpdmVycyByZXR1cm4gYWNjdXJhdGUgaW5wdXRfZm10cyBldmVuIGlmIHRoZXkKPiAgIGFyZSBr bm93biB0byBiZSB0aGUgZmlyc3QgZWxlbWVudCBpbiB0aGUgYnJpZGdlIGNoYWluCj4gCj4gQ2hh bmdlcyBpbiB2MjoKPiAqIFJld29yayB0aGluZ3MgdG8gc3VwcG9ydCBtb3JlIGNvbXBsZXggdXNl IGNhc2VzCj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fYnJpZGdlLmMgfCAyNTcgKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KPiAgaW5jbHVkZS9kcm0vZHJtX2JyaWRnZS5o ICAgICB8IDEwNiArKysrKysrKysrKysrKysKPiAgMiBmaWxlcyBjaGFuZ2VkLCAzNjIgaW5zZXJ0 aW9ucygrKSwgMSBkZWxldGlvbigtKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v ZHJtX2JyaWRnZS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9icmlkZ2UuYwo+IGluZGV4IDk5MGUw NTYyOTZiZC4uNjAyMmZiM2Q0MDZhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1f YnJpZGdlLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2JyaWRnZS5jCj4gQEAgLTY0MSwx MyArNjQxLDI1MSBAQCBzdGF0aWMgaW50IGRybV9hdG9taWNfYnJpZGdlX2NoZWNrKHN0cnVjdCBk cm1fYnJpZGdlICpicmlkZ2UsCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiArc3RhdGljIGludCBz ZWxlY3RfYnVzX2ZtdF9yZWN1cnNpdmUoc3RydWN0IGRybV9icmlkZ2UgKmZpcnN0LAoKcy9maXJz dC9maXJzdF9icmlkZ2UvIHRvIG1ha2UgdGhlIGNvZGUgbW9yZSBleHBsaWNpdCA/Cgo+ICsJCQkJ ICAgIHN0cnVjdCBkcm1fYnJpZGdlICpjdXIsCj4gKwkJCQkgICAgc3RydWN0IGRybV9jcnRjX3N0 YXRlICpjcnRjX3N0YXRlLAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpj b25uX3N0YXRlLAo+ICsJCQkJICAgIHUzMiBvdXRfYnVzX2ZtdCkKPiArewo+ICsJc3RydWN0IGRy bV9icmlkZ2Vfc3RhdGUgKmN1cl9zdGF0ZTsKPiArCXVuc2lnbmVkIGludCBudW1faW5fYnVzX2Zt dHMsIGk7Cj4gKwlzdHJ1Y3QgZHJtX2JyaWRnZSAqcHJldjsKPiArCXUzMiAqaW5fYnVzX2ZtdHM7 Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXByZXYgPSBkcm1fYnJpZGdlX2NoYWluX2dldF9wcmV2X2Jy aWRnZShjdXIpOwo+ICsJY3VyX3N0YXRlID0gZHJtX2F0b21pY19nZXRfbmV3X2JyaWRnZV9zdGF0 ZShjcnRjX3N0YXRlLT5zdGF0ZSwgY3VyKTsKPiArCWlmIChXQVJOX09OKCFjdXJfc3RhdGUpKQo+ ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCS8qCj4gKwkgKiBCdXMgZm9ybWF0IG5lZ290aWF0 aW9uIGlzIG5vdCBzdXBwb3J0ZWQgYnkgdGhpcyBicmlkZ2UsIGxldCdzIHBhc3MKCnMvQnVzIGZv cm1hdC9JZiBidXMgZm9ybWF0LwoKb3IgbW92ZSB0aGUgY29tbWVudCB3aXRoaW4gdGhlIGlmICgp IGJsb2NrLgoKPiArCSAqIE1FRElBX0JVU19GTVRfRklYRUQgdG8gdGhlIHByZXZpb3VzIGJyaWRn ZSBpbiB0aGUgY2hhaW4gYW5kIGhvcGUKPiArCSAqIHRoYXQgaXQgY2FuIGhhbmRsZSB0aGlzIHNp dHVhdGlvbiBncmFjZWZ1bGx5IChieSBwcm92aWRpbmcKPiArCSAqIGFwcHJvcHJpYXRlIGRlZmF1 bHQgdmFsdWVzKS4KPiArCSAqLwo+ICsJaWYgKCFjdXItPmZ1bmNzLT5hdG9taWNfZ2V0X2lucHV0 X2J1c19mbXRzKSB7Cj4gKwkJaWYgKGN1ciAhPSBmaXJzdCkgewo+ICsJCQlyZXQgPSBzZWxlY3Rf YnVzX2ZtdF9yZWN1cnNpdmUoZmlyc3QsIHByZXYsIGNydGNfc3RhdGUsCj4gKwkJCQkJCSAgICAg ICBjb25uX3N0YXRlLAo+ICsJCQkJCQkgICAgICAgTUVESUFfQlVTX0ZNVF9GSVhFRCk7Cj4gKwkJ CWlmIChyZXQpCj4gKwkJCQlyZXR1cm4gcmV0Owo+ICsJCX0KPiArCj4gKwkJY3VyX3N0YXRlLT5p bnB1dF9idXNfY2ZnLmZtdCA9IE1FRElBX0JVU19GTVRfRklYRUQ7Cj4gKwkJY3VyX3N0YXRlLT5v dXRwdXRfYnVzX2NmZy5mbXQgPSBvdXRfYnVzX2ZtdDsKPiArCQlyZXR1cm4gMDsKPiArCX0KPiAr Cj4gKwlpbl9idXNfZm10cyA9IGN1ci0+ZnVuY3MtPmF0b21pY19nZXRfaW5wdXRfYnVzX2ZtdHMo Y3VyLCBjdXJfc3RhdGUsCj4gKwkJCQkJCQkgICAgY3J0Y19zdGF0ZSwKPiArCQkJCQkJCSAgICBj b25uX3N0YXRlLAo+ICsJCQkJCQkJICAgIG91dF9idXNfZm10LAo+ICsJCQkJCQkJICAgICZudW1f aW5fYnVzX2ZtdHMpOwo+ICsJaWYgKCFudW1faW5fYnVzX2ZtdHMpCj4gKwkJcmV0dXJuIC1FTk9U U1VQUDsKPiArCWVsc2UgaWYgKCFpbl9idXNfZm10cykKPiArCQlyZXR1cm4gLUVOT01FTTsKPiAr Cj4gKwlpZiAoZmlyc3QgPT0gY3VyKSB7Cj4gKwkJY3VyX3N0YXRlLT5pbnB1dF9idXNfY2ZnLmZt dCA9IGluX2J1c19mbXRzWzBdOwo+ICsJCWN1cl9zdGF0ZS0+b3V0cHV0X2J1c19jZmcuZm10ID0g b3V0X2J1c19mbXQ7Cj4gKwkJa2ZyZWUoaW5fYnVzX2ZtdHMpOwo+ICsJCXJldHVybiAwOwo+ICsJ fQo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBudW1faW5fYnVzX2ZtdHM7IGkrKykgewo+ICsJCXJl dCA9IHNlbGVjdF9idXNfZm10X3JlY3Vyc2l2ZShmaXJzdCwgcHJldiwgY3J0Y19zdGF0ZSwKPiAr CQkJCQkgICAgICAgY29ubl9zdGF0ZSwgaW5fYnVzX2ZtdHNbaV0pOwo+ICsJCWlmIChyZXQgIT0g LUVOT1RTVVBQKQo+ICsJCQlicmVhazsKPiArCX0KPiArCj4gKwlpZiAoIXJldCkgewo+ICsJCWN1 cl9zdGF0ZS0+aW5wdXRfYnVzX2NmZy5mbXQgPSBpbl9idXNfZm10c1tpXTsKPiArCQljdXJfc3Rh dGUtPm91dHB1dF9idXNfY2ZnLmZtdCA9IG91dF9idXNfZm10Owo+ICsJfQo+ICsKPiArCWtmcmVl KGluX2J1c19mbXRzKTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gKy8qCj4gKyAqIFRoaXMg ZnVuY3Rpb24gaXMgY2FsbGVkIGJ5ICZkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9jaGVjaygpIGp1 c3QgYmVmb3JlCj4gKyAqIGNhbGxpbmcgJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2NoZWNrKCkg b24gYWxsIGVsZW1lbnRzIG9mIHRoZSBjaGFpbi4KPiArICogSXQncyBwcm92aWRpbmcgYnVzIGZv cm1hdCBuZWdvdGlhdGlvbiBiZXR3ZWVuIGJyaWRnZSBlbGVtZW50cy4gVGhlCgpzL0l0J3MgcHJv dmlkaW5nL0l0IHBlcmZvcm1zLwoKPiArICogbmVnb3RpYXRpb24gaGFwcGVucyBpbiByZXZlcnNl IG9yZGVyLCBzdGFydGluZyBmcm9tIHRoZSBsYXN0IGVsZW1lbnQgaW4KPiArICogdGhlIGNoYWlu IHVwIHRvIEBicmlkZ2UuCj4gKyAqCj4gKyAqIE5lZ290aWF0aW9uIHN0YXJ0cyBieSByZXRyaWV2 aW5nIHN1cHBvcnRlZCBvdXRwdXQgYnVzIGZvcm1hdHMgb24gdGhlIGxhc3QKPiArICogYnJpZGdl IGVsZW1lbnQgYW5kIHRlc3RpbmcgdGhlbSBvbmUgYnkgb25lLiBUaGUgdGVzdCBpcyByZWN1cnNp dmUsIG1lYW5pbmcKPiArICogdGhhdCBmb3IgZWFjaCB0ZXN0ZWQgb3V0cHV0IGZvcm1hdCwgdGhl IHdob2xlIGNoYWluIHdpbGwgYmUgd2Fsa2VkIGJhY2t3YXJkLAo+ICsgKiBhbmQgZWFjaCBlbGVt ZW50IHdpbGwgaGF2ZSB0byBjaG9vc2UgYW4gaW5wdXQgYnVzIGZvcm1hdCB0aGF0IGNhbiBiZQo+ ICsgKiB0cmFuc2NvZGVkIHRvIHRoZSByZXF1ZXN0ZWQgb3V0cHV0IGZvcm1hdC4gV2hlbiBhIGJy aWRnZSBlbGVtZW50IGRvZXMgbm90Cj4gKyAqIHN1cHBvcnQgdHJhbnNjb2RpbmcgaW50byBhIHNw ZWNpZmljIG91dHB1dCBmb3JtYXQgLUVOT1RTVVBQIGlzIHJldHVybmVkIGFuZAo+ICsgKiB0aGUg bmV4dCBicmlkZ2UgZWxlbWVudCB3aWxsIGhhdmUgdG8gdHJ5IGEgZGlmZmVyZW50IGZvcm1hdC4g SWYgbm9uZSBvZiB0aGUKPiArICogY29tYmluYXRpb25zIHdvcmtlZCwgLUVOT1RTVVBQIGlzIHJl dHVybmVkIGFuZCB0aGUgYXRvbWljIG1vZGVzZXQgd2lsbCBmYWlsLgo+ICsgKgo+ICsgKiBUaGlz IGltcGxlbWVudGF0aW9uIGlzIHJlbHlpbmcgb24KPiArICogJmRybV9icmlkZ2VfZnVuY3MuYXRv bWljX2dldF9vdXRwdXRfYnVzX2ZtdHMoKSBhbmQKPiArICogJmRybV9icmlkZ2VfZnVuY3MuYXRv bWljX2dldF9pbnB1dF9idXNfZm10cygpIHRvIGdhdGhlciBzdXBwb3J0ZWQKPiArICogaW5wdXQv b3V0cHV0IGZvcm1hdHMuCgpCbGFuayBsaW5lIG9yIHJlZmxvdy4KCj4gKyAqIFdoZW4gJmRybV9i cmlkZ2VfZnVuY3MuYXRvbWljX2dldF9vdXRwdXRfYnVzX2ZtdHMoKSBpcyBub3QgaW1wbGVtZW50 ZWQgYnkKPiArICogdGhlIGxhc3QgZWxlbWVudCBvZiB0aGUgY2hhaW4sICZkcm1fYXRvbWljX2Jy aWRnZV9jaGFpbl9zZWxlY3RfYnVzX2ZtdHMoKQo+ICsgKiB0cmllcyBhIHNpbmdsZSBmb3JtYXQ6 ICZkcm1fY29ubmVjdG9yLmRpc3BsYXlfaW5mby5idXNfZm9ybWF0c1swXSBpZgo+ICsgKiBhdmFp bGFibGUsIE1FRElBX0JVU19GTVRfRklYRUQgb3RoZXJ3aXNlLgoKQmxhbmsgbGluZSBvciByZWZs b3cuCgo+ICsgKiBXaGVuICZkcm1fYnJpZGdlX2Z1bmNzLmF0b21pY19nZXRfaW5wdXRfYnVzX2Zt dHMoKSBpcyBub3QgaW1wbGVtZW50ZWQsCj4gKyAqICZkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9z ZWxlY3RfYnVzX2ZtdHMoKSBza2lwcyB0aGUgbmVnb3RpYXRpb24gb24gdGhlCj4gKyAqIGJyaWRn ZSBlbGVtZW50IHRoYXQgbGFja3MgdGhpcyBob29rIGFuZCBhc2tzIHRoZSBwcmV2aW91cyBlbGVt ZW50IGluIHRoZQo+ICsgKiBjaGFpbiB0byB0cnkgTUVESUFfQlVTX0ZNVF9GSVhFRC4gSXQncyB1 cCB0byBicmlkZ2UgZHJpdmVycyB0byBkZWNpZGUgd2hhdAo+ICsgKiB0byBkbyBpbiB0aGF0IGNh c2UgKGZhaWwgaWYgdGhleSB3YW50IHRvIGVuZm9yY2UgYnVzIGZvcm1hdCBuZWdvdGlhdGlvbiwg b3IKPiArICogcHJvdmlkZSBhIHJlYXNvbmFibGUgZGVmYXVsdCBpZiB0aGV5IG5lZWQgdG8gc3Vw cG9ydCBwaXBlbGluZXMgd2hlcmUgbm90Cj4gKyAqIGFsbCBlbGVtZW50cyBzdXBwb3J0IGJ1cyBm b3JtYXQgbmVnb3RpYXRpb24pLgo+ICsgKi8KPiArc3RhdGljIGludAo+ICtkcm1fYXRvbWljX2Jy aWRnZV9jaGFpbl9zZWxlY3RfYnVzX2ZtdHMoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKPiAr CQkJCQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCj4gKwkJCQkJc3RydWN0IGRy bV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK3sKPiArCXN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uID0gY29ubl9zdGF0ZS0+Y29ubmVjdG9yOwo+ICsJc3RydWN0IGRybV9lbmNvZGVy ICplbmNvZGVyID0gYnJpZGdlLT5lbmNvZGVyOwo+ICsJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUg Kmxhc3RfYnJpZGdlX3N0YXRlOwo+ICsJdW5zaWduZWQgaW50IGksIG51bV9vdXRfYnVzX2ZtdHM7 Cj4gKwlzdHJ1Y3QgZHJtX2JyaWRnZSAqbGFzdF9icmlkZ2U7Cj4gKwl1MzIgKm91dF9idXNfZm10 czsKPiArCWludCByZXQgPSAwOwo+ICsKPiArCWxhc3RfYnJpZGdlID0gbGlzdF9sYXN0X2VudHJ5 KCZlbmNvZGVyLT5icmlkZ2VfY2hhaW4sCj4gKwkJCQkgICAgICBzdHJ1Y3QgZHJtX2JyaWRnZSwg Y2hhaW5fbm9kZSk7Cj4gKwlsYXN0X2JyaWRnZV9zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X25ld19i cmlkZ2Vfc3RhdGUoY3J0Y19zdGF0ZS0+c3RhdGUsCj4gKwkJCQkJCQkgICAgbGFzdF9icmlkZ2Up Owo+ICsJaWYgKFdBUk5fT04oIWxhc3RfYnJpZGdlX3N0YXRlKSkKPiArCQlyZXR1cm4gLUVJTlZB TDsKPiArCj4gKwlpZiAobGFzdF9icmlkZ2UtPmZ1bmNzLT5hdG9taWNfZ2V0X291dHB1dF9idXNf Zm10cykgewo+ICsJCWNvbnN0IHN0cnVjdCBkcm1fYnJpZGdlX2Z1bmNzICpmdW5jcyA9IGxhc3Rf YnJpZGdlLT5mdW5jczsKPiArCj4gKwkJb3V0X2J1c19mbXRzID0gZnVuY3MtPmF0b21pY19nZXRf b3V0cHV0X2J1c19mbXRzKGxhc3RfYnJpZGdlLAo+ICsJCQkJCQkJbGFzdF9icmlkZ2Vfc3RhdGUs Cj4gKwkJCQkJCQljcnRjX3N0YXRlLAo+ICsJCQkJCQkJY29ubl9zdGF0ZSwKPiArCQkJCQkJCSZu dW1fb3V0X2J1c19mbXRzKTsKPiArCQlpZiAoIW51bV9vdXRfYnVzX2ZtdHMpCj4gKwkJCXJldHVy biAtRU5PVFNVUFA7Cj4gKwkJZWxzZSBpZiAoIW91dF9idXNfZm10cykKPiArCQkJcmV0dXJuIC1F Tk9NRU07Cj4gKwl9IGVsc2Ugewo+ICsJCW51bV9vdXRfYnVzX2ZtdHMgPSAxOwo+ICsJCW91dF9i dXNfZm10cyA9IGt6YWxsb2Moc2l6ZW9mKCpvdXRfYnVzX2ZtdHMpLCBHRlBfS0VSTkVMKTsKCmtt YWxsb2Mgd291bGQgZG8uCgo+ICsJCWlmICghb3V0X2J1c19mbXRzKQo+ICsJCQlyZXR1cm4gLUVO T01FTTsKPiArCj4gKwkJaWYgKGNvbm4tPmRpc3BsYXlfaW5mby5udW1fYnVzX2Zvcm1hdHMgJiYK PiArCQkgICAgY29ubi0+ZGlzcGxheV9pbmZvLmJ1c19mb3JtYXRzKQo+ICsJCQlvdXRfYnVzX2Zt dHNbMF0gPSBjb25uLT5kaXNwbGF5X2luZm8uYnVzX2Zvcm1hdHNbMF07Cj4gKwkJZWxzZQo+ICsJ CQlvdXRfYnVzX2ZtdHNbMF0gPSBNRURJQV9CVVNfRk1UX0ZJWEVEOwo+ICsJfQo+ICsKPiArCWZv ciAoaSA9IDA7IGkgPCBudW1fb3V0X2J1c19mbXRzOyBpKyspIHsKPiArCQlyZXQgPSBzZWxlY3Rf YnVzX2ZtdF9yZWN1cnNpdmUoYnJpZGdlLCBsYXN0X2JyaWRnZSwgY3J0Y19zdGF0ZSwKPiArCQkJ CQkgICAgICAgY29ubl9zdGF0ZSwgb3V0X2J1c19mbXRzW2ldKTsKPiArCQlpZiAocmV0ICE9IC1F Tk9UU1VQUCkKPiArCQkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJa2ZyZWUob3V0X2J1c19mbXRzKTsK PiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZAo+ICtkcm1fYXRvbWlj X2JyaWRnZV9wcm9wYWdhdGVfYnVzX2ZsYWdzKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4g KwkJCQkgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubiwKPiArCQkJCSAgICAgIHN0cnVj dCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKPiArewo+ICsJc3RydWN0IGRybV9icmlkZ2Vfc3Rh dGUgKmJyaWRnZV9zdGF0ZSwgKm5leHRfYnJpZGdlX3N0YXRlOwo+ICsJc3RydWN0IGRybV9icmlk Z2UgKm5leHRfYnJpZGdlOwo+ICsJdTMyIG91dHB1dF9mbGFnczsKPiArCj4gKwlicmlkZ2Vfc3Rh dGUgPSBkcm1fYXRvbWljX2dldF9uZXdfYnJpZGdlX3N0YXRlKHN0YXRlLCBicmlkZ2UpOwo+ICsJ bmV4dF9icmlkZ2UgPSBkcm1fYnJpZGdlX2NoYWluX2dldF9uZXh0X2JyaWRnZShicmlkZ2UpOwo+ ICsKPiArCS8qCj4gKwkgKiBMZXQncyB0cnkgdG8gYXBwbHkgdGhlIG1vc3QgY29tbW9uIGNhc2Ug aGVyZSwgdGhhdCBpcywgcHJvcGFnYXRlCj4gKwkgKiBkaXNwbGF5X2luZm8gZmxhZ3MgZm9yIHRo ZSBsYXN0IGJyaWRnZSwgYW5kIHByb3BhZ2F0ZSB0aGUgaW5wdXQKPiArCSAqIGZsYWdzIG9mIHRo ZSBuZXh0IGJyaWRnZSBlbGVtZW50IHRvIHRoZSBvdXRwdXQgZW5kIG9mIHRoZSBjdXJyZW50Cj4g KwkgKiBicmlkZ2Ugd2hlbiB0aGUgYnJpZGdlIGlzIG5vdCB0aGUgbGFzdCBvbmUuCj4gKwkgKiBU aGVyZSBhcmUgZXhjZXB0aW9ucyB0byB0aGlzIHJ1bGUsIGxpa2Ugd2hlbiBzaWduYWwgaW52ZXJz aW9uIGlzCj4gKwkgKiBoYXBwZW5pbmcgYXQgdGhlIGJvYXJkIGxldmVsLCBidXQgdGhhdCdzIHNv bWV0aGluZyBkcml2ZXJzIGNhbiBkZWFsCj4gKwkgKiB3aXRoIGZyb20gdGhlaXIgJmRybV9icmlk Z2VfZnVuY3MuYXRvbWljX2NoZWNrKCkgaW1wbGVtZW50YXRpb24gYnkKPiArCSAqIHNpbXBseSBv dmVycmlkaW5nIHRoZSBmbGFncyB2YWx1ZSB3ZSd2ZSBzZXQgaGVyZS4KPiArCSAqLwo+ICsJaWYg KCFuZXh0X2JyaWRnZSkgewo+ICsJCW91dHB1dF9mbGFncyA9IGNvbm4tPmRpc3BsYXlfaW5mby5i dXNfZmxhZ3M7Cj4gKwl9IGVsc2Ugewo+ICsJCW5leHRfYnJpZGdlX3N0YXRlID0gZHJtX2F0b21p Y19nZXRfbmV3X2JyaWRnZV9zdGF0ZShzdGF0ZSwKPiArCQkJCQkJCQluZXh0X2JyaWRnZSk7Cj4g KwkJb3V0cHV0X2ZsYWdzID0gbmV4dF9icmlkZ2Vfc3RhdGUtPmlucHV0X2J1c19jZmcuZmxhZ3M7 Cj4gKwl9Cj4gKwo+ICsJYnJpZGdlX3N0YXRlLT5vdXRwdXRfYnVzX2NmZy5mbGFncyA9IG91dHB1 dF9mbGFnczsKPiArCj4gKwkvKgo+ICsJICogUHJvcGFnZSB0aGUgb3V0cHV0IGZsYWdzIHRvIHRo ZSBpbnB1dCBlbmQgb2YgdGhlIGJyaWRnZS4gQWdhaW4sIGl0J3MKPiArCSAqIG5vdCBuZWNlc3Nh cmlseSB3aGF0IGFsbCBicmlkZ2VzIHdhbnQsIGJ1dCB0aGF0J3Mgd2hhdCBtb3N0IG9mIHRoZW0K PiArCSAqIGRvLCBhbmQgYnkgZG9pbmcgdGhhdCBieSBkZWZhdWx0IHdlIGF2b2lkIGZvcmNpbmcg ZHJpdmVycyB0bwo+ICsJICogZHVwbGljYXRlIHRoZSAiZHVtbXkgcHJvcGFnYXRpb24iIGxvZ2lj Lgo+ICsJICovCj4gKwlicmlkZ2Vfc3RhdGUtPmlucHV0X2J1c19jZmcuZmxhZ3MgPSBvdXRwdXRf ZmxhZ3M7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBkcm1fYXRvbWljX2hlbHBlcl9icmlkZ2VfcHJv cGFnYXRlX2J1c19mbXQoKSAtIFByb3BhZ2F0ZSBvdXRwdXQgZm9ybWF0IHRvCj4gKyAqCQkJCQkJ ICB0aGUgaW5wdXQgZW5kIG9mIGEgYnJpZGdlCgpJIHdvdWxkIG1vdmUgdGhpcyBmdW5jdGlvbiBh Ym92ZSBzZWxlY3RfYnVzX2ZtdF9yZWN1cnNpdmUoKSB0byBhdm9pZApwdXR0aW5nIGl0IGluLWJl dHdlZW4gZnVuY3Rpb25zIHRoYXQgYXJlIHJlbGF0ZWQgdG8gZWFjaCBvdGhlci4KCj4gKyAqIEBi cmlkZ2U6IGJyaWRnZSBjb250cm9sIHN0cnVjdHVyZQo+ICsgKiBAYnJpZGdlX3N0YXRlOiBuZXcg YnJpZGdlIHN0YXRlCj4gKyAqIEBjcnRjX3N0YXRlOiBuZXcgQ1JUQyBzdGF0ZQo+ICsgKiBAY29u bl9zdGF0ZTogbmV3IGNvbm5lY3RvciBzdGF0ZQo+ICsgKiBAb3V0cHV0X2ZtdDogdGVzdGVkIG91 dHB1dCBidXMgZm9ybWF0Cj4gKyAqIEBudW1faW5wdXRfZm10czogd2lsbCBjb250YWluIHRoZSBz aXplIG9mIHRoZSByZXR1cm5lZCBhcnJheQo+ICsgKgo+ICsgKiBIZWxwZXIgdGhhdCBwcm9wYWdh dGUgdGhlIG91dHB1dCBmb3JtYXQgdG8gdGhlIGlucHV0IGVuZCBvZiBicmlkZ2UuCj4gKyAqIFBh cnRpY3VsYXJseSB1c2VmdWwgZm9yIGR1bW15IGJyaWRnZSBlbGVtZW50cyBsaWtlIHRoZSBwYW5l bF9icmlkZ2UuCgpJIHRoaW5rIHRoaXMgbmVlZHMgdG8gYmUgY2xhcmlmaWVkLgoKICogVGhpcyBo ZWxwZXIgaXMgYSBwbHVnZ2FibGUgaW1wbGVtZW50YXRpb24gb2YgdGhlCiAqICZkcm1fYnJpZGdl X2Z1bmNzLmF0b21pY19nZXRfaW5wdXRfYnVzX2ZtdHMgb3BlcmF0aW9uIGZvciBicmlkZ2VzIHRo YXQgZG9uJ3QKICogbW9kaWZ5IHRoZSBidXMgY29uZmlndXJhdGlvbiBiZXR3ZWVuIHRoZWlyIGlu cHV0IGFuZCB0aGVpciBvdXRwdXQuIEl0IHJldHVybnMKICogYW4gYXJyYXkgb2YgaW5wdXQgZm9y bWF0cyB3aXRoIGEgc2luZ2xlIGVsZW1lbnQgc2V0IHRvIEBvdXRwdXRfZm10LgoKPiArICoKPiAr ICogUkVUVVJOUzoKPiArICogYSB2YWxpZCBmb3JtYXQgYXJyYXkgb2Ygc2l6ZSBAbnVtX2lucHV0 X2ZtdHMsIG9yIE5VTEwgaWYgdGhlIGFsbG9jYXRpb24KPiArICogZmFpbGVkIG9yIGlmIEBudW1f aW5wdXRfZm10cyBpcyBzZXQgdG8gMAoKcy8wL05VTEwvCgphbmQgdGhhdCdzIGFjdHVhbGx5IG5v dCB0cnVlLCB5b3UganVzdCBjcmFzaCBpZiBudW1faW5wdXRfZm10cyA9PSBOVUxMCjotKSBUaGF0 J3MgZmluZSBhcyBudW1faW5wdXRfZm10cyBjYW4ndCBiZSBOVUxMLCBzbyBqdXN0IGRyb3AgdGhl IGxhc3QKcGFydCBvZiB0aGUgc2VudGVuY2UuCgo+ICsgKi8KPiArdTMyICoKPiArZHJtX2F0b21p Y19oZWxwZXJfYnJpZGdlX3Byb3BhZ2F0ZV9idXNfZm10KHN0cnVjdCBkcm1fYnJpZGdlICpicmlk Z2UsCj4gKwkJCQkJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKmJyaWRnZV9zdGF0ZSwKPiArCQkJ CQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCj4gKwkJCQkJc3RydWN0IGRybV9j b25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCj4gKwkJCQkJdTMyIG91dHB1dF9mbXQsCj4gKwkJ CQkJdW5zaWduZWQgaW50ICpudW1faW5wdXRfZm10cykKPiArewo+ICsJdTMyICppbnB1dF9mbXRz Owo+ICsKPiArCSpudW1faW5wdXRfZm10cyA9IDE7Cj4gKwlpbnB1dF9mbXRzID0ga3phbGxvYyhz aXplb2YoKmlucHV0X2ZtdHMpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghaW5wdXRfZm10cykKPiAr CQlyZXR1cm4gTlVMTDsKPiArCj4gKwlpbnB1dF9mbXRzWzBdID0gb3V0cHV0X2ZtdDsKPiArCXJl dHVybiBpbnB1dF9mbXRzOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woZHJtX2F0b21pY19oZWxwZXJf YnJpZGdlX3Byb3BhZ2F0ZV9idXNfZm10KTsKPiArCj4gIC8qKgo+ICAgKiBkcm1fYXRvbWljX2Jy aWRnZV9jaGFpbl9jaGVjaygpIC0gRG8gYW4gYXRvbWljIGNoZWNrIG9uIHRoZSBicmlkZ2UgY2hh aW4KPiAgICogQGJyaWRnZTogYnJpZGdlIGNvbnRyb2wgc3RydWN0dXJlCj4gICAqIEBjcnRjX3N0 YXRlOiBuZXcgQ1JUQyBzdGF0ZQo+ICAgKiBAY29ubl9zdGF0ZTogbmV3IGNvbm5lY3RvciBzdGF0 ZQo+ICAgKgo+IC0gKiBDYWxscyAmZHJtX2JyaWRnZV9mdW5jcy5hdG9taWNfY2hlY2soKSAoZmFs bHMgYmFjayBvbgo+ICsgKiBGaXJzdCB0cmlnZ2VyIGEgYnVzIGZvcm1hdCBuZWdvdGlhdGlvbiBi ZWZvcmUgY2FsbGluZwo+ICsgKiAmZHJtX2JyaWRnZV9mdW5jcy5hdG9taWNfY2hlY2soKSAoZmFs bHMgYmFjayBvbgo+ICAgKiAmZHJtX2JyaWRnZV9mdW5jcy5tb2RlX2ZpeHVwKCkpIG9wIGZvciBh bGwgdGhlIGJyaWRnZXMgaW4gdGhlIGVuY29kZXIgY2hhaW4sCj4gICAqIHN0YXJ0aW5nIGZyb20g dGhlIGxhc3QgYnJpZGdlIHRvIHRoZSBmaXJzdC4gVGhlc2UgYXJlIGNhbGxlZCBiZWZvcmUgY2Fs bGluZwo+ICAgKiAmZHJtX2VuY29kZXJfaGVscGVyX2Z1bmNzLmF0b21pY19jaGVjaygpCj4gQEAg LTY1OSwxMiArODk3LDI5IEBAIGludCBkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9jaGVjayhzdHJ1 Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICAJCQkJICBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNy dGNfc3RhdGUsCj4gIAkJCQkgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRl KQo+ICB7Cj4gKwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubiA9IGNvbm5fc3RhdGUtPmNvbm5l Y3RvcjsKPiAgCXN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlciA9IGJyaWRnZS0+ZW5jb2RlcjsK PiAgCXN0cnVjdCBkcm1fYnJpZGdlICppdGVyOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBk cm1fYXRvbWljX2JyaWRnZV9jaGFpbl9zZWxlY3RfYnVzX2ZtdHMoYnJpZGdlLCBjcnRjX3N0YXRl LAo+ICsJCQkJCQkgICAgICBjb25uX3N0YXRlKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJl dDsKPiAgCj4gIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JldmVyc2UoaXRlciwgJmVuY29kZXItPmJy aWRnZV9jaGFpbiwgY2hhaW5fbm9kZSkgewo+ICAJCWludCByZXQ7Cj4gIAo+ICsJCS8qCj4gKwkJ ICogQnVzIGZsYWdzIGFyZSBwcm9wYWdhdGVkIGJ5IGRlZmF1bHQuIElmIGEgYnJpZGdlIG5lZWRz IHRvCj4gKwkJICogdHdlYWsgdGhlIGlucHV0IGJ1cyBmbGFncyBmb3IgYW55IHJlYXNvbiwgaXQg c2hvdWxkIGhhcHBlbgo+ICsJCSAqIGluIGl0cyAmZHJtX2JyaWRnZV9mdW5jcy5hdG9taWNfY2hl Y2soKSBpbXBsZW1lbnRhdGlvbiBzdWNoCj4gKwkJICogdGhhdCBwcmVjZWRpbmcgYnJpZGdlcyBp biB0aGUgY2hhaW4gY2FuIHByb3BhZ2F0ZSB0aGUgbmV3Cj4gKwkJICogYnVzIGZsYWdzLgo+ICsJ CSAqLwo+ICsJCWRybV9hdG9taWNfYnJpZGdlX3Byb3BhZ2F0ZV9idXNfZmxhZ3MoaXRlciwgY29u biwKPiArCQkJCQkJICAgICAgY3J0Y19zdGF0ZS0+c3RhdGUpOwo+ICsKPiAgCQlyZXQgPSBkcm1f YXRvbWljX2JyaWRnZV9jaGVjayhpdGVyLCBjcnRjX3N0YXRlLCBjb25uX3N0YXRlKTsKPiAgCQlp ZiAocmV0KQo+ICAJCQlyZXR1cm4gcmV0Owo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1f YnJpZGdlLmggYi9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgKPiBpbmRleCAzZmI1MTg0OTQ2NDAu LmQzN2FhZjM0Yjg4MiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgKPiAr KysgYi9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgKPiBAQCAtMzQsMTUgKzM0LDQzIEBAIHN0cnVj dCBkcm1fYnJpZGdlOwo+ICBzdHJ1Y3QgZHJtX2JyaWRnZV90aW1pbmdzOwo+ICBzdHJ1Y3QgZHJt X3BhbmVsOwo+ICAKPiArLyoqCj4gKyAqIHN0cnVjdCBkcm1fYnVzX2NmZyAtIGJ1cyBjb25maWd1 cmF0aW9uCj4gKyAqIEBmbXQ6IGZvcm1hdCB1c2VkIG9uIHRoaXMgYnVzLiBUaGlzIGZpZWxkIHNo b3VsZCBub3QgYmUgZGlyZWN0bHkgbW9kaWZpZWQKPiArICoJIGJ5IGRyaXZlcnMgKCZkcm1fYXRv bWljX2JyaWRnZV9jaGFpbl9zZWxlY3RfYnVzX2ZtdHMoKSB0YWtlcyBjYXJlIG9mCj4gKyAqCSB0 aGUgYnVzIGZvcm1hdCBuZWdvdGlhdGlvbikuCgpJIHdvdWxkIG1lbnRpb24gdGhhdCB0aGUgdmFs dWUgc3RvcmVkIGhlcmUgaXMgb25lIG9mIE1FRElBX0JVU19GTVRfKi4KCj4gKyAqIEBmbGFnczog RFJNX0JVU18gZmxhZ3MgdXNlZCBvbiB0aGlzIGJ1cy4gRHJpdmVycyBzaG91bGQgc2V0IHRoZSBv dXRwdXQgYnVzCj4gKyAqCSAgIGZsYWdzIHRvIHRoZSBpbnB1dCBidXMgZmxhZ3Mgb2YgdGhlIG5l eHQgYnJpZGdlIGVsZW1lbnQgKHVubGVzcyB0aGV5Cj4gKyAqCSAgIGhhdmUgYSBnb29kIHJlYXNv biBub3QgdG8sIGxpa2UgYSBwYXNzaXZlIHNpZ25hbCBpbnZlcnNpb24gYmV0d2Vlbgo+ICsgKgkg ICB0aG9zZSAyIGVsZW1lbnRzKS4gSW5wdXQgYnVzIGZsYWdzIGNhbiBiZSBkaWZmZXJlbnQgZnJv bSB0aGUgb3V0cHV0Cj4gKyAqCSAgIG9uZXMgaWYgdGhlcmUncyBzb21lIGtpbmQgb2YgY29udmVy c2lvbiBoYXBwZW5pbmcgaW5zaWRlIHRoZSBicmlkZ2UsCj4gKyAqCSAgIGJ1dCBtb3N0IG9mIHRo ZSB0aW1lcyBpdCdzIHNhZmUgdG8ganVzdCBwcm9wYWdhdGUgdGhlIG91dHB1dCBidXMKPiArICoJ ICAgZmxhZ3MgdG8gdGhlIGlucHV0IGVuZC4KPiArICoJICAgVGhpcyBidXMgZmxhZ3Mgc2VsZWN0 aW9uL3Byb3BhZ2F0aW9uIHNob3VsZCBiZSBkb25lIGluIHRoZSBkcml2ZXIKPiArICoJICAgJmRy bV9icmlkZ2VfZnVuY3MuYXRvbWljX2NoZWNrKCkgaG9vay4KPiArICoKPiArICogRW5jb2RlcyB0 aGUgYnVzIGZvcm1hdCBhbmQgYnVzIGZsYWdzIHVzZWQgYnkgb25lIGVuZCBvZiB0aGUgYnJpZGdl IG9yCj4gKyAqIGJ5IHRoZSBlbmNvZGVyIG91dHB1dC4KCkkgdGhpbmsgdGhpcyBuZWVkcyB0byBi ZSBleHRlbmRlZCBhIGxpdHRsZSBiaXQuIEkgaGF2ZSBubyB0cm91YmxlCnVuZGVyc3RhbmRpbmcg d2hhdCB0aGlzIHN0cnVjdHVyZSBkZXNjcmliZXMsIGJ1dCBpdCBtYXkgYmUgbGVzcyBldmlkZW50 CmZvciBzb21lb25lIHdobyBoYXNuJ3QgZm9sbG93ZWQgdGhlIGRldmVsb3BtZW50LiBUaGUgY29t bWl0IG1lc3NhZ2UKc3VmZmVycyBmcm9tIHRoZSBzYW1lIGlzc3VlLCBwZXJoYXBzIGV2ZW4gbW9y ZS4KCkhvdyBhYm91dAoKICogVGhpcyBzdHJ1Y3R1cmUgc3RvcmVzIHRoZSBjb25maWd1cmF0aW9u IG9mIGEgcGh5c2ljYWwgYnVzIGJldHdlZW4gdHdvCiAqIGNvbXBvbmVudHMgaW4gYW4gb3V0cHV0 IHBpcGVsaW5lLCB1c3VhbGx5IGJldHdlZW4gdHdvIGJyaWRnZXMsIGFuIGVuY29kZXIgYW5kCiAq IGEgYnJpZGdlLCBvciBhIGJyaWRnZSBhbmQgYSBjb25uZWN0b3IuCiAqCiAqIFRoZSBidXMgY29u ZmlndXJhdGlvbiBpcyBzdG9yZWQgaW4gJmRybV9icmlkZ2Vfc3RhdGUgc2VwYXJhdGVseSBmb3Ig dGhlIGlucHV0CiAqIGFuZCBvdXRwdXQgYnVzZXMsIGFzIHNlZW4gZnJvbSB0aGUgcG9pbnQgb2Yg dmlldyBvZiBlYWNoIGJyaWRnZS4gVGhlIGJ1cwogKiBjb25maWd1cmF0aW9uIG9mIGEgYnJpZGdl IG91dHB1dCBpcyB1c3VhbGx5IGlkZW50aWNhbCB0byB0aGUgY29uZmlndXJhdGlvbiBvZgogKiB0 aGUgbmV4dCBicmlkZ2UncyBpbnB1dCwgYnV0IG1heSBkaWZmZXIgaWYgdGhlIHNpZ25hbHMgYXJl IG1vZGlmaWVkIGJldHdlZW4KICogdGhlIHR3byBicmlkZ2VzLCBmb3IgaW5zdGFuY2UgYnkgYW4g aW52ZXJ0ZXIgb24gdGhlIGJvYXJkLiBUaGUgaW5wdXQgYW5kCiAqIG91dHB1dCBjb25maWd1cmF0 aW9ucyBvZiBhIGJyaWRnZSBtYXkgZGlmZmVyIGlmIHRoZSBicmlkZ2UgbW9kaWZpZXMgdGhlCiAq IHNpZ25hbHMgaW50ZXJuYWxseSwgZm9yIGluc3RhbmNlIGJ5IHBlcmZvcm1pbmcgZm9ybWF0IGNv bnZlcnNpb24sIG9yCiAqIG1vZGlmeWluZyBzaWduYWxzIHBvbGFyaXRpZXMuCgpXaXRoIHRoaXMg SSB3b3VsZCBhbHNvIHNpbXBsaWZ5IHRoZSBkZXNjcmlwdGlvbiBvZiB0aGUgZmxhZ3MgZmllbGQg YXMgaXQKd291bGQgb3RoZXJ3aXNlIGNvbnRhaW4gcmVkdW5kYW50IGluZm9ybWF0aW9uLgoKPiAr ICovCj4gK3N0cnVjdCBkcm1fYnVzX2NmZyB7Cj4gKwl1MzIgZm10OwoKSG93IGFib3V0IHNwZWxs aW5nIHRoaXMgb3V0IGFzIGZvcm1hdCBpbnN0ZWFkIG9mIGFiYnJldmlhdGluZyBpdCA/Cgo+ICsJ dTMyIGZsYWdzOwo+ICt9Owo+ICsKPiAgLyoqCj4gICAqIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRl IC0gQXRvbWljIGJyaWRnZSBzdGF0ZSBvYmplY3QKPiAgICogQGJhc2U6IGluaGVyaXQgZnJvbSAm ZHJtX3ByaXZhdGVfc3RhdGUKPiAgICogQGJyaWRnZTogdGhlIGJyaWRnZSB0aGlzIHN0YXRlIHJl ZmVycyB0bwo+ICsgKiBAaW5wdXRfYnVzX2luZm86IGlucHV0IGJ1cyBpbmZvcm1hdGlvbgo+ICsg KiBAb3V0cHV0X2J1c19pbmZvOiBvdXRwdXQgYnVzIGluZm9ybWF0aW9uCgpUaGUgZmllbGRzIGFy ZSBuYW1lZCBzL2luZm8vY2ZnLwoKPiAgICovCj4gIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlIHsK PiAgCXN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZSBiYXNlOwo+ICAKPiAgCXN0cnVjdCBkcm1fYnJp ZGdlICpicmlkZ2U7Cj4gKwo+ICsJc3RydWN0IGRybV9idXNfY2ZnIGlucHV0X2J1c19jZmc7Cj4g KwlzdHJ1Y3QgZHJtX2J1c19jZmcgb3V0cHV0X2J1c19jZmc7Cj4gIH07Cj4gIAo+ICBzdGF0aWMg aW5saW5lIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICoKPiBAQCAtMzkzLDYgKzQyMSw2OSBAQCBz dHJ1Y3QgZHJtX2JyaWRnZV9mdW5jcyB7Cj4gIAl2b2lkICgqYXRvbWljX2Rlc3Ryb3lfc3RhdGUp KHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4gIAkJCQkgICAgIHN0cnVjdCBkcm1fYnJpZGdl X3N0YXRlICpzdGF0ZSk7Cj4gIAo+ICsJLyoqCj4gKwkgKiBAYXRvbWljX2dldF9vdXRwdXRfYnVz X2ZtdHM6Cj4gKwkgKgo+ICsJICogUmV0dXJuIHRoZSBzdXBwb3J0ZWQgYnVzIGZvcm1hdHMgb24g dGhlIG91dHB1dCBlbmQgb2YgYSBicmlkZ2UuCj4gKwkgKiBUaGUgcmV0dXJuZWQgYXJyYXkgbXVz dCBiZSBhbGxvY2F0ZWQgd2l0aCBrbWFsbG9jKCkgYW5kIHdpbGwgYmUKPiArCSAqIGZyZWVkIGJ5 IHRoZSBjYWxsZXIsIGlmIHRoZSBhbGxvY2F0aW9uIGZhaWxzLCBOVUxMIHNob3VsZCBiZQoKcy9j YWxsZXIsL2NhbGxlcjsvIG9yIHMvY2FsbGVyLCBpZi9jYWxsZXIgaWYvCgo+ICsJICogcmV0dXJu ZWQuIG51bV9vdXRwdXRfZm10cyBtdXN0IGJlIHNldCB0byB0aGUgcmV0dXJuZWQgYXJyYXkgc2l6 ZS4KPiArCSAqIEZvcm1hdHMgbGlzdGVkIGluIHRoZSByZXR1cm5lZCBhcnJheSBzaG91bGQgYmUg bGlzdGVkIGluIGRlY3JlYXNpbmcKPiArCSAqIHByZWZlcmVuY2Ugb3JkZXIgKHRoZSBjb3JlIHdp bGwgdHJ5IGFsbCBmb3JtYXRzIHVudGlsIGl0IGZpbmRzIG9uZQo+ICsJICogdGhhdCB3b3Jrcyku Cj4gKwkgKgo+ICsJICogVGhpcyBtZXRob2QgaXMgb25seSBjYWxsZWQgb24gdGhlIGxhc3QgZWxl bWVudCBvZiB0aGUgYnJpZGdlIGNoYWluCj4gKwkgKiBhcyBwYXJ0IG9mIHRoZSBidXMgZm9ybWF0 IG5lZ290aWF0aW9uIHByb2Nlc3MgdGhhdCBoYXBwZW5zIGluCj4gKwkgKiAmZHJtX2F0b21pY19i cmlkZ2VfY2hhaW5fc2VsZWN0X2J1c19mbXRzKCkuCj4gKwkgKiBUaGlzIG1ldGhvZCBpcyBvcHRp b25hbC4gV2hlbiBub3QgaW1wbGVtZW50ZWQsIHRoZSBjb3JlIHdpbGwKPiArCSAqIGZhbGxiYWNr IHRvICZkcm1fY29ubmVjdG9yLmRpc3BsYXlfaW5mby5idXNfZm9ybWF0c1swXSBpZgoKcy9mYWxs YmFjay9mYWxsIGJhY2svCgo+ICsJICogJmRybV9jb25uZWN0b3IuZGlzcGxheV9pbmZvLm51bV9i dXNfZm9ybWF0cyA+IDAsCj4gKwkgKiBNRURJQV9CVVNfRk1UX0ZJWEVEIG90aGVyd2lzZS4KCnMv TUVESUFfQlVTX0ZNVF9GSVhFRC9vciB0byBNRURJQV9CVVNfRk1UX0ZJWEVELwoKPiArCSAqLwo+ ICsJdTMyICooKmF0b21pY19nZXRfb3V0cHV0X2J1c19mbXRzKShzdHJ1Y3QgZHJtX2JyaWRnZSAq YnJpZGdlLAo+ICsJCQkJCSAgIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpicmlkZ2Vfc3RhdGUs Cj4gKwkJCQkJICAgc3RydWN0IGRybV9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAo+ICsJCQkJCSAg IHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAo+ICsJCQkJCSAgIHVuc2ln bmVkIGludCAqbnVtX291dHB1dF9mbXRzKTsKPiArCj4gKwkvKioKPiArCSAqIEBhdG9taWNfZ2V0 X2lucHV0X2J1c19mbXRzOgo+ICsJICoKPiArCSAqIFJldHVybiB0aGUgc3VwcG9ydGVkIGJ1cyBm b3JtYXRzIG9uIHRoZSBpbnB1dCBlbmQgb2YgYSBicmlkZ2UgZm9yCj4gKwkgKiBhIHNwZWNpZmlj IG91dHB1dCBidXMgZm9ybWF0LgoKWW91IG5lZWQgZWl0aGVyIGEgYmxhbmsgbGluZSwgb3IgYSBy ZWZsb3cgb2YgdGhlIHBhcmFncmFwaC4KCj4gKwkgKiBUaGUgcmV0dXJuZWQgYXJyYXkgbXVzdCBi ZSBhbGxvY2F0ZWQgd2l0aCBrbWFsbG9jKCkgYW5kIHdpbGwgYmUKPiArCSAqIGZyZWVkIGJ5IHRo ZSBjYWxsZXIsIGlmIHRoZSBhbGxvY2F0aW9uIGZhaWxzLCBOVUxMIHNob3VsZCBiZQoKcy9jYWxs ZXIsL2NhbGxlcjsvIG9yIHMvY2FsbGVyLCBpZi9jYWxsZXIgaWYvCgo+ICsJICogcmV0dXJuZWQu IG51bV9vdXRwdXRfZm10cyBtdXN0IGJlIHNldCB0byB0aGUgcmV0dXJuZWQgYXJyYXkgc2l6ZS4K PiArCSAqIEZvcm1hdHMgbGlzdGVkIGluIHRoZSByZXR1cm5lZCBhcnJheSBzaG91bGQgYmUgbGlz dGVkIGluIGRlY3JlYXNpbmcKPiArCSAqIHByZWZlcmVuY2Ugb3JkZXIgKHRoZSBjb3JlIHdpbGwg dHJ5IGFsbCBmb3JtYXRzIHVudGlsIGl0IGZpbmRzIG9uZQo+ICsJICogdGhhdCB3b3JrcykuCgpZ b3UgbmVlZCB0byBkZXNjcmliZSB3aGF0IGhhcHBlbnMgaWYgdGhlIG91dHB1dF9mbXQgaXNuJ3Qg c3VwcG9ydGVkLgpTaG91bGQgdGhpcyByZXR1cm4gYW4gYWxsb2NhdGVkIGFycmF5IG9mIHplcm8g c2l6ZSBvciBOVUxMID8KCj4gKwkgKgo+ICsJICogVGhpcyBtZXRob2QgaXMgY2FsbGVkIG9uIGFs bCBlbGVtZW50IG9mIHRoZSBicmlkZ2UgY2hhaW4gYXMgcGFydCBvZgoKcy9lbGVtZW50L2VsZW1l bnRzLwoKPiArCSAqIHRoZSBidXMgZm9ybWF0IG5lZ290aWF0aW9uIHByb2Nlc3MgdGhhdCBoYXBw ZW5zIGluCj4gKwkgKiAmZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fc2VsZWN0X2J1c19mbXRzKCku Cj4gKwkgKiBUaGlzIG1ldGhvZCBpcyBvcHRpb25hbC4gV2hlbiBub3QgaW1wbGVtZW50ZWQsIHRo ZSBjb3JlIHdpbGwgYnlwYXNzCj4gKwkgKiBidXMgZm9ybWF0IG5lZ290aWF0aW9uIG9uIHRoaXMg ZWxlbWVudCBvZiB0aGUgYnJpZGdlIHdpdGhvdXQKPiArCSAqIGZhaWxpbmcsIGFuZCB0aGUgcHJl dmlvdXMgZWxlbWVudCBpbiB0aGUgY2hhaW4gd2lsbCBiZSBwYXNzZWQKPiArCSAqIE1FRElBX0JV U19GTVRfRklYRUQgYXMgaXRzIG91dHB1dCBidXMgZm9ybWF0Lgo+ICsJICoKPiArCSAqIEJyaWRn ZSBkcml2ZXJzIHRoYXQgbmVlZCB0byBzdXBwb3J0IGJlaW5nIGxpbmtlZCB0byBicmlkZ2VzIHRo YXQgYXJlCj4gKwkgKiBub3Qgc3VwcG9ydGluZyBidXMgZm9ybWF0IG5lZ290aWF0aW9uIHNob3Vs ZCBoYW5kbGUgdGhlCj4gKwkgKiBvdXRwdXRfZm10ID09IE1FRElBX0JVU19GTVRfRklYRUQgY2Fz ZSBhcHByb3ByaWF0ZWx5LCBieSBzZWxlY3RpbmcgYQo+ICsJICogc2Vuc2libGUgZGVmYXVsdCB2 YWx1ZSBvciBleHRyYWN0aW5nIHRoaXMgaW5mb3JtYXRpb24gZnJvbSBzb21ld2hlcmUKPiArCSAq IGVsc2UgKEZXIHByb3BlcnR5LCAmZHJtX2Rpc3BsYXlfbW9kZSwgJmRybV9kaXNwbGF5X2luZm8s IC4uLikKPiArCSAqCj4gKwkgKiBOb3RlOiBldmVuIGlmIGlucHV0IGZvcm1hdCBzZWxlY3Rpb24g b24gdGhlIGZpcnN0IGJyaWRnZSBoYXMgbm8KCnMvZXZlbi9FdmVuLwoKPiArCSAqIGltcGFjdCBv biB0aGUgbmVnb3RpYXRpb24gcHJvY2VzcyAoYnVzIGZvcm1hdCBuZWdvdGlhdGlvbiBzdG9wcyBv bmNlCj4gKwkgKiB3ZSByZWFjaCB0aGUgZmlyc3QgZWxlbWVudCBvZiB0aGUgY2hhaW4pLCBkcml2 ZXJzIGFyZSBleHBlY3RlZCB0bwo+ICsJICogcmV0dXJuIGFjY3VyYXRlIGlucHV0IGZvcm1hdHMu CgpJIHdvdWxkIGFkZCAiYXMgdGhlIGlucHV0IGZvcm1hdCBtYXkgYmUgdXNlZCB0byBjb25maWd1 cmUgdGhlIENSVEMKb3V0cHV0IGFwcHJvcHJpYXRlbHkuIi4KCj4gKwkgKi8KPiArCXUzMiAqKCph dG9taWNfZ2V0X2lucHV0X2J1c19mbXRzKShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICsJ CQkJCSAgc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKmJyaWRnZV9zdGF0ZSwKPiArCQkJCQkgIHN0 cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSwKPiArCQkJCQkgIHN0cnVjdCBkcm1fY29u bmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAo+ICsJCQkJCSAgdTMyIG91dHB1dF9mbXQsCj4gKwkJ CQkJICB1bnNpZ25lZCBpbnQgKm51bV9pbnB1dF9mbXRzKTsKPiArCj4gIAkvKioKPiAgCSAqIEBh dG9taWNfY2hlY2s6Cj4gIAkgKgo+IEBAIC00MDcsNiArNDk4LDEzIEBAIHN0cnVjdCBkcm1fYnJp ZGdlX2Z1bmNzIHsKPiAgCSAqIGNhbGxlZCB3aGVuICZkcm1fYnJpZGdlX2Z1bmNzLmF0b21pY19j aGVjaygpIGlzIGltcGxlbWVudGVkLCBzbyBvbmx5Cj4gIAkgKiBvbmUgb2YgdGhlbSBzaG91bGQg YmUgcHJvdmlkZWQuCj4gIAkgKgo+ICsJICogSWYgZHJpdmVycyBuZWVkIHRvIHR3ZWFrICZkcm1f YnJpZGdlX3N0YXRlLmlucHV0X2J1c19jZmcuZmxhZ3Mgb3IKPiArCSAqICZkcm1fYnJpZGdlX3N0 YXRlLmlucHV0X2J1c19jZmcuZmxhZ3MgaXQgc2hvdWxkIHNob3VsZCBoYXBwZW4gaW4KClRoYXQn cyB0d2ljZSB0aGUgc2FtZSBmaWVsZCwgZGlkIHlvdSBtZWFuIG91dHB1dF9idXNfY2ZnLmZsYWdz IGZvciB0aGUKc2Vjb25kIG9uZSA/Cgo+ICsJICogdGhpcyBmdW5jdGlvbi4gQnkgZGVmYXVsdCB0 aG9zZSBmaWVsZHMgYXJlIHNldCB0byB0aGUgbmV4dCBicmlkZ2UKCnMvdGhvc2UgZmllbGRzIGFy ZSBzZXQvdGhlICZkcm1fYnJpZGdlX3N0YXRlLm91dHB1dF9idXNfY2ZnLmZsYWdzIGZpZWxkIGlz IHNldC8KCj4gKwkgKiAmZHJtX2JyaWRnZV9zdGF0ZS5pbnB1dF9idXNfY2ZnLmZsYWdzIHZhbHVl IG9yCj4gKwkgKiAmZHJtX2Nvbm5lY3Rvci5kaXNwbGF5X2luZm8uYnVzX2ZsYWdzIGlmIHRoZSBi cmlkZ2UgaXMgdGhlIGxhc3QKPiArCSAqIGVsZW1lbnQgaW4gdGhlIGNoYWluLgo+ICsJICoKPiAg CSAqIFJFVFVSTlM6Cj4gIAkgKiB6ZXJvIGlmIHRoZSBjaGVjayBwYXNzZWQsIGEgbmVnYXRpdmUg ZXJyb3IgY29kZSBvdGhlcndpc2UuCj4gIAkgKi8KPiBAQCAtNTk0LDYgKzY5MiwxNCBAQCB2b2lk IGRybV9hdG9taWNfYnJpZGdlX2NoYWluX3ByZV9lbmFibGUoc3RydWN0IGRybV9icmlkZ2UgKmJy aWRnZSwKPiAgdm9pZCBkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9lbmFibGUoc3RydWN0IGRybV9i cmlkZ2UgKmJyaWRnZSwKPiAgCQkJCSAgICBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUp Owo+ICAKPiArdTMyICoKPiArZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX3Byb3BhZ2F0ZV9idXNf Zm10KHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4gKwkJCQkJc3RydWN0IGRybV9icmlkZ2Vf c3RhdGUgKmJyaWRnZV9zdGF0ZSwKPiArCQkJCQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNf c3RhdGUsCj4gKwkJCQkJc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCj4g KwkJCQkJdTMyIG91dHB1dF9mbXQsCj4gKwkJCQkJdW5zaWduZWQgaW50ICpudW1faW5wdXRfZm10 cyk7Cj4gKwo+ICB2b2lkIF9fZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX3Jlc2V0KHN0cnVjdCBk cm1fYnJpZGdlICpicmlkZ2UsCj4gIAkJCQkgICAgICBzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAq c3RhdGUpOwo+ICBzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqCgotLSAKUmVnYXJkcywKCkxhdXJl bnQgUGluY2hhcnQKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs