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.8 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 77AD9C2B9F4 for ; Mon, 28 Jun 2021 14:46:50 +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 1265561C7E for ; Mon, 28 Jun 2021 14:46:50 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1265561C7E 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 526136E46B; Mon, 28 Jun 2021 14:46:45 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 29A1589FD7; Mon, 28 Jun 2021 14:46:41 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10029"; a="271825207" X-IronPort-AV: E=Sophos;i="5.83,306,1616482800"; d="scan'208";a="271825207" Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jun 2021 07:46:41 -0700 X-IronPort-AV: E=Sophos;i="5.83,306,1616482800"; d="scan'208";a="408091021" Received: from danielmi-mobl2.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.242]) by orsmga003-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jun 2021 07:46:38 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v3 1/5] drm/i915/gem: Implement object migration Date: Mon, 28 Jun 2021 16:46:22 +0200 Message-Id: <20210628144626.76126-2-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210628144626.76126-1-thomas.hellstrom@linux.intel.com> References: <20210628144626.76126-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?= , matthew.auld@intel.com, kernel test robot Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Introduce an interface to migrate objects between regions. This is primarily intended to migrate objects to LMEM for display and to SYSTEM for dma-buf, but might be reused in one form or another for performance-based migration. v2: - Verify that the memory region given as an id really exists. (Reported by Matthew Auld) - Call i915_gem_object_{init,release}_memory_region() when switching region to handle also switching region lists. (Reported by Matthew Auld) v3: - Fix i915_gem_object_can_migrate() to return true if object is already in the correct region, even if the object ops doesn't have a migrate() callback. - Update typo in commit message. - Fix kerneldoc of i915_gem_object_wait_migration(). Reported-by: kernel test robot Signed-off-by: Thomas Hellström --- drivers/gpu/drm/i915/gem/i915_gem_object.c | 96 +++++++++++++++++++ drivers/gpu/drm/i915/gem/i915_gem_object.h | 12 +++ .../gpu/drm/i915/gem/i915_gem_object_types.h | 9 ++ drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 69 +++++++++---- drivers/gpu/drm/i915/gem/i915_gem_wait.c | 19 ++++ 5 files changed, 188 insertions(+), 17 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.c b/drivers/gpu/drm/i915/gem/i915_gem_object.c index 07e8ff9a8aae..1c18be067b58 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -513,6 +513,102 @@ bool i915_gem_object_has_iomem(const struct drm_i915_gem_object *obj) return obj->mem_flags & I915_BO_FLAG_IOMEM; } +/** + * i915_gem_object_can_migrate - Whether an object likely can be migrated + * + * @obj: The object to migrate + * @id: The region intended to migrate to + * + * Check whether the object backend supports migration to the + * given region. Note that pinning may affect the ability to migrate. + * + * Return: true if migration is possible, false otherwise. + */ +bool i915_gem_object_can_migrate(struct drm_i915_gem_object *obj, + enum intel_region_id id) +{ + struct drm_i915_private *i915 = to_i915(obj->base.dev); + unsigned int num_allowed = obj->mm.n_placements; + struct intel_memory_region *mr; + unsigned int i; + + GEM_BUG_ON(id >= INTEL_REGION_UNKNOWN); + GEM_BUG_ON(obj->mm.madv != I915_MADV_WILLNEED); + + mr = i915->mm.regions[id]; + if (!mr) + return false; + + if (obj->mm.region == mr) + return true; + + if (!i915_gem_object_evictable(obj)) + return false; + + if (!obj->ops->migrate) + return false; + + if (!(obj->flags & I915_BO_ALLOC_USER)) + return true; + + if (num_allowed == 0) + return false; + + for (i = 0; i < num_allowed; ++i) { + if (mr == obj->mm.placements[i]) + return true; + } + + return false; +} + +/** + * i915_gem_object_migrate - Migrate an object to the desired region id + * @obj: The object to migrate. + * @ww: An optional struct i915_gem_ww_ctx. If NULL, the backend may + * not be successful in evicting other objects to make room for this object. + * @id: The region id to migrate to. + * + * Attempt to migrate the object to the desired memory region. The + * object backend must support migration and the object may not be + * pinned, (explicitly pinned pages or pinned vmas). The object must + * be locked. + * On successful completion, the object will have pages pointing to + * memory in the new region, but an async migration task may not have + * completed yet, and to accomplish that, i915_gem_object_wait_migration() + * must be called. + * + * Return: 0 on success. Negative error code on failure. In particular may + * return -ENXIO on lack of region space, -EDEADLK for deadlock avoidance + * if @ww is set, -EINTR or -ERESTARTSYS if signal pending, and + * -EBUSY if the object is pinned. + */ +int i915_gem_object_migrate(struct drm_i915_gem_object *obj, + struct i915_gem_ww_ctx *ww, + enum intel_region_id id) +{ + struct drm_i915_private *i915 = to_i915(obj->base.dev); + struct intel_memory_region *mr; + + GEM_BUG_ON(id >= INTEL_REGION_UNKNOWN); + GEM_BUG_ON(obj->mm.madv != I915_MADV_WILLNEED); + assert_object_held(obj); + + mr = i915->mm.regions[id]; + GEM_BUG_ON(!mr); + + if (obj->mm.region == mr) + return 0; + + if (!i915_gem_object_evictable(obj)) + return -EBUSY; + + if (!obj->ops->migrate) + return -EOPNOTSUPP; + + return obj->ops->migrate(obj, mr); +} + void i915_gem_init__objects(struct drm_i915_private *i915) { INIT_WORK(&i915->mm.free_work, __i915_gem_free_work); diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.h b/drivers/gpu/drm/i915/gem/i915_gem_object.h index ea3224a480c4..8cbd7a5334e2 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.h @@ -17,6 +17,8 @@ #include "i915_gem_ww.h" #include "i915_vma_types.h" +enum intel_region_id; + /* * XXX: There is a prevalence of the assumption that we fit the * object's page count inside a 32bit _signed_ variable. Let's document @@ -597,6 +599,16 @@ bool i915_gem_object_migratable(struct drm_i915_gem_object *obj); bool i915_gem_object_validates_to_lmem(struct drm_i915_gem_object *obj); +int i915_gem_object_migrate(struct drm_i915_gem_object *obj, + struct i915_gem_ww_ctx *ww, + enum intel_region_id id); + +bool i915_gem_object_can_migrate(struct drm_i915_gem_object *obj, + enum intel_region_id id); + +int i915_gem_object_wait_migration(struct drm_i915_gem_object *obj, + unsigned int flags); + #ifdef CONFIG_MMU_NOTIFIER static inline bool i915_gem_object_is_userptr(struct drm_i915_gem_object *obj) 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 441f913c87e6..ef3de2ae9723 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h @@ -18,6 +18,7 @@ struct drm_i915_gem_object; struct intel_fronbuffer; +struct intel_memory_region; /* * struct i915_lut_handle tracks the fast lookups from handle to vma used @@ -77,6 +78,14 @@ struct drm_i915_gem_object_ops { * delayed_free - Override the default delayed free implementation */ void (*delayed_free)(struct drm_i915_gem_object *obj); + + /** + * migrate - Migrate object to a different region either for + * pinning or for as long as the object lock is held. + */ + int (*migrate)(struct drm_i915_gem_object *obj, + struct intel_memory_region *mr); + void (*release)(struct drm_i915_gem_object *obj); const struct vm_operations_struct *mmap_ops; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c index c39d982c4fa6..8f89185b6507 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -617,7 +617,8 @@ struct ttm_device_funcs *i915_ttm_driver(void) return &i915_ttm_bo_driver; } -static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) +static int __i915_ttm_get_pages(struct drm_i915_gem_object *obj, + struct ttm_placement *placement) { struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); struct ttm_operation_ctx ctx = { @@ -625,19 +626,12 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) .no_wait_gpu = false, }; struct sg_table *st; - struct ttm_place requested, busy[I915_TTM_MAX_PLACEMENTS]; - struct ttm_placement placement; int real_num_busy; int ret; - GEM_BUG_ON(obj->mm.n_placements > I915_TTM_MAX_PLACEMENTS); - - /* Move to the requested placement. */ - i915_ttm_placement_from_obj(obj, &requested, busy, &placement); - /* First try only the requested placement. No eviction. */ - real_num_busy = fetch_and_zero(&placement.num_busy_placement); - ret = ttm_bo_validate(bo, &placement, &ctx); + real_num_busy = fetch_and_zero(&placement->num_busy_placement); + ret = ttm_bo_validate(bo, placement, &ctx); if (ret) { ret = i915_ttm_err_to_gem(ret); /* @@ -652,8 +646,8 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) * If the initial attempt fails, allow all accepted placements, * evicting if necessary. */ - placement.num_busy_placement = real_num_busy; - ret = ttm_bo_validate(bo, &placement, &ctx); + placement->num_busy_placement = real_num_busy; + ret = ttm_bo_validate(bo, placement, &ctx); if (ret) return i915_ttm_err_to_gem(ret); } @@ -668,16 +662,56 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) i915_ttm_adjust_gem_after_move(obj); } - /* Object either has a page vector or is an iomem object */ - st = bo->ttm ? i915_ttm_tt_get_st(bo->ttm) : obj->ttm.cached_io_st; - if (IS_ERR(st)) - return PTR_ERR(st); + if (!obj->mm.pages) { + /* Object either has a page vector or is an iomem object */ + st = bo->ttm ? i915_ttm_tt_get_st(bo->ttm) : obj->ttm.cached_io_st; + if (IS_ERR(st)) + return PTR_ERR(st); - __i915_gem_object_set_pages(obj, st, i915_sg_dma_sizes(st->sgl)); + __i915_gem_object_set_pages(obj, st, i915_sg_dma_sizes(st->sgl)); + } return ret; } +static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) +{ + struct ttm_place requested, busy[I915_TTM_MAX_PLACEMENTS]; + struct ttm_placement placement; + + GEM_BUG_ON(obj->mm.n_placements > I915_TTM_MAX_PLACEMENTS); + + /* Move to the requested placement. */ + i915_ttm_placement_from_obj(obj, &requested, busy, &placement); + + return __i915_ttm_get_pages(obj, &placement); +} + +static int i915_ttm_migrate(struct drm_i915_gem_object *obj, + struct intel_memory_region *mr) +{ + struct ttm_place requested; + struct ttm_placement placement; + int ret; + + i915_ttm_place_from_region(mr, &requested, obj->flags); + placement.num_placement = 1; + placement.num_busy_placement = 1; + placement.placement = &requested; + placement.busy_placement = &requested; + + ret = __i915_ttm_get_pages(obj, &placement); + if (ret) + return ret; + + if (obj->mm.region != mr) { + i915_gem_object_release_memory_region(obj); + i915_gem_object_init_memory_region(obj, mr); + } + + return 0; +} + static void i915_ttm_put_pages(struct drm_i915_gem_object *obj, struct sg_table *st) { @@ -814,6 +848,7 @@ static const struct drm_i915_gem_object_ops i915_gem_ttm_obj_ops = { .truncate = i915_ttm_purge, .adjust_lru = i915_ttm_adjust_lru, .delayed_free = i915_ttm_delayed_free, + .migrate = i915_ttm_migrate, .mmap_offset = i915_ttm_mmap_offset, .mmap_ops = &vm_ops_ttm, }; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_wait.c b/drivers/gpu/drm/i915/gem/i915_gem_wait.c index 1070d3afdce7..f909aaa09d9c 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_wait.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_wait.c @@ -290,3 +290,22 @@ i915_gem_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *file) i915_gem_object_put(obj); return ret; } + +/** + * i915_gem_object_wait_migration - Sync an accelerated migration operation + * @obj: The migrating object. + * @flags: waiting flags. Currently supports only I915_WAIT_INTERRUPTIBLE. + * + * Wait for any pending async migration operation on the object, + * whether it's explicitly (i915_gem_object_migrate()) or implicitly + * (swapin, initial clearing) initiated. + * + * Return: 0 if successful, -ERESTARTSYS if a signal was hit during waiting. + */ +int i915_gem_object_wait_migration(struct drm_i915_gem_object *obj, + unsigned int flags) +{ + might_sleep(); + /* NOP for now. */ + return 0; +} -- 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.8 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 AE00CC49361 for ; Mon, 28 Jun 2021 14:46:48 +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 617E361C7E for ; Mon, 28 Jun 2021 14:46:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 617E361C7E 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 A54E96E462; Mon, 28 Jun 2021 14:46:42 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 29A1589FD7; Mon, 28 Jun 2021 14:46:41 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10029"; a="271825207" X-IronPort-AV: E=Sophos;i="5.83,306,1616482800"; d="scan'208";a="271825207" Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jun 2021 07:46:41 -0700 X-IronPort-AV: E=Sophos;i="5.83,306,1616482800"; d="scan'208";a="408091021" Received: from danielmi-mobl2.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.242]) by orsmga003-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 Jun 2021 07:46:38 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Mon, 28 Jun 2021 16:46:22 +0200 Message-Id: <20210628144626.76126-2-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210628144626.76126-1-thomas.hellstrom@linux.intel.com> References: <20210628144626.76126-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v3 1/5] drm/i915/gem: Implement object migration 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?= , matthew.auld@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" SW50cm9kdWNlIGFuIGludGVyZmFjZSB0byBtaWdyYXRlIG9iamVjdHMgYmV0d2VlbiByZWdpb25z LgpUaGlzIGlzIHByaW1hcmlseSBpbnRlbmRlZCB0byBtaWdyYXRlIG9iamVjdHMgdG8gTE1FTSBm b3IgZGlzcGxheSBhbmQKdG8gU1lTVEVNIGZvciBkbWEtYnVmLCBidXQgbWlnaHQgYmUgcmV1c2Vk IGluIG9uZSBmb3JtIG9yIGFub3RoZXIgZm9yCnBlcmZvcm1hbmNlLWJhc2VkIG1pZ3JhdGlvbi4K CnYyOgotIFZlcmlmeSB0aGF0IHRoZSBtZW1vcnkgcmVnaW9uIGdpdmVuIGFzIGFuIGlkIHJlYWxs eSBleGlzdHMuCiAgKFJlcG9ydGVkIGJ5IE1hdHRoZXcgQXVsZCkKLSBDYWxsIGk5MTVfZ2VtX29i amVjdF97aW5pdCxyZWxlYXNlfV9tZW1vcnlfcmVnaW9uKCkgd2hlbiBzd2l0Y2hpbmcgcmVnaW9u CiAgdG8gaGFuZGxlIGFsc28gc3dpdGNoaW5nIHJlZ2lvbiBsaXN0cy4gKFJlcG9ydGVkIGJ5IE1h dHRoZXcgQXVsZCkKdjM6Ci0gRml4IGk5MTVfZ2VtX29iamVjdF9jYW5fbWlncmF0ZSgpIHRvIHJl dHVybiB0cnVlIGlmIG9iamVjdCBpcyBhbHJlYWR5IGluCiAgdGhlIGNvcnJlY3QgcmVnaW9uLCBl dmVuIGlmIHRoZSBvYmplY3Qgb3BzIGRvZXNuJ3QgaGF2ZSBhIG1pZ3JhdGUoKQogIGNhbGxiYWNr LgotIFVwZGF0ZSB0eXBvIGluIGNvbW1pdCBtZXNzYWdlLgotIEZpeCBrZXJuZWxkb2Mgb2YgaTkx NV9nZW1fb2JqZWN0X3dhaXRfbWlncmF0aW9uKCkuCgpSZXBvcnRlZC1ieToga2VybmVsIHRlc3Qg cm9ib3QgPGxrcEBpbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0 aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fb2JqZWN0LmMgICAgfCA5NiArKysrKysrKysrKysrKysrKysrCiBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmggICAgfCAxMiArKysKIC4uLi9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oICB8ICA5ICsrCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMgICAgICAgfCA2OSArKysrKysrKystLS0t CiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fd2FpdC5jICAgICAgfCAxOSArKysr CiA1IGZpbGVzIGNoYW5nZWQsIDE4OCBpbnNlcnRpb25zKCspLCAxNyBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmMgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmMKaW5kZXggMDdlOGZmOWE4 YWFlLi4xYzE4YmUwNjdiNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV9vYmplY3QuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1f b2JqZWN0LmMKQEAgLTUxMyw2ICs1MTMsMTAyIEBAIGJvb2wgaTkxNV9nZW1fb2JqZWN0X2hhc19p b21lbShjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogCXJldHVybiBvYmot Pm1lbV9mbGFncyAmIEk5MTVfQk9fRkxBR19JT01FTTsKIH0KIAorLyoqCisgKiBpOTE1X2dlbV9v YmplY3RfY2FuX21pZ3JhdGUgLSBXaGV0aGVyIGFuIG9iamVjdCBsaWtlbHkgY2FuIGJlIG1pZ3Jh dGVkCisgKgorICogQG9iajogVGhlIG9iamVjdCB0byBtaWdyYXRlCisgKiBAaWQ6IFRoZSByZWdp b24gaW50ZW5kZWQgdG8gbWlncmF0ZSB0bworICoKKyAqIENoZWNrIHdoZXRoZXIgdGhlIG9iamVj dCBiYWNrZW5kIHN1cHBvcnRzIG1pZ3JhdGlvbiB0byB0aGUKKyAqIGdpdmVuIHJlZ2lvbi4gTm90 ZSB0aGF0IHBpbm5pbmcgbWF5IGFmZmVjdCB0aGUgYWJpbGl0eSB0byBtaWdyYXRlLgorICoKKyAq IFJldHVybjogdHJ1ZSBpZiBtaWdyYXRpb24gaXMgcG9zc2libGUsIGZhbHNlIG90aGVyd2lzZS4K KyAqLworYm9vbCBpOTE1X2dlbV9vYmplY3RfY2FuX21pZ3JhdGUoc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaiwKKwkJCQkgZW51bSBpbnRlbF9yZWdpb25faWQgaWQpCit7CisJc3RydWN0 IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUgPSB0b19pOTE1KG9iai0+YmFzZS5kZXYpOworCXVuc2ln bmVkIGludCBudW1fYWxsb3dlZCA9IG9iai0+bW0ubl9wbGFjZW1lbnRzOworCXN0cnVjdCBpbnRl bF9tZW1vcnlfcmVnaW9uICptcjsKKwl1bnNpZ25lZCBpbnQgaTsKKworCUdFTV9CVUdfT04oaWQg Pj0gSU5URUxfUkVHSU9OX1VOS05PV04pOworCUdFTV9CVUdfT04ob2JqLT5tbS5tYWR2ICE9IEk5 MTVfTUFEVl9XSUxMTkVFRCk7CisKKwltciA9IGk5MTUtPm1tLnJlZ2lvbnNbaWRdOworCWlmICgh bXIpCisJCXJldHVybiBmYWxzZTsKKworCWlmIChvYmotPm1tLnJlZ2lvbiA9PSBtcikKKwkJcmV0 dXJuIHRydWU7CisKKwlpZiAoIWk5MTVfZ2VtX29iamVjdF9ldmljdGFibGUob2JqKSkKKwkJcmV0 dXJuIGZhbHNlOworCisJaWYgKCFvYmotPm9wcy0+bWlncmF0ZSkKKwkJcmV0dXJuIGZhbHNlOwor CisJaWYgKCEob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfVVNFUikpCisJCXJldHVybiB0cnVl OworCisJaWYgKG51bV9hbGxvd2VkID09IDApCisJCXJldHVybiBmYWxzZTsKKworCWZvciAoaSA9 IDA7IGkgPCBudW1fYWxsb3dlZDsgKytpKSB7CisJCWlmIChtciA9PSBvYmotPm1tLnBsYWNlbWVu dHNbaV0pCisJCQlyZXR1cm4gdHJ1ZTsKKwl9CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKKy8qKgor ICogaTkxNV9nZW1fb2JqZWN0X21pZ3JhdGUgLSBNaWdyYXRlIGFuIG9iamVjdCB0byB0aGUgZGVz aXJlZCByZWdpb24gaWQKKyAqIEBvYmo6IFRoZSBvYmplY3QgdG8gbWlncmF0ZS4KKyAqIEB3dzog QW4gb3B0aW9uYWwgc3RydWN0IGk5MTVfZ2VtX3d3X2N0eC4gSWYgTlVMTCwgdGhlIGJhY2tlbmQg bWF5CisgKiBub3QgYmUgc3VjY2Vzc2Z1bCBpbiBldmljdGluZyBvdGhlciBvYmplY3RzIHRvIG1h a2Ugcm9vbSBmb3IgdGhpcyBvYmplY3QuCisgKiBAaWQ6IFRoZSByZWdpb24gaWQgdG8gbWlncmF0 ZSB0by4KKyAqCisgKiBBdHRlbXB0IHRvIG1pZ3JhdGUgdGhlIG9iamVjdCB0byB0aGUgZGVzaXJl ZCBtZW1vcnkgcmVnaW9uLiBUaGUKKyAqIG9iamVjdCBiYWNrZW5kIG11c3Qgc3VwcG9ydCBtaWdy YXRpb24gYW5kIHRoZSBvYmplY3QgbWF5IG5vdCBiZQorICogcGlubmVkLCAoZXhwbGljaXRseSBw aW5uZWQgcGFnZXMgb3IgcGlubmVkIHZtYXMpLiBUaGUgb2JqZWN0IG11c3QKKyAqIGJlIGxvY2tl ZC4KKyAqIE9uIHN1Y2Nlc3NmdWwgY29tcGxldGlvbiwgdGhlIG9iamVjdCB3aWxsIGhhdmUgcGFn ZXMgcG9pbnRpbmcgdG8KKyAqIG1lbW9yeSBpbiB0aGUgbmV3IHJlZ2lvbiwgYnV0IGFuIGFzeW5j IG1pZ3JhdGlvbiB0YXNrIG1heSBub3QgaGF2ZQorICogY29tcGxldGVkIHlldCwgYW5kIHRvIGFj Y29tcGxpc2ggdGhhdCwgaTkxNV9nZW1fb2JqZWN0X3dhaXRfbWlncmF0aW9uKCkKKyAqIG11c3Qg YmUgY2FsbGVkLgorICoKKyAqIFJldHVybjogMCBvbiBzdWNjZXNzLiBOZWdhdGl2ZSBlcnJvciBj b2RlIG9uIGZhaWx1cmUuIEluIHBhcnRpY3VsYXIgbWF5CisgKiByZXR1cm4gLUVOWElPIG9uIGxh Y2sgb2YgcmVnaW9uIHNwYWNlLCAtRURFQURMSyBmb3IgZGVhZGxvY2sgYXZvaWRhbmNlCisgKiBp ZiBAd3cgaXMgc2V0LCAtRUlOVFIgb3IgLUVSRVNUQVJUU1lTIGlmIHNpZ25hbCBwZW5kaW5nLCBh bmQKKyAqIC1FQlVTWSBpZiB0aGUgb2JqZWN0IGlzIHBpbm5lZC4KKyAqLworaW50IGk5MTVfZ2Vt X29iamVjdF9taWdyYXRlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgICAg c3RydWN0IGk5MTVfZ2VtX3d3X2N0eCAqd3csCisJCQkgICAgZW51bSBpbnRlbF9yZWdpb25faWQg aWQpCit7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUgPSB0b19pOTE1KG9iai0+YmFz ZS5kZXYpOworCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptcjsKKworCUdFTV9CVUdfT04o aWQgPj0gSU5URUxfUkVHSU9OX1VOS05PV04pOworCUdFTV9CVUdfT04ob2JqLT5tbS5tYWR2ICE9 IEk5MTVfTUFEVl9XSUxMTkVFRCk7CisJYXNzZXJ0X29iamVjdF9oZWxkKG9iaik7CisKKwltciA9 IGk5MTUtPm1tLnJlZ2lvbnNbaWRdOworCUdFTV9CVUdfT04oIW1yKTsKKworCWlmIChvYmotPm1t LnJlZ2lvbiA9PSBtcikKKwkJcmV0dXJuIDA7CisKKwlpZiAoIWk5MTVfZ2VtX29iamVjdF9ldmlj dGFibGUob2JqKSkKKwkJcmV0dXJuIC1FQlVTWTsKKworCWlmICghb2JqLT5vcHMtPm1pZ3JhdGUp CisJCXJldHVybiAtRU9QTk9UU1VQUDsKKworCXJldHVybiBvYmotPm9wcy0+bWlncmF0ZShvYmos IG1yKTsKK30KKwogdm9pZCBpOTE1X2dlbV9pbml0X19vYmplY3RzKHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICppOTE1KQogewogCUlOSVRfV09SSygmaTkxNS0+bW0uZnJlZV93b3JrLCBfX2k5MTVf Z2VtX2ZyZWVfd29yayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkx NV9nZW1fb2JqZWN0LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0 LmgKaW5kZXggZWEzMjI0YTQ4MGM0Li44Y2JkN2E1MzM0ZTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmgKQEAgLTE3LDYgKzE3LDggQEAKICNpbmNsdWRlICJp OTE1X2dlbV93dy5oIgogI2luY2x1ZGUgImk5MTVfdm1hX3R5cGVzLmgiCiAKK2VudW0gaW50ZWxf cmVnaW9uX2lkOworCiAvKgogICogWFhYOiBUaGVyZSBpcyBhIHByZXZhbGVuY2Ugb2YgdGhlIGFz c3VtcHRpb24gdGhhdCB3ZSBmaXQgdGhlCiAgKiBvYmplY3QncyBwYWdlIGNvdW50IGluc2lkZSBh IDMyYml0IF9zaWduZWRfIHZhcmlhYmxlLiBMZXQncyBkb2N1bWVudApAQCAtNTk3LDYgKzU5OSwx NiBAQCBib29sIGk5MTVfZ2VtX29iamVjdF9taWdyYXRhYmxlKHN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmopOwogCiBib29sIGk5MTVfZ2VtX29iamVjdF92YWxpZGF0ZXNfdG9fbG1lbShz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKIAoraW50IGk5MTVfZ2VtX29iamVjdF9t aWdyYXRlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgICAgc3RydWN0IGk5 MTVfZ2VtX3d3X2N0eCAqd3csCisJCQkgICAgZW51bSBpbnRlbF9yZWdpb25faWQgaWQpOworCiti b29sIGk5MTVfZ2VtX29iamVjdF9jYW5fbWlncmF0ZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqLAorCQkJCSBlbnVtIGludGVsX3JlZ2lvbl9pZCBpZCk7CisKK2ludCBpOTE1X2dlbV9v YmplY3Rfd2FpdF9taWdyYXRpb24oc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKKwkJ CQkgICB1bnNpZ25lZCBpbnQgZmxhZ3MpOworCiAjaWZkZWYgQ09ORklHX01NVV9OT1RJRklFUgog c3RhdGljIGlubGluZSBib29sCiBpOTE1X2dlbV9vYmplY3RfaXNfdXNlcnB0cihzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqb2JqKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX29iamVjdF90eXBlcy5oCmluZGV4IDQ0MWY5MTNjODdlNi4uZWYzZGUyYWU5NzIzIDEw MDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVz LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5o CkBAIC0xOCw2ICsxOCw3IEBACiAKIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0Owogc3RydWN0 IGludGVsX2Zyb25idWZmZXI7CitzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbjsKIAogLyoKICAq IHN0cnVjdCBpOTE1X2x1dF9oYW5kbGUgdHJhY2tzIHRoZSBmYXN0IGxvb2t1cHMgZnJvbSBoYW5k bGUgdG8gdm1hIHVzZWQKQEAgLTc3LDYgKzc4LDE0IEBAIHN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0X29wcyB7CiAJICogZGVsYXllZF9mcmVlIC0gT3ZlcnJpZGUgdGhlIGRlZmF1bHQgZGVsYXll ZCBmcmVlIGltcGxlbWVudGF0aW9uCiAJICovCiAJdm9pZCAoKmRlbGF5ZWRfZnJlZSkoc3RydWN0 IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKKwkvKioKKwkgKiBtaWdyYXRlIC0gTWlncmF0 ZSBvYmplY3QgdG8gYSBkaWZmZXJlbnQgcmVnaW9uIGVpdGhlciBmb3IKKwkgKiBwaW5uaW5nIG9y IGZvciBhcyBsb25nIGFzIHRoZSBvYmplY3QgbG9jayBpcyBoZWxkLgorCSAqLworCWludCAoKm1p Z3JhdGUpKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCSAgICAgICBzdHJ1Y3Qg aW50ZWxfbWVtb3J5X3JlZ2lvbiAqbXIpOworCiAJdm9pZCAoKnJlbGVhc2UpKHN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0ICpvYmopOwogCiAJY29uc3Qgc3RydWN0IHZtX29wZXJhdGlvbnNfc3Ry dWN0ICptbWFwX29wczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV90dG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYwppbmRl eCBjMzlkOTgyYzRmYTYuLjhmODkxODViNjUwNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV90dG0uYwpAQCAtNjE3LDcgKzYxNyw4IEBAIHN0cnVjdCB0dG1fZGV2aWNlX2Z1bmNz ICppOTE1X3R0bV9kcml2ZXIodm9pZCkKIAlyZXR1cm4gJmk5MTVfdHRtX2JvX2RyaXZlcjsKIH0K IAotc3RhdGljIGludCBpOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKm9iaikKK3N0YXRpYyBpbnQgX19pOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaiwKKwkJCQlzdHJ1Y3QgdHRtX3BsYWNlbWVudCAqcGxhY2VtZW50KQog ewogCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190dG0ob2JqKTsK IAlzdHJ1Y3QgdHRtX29wZXJhdGlvbl9jdHggY3R4ID0gewpAQCAtNjI1LDE5ICs2MjYsMTIgQEAg c3RhdGljIGludCBpOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaikKIAkJLm5vX3dhaXRfZ3B1ID0gZmFsc2UsCiAJfTsKIAlzdHJ1Y3Qgc2dfdGFibGUgKnN0 OwotCXN0cnVjdCB0dG1fcGxhY2UgcmVxdWVzdGVkLCBidXN5W0k5MTVfVFRNX01BWF9QTEFDRU1F TlRTXTsKLQlzdHJ1Y3QgdHRtX3BsYWNlbWVudCBwbGFjZW1lbnQ7CiAJaW50IHJlYWxfbnVtX2J1 c3k7CiAJaW50IHJldDsKIAotCUdFTV9CVUdfT04ob2JqLT5tbS5uX3BsYWNlbWVudHMgPiBJOTE1 X1RUTV9NQVhfUExBQ0VNRU5UUyk7Ci0KLQkvKiBNb3ZlIHRvIHRoZSByZXF1ZXN0ZWQgcGxhY2Vt ZW50LiAqLwotCWk5MTVfdHRtX3BsYWNlbWVudF9mcm9tX29iaihvYmosICZyZXF1ZXN0ZWQsIGJ1 c3ksICZwbGFjZW1lbnQpOwotCiAJLyogRmlyc3QgdHJ5IG9ubHkgdGhlIHJlcXVlc3RlZCBwbGFj ZW1lbnQuIE5vIGV2aWN0aW9uLiAqLwotCXJlYWxfbnVtX2J1c3kgPSBmZXRjaF9hbmRfemVybygm cGxhY2VtZW50Lm51bV9idXN5X3BsYWNlbWVudCk7Ci0JcmV0ID0gdHRtX2JvX3ZhbGlkYXRlKGJv LCAmcGxhY2VtZW50LCAmY3R4KTsKKwlyZWFsX251bV9idXN5ID0gZmV0Y2hfYW5kX3plcm8oJnBs YWNlbWVudC0+bnVtX2J1c3lfcGxhY2VtZW50KTsKKwlyZXQgPSB0dG1fYm9fdmFsaWRhdGUoYm8s IHBsYWNlbWVudCwgJmN0eCk7CiAJaWYgKHJldCkgewogCQlyZXQgPSBpOTE1X3R0bV9lcnJfdG9f Z2VtKHJldCk7CiAJCS8qCkBAIC02NTIsOCArNjQ2LDggQEAgc3RhdGljIGludCBpOTE1X3R0bV9n ZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKIAkJICogSWYgdGhlIGlu aXRpYWwgYXR0ZW1wdCBmYWlscywgYWxsb3cgYWxsIGFjY2VwdGVkIHBsYWNlbWVudHMsCiAJCSAq IGV2aWN0aW5nIGlmIG5lY2Vzc2FyeS4KIAkJICovCi0JCXBsYWNlbWVudC5udW1fYnVzeV9wbGFj ZW1lbnQgPSByZWFsX251bV9idXN5OwotCQlyZXQgPSB0dG1fYm9fdmFsaWRhdGUoYm8sICZwbGFj ZW1lbnQsICZjdHgpOworCQlwbGFjZW1lbnQtPm51bV9idXN5X3BsYWNlbWVudCA9IHJlYWxfbnVt X2J1c3k7CisJCXJldCA9IHR0bV9ib192YWxpZGF0ZShibywgcGxhY2VtZW50LCAmY3R4KTsKIAkJ aWYgKHJldCkKIAkJCXJldHVybiBpOTE1X3R0bV9lcnJfdG9fZ2VtKHJldCk7CiAJfQpAQCAtNjY4 LDE2ICs2NjIsNTYgQEAgc3RhdGljIGludCBpOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRybV9p OTE1X2dlbV9vYmplY3QgKm9iaikKIAkJaTkxNV90dG1fYWRqdXN0X2dlbV9hZnRlcl9tb3ZlKG9i aik7CiAJfQogCi0JLyogT2JqZWN0IGVpdGhlciBoYXMgYSBwYWdlIHZlY3RvciBvciBpcyBhbiBp b21lbSBvYmplY3QgKi8KLQlzdCA9IGJvLT50dG0gPyBpOTE1X3R0bV90dF9nZXRfc3QoYm8tPnR0 bSkgOiBvYmotPnR0bS5jYWNoZWRfaW9fc3Q7Ci0JaWYgKElTX0VSUihzdCkpCi0JCXJldHVybiBQ VFJfRVJSKHN0KTsKKwlpZiAoIW9iai0+bW0ucGFnZXMpIHsKKwkJLyogT2JqZWN0IGVpdGhlciBo YXMgYSBwYWdlIHZlY3RvciBvciBpcyBhbiBpb21lbSBvYmplY3QgKi8KKwkJc3QgPSBiby0+dHRt ID8gaTkxNV90dG1fdHRfZ2V0X3N0KGJvLT50dG0pIDogb2JqLT50dG0uY2FjaGVkX2lvX3N0Owor CQlpZiAoSVNfRVJSKHN0KSkKKwkJCXJldHVybiBQVFJfRVJSKHN0KTsKIAotCV9faTkxNV9nZW1f b2JqZWN0X3NldF9wYWdlcyhvYmosIHN0LCBpOTE1X3NnX2RtYV9zaXplcyhzdC0+c2dsKSk7CisJ CV9faTkxNV9nZW1fb2JqZWN0X3NldF9wYWdlcyhvYmosIHN0LCBpOTE1X3NnX2RtYV9zaXplcyhz dC0+c2dsKSk7CisJfQogCiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIGludCBpOTE1X3R0bV9n ZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwlzdHJ1Y3QgdHRt X3BsYWNlIHJlcXVlc3RlZCwgYnVzeVtJOTE1X1RUTV9NQVhfUExBQ0VNRU5UU107CisJc3RydWN0 IHR0bV9wbGFjZW1lbnQgcGxhY2VtZW50OworCisJR0VNX0JVR19PTihvYmotPm1tLm5fcGxhY2Vt ZW50cyA+IEk5MTVfVFRNX01BWF9QTEFDRU1FTlRTKTsKKworCS8qIE1vdmUgdG8gdGhlIHJlcXVl c3RlZCBwbGFjZW1lbnQuICovCisJaTkxNV90dG1fcGxhY2VtZW50X2Zyb21fb2JqKG9iaiwgJnJl cXVlc3RlZCwgYnVzeSwgJnBsYWNlbWVudCk7CisKKwlyZXR1cm4gX19pOTE1X3R0bV9nZXRfcGFn ZXMob2JqLCAmcGxhY2VtZW50KTsKK30KKworc3RhdGljIGludCBpOTE1X3R0bV9taWdyYXRlKHN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgICAgc3RydWN0IGludGVsX21lbW9y eV9yZWdpb24gKm1yKQoreworCXN0cnVjdCB0dG1fcGxhY2UgcmVxdWVzdGVkOworCXN0cnVjdCB0 dG1fcGxhY2VtZW50IHBsYWNlbWVudDsKKwlpbnQgcmV0OworCisJaTkxNV90dG1fcGxhY2VfZnJv bV9yZWdpb24obXIsICZyZXF1ZXN0ZWQsIG9iai0+ZmxhZ3MpOworCXBsYWNlbWVudC5udW1fcGxh Y2VtZW50ID0gMTsKKwlwbGFjZW1lbnQubnVtX2J1c3lfcGxhY2VtZW50ID0gMTsKKwlwbGFjZW1l bnQucGxhY2VtZW50ID0gJnJlcXVlc3RlZDsKKwlwbGFjZW1lbnQuYnVzeV9wbGFjZW1lbnQgPSAm cmVxdWVzdGVkOworCisJcmV0ID0gX19pOTE1X3R0bV9nZXRfcGFnZXMob2JqLCAmcGxhY2VtZW50 KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJaWYgKG9iai0+bW0ucmVnaW9uICE9IG1y KSB7CisJCWk5MTVfZ2VtX29iamVjdF9yZWxlYXNlX21lbW9yeV9yZWdpb24ob2JqKTsKKwkJaTkx NV9nZW1fb2JqZWN0X2luaXRfbWVtb3J5X3JlZ2lvbihvYmosIG1yKTsKKwl9CisKKwlyZXR1cm4g MDsKK30KKwogc3RhdGljIHZvaWQgaTkxNV90dG1fcHV0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9n ZW1fb2JqZWN0ICpvYmosCiAJCQkgICAgICAgc3RydWN0IHNnX3RhYmxlICpzdCkKIHsKQEAgLTgx NCw2ICs4NDgsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3Bz IGk5MTVfZ2VtX3R0bV9vYmpfb3BzID0gewogCS50cnVuY2F0ZSA9IGk5MTVfdHRtX3B1cmdlLAog CS5hZGp1c3RfbHJ1ID0gaTkxNV90dG1fYWRqdXN0X2xydSwKIAkuZGVsYXllZF9mcmVlID0gaTkx NV90dG1fZGVsYXllZF9mcmVlLAorCS5taWdyYXRlID0gaTkxNV90dG1fbWlncmF0ZSwKIAkubW1h cF9vZmZzZXQgPSBpOTE1X3R0bV9tbWFwX29mZnNldCwKIAkubW1hcF9vcHMgPSAmdm1fb3BzX3R0 bSwKIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fd2Fp dC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3dhaXQuYwppbmRleCAxMDcw ZDNhZmRjZTcuLmY5MDlhYWEwOWQ5YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX3dhaXQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9n ZW1fd2FpdC5jCkBAIC0yOTAsMyArMjkwLDIyIEBAIGk5MTVfZ2VtX3dhaXRfaW9jdGwoc3RydWN0 IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwgc3RydWN0IGRybV9maWxlICpmaWxlKQogCWk5 MTVfZ2VtX29iamVjdF9wdXQob2JqKTsKIAlyZXR1cm4gcmV0OwogfQorCisvKioKKyAqIGk5MTVf Z2VtX29iamVjdF93YWl0X21pZ3JhdGlvbiAtIFN5bmMgYW4gYWNjZWxlcmF0ZWQgbWlncmF0aW9u IG9wZXJhdGlvbgorICogQG9iajogVGhlIG1pZ3JhdGluZyBvYmplY3QuCisgKiBAZmxhZ3M6IHdh aXRpbmcgZmxhZ3MuIEN1cnJlbnRseSBzdXBwb3J0cyBvbmx5IEk5MTVfV0FJVF9JTlRFUlJVUFRJ QkxFLgorICoKKyAqIFdhaXQgZm9yIGFueSBwZW5kaW5nIGFzeW5jIG1pZ3JhdGlvbiBvcGVyYXRp b24gb24gdGhlIG9iamVjdCwKKyAqIHdoZXRoZXIgaXQncyBleHBsaWNpdGx5IChpOTE1X2dlbV9v YmplY3RfbWlncmF0ZSgpKSBvciBpbXBsaWNpdGx5CisgKiAoc3dhcGluLCBpbml0aWFsIGNsZWFy aW5nKSBpbml0aWF0ZWQuCisgKgorICogUmV0dXJuOiAwIGlmIHN1Y2Nlc3NmdWwsIC1FUkVTVEFS VFNZUyBpZiBhIHNpZ25hbCB3YXMgaGl0IGR1cmluZyB3YWl0aW5nLgorICovCitpbnQgaTkxNV9n ZW1fb2JqZWN0X3dhaXRfbWlncmF0aW9uKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmos CisJCQkJICAgdW5zaWduZWQgaW50IGZsYWdzKQoreworCW1pZ2h0X3NsZWVwKCk7CisJLyogTk9Q IGZvciBub3cuICovCisJcmV0dXJuIDA7Cit9Ci0tIAoyLjMxLjEKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50 ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=