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 508DDC48BDF for ; Thu, 24 Jun 2021 08:43:18 +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 1E2C4613D8 for ; Thu, 24 Jun 2021 08:43:18 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1E2C4613D8 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 6ED216EB28; Thu, 24 Jun 2021 08:43:12 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 371066EB2B; Thu, 24 Jun 2021 08:43:10 +0000 (UTC) IronPort-SDR: wl4Rr8UUeuZyvQUQHudvb6Gn2Q4F2N+Z9ByhC0lAn0WYulx5CpQ8VeGAZg+r5ee2e6NFNaX3fm pj3lA+x2rl9g== X-IronPort-AV: E=McAfee;i="6200,9189,10024"; a="205601340" X-IronPort-AV: E=Sophos;i="5.83,296,1616482800"; d="scan'208";a="205601340" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 Jun 2021 01:43:09 -0700 IronPort-SDR: ZACg4uFEnF6eKV727w3DFpesBPdmh91RnnwB/gppwShkyOhDxJohpLhXGhFgHimXOAL/+TDYV+ IfSu27njsHMA== X-IronPort-AV: E=Sophos;i="5.83,296,1616482800"; d="scan'208";a="453344922" Received: from cmutgix-mobl.gar.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.20]) by orsmga008-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 Jun 2021 01:43:07 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v10 2/3] drm/i915/ttm: Adjust gem flags and caching settings after a move Date: Thu, 24 Jun 2021 10:42:39 +0200 Message-Id: <20210624084240.270219-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210624084240.270219-1-thomas.hellstrom@linux.intel.com> References: <20210624084240.270219-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 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" After a TTM move or object init we need to update the i915 gem flags and caching settings to reflect the new placement. Currently caching settings are not changed during the lifetime of an object, although that might change moving forward if we run into performance issues or issues with WC system page allocations. Also introduce gpu_binds_iomem() and cpu_maps_iomem() to clean up the various ways we previously used to detect this. Finally, initialize the TTM object reserved to be able to update flags and caching before anyone else gets hold of the object. Signed-off-by: Thomas Hellström Reviewed-by: Matthew Auld --- v6: - Rebase on accelerated ttm moves. v8: - Reinstate alignment at ttm_bo_init_reserved() time. (Reported by Matthew Auld). --- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 144 ++++++++++++++++++------ 1 file changed, 108 insertions(+), 36 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c index b5dd3b7037f4..a1dc592c11bc 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -91,6 +91,26 @@ static int i915_ttm_err_to_gem(int err) return err; } +static bool gpu_binds_iomem(struct ttm_resource *mem) +{ + return mem->mem_type != TTM_PL_SYSTEM; +} + +static bool cpu_maps_iomem(struct ttm_resource *mem) +{ + /* Once / if we support GGTT, this is also false for cached ttm_tts */ + return mem->mem_type != TTM_PL_SYSTEM; +} + +static enum i915_cache_level +i915_ttm_cache_level(struct drm_i915_private *i915, struct ttm_resource *res, + struct ttm_tt *ttm) +{ + return ((HAS_LLC(i915) || HAS_SNOOP(i915)) && !gpu_binds_iomem(res) && + ttm->caching == ttm_cached) ? I915_CACHE_LLC : + I915_CACHE_NONE; +} + static void i915_ttm_adjust_lru(struct drm_i915_gem_object *obj); static enum ttm_caching @@ -248,6 +268,35 @@ static void i915_ttm_free_cached_io_st(struct drm_i915_gem_object *obj) obj->ttm.cached_io_st = NULL; } +static void +i915_ttm_adjust_domains_after_move(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + + if (cpu_maps_iomem(bo->resource) || bo->ttm->caching != ttm_cached) { + obj->write_domain = I915_GEM_DOMAIN_WC; + obj->read_domains = I915_GEM_DOMAIN_WC; + } else { + obj->write_domain = I915_GEM_DOMAIN_CPU; + obj->read_domains = I915_GEM_DOMAIN_CPU; + } +} + +static void i915_ttm_adjust_gem_after_move(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + unsigned int cache_level; + + obj->mem_flags &= ~(I915_BO_FLAG_STRUCT_PAGE | I915_BO_FLAG_IOMEM); + + obj->mem_flags |= cpu_maps_iomem(bo->resource) ? I915_BO_FLAG_IOMEM : + I915_BO_FLAG_STRUCT_PAGE; + + cache_level = i915_ttm_cache_level(to_i915(bo->base.dev), bo->resource, + bo->ttm); + i915_gem_object_set_cache_coherency(obj, cache_level); +} + static void i915_ttm_purge(struct drm_i915_gem_object *obj) { struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); @@ -263,8 +312,10 @@ static void i915_ttm_purge(struct drm_i915_gem_object *obj) /* TTM's purge interface. Note that we might be reentering. */ ret = ttm_bo_validate(bo, &place, &ctx); - if (!ret) { + obj->write_domain = 0; + obj->read_domains = 0; + i915_ttm_adjust_gem_after_move(obj); i915_ttm_free_cached_io_st(obj); obj->mm.madv = __I915_MADV_PURGED; } @@ -347,12 +398,15 @@ i915_ttm_resource_get_st(struct drm_i915_gem_object *obj, struct ttm_resource *res) { struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); - struct ttm_resource_manager *man = - ttm_manager_type(bo->bdev, res->mem_type); - if (man->use_tt) + if (!gpu_binds_iomem(res)) return i915_ttm_tt_get_st(bo->ttm); + /* + * If CPU mapping differs, we need to add the ttm_tt pages to + * the resulting st. Might make sense for GGTT. + */ + GEM_WARN_ON(!cpu_maps_iomem(res)); return intel_region_ttm_resource_to_st(obj->mm.region, res); } @@ -367,23 +421,25 @@ static int i915_ttm_accel_move(struct ttm_buffer_object *bo, struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); struct sg_table *src_st; struct i915_request *rq; + struct ttm_tt *ttm = bo->ttm; + enum i915_cache_level src_level, dst_level; int ret; if (!i915->gt.migrate.context) return -EINVAL; - if (!bo->ttm || !ttm_tt_is_populated(bo->ttm)) { + dst_level = i915_ttm_cache_level(i915, dst_mem, ttm); + if (!ttm || !ttm_tt_is_populated(ttm)) { if (bo->type == ttm_bo_type_kernel) return -EINVAL; - if (bo->ttm && - !(bo->ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)) + if (ttm && !(ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)) return 0; intel_engine_pm_get(i915->gt.migrate.context->engine); ret = intel_context_migrate_clear(i915->gt.migrate.context, NULL, - dst_st->sgl, I915_CACHE_NONE, - dst_mem->mem_type >= I915_PL_LMEM0, + dst_st->sgl, dst_level, + gpu_binds_iomem(dst_mem), 0, &rq); if (!ret && rq) { @@ -392,15 +448,16 @@ static int i915_ttm_accel_move(struct ttm_buffer_object *bo, } intel_engine_pm_put(i915->gt.migrate.context->engine); } else { - src_st = src_man->use_tt ? i915_ttm_tt_get_st(bo->ttm) : - obj->ttm.cached_io_st; + src_st = src_man->use_tt ? i915_ttm_tt_get_st(ttm) : + obj->ttm.cached_io_st; + src_level = i915_ttm_cache_level(i915, bo->resource, ttm); intel_engine_pm_get(i915->gt.migrate.context->engine); ret = intel_context_migrate_copy(i915->gt.migrate.context, - NULL, src_st->sgl, I915_CACHE_NONE, - bo->resource->mem_type >= I915_PL_LMEM0, - dst_st->sgl, I915_CACHE_NONE, - dst_mem->mem_type >= I915_PL_LMEM0, + NULL, src_st->sgl, src_level, + gpu_binds_iomem(bo->resource), + dst_st->sgl, dst_level, + gpu_binds_iomem(dst_mem), &rq); if (!ret && rq) { i915_request_wait(rq, 0, MAX_SCHEDULE_TIMEOUT); @@ -420,8 +477,6 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); struct ttm_resource_manager *dst_man = ttm_manager_type(bo->bdev, dst_mem->mem_type); - struct ttm_resource_manager *src_man = - ttm_manager_type(bo->bdev, bo->resource->mem_type); struct intel_memory_region *dst_reg, *src_reg; union { struct ttm_kmap_iter_tt tt; @@ -465,12 +520,12 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, ret = i915_ttm_accel_move(bo, dst_mem, dst_st); if (ret) { /* If we start mapping GGTT, we can no longer use man::use_tt here. */ - dst_iter = dst_man->use_tt ? + dst_iter = !cpu_maps_iomem(dst_mem) ? ttm_kmap_iter_tt_init(&_dst_iter.tt, bo->ttm) : ttm_kmap_iter_iomap_init(&_dst_iter.io, &dst_reg->iomap, dst_st, dst_reg->region.start); - src_iter = src_man->use_tt ? + src_iter = !cpu_maps_iomem(bo->resource) ? ttm_kmap_iter_tt_init(&_src_iter.tt, bo->ttm) : ttm_kmap_iter_iomap_init(&_src_iter.io, &src_reg->iomap, obj->ttm.cached_io_st, @@ -478,21 +533,24 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, ttm_move_memcpy(bo, dst_mem->num_pages, dst_iter, src_iter); } + /* Below dst_mem becomes bo->resource. */ ttm_bo_move_sync_cleanup(bo, dst_mem); + i915_ttm_adjust_domains_after_move(obj); i915_ttm_free_cached_io_st(obj); - if (!dst_man->use_tt) { + if (gpu_binds_iomem(dst_mem) || cpu_maps_iomem(dst_mem)) { obj->ttm.cached_io_st = dst_st; obj->ttm.get_io_page.sg_pos = dst_st->sgl; obj->ttm.get_io_page.sg_idx = 0; } + i915_ttm_adjust_gem_after_move(obj); return 0; } static int i915_ttm_io_mem_reserve(struct ttm_device *bdev, struct ttm_resource *mem) { - if (mem->mem_type < I915_PL_LMEM0) + if (!cpu_maps_iomem(mem)) return 0; mem->bus.caching = ttm_write_combined; @@ -590,6 +648,16 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) return i915_ttm_err_to_gem(ret); } + i915_ttm_adjust_lru(obj); + if (bo->ttm && !ttm_tt_is_populated(bo->ttm)) { + ret = ttm_tt_populate(bo->bdev, bo->ttm, &ctx); + if (ret) + return ret; + + i915_ttm_adjust_domains_after_move(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)) @@ -597,8 +665,6 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) __i915_gem_object_set_pages(obj, st, i915_sg_dma_sizes(st->sgl)); - i915_ttm_adjust_lru(obj); - return ret; } @@ -768,6 +834,10 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, { static struct lock_class_key lock_class; struct drm_i915_private *i915 = mem->i915; + struct ttm_operation_ctx ctx = { + .interruptible = true, + .no_wait_gpu = false, + }; enum ttm_bo_type bo_type; int ret; @@ -775,14 +845,13 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, i915_gem_object_init(obj, &i915_gem_ttm_obj_ops, &lock_class, flags); i915_gem_object_init_memory_region(obj, mem); i915_gem_object_make_unshrinkable(obj); - obj->read_domains = I915_GEM_DOMAIN_WC | I915_GEM_DOMAIN_GTT; - obj->mem_flags |= I915_BO_FLAG_IOMEM; - i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); INIT_RADIX_TREE(&obj->ttm.get_io_page.radix, GFP_KERNEL | __GFP_NOWARN); mutex_init(&obj->ttm.get_io_page.lock); bo_type = (obj->flags & I915_BO_ALLOC_USER) ? ttm_bo_type_device : ttm_bo_type_kernel; + obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); + /* * If this function fails, it will call the destructor, but * our caller still owns the object. So no freeing in the @@ -790,14 +859,17 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, * Similarly, in delayed_destroy, we can't call ttm_bo_put() * until successful initialization. */ - obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); - ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, - bo_type, &i915_sys_placement, - mem->min_page_size >> PAGE_SHIFT, - true, NULL, NULL, i915_ttm_bo_destroy); - if (!ret) - obj->ttm.created = true; - - /* i915 wants -ENXIO when out of memory region space. */ - return i915_ttm_err_to_gem(ret); + ret = ttm_bo_init_reserved(&i915->bdev, i915_gem_to_ttm(obj), size, + bo_type, &i915_sys_placement, + mem->min_page_size >> PAGE_SHIFT, + &ctx, NULL, NULL, i915_ttm_bo_destroy); + if (ret) + return i915_ttm_err_to_gem(ret); + + obj->ttm.created = true; + i915_ttm_adjust_domains_after_move(obj); + i915_ttm_adjust_gem_after_move(obj); + i915_gem_object_unlock(obj); + + 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.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 88592C49EA6 for ; Thu, 24 Jun 2021 08:43:17 +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 0C080613D8 for ; Thu, 24 Jun 2021 08:43:17 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0C080613D8 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 CD2C56EB25; Thu, 24 Jun 2021 08:43:11 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 371066EB2B; Thu, 24 Jun 2021 08:43:10 +0000 (UTC) IronPort-SDR: wl4Rr8UUeuZyvQUQHudvb6Gn2Q4F2N+Z9ByhC0lAn0WYulx5CpQ8VeGAZg+r5ee2e6NFNaX3fm pj3lA+x2rl9g== X-IronPort-AV: E=McAfee;i="6200,9189,10024"; a="205601340" X-IronPort-AV: E=Sophos;i="5.83,296,1616482800"; d="scan'208";a="205601340" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 Jun 2021 01:43:09 -0700 IronPort-SDR: ZACg4uFEnF6eKV727w3DFpesBPdmh91RnnwB/gppwShkyOhDxJohpLhXGhFgHimXOAL/+TDYV+ IfSu27njsHMA== X-IronPort-AV: E=Sophos;i="5.83,296,1616482800"; d="scan'208";a="453344922" Received: from cmutgix-mobl.gar.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.20]) by orsmga008-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 Jun 2021 01:43:07 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Thu, 24 Jun 2021 10:42:39 +0200 Message-Id: <20210624084240.270219-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210624084240.270219-1-thomas.hellstrom@linux.intel.com> References: <20210624084240.270219-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v10 2/3] drm/i915/ttm: Adjust gem flags and caching settings after a move 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" QWZ0ZXIgYSBUVE0gbW92ZSBvciBvYmplY3QgaW5pdCB3ZSBuZWVkIHRvIHVwZGF0ZSB0aGUgaTkx NSBnZW0gZmxhZ3MgYW5kCmNhY2hpbmcgc2V0dGluZ3MgdG8gcmVmbGVjdCB0aGUgbmV3IHBsYWNl bWVudC4gQ3VycmVudGx5IGNhY2hpbmcgc2V0dGluZ3MKYXJlIG5vdCBjaGFuZ2VkIGR1cmluZyB0 aGUgbGlmZXRpbWUgb2YgYW4gb2JqZWN0LCBhbHRob3VnaCB0aGF0IG1pZ2h0CmNoYW5nZSBtb3Zp bmcgZm9yd2FyZCBpZiB3ZSBydW4gaW50byBwZXJmb3JtYW5jZSBpc3N1ZXMgb3IgaXNzdWVzIHdp dGgKV0Mgc3lzdGVtIHBhZ2UgYWxsb2NhdGlvbnMuCkFsc28gaW50cm9kdWNlIGdwdV9iaW5kc19p b21lbSgpIGFuZCBjcHVfbWFwc19pb21lbSgpIHRvIGNsZWFuIHVwIHRoZQp2YXJpb3VzIHdheXMg d2UgcHJldmlvdXNseSB1c2VkIHRvIGRldGVjdCB0aGlzLgpGaW5hbGx5LCBpbml0aWFsaXplIHRo ZSBUVE0gb2JqZWN0IHJlc2VydmVkIHRvIGJlIGFibGUgdG8gdXBkYXRlCmZsYWdzIGFuZCBjYWNo aW5nIGJlZm9yZSBhbnlvbmUgZWxzZSBnZXRzIGhvbGQgb2YgdGhlIG9iamVjdC4KClNpZ25lZC1v ZmYtYnk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNv bT4KUmV2aWV3ZWQtYnk6IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGludGVsLmNvbT4KLS0t CnY2OgotIFJlYmFzZSBvbiBhY2NlbGVyYXRlZCB0dG0gbW92ZXMuCnY4OgotIFJlaW5zdGF0ZSBh bGlnbm1lbnQgYXQgdHRtX2JvX2luaXRfcmVzZXJ2ZWQoKSB0aW1lLiAoUmVwb3J0ZWQgYnkKICBN YXR0aGV3IEF1bGQpLgotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0u YyB8IDE0NCArKysrKysrKysrKysrKysrKystLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxMDggaW5z ZXJ0aW9ucygrKSwgMzYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVf Z2VtX3R0bS5jCmluZGV4IGI1ZGQzYjcwMzdmNC4uYTFkYzU5MmMxMWJjIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCkBAIC05MSw2ICs5MSwyNiBAQCBzdGF0aWMgaW50 IGk5MTVfdHRtX2Vycl90b19nZW0oaW50IGVycikKIAlyZXR1cm4gZXJyOwogfQogCitzdGF0aWMg Ym9vbCBncHVfYmluZHNfaW9tZW0oc3RydWN0IHR0bV9yZXNvdXJjZSAqbWVtKQoreworCXJldHVy biBtZW0tPm1lbV90eXBlICE9IFRUTV9QTF9TWVNURU07Cit9CisKK3N0YXRpYyBib29sIGNwdV9t YXBzX2lvbWVtKHN0cnVjdCB0dG1fcmVzb3VyY2UgKm1lbSkKK3sKKwkvKiBPbmNlIC8gaWYgd2Ug c3VwcG9ydCBHR1RULCB0aGlzIGlzIGFsc28gZmFsc2UgZm9yIGNhY2hlZCB0dG1fdHRzICovCisJ cmV0dXJuIG1lbS0+bWVtX3R5cGUgIT0gVFRNX1BMX1NZU1RFTTsKK30KKworc3RhdGljIGVudW0g aTkxNV9jYWNoZV9sZXZlbAoraTkxNV90dG1fY2FjaGVfbGV2ZWwoc3RydWN0IGRybV9pOTE1X3By aXZhdGUgKmk5MTUsIHN0cnVjdCB0dG1fcmVzb3VyY2UgKnJlcywKKwkJICAgICBzdHJ1Y3QgdHRt X3R0ICp0dG0pCit7CisJcmV0dXJuICgoSEFTX0xMQyhpOTE1KSB8fCBIQVNfU05PT1AoaTkxNSkp ICYmICFncHVfYmluZHNfaW9tZW0ocmVzKSAmJgorCQl0dG0tPmNhY2hpbmcgPT0gdHRtX2NhY2hl ZCkgPyBJOTE1X0NBQ0hFX0xMQyA6CisJCUk5MTVfQ0FDSEVfTk9ORTsKK30KKwogc3RhdGljIHZv aWQgaTkxNV90dG1fYWRqdXN0X2xydShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsK IAogc3RhdGljIGVudW0gdHRtX2NhY2hpbmcKQEAgLTI0OCw2ICsyNjgsMzUgQEAgc3RhdGljIHZv aWQgaTkxNV90dG1fZnJlZV9jYWNoZWRfaW9fc3Qoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaikKIAlvYmotPnR0bS5jYWNoZWRfaW9fc3QgPSBOVUxMOwogfQogCitzdGF0aWMgdm9pZAor aTkxNV90dG1fYWRqdXN0X2RvbWFpbnNfYWZ0ZXJfbW92ZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdCAqb2JqKQoreworCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90 b190dG0ob2JqKTsKKworCWlmIChjcHVfbWFwc19pb21lbShiby0+cmVzb3VyY2UpIHx8IGJvLT50 dG0tPmNhY2hpbmcgIT0gdHRtX2NhY2hlZCkgeworCQlvYmotPndyaXRlX2RvbWFpbiA9IEk5MTVf R0VNX0RPTUFJTl9XQzsKKwkJb2JqLT5yZWFkX2RvbWFpbnMgPSBJOTE1X0dFTV9ET01BSU5fV0M7 CisJfSBlbHNlIHsKKwkJb2JqLT53cml0ZV9kb21haW4gPSBJOTE1X0dFTV9ET01BSU5fQ1BVOwor CQlvYmotPnJlYWRfZG9tYWlucyA9IEk5MTVfR0VNX0RPTUFJTl9DUFU7CisJfQorfQorCitzdGF0 aWMgdm9pZCBpOTE1X3R0bV9hZGp1c3RfZ2VtX2FmdGVyX21vdmUoc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaikKK3sKKwlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvID0gaTkxNV9n ZW1fdG9fdHRtKG9iaik7CisJdW5zaWduZWQgaW50IGNhY2hlX2xldmVsOworCisJb2JqLT5tZW1f ZmxhZ3MgJj0gfihJOTE1X0JPX0ZMQUdfU1RSVUNUX1BBR0UgfCBJOTE1X0JPX0ZMQUdfSU9NRU0p OworCisJb2JqLT5tZW1fZmxhZ3MgfD0gY3B1X21hcHNfaW9tZW0oYm8tPnJlc291cmNlKSA/IEk5 MTVfQk9fRkxBR19JT01FTSA6CisJCUk5MTVfQk9fRkxBR19TVFJVQ1RfUEFHRTsKKworCWNhY2hl X2xldmVsID0gaTkxNV90dG1fY2FjaGVfbGV2ZWwodG9faTkxNShiby0+YmFzZS5kZXYpLCBiby0+ cmVzb3VyY2UsCisJCQkJCSAgIGJvLT50dG0pOworCWk5MTVfZ2VtX29iamVjdF9zZXRfY2FjaGVf Y29oZXJlbmN5KG9iaiwgY2FjaGVfbGV2ZWwpOworfQorCiBzdGF0aWMgdm9pZCBpOTE1X3R0bV9w dXJnZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogewogCXN0cnVjdCB0dG1fYnVm ZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190dG0ob2JqKTsKQEAgLTI2Myw4ICszMTIsMTAg QEAgc3RhdGljIHZvaWQgaTkxNV90dG1fcHVyZ2Uoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaikKIAogCS8qIFRUTSdzIHB1cmdlIGludGVyZmFjZS4gTm90ZSB0aGF0IHdlIG1pZ2h0IGJl IHJlZW50ZXJpbmcuICovCiAJcmV0ID0gdHRtX2JvX3ZhbGlkYXRlKGJvLCAmcGxhY2UsICZjdHgp OwotCiAJaWYgKCFyZXQpIHsKKwkJb2JqLT53cml0ZV9kb21haW4gPSAwOworCQlvYmotPnJlYWRf ZG9tYWlucyA9IDA7CisJCWk5MTVfdHRtX2FkanVzdF9nZW1fYWZ0ZXJfbW92ZShvYmopOwogCQlp OTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChvYmopOwogCQlvYmotPm1tLm1hZHYgPSBfX0k5MTVf TUFEVl9QVVJHRUQ7CiAJfQpAQCAtMzQ3LDEyICszOTgsMTUgQEAgaTkxNV90dG1fcmVzb3VyY2Vf Z2V0X3N0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCiAJCQkgc3RydWN0IHR0bV9y ZXNvdXJjZSAqcmVzKQogewogCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dl bV90b190dG0ob2JqKTsKLQlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9Ci0JCXR0 bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIHJlcy0+bWVtX3R5cGUpOwogCi0JaWYgKG1hbi0+dXNl X3R0KQorCWlmICghZ3B1X2JpbmRzX2lvbWVtKHJlcykpCiAJCXJldHVybiBpOTE1X3R0bV90dF9n ZXRfc3QoYm8tPnR0bSk7CiAKKwkvKgorCSAqIElmIENQVSBtYXBwaW5nIGRpZmZlcnMsIHdlIG5l ZWQgdG8gYWRkIHRoZSB0dG1fdHQgcGFnZXMgdG8KKwkgKiB0aGUgcmVzdWx0aW5nIHN0LiBNaWdo dCBtYWtlIHNlbnNlIGZvciBHR1RULgorCSAqLworCUdFTV9XQVJOX09OKCFjcHVfbWFwc19pb21l bShyZXMpKTsKIAlyZXR1cm4gaW50ZWxfcmVnaW9uX3R0bV9yZXNvdXJjZV90b19zdChvYmotPm1t LnJlZ2lvbiwgcmVzKTsKIH0KIApAQCAtMzY3LDIzICs0MjEsMjUgQEAgc3RhdGljIGludCBpOTE1 X3R0bV9hY2NlbF9tb3ZlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCiAJc3RydWN0IGRy bV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CiAJc3RydWN0IHNn X3RhYmxlICpzcmNfc3Q7CiAJc3RydWN0IGk5MTVfcmVxdWVzdCAqcnE7CisJc3RydWN0IHR0bV90 dCAqdHRtID0gYm8tPnR0bTsKKwllbnVtIGk5MTVfY2FjaGVfbGV2ZWwgc3JjX2xldmVsLCBkc3Rf bGV2ZWw7CiAJaW50IHJldDsKIAogCWlmICghaTkxNS0+Z3QubWlncmF0ZS5jb250ZXh0KQogCQly ZXR1cm4gLUVJTlZBTDsKIAotCWlmICghYm8tPnR0bSB8fCAhdHRtX3R0X2lzX3BvcHVsYXRlZChi by0+dHRtKSkgeworCWRzdF9sZXZlbCA9IGk5MTVfdHRtX2NhY2hlX2xldmVsKGk5MTUsIGRzdF9t ZW0sIHR0bSk7CisJaWYgKCF0dG0gfHwgIXR0bV90dF9pc19wb3B1bGF0ZWQodHRtKSkgewogCQlp ZiAoYm8tPnR5cGUgPT0gdHRtX2JvX3R5cGVfa2VybmVsKQogCQkJcmV0dXJuIC1FSU5WQUw7CiAK LQkJaWYgKGJvLT50dG0gJiYKLQkJICAgICEoYm8tPnR0bS0+cGFnZV9mbGFncyAmIFRUTV9QQUdF X0ZMQUdfWkVST19BTExPQykpCisJCWlmICh0dG0gJiYgISh0dG0tPnBhZ2VfZmxhZ3MgJiBUVE1f UEFHRV9GTEFHX1pFUk9fQUxMT0MpKQogCQkJcmV0dXJuIDA7CiAKIAkJaW50ZWxfZW5naW5lX3Bt X2dldChpOTE1LT5ndC5taWdyYXRlLmNvbnRleHQtPmVuZ2luZSk7CiAJCXJldCA9IGludGVsX2Nv bnRleHRfbWlncmF0ZV9jbGVhcihpOTE1LT5ndC5taWdyYXRlLmNvbnRleHQsIE5VTEwsCi0JCQkJ CQkgIGRzdF9zdC0+c2dsLCBJOTE1X0NBQ0hFX05PTkUsCi0JCQkJCQkgIGRzdF9tZW0tPm1lbV90 eXBlID49IEk5MTVfUExfTE1FTTAsCisJCQkJCQkgIGRzdF9zdC0+c2dsLCBkc3RfbGV2ZWwsCisJ CQkJCQkgIGdwdV9iaW5kc19pb21lbShkc3RfbWVtKSwKIAkJCQkJCSAgMCwgJnJxKTsKIAogCQlp ZiAoIXJldCAmJiBycSkgewpAQCAtMzkyLDE1ICs0NDgsMTYgQEAgc3RhdGljIGludCBpOTE1X3R0 bV9hY2NlbF9tb3ZlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCiAJCX0KIAkJaW50ZWxf ZW5naW5lX3BtX3B1dChpOTE1LT5ndC5taWdyYXRlLmNvbnRleHQtPmVuZ2luZSk7CiAJfSBlbHNl IHsKLQkJc3JjX3N0ID0gc3JjX21hbi0+dXNlX3R0ID8gaTkxNV90dG1fdHRfZ2V0X3N0KGJvLT50 dG0pIDoKLQkJCQkJCW9iai0+dHRtLmNhY2hlZF9pb19zdDsKKwkJc3JjX3N0ID0gc3JjX21hbi0+ dXNlX3R0ID8gaTkxNV90dG1fdHRfZ2V0X3N0KHR0bSkgOgorCQkJb2JqLT50dG0uY2FjaGVkX2lv X3N0OwogCisJCXNyY19sZXZlbCA9IGk5MTVfdHRtX2NhY2hlX2xldmVsKGk5MTUsIGJvLT5yZXNv dXJjZSwgdHRtKTsKIAkJaW50ZWxfZW5naW5lX3BtX2dldChpOTE1LT5ndC5taWdyYXRlLmNvbnRl eHQtPmVuZ2luZSk7CiAJCXJldCA9IGludGVsX2NvbnRleHRfbWlncmF0ZV9jb3B5KGk5MTUtPmd0 Lm1pZ3JhdGUuY29udGV4dCwKLQkJCQkJCSBOVUxMLCBzcmNfc3QtPnNnbCwgSTkxNV9DQUNIRV9O T05FLAotCQkJCQkJIGJvLT5yZXNvdXJjZS0+bWVtX3R5cGUgPj0gSTkxNV9QTF9MTUVNMCwKLQkJ CQkJCSBkc3Rfc3QtPnNnbCwgSTkxNV9DQUNIRV9OT05FLAotCQkJCQkJIGRzdF9tZW0tPm1lbV90 eXBlID49IEk5MTVfUExfTE1FTTAsCisJCQkJCQkgTlVMTCwgc3JjX3N0LT5zZ2wsIHNyY19sZXZl bCwKKwkJCQkJCSBncHVfYmluZHNfaW9tZW0oYm8tPnJlc291cmNlKSwKKwkJCQkJCSBkc3Rfc3Qt PnNnbCwgZHN0X2xldmVsLAorCQkJCQkJIGdwdV9iaW5kc19pb21lbShkc3RfbWVtKSwKIAkJCQkJ CSAmcnEpOwogCQlpZiAoIXJldCAmJiBycSkgewogCQkJaTkxNV9yZXF1ZXN0X3dhaXQocnEsIDAs IE1BWF9TQ0hFRFVMRV9USU1FT1VUKTsKQEAgLTQyMCw4ICs0NzcsNiBAQCBzdGF0aWMgaW50IGk5 MTVfdHRtX21vdmUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywgYm9vbCBldmljdCwKIAlz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKIAlz dHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKmRzdF9tYW4gPQogCQl0dG1fbWFuYWdlcl90eXBl KGJvLT5iZGV2LCBkc3RfbWVtLT5tZW1fdHlwZSk7Ci0Jc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5h Z2VyICpzcmNfbWFuID0KLQkJdHRtX21hbmFnZXJfdHlwZShiby0+YmRldiwgYm8tPnJlc291cmNl LT5tZW1fdHlwZSk7CiAJc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKmRzdF9yZWcsICpzcmNf cmVnOwogCXVuaW9uIHsKIAkJc3RydWN0IHR0bV9rbWFwX2l0ZXJfdHQgdHQ7CkBAIC00NjUsMTIg KzUyMCwxMiBAQCBzdGF0aWMgaW50IGk5MTVfdHRtX21vdmUoc3RydWN0IHR0bV9idWZmZXJfb2Jq ZWN0ICpibywgYm9vbCBldmljdCwKIAlyZXQgPSBpOTE1X3R0bV9hY2NlbF9tb3ZlKGJvLCBkc3Rf bWVtLCBkc3Rfc3QpOwogCWlmIChyZXQpIHsKIAkJLyogSWYgd2Ugc3RhcnQgbWFwcGluZyBHR1RU LCB3ZSBjYW4gbm8gbG9uZ2VyIHVzZSBtYW46OnVzZV90dCBoZXJlLiAqLwotCQlkc3RfaXRlciA9 IGRzdF9tYW4tPnVzZV90dCA/CisJCWRzdF9pdGVyID0gIWNwdV9tYXBzX2lvbWVtKGRzdF9tZW0p ID8KIAkJCXR0bV9rbWFwX2l0ZXJfdHRfaW5pdCgmX2RzdF9pdGVyLnR0LCBiby0+dHRtKSA6CiAJ CQl0dG1fa21hcF9pdGVyX2lvbWFwX2luaXQoJl9kc3RfaXRlci5pbywgJmRzdF9yZWctPmlvbWFw LAogCQkJCQkJIGRzdF9zdCwgZHN0X3JlZy0+cmVnaW9uLnN0YXJ0KTsKIAotCQlzcmNfaXRlciA9 IHNyY19tYW4tPnVzZV90dCA/CisJCXNyY19pdGVyID0gIWNwdV9tYXBzX2lvbWVtKGJvLT5yZXNv dXJjZSkgPwogCQkJdHRtX2ttYXBfaXRlcl90dF9pbml0KCZfc3JjX2l0ZXIudHQsIGJvLT50dG0p IDoKIAkJCXR0bV9rbWFwX2l0ZXJfaW9tYXBfaW5pdCgmX3NyY19pdGVyLmlvLCAmc3JjX3JlZy0+ aW9tYXAsCiAJCQkJCQkgb2JqLT50dG0uY2FjaGVkX2lvX3N0LApAQCAtNDc4LDIxICs1MzMsMjQg QEAgc3RhdGljIGludCBpOTE1X3R0bV9tb3ZlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8s IGJvb2wgZXZpY3QsCiAKIAkJdHRtX21vdmVfbWVtY3B5KGJvLCBkc3RfbWVtLT5udW1fcGFnZXMs IGRzdF9pdGVyLCBzcmNfaXRlcik7CiAJfQorCS8qIEJlbG93IGRzdF9tZW0gYmVjb21lcyBiby0+ cmVzb3VyY2UuICovCiAJdHRtX2JvX21vdmVfc3luY19jbGVhbnVwKGJvLCBkc3RfbWVtKTsKKwlp OTE1X3R0bV9hZGp1c3RfZG9tYWluc19hZnRlcl9tb3ZlKG9iaik7CiAJaTkxNV90dG1fZnJlZV9j YWNoZWRfaW9fc3Qob2JqKTsKIAotCWlmICghZHN0X21hbi0+dXNlX3R0KSB7CisJaWYgKGdwdV9i aW5kc19pb21lbShkc3RfbWVtKSB8fCBjcHVfbWFwc19pb21lbShkc3RfbWVtKSkgewogCQlvYmot PnR0bS5jYWNoZWRfaW9fc3QgPSBkc3Rfc3Q7CiAJCW9iai0+dHRtLmdldF9pb19wYWdlLnNnX3Bv cyA9IGRzdF9zdC0+c2dsOwogCQlvYmotPnR0bS5nZXRfaW9fcGFnZS5zZ19pZHggPSAwOwogCX0K IAorCWk5MTVfdHRtX2FkanVzdF9nZW1fYWZ0ZXJfbW92ZShvYmopOwogCXJldHVybiAwOwogfQog CiBzdGF0aWMgaW50IGk5MTVfdHRtX2lvX21lbV9yZXNlcnZlKHN0cnVjdCB0dG1fZGV2aWNlICpi ZGV2LCBzdHJ1Y3QgdHRtX3Jlc291cmNlICptZW0pCiB7Ci0JaWYgKG1lbS0+bWVtX3R5cGUgPCBJ OTE1X1BMX0xNRU0wKQorCWlmICghY3B1X21hcHNfaW9tZW0obWVtKSkKIAkJcmV0dXJuIDA7CiAK IAltZW0tPmJ1cy5jYWNoaW5nID0gdHRtX3dyaXRlX2NvbWJpbmVkOwpAQCAtNTkwLDYgKzY0OCwx NiBAQCBzdGF0aWMgaW50IGk5MTVfdHRtX2dldF9wYWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdCAqb2JqKQogCQkJcmV0dXJuIGk5MTVfdHRtX2Vycl90b19nZW0ocmV0KTsKIAl9CiAKKwlp OTE1X3R0bV9hZGp1c3RfbHJ1KG9iaik7CisJaWYgKGJvLT50dG0gJiYgIXR0bV90dF9pc19wb3B1 bGF0ZWQoYm8tPnR0bSkpIHsKKwkJcmV0ID0gdHRtX3R0X3BvcHVsYXRlKGJvLT5iZGV2LCBiby0+ dHRtLCAmY3R4KTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisKKwkJaTkxNV90dG1fYWRq dXN0X2RvbWFpbnNfYWZ0ZXJfbW92ZShvYmopOworCQlpOTE1X3R0bV9hZGp1c3RfZ2VtX2FmdGVy X21vdmUob2JqKTsKKwl9CisKIAkvKiBPYmplY3QgZWl0aGVyIGhhcyBhIHBhZ2UgdmVjdG9yIG9y IGlzIGFuIGlvbWVtIG9iamVjdCAqLwogCXN0ID0gYm8tPnR0bSA/IGk5MTVfdHRtX3R0X2dldF9z dChiby0+dHRtKSA6IG9iai0+dHRtLmNhY2hlZF9pb19zdDsKIAlpZiAoSVNfRVJSKHN0KSkKQEAg LTU5Nyw4ICs2NjUsNiBAQCBzdGF0aWMgaW50IGk5MTVfdHRtX2dldF9wYWdlcyhzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqb2JqKQogCiAJX19pOTE1X2dlbV9vYmplY3Rfc2V0X3BhZ2VzKG9i aiwgc3QsIGk5MTVfc2dfZG1hX3NpemVzKHN0LT5zZ2wpKTsKIAotCWk5MTVfdHRtX2FkanVzdF9s cnUob2JqKTsKLQogCXJldHVybiByZXQ7CiB9CiAKQEAgLTc2OCw2ICs4MzQsMTAgQEAgaW50IF9f aTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0s CiB7CiAJc3RhdGljIHN0cnVjdCBsb2NrX2NsYXNzX2tleSBsb2NrX2NsYXNzOwogCXN0cnVjdCBk cm1faTkxNV9wcml2YXRlICppOTE1ID0gbWVtLT5pOTE1OworCXN0cnVjdCB0dG1fb3BlcmF0aW9u X2N0eCBjdHggPSB7CisJCS5pbnRlcnJ1cHRpYmxlID0gdHJ1ZSwKKwkJLm5vX3dhaXRfZ3B1ID0g ZmFsc2UsCisJfTsKIAllbnVtIHR0bV9ib190eXBlIGJvX3R5cGU7CiAJaW50IHJldDsKIApAQCAt Nzc1LDE0ICs4NDUsMTMgQEAgaW50IF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVjdCBp bnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJaTkxNV9nZW1fb2JqZWN0X2luaXQob2JqLCAmaTkx NV9nZW1fdHRtX29ial9vcHMsICZsb2NrX2NsYXNzLCBmbGFncyk7CiAJaTkxNV9nZW1fb2JqZWN0 X2luaXRfbWVtb3J5X3JlZ2lvbihvYmosIG1lbSk7CiAJaTkxNV9nZW1fb2JqZWN0X21ha2VfdW5z aHJpbmthYmxlKG9iaik7Ci0Jb2JqLT5yZWFkX2RvbWFpbnMgPSBJOTE1X0dFTV9ET01BSU5fV0Mg fCBJOTE1X0dFTV9ET01BSU5fR1RUOwotCW9iai0+bWVtX2ZsYWdzIHw9IEk5MTVfQk9fRkxBR19J T01FTTsKLQlpOTE1X2dlbV9vYmplY3Rfc2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIEk5MTVfQ0FD SEVfTk9ORSk7CiAJSU5JVF9SQURJWF9UUkVFKCZvYmotPnR0bS5nZXRfaW9fcGFnZS5yYWRpeCwg R0ZQX0tFUk5FTCB8IF9fR0ZQX05PV0FSTik7CiAJbXV0ZXhfaW5pdCgmb2JqLT50dG0uZ2V0X2lv X3BhZ2UubG9jayk7CiAJYm9fdHlwZSA9IChvYmotPmZsYWdzICYgSTkxNV9CT19BTExPQ19VU0VS KSA/IHR0bV9ib190eXBlX2RldmljZSA6CiAJCXR0bV9ib190eXBlX2tlcm5lbDsKIAorCW9iai0+ YmFzZS52bWFfbm9kZS5kcml2ZXJfcHJpdmF0ZSA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCiAJ LyoKIAkgKiBJZiB0aGlzIGZ1bmN0aW9uIGZhaWxzLCBpdCB3aWxsIGNhbGwgdGhlIGRlc3RydWN0 b3IsIGJ1dAogCSAqIG91ciBjYWxsZXIgc3RpbGwgb3ducyB0aGUgb2JqZWN0LiBTbyBubyBmcmVl aW5nIGluIHRoZQpAQCAtNzkwLDE0ICs4NTksMTcgQEAgaW50IF9faTkxNV9nZW1fdHRtX29iamVj dF9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJICogU2ltaWxhcmx5LCBp biBkZWxheWVkX2Rlc3Ryb3ksIHdlIGNhbid0IGNhbGwgdHRtX2JvX3B1dCgpCiAJICogdW50aWwg c3VjY2Vzc2Z1bCBpbml0aWFsaXphdGlvbi4KIAkgKi8KLQlvYmotPmJhc2Uudm1hX25vZGUuZHJp dmVyX3ByaXZhdGUgPSBpOTE1X2dlbV90b190dG0ob2JqKTsKLQlyZXQgPSB0dG1fYm9faW5pdCgm aTkxNS0+YmRldiwgaTkxNV9nZW1fdG9fdHRtKG9iaiksIHNpemUsCi0JCQkgIGJvX3R5cGUsICZp OTE1X3N5c19wbGFjZW1lbnQsCi0JCQkgIG1lbS0+bWluX3BhZ2Vfc2l6ZSA+PiBQQUdFX1NISUZU LAotCQkJICB0cnVlLCBOVUxMLCBOVUxMLCBpOTE1X3R0bV9ib19kZXN0cm95KTsKLQlpZiAoIXJl dCkKLQkJb2JqLT50dG0uY3JlYXRlZCA9IHRydWU7Ci0KLQkvKiBpOTE1IHdhbnRzIC1FTlhJTyB3 aGVuIG91dCBvZiBtZW1vcnkgcmVnaW9uIHNwYWNlLiAqLwotCXJldHVybiBpOTE1X3R0bV9lcnJf dG9fZ2VtKHJldCk7CisJcmV0ID0gdHRtX2JvX2luaXRfcmVzZXJ2ZWQoJmk5MTUtPmJkZXYsIGk5 MTVfZ2VtX3RvX3R0bShvYmopLCBzaXplLAorCQkJCSAgIGJvX3R5cGUsICZpOTE1X3N5c19wbGFj ZW1lbnQsCisJCQkJICAgbWVtLT5taW5fcGFnZV9zaXplID4+IFBBR0VfU0hJRlQsCisJCQkJICAg JmN0eCwgTlVMTCwgTlVMTCwgaTkxNV90dG1fYm9fZGVzdHJveSk7CisJaWYgKHJldCkKKwkJcmV0 dXJuIGk5MTVfdHRtX2Vycl90b19nZW0ocmV0KTsKKworCW9iai0+dHRtLmNyZWF0ZWQgPSB0cnVl OworCWk5MTVfdHRtX2FkanVzdF9kb21haW5zX2FmdGVyX21vdmUob2JqKTsKKwlpOTE1X3R0bV9h ZGp1c3RfZ2VtX2FmdGVyX21vdmUob2JqKTsKKwlpOTE1X2dlbV9vYmplY3RfdW5sb2NrKG9iaik7 CisKKwlyZXR1cm4gMDsKIH0KLS0gCjIuMzEuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vaW50ZWwtZ2Z4Cg==