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=-16.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 628B3C4707C for ; Fri, 21 May 2021 15:33:21 +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 2846E613D9 for ; Fri, 21 May 2021 15:33:21 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2846E613D9 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.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 EC0B08973E; Fri, 21 May 2021 15:33:17 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8DD216EDA1; Fri, 21 May 2021 15:33:10 +0000 (UTC) IronPort-SDR: GuyI5+zUoQNx7n2gxl3LQzCLN00N6bazspXbIQlyWqhyMb/DcOwpuonerAgogJTVR4FzmWrNlJ hgCJ+FIE7mkg== X-IronPort-AV: E=McAfee;i="6200,9189,9990"; a="265415698" X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="265415698" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:10 -0700 IronPort-SDR: lVy/OKRWLD+dB/lM518XJ6Mkcr5w8rzQvA9vHhOHRDWQso7v8hwvYEaJt5e4t/orFxdFMbypR6 1TcAfIpaQMmw== X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="441125344" Received: from imarinmo-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.34]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:08 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v3 02/12] drm/i915: Don't free shared locks while shared Date: Fri, 21 May 2021 17:32:43 +0200 Message-Id: <20210521153253.518037-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> References: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" We are currently sharing the VM reservation locks across a number of gem objects with page-table memory. Since TTM will individiualize the reservation locks when freeing objects, including accessing the shared locks, make sure that the shared locks are not freed until that is done. For PPGTT we add an additional refcount, for GGTT we take additional measures to make sure objects sharing the GGTT reservation lock are freed at GGTT takedown Signed-off-by: Thomas Hellström Reviewed-by: Maarten Lankhorst --- v2: Try harder to make sure objects sharing the GGTT reservation lock are freed at GGTT takedown. v3: Use a pointer to the vm to indicate that an object shares a reservation object from that vm, rather than a pointer to the reservation object itself. --- drivers/gpu/drm/i915/gem/i915_gem_object.c | 3 ++ .../gpu/drm/i915/gem/i915_gem_object_types.h | 4 ++ drivers/gpu/drm/i915/gt/intel_ggtt.c | 19 ++++++-- drivers/gpu/drm/i915/gt/intel_gtt.c | 45 +++++++++++++++---- drivers/gpu/drm/i915/gt/intel_gtt.h | 28 +++++++++++- drivers/gpu/drm/i915/gt/intel_ppgtt.c | 2 +- drivers/gpu/drm/i915/i915_drv.c | 5 +++ 7 files changed, 93 insertions(+), 13 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.c b/drivers/gpu/drm/i915/gem/i915_gem_object.c index 28144410df86..2be6109d0093 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -252,6 +252,9 @@ static void __i915_gem_free_objects(struct drm_i915_private *i915, if (obj->mm.n_placements > 1) kfree(obj->mm.placements); + if (obj->shares_resv_from) + i915_vm_resv_put(obj->shares_resv_from); + /* But keep the pointer alive for RCU-protected lookups */ call_rcu(&obj->rcu, __i915_gem_free_object_rcu); cond_resched(); diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h index 0727d0c76aa0..0415f99b6b95 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h @@ -149,6 +149,10 @@ struct drm_i915_gem_object { * when i915_gem_ww_ctx_backoff() or i915_gem_ww_ctx_fini() are called. */ struct list_head obj_link; + /** + * @shared_resv_from: The object shares the resv from this vm. + */ + struct i915_address_space *shares_resv_from; union { struct rcu_head rcu; diff --git a/drivers/gpu/drm/i915/gt/intel_ggtt.c b/drivers/gpu/drm/i915/gt/intel_ggtt.c index 35069ca5d7de..10c23a749a95 100644 --- a/drivers/gpu/drm/i915/gt/intel_ggtt.c +++ b/drivers/gpu/drm/i915/gt/intel_ggtt.c @@ -746,7 +746,6 @@ static void ggtt_cleanup_hw(struct i915_ggtt *ggtt) mutex_unlock(&ggtt->vm.mutex); i915_address_space_fini(&ggtt->vm); - dma_resv_fini(&ggtt->vm.resv); arch_phys_wc_del(ggtt->mtrr); @@ -768,6 +767,19 @@ void i915_ggtt_driver_release(struct drm_i915_private *i915) ggtt_cleanup_hw(ggtt); } +/** + * i915_ggtt_driver_late_release - Cleanup of GGTT that needs to be done after + * all free objects have been drained. + * @i915: i915 device + */ +void i915_ggtt_driver_late_release(struct drm_i915_private *i915) +{ + struct i915_ggtt *ggtt = &i915->ggtt; + + GEM_WARN_ON(kref_read(&ggtt->vm.resv_ref) != 1); + dma_resv_fini(&ggtt->vm._resv); +} + static unsigned int gen6_get_total_gtt_size(u16 snb_gmch_ctl) { snb_gmch_ctl >>= SNB_GMCH_GGMS_SHIFT; @@ -829,6 +841,7 @@ static int ggtt_probe_common(struct i915_ggtt *ggtt, u64 size) return -ENOMEM; } + kref_init(&ggtt->vm.resv_ref); ret = setup_scratch_page(&ggtt->vm); if (ret) { drm_err(&i915->drm, "Scratch setup failed\n"); @@ -1135,7 +1148,7 @@ static int ggtt_probe_hw(struct i915_ggtt *ggtt, struct intel_gt *gt) ggtt->vm.gt = gt; ggtt->vm.i915 = i915; ggtt->vm.dma = i915->drm.dev; - dma_resv_init(&ggtt->vm.resv); + dma_resv_init(&ggtt->vm._resv); if (INTEL_GEN(i915) <= 5) ret = i915_gmch_probe(ggtt); @@ -1144,7 +1157,7 @@ static int ggtt_probe_hw(struct i915_ggtt *ggtt, struct intel_gt *gt) else ret = gen8_gmch_probe(ggtt); if (ret) { - dma_resv_fini(&ggtt->vm.resv); + dma_resv_fini(&ggtt->vm._resv); return ret; } diff --git a/drivers/gpu/drm/i915/gt/intel_gtt.c b/drivers/gpu/drm/i915/gt/intel_gtt.c index 9b98f9d9faa3..94849567143d 100644 --- a/drivers/gpu/drm/i915/gt/intel_gtt.c +++ b/drivers/gpu/drm/i915/gt/intel_gtt.c @@ -22,8 +22,11 @@ struct drm_i915_gem_object *alloc_pt_lmem(struct i915_address_space *vm, int sz) * object underneath, with the idea that one object_lock() will lock * them all at once. */ - if (!IS_ERR(obj)) - obj->base.resv = &vm->resv; + if (!IS_ERR(obj)) { + obj->base.resv = i915_vm_resv_get(vm); + obj->shares_resv_from = vm; + } + return obj; } @@ -40,8 +43,11 @@ struct drm_i915_gem_object *alloc_pt_dma(struct i915_address_space *vm, int sz) * object underneath, with the idea that one object_lock() will lock * them all at once. */ - if (!IS_ERR(obj)) - obj->base.resv = &vm->resv; + if (!IS_ERR(obj)) { + obj->base.resv = i915_vm_resv_get(vm); + obj->shares_resv_from = vm; + } + return obj; } @@ -102,7 +108,7 @@ void __i915_vm_close(struct i915_address_space *vm) int i915_vm_lock_objects(struct i915_address_space *vm, struct i915_gem_ww_ctx *ww) { - if (vm->scratch[0]->base.resv == &vm->resv) { + if (vm->scratch[0]->base.resv == &vm->_resv) { return i915_gem_object_lock(vm->scratch[0], ww); } else { struct i915_ppgtt *ppgtt = i915_vm_to_ppgtt(vm); @@ -118,6 +124,22 @@ void i915_address_space_fini(struct i915_address_space *vm) mutex_destroy(&vm->mutex); } +/** + * i915_vm_resv_release - Final struct i915_address_space destructor + * @kref: Pointer to the &i915_address_space.resv_ref member. + * + * This function is called when the last lock sharer no longer shares the + * &i915_address_space._resv lock. + */ +void i915_vm_resv_release(struct kref *kref) +{ + struct i915_address_space *vm = + container_of(kref, typeof(*vm), resv_ref); + + dma_resv_fini(&vm->_resv); + kfree(vm); +} + static void __i915_vm_release(struct work_struct *work) { struct i915_address_space *vm = @@ -125,9 +147,8 @@ static void __i915_vm_release(struct work_struct *work) vm->cleanup(vm); i915_address_space_fini(vm); - dma_resv_fini(&vm->resv); - kfree(vm); + i915_vm_resv_put(vm); } void i915_vm_release(struct kref *kref) @@ -144,6 +165,14 @@ void i915_vm_release(struct kref *kref) void i915_address_space_init(struct i915_address_space *vm, int subclass) { kref_init(&vm->ref); + + /* + * Special case for GGTT that has already done an early + * kref_init here. + */ + if (!kref_read(&vm->resv_ref)) + kref_init(&vm->resv_ref); + INIT_RCU_WORK(&vm->rcu, __i915_vm_release); atomic_set(&vm->open, 1); @@ -170,7 +199,7 @@ void i915_address_space_init(struct i915_address_space *vm, int subclass) might_alloc(GFP_KERNEL); mutex_release(&vm->mutex.dep_map, _THIS_IP_); } - dma_resv_init(&vm->resv); + dma_resv_init(&vm->_resv); GEM_BUG_ON(!vm->total); drm_mm_init(&vm->mm, 0, vm->total); diff --git a/drivers/gpu/drm/i915/gt/intel_gtt.h b/drivers/gpu/drm/i915/gt/intel_gtt.h index ca00b45827b7..f39be66e84f6 100644 --- a/drivers/gpu/drm/i915/gt/intel_gtt.h +++ b/drivers/gpu/drm/i915/gt/intel_gtt.h @@ -245,7 +245,9 @@ struct i915_address_space { atomic_t open; struct mutex mutex; /* protects vma and our lists */ - struct dma_resv resv; /* reservation lock for all pd objects, and buffer pool */ + + struct kref resv_ref; /* kref to keep the reservation lock alive. */ + struct dma_resv _resv; /* reservation lock for all pd objects, and buffer pool */ #define VM_CLASS_GGTT 0 #define VM_CLASS_PPGTT 1 #define VM_CLASS_DPT 2 @@ -404,13 +406,36 @@ i915_vm_get(struct i915_address_space *vm) return vm; } +/** + * i915_vm_resv_get - Obtain a reference on the vm's reservation lock + * @vm: The vm whose reservation lock we want to share. + * + * Return: A pointer to the vm's reservation lock. + */ +static inline struct dma_resv *i915_vm_resv_get(struct i915_address_space *vm) +{ + kref_get(&vm->resv_ref); + return &vm->_resv; +} + void i915_vm_release(struct kref *kref); +void i915_vm_resv_release(struct kref *kref); + static inline void i915_vm_put(struct i915_address_space *vm) { kref_put(&vm->ref, i915_vm_release); } +/** + * i915_vm_resv_put - Release a reference on the vm's reservation lock + * @resv: Pointer to a reservation lock obtained from i915_vm_resv_get() + */ +static inline void i915_vm_resv_put(struct i915_address_space *vm) +{ + kref_put(&vm->resv_ref, i915_vm_resv_release); +} + static inline struct i915_address_space * i915_vm_open(struct i915_address_space *vm) { @@ -506,6 +531,7 @@ void i915_ggtt_enable_guc(struct i915_ggtt *ggtt); void i915_ggtt_disable_guc(struct i915_ggtt *ggtt); int i915_init_ggtt(struct drm_i915_private *i915); void i915_ggtt_driver_release(struct drm_i915_private *i915); +void i915_ggtt_driver_late_release(struct drm_i915_private *i915); static inline bool i915_ggtt_has_aperture(const struct i915_ggtt *ggtt) { diff --git a/drivers/gpu/drm/i915/gt/intel_ppgtt.c b/drivers/gpu/drm/i915/gt/intel_ppgtt.c index 4e3d80c2295c..aee3a8929245 100644 --- a/drivers/gpu/drm/i915/gt/intel_ppgtt.c +++ b/drivers/gpu/drm/i915/gt/intel_ppgtt.c @@ -307,7 +307,7 @@ void ppgtt_init(struct i915_ppgtt *ppgtt, struct intel_gt *gt) ppgtt->vm.dma = i915->drm.dev; ppgtt->vm.total = BIT_ULL(INTEL_INFO(i915)->ppgtt_size); - dma_resv_init(&ppgtt->vm.resv); + dma_resv_init(&ppgtt->vm._resv); i915_address_space_init(&ppgtt->vm, VM_CLASS_PPGTT); ppgtt->vm.vma_ops.bind_vma = ppgtt_bind_vma; diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 5118dc8386b2..92bccc5623a8 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -631,6 +631,8 @@ static int i915_driver_hw_probe(struct drm_i915_private *dev_priv) intel_memory_regions_driver_release(dev_priv); err_ggtt: i915_ggtt_driver_release(dev_priv); + i915_gem_drain_freed_objects(dev_priv); + i915_ggtt_driver_late_release(dev_priv); err_perf: i915_perf_fini(dev_priv); return ret; @@ -880,6 +882,8 @@ int i915_driver_probe(struct pci_dev *pdev, const struct pci_device_id *ent) i915_driver_hw_remove(i915); intel_memory_regions_driver_release(i915); i915_ggtt_driver_release(i915); + i915_gem_drain_freed_objects(i915); + i915_ggtt_driver_late_release(i915); out_cleanup_mmio: i915_driver_mmio_release(i915); out_runtime_pm_put: @@ -936,6 +940,7 @@ static void i915_driver_release(struct drm_device *dev) intel_memory_regions_driver_release(dev_priv); i915_ggtt_driver_release(dev_priv); i915_gem_drain_freed_objects(dev_priv); + i915_ggtt_driver_late_release(dev_priv); i915_driver_mmio_release(dev_priv); -- 2.31.1 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=-16.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 68B40C47076 for ; Fri, 21 May 2021 15:33:19 +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 1569F613E6 for ; Fri, 21 May 2021 15:33:19 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1569F613E6 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id A847688F2D; Fri, 21 May 2021 15:33:15 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8DD216EDA1; Fri, 21 May 2021 15:33:10 +0000 (UTC) IronPort-SDR: GuyI5+zUoQNx7n2gxl3LQzCLN00N6bazspXbIQlyWqhyMb/DcOwpuonerAgogJTVR4FzmWrNlJ hgCJ+FIE7mkg== X-IronPort-AV: E=McAfee;i="6200,9189,9990"; a="265415698" X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="265415698" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:10 -0700 IronPort-SDR: lVy/OKRWLD+dB/lM518XJ6Mkcr5w8rzQvA9vHhOHRDWQso7v8hwvYEaJt5e4t/orFxdFMbypR6 1TcAfIpaQMmw== X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="441125344" Received: from imarinmo-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.34]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:08 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Fri, 21 May 2021 17:32:43 +0200 Message-Id: <20210521153253.518037-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> References: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v3 02/12] drm/i915: Don't free shared locks while shared X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" V2UgYXJlIGN1cnJlbnRseSBzaGFyaW5nIHRoZSBWTSByZXNlcnZhdGlvbiBsb2NrcyBhY3Jvc3Mg YSBudW1iZXIgb2YKZ2VtIG9iamVjdHMgd2l0aCBwYWdlLXRhYmxlIG1lbW9yeS4gU2luY2UgVFRN IHdpbGwgaW5kaXZpZGl1YWxpemUgdGhlCnJlc2VydmF0aW9uIGxvY2tzIHdoZW4gZnJlZWluZyBv YmplY3RzLCBpbmNsdWRpbmcgYWNjZXNzaW5nIHRoZSBzaGFyZWQKbG9ja3MsIG1ha2Ugc3VyZSB0 aGF0IHRoZSBzaGFyZWQgbG9ja3MgYXJlIG5vdCBmcmVlZCB1bnRpbCB0aGF0IGlzIGRvbmUuCkZv ciBQUEdUVCB3ZSBhZGQgYW4gYWRkaXRpb25hbCByZWZjb3VudCwgZm9yIEdHVFQgd2UgdGFrZSBh ZGRpdGlvbmFsCm1lYXN1cmVzIHRvIG1ha2Ugc3VyZSBvYmplY3RzIHNoYXJpbmcgdGhlIEdHVFQg cmVzZXJ2YXRpb24gbG9jayBhcmUKZnJlZWQgYXQgR0dUVCB0YWtlZG93bgoKU2lnbmVkLW9mZi1i eTogVGhvbWFzIEhlbGxzdHLDtm0gPHRob21hcy5oZWxsc3Ryb21AbGludXguaW50ZWwuY29tPgpS ZXZpZXdlZC1ieTogTWFhcnRlbiBMYW5raG9yc3QgPG1hYXJ0ZW4ubGFua2hvcnN0QGxpbnV4Lmlu dGVsLmNvbT4KLS0tCnYyOiBUcnkgaGFyZGVyIHRvIG1ha2Ugc3VyZSBvYmplY3RzIHNoYXJpbmcg dGhlIEdHVFQgcmVzZXJ2YXRpb24gbG9jayBhcmUKZnJlZWQgYXQgR0dUVCB0YWtlZG93bi4KdjM6 IFVzZSBhIHBvaW50ZXIgdG8gdGhlIHZtIHRvIGluZGljYXRlIHRoYXQgYW4gb2JqZWN0IHNoYXJl cyBhIHJlc2VydmF0aW9uCm9iamVjdCBmcm9tIHRoYXQgdm0sIHJhdGhlciB0aGFuIGEgcG9pbnRl ciB0byB0aGUgcmVzZXJ2YXRpb24gb2JqZWN0IGl0c2VsZi4KLS0tCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmMgICAgfCAgMyArKwogLi4uL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmggIHwgIDQgKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L2ludGVsX2dndHQuYyAgICAgICAgICB8IDE5ICsrKysrKy0tCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9pbnRlbF9ndHQuYyAgICAgICAgICAgfCA0NSArKysrKysrKysrKysrKystLS0tCiBk cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndHQuaCAgICAgICAgICAgfCAyOCArKysrKysr KysrKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3BwZ3R0LmMgICAgICAgICB8ICAy ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jICAgICAgICAgICAgICAgfCAgNSAr KysKIDcgZmlsZXMgY2hhbmdlZCwgOTMgaW5zZXJ0aW9ucygrKSwgMTMgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCmluZGV4IDI4MTQ0NDEw ZGY4Ni4uMmJlNjEwOWQwMDkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0v aTkxNV9nZW1fb2JqZWN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X29iamVjdC5jCkBAIC0yNTIsNiArMjUyLDkgQEAgc3RhdGljIHZvaWQgX19pOTE1X2dlbV9mcmVl X29iamVjdHMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJCWlmIChvYmotPm1tLm5f cGxhY2VtZW50cyA+IDEpCiAJCQlrZnJlZShvYmotPm1tLnBsYWNlbWVudHMpOwogCisJCWlmIChv YmotPnNoYXJlc19yZXN2X2Zyb20pCisJCQlpOTE1X3ZtX3Jlc3ZfcHV0KG9iai0+c2hhcmVzX3Jl c3ZfZnJvbSk7CisKIAkJLyogQnV0IGtlZXAgdGhlIHBvaW50ZXIgYWxpdmUgZm9yIFJDVS1wcm90 ZWN0ZWQgbG9va3VwcyAqLwogCQljYWxsX3JjdSgmb2JqLT5yY3UsIF9faTkxNV9nZW1fZnJlZV9v YmplY3RfcmN1KTsKIAkJY29uZF9yZXNjaGVkKCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmgKaW5kZXggMDcyN2QwYzc2YWEwLi4wNDE1Zjk5 YjZiOTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmpl Y3RfdHlwZXMuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0 X3R5cGVzLmgKQEAgLTE0OSw2ICsxNDksMTAgQEAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg ewogCSAqIHdoZW4gaTkxNV9nZW1fd3dfY3R4X2JhY2tvZmYoKSBvciBpOTE1X2dlbV93d19jdHhf ZmluaSgpIGFyZSBjYWxsZWQuCiAJICovCiAJc3RydWN0IGxpc3RfaGVhZCBvYmpfbGluazsKKwkv KioKKwkgKiBAc2hhcmVkX3Jlc3ZfZnJvbTogVGhlIG9iamVjdCBzaGFyZXMgdGhlIHJlc3YgZnJv bSB0aGlzIHZtLgorCSAqLworCXN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgKnNoYXJlc19yZXN2 X2Zyb207CiAKIAl1bmlvbiB7CiAJCXN0cnVjdCByY3VfaGVhZCByY3U7CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9nZ3R0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndC9pbnRlbF9nZ3R0LmMKaW5kZXggMzUwNjljYTVkN2RlLi4xMGMyM2E3NDlhOTUgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2dndHQuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9nZ3R0LmMKQEAgLTc0Niw3ICs3NDYsNiBAQCBzdGF0aWMg dm9pZCBnZ3R0X2NsZWFudXBfaHcoc3RydWN0IGk5MTVfZ2d0dCAqZ2d0dCkKIAogCW11dGV4X3Vu bG9jaygmZ2d0dC0+dm0ubXV0ZXgpOwogCWk5MTVfYWRkcmVzc19zcGFjZV9maW5pKCZnZ3R0LT52 bSk7Ci0JZG1hX3Jlc3ZfZmluaSgmZ2d0dC0+dm0ucmVzdik7CiAKIAlhcmNoX3BoeXNfd2NfZGVs KGdndHQtPm10cnIpOwogCkBAIC03NjgsNiArNzY3LDE5IEBAIHZvaWQgaTkxNV9nZ3R0X2RyaXZl cl9yZWxlYXNlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQogCWdndHRfY2xlYW51cF9o dyhnZ3R0KTsKIH0KIAorLyoqCisgKiBpOTE1X2dndHRfZHJpdmVyX2xhdGVfcmVsZWFzZSAtIENs ZWFudXAgb2YgR0dUVCB0aGF0IG5lZWRzIHRvIGJlIGRvbmUgYWZ0ZXIKKyAqIGFsbCBmcmVlIG9i amVjdHMgaGF2ZSBiZWVuIGRyYWluZWQuCisgKiBAaTkxNTogaTkxNSBkZXZpY2UKKyAqLwordm9p ZCBpOTE1X2dndHRfZHJpdmVyX2xhdGVfcmVsZWFzZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAq aTkxNSkKK3sKKwlzdHJ1Y3QgaTkxNV9nZ3R0ICpnZ3R0ID0gJmk5MTUtPmdndHQ7CisKKwlHRU1f V0FSTl9PTihrcmVmX3JlYWQoJmdndHQtPnZtLnJlc3ZfcmVmKSAhPSAxKTsKKwlkbWFfcmVzdl9m aW5pKCZnZ3R0LT52bS5fcmVzdik7Cit9CisKIHN0YXRpYyB1bnNpZ25lZCBpbnQgZ2VuNl9nZXRf dG90YWxfZ3R0X3NpemUodTE2IHNuYl9nbWNoX2N0bCkKIHsKIAlzbmJfZ21jaF9jdGwgPj49IFNO Ql9HTUNIX0dHTVNfU0hJRlQ7CkBAIC04MjksNiArODQxLDcgQEAgc3RhdGljIGludCBnZ3R0X3By b2JlX2NvbW1vbihzdHJ1Y3QgaTkxNV9nZ3R0ICpnZ3R0LCB1NjQgc2l6ZSkKIAkJcmV0dXJuIC1F Tk9NRU07CiAJfQogCisJa3JlZl9pbml0KCZnZ3R0LT52bS5yZXN2X3JlZik7CiAJcmV0ID0gc2V0 dXBfc2NyYXRjaF9wYWdlKCZnZ3R0LT52bSk7CiAJaWYgKHJldCkgewogCQlkcm1fZXJyKCZpOTE1 LT5kcm0sICJTY3JhdGNoIHNldHVwIGZhaWxlZFxuIik7CkBAIC0xMTM1LDcgKzExNDgsNyBAQCBz dGF0aWMgaW50IGdndHRfcHJvYmVfaHcoc3RydWN0IGk5MTVfZ2d0dCAqZ2d0dCwgc3RydWN0IGlu dGVsX2d0ICpndCkKIAlnZ3R0LT52bS5ndCA9IGd0OwogCWdndHQtPnZtLmk5MTUgPSBpOTE1Owog CWdndHQtPnZtLmRtYSA9IGk5MTUtPmRybS5kZXY7Ci0JZG1hX3Jlc3ZfaW5pdCgmZ2d0dC0+dm0u cmVzdik7CisJZG1hX3Jlc3ZfaW5pdCgmZ2d0dC0+dm0uX3Jlc3YpOwogCiAJaWYgKElOVEVMX0dF TihpOTE1KSA8PSA1KQogCQlyZXQgPSBpOTE1X2dtY2hfcHJvYmUoZ2d0dCk7CkBAIC0xMTQ0LDcg KzExNTcsNyBAQCBzdGF0aWMgaW50IGdndHRfcHJvYmVfaHcoc3RydWN0IGk5MTVfZ2d0dCAqZ2d0 dCwgc3RydWN0IGludGVsX2d0ICpndCkKIAllbHNlCiAJCXJldCA9IGdlbjhfZ21jaF9wcm9iZShn Z3R0KTsKIAlpZiAocmV0KSB7Ci0JCWRtYV9yZXN2X2ZpbmkoJmdndHQtPnZtLnJlc3YpOworCQlk bWFfcmVzdl9maW5pKCZnZ3R0LT52bS5fcmVzdik7CiAJCXJldHVybiByZXQ7CiAJfQogCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndHQuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L2ludGVsX2d0dC5jCmluZGV4IDliOThmOWQ5ZmFhMy4uOTQ4NDk1NjcxNDNk IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndHQuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndHQuYwpAQCAtMjIsOCArMjIsMTEgQEAgc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKmFsbG9jX3B0X2xtZW0oc3RydWN0IGk5MTVfYWRkcmVz c19zcGFjZSAqdm0sIGludCBzeikKIAkgKiBvYmplY3QgdW5kZXJuZWF0aCwgd2l0aCB0aGUgaWRl YSB0aGF0IG9uZSBvYmplY3RfbG9jaygpIHdpbGwgbG9jawogCSAqIHRoZW0gYWxsIGF0IG9uY2Uu CiAJICovCi0JaWYgKCFJU19FUlIob2JqKSkKLQkJb2JqLT5iYXNlLnJlc3YgPSAmdm0tPnJlc3Y7 CisJaWYgKCFJU19FUlIob2JqKSkgeworCQlvYmotPmJhc2UucmVzdiA9IGk5MTVfdm1fcmVzdl9n ZXQodm0pOworCQlvYmotPnNoYXJlc19yZXN2X2Zyb20gPSB2bTsKKwl9CisKIAlyZXR1cm4gb2Jq OwogfQogCkBAIC00MCw4ICs0MywxMSBAQCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqYWxs b2NfcHRfZG1hKHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgKnZtLCBpbnQgc3opCiAJICogb2Jq ZWN0IHVuZGVybmVhdGgsIHdpdGggdGhlIGlkZWEgdGhhdCBvbmUgb2JqZWN0X2xvY2soKSB3aWxs IGxvY2sKIAkgKiB0aGVtIGFsbCBhdCBvbmNlLgogCSAqLwotCWlmICghSVNfRVJSKG9iaikpCi0J CW9iai0+YmFzZS5yZXN2ID0gJnZtLT5yZXN2OworCWlmICghSVNfRVJSKG9iaikpIHsKKwkJb2Jq LT5iYXNlLnJlc3YgPSBpOTE1X3ZtX3Jlc3ZfZ2V0KHZtKTsKKwkJb2JqLT5zaGFyZXNfcmVzdl9m cm9tID0gdm07CisJfQorCiAJcmV0dXJuIG9iajsKIH0KIApAQCAtMTAyLDcgKzEwOCw3IEBAIHZv aWQgX19pOTE1X3ZtX2Nsb3NlKHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgKnZtKQogaW50IGk5 MTVfdm1fbG9ja19vYmplY3RzKHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgKnZtLAogCQkJIHN0 cnVjdCBpOTE1X2dlbV93d19jdHggKnd3KQogewotCWlmICh2bS0+c2NyYXRjaFswXS0+YmFzZS5y ZXN2ID09ICZ2bS0+cmVzdikgeworCWlmICh2bS0+c2NyYXRjaFswXS0+YmFzZS5yZXN2ID09ICZ2 bS0+X3Jlc3YpIHsKIAkJcmV0dXJuIGk5MTVfZ2VtX29iamVjdF9sb2NrKHZtLT5zY3JhdGNoWzBd LCB3dyk7CiAJfSBlbHNlIHsKIAkJc3RydWN0IGk5MTVfcHBndHQgKnBwZ3R0ID0gaTkxNV92bV90 b19wcGd0dCh2bSk7CkBAIC0xMTgsNiArMTI0LDIyIEBAIHZvaWQgaTkxNV9hZGRyZXNzX3NwYWNl X2Zpbmkoc3RydWN0IGk5MTVfYWRkcmVzc19zcGFjZSAqdm0pCiAJbXV0ZXhfZGVzdHJveSgmdm0t Pm11dGV4KTsKIH0KIAorLyoqCisgKiBpOTE1X3ZtX3Jlc3ZfcmVsZWFzZSAtIEZpbmFsIHN0cnVj dCBpOTE1X2FkZHJlc3Nfc3BhY2UgZGVzdHJ1Y3RvcgorICogQGtyZWY6IFBvaW50ZXIgdG8gdGhl ICZpOTE1X2FkZHJlc3Nfc3BhY2UucmVzdl9yZWYgbWVtYmVyLgorICoKKyAqIFRoaXMgZnVuY3Rp b24gaXMgY2FsbGVkIHdoZW4gdGhlIGxhc3QgbG9jayBzaGFyZXIgbm8gbG9uZ2VyIHNoYXJlcyB0 aGUKKyAqICZpOTE1X2FkZHJlc3Nfc3BhY2UuX3Jlc3YgbG9jay4KKyAqLwordm9pZCBpOTE1X3Zt X3Jlc3ZfcmVsZWFzZShzdHJ1Y3Qga3JlZiAqa3JlZikKK3sKKwlzdHJ1Y3QgaTkxNV9hZGRyZXNz X3NwYWNlICp2bSA9CisJCWNvbnRhaW5lcl9vZihrcmVmLCB0eXBlb2YoKnZtKSwgcmVzdl9yZWYp OworCisJZG1hX3Jlc3ZfZmluaSgmdm0tPl9yZXN2KTsKKwlrZnJlZSh2bSk7Cit9CisKIHN0YXRp YyB2b2lkIF9faTkxNV92bV9yZWxlYXNlKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIHsKIAlz dHJ1Y3QgaTkxNV9hZGRyZXNzX3NwYWNlICp2bSA9CkBAIC0xMjUsOSArMTQ3LDggQEAgc3RhdGlj IHZvaWQgX19pOTE1X3ZtX3JlbGVhc2Uoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogCiAJdm0t PmNsZWFudXAodm0pOwogCWk5MTVfYWRkcmVzc19zcGFjZV9maW5pKHZtKTsKLQlkbWFfcmVzdl9m aW5pKCZ2bS0+cmVzdik7CiAKLQlrZnJlZSh2bSk7CisJaTkxNV92bV9yZXN2X3B1dCh2bSk7CiB9 CiAKIHZvaWQgaTkxNV92bV9yZWxlYXNlKHN0cnVjdCBrcmVmICprcmVmKQpAQCAtMTQ0LDYgKzE2 NSwxNCBAQCB2b2lkIGk5MTVfdm1fcmVsZWFzZShzdHJ1Y3Qga3JlZiAqa3JlZikKIHZvaWQgaTkx NV9hZGRyZXNzX3NwYWNlX2luaXQoc3RydWN0IGk5MTVfYWRkcmVzc19zcGFjZSAqdm0sIGludCBz dWJjbGFzcykKIHsKIAlrcmVmX2luaXQoJnZtLT5yZWYpOworCisJLyoKKwkgKiBTcGVjaWFsIGNh c2UgZm9yIEdHVFQgdGhhdCBoYXMgYWxyZWFkeSBkb25lIGFuIGVhcmx5CisJICoga3JlZl9pbml0 IGhlcmUuCisJICovCisJaWYgKCFrcmVmX3JlYWQoJnZtLT5yZXN2X3JlZikpCisJCWtyZWZfaW5p dCgmdm0tPnJlc3ZfcmVmKTsKKwogCUlOSVRfUkNVX1dPUksoJnZtLT5yY3UsIF9faTkxNV92bV9y ZWxlYXNlKTsKIAlhdG9taWNfc2V0KCZ2bS0+b3BlbiwgMSk7CiAKQEAgLTE3MCw3ICsxOTksNyBA QCB2b2lkIGk5MTVfYWRkcmVzc19zcGFjZV9pbml0KHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2Ug KnZtLCBpbnQgc3ViY2xhc3MpCiAJCW1pZ2h0X2FsbG9jKEdGUF9LRVJORUwpOwogCQltdXRleF9y ZWxlYXNlKCZ2bS0+bXV0ZXguZGVwX21hcCwgX1RISVNfSVBfKTsKIAl9Ci0JZG1hX3Jlc3ZfaW5p dCgmdm0tPnJlc3YpOworCWRtYV9yZXN2X2luaXQoJnZtLT5fcmVzdik7CiAKIAlHRU1fQlVHX09O KCF2bS0+dG90YWwpOwogCWRybV9tbV9pbml0KCZ2bS0+bW0sIDAsIHZtLT50b3RhbCk7CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndHQuaCBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L2ludGVsX2d0dC5oCmluZGV4IGNhMDBiNDU4MjdiNy4uZjM5YmU2NmU4NGY2 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndHQuaAorKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndHQuaApAQCAtMjQ1LDcgKzI0NSw5IEBAIHN0 cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgewogCWF0b21pY190IG9wZW47CiAKIAlzdHJ1Y3QgbXV0 ZXggbXV0ZXg7IC8qIHByb3RlY3RzIHZtYSBhbmQgb3VyIGxpc3RzICovCi0Jc3RydWN0IGRtYV9y ZXN2IHJlc3Y7IC8qIHJlc2VydmF0aW9uIGxvY2sgZm9yIGFsbCBwZCBvYmplY3RzLCBhbmQgYnVm ZmVyIHBvb2wgKi8KKworCXN0cnVjdCBrcmVmIHJlc3ZfcmVmOyAvKiBrcmVmIHRvIGtlZXAgdGhl IHJlc2VydmF0aW9uIGxvY2sgYWxpdmUuICovCisJc3RydWN0IGRtYV9yZXN2IF9yZXN2OyAvKiBy ZXNlcnZhdGlvbiBsb2NrIGZvciBhbGwgcGQgb2JqZWN0cywgYW5kIGJ1ZmZlciBwb29sICovCiAj ZGVmaW5lIFZNX0NMQVNTX0dHVFQgMAogI2RlZmluZSBWTV9DTEFTU19QUEdUVCAxCiAjZGVmaW5l IFZNX0NMQVNTX0RQVCAyCkBAIC00MDQsMTMgKzQwNiwzNiBAQCBpOTE1X3ZtX2dldChzdHJ1Y3Qg aTkxNV9hZGRyZXNzX3NwYWNlICp2bSkKIAlyZXR1cm4gdm07CiB9CiAKKy8qKgorICogaTkxNV92 bV9yZXN2X2dldCAtIE9idGFpbiBhIHJlZmVyZW5jZSBvbiB0aGUgdm0ncyByZXNlcnZhdGlvbiBs b2NrCisgKiBAdm06IFRoZSB2bSB3aG9zZSByZXNlcnZhdGlvbiBsb2NrIHdlIHdhbnQgdG8gc2hh cmUuCisgKgorICogUmV0dXJuOiBBIHBvaW50ZXIgdG8gdGhlIHZtJ3MgcmVzZXJ2YXRpb24gbG9j ay4KKyAqLworc3RhdGljIGlubGluZSBzdHJ1Y3QgZG1hX3Jlc3YgKmk5MTVfdm1fcmVzdl9nZXQo c3RydWN0IGk5MTVfYWRkcmVzc19zcGFjZSAqdm0pCit7CisJa3JlZl9nZXQoJnZtLT5yZXN2X3Jl Zik7CisJcmV0dXJuICZ2bS0+X3Jlc3Y7Cit9CisKIHZvaWQgaTkxNV92bV9yZWxlYXNlKHN0cnVj dCBrcmVmICprcmVmKTsKIAordm9pZCBpOTE1X3ZtX3Jlc3ZfcmVsZWFzZShzdHJ1Y3Qga3JlZiAq a3JlZik7CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBpOTE1X3ZtX3B1dChzdHJ1Y3QgaTkxNV9hZGRy ZXNzX3NwYWNlICp2bSkKIHsKIAlrcmVmX3B1dCgmdm0tPnJlZiwgaTkxNV92bV9yZWxlYXNlKTsK IH0KIAorLyoqCisgKiBpOTE1X3ZtX3Jlc3ZfcHV0IC0gUmVsZWFzZSBhIHJlZmVyZW5jZSBvbiB0 aGUgdm0ncyByZXNlcnZhdGlvbiBsb2NrCisgKiBAcmVzdjogUG9pbnRlciB0byBhIHJlc2VydmF0 aW9uIGxvY2sgb2J0YWluZWQgZnJvbSBpOTE1X3ZtX3Jlc3ZfZ2V0KCkKKyAqLworc3RhdGljIGlu bGluZSB2b2lkIGk5MTVfdm1fcmVzdl9wdXQoc3RydWN0IGk5MTVfYWRkcmVzc19zcGFjZSAqdm0p Cit7CisJa3JlZl9wdXQoJnZtLT5yZXN2X3JlZiwgaTkxNV92bV9yZXN2X3JlbGVhc2UpOworfQor CiBzdGF0aWMgaW5saW5lIHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgKgogaTkxNV92bV9vcGVu KHN0cnVjdCBpOTE1X2FkZHJlc3Nfc3BhY2UgKnZtKQogewpAQCAtNTA2LDYgKzUzMSw3IEBAIHZv aWQgaTkxNV9nZ3R0X2VuYWJsZV9ndWMoc3RydWN0IGk5MTVfZ2d0dCAqZ2d0dCk7CiB2b2lkIGk5 MTVfZ2d0dF9kaXNhYmxlX2d1YyhzdHJ1Y3QgaTkxNV9nZ3R0ICpnZ3R0KTsKIGludCBpOTE1X2lu aXRfZ2d0dChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSk7CiB2b2lkIGk5MTVfZ2d0dF9k cml2ZXJfcmVsZWFzZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSk7Cit2b2lkIGk5MTVf Z2d0dF9kcml2ZXJfbGF0ZV9yZWxlYXNlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KTsK IAogc3RhdGljIGlubGluZSBib29sIGk5MTVfZ2d0dF9oYXNfYXBlcnR1cmUoY29uc3Qgc3RydWN0 IGk5MTVfZ2d0dCAqZ2d0dCkKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L2ludGVsX3BwZ3R0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9wcGd0dC5jCmlu ZGV4IDRlM2Q4MGMyMjk1Yy4uYWVlM2E4OTI5MjQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9wcGd0dC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2lu dGVsX3BwZ3R0LmMKQEAgLTMwNyw3ICszMDcsNyBAQCB2b2lkIHBwZ3R0X2luaXQoc3RydWN0IGk5 MTVfcHBndHQgKnBwZ3R0LCBzdHJ1Y3QgaW50ZWxfZ3QgKmd0KQogCXBwZ3R0LT52bS5kbWEgPSBp OTE1LT5kcm0uZGV2OwogCXBwZ3R0LT52bS50b3RhbCA9IEJJVF9VTEwoSU5URUxfSU5GTyhpOTE1 KS0+cHBndHRfc2l6ZSk7CiAKLQlkbWFfcmVzdl9pbml0KCZwcGd0dC0+dm0ucmVzdik7CisJZG1h X3Jlc3ZfaW5pdCgmcHBndHQtPnZtLl9yZXN2KTsKIAlpOTE1X2FkZHJlc3Nfc3BhY2VfaW5pdCgm cHBndHQtPnZtLCBWTV9DTEFTU19QUEdUVCk7CiAKIAlwcGd0dC0+dm0udm1hX29wcy5iaW5kX3Zt YSAgICA9IHBwZ3R0X2JpbmRfdm1hOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aTkxNV9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMKaW5kZXggNTExOGRj ODM4NmIyLi45MmJjY2M1NjIzYTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfZHJ2LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYwpAQCAtNjMxLDYg KzYzMSw4IEBAIHN0YXRpYyBpbnQgaTkxNV9kcml2ZXJfaHdfcHJvYmUoc3RydWN0IGRybV9pOTE1 X3ByaXZhdGUgKmRldl9wcml2KQogCWludGVsX21lbW9yeV9yZWdpb25zX2RyaXZlcl9yZWxlYXNl KGRldl9wcml2KTsKIGVycl9nZ3R0OgogCWk5MTVfZ2d0dF9kcml2ZXJfcmVsZWFzZShkZXZfcHJp dik7CisJaTkxNV9nZW1fZHJhaW5fZnJlZWRfb2JqZWN0cyhkZXZfcHJpdik7CisJaTkxNV9nZ3R0 X2RyaXZlcl9sYXRlX3JlbGVhc2UoZGV2X3ByaXYpOwogZXJyX3BlcmY6CiAJaTkxNV9wZXJmX2Zp bmkoZGV2X3ByaXYpOwogCXJldHVybiByZXQ7CkBAIC04ODAsNiArODgyLDggQEAgaW50IGk5MTVf ZHJpdmVyX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBjb25zdCBzdHJ1Y3QgcGNpX2Rldmlj ZV9pZCAqZW50KQogCWk5MTVfZHJpdmVyX2h3X3JlbW92ZShpOTE1KTsKIAlpbnRlbF9tZW1vcnlf cmVnaW9uc19kcml2ZXJfcmVsZWFzZShpOTE1KTsKIAlpOTE1X2dndHRfZHJpdmVyX3JlbGVhc2Uo aTkxNSk7CisJaTkxNV9nZW1fZHJhaW5fZnJlZWRfb2JqZWN0cyhpOTE1KTsKKwlpOTE1X2dndHRf ZHJpdmVyX2xhdGVfcmVsZWFzZShpOTE1KTsKIG91dF9jbGVhbnVwX21taW86CiAJaTkxNV9kcml2 ZXJfbW1pb19yZWxlYXNlKGk5MTUpOwogb3V0X3J1bnRpbWVfcG1fcHV0OgpAQCAtOTM2LDYgKzk0 MCw3IEBAIHN0YXRpYyB2b2lkIGk5MTVfZHJpdmVyX3JlbGVhc2Uoc3RydWN0IGRybV9kZXZpY2Ug KmRldikKIAlpbnRlbF9tZW1vcnlfcmVnaW9uc19kcml2ZXJfcmVsZWFzZShkZXZfcHJpdik7CiAJ aTkxNV9nZ3R0X2RyaXZlcl9yZWxlYXNlKGRldl9wcml2KTsKIAlpOTE1X2dlbV9kcmFpbl9mcmVl ZF9vYmplY3RzKGRldl9wcml2KTsKKwlpOTE1X2dndHRfZHJpdmVyX2xhdGVfcmVsZWFzZShkZXZf cHJpdik7CiAKIAlpOTE1X2RyaXZlcl9tbWlvX3JlbGVhc2UoZGV2X3ByaXYpOwogCi0tIAoyLjMx LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVs LWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=