From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1757056AbcJMVQz (ORCPT ); Thu, 13 Oct 2016 17:16:55 -0400 Received: from mga05.intel.com ([192.55.52.43]:31307 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751393AbcJMVQe (ORCPT ); Thu, 13 Oct 2016 17:16:34 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.31,489,1473145200"; d="scan'208";a="19812114" Message-ID: <1476393325.2478.48.camel@intel.com> Subject: Re: [PATCH 09/10] drm/i915/gen9: Actually verify WM levels in verify_wm_state() From: Paulo Zanoni To: Lyude , intel-gfx@lists.freedesktop.org Cc: Maarten Lankhorst , Ville =?ISO-8859-1?Q?Syrj=E4l=E4?= , Daniel Vetter , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Date: Thu, 13 Oct 2016 18:15:25 -0300 In-Reply-To: <1475885497-6094-10-git-send-email-cpaul@redhat.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> <1475885497-6094-10-git-send-email-cpaul@redhat.com> Content-Type: text/plain; charset="UTF-8" X-Mailer: Evolution 3.20.5 (3.20.5-1.fc24) Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Em Sex, 2016-10-07 às 20:11 -0400, Lyude escreveu: > Thanks to Paulo Zanoni for indirectly pointing this out. > > Looks like we never actually added any code for checking whether or > not > we actually wrote watermark levels properly. Let's fix that. Thanks for doing this! Reviewed-by: Paulo Zanoni A check that would have prevented one of the bugs I solved would be "if plane is active, then level 0 must be enabled, and DDB partitioning size must be non-zero". I'll put this in my TODO list, but I won't complain if somebody does it first :) > > Signed-off-by: Lyude > Cc: Maarten Lankhorst > Cc: Ville Syrjälä > Cc: Paulo Zanoni > --- >  drivers/gpu/drm/i915/intel_display.c | 100 > +++++++++++++++++++++++++++++------ >  1 file changed, 84 insertions(+), 16 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_display.c > b/drivers/gpu/drm/i915/intel_display.c > index 39400a0..2c682bc 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -13444,30 +13444,66 @@ static void verify_wm_state(struct drm_crtc > *crtc, >   struct drm_device *dev = crtc->dev; >   struct drm_i915_private *dev_priv = to_i915(dev); >   struct skl_ddb_allocation hw_ddb, *sw_ddb; > - struct skl_ddb_entry *hw_entry, *sw_entry; > + struct skl_pipe_wm hw_wm, *sw_wm; > + struct skl_plane_wm *hw_plane_wm, *sw_plane_wm; > + struct skl_ddb_entry *hw_ddb_entry, *sw_ddb_entry; >   struct intel_crtc *intel_crtc = to_intel_crtc(crtc); >   const enum pipe pipe = intel_crtc->pipe; > - int plane; > + int plane, level, max_level = ilk_wm_max_level(dev); >   >   if (INTEL_INFO(dev)->gen < 9 || !new_state->active) >   return; >   > + skl_pipe_wm_get_hw_state(crtc, &hw_wm); > + sw_wm = &intel_crtc->wm.active.skl; > + >   skl_ddb_get_hw_state(dev_priv, &hw_ddb); >   sw_ddb = &dev_priv->wm.skl_hw.ddb; >   >   /* planes */ >   for_each_plane(dev_priv, pipe, plane) { > - hw_entry = &hw_ddb.plane[pipe][plane]; > - sw_entry = &sw_ddb->plane[pipe][plane]; > + hw_plane_wm = &hw_wm.planes[plane]; > + sw_plane_wm = &sw_wm->planes[plane]; >   > - if (skl_ddb_entry_equal(hw_entry, sw_entry)) > - continue; > + /* Watermarks */ > + for (level = 0; level <= max_level; level++) { > + if (skl_wm_level_equals(&hw_plane_wm- > >wm[level], > + &sw_plane_wm- > >wm[level])) > + continue; > + > + DRM_ERROR("mismatch in WM pipe %c plane %d > level %d (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", > +   pipe_name(pipe), plane + 1, level, > +   sw_plane_wm->wm[level].plane_en, > +   sw_plane_wm- > >wm[level].plane_res_b, > +   sw_plane_wm- > >wm[level].plane_res_l, > +   hw_plane_wm->wm[level].plane_en, > +   hw_plane_wm- > >wm[level].plane_res_b, > +   hw_plane_wm- > >wm[level].plane_res_l); > + } >   > - DRM_ERROR("mismatch in DDB state pipe %c plane %d " > -   "(expected (%u,%u), found (%u,%u))\n", > -   pipe_name(pipe), plane + 1, > -   sw_entry->start, sw_entry->end, > -   hw_entry->start, hw_entry->end); > + if (!skl_wm_level_equals(&hw_plane_wm->trans_wm, > +  &sw_plane_wm->trans_wm)) { > + DRM_ERROR("mismatch in trans WM pipe %c > plane %d (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", > +   pipe_name(pipe), plane + 1, > +   sw_plane_wm->trans_wm.plane_en, > +   sw_plane_wm->trans_wm.plane_res_b, > +   sw_plane_wm->trans_wm.plane_res_l, > +   hw_plane_wm->trans_wm.plane_en, > +   hw_plane_wm->trans_wm.plane_res_b, > +   hw_plane_wm- > >trans_wm.plane_res_l); > + } > + > + /* DDB */ > + hw_ddb_entry = &hw_ddb.plane[pipe][plane]; > + sw_ddb_entry = &sw_ddb->plane[pipe][plane]; > + > + if (!skl_ddb_entry_equal(hw_ddb_entry, > sw_ddb_entry)) { > + DRM_ERROR("mismatch in DDB state pipe %c > plane %d " > +   "(expected (%u,%u), found > (%u,%u))\n", > +   pipe_name(pipe), plane + 1, > +   sw_ddb_entry->start, sw_ddb_entry- > >end, > +   hw_ddb_entry->start, hw_ddb_entry- > >end); > + } >   } >   >   /* > @@ -13477,15 +13513,47 @@ static void verify_wm_state(struct drm_crtc > *crtc, >    * once the plane becomes visible, we can skip this check >    */ >   if (intel_crtc->cursor_addr) { > - hw_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; > - sw_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; > + hw_plane_wm = &hw_wm.planes[PLANE_CURSOR]; > + sw_plane_wm = &sw_wm->planes[PLANE_CURSOR]; > + > + /* Watermarks */ > + for (level = 0; level <= max_level; level++) { > + if (skl_wm_level_equals(&hw_plane_wm- > >wm[level], > + &sw_plane_wm- > >wm[level])) > + continue; > + > + DRM_ERROR("mismatch in WM pipe %c cursor > level %d (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", > +   pipe_name(pipe), level, > +   sw_plane_wm->wm[level].plane_en, > +   sw_plane_wm- > >wm[level].plane_res_b, > +   sw_plane_wm- > >wm[level].plane_res_l, > +   hw_plane_wm->wm[level].plane_en, > +   hw_plane_wm- > >wm[level].plane_res_b, > +   hw_plane_wm- > >wm[level].plane_res_l); > + } > + > + if (!skl_wm_level_equals(&hw_plane_wm->trans_wm, > +  &sw_plane_wm->trans_wm)) { > + DRM_ERROR("mismatch in trans WM pipe %c > cursor (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", > +   pipe_name(pipe), > +   sw_plane_wm->trans_wm.plane_en, > +   sw_plane_wm->trans_wm.plane_res_b, > +   sw_plane_wm->trans_wm.plane_res_l, > +   hw_plane_wm->trans_wm.plane_en, > +   hw_plane_wm->trans_wm.plane_res_b, > +   hw_plane_wm- > >trans_wm.plane_res_l); > + } > + > + /* DDB */ > + hw_ddb_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; > + sw_ddb_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; >   > - if (!skl_ddb_entry_equal(hw_entry, sw_entry)) { > + if (!skl_ddb_entry_equal(hw_ddb_entry, > sw_ddb_entry)) { >   DRM_ERROR("mismatch in DDB state pipe %c > cursor " >     "(expected (%u,%u), found > (%u,%u))\n", >     pipe_name(pipe), > -   sw_entry->start, sw_entry->end, > -   hw_entry->start, hw_entry->end); > +   sw_ddb_entry->start, sw_ddb_entry- > >end, > +   hw_ddb_entry->start, hw_ddb_entry- > >end); >   } >   } >  } From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paulo Zanoni Subject: Re: [PATCH 09/10] drm/i915/gen9: Actually verify WM levels in verify_wm_state() Date: Thu, 13 Oct 2016 18:15:25 -0300 Message-ID: <1476393325.2478.48.camel@intel.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> <1475885497-6094-10-git-send-email-cpaul@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1475885497-6094-10-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Lyude , intel-gfx@lists.freedesktop.org Cc: David Airlie , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Daniel Vetter List-Id: dri-devel@lists.freedesktop.org RW0gU2V4LCAyMDE2LTEwLTA3IMOgcyAyMDoxMSAtMDQwMCwgTHl1ZGUgZXNjcmV2ZXU6Cj4gVGhh bmtzIHRvIFBhdWxvIFphbm9uaSBmb3IgaW5kaXJlY3RseSBwb2ludGluZyB0aGlzIG91dC4KPiAK PiBMb29rcyBsaWtlIHdlIG5ldmVyIGFjdHVhbGx5IGFkZGVkIGFueSBjb2RlIGZvciBjaGVja2lu ZyB3aGV0aGVyIG9yCj4gbm90Cj4gd2UgYWN0dWFsbHkgd3JvdGUgd2F0ZXJtYXJrIGxldmVscyBw cm9wZXJseS4gTGV0J3MgZml4IHRoYXQuCgpUaGFua3MgZm9yIGRvaW5nIHRoaXMhCgpSZXZpZXdl ZC1ieTogUGF1bG8gWmFub25pIDxwYXVsby5yLnphbm9uaUBpbnRlbC5jb20+CgpBIGNoZWNrIHRo YXQgd291bGQgaGF2ZSBwcmV2ZW50ZWQgb25lIG9mIHRoZSBidWdzIEkgc29sdmVkIHdvdWxkIGJl ICJpZgpwbGFuZSBpcyBhY3RpdmUsIHRoZW4gbGV2ZWwgMCBtdXN0IGJlIGVuYWJsZWQsIGFuZCBE REIgcGFydGl0aW9uaW5nCnNpemUgbXVzdCBiZSBub24temVybyIuIEknbGwgcHV0IHRoaXMgaW4g bXkgVE9ETyBsaXN0LCBidXQgSSB3b24ndApjb21wbGFpbiBpZiBzb21lYm9keSBkb2VzIGl0IGZp cnN0IDopCgo+IAo+IFNpZ25lZC1vZmYtYnk6IEx5dWRlIDxjcGF1bEByZWRoYXQuY29tPgo+IENj OiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwuY29tPgo+ IENjOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgo+IENj OiBQYXVsbyBaYW5vbmkgPHBhdWxvLnIuemFub25pQGludGVsLmNvbT4KPiAtLS0KPiDCoGRyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyB8IDEwMAo+ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tLS0tCj4gwqAxIGZpbGUgY2hhbmdlZCwgODQgaW5zZXJ0aW9ucygrKSwg MTYgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2Rpc3BsYXkuYwo+IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4g aW5kZXggMzk0MDBhMC4uMmM2ODJiYyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9kaXNwbGF5LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNw bGF5LmMKPiBAQCAtMTM0NDQsMzAgKzEzNDQ0LDY2IEBAIHN0YXRpYyB2b2lkIHZlcmlmeV93bV9z dGF0ZShzdHJ1Y3QgZHJtX2NydGMKPiAqY3J0YywKPiDCoAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 ID0gY3J0Yy0+ZGV2Owo+IMKgCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRv X2k5MTUoZGV2KTsKPiDCoAlzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uIGh3X2RkYiwgKnN3X2Rk YjsKPiAtCXN0cnVjdCBza2xfZGRiX2VudHJ5ICpod19lbnRyeSwgKnN3X2VudHJ5Owo+ICsJc3Ry dWN0IHNrbF9waXBlX3dtIGh3X3dtLCAqc3dfd207Cj4gKwlzdHJ1Y3Qgc2tsX3BsYW5lX3dtICpo d19wbGFuZV93bSwgKnN3X3BsYW5lX3dtOwo+ICsJc3RydWN0IHNrbF9kZGJfZW50cnkgKmh3X2Rk Yl9lbnRyeSwgKnN3X2RkYl9lbnRyeTsKPiDCoAlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0 YyA9IHRvX2ludGVsX2NydGMoY3J0Yyk7Cj4gwqAJY29uc3QgZW51bSBwaXBlIHBpcGUgPSBpbnRl bF9jcnRjLT5waXBlOwo+IC0JaW50IHBsYW5lOwo+ICsJaW50IHBsYW5lLCBsZXZlbCwgbWF4X2xl dmVsID0gaWxrX3dtX21heF9sZXZlbChkZXYpOwo+IMKgCj4gwqAJaWYgKElOVEVMX0lORk8oZGV2 KS0+Z2VuIDwgOSB8fCAhbmV3X3N0YXRlLT5hY3RpdmUpCj4gwqAJCXJldHVybjsKPiDCoAo+ICsJ c2tsX3BpcGVfd21fZ2V0X2h3X3N0YXRlKGNydGMsICZod193bSk7Cj4gKwlzd193bSA9ICZpbnRl bF9jcnRjLT53bS5hY3RpdmUuc2tsOwo+ICsKPiDCoAlza2xfZGRiX2dldF9od19zdGF0ZShkZXZf cHJpdiwgJmh3X2RkYik7Cj4gwqAJc3dfZGRiID0gJmRldl9wcml2LT53bS5za2xfaHcuZGRiOwo+ IMKgCj4gwqAJLyogcGxhbmVzICovCj4gwqAJZm9yX2VhY2hfcGxhbmUoZGV2X3ByaXYsIHBpcGUs IHBsYW5lKSB7Cj4gLQkJaHdfZW50cnkgPSAmaHdfZGRiLnBsYW5lW3BpcGVdW3BsYW5lXTsKPiAt CQlzd19lbnRyeSA9ICZzd19kZGItPnBsYW5lW3BpcGVdW3BsYW5lXTsKPiArCQlod19wbGFuZV93 bSA9ICZod193bS5wbGFuZXNbcGxhbmVdOwo+ICsJCXN3X3BsYW5lX3dtID0gJnN3X3dtLT5wbGFu ZXNbcGxhbmVdOwo+IMKgCj4gLQkJaWYgKHNrbF9kZGJfZW50cnlfZXF1YWwoaHdfZW50cnksIHN3 X2VudHJ5KSkKPiAtCQkJY29udGludWU7Cj4gKwkJLyogV2F0ZXJtYXJrcyAqLwo+ICsJCWZvciAo bGV2ZWwgPSAwOyBsZXZlbCA8PSBtYXhfbGV2ZWw7IGxldmVsKyspIHsKPiArCQkJaWYgKHNrbF93 bV9sZXZlbF9lcXVhbHMoJmh3X3BsYW5lX3dtLQo+ID53bVtsZXZlbF0sCj4gKwkJCQkJCSZzd19w bGFuZV93bS0KPiA+d21bbGV2ZWxdKSkKPiArCQkJCWNvbnRpbnVlOwo+ICsKPiArCQkJRFJNX0VS Uk9SKCJtaXNtYXRjaCBpbiBXTSBwaXBlICVjIHBsYW5lICVkCj4gbGV2ZWwgJWQgKGV4cGVjdGVk IGU9JWQgYj0lZCBsPSVkLCBnb3QgZT0lZCBiPSVkIGw9JWQpXG4iLAo+ICsJCQkJwqDCoHBpcGVf bmFtZShwaXBlKSwgcGxhbmUgKyAxLCBsZXZlbCwKPiArCQkJCcKgwqBzd19wbGFuZV93bS0+d21b bGV2ZWxdLnBsYW5lX2VuLAo+ICsJCQkJwqDCoHN3X3BsYW5lX3dtLQo+ID53bVtsZXZlbF0ucGxh bmVfcmVzX2IsCj4gKwkJCQnCoMKgc3dfcGxhbmVfd20tCj4gPndtW2xldmVsXS5wbGFuZV9yZXNf bCwKPiArCQkJCcKgwqBod19wbGFuZV93bS0+d21bbGV2ZWxdLnBsYW5lX2VuLAo+ICsJCQkJwqDC oGh3X3BsYW5lX3dtLQo+ID53bVtsZXZlbF0ucGxhbmVfcmVzX2IsCj4gKwkJCQnCoMKgaHdfcGxh bmVfd20tCj4gPndtW2xldmVsXS5wbGFuZV9yZXNfbCk7Cj4gKwkJfQo+IMKgCj4gLQkJRFJNX0VS Uk9SKCJtaXNtYXRjaCBpbiBEREIgc3RhdGUgcGlwZSAlYyBwbGFuZSAlZCAiCj4gLQkJCcKgwqAi KGV4cGVjdGVkICgldSwldSksIGZvdW5kICgldSwldSkpXG4iLAo+IC0JCQnCoMKgcGlwZV9uYW1l KHBpcGUpLCBwbGFuZSArIDEsCj4gLQkJCcKgwqBzd19lbnRyeS0+c3RhcnQsIHN3X2VudHJ5LT5l bmQsCj4gLQkJCcKgwqBod19lbnRyeS0+c3RhcnQsIGh3X2VudHJ5LT5lbmQpOwo+ICsJCWlmICgh c2tsX3dtX2xldmVsX2VxdWFscygmaHdfcGxhbmVfd20tPnRyYW5zX3dtLAo+ICsJCQkJCcKgJnN3 X3BsYW5lX3dtLT50cmFuc193bSkpIHsKPiArCQkJRFJNX0VSUk9SKCJtaXNtYXRjaCBpbiB0cmFu cyBXTSBwaXBlICVjCj4gcGxhbmUgJWQgKGV4cGVjdGVkIGU9JWQgYj0lZCBsPSVkLCBnb3QgZT0l ZCBiPSVkIGw9JWQpXG4iLAo+ICsJCQkJwqDCoHBpcGVfbmFtZShwaXBlKSwgcGxhbmUgKyAxLAo+ ICsJCQkJwqDCoHN3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9lbiwKPiArCQkJCcKgwqBzd19w bGFuZV93bS0+dHJhbnNfd20ucGxhbmVfcmVzX2IsCj4gKwkJCQnCoMKgc3dfcGxhbmVfd20tPnRy YW5zX3dtLnBsYW5lX3Jlc19sLAo+ICsJCQkJwqDCoGh3X3BsYW5lX3dtLT50cmFuc193bS5wbGFu ZV9lbiwKPiArCQkJCcKgwqBod19wbGFuZV93bS0+dHJhbnNfd20ucGxhbmVfcmVzX2IsCj4gKwkJ CQnCoMKgaHdfcGxhbmVfd20tCj4gPnRyYW5zX3dtLnBsYW5lX3Jlc19sKTsKPiArCQl9Cj4gKwo+ ICsJCS8qIEREQiAqLwo+ICsJCWh3X2RkYl9lbnRyeSA9ICZod19kZGIucGxhbmVbcGlwZV1bcGxh bmVdOwo+ICsJCXN3X2RkYl9lbnRyeSA9ICZzd19kZGItPnBsYW5lW3BpcGVdW3BsYW5lXTsKPiAr Cj4gKwkJaWYgKCFza2xfZGRiX2VudHJ5X2VxdWFsKGh3X2RkYl9lbnRyeSwKPiBzd19kZGJfZW50 cnkpKSB7Cj4gKwkJCURSTV9FUlJPUigibWlzbWF0Y2ggaW4gRERCIHN0YXRlIHBpcGUgJWMKPiBw bGFuZSAlZCAiCj4gKwkJCQnCoMKgIihleHBlY3RlZCAoJXUsJXUpLCBmb3VuZAo+ICgldSwldSkp XG4iLAo+ICsJCQkJwqDCoHBpcGVfbmFtZShwaXBlKSwgcGxhbmUgKyAxLAo+ICsJCQkJwqDCoHN3 X2RkYl9lbnRyeS0+c3RhcnQsIHN3X2RkYl9lbnRyeS0KPiA+ZW5kLAo+ICsJCQkJwqDCoGh3X2Rk Yl9lbnRyeS0+c3RhcnQsIGh3X2RkYl9lbnRyeS0KPiA+ZW5kKTsKPiArCQl9Cj4gwqAJfQo+IMKg Cj4gwqAJLyoKPiBAQCAtMTM0NzcsMTUgKzEzNTEzLDQ3IEBAIHN0YXRpYyB2b2lkIHZlcmlmeV93 bV9zdGF0ZShzdHJ1Y3QgZHJtX2NydGMKPiAqY3J0YywKPiDCoAnCoCogb25jZSB0aGUgcGxhbmUg YmVjb21lcyB2aXNpYmxlLCB3ZSBjYW4gc2tpcCB0aGlzIGNoZWNrCj4gwqAJwqAqLwo+IMKgCWlm IChpbnRlbF9jcnRjLT5jdXJzb3JfYWRkcikgewo+IC0JCWh3X2VudHJ5ID0gJmh3X2RkYi5wbGFu ZVtwaXBlXVtQTEFORV9DVVJTT1JdOwo+IC0JCXN3X2VudHJ5ID0gJnN3X2RkYi0+cGxhbmVbcGlw ZV1bUExBTkVfQ1VSU09SXTsKPiArCQlod19wbGFuZV93bSA9ICZod193bS5wbGFuZXNbUExBTkVf Q1VSU09SXTsKPiArCQlzd19wbGFuZV93bSA9ICZzd193bS0+cGxhbmVzW1BMQU5FX0NVUlNPUl07 Cj4gKwo+ICsJCS8qIFdhdGVybWFya3MgKi8KPiArCQlmb3IgKGxldmVsID0gMDsgbGV2ZWwgPD0g bWF4X2xldmVsOyBsZXZlbCsrKSB7Cj4gKwkJCWlmIChza2xfd21fbGV2ZWxfZXF1YWxzKCZod19w bGFuZV93bS0KPiA+d21bbGV2ZWxdLAo+ICsJCQkJCQkmc3dfcGxhbmVfd20tCj4gPndtW2xldmVs XSkpCj4gKwkJCQljb250aW51ZTsKPiArCj4gKwkJCURSTV9FUlJPUigibWlzbWF0Y2ggaW4gV00g cGlwZSAlYyBjdXJzb3IKPiBsZXZlbCAlZCAoZXhwZWN0ZWQgZT0lZCBiPSVkIGw9JWQsIGdvdCBl PSVkIGI9JWQgbD0lZClcbiIsCj4gKwkJCQnCoMKgcGlwZV9uYW1lKHBpcGUpLCBsZXZlbCwKPiAr CQkJCcKgwqBzd19wbGFuZV93bS0+d21bbGV2ZWxdLnBsYW5lX2VuLAo+ICsJCQkJwqDCoHN3X3Bs YW5lX3dtLQo+ID53bVtsZXZlbF0ucGxhbmVfcmVzX2IsCj4gKwkJCQnCoMKgc3dfcGxhbmVfd20t Cj4gPndtW2xldmVsXS5wbGFuZV9yZXNfbCwKPiArCQkJCcKgwqBod19wbGFuZV93bS0+d21bbGV2 ZWxdLnBsYW5lX2VuLAo+ICsJCQkJwqDCoGh3X3BsYW5lX3dtLQo+ID53bVtsZXZlbF0ucGxhbmVf cmVzX2IsCj4gKwkJCQnCoMKgaHdfcGxhbmVfd20tCj4gPndtW2xldmVsXS5wbGFuZV9yZXNfbCk7 Cj4gKwkJfQo+ICsKPiArCQlpZiAoIXNrbF93bV9sZXZlbF9lcXVhbHMoJmh3X3BsYW5lX3dtLT50 cmFuc193bSwKPiArCQkJCQnCoCZzd19wbGFuZV93bS0+dHJhbnNfd20pKSB7Cj4gKwkJCURSTV9F UlJPUigibWlzbWF0Y2ggaW4gdHJhbnMgV00gcGlwZSAlYwo+IGN1cnNvciAoZXhwZWN0ZWQgZT0l ZCBiPSVkIGw9JWQsIGdvdCBlPSVkIGI9JWQgbD0lZClcbiIsCj4gKwkJCQnCoMKgcGlwZV9uYW1l KHBpcGUpLAo+ICsJCQkJwqDCoHN3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9lbiwKPiArCQkJ CcKgwqBzd19wbGFuZV93bS0+dHJhbnNfd20ucGxhbmVfcmVzX2IsCj4gKwkJCQnCoMKgc3dfcGxh bmVfd20tPnRyYW5zX3dtLnBsYW5lX3Jlc19sLAo+ICsJCQkJwqDCoGh3X3BsYW5lX3dtLT50cmFu c193bS5wbGFuZV9lbiwKPiArCQkJCcKgwqBod19wbGFuZV93bS0+dHJhbnNfd20ucGxhbmVfcmVz X2IsCj4gKwkJCQnCoMKgaHdfcGxhbmVfd20tCj4gPnRyYW5zX3dtLnBsYW5lX3Jlc19sKTsKPiAr CQl9Cj4gKwo+ICsJCS8qIEREQiAqLwo+ICsJCWh3X2RkYl9lbnRyeSA9ICZod19kZGIucGxhbmVb cGlwZV1bUExBTkVfQ1VSU09SXTsKPiArCQlzd19kZGJfZW50cnkgPSAmc3dfZGRiLT5wbGFuZVtw aXBlXVtQTEFORV9DVVJTT1JdOwo+IMKgCj4gLQkJaWYgKCFza2xfZGRiX2VudHJ5X2VxdWFsKGh3 X2VudHJ5LCBzd19lbnRyeSkpIHsKPiArCQlpZiAoIXNrbF9kZGJfZW50cnlfZXF1YWwoaHdfZGRi X2VudHJ5LAo+IHN3X2RkYl9lbnRyeSkpIHsKPiDCoAkJCURSTV9FUlJPUigibWlzbWF0Y2ggaW4g RERCIHN0YXRlIHBpcGUgJWMKPiBjdXJzb3IgIgo+IMKgCQkJCcKgwqAiKGV4cGVjdGVkICgldSwl dSksIGZvdW5kCj4gKCV1LCV1KSlcbiIsCj4gwqAJCQkJwqDCoHBpcGVfbmFtZShwaXBlKSwKPiAt CQkJCcKgwqBzd19lbnRyeS0+c3RhcnQsIHN3X2VudHJ5LT5lbmQsCj4gLQkJCQnCoMKgaHdfZW50 cnktPnN0YXJ0LCBod19lbnRyeS0+ZW5kKTsKPiArCQkJCcKgwqBzd19kZGJfZW50cnktPnN0YXJ0 LCBzd19kZGJfZW50cnktCj4gPmVuZCwKPiArCQkJCcKgwqBod19kZGJfZW50cnktPnN0YXJ0LCBo d19kZGJfZW50cnktCj4gPmVuZCk7Cj4gwqAJCX0KPiDCoAl9Cj4gwqB9Cl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QK SW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=