From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ed1-f68.google.com ([209.85.208.68]:36884 "EHLO mail-ed1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728003AbeJBSyl (ORCPT ); Tue, 2 Oct 2018 14:54:41 -0400 Received: by mail-ed1-f68.google.com with SMTP id c22-v6so1841948edc.4 for ; Tue, 02 Oct 2018 05:11:39 -0700 (PDT) Date: Tue, 2 Oct 2018 14:11:34 +0200 From: Daniel Vetter To: Ville Syrjala Cc: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, Dennis , stable@vger.kernel.org Subject: Re: [Intel-gfx] [PATCH 2/3] drm/i915: Use the correct crtc when sanitizing plane mapping Message-ID: <20181002121134.GN11082@phenom.ffwll.local> References: <20181001142909.5567-1-ville.syrjala@linux.intel.com> <20181001143120.5777-1-ville.syrjala@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20181001143120.5777-1-ville.syrjala@linux.intel.com> Sender: stable-owner@vger.kernel.org List-ID: On Mon, Oct 01, 2018 at 05:31:20PM +0300, Ville Syrjala wrote: > From: Ville Syrj�l� > > When we decide that a plane is attached to the wrong pipe we try > to turn off said plane. However we are passing around the crtc we > think that the plane is supposed to be using rather than the crtc > it is currently using. That doesn't work all that well because > we may have to do vblank waits etc. and the other pipe might > not even be enabled here. So let's pass the plane's current crtc to > intel_plane_disable_noatomic() so that it can its job correctly. > > To do that semi-cleanly we also have to change the plane readout > to record the plane's visibility into the bitmasks of the crtc > where the plane is currently enabled rather than to the crtc > we want to use for the plane. > > One caveat here is that our active_planes bitmask will get confused > if both planes are enabled on the same pipe. Fortunately we can use > plane_mask to reconstruct active_planes sufficiently since > plane_mask still has the same meaning (is the plane visible?) > during readout. We also have to do the same during the initial > plane readout as the second plane could clear the active_planes > bit the first plane had already set. How often have we broken this :-/ Unfortunately I still don't have a good idea how to best CI this, since we shut down everything on module unload. Maybe we should have a special mode for module unload to leave the hw on, so that we can start testing various fastboot scenarios ... Some questions below. > Cc: stable@vger.kernel.org # fcba862e8428 drm/i915: Have plane->get_hw_state() return the current pipe > Cc: stable@vger.kernel.org > Cc: Dennis > Tested-by: Dennis > Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=105637 > Fixes: b1e01595a66d ("drm/i915: Redo plane sanitation during readout") > Signed-off-by: Ville Syrj�l� > --- > drivers/gpu/drm/i915/intel_display.c | 63 +++++++++++++++++++++++++++--------- > 1 file changed, 47 insertions(+), 16 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index e018b37bed39..c72be8cd1f54 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -15475,15 +15475,16 @@ void i830_disable_pipe(struct drm_i915_private *dev_priv, enum pipe pipe) > POSTING_READ(DPLL(pipe)); > } > > -static bool intel_plane_mapping_ok(struct intel_crtc *crtc, > - struct intel_plane *plane) > +static void fixup_active_planes(struct intel_crtc *crtc) > { > - enum pipe pipe; > - > - if (!plane->get_hw_state(plane, &pipe)) > - return true; > + struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); > + struct intel_crtc_state *crtc_state = > + to_intel_crtc_state(crtc->base.state); > + struct drm_plane *plane; > > - return pipe == crtc->pipe; > + drm_for_each_plane_mask(plane, &dev_priv->drm, > + crtc_state->base.plane_mask) > + crtc_state->active_planes |= BIT(to_intel_plane(plane)->id); I think we need to also update plane_mask here. > } > > static void > @@ -15497,13 +15498,28 @@ intel_sanitize_plane_mapping(struct drm_i915_private *dev_priv) > for_each_intel_crtc(&dev_priv->drm, crtc) { > struct intel_plane *plane = > to_intel_plane(crtc->base.primary); > + struct intel_crtc *plane_crtc; > + enum pipe pipe; > + > + if (!plane->get_hw_state(plane, &pipe)) > + continue; > > - if (intel_plane_mapping_ok(crtc, plane)) > + if (pipe == crtc->pipe) > continue; > > DRM_DEBUG_KMS("%s attached to the wrong pipe, disabling plane\n", > plane->base.name); > - intel_plane_disable_noatomic(crtc, plane); > + > + plane_crtc = intel_get_crtc_for_pipe(dev_priv, pipe); > + intel_plane_disable_noatomic(plane_crtc, plane); > + > + /* > + * Our active_planes tracking will get confused here > + * if both planes A and B are enabled on the same pipe > + * (since both planes map to BIT(PLANE_PRIMARY)). > + * Reconstruct active_planes after disabling the plane. > + */ Hm, would be neat if we could retire intel_crtc_state->active_planes in favour of drm_crtc_state->plane_mask. Except for that entire visible y/n thing :-/ > + fixup_active_planes(plane_crtc); Bit a bikeshed, but what about throwing the plane state away and just starting over, instead of trying to fix it up? We could then use that as a consistency check, if the plane mappings are still wrong our code is broken and we should bail out with a very loud warning. But this here should work too, albeit a bit more fragile I think. Cheers, Daniel > } > } > > @@ -15671,23 +15687,38 @@ void i915_redisable_vga(struct drm_i915_private *dev_priv) > } > > /* FIXME read out full plane state for all planes */ > -static void readout_plane_state(struct intel_crtc *crtc) > +static void readout_plane_state(struct drm_i915_private *dev_priv) > { > - struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); > - struct intel_crtc_state *crtc_state = > - to_intel_crtc_state(crtc->base.state); > struct intel_plane *plane; > + struct intel_crtc *crtc; > > - for_each_intel_plane_on_crtc(&dev_priv->drm, crtc, plane) { > + for_each_intel_plane(&dev_priv->drm, plane) { > struct intel_plane_state *plane_state = > to_intel_plane_state(plane->base.state); > + struct intel_crtc_state *crtc_state; > enum pipe pipe; > bool visible; > > visible = plane->get_hw_state(plane, &pipe); > > + crtc = intel_get_crtc_for_pipe(dev_priv, pipe); > + crtc_state = to_intel_crtc_state(crtc->base.state); > + > intel_set_plane_visible(crtc_state, plane_state, visible); > } > + > + for_each_intel_crtc(&dev_priv->drm, crtc) { > + /* > + * Our active_planes tracking may get confused here > + * on gen2/3 if the first plane is enabled but the > + * second one isn't but both indicate the same pipe. > + * The second plane would clear the active_planes > + * bit for the first plane (since both map to > + * BIT(PLANE_PRIMARY). Reconstruct active_planes > + * after plane readout is done. > + */ > + fixup_active_planes(crtc); > + } > } > > static void intel_modeset_readout_hw_state(struct drm_device *dev) > @@ -15719,13 +15750,13 @@ static void intel_modeset_readout_hw_state(struct drm_device *dev) > if (crtc_state->base.active) > dev_priv->active_crtcs |= 1 << crtc->pipe; > > - readout_plane_state(crtc); > - > DRM_DEBUG_KMS("[CRTC:%d:%s] hw state readout: %s\n", > crtc->base.base.id, crtc->base.name, > enableddisabled(crtc_state->base.active)); > } > > + readout_plane_state(dev_priv); > + > for (i = 0; i < dev_priv->num_shared_dpll; i++) { > struct intel_shared_dpll *pll = &dev_priv->shared_dplls[i]; > > -- > 2.16.4 > > _______________________________________________ > Intel-gfx mailing list > Intel-gfx@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/intel-gfx -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [Intel-gfx] [PATCH 2/3] drm/i915: Use the correct crtc when sanitizing plane mapping Date: Tue, 2 Oct 2018 14:11:34 +0200 Message-ID: <20181002121134.GN11082@phenom.ffwll.local> References: <20181001142909.5567-1-ville.syrjala@linux.intel.com> <20181001143120.5777-1-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-ed1-x544.google.com (mail-ed1-x544.google.com [IPv6:2a00:1450:4864:20::544]) by gabe.freedesktop.org (Postfix) with ESMTPS id CE6D26E0EB for ; Tue, 2 Oct 2018 12:11:39 +0000 (UTC) Received: by mail-ed1-x544.google.com with SMTP id c1-v6so1832839ede.5 for ; Tue, 02 Oct 2018 05:11:39 -0700 (PDT) Content-Disposition: inline In-Reply-To: <20181001143120.5777-1-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Ville Syrjala Cc: stable@vger.kernel.org, intel-gfx@lists.freedesktop.org, Dennis , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gTW9uLCBPY3QgMDEsIDIwMTggYXQgMDU6MzE6MjBQTSArMDMwMCwgVmlsbGUgU3lyamFsYSB3 cm90ZToKPiBGcm9tOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwu Y29tPgo+IAo+IFdoZW4gd2UgZGVjaWRlIHRoYXQgYSBwbGFuZSBpcyBhdHRhY2hlZCB0byB0aGUg d3JvbmcgcGlwZSB3ZSB0cnkKPiB0byB0dXJuIG9mZiBzYWlkIHBsYW5lLiBIb3dldmVyIHdlIGFy ZSBwYXNzaW5nIGFyb3VuZCB0aGUgY3J0YyB3ZQo+IHRoaW5rIHRoYXQgdGhlIHBsYW5lIGlzIHN1 cHBvc2VkIHRvIGJlIHVzaW5nIHJhdGhlciB0aGFuIHRoZSBjcnRjCj4gaXQgaXMgY3VycmVudGx5 IHVzaW5nLiBUaGF0IGRvZXNuJ3Qgd29yayBhbGwgdGhhdCB3ZWxsIGJlY2F1c2UKPiB3ZSBtYXkg aGF2ZSB0byBkbyB2Ymxhbmsgd2FpdHMgZXRjLiBhbmQgdGhlIG90aGVyIHBpcGUgbWlnaHQKPiBu b3QgZXZlbiBiZSBlbmFibGVkIGhlcmUuIFNvIGxldCdzIHBhc3MgdGhlIHBsYW5lJ3MgY3VycmVu dCBjcnRjIHRvCj4gaW50ZWxfcGxhbmVfZGlzYWJsZV9ub2F0b21pYygpIHNvIHRoYXQgaXQgY2Fu IGl0cyBqb2IgY29ycmVjdGx5Lgo+IAo+IFRvIGRvIHRoYXQgc2VtaS1jbGVhbmx5IHdlIGFsc28g aGF2ZSB0byBjaGFuZ2UgdGhlIHBsYW5lIHJlYWRvdXQKPiB0byByZWNvcmQgdGhlIHBsYW5lJ3Mg dmlzaWJpbGl0eSBpbnRvIHRoZSBiaXRtYXNrcyBvZiB0aGUgY3J0Ywo+IHdoZXJlIHRoZSBwbGFu ZSBpcyBjdXJyZW50bHkgZW5hYmxlZCByYXRoZXIgdGhhbiB0byB0aGUgY3J0Ywo+IHdlIHdhbnQg dG8gdXNlIGZvciB0aGUgcGxhbmUuCj4gCj4gT25lIGNhdmVhdCBoZXJlIGlzIHRoYXQgb3VyIGFj dGl2ZV9wbGFuZXMgYml0bWFzayB3aWxsIGdldCBjb25mdXNlZAo+IGlmIGJvdGggcGxhbmVzIGFy ZSBlbmFibGVkIG9uIHRoZSBzYW1lIHBpcGUuIEZvcnR1bmF0ZWx5IHdlIGNhbiB1c2UKPiBwbGFu ZV9tYXNrIHRvIHJlY29uc3RydWN0IGFjdGl2ZV9wbGFuZXMgc3VmZmljaWVudGx5IHNpbmNlCj4g cGxhbmVfbWFzayBzdGlsbCBoYXMgdGhlIHNhbWUgbWVhbmluZyAoaXMgdGhlIHBsYW5lIHZpc2li bGU/KQo+IGR1cmluZyByZWFkb3V0LiBXZSBhbHNvIGhhdmUgdG8gZG8gdGhlIHNhbWUgZHVyaW5n IHRoZSBpbml0aWFsCj4gcGxhbmUgcmVhZG91dCBhcyB0aGUgc2Vjb25kIHBsYW5lIGNvdWxkIGNs ZWFyIHRoZSBhY3RpdmVfcGxhbmVzCj4gYml0IHRoZSBmaXJzdCBwbGFuZSBoYWQgYWxyZWFkeSBz ZXQuCgpIb3cgb2Z0ZW4gaGF2ZSB3ZSBicm9rZW4gdGhpcyA6LS8KClVuZm9ydHVuYXRlbHkgSSBz dGlsbCBkb24ndCBoYXZlIGEgZ29vZCBpZGVhIGhvdyB0byBiZXN0IENJIHRoaXMsIHNpbmNlIHdl CnNodXQgZG93biBldmVyeXRoaW5nIG9uIG1vZHVsZSB1bmxvYWQuIE1heWJlIHdlIHNob3VsZCBo YXZlIGEgc3BlY2lhbCBtb2RlCmZvciBtb2R1bGUgdW5sb2FkIHRvIGxlYXZlIHRoZSBodyBvbiwg c28gdGhhdCB3ZSBjYW4gc3RhcnQgdGVzdGluZyB2YXJpb3VzCmZhc3Rib290IHNjZW5hcmlvcyAu Li4KClNvbWUgcXVlc3Rpb25zIGJlbG93LgoKPiBDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZyAj IGZjYmE4NjJlODQyOCBkcm0vaTkxNTogSGF2ZSBwbGFuZS0+Z2V0X2h3X3N0YXRlKCkgcmV0dXJu IHRoZSBjdXJyZW50IHBpcGUKPiBDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZwo+IENjOiBEZW5u aXMgPGRlbm5pcy5uZXppY0B1dG9yb250by5jYT4KPiBUZXN0ZWQtYnk6IERlbm5pcyA8ZGVubmlz Lm5lemljQHV0b3JvbnRvLmNhPgo+IEJ1Z3ppbGxhOiBodHRwczovL2J1Z3MuZnJlZWRlc2t0b3Au b3JnL3Nob3dfYnVnLmNnaT9pZD0xMDU2MzcKPiBGaXhlczogYjFlMDE1OTVhNjZkICgiZHJtL2k5 MTU6IFJlZG8gcGxhbmUgc2FuaXRhdGlvbiBkdXJpbmcgcmVhZG91dCIpCj4gU2lnbmVkLW9mZi1i eTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiAtLS0K PiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIHwgNjMgKysrKysrKysrKysr KysrKysrKysrKysrKysrLS0tLS0tLS0tCj4gIDEgZmlsZSBjaGFuZ2VkLCA0NyBpbnNlcnRpb25z KCspLCAxNiBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZGlzcGxheS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5j Cj4gaW5kZXggZTAxOGIzN2JlZDM5Li5jNzJiZThjZDFmNTQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZGlzcGxheS5jCj4gQEAgLTE1NDc1LDE1ICsxNTQ3NSwxNiBAQCB2b2lkIGk4MzBf ZGlzYWJsZV9waXBlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgZW51bSBwaXBl IHBpcGUpCj4gIAlQT1NUSU5HX1JFQUQoRFBMTChwaXBlKSk7Cj4gIH0KPiAgCj4gLXN0YXRpYyBi b29sIGludGVsX3BsYW5lX21hcHBpbmdfb2soc3RydWN0IGludGVsX2NydGMgKmNydGMsCj4gLQkJ CQkgICBzdHJ1Y3QgaW50ZWxfcGxhbmUgKnBsYW5lKQo+ICtzdGF0aWMgdm9pZCBmaXh1cF9hY3Rp dmVfcGxhbmVzKHN0cnVjdCBpbnRlbF9jcnRjICpjcnRjKQo+ICB7Cj4gLQllbnVtIHBpcGUgcGlw ZTsKPiAtCj4gLQlpZiAoIXBsYW5lLT5nZXRfaHdfc3RhdGUocGxhbmUsICZwaXBlKSkKPiAtCQly ZXR1cm4gdHJ1ZTsKPiArCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5 MTUoY3J0Yy0+YmFzZS5kZXYpOwo+ICsJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3Rh dGUgPQo+ICsJCXRvX2ludGVsX2NydGNfc3RhdGUoY3J0Yy0+YmFzZS5zdGF0ZSk7Cj4gKwlzdHJ1 Y3QgZHJtX3BsYW5lICpwbGFuZTsKPiAgCj4gLQlyZXR1cm4gcGlwZSA9PSBjcnRjLT5waXBlOwo+ ICsJZHJtX2Zvcl9lYWNoX3BsYW5lX21hc2socGxhbmUsICZkZXZfcHJpdi0+ZHJtLAo+ICsJCQkJ Y3J0Y19zdGF0ZS0+YmFzZS5wbGFuZV9tYXNrKQo+ICsJCWNydGNfc3RhdGUtPmFjdGl2ZV9wbGFu ZXMgfD0gQklUKHRvX2ludGVsX3BsYW5lKHBsYW5lKS0+aWQpOwoKSSB0aGluayB3ZSBuZWVkIHRv IGFsc28gdXBkYXRlIHBsYW5lX21hc2sgaGVyZS4KCj4gIH0KPiAgCj4gIHN0YXRpYyB2b2lkCj4g QEAgLTE1NDk3LDEzICsxNTQ5OCwyOCBAQCBpbnRlbF9zYW5pdGl6ZV9wbGFuZV9tYXBwaW5nKHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKPiAgCWZvcl9lYWNoX2ludGVsX2NydGMo JmRldl9wcml2LT5kcm0sIGNydGMpIHsKPiAgCQlzdHJ1Y3QgaW50ZWxfcGxhbmUgKnBsYW5lID0K PiAgCQkJdG9faW50ZWxfcGxhbmUoY3J0Yy0+YmFzZS5wcmltYXJ5KTsKPiArCQlzdHJ1Y3QgaW50 ZWxfY3J0YyAqcGxhbmVfY3J0YzsKPiArCQllbnVtIHBpcGUgcGlwZTsKPiArCj4gKwkJaWYgKCFw bGFuZS0+Z2V0X2h3X3N0YXRlKHBsYW5lLCAmcGlwZSkpCj4gKwkJCWNvbnRpbnVlOwo+ICAKPiAt CQlpZiAoaW50ZWxfcGxhbmVfbWFwcGluZ19vayhjcnRjLCBwbGFuZSkpCj4gKwkJaWYgKHBpcGUg PT0gY3J0Yy0+cGlwZSkKPiAgCQkJY29udGludWU7Cj4gIAo+ICAJCURSTV9ERUJVR19LTVMoIiVz IGF0dGFjaGVkIHRvIHRoZSB3cm9uZyBwaXBlLCBkaXNhYmxpbmcgcGxhbmVcbiIsCj4gIAkJCSAg ICAgIHBsYW5lLT5iYXNlLm5hbWUpOwo+IC0JCWludGVsX3BsYW5lX2Rpc2FibGVfbm9hdG9taWMo Y3J0YywgcGxhbmUpOwo+ICsKPiArCQlwbGFuZV9jcnRjID0gaW50ZWxfZ2V0X2NydGNfZm9yX3Bp cGUoZGV2X3ByaXYsIHBpcGUpOwo+ICsJCWludGVsX3BsYW5lX2Rpc2FibGVfbm9hdG9taWMocGxh bmVfY3J0YywgcGxhbmUpOwo+ICsKPiArCQkvKgo+ICsJCSAqIE91ciBhY3RpdmVfcGxhbmVzIHRy YWNraW5nIHdpbGwgZ2V0IGNvbmZ1c2VkIGhlcmUKPiArCQkgKiBpZiBib3RoIHBsYW5lcyBBIGFu ZCBCIGFyZSBlbmFibGVkIG9uIHRoZSBzYW1lIHBpcGUKPiArCQkgKiAoc2luY2UgYm90aCBwbGFu ZXMgbWFwIHRvIEJJVChQTEFORV9QUklNQVJZKSkuCj4gKwkJICogUmVjb25zdHJ1Y3QgYWN0aXZl X3BsYW5lcyBhZnRlciBkaXNhYmxpbmcgdGhlIHBsYW5lLgo+ICsJCSAqLwoKSG0sIHdvdWxkIGJl IG5lYXQgaWYgd2UgY291bGQgcmV0aXJlIGludGVsX2NydGNfc3RhdGUtPmFjdGl2ZV9wbGFuZXMg aW4KZmF2b3VyIG9mIGRybV9jcnRjX3N0YXRlLT5wbGFuZV9tYXNrLiBFeGNlcHQgZm9yIHRoYXQg ZW50aXJlIHZpc2libGUgeS9uCnRoaW5nIDotLwoKPiArCQlmaXh1cF9hY3RpdmVfcGxhbmVzKHBs YW5lX2NydGMpOwoKQml0IGEgYmlrZXNoZWQsIGJ1dCB3aGF0IGFib3V0IHRocm93aW5nIHRoZSBw bGFuZSBzdGF0ZSBhd2F5IGFuZCBqdXN0CnN0YXJ0aW5nIG92ZXIsIGluc3RlYWQgb2YgdHJ5aW5n IHRvIGZpeCBpdCB1cD8gV2UgY291bGQgdGhlbiB1c2UgdGhhdCBhcyBhCmNvbnNpc3RlbmN5IGNo ZWNrLCBpZiB0aGUgcGxhbmUgbWFwcGluZ3MgYXJlIHN0aWxsIHdyb25nIG91ciBjb2RlIGlzCmJy b2tlbiBhbmQgd2Ugc2hvdWxkIGJhaWwgb3V0IHdpdGggYSB2ZXJ5IGxvdWQgd2FybmluZy4KCkJ1 dCB0aGlzIGhlcmUgc2hvdWxkIHdvcmsgdG9vLCBhbGJlaXQgYSBiaXQgbW9yZSBmcmFnaWxlIEkg dGhpbmsuCgpDaGVlcnMsIERhbmllbAo+ICAJfQo+ICB9Cj4gIAo+IEBAIC0xNTY3MSwyMyArMTU2 ODcsMzggQEAgdm9pZCBpOTE1X3JlZGlzYWJsZV92Z2Eoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg KmRldl9wcml2KQo+ICB9Cj4gIAo+ICAvKiBGSVhNRSByZWFkIG91dCBmdWxsIHBsYW5lIHN0YXRl IGZvciBhbGwgcGxhbmVzICovCj4gLXN0YXRpYyB2b2lkIHJlYWRvdXRfcGxhbmVfc3RhdGUoc3Ry dWN0IGludGVsX2NydGMgKmNydGMpCj4gK3N0YXRpYyB2b2lkIHJlYWRvdXRfcGxhbmVfc3RhdGUo c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQo+ICB7Cj4gLQlzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGNydGMtPmJhc2UuZGV2KTsKPiAtCXN0cnVj dCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlID0KPiAtCQl0b19pbnRlbF9jcnRjX3N0YXRl KGNydGMtPmJhc2Uuc3RhdGUpOwo+ICAJc3RydWN0IGludGVsX3BsYW5lICpwbGFuZTsKPiArCXN0 cnVjdCBpbnRlbF9jcnRjICpjcnRjOwo+ICAKPiAtCWZvcl9lYWNoX2ludGVsX3BsYW5lX29uX2Ny dGMoJmRldl9wcml2LT5kcm0sIGNydGMsIHBsYW5lKSB7Cj4gKwlmb3JfZWFjaF9pbnRlbF9wbGFu ZSgmZGV2X3ByaXYtPmRybSwgcGxhbmUpIHsKPiAgCQlzdHJ1Y3QgaW50ZWxfcGxhbmVfc3RhdGUg KnBsYW5lX3N0YXRlID0KPiAgCQkJdG9faW50ZWxfcGxhbmVfc3RhdGUocGxhbmUtPmJhc2Uuc3Rh dGUpOwo+ICsJCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlOwo+ICAJCWVudW0g cGlwZSBwaXBlOwo+ICAJCWJvb2wgdmlzaWJsZTsKPiAgCj4gIAkJdmlzaWJsZSA9IHBsYW5lLT5n ZXRfaHdfc3RhdGUocGxhbmUsICZwaXBlKTsKPiAgCj4gKwkJY3J0YyA9IGludGVsX2dldF9jcnRj X2Zvcl9waXBlKGRldl9wcml2LCBwaXBlKTsKPiArCQljcnRjX3N0YXRlID0gdG9faW50ZWxfY3J0 Y19zdGF0ZShjcnRjLT5iYXNlLnN0YXRlKTsKPiArCj4gIAkJaW50ZWxfc2V0X3BsYW5lX3Zpc2li bGUoY3J0Y19zdGF0ZSwgcGxhbmVfc3RhdGUsIHZpc2libGUpOwo+ICAJfQo+ICsKPiArCWZvcl9l YWNoX2ludGVsX2NydGMoJmRldl9wcml2LT5kcm0sIGNydGMpIHsKPiArCQkvKgo+ICsJCSAqIE91 ciBhY3RpdmVfcGxhbmVzIHRyYWNraW5nIG1heSBnZXQgY29uZnVzZWQgaGVyZQo+ICsJCSAqIG9u IGdlbjIvMyBpZiB0aGUgZmlyc3QgcGxhbmUgaXMgZW5hYmxlZCBidXQgdGhlCj4gKwkJICogc2Vj b25kIG9uZSBpc24ndCBidXQgYm90aCBpbmRpY2F0ZSB0aGUgc2FtZSBwaXBlLgo+ICsJCSAqIFRo ZSBzZWNvbmQgcGxhbmUgd291bGQgY2xlYXIgdGhlIGFjdGl2ZV9wbGFuZXMKPiArCQkgKiBiaXQg Zm9yIHRoZSBmaXJzdCBwbGFuZSAoc2luY2UgYm90aCBtYXAgdG8KPiArCQkgKiBCSVQoUExBTkVf UFJJTUFSWSkuIFJlY29uc3RydWN0IGFjdGl2ZV9wbGFuZXMKPiArCQkgKiBhZnRlciBwbGFuZSBy ZWFkb3V0IGlzIGRvbmUuCj4gKwkJICovCj4gKwkJZml4dXBfYWN0aXZlX3BsYW5lcyhjcnRjKTsK PiArCX0KPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQgaW50ZWxfbW9kZXNldF9yZWFkb3V0X2h3X3N0 YXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gQEAgLTE1NzE5LDEzICsxNTc1MCwxMyBAQCBz dGF0aWMgdm9pZCBpbnRlbF9tb2Rlc2V0X3JlYWRvdXRfaHdfc3RhdGUoc3RydWN0IGRybV9kZXZp Y2UgKmRldikKPiAgCQlpZiAoY3J0Y19zdGF0ZS0+YmFzZS5hY3RpdmUpCj4gIAkJCWRldl9wcml2 LT5hY3RpdmVfY3J0Y3MgfD0gMSA8PCBjcnRjLT5waXBlOwo+ICAKPiAtCQlyZWFkb3V0X3BsYW5l X3N0YXRlKGNydGMpOwo+IC0KPiAgCQlEUk1fREVCVUdfS01TKCJbQ1JUQzolZDolc10gaHcgc3Rh dGUgcmVhZG91dDogJXNcbiIsCj4gIAkJCSAgICAgIGNydGMtPmJhc2UuYmFzZS5pZCwgY3J0Yy0+ YmFzZS5uYW1lLAo+ICAJCQkgICAgICBlbmFibGVkZGlzYWJsZWQoY3J0Y19zdGF0ZS0+YmFzZS5h Y3RpdmUpKTsKPiAgCX0KPiAgCj4gKwlyZWFkb3V0X3BsYW5lX3N0YXRlKGRldl9wcml2KTsKPiAr Cj4gIAlmb3IgKGkgPSAwOyBpIDwgZGV2X3ByaXYtPm51bV9zaGFyZWRfZHBsbDsgaSsrKSB7Cj4g IAkJc3RydWN0IGludGVsX3NoYXJlZF9kcGxsICpwbGwgPSAmZGV2X3ByaXYtPnNoYXJlZF9kcGxs c1tpXTsKPiAgCj4gLS0gCj4gMi4xNi40Cj4gCj4gX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KPiBJbnRlbC1nZnggbWFpbGluZyBsaXN0Cj4gSW50ZWwtZ2Z4 QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4CgotLSAKRGFuaWVsIFZldHRlcgpTb2Z0d2FyZSBFbmdp bmVlciwgSW50ZWwgQ29ycG9yYXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlz dApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==