From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm0-f65.google.com ([74.125.82.65]:33816 "EHLO mail-wm0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S965799AbcDMJ5G (ORCPT ); Wed, 13 Apr 2016 05:57:06 -0400 Received: by mail-wm0-f65.google.com with SMTP id n3so12404576wmn.1 for ; Wed, 13 Apr 2016 02:57:05 -0700 (PDT) Date: Wed, 13 Apr 2016 11:57:21 +0200 From: Daniel Vetter To: Chris Wilson Cc: intel-gfx@lists.freedesktop.org, Daniel Vetter , Tvrtko Ursulin , stable@vger.kernel.org, John Harrison Subject: Re: [CI-ping 15/15] drm/i915: Late request cancellations are harmful Message-ID: <20160413095721.GR2510@phenom.ffwll.local> References: <1460491389-8602-1-git-send-email-chris@chris-wilson.co.uk> <1460491389-8602-15-git-send-email-chris@chris-wilson.co.uk> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1460491389-8602-15-git-send-email-chris@chris-wilson.co.uk> Sender: stable-owner@vger.kernel.org List-ID: On Tue, Apr 12, 2016 at 09:03:09PM +0100, Chris Wilson wrote: > Conceptually, each request is a record of a hardware transaction - we > build up a list of pending commands and then either commit them to > hardware, or cancel them. However, whilst building up the list of > pending commands, we may modify state outside of the request and make > references to the pending request. If we do so and then cancel that > request, external objects then point to the deleted request leading to > both graphical and memory corruption. > > The easiest example is to consider object/VMA tracking. When we mark an > object as active in a request, we store a pointer to this, the most > recent request, in the object. Then we want to free that object, we wait > for the most recent request to be idle before proceeding (otherwise the > hardware will write to pages now owned by the system, or we will attempt > to read from those pages before the hardware is finished writing). If > the request was cancelled instead, that wait completes immediately. As a > result, all requests must be committed and not cancelled if the external > state is unknown. > > All that remains of i915_gem_request_cancel() users are just a couple of > extremely unlikely allocation failures, so remove the API entirely. > > A consequence of committing all incomplete requests is that we generate > excess breadcrumbs and fill the ring much more often with dummy work. We > have completely undone the outstanding_last_seqno optimisation. > > Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=93907 > Signed-off-by: Chris Wilson > Cc: Daniel Vetter > Cc: Tvrtko Ursulin > Cc: stable@vger.kernel.org Cc: John Harrison I'd like John's ack on this on too, but patch itself looks sound. Fast r-b since we've discussed this a while ago already ... Reviewed-by: Daniel Vetter > --- > drivers/gpu/drm/i915/i915_drv.h | 2 -- > drivers/gpu/drm/i915/i915_gem.c | 50 ++++++++++++------------------ > drivers/gpu/drm/i915/i915_gem_execbuffer.c | 15 +++------ > drivers/gpu/drm/i915/intel_display.c | 2 +- > drivers/gpu/drm/i915/intel_lrc.c | 4 +-- > drivers/gpu/drm/i915/intel_overlay.c | 8 ++--- > 6 files changed, 30 insertions(+), 51 deletions(-) > > diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h > index 061ecc43d935..de84dd7be971 100644 > --- a/drivers/gpu/drm/i915/i915_drv.h > +++ b/drivers/gpu/drm/i915/i915_drv.h > @@ -2331,7 +2331,6 @@ struct drm_i915_gem_request { > struct drm_i915_gem_request * __must_check > i915_gem_request_alloc(struct intel_engine_cs *engine, > struct intel_context *ctx); > -void i915_gem_request_cancel(struct drm_i915_gem_request *req); > void i915_gem_request_free(struct kref *req_ref); > int i915_gem_request_add_to_client(struct drm_i915_gem_request *req, > struct drm_file *file); > @@ -2883,7 +2882,6 @@ int i915_gem_sw_finish_ioctl(struct drm_device *dev, void *data, > struct drm_file *file_priv); > void i915_gem_execbuffer_move_to_active(struct list_head *vmas, > struct drm_i915_gem_request *req); > -void i915_gem_execbuffer_retire_commands(struct i915_execbuffer_params *params); > int i915_gem_ringbuffer_submission(struct i915_execbuffer_params *params, > struct drm_i915_gem_execbuffer2 *args, > struct list_head *vmas); > diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c > index b6879d43dd74..c6f09e7839ea 100644 > --- a/drivers/gpu/drm/i915/i915_gem.c > +++ b/drivers/gpu/drm/i915/i915_gem.c > @@ -2785,7 +2785,8 @@ __i915_gem_request_alloc(struct intel_engine_cs *engine, > * fully prepared. Thus it can be cleaned up using the proper > * free code. > */ > - i915_gem_request_cancel(req); > + intel_ring_reserved_space_cancel(req->ringbuf); > + i915_gem_request_unreference(req); > return ret; > } > > @@ -2822,13 +2823,6 @@ i915_gem_request_alloc(struct intel_engine_cs *engine, > return err ? ERR_PTR(err) : req; > } > > -void i915_gem_request_cancel(struct drm_i915_gem_request *req) > -{ > - intel_ring_reserved_space_cancel(req->ringbuf); > - > - i915_gem_request_unreference(req); > -} > - > struct drm_i915_gem_request * > i915_gem_find_active_request(struct intel_engine_cs *engine) > { > @@ -3438,12 +3432,9 @@ int i915_gpu_idle(struct drm_device *dev) > return PTR_ERR(req); > > ret = i915_switch_context(req); > - if (ret) { > - i915_gem_request_cancel(req); > - return ret; > - } > - > i915_add_request_no_flush(req); > + if (ret) > + return ret; > } > > ret = intel_engine_idle(engine); > @@ -4943,34 +4934,33 @@ i915_gem_init_hw(struct drm_device *dev) > req = i915_gem_request_alloc(engine, NULL); > if (IS_ERR(req)) { > ret = PTR_ERR(req); > - i915_gem_cleanup_engines(dev); > - goto out; > + break; > } > > if (engine->id == RCS) { > - for (j = 0; j < NUM_L3_SLICES(dev); j++) > - i915_gem_l3_remap(req, j); > + for (j = 0; j < NUM_L3_SLICES(dev); j++) { > + ret = i915_gem_l3_remap(req, j); > + if (ret) > + goto err_request; > + } > } > > ret = i915_ppgtt_init_ring(req); > - if (ret && ret != -EIO) { > - DRM_ERROR("PPGTT enable %s failed %d\n", > - engine->name, ret); > - i915_gem_request_cancel(req); > - i915_gem_cleanup_engines(dev); > - goto out; > - } > + if (ret) > + goto err_request; > > ret = i915_gem_context_enable(req); > - if (ret && ret != -EIO) { > - DRM_ERROR("Context enable %s failed %d\n", > + if (ret) > + goto err_request; > + > +err_request: > + i915_add_request_no_flush(req); > + if (ret) { > + DRM_ERROR("Failed to enable %s, error=%d\n", > engine->name, ret); > - i915_gem_request_cancel(req); > i915_gem_cleanup_engines(dev); > - goto out; > + break; > } > - > - i915_add_request_no_flush(req); > } > > out: > diff --git a/drivers/gpu/drm/i915/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/i915_gem_execbuffer.c > index 6ee4f00f620c..6f4f2a6cdf93 100644 > --- a/drivers/gpu/drm/i915/i915_gem_execbuffer.c > +++ b/drivers/gpu/drm/i915/i915_gem_execbuffer.c > @@ -1137,7 +1137,7 @@ i915_gem_execbuffer_move_to_active(struct list_head *vmas, > } > } > > -void > +static void > i915_gem_execbuffer_retire_commands(struct i915_execbuffer_params *params) > { > /* Unconditionally force add_request to emit a full flush. */ > @@ -1322,7 +1322,6 @@ i915_gem_ringbuffer_submission(struct i915_execbuffer_params *params, > trace_i915_gem_ring_dispatch(params->request, params->dispatch_flags); > > i915_gem_execbuffer_move_to_active(vmas, params->request); > - i915_gem_execbuffer_retire_commands(params); > > return 0; > } > @@ -1624,7 +1623,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data, > > ret = i915_gem_request_add_to_client(req, file); > if (ret) > - goto err_batch_unpin; > + goto err_request; > > /* > * Save assorted stuff away to pass through to *_submission(). > @@ -1641,6 +1640,8 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data, > params->request = req; > > ret = dev_priv->gt.execbuf_submit(params, args, &eb->vmas); > +err_request: > + i915_gem_execbuffer_retire_commands(params); > > err_batch_unpin: > /* > @@ -1657,14 +1658,6 @@ err: > i915_gem_context_unreference(ctx); > eb_destroy(eb); > > - /* > - * If the request was created but not successfully submitted then it > - * must be freed again. If it was submitted then it is being tracked > - * on the active request list and no clean up is required here. > - */ > - if (ret && !IS_ERR_OR_NULL(req)) > - i915_gem_request_cancel(req); > - > mutex_unlock(&dev->struct_mutex); > > pre_mutex_err: > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index b1b457864e17..3cae596d10a3 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -11664,7 +11664,7 @@ cleanup_unpin: > intel_unpin_fb_obj(fb, crtc->primary->state->rotation); > cleanup_pending: > if (!IS_ERR_OR_NULL(request)) > - i915_gem_request_cancel(request); > + i915_add_request_no_flush(request); > atomic_dec(&intel_crtc->unpin_work_count); > mutex_unlock(&dev->struct_mutex); > cleanup: > diff --git a/drivers/gpu/drm/i915/intel_lrc.c b/drivers/gpu/drm/i915/intel_lrc.c > index b8f6b96472a6..6fc24deaa16a 100644 > --- a/drivers/gpu/drm/i915/intel_lrc.c > +++ b/drivers/gpu/drm/i915/intel_lrc.c > @@ -1010,7 +1010,6 @@ int intel_execlists_submission(struct i915_execbuffer_params *params, > trace_i915_gem_ring_dispatch(params->request, params->dispatch_flags); > > i915_gem_execbuffer_move_to_active(vmas, params->request); > - i915_gem_execbuffer_retire_commands(params); > > return 0; > } > @@ -2679,13 +2678,12 @@ int intel_lr_context_deferred_alloc(struct intel_context *ctx, > } > > ret = engine->init_context(req); > + i915_add_request_no_flush(req); > if (ret) { > DRM_ERROR("ring init context: %d\n", > ret); > - i915_gem_request_cancel(req); > goto error_ringbuf; > } > - i915_add_request_no_flush(req); > } > return 0; > > diff --git a/drivers/gpu/drm/i915/intel_overlay.c b/drivers/gpu/drm/i915/intel_overlay.c > index 6694e9230cd5..bcc3b6a016d8 100644 > --- a/drivers/gpu/drm/i915/intel_overlay.c > +++ b/drivers/gpu/drm/i915/intel_overlay.c > @@ -247,7 +247,7 @@ static int intel_overlay_on(struct intel_overlay *overlay) > > ret = intel_ring_begin(req, 4); > if (ret) { > - i915_gem_request_cancel(req); > + i915_add_request_no_flush(req); > return ret; > } > > @@ -290,7 +290,7 @@ static int intel_overlay_continue(struct intel_overlay *overlay, > > ret = intel_ring_begin(req, 2); > if (ret) { > - i915_gem_request_cancel(req); > + i915_add_request_no_flush(req); > return ret; > } > > @@ -356,7 +356,7 @@ static int intel_overlay_off(struct intel_overlay *overlay) > > ret = intel_ring_begin(req, 6); > if (ret) { > - i915_gem_request_cancel(req); > + i915_add_request_no_flush(req); > return ret; > } > > @@ -431,7 +431,7 @@ static int intel_overlay_release_old_vid(struct intel_overlay *overlay) > > ret = intel_ring_begin(req, 2); > if (ret) { > - i915_gem_request_cancel(req); > + i915_add_request_no_flush(req); > return ret; > } > > -- > 2.8.0.rc3 > -- 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: [CI-ping 15/15] drm/i915: Late request cancellations are harmful Date: Wed, 13 Apr 2016 11:57:21 +0200 Message-ID: <20160413095721.GR2510@phenom.ffwll.local> References: <1460491389-8602-1-git-send-email-chris@chris-wilson.co.uk> <1460491389-8602-15-git-send-email-chris@chris-wilson.co.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x244.google.com (mail-wm0-x244.google.com [IPv6:2a00:1450:400c:c09::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id F0C276E3B5 for ; Wed, 13 Apr 2016 09:57:05 +0000 (UTC) Received: by mail-wm0-x244.google.com with SMTP id a140so12396824wma.2 for ; Wed, 13 Apr 2016 02:57:05 -0700 (PDT) Content-Disposition: inline In-Reply-To: <1460491389-8602-15-git-send-email-chris@chris-wilson.co.uk> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Chris Wilson Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, stable@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org T24gVHVlLCBBcHIgMTIsIDIwMTYgYXQgMDk6MDM6MDlQTSArMDEwMCwgQ2hyaXMgV2lsc29uIHdy b3RlOgo+IENvbmNlcHR1YWxseSwgZWFjaCByZXF1ZXN0IGlzIGEgcmVjb3JkIG9mIGEgaGFyZHdh cmUgdHJhbnNhY3Rpb24gLSB3ZQo+IGJ1aWxkIHVwIGEgbGlzdCBvZiBwZW5kaW5nIGNvbW1hbmRz IGFuZCB0aGVuIGVpdGhlciBjb21taXQgdGhlbSB0bwo+IGhhcmR3YXJlLCBvciBjYW5jZWwgdGhl bS4gSG93ZXZlciwgd2hpbHN0IGJ1aWxkaW5nIHVwIHRoZSBsaXN0IG9mCj4gcGVuZGluZyBjb21t YW5kcywgd2UgbWF5IG1vZGlmeSBzdGF0ZSBvdXRzaWRlIG9mIHRoZSByZXF1ZXN0IGFuZCBtYWtl Cj4gcmVmZXJlbmNlcyB0byB0aGUgcGVuZGluZyByZXF1ZXN0LiBJZiB3ZSBkbyBzbyBhbmQgdGhl biBjYW5jZWwgdGhhdAo+IHJlcXVlc3QsIGV4dGVybmFsIG9iamVjdHMgdGhlbiBwb2ludCB0byB0 aGUgZGVsZXRlZCByZXF1ZXN0IGxlYWRpbmcgdG8KPiBib3RoIGdyYXBoaWNhbCBhbmQgbWVtb3J5 IGNvcnJ1cHRpb24uCj4gCj4gVGhlIGVhc2llc3QgZXhhbXBsZSBpcyB0byBjb25zaWRlciBvYmpl Y3QvVk1BIHRyYWNraW5nLiBXaGVuIHdlIG1hcmsgYW4KPiBvYmplY3QgYXMgYWN0aXZlIGluIGEg cmVxdWVzdCwgd2Ugc3RvcmUgYSBwb2ludGVyIHRvIHRoaXMsIHRoZSBtb3N0Cj4gcmVjZW50IHJl cXVlc3QsIGluIHRoZSBvYmplY3QuIFRoZW4gd2Ugd2FudCB0byBmcmVlIHRoYXQgb2JqZWN0LCB3 ZSB3YWl0Cj4gZm9yIHRoZSBtb3N0IHJlY2VudCByZXF1ZXN0IHRvIGJlIGlkbGUgYmVmb3JlIHBy b2NlZWRpbmcgKG90aGVyd2lzZSB0aGUKPiBoYXJkd2FyZSB3aWxsIHdyaXRlIHRvIHBhZ2VzIG5v dyBvd25lZCBieSB0aGUgc3lzdGVtLCBvciB3ZSB3aWxsIGF0dGVtcHQKPiB0byByZWFkIGZyb20g dGhvc2UgcGFnZXMgYmVmb3JlIHRoZSBoYXJkd2FyZSBpcyBmaW5pc2hlZCB3cml0aW5nKS4gSWYK PiB0aGUgcmVxdWVzdCB3YXMgY2FuY2VsbGVkIGluc3RlYWQsIHRoYXQgd2FpdCBjb21wbGV0ZXMg aW1tZWRpYXRlbHkuIEFzIGEKPiByZXN1bHQsIGFsbCByZXF1ZXN0cyBtdXN0IGJlIGNvbW1pdHRl ZCBhbmQgbm90IGNhbmNlbGxlZCBpZiB0aGUgZXh0ZXJuYWwKPiBzdGF0ZSBpcyB1bmtub3duLgo+ IAo+IEFsbCB0aGF0IHJlbWFpbnMgb2YgaTkxNV9nZW1fcmVxdWVzdF9jYW5jZWwoKSB1c2VycyBh cmUganVzdCBhIGNvdXBsZSBvZgo+IGV4dHJlbWVseSB1bmxpa2VseSBhbGxvY2F0aW9uIGZhaWx1 cmVzLCBzbyByZW1vdmUgdGhlIEFQSSBlbnRpcmVseS4KPiAKPiBBIGNvbnNlcXVlbmNlIG9mIGNv bW1pdHRpbmcgYWxsIGluY29tcGxldGUgcmVxdWVzdHMgaXMgdGhhdCB3ZSBnZW5lcmF0ZQo+IGV4 Y2VzcyBicmVhZGNydW1icyBhbmQgZmlsbCB0aGUgcmluZyBtdWNoIG1vcmUgb2Z0ZW4gd2l0aCBk dW1teSB3b3JrLiBXZQo+IGhhdmUgY29tcGxldGVseSB1bmRvbmUgdGhlIG91dHN0YW5kaW5nX2xh c3Rfc2Vxbm8gb3B0aW1pc2F0aW9uLgo+IAo+IEJ1Z3ppbGxhOiBodHRwczovL2J1Z3MuZnJlZWRl c2t0b3Aub3JnL3Nob3dfYnVnLmNnaT9pZD05MzkwNwo+IFNpZ25lZC1vZmYtYnk6IENocmlzIFdp bHNvbiA8Y2hyaXNAY2hyaXMtd2lsc29uLmNvLnVrPgo+IENjOiBEYW5pZWwgVmV0dGVyIDxkYW5p ZWwudmV0dGVyQGZmd2xsLmNoPgo+IENjOiBUdnJ0a28gVXJzdWxpbiA8dHZydGtvLnVyc3VsaW5A bGludXguaW50ZWwuY29tPgo+IENjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCgpDYzogSm9obiBI YXJyaXNvbiA8Sm9obi5DLkhhcnJpc29uQEludGVsLmNvbT4KCkknZCBsaWtlIEpvaG4ncyBhY2sg b24gdGhpcyBvbiB0b28sIGJ1dCBwYXRjaCBpdHNlbGYgbG9va3Mgc291bmQuIEZhc3Qgci1iCnNp bmNlIHdlJ3ZlIGRpc2N1c3NlZCB0aGlzIGEgd2hpbGUgYWdvIGFscmVhZHkgLi4uCgpSZXZpZXdl ZC1ieTogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KPiAtLS0KPiAgZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCAgICAgICAgICAgIHwgIDIgLS0KPiAgZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYyAgICAgICAgICAgIHwgNTAgKysrKysrKysrKysrLS0t LS0tLS0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2V4ZWNidWZm ZXIuYyB8IDE1ICsrKy0tLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5 LmMgICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9scmMuYyAgICAg ICAgICAgfCAgNCArLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfb3ZlcmxheS5jICAg ICAgIHwgIDggKystLS0KPiAgNiBmaWxlcyBjaGFuZ2VkLCAzMCBpbnNlcnRpb25zKCspLCA1MSBk ZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9k cnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKPiBpbmRleCAwNjFlY2M0M2Q5 MzUuLmRlODRkZDdiZTk3MSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAo+IEBAIC0yMzMx LDcgKzIzMzEsNiBAQCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX3JlcXVlc3Qgewo+ICBzdHJ1Y3QgZHJt X2k5MTVfZ2VtX3JlcXVlc3QgKiBfX211c3RfY2hlY2sKPiAgaTkxNV9nZW1fcmVxdWVzdF9hbGxv YyhzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCj4gIAkJICAgICAgIHN0cnVjdCBpbnRl bF9jb250ZXh0ICpjdHgpOwo+IC12b2lkIGk5MTVfZ2VtX3JlcXVlc3RfY2FuY2VsKHN0cnVjdCBk cm1faTkxNV9nZW1fcmVxdWVzdCAqcmVxKTsKPiAgdm9pZCBpOTE1X2dlbV9yZXF1ZXN0X2ZyZWUo c3RydWN0IGtyZWYgKnJlcV9yZWYpOwo+ICBpbnQgaTkxNV9nZW1fcmVxdWVzdF9hZGRfdG9fY2xp ZW50KHN0cnVjdCBkcm1faTkxNV9nZW1fcmVxdWVzdCAqcmVxLAo+ICAJCQkJICAgc3RydWN0IGRy bV9maWxlICpmaWxlKTsKPiBAQCAtMjg4Myw3ICsyODgyLDYgQEAgaW50IGk5MTVfZ2VtX3N3X2Zp bmlzaF9pb2N0bChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAo+ICAJCQkgICAg IHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2KTsKPiAgdm9pZCBpOTE1X2dlbV9leGVjYnVmZmVy X21vdmVfdG9fYWN0aXZlKHN0cnVjdCBsaXN0X2hlYWQgKnZtYXMsCj4gIAkJCQkJc3RydWN0IGRy bV9pOTE1X2dlbV9yZXF1ZXN0ICpyZXEpOwo+IC12b2lkIGk5MTVfZ2VtX2V4ZWNidWZmZXJfcmV0 aXJlX2NvbW1hbmRzKHN0cnVjdCBpOTE1X2V4ZWNidWZmZXJfcGFyYW1zICpwYXJhbXMpOwo+ICBp bnQgaTkxNV9nZW1fcmluZ2J1ZmZlcl9zdWJtaXNzaW9uKHN0cnVjdCBpOTE1X2V4ZWNidWZmZXJf cGFyYW1zICpwYXJhbXMsCj4gIAkJCQkgICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2V4ZWNidWZmZXIy ICphcmdzLAo+ICAJCQkJICAgc3RydWN0IGxpc3RfaGVhZCAqdm1hcyk7Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2dlbS5jCj4gaW5kZXggYjY4NzlkNDNkZDc0Li5jNmYwOWU3ODM5ZWEgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfZ2VtLmMKPiBAQCAtMjc4NSw3ICsyNzg1LDggQEAgX19pOTE1X2dlbV9yZXF1 ZXN0X2FsbG9jKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKPiAgCQkgKiBmdWxseSBw cmVwYXJlZC4gVGh1cyBpdCBjYW4gYmUgY2xlYW5lZCB1cCB1c2luZyB0aGUgcHJvcGVyCj4gIAkJ ICogZnJlZSBjb2RlLgo+ICAJCSAqLwo+IC0JCWk5MTVfZ2VtX3JlcXVlc3RfY2FuY2VsKHJlcSk7 Cj4gKwkJaW50ZWxfcmluZ19yZXNlcnZlZF9zcGFjZV9jYW5jZWwocmVxLT5yaW5nYnVmKTsKPiAr CQlpOTE1X2dlbV9yZXF1ZXN0X3VucmVmZXJlbmNlKHJlcSk7Cj4gIAkJcmV0dXJuIHJldDsKPiAg CX0KPiAgCj4gQEAgLTI4MjIsMTMgKzI4MjMsNiBAQCBpOTE1X2dlbV9yZXF1ZXN0X2FsbG9jKHN0 cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKPiAgCXJldHVybiBlcnIgPyBFUlJfUFRSKGVy cikgOiByZXE7Cj4gIH0KPiAgCj4gLXZvaWQgaTkxNV9nZW1fcmVxdWVzdF9jYW5jZWwoc3RydWN0 IGRybV9pOTE1X2dlbV9yZXF1ZXN0ICpyZXEpCj4gLXsKPiAtCWludGVsX3JpbmdfcmVzZXJ2ZWRf c3BhY2VfY2FuY2VsKHJlcS0+cmluZ2J1Zik7Cj4gLQo+IC0JaTkxNV9nZW1fcmVxdWVzdF91bnJl ZmVyZW5jZShyZXEpOwo+IC19Cj4gLQo+ICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX3JlcXVlc3QgKgo+ ICBpOTE1X2dlbV9maW5kX2FjdGl2ZV9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVu Z2luZSkKPiAgewo+IEBAIC0zNDM4LDEyICszNDMyLDkgQEAgaW50IGk5MTVfZ3B1X2lkbGUoc3Ry dWN0IGRybV9kZXZpY2UgKmRldikKPiAgCQkJCXJldHVybiBQVFJfRVJSKHJlcSk7Cj4gIAo+ICAJ CQlyZXQgPSBpOTE1X3N3aXRjaF9jb250ZXh0KHJlcSk7Cj4gLQkJCWlmIChyZXQpIHsKPiAtCQkJ CWk5MTVfZ2VtX3JlcXVlc3RfY2FuY2VsKHJlcSk7Cj4gLQkJCQlyZXR1cm4gcmV0Owo+IC0JCQl9 Cj4gLQo+ICAJCQlpOTE1X2FkZF9yZXF1ZXN0X25vX2ZsdXNoKHJlcSk7Cj4gKwkJCWlmIChyZXQp Cj4gKwkJCQlyZXR1cm4gcmV0Owo+ICAJCX0KPiAgCj4gIAkJcmV0ID0gaW50ZWxfZW5naW5lX2lk bGUoZW5naW5lKTsKPiBAQCAtNDk0MywzNCArNDkzNCwzMyBAQCBpOTE1X2dlbV9pbml0X2h3KHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gIAkJcmVxID0gaTkxNV9nZW1fcmVxdWVzdF9hbGxvYyhl bmdpbmUsIE5VTEwpOwo+ICAJCWlmIChJU19FUlIocmVxKSkgewo+ICAJCQlyZXQgPSBQVFJfRVJS KHJlcSk7Cj4gLQkJCWk5MTVfZ2VtX2NsZWFudXBfZW5naW5lcyhkZXYpOwo+IC0JCQlnb3RvIG91 dDsKPiArCQkJYnJlYWs7Cj4gIAkJfQo+ICAKPiAgCQlpZiAoZW5naW5lLT5pZCA9PSBSQ1MpIHsK PiAtCQkJZm9yIChqID0gMDsgaiA8IE5VTV9MM19TTElDRVMoZGV2KTsgaisrKQo+IC0JCQkJaTkx NV9nZW1fbDNfcmVtYXAocmVxLCBqKTsKPiArCQkJZm9yIChqID0gMDsgaiA8IE5VTV9MM19TTElD RVMoZGV2KTsgaisrKSB7Cj4gKwkJCQlyZXQgPSBpOTE1X2dlbV9sM19yZW1hcChyZXEsIGopOwo+ ICsJCQkJaWYgKHJldCkKPiArCQkJCQlnb3RvIGVycl9yZXF1ZXN0Owo+ICsJCQl9Cj4gIAkJfQo+ ICAKPiAgCQlyZXQgPSBpOTE1X3BwZ3R0X2luaXRfcmluZyhyZXEpOwo+IC0JCWlmIChyZXQgJiYg cmV0ICE9IC1FSU8pIHsKPiAtCQkJRFJNX0VSUk9SKCJQUEdUVCBlbmFibGUgJXMgZmFpbGVkICVk XG4iLAo+IC0JCQkJICBlbmdpbmUtPm5hbWUsIHJldCk7Cj4gLQkJCWk5MTVfZ2VtX3JlcXVlc3Rf Y2FuY2VsKHJlcSk7Cj4gLQkJCWk5MTVfZ2VtX2NsZWFudXBfZW5naW5lcyhkZXYpOwo+IC0JCQln b3RvIG91dDsKPiAtCQl9Cj4gKwkJaWYgKHJldCkKPiArCQkJZ290byBlcnJfcmVxdWVzdDsKPiAg Cj4gIAkJcmV0ID0gaTkxNV9nZW1fY29udGV4dF9lbmFibGUocmVxKTsKPiAtCQlpZiAocmV0ICYm IHJldCAhPSAtRUlPKSB7Cj4gLQkJCURSTV9FUlJPUigiQ29udGV4dCBlbmFibGUgJXMgZmFpbGVk ICVkXG4iLAo+ICsJCWlmIChyZXQpCj4gKwkJCWdvdG8gZXJyX3JlcXVlc3Q7Cj4gKwo+ICtlcnJf cmVxdWVzdDoKPiArCQlpOTE1X2FkZF9yZXF1ZXN0X25vX2ZsdXNoKHJlcSk7Cj4gKwkJaWYgKHJl dCkgewo+ICsJCQlEUk1fRVJST1IoIkZhaWxlZCB0byBlbmFibGUgJXMsIGVycm9yPSVkXG4iLAo+ ICAJCQkJICBlbmdpbmUtPm5hbWUsIHJldCk7Cj4gLQkJCWk5MTVfZ2VtX3JlcXVlc3RfY2FuY2Vs KHJlcSk7Cj4gIAkJCWk5MTVfZ2VtX2NsZWFudXBfZW5naW5lcyhkZXYpOwo+IC0JCQlnb3RvIG91 dDsKPiArCQkJYnJlYWs7Cj4gIAkJfQo+IC0KPiAtCQlpOTE1X2FkZF9yZXF1ZXN0X25vX2ZsdXNo KHJlcSk7Cj4gIAl9Cj4gIAo+ICBvdXQ6Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfZ2VtX2V4ZWNidWZmZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2Vt X2V4ZWNidWZmZXIuYwo+IGluZGV4IDZlZTRmMDBmNjIwYy4uNmY0ZjJhNmNkZjkzIDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2V4ZWNidWZmZXIuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2V4ZWNidWZmZXIuYwo+IEBAIC0xMTM3LDcg KzExMzcsNyBAQCBpOTE1X2dlbV9leGVjYnVmZmVyX21vdmVfdG9fYWN0aXZlKHN0cnVjdCBsaXN0 X2hlYWQgKnZtYXMsCj4gIAl9Cj4gIH0KPiAgCj4gLXZvaWQKPiArc3RhdGljIHZvaWQKPiAgaTkx NV9nZW1fZXhlY2J1ZmZlcl9yZXRpcmVfY29tbWFuZHMoc3RydWN0IGk5MTVfZXhlY2J1ZmZlcl9w YXJhbXMgKnBhcmFtcykKPiAgewo+ICAJLyogVW5jb25kaXRpb25hbGx5IGZvcmNlIGFkZF9yZXF1 ZXN0IHRvIGVtaXQgYSBmdWxsIGZsdXNoLiAqLwo+IEBAIC0xMzIyLDcgKzEzMjIsNiBAQCBpOTE1 X2dlbV9yaW5nYnVmZmVyX3N1Ym1pc3Npb24oc3RydWN0IGk5MTVfZXhlY2J1ZmZlcl9wYXJhbXMg KnBhcmFtcywKPiAgCXRyYWNlX2k5MTVfZ2VtX3JpbmdfZGlzcGF0Y2gocGFyYW1zLT5yZXF1ZXN0 LCBwYXJhbXMtPmRpc3BhdGNoX2ZsYWdzKTsKPiAgCj4gIAlpOTE1X2dlbV9leGVjYnVmZmVyX21v dmVfdG9fYWN0aXZlKHZtYXMsIHBhcmFtcy0+cmVxdWVzdCk7Cj4gLQlpOTE1X2dlbV9leGVjYnVm ZmVyX3JldGlyZV9jb21tYW5kcyhwYXJhbXMpOwo+ICAKPiAgCXJldHVybiAwOwo+ICB9Cj4gQEAg LTE2MjQsNyArMTYyMyw3IEBAIGk5MTVfZ2VtX2RvX2V4ZWNidWZmZXIoc3RydWN0IGRybV9kZXZp Y2UgKmRldiwgdm9pZCAqZGF0YSwKPiAgCj4gIAlyZXQgPSBpOTE1X2dlbV9yZXF1ZXN0X2FkZF90 b19jbGllbnQocmVxLCBmaWxlKTsKPiAgCWlmIChyZXQpCj4gLQkJZ290byBlcnJfYmF0Y2hfdW5w aW47Cj4gKwkJZ290byBlcnJfcmVxdWVzdDsKPiAgCj4gIAkvKgo+ICAJICogU2F2ZSBhc3NvcnRl ZCBzdHVmZiBhd2F5IHRvIHBhc3MgdGhyb3VnaCB0byAqX3N1Ym1pc3Npb24oKS4KPiBAQCAtMTY0 MSw2ICsxNjQwLDggQEAgaTkxNV9nZW1fZG9fZXhlY2J1ZmZlcihzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2LCB2b2lkICpkYXRhLAo+ICAJcGFyYW1zLT5yZXF1ZXN0ICAgICAgICAgICAgICAgICA9IHJl cTsKPiAgCj4gIAlyZXQgPSBkZXZfcHJpdi0+Z3QuZXhlY2J1Zl9zdWJtaXQocGFyYW1zLCBhcmdz LCAmZWItPnZtYXMpOwo+ICtlcnJfcmVxdWVzdDoKPiArCWk5MTVfZ2VtX2V4ZWNidWZmZXJfcmV0 aXJlX2NvbW1hbmRzKHBhcmFtcyk7Cj4gIAo+ICBlcnJfYmF0Y2hfdW5waW46Cj4gIAkvKgo+IEBA IC0xNjU3LDE0ICsxNjU4LDYgQEAgZXJyOgo+ICAJaTkxNV9nZW1fY29udGV4dF91bnJlZmVyZW5j ZShjdHgpOwo+ICAJZWJfZGVzdHJveShlYik7Cj4gIAo+IC0JLyoKPiAtCSAqIElmIHRoZSByZXF1 ZXN0IHdhcyBjcmVhdGVkIGJ1dCBub3Qgc3VjY2Vzc2Z1bGx5IHN1Ym1pdHRlZCB0aGVuIGl0Cj4g LQkgKiBtdXN0IGJlIGZyZWVkIGFnYWluLiBJZiBpdCB3YXMgc3VibWl0dGVkIHRoZW4gaXQgaXMg YmVpbmcgdHJhY2tlZAo+IC0JICogb24gdGhlIGFjdGl2ZSByZXF1ZXN0IGxpc3QgYW5kIG5vIGNs ZWFuIHVwIGlzIHJlcXVpcmVkIGhlcmUuCj4gLQkgKi8KPiAtCWlmIChyZXQgJiYgIUlTX0VSUl9P Ul9OVUxMKHJlcSkpCj4gLQkJaTkxNV9nZW1fcmVxdWVzdF9jYW5jZWwocmVxKTsKPiAtCj4gIAlt dXRleF91bmxvY2soJmRldi0+c3RydWN0X211dGV4KTsKPiAgCj4gIHByZV9tdXRleF9lcnI6Cj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IGluZGV4IGIxYjQ1Nzg2NGUxNy4uM2Nh ZTU5NmQxMGEzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3Bs YXkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IEBAIC0x MTY2NCw3ICsxMTY2NCw3IEBAIGNsZWFudXBfdW5waW46Cj4gIAlpbnRlbF91bnBpbl9mYl9vYmoo ZmIsIGNydGMtPnByaW1hcnktPnN0YXRlLT5yb3RhdGlvbik7Cj4gIGNsZWFudXBfcGVuZGluZzoK PiAgCWlmICghSVNfRVJSX09SX05VTEwocmVxdWVzdCkpCj4gLQkJaTkxNV9nZW1fcmVxdWVzdF9j YW5jZWwocmVxdWVzdCk7Cj4gKwkJaTkxNV9hZGRfcmVxdWVzdF9ub19mbHVzaChyZXF1ZXN0KTsK PiAgCWF0b21pY19kZWMoJmludGVsX2NydGMtPnVucGluX3dvcmtfY291bnQpOwo+ICAJbXV0ZXhf dW5sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7Cj4gIGNsZWFudXA6Cj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2xyYy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfbHJjLmMKPiBpbmRleCBiOGY2Yjk2NDcyYTYuLjZmYzI0ZGVhYTE2YSAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9scmMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2xyYy5jCj4gQEAgLTEwMTAsNyArMTAxMCw2IEBAIGludCBpbnRlbF9leGVj bGlzdHNfc3VibWlzc2lvbihzdHJ1Y3QgaTkxNV9leGVjYnVmZmVyX3BhcmFtcyAqcGFyYW1zLAo+ ICAJdHJhY2VfaTkxNV9nZW1fcmluZ19kaXNwYXRjaChwYXJhbXMtPnJlcXVlc3QsIHBhcmFtcy0+ ZGlzcGF0Y2hfZmxhZ3MpOwo+ICAKPiAgCWk5MTVfZ2VtX2V4ZWNidWZmZXJfbW92ZV90b19hY3Rp dmUodm1hcywgcGFyYW1zLT5yZXF1ZXN0KTsKPiAtCWk5MTVfZ2VtX2V4ZWNidWZmZXJfcmV0aXJl X2NvbW1hbmRzKHBhcmFtcyk7Cj4gIAo+ICAJcmV0dXJuIDA7Cj4gIH0KPiBAQCAtMjY3OSwxMyAr MjY3OCwxMiBAQCBpbnQgaW50ZWxfbHJfY29udGV4dF9kZWZlcnJlZF9hbGxvYyhzdHJ1Y3QgaW50 ZWxfY29udGV4dCAqY3R4LAo+ICAJCX0KPiAgCj4gIAkJcmV0ID0gZW5naW5lLT5pbml0X2NvbnRl eHQocmVxKTsKPiArCQlpOTE1X2FkZF9yZXF1ZXN0X25vX2ZsdXNoKHJlcSk7Cj4gIAkJaWYgKHJl dCkgewo+ICAJCQlEUk1fRVJST1IoInJpbmcgaW5pdCBjb250ZXh0OiAlZFxuIiwKPiAgCQkJCXJl dCk7Cj4gLQkJCWk5MTVfZ2VtX3JlcXVlc3RfY2FuY2VsKHJlcSk7Cj4gIAkJCWdvdG8gZXJyb3Jf cmluZ2J1ZjsKPiAgCQl9Cj4gLQkJaTkxNV9hZGRfcmVxdWVzdF9ub19mbHVzaChyZXEpOwo+ICAJ fQo+ICAJcmV0dXJuIDA7Cj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9vdmVybGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vdmVybGF5LmMKPiBp bmRleCA2Njk0ZTkyMzBjZDUuLmJjYzNiNmEwMTZkOCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9vdmVybGF5LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9vdmVybGF5LmMKPiBAQCAtMjQ3LDcgKzI0Nyw3IEBAIHN0YXRpYyBpbnQgaW50ZWxfb3Zl cmxheV9vbihzdHJ1Y3QgaW50ZWxfb3ZlcmxheSAqb3ZlcmxheSkKPiAgCj4gIAlyZXQgPSBpbnRl bF9yaW5nX2JlZ2luKHJlcSwgNCk7Cj4gIAlpZiAocmV0KSB7Cj4gLQkJaTkxNV9nZW1fcmVxdWVz dF9jYW5jZWwocmVxKTsKPiArCQlpOTE1X2FkZF9yZXF1ZXN0X25vX2ZsdXNoKHJlcSk7Cj4gIAkJ cmV0dXJuIHJldDsKPiAgCX0KPiAgCj4gQEAgLTI5MCw3ICsyOTAsNyBAQCBzdGF0aWMgaW50IGlu dGVsX292ZXJsYXlfY29udGludWUoc3RydWN0IGludGVsX292ZXJsYXkgKm92ZXJsYXksCj4gIAo+ ICAJcmV0ID0gaW50ZWxfcmluZ19iZWdpbihyZXEsIDIpOwo+ICAJaWYgKHJldCkgewo+IC0JCWk5 MTVfZ2VtX3JlcXVlc3RfY2FuY2VsKHJlcSk7Cj4gKwkJaTkxNV9hZGRfcmVxdWVzdF9ub19mbHVz aChyZXEpOwo+ICAJCXJldHVybiByZXQ7Cj4gIAl9Cj4gIAo+IEBAIC0zNTYsNyArMzU2LDcgQEAg c3RhdGljIGludCBpbnRlbF9vdmVybGF5X29mZihzdHJ1Y3QgaW50ZWxfb3ZlcmxheSAqb3Zlcmxh eSkKPiAgCj4gIAlyZXQgPSBpbnRlbF9yaW5nX2JlZ2luKHJlcSwgNik7Cj4gIAlpZiAocmV0KSB7 Cj4gLQkJaTkxNV9nZW1fcmVxdWVzdF9jYW5jZWwocmVxKTsKPiArCQlpOTE1X2FkZF9yZXF1ZXN0 X25vX2ZsdXNoKHJlcSk7Cj4gIAkJcmV0dXJuIHJldDsKPiAgCX0KPiAgCj4gQEAgLTQzMSw3ICs0 MzEsNyBAQCBzdGF0aWMgaW50IGludGVsX292ZXJsYXlfcmVsZWFzZV9vbGRfdmlkKHN0cnVjdCBp bnRlbF9vdmVybGF5ICpvdmVybGF5KQo+ICAKPiAgCQlyZXQgPSBpbnRlbF9yaW5nX2JlZ2luKHJl cSwgMik7Cj4gIAkJaWYgKHJldCkgewo+IC0JCQlpOTE1X2dlbV9yZXF1ZXN0X2NhbmNlbChyZXEp Owo+ICsJCQlpOTE1X2FkZF9yZXF1ZXN0X25vX2ZsdXNoKHJlcSk7Cj4gIAkJCXJldHVybiByZXQ7 Cj4gIAkJfQo+ICAKPiAtLSAKPiAyLjguMC5yYzMKPiAKCi0tIApEYW5pZWwgVmV0dGVyClNvZnR3 YXJlIEVuZ2luZWVyLCBJbnRlbCBDb3Jwb3JhdGlvbgpodHRwOi8vYmxvZy5mZndsbC5jaApfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFp bGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK