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,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 9EA2CC4708E for ; Fri, 28 May 2021 10:58:28 +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 632E2613B5 for ; Fri, 28 May 2021 10:58:28 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 632E2613B5 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 874416F596; Fri, 28 May 2021 10:58:17 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id E59106F595; Fri, 28 May 2021 10:58:15 +0000 (UTC) IronPort-SDR: +PJ0GPmXcJMDOYyw1ZcyfkKM1B2JnieBzRxCynG/uEA5UUFLN879qQmMaAIAUn4enIzOZQ45hr klQMdFKUgFWg== X-IronPort-AV: E=McAfee;i="6200,9189,9997"; a="266821848" X-IronPort-AV: E=Sophos;i="5.83,229,1616482800"; d="scan'208";a="266821848" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 May 2021 03:58:15 -0700 IronPort-SDR: tS/XY2RCUN8JLNd+3GdEiSpdSy1IWw3ctS16o2eCCIRDW9K/069Tqjj2hPwd4J1qKKEzLnaZI+ 5xqjHuxpwwEw== X-IronPort-AV: E=Sophos;i="5.83,229,1616482800"; d="scan'208";a="477885254" Received: from jdahlin-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.92]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 May 2021 03:58:14 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v6 11/15] drm/i915/ttm: Introduce a TTM i915 gem object backend Date: Fri, 28 May 2021 12:57:40 +0200 Message-Id: <20210528105744.58271-12-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210528105744.58271-1-thomas.hellstrom@linux.intel.com> References: <20210528105744.58271-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 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Most logical place to introduce TTM buffer objects is as an i915 gem object backend. We need to add some ops to account for added functionality like delayed delete and LRU list manipulation. Initially we support only LMEM and SYSTEM memory, but SYSTEM (which in this case means evicted LMEM objects) is not visible to i915 GEM yet. The plan is to move the i915 gem system region over to the TTM system memory type in upcoming patches. We set up GPU bindings directly both from LMEM and from the system region, as there is no need to use the legacy TTM_TT memory type. We reserve that for future porting of GGTT bindings to TTM. Remove the old lmem backend. Signed-off-by: Thomas Hellström Reviewed-by: Matthew Auld --- v2: - Break out needed TTM functionality to a separate patch (Reported by Christian König). - Fix an unhandled error (Reported by Matthew Auld and Maarten Lankhorst) - Remove a stray leftover sg_table allocation (Reported by Matthew Auld) - Use ttm_tt_unpopulate() rather than ttm_tt_destroy() in the purge path as some TTM functionality relies on having a ttm_tt present for !is_iomem. v3: - Use ttm_bo_type_device for userspace visible objects so that TTM can allocate an address space offset for mmap'ing. - Fix up the destruction path (Reported by Matthew Auld) - Use ttm_bo_validate() for purging (Reported by Christian König) - Create ttm_tts write-combined as they are currently for eviction only and we want to maintain consistent write-combined caching for bos that are not in system only. (Suggested by Daniel Vetter) - Make struct ttm_placements static. - Add the ttm device funcs/ops to i915_gem_ttm.h for the region code. - Rename new->dst and old->src. Check for swapin in the move callback. v4: - Adapt to small interface change in ttm_move_memcpy. - Use a function to pull out the ttm driver from the backend. v6: - Remove the ttm device verify_access assignment. The member is gone upstream. --- drivers/gpu/drm/i915/Makefile | 1 + drivers/gpu/drm/i915/gem/i915_gem_create.c | 9 +- drivers/gpu/drm/i915/gem/i915_gem_lmem.c | 84 --- drivers/gpu/drm/i915/gem/i915_gem_lmem.h | 5 - drivers/gpu/drm/i915/gem/i915_gem_object.c | 125 ++-- drivers/gpu/drm/i915/gem/i915_gem_object.h | 9 + .../gpu/drm/i915/gem/i915_gem_object_types.h | 27 +- drivers/gpu/drm/i915/gem/i915_gem_region.c | 6 +- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 540 ++++++++++++++++++ drivers/gpu/drm/i915/gem/i915_gem_ttm.h | 48 ++ drivers/gpu/drm/i915/gt/intel_region_lmem.c | 3 +- drivers/gpu/drm/i915/i915_gem.c | 5 +- drivers/gpu/drm/i915/intel_memory_region.c | 1 - drivers/gpu/drm/i915/intel_memory_region.h | 1 - drivers/gpu/drm/i915/intel_region_ttm.c | 8 +- drivers/gpu/drm/i915/intel_region_ttm.h | 11 +- 16 files changed, 730 insertions(+), 153 deletions(-) create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm.c create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm.h diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 4f22cac1c49b..f57dfc74d6ce 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -155,6 +155,7 @@ gem-y += \ gem/i915_gem_stolen.o \ gem/i915_gem_throttle.o \ gem/i915_gem_tiling.o \ + gem/i915_gem_ttm.o \ gem/i915_gem_userptr.o \ gem/i915_gem_wait.o \ gem/i915_gemfs.o diff --git a/drivers/gpu/drm/i915/gem/i915_gem_create.c b/drivers/gpu/drm/i915/gem/i915_gem_create.c index 548ddf39d853..93bf63bbaff1 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_create.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_create.c @@ -85,13 +85,10 @@ i915_gem_setup(struct drm_i915_gem_object *obj, u64 size) return -E2BIG; /* - * For now resort to CPU based clearing for device local-memory, in the - * near future this will use the blitter engine for accelerated, GPU - * based clearing. + * I915_BO_ALLOC_USER will make sure the object is cleared before + * any user access. */ - flags = 0; - if (mr->type == INTEL_MEMORY_LOCAL) - flags = I915_BO_ALLOC_CPU_CLEAR; + flags = I915_BO_ALLOC_USER; ret = mr->ops->init_object(mr, obj, size, flags); if (ret) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c index 3b4aa28a076d..2b8cd15de1d9 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c @@ -4,74 +4,10 @@ */ #include "intel_memory_region.h" -#include "intel_region_ttm.h" #include "gem/i915_gem_region.h" #include "gem/i915_gem_lmem.h" #include "i915_drv.h" -static void lmem_put_pages(struct drm_i915_gem_object *obj, - struct sg_table *pages) -{ - intel_region_ttm_node_free(obj->mm.region, obj->mm.st_mm_node); - obj->mm.dirty = false; - sg_free_table(pages); - kfree(pages); -} - -static int lmem_get_pages(struct drm_i915_gem_object *obj) -{ - unsigned int flags; - struct sg_table *pages; - - flags = I915_ALLOC_MIN_PAGE_SIZE; - if (obj->flags & I915_BO_ALLOC_CONTIGUOUS) - flags |= I915_ALLOC_CONTIGUOUS; - - obj->mm.st_mm_node = intel_region_ttm_node_alloc(obj->mm.region, - obj->base.size, - flags); - if (IS_ERR(obj->mm.st_mm_node)) - return PTR_ERR(obj->mm.st_mm_node); - - /* Range manager is always contigous */ - if (obj->mm.region->is_range_manager) - obj->flags |= I915_BO_ALLOC_CONTIGUOUS; - pages = intel_region_ttm_node_to_st(obj->mm.region, obj->mm.st_mm_node); - if (IS_ERR(pages)) { - intel_region_ttm_node_free(obj->mm.region, obj->mm.st_mm_node); - return PTR_ERR(pages); - } - - __i915_gem_object_set_pages(obj, pages, i915_sg_dma_sizes(pages->sgl)); - - if (obj->flags & I915_BO_ALLOC_CPU_CLEAR) { - void __iomem *vaddr = - i915_gem_object_lmem_io_map(obj, 0, obj->base.size); - - if (!vaddr) { - struct sg_table *pages = - __i915_gem_object_unset_pages(obj); - - if (!IS_ERR_OR_NULL(pages)) - lmem_put_pages(obj, pages); - } - - memset_io(vaddr, 0, obj->base.size); - io_mapping_unmap(vaddr); - } - - return 0; -} - -const struct drm_i915_gem_object_ops i915_gem_lmem_obj_ops = { - .name = "i915_gem_object_lmem", - .flags = I915_GEM_OBJECT_HAS_IOMEM, - - .get_pages = lmem_get_pages, - .put_pages = lmem_put_pages, - .release = i915_gem_object_release_memory_region, -}; - void __iomem * i915_gem_object_lmem_io_map(struct drm_i915_gem_object *obj, unsigned long n, @@ -103,23 +39,3 @@ i915_gem_object_create_lmem(struct drm_i915_private *i915, return i915_gem_object_create_region(i915->mm.regions[INTEL_REGION_LMEM], size, flags); } - -int __i915_gem_lmem_object_init(struct intel_memory_region *mem, - struct drm_i915_gem_object *obj, - resource_size_t size, - unsigned int flags) -{ - static struct lock_class_key lock_class; - struct drm_i915_private *i915 = mem->i915; - - drm_gem_private_object_init(&i915->drm, &obj->base, size); - i915_gem_object_init(obj, &i915_gem_lmem_obj_ops, &lock_class, flags); - - obj->read_domains = I915_GEM_DOMAIN_WC | I915_GEM_DOMAIN_GTT; - - i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); - - i915_gem_object_init_memory_region(obj, mem); - - return 0; -} diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.h b/drivers/gpu/drm/i915/gem/i915_gem_lmem.h index fac6bc5a5ebb..ea76fd11ccb0 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.h @@ -26,9 +26,4 @@ i915_gem_object_create_lmem(struct drm_i915_private *i915, resource_size_t size, unsigned int flags); -int __i915_gem_lmem_object_init(struct intel_memory_region *mem, - struct drm_i915_gem_object *obj, - resource_size_t size, - unsigned int flags); - #endif /* !__I915_GEM_LMEM_H */ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.c b/drivers/gpu/drm/i915/gem/i915_gem_object.c index 5706d471692d..16eac5ea9238 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -172,7 +172,7 @@ static void i915_gem_close_object(struct drm_gem_object *gem, struct drm_file *f } } -static void __i915_gem_free_object_rcu(struct rcu_head *head) +void __i915_gem_free_object_rcu(struct rcu_head *head) { struct drm_i915_gem_object *obj = container_of(head, typeof(*obj), rcu); @@ -208,59 +208,69 @@ static void __i915_gem_object_free_mmaps(struct drm_i915_gem_object *obj) } } -static void __i915_gem_free_objects(struct drm_i915_private *i915, - struct llist_node *freed) +void __i915_gem_free_object(struct drm_i915_gem_object *obj) { - struct drm_i915_gem_object *obj, *on; + trace_i915_gem_object_destroy(obj); - llist_for_each_entry_safe(obj, on, freed, freed) { - trace_i915_gem_object_destroy(obj); + if (!list_empty(&obj->vma.list)) { + struct i915_vma *vma; + + /* + * Note that the vma keeps an object reference while + * it is active, so it *should* not sleep while we + * destroy it. Our debug code errs insits it *might*. + * For the moment, play along. + */ + spin_lock(&obj->vma.lock); + while ((vma = list_first_entry_or_null(&obj->vma.list, + struct i915_vma, + obj_link))) { + GEM_BUG_ON(vma->obj != obj); + spin_unlock(&obj->vma.lock); - if (!list_empty(&obj->vma.list)) { - struct i915_vma *vma; + __i915_vma_put(vma); - /* - * Note that the vma keeps an object reference while - * it is active, so it *should* not sleep while we - * destroy it. Our debug code errs insits it *might*. - * For the moment, play along. - */ spin_lock(&obj->vma.lock); - while ((vma = list_first_entry_or_null(&obj->vma.list, - struct i915_vma, - obj_link))) { - GEM_BUG_ON(vma->obj != obj); - spin_unlock(&obj->vma.lock); + } + spin_unlock(&obj->vma.lock); + } - __i915_vma_put(vma); + __i915_gem_object_free_mmaps(obj); - spin_lock(&obj->vma.lock); - } - spin_unlock(&obj->vma.lock); - } + GEM_BUG_ON(!list_empty(&obj->lut_list)); - __i915_gem_object_free_mmaps(obj); + atomic_set(&obj->mm.pages_pin_count, 0); + __i915_gem_object_put_pages(obj); + GEM_BUG_ON(i915_gem_object_has_pages(obj)); + bitmap_free(obj->bit_17); - GEM_BUG_ON(!list_empty(&obj->lut_list)); + if (obj->base.import_attach) + drm_prime_gem_destroy(&obj->base, NULL); - atomic_set(&obj->mm.pages_pin_count, 0); - __i915_gem_object_put_pages(obj); - GEM_BUG_ON(i915_gem_object_has_pages(obj)); - bitmap_free(obj->bit_17); + drm_gem_free_mmap_offset(&obj->base); - if (obj->base.import_attach) - drm_prime_gem_destroy(&obj->base, NULL); + if (obj->ops->release) + obj->ops->release(obj); - drm_gem_free_mmap_offset(&obj->base); + if (obj->mm.n_placements > 1) + kfree(obj->mm.placements); - if (obj->ops->release) - obj->ops->release(obj); + if (obj->shares_resv_from) + i915_vm_resv_put(obj->shares_resv_from); +} - if (obj->mm.n_placements > 1) - kfree(obj->mm.placements); +static void __i915_gem_free_objects(struct drm_i915_private *i915, + struct llist_node *freed) +{ + struct drm_i915_gem_object *obj, *on; - if (obj->shares_resv_from) - i915_vm_resv_put(obj->shares_resv_from); + llist_for_each_entry_safe(obj, on, freed, freed) { + might_sleep(); + if (obj->ops->delayed_free) { + obj->ops->delayed_free(obj); + continue; + } + __i915_gem_free_object(obj); /* But keep the pointer alive for RCU-protected lookups */ call_rcu(&obj->rcu, __i915_gem_free_object_rcu); @@ -318,6 +328,7 @@ static void i915_gem_free_object(struct drm_gem_object *gem_obj) * worker and performing frees directly from subsequent allocations for * crude but effective memory throttling. */ + if (llist_add(&obj->freed, &i915->mm.free_list)) queue_work(i915->wq, &i915->mm.free_work); } @@ -410,6 +421,42 @@ int i915_gem_object_read_from_page(struct drm_i915_gem_object *obj, u64 offset, return 0; } +/** + * i915_gem_object_evictable - Whether object is likely evictable after unbind. + * @obj: The object to check + * + * This function checks whether the object is likely unvictable after unbind. + * If the object is not locked when checking, the result is only advisory. + * If the object is locked when checking, and the function returns true, + * then an eviction should indeed be possible. But since unlocked vma + * unpinning and unbinding is currently possible, the object can actually + * become evictable even if this function returns false. + * + * Return: true if the object may be evictable. False otherwise. + */ +bool i915_gem_object_evictable(struct drm_i915_gem_object *obj) +{ + struct i915_vma *vma; + int pin_count = atomic_read(&obj->mm.pages_pin_count); + + if (!pin_count) + return true; + + spin_lock(&obj->vma.lock); + list_for_each_entry(vma, &obj->vma.list, obj_link) { + if (i915_vma_is_pinned(vma)) { + spin_unlock(&obj->vma.lock); + return false; + } + if (atomic_read(&vma->pages_count)) + pin_count--; + } + spin_unlock(&obj->vma.lock); + GEM_WARN_ON(pin_count < 0); + + return pin_count == 0; +} + 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 2ebd79537aea..ae5930e307d5 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.h @@ -200,6 +200,9 @@ static inline bool i915_gem_object_trylock(struct drm_i915_gem_object *obj) static inline void i915_gem_object_unlock(struct drm_i915_gem_object *obj) { + if (obj->ops->adjust_lru) + obj->ops->adjust_lru(obj); + dma_resv_unlock(obj->base.resv); } @@ -587,6 +590,12 @@ int i915_gem_object_read_from_page(struct drm_i915_gem_object *obj, u64 offset, bool i915_gem_object_is_shmem(const struct drm_i915_gem_object *obj); +void __i915_gem_free_object_rcu(struct rcu_head *head); + +void __i915_gem_free_object(struct drm_i915_gem_object *obj); + +bool i915_gem_object_evictable(struct drm_i915_gem_object *obj); + #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 d047ea126029..68313474e6a6 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h @@ -63,6 +63,20 @@ struct drm_i915_gem_object_ops { const struct drm_i915_gem_pwrite *arg); int (*dmabuf_export)(struct drm_i915_gem_object *obj); + + /** + * adjust_lru - notify that the madvise value was updated + * @obj: The gem object + * + * The madvise value may have been updated, or object was recently + * referenced so act accordingly (Perhaps changing an LRU list etc). + */ + void (*adjust_lru)(struct drm_i915_gem_object *obj); + + /** + * delayed_free - Override the default delayed free implementation + */ + void (*delayed_free)(struct drm_i915_gem_object *obj); void (*release)(struct drm_i915_gem_object *obj); const char *name; /* friendly name for debug, e.g. lockdep classes */ @@ -187,12 +201,14 @@ struct drm_i915_gem_object { #define I915_BO_ALLOC_VOLATILE BIT(1) #define I915_BO_ALLOC_STRUCT_PAGE BIT(2) #define I915_BO_ALLOC_CPU_CLEAR BIT(3) +#define I915_BO_ALLOC_USER BIT(4) #define I915_BO_ALLOC_FLAGS (I915_BO_ALLOC_CONTIGUOUS | \ I915_BO_ALLOC_VOLATILE | \ I915_BO_ALLOC_STRUCT_PAGE | \ - I915_BO_ALLOC_CPU_CLEAR) -#define I915_BO_READONLY BIT(4) -#define I915_TILING_QUIRK_BIT 5 /* unknown swizzling; do not release! */ + I915_BO_ALLOC_CPU_CLEAR | \ + I915_BO_ALLOC_USER) +#define I915_BO_READONLY BIT(5) +#define I915_TILING_QUIRK_BIT 6 /* unknown swizzling; do not release! */ /* * Is the object to be mapped as read-only to the GPU @@ -310,6 +326,11 @@ struct drm_i915_gem_object { bool dirty:1; } mm; + struct { + struct sg_table *cached_io_st; + bool created:1; + } ttm; + /** Record of address bit 17 of each page at last unbind. */ unsigned long *bit_17; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_region.c b/drivers/gpu/drm/i915/gem/i915_gem_region.c index f25e6646c5b7..d1f1840540dd 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_region.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_region.c @@ -18,11 +18,7 @@ void i915_gem_object_init_memory_region(struct drm_i915_gem_object *obj, mutex_lock(&mem->objects.lock); - if (obj->flags & I915_BO_ALLOC_VOLATILE) - list_add(&obj->mm.region_link, &mem->objects.purgeable); - else - list_add(&obj->mm.region_link, &mem->objects.list); - + list_add(&obj->mm.region_link, &mem->objects.list); mutex_unlock(&mem->objects.lock); } diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c new file mode 100644 index 000000000000..fbb32b148be3 --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -0,0 +1,540 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2021 Intel Corporation + */ + +#include +#include + +#include "i915_drv.h" +#include "intel_memory_region.h" +#include "intel_region_ttm.h" + +#include "gem/i915_gem_object.h" +#include "gem/i915_gem_region.h" +#include "gem/i915_gem_ttm.h" + +#define I915_PL_LMEM0 TTM_PL_PRIV +#define I915_PL_SYSTEM TTM_PL_SYSTEM +#define I915_PL_STOLEN TTM_PL_VRAM +#define I915_PL_GGTT TTM_PL_TT + +#define I915_TTM_PRIO_PURGE 0 +#define I915_TTM_PRIO_NO_PAGES 1 +#define I915_TTM_PRIO_HAS_PAGES 2 + +/** + * struct i915_ttm_tt - TTM page vector with additional private information + * @ttm: The base TTM page vector. + * @dev: The struct device used for dma mapping and unmapping. + * @cached_st: The cached scatter-gather table. + * + * Note that DMA may be going on right up to the point where the page- + * vector is unpopulated in delayed destroy. Hence keep the + * scatter-gather table mapped and cached up to that point. This is + * different from the cached gem object io scatter-gather table which + * doesn't have an associated dma mapping. + */ +struct i915_ttm_tt { + struct ttm_tt ttm; + struct device *dev; + struct sg_table *cached_st; +}; + +static const struct ttm_place lmem0_sys_placement_flags[] = { + { + .fpfn = 0, + .lpfn = 0, + .mem_type = I915_PL_LMEM0, + .flags = 0, + }, { + .fpfn = 0, + .lpfn = 0, + .mem_type = I915_PL_SYSTEM, + .flags = 0, + } +}; + +static struct ttm_placement i915_lmem0_placement = { + .num_placement = 1, + .placement = &lmem0_sys_placement_flags[0], + .num_busy_placement = 1, + .busy_placement = &lmem0_sys_placement_flags[0], +}; + +static struct ttm_placement i915_sys_placement = { + .num_placement = 1, + .placement = &lmem0_sys_placement_flags[1], + .num_busy_placement = 1, + .busy_placement = &lmem0_sys_placement_flags[1], +}; + +static void i915_ttm_adjust_lru(struct drm_i915_gem_object *obj); + +static struct ttm_tt *i915_ttm_tt_create(struct ttm_buffer_object *bo, + uint32_t page_flags) +{ + struct ttm_resource_manager *man = + ttm_manager_type(bo->bdev, bo->mem.mem_type); + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + struct i915_ttm_tt *i915_tt; + int ret; + + i915_tt = kzalloc(sizeof(*i915_tt), GFP_KERNEL); + if (!i915_tt) + return NULL; + + if (obj->flags & I915_BO_ALLOC_CPU_CLEAR && + man->use_tt) + page_flags |= TTM_PAGE_FLAG_ZERO_ALLOC; + + ret = ttm_tt_init(&i915_tt->ttm, bo, page_flags, ttm_write_combined); + if (ret) { + kfree(i915_tt); + return NULL; + } + + i915_tt->dev = obj->base.dev->dev; + + return &i915_tt->ttm; +} + +static void i915_ttm_tt_unpopulate(struct ttm_device *bdev, struct ttm_tt *ttm) +{ + struct i915_ttm_tt *i915_tt = container_of(ttm, typeof(*i915_tt), ttm); + + if (i915_tt->cached_st) { + dma_unmap_sgtable(i915_tt->dev, i915_tt->cached_st, + DMA_BIDIRECTIONAL, 0); + sg_free_table(i915_tt->cached_st); + kfree(i915_tt->cached_st); + i915_tt->cached_st = NULL; + } + ttm_pool_free(&bdev->pool, ttm); +} + +static void i915_ttm_tt_destroy(struct ttm_device *bdev, struct ttm_tt *ttm) +{ + struct i915_ttm_tt *i915_tt = container_of(ttm, typeof(*i915_tt), ttm); + + ttm_tt_destroy_common(bdev, ttm); + kfree(i915_tt); +} + +static bool i915_ttm_eviction_valuable(struct ttm_buffer_object *bo, + const struct ttm_place *place) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + + /* Will do for now. Our pinned objects are still on TTM's LRU lists */ + if (!i915_gem_object_evictable(obj)) + return false; + + /* This isn't valid with a buddy allocator */ + return ttm_bo_eviction_valuable(bo, place); +} + +static void i915_ttm_evict_flags(struct ttm_buffer_object *bo, + struct ttm_placement *placement) +{ + *placement = i915_sys_placement; +} + +static int i915_ttm_move_notify(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + int ret; + + ret = i915_gem_object_unbind(obj, I915_GEM_OBJECT_UNBIND_ACTIVE); + if (ret) + return ret; + + ret = __i915_gem_object_put_pages(obj); + if (ret) + return ret; + + return 0; +} + +static void i915_ttm_free_cached_io_st(struct drm_i915_gem_object *obj) +{ + if (obj->ttm.cached_io_st) { + sg_free_table(obj->ttm.cached_io_st); + kfree(obj->ttm.cached_io_st); + obj->ttm.cached_io_st = NULL; + } +} + +static void i915_ttm_purge(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + struct ttm_operation_ctx ctx = { + .interruptible = true, + .no_wait_gpu = false, + }; + struct ttm_placement place = {}; + int ret; + + if (obj->mm.madv == __I915_MADV_PURGED) + return; + + /* TTM's purge interface. Note that we might be reentering. */ + ret = ttm_bo_validate(bo, &place, &ctx); + + if (!ret) { + i915_ttm_free_cached_io_st(obj); + obj->mm.madv = __I915_MADV_PURGED; + } +} + +static void i915_ttm_swap_notify(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + int ret = i915_ttm_move_notify(bo); + + GEM_WARN_ON(ret); + GEM_WARN_ON(obj->ttm.cached_io_st); + if (!ret && obj->mm.madv != I915_MADV_WILLNEED) + i915_ttm_purge(obj); +} + +static void i915_ttm_delete_mem_notify(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + + if (likely(obj)) { + /* This releases all gem object bindings to the backend. */ + __i915_gem_free_object(obj); + } +} + +static struct intel_memory_region * +i915_ttm_region(struct ttm_device *bdev, int ttm_mem_type) +{ + struct drm_i915_private *i915 = container_of(bdev, typeof(*i915), bdev); + + /* There's some room for optimization here... */ + GEM_BUG_ON(ttm_mem_type != I915_PL_SYSTEM && + ttm_mem_type < I915_PL_LMEM0); + if (ttm_mem_type == I915_PL_SYSTEM) + return intel_memory_region_lookup(i915, INTEL_MEMORY_SYSTEM, + 0); + + return intel_memory_region_lookup(i915, INTEL_MEMORY_LOCAL, + ttm_mem_type - I915_PL_LMEM0); +} + +static struct sg_table *i915_ttm_tt_get_st(struct ttm_tt *ttm) +{ + struct i915_ttm_tt *i915_tt = container_of(ttm, typeof(*i915_tt), ttm); + struct scatterlist *sg; + struct sg_table *st; + int ret; + + if (i915_tt->cached_st) + return i915_tt->cached_st; + + st = kzalloc(sizeof(*st), GFP_KERNEL); + if (!st) + return ERR_PTR(-ENOMEM); + + sg = __sg_alloc_table_from_pages + (st, ttm->pages, ttm->num_pages, 0, + (unsigned long)ttm->num_pages << PAGE_SHIFT, + i915_sg_segment_size(), NULL, 0, GFP_KERNEL); + if (IS_ERR(sg)) { + kfree(st); + return ERR_CAST(sg); + } + + ret = dma_map_sgtable(i915_tt->dev, st, DMA_BIDIRECTIONAL, 0); + if (ret) { + sg_free_table(st); + kfree(st); + return ERR_PTR(ret); + } + + i915_tt->cached_st = st; + return st; +} + +static struct sg_table * +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) + return i915_ttm_tt_get_st(bo->ttm); + + return intel_region_ttm_node_to_st(obj->mm.region, res->mm_node); +} + +static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, + struct ttm_operation_ctx *ctx, + struct ttm_resource *dst_mem, + struct ttm_place *hop) +{ + 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->mem.mem_type); + struct intel_memory_region *dst_reg, *src_reg; + union { + struct ttm_kmap_iter_tt tt; + struct ttm_kmap_iter_iomap io; + } _dst_iter, _src_iter; + struct ttm_kmap_iter *dst_iter, *src_iter; + struct sg_table *dst_st; + int ret; + + dst_reg = i915_ttm_region(bo->bdev, dst_mem->mem_type); + src_reg = i915_ttm_region(bo->bdev, bo->mem.mem_type); + GEM_BUG_ON(!dst_reg || !src_reg); + + /* Sync for now. We could do the actual copy async. */ + ret = ttm_bo_wait_ctx(bo, ctx); + if (ret) + return ret; + + ret = i915_ttm_move_notify(bo); + if (ret) + return ret; + + if (obj->mm.madv != I915_MADV_WILLNEED) { + i915_ttm_purge(obj); + ttm_resource_free(bo, dst_mem); + return 0; + } + + /* Populate ttm with pages if needed. Typically system memory. */ + if (bo->ttm && (dst_man->use_tt || + (bo->ttm->page_flags & TTM_PAGE_FLAG_SWAPPED))) { + ret = ttm_tt_populate(bo->bdev, bo->ttm, ctx); + if (ret) + return ret; + } + + dst_st = i915_ttm_resource_get_st(obj, dst_mem); + if (IS_ERR(dst_st)) + return PTR_ERR(dst_st); + + /* If we start mapping GGTT, we can no longer use man::use_tt here. */ + dst_iter = dst_man->use_tt ? + 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 ? + 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, + src_reg->region.start); + + ttm_move_memcpy(bo, dst_mem->num_pages, dst_iter, src_iter); + ttm_bo_move_sync_cleanup(bo, dst_mem); + i915_ttm_free_cached_io_st(obj); + + if (!dst_man->use_tt) + obj->ttm.cached_io_st = dst_st; + + return 0; +} + +static struct ttm_device_funcs i915_ttm_bo_driver = { + .ttm_tt_create = i915_ttm_tt_create, + .ttm_tt_unpopulate = i915_ttm_tt_unpopulate, + .ttm_tt_destroy = i915_ttm_tt_destroy, + .eviction_valuable = i915_ttm_eviction_valuable, + .evict_flags = i915_ttm_evict_flags, + .move = i915_ttm_move, + .swap_notify = i915_ttm_swap_notify, + .delete_mem_notify = i915_ttm_delete_mem_notify, +}; + +/** + * i915_ttm_driver - Return a pointer to the TTM device funcs + * + * Return: Pointer to statically allocated TTM device funcs. + */ +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) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + struct ttm_operation_ctx ctx = { + .interruptible = true, + .no_wait_gpu = false, + }; + struct sg_table *st; + int ret; + + /* Move to the requested placement. */ + ret = ttm_bo_validate(bo, &i915_lmem0_placement, &ctx); + if (ret) + return ret == -ENOSPC ? -ENXIO : ret; + + /* 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_ttm_adjust_lru(obj); + + return ret; +} + +static void i915_ttm_put_pages(struct drm_i915_gem_object *obj, + struct sg_table *st) +{ + /* + * We're currently not called from a shrinker, so put_pages() + * typically means the object is about to destroyed, or called + * from move_notify(). So just avoid doing much for now. + * If the object is not destroyed next, The TTM eviction logic + * and shrinkers will move it out if needed. + */ + + i915_ttm_adjust_lru(obj); +} + +static void i915_ttm_adjust_lru(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + + /* + * Don't manipulate the TTM LRUs while in TTM bo destruction. + * We're called through i915_ttm_delete_mem_notify(). + */ + if (!kref_read(&bo->kref)) + return; + + /* + * Put on the correct LRU list depending on the MADV status + */ + spin_lock(&bo->bdev->lru_lock); + if (obj->mm.madv != I915_MADV_WILLNEED) { + bo->priority = I915_TTM_PRIO_PURGE; + } else if (!i915_gem_object_has_pages(obj)) { + if (bo->priority < I915_TTM_PRIO_HAS_PAGES) + bo->priority = I915_TTM_PRIO_HAS_PAGES; + } else { + if (bo->priority > I915_TTM_PRIO_NO_PAGES) + bo->priority = I915_TTM_PRIO_NO_PAGES; + } + + ttm_bo_move_to_lru_tail(bo, &bo->mem, NULL); + spin_unlock(&bo->bdev->lru_lock); +} + +/* + * TTM-backed gem object destruction requires some clarification. + * Basically we have two possibilities here. We can either rely on the + * i915 delayed destruction and put the TTM object when the object + * is idle. This would be detected by TTM which would bypass the + * TTM delayed destroy handling. The other approach is to put the TTM + * object early and rely on the TTM destroyed handling, and then free + * the leftover parts of the GEM object once TTM's destroyed list handling is + * complete. For now, we rely on the latter for two reasons: + * a) TTM can evict an object even when it's on the delayed destroy list, + * which in theory allows for complete eviction. + * b) There is work going on in TTM to allow freeing an object even when + * it's not idle, and using the TTM destroyed list handling could help us + * benefit from that. + */ +static void i915_ttm_delayed_free(struct drm_i915_gem_object *obj) +{ + if (obj->ttm.created) { + ttm_bo_put(i915_gem_to_ttm(obj)); + } else { + __i915_gem_free_object(obj); + call_rcu(&obj->rcu, __i915_gem_free_object_rcu); + } +} + +static const struct drm_i915_gem_object_ops i915_gem_ttm_obj_ops = { + .name = "i915_gem_object_ttm", + .flags = I915_GEM_OBJECT_HAS_IOMEM, + + .get_pages = i915_ttm_get_pages, + .put_pages = i915_ttm_put_pages, + .truncate = i915_ttm_purge, + .adjust_lru = i915_ttm_adjust_lru, + .delayed_free = i915_ttm_delayed_free, +}; + +void i915_ttm_bo_destroy(struct ttm_buffer_object *bo) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + + i915_gem_object_release_memory_region(obj); + if (obj->ttm.created) + call_rcu(&obj->rcu, __i915_gem_free_object_rcu); +} + +/** + * __i915_gem_ttm_object_init - Initialize a ttm-backed i915 gem object + * @mem: The initial memory region for the object. + * @obj: The gem object. + * @size: Object size in bytes. + * @flags: gem object flags. + * + * Return: 0 on success, negative error code on failure. + */ +int __i915_gem_ttm_object_init(struct intel_memory_region *mem, + struct drm_i915_gem_object *obj, + resource_size_t size, + unsigned int flags) +{ + static struct lock_class_key lock_class; + struct drm_i915_private *i915 = mem->i915; + enum ttm_bo_type bo_type; + size_t alignment = 0; + int ret; + + /* Adjust alignment to GPU- and CPU huge page sizes. */ + + if (mem->is_range_manager) { + if (size >= SZ_1G) + alignment = SZ_1G >> PAGE_SHIFT; + else if (size >= SZ_2M) + alignment = SZ_2M >> PAGE_SHIFT; + else if (size >= SZ_64K) + alignment = SZ_64K >> PAGE_SHIFT; + } + + drm_gem_private_object_init(&i915->drm, &obj->base, size); + 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; + i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); + + bo_type = (obj->flags & I915_BO_ALLOC_USER) ? ttm_bo_type_device : + ttm_bo_type_kernel; + + /* + * If this function fails, it will call the destructor, but + * our caller still owns the object. So no freeing in the + * destructor until obj->ttm.created is true. + * Similarly, in delayed_destroy, we can't call ttm_bo_put() + * until successful initialization. + */ + ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, + bo_type, &i915_sys_placement, alignment, + true, NULL, NULL, i915_ttm_bo_destroy); + + if (!ret) + obj->ttm.created = true; + + /* i915 wants -ENXIO when out of memory region space. */ + return (ret == -ENOSPC) ? -ENXIO : ret; +} diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.h b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h new file mode 100644 index 000000000000..b8d3dcbb50df --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2021 Intel Corporation + */ +#ifndef _I915_GEM_TTM_H_ +#define _I915_GEM_TTM_H_ + +#include "gem/i915_gem_object_types.h" + +/** + * i915_gem_to_ttm - Convert a struct drm_i915_gem_object to a + * struct ttm_buffer_object. + * @obj: Pointer to the gem object. + * + * Return: Pointer to the embedded struct ttm_buffer_object. + */ +static inline struct ttm_buffer_object * +i915_gem_to_ttm(struct drm_i915_gem_object *obj) +{ + return &obj->__do_not_access; +} + +/* + * i915 ttm gem object destructor. Internal use only. + */ +void i915_ttm_bo_destroy(struct ttm_buffer_object *bo); + +/** + * i915_ttm_to_gem - Convert a struct ttm_buffer_object to an embedding + * struct drm_i915_gem_object. + * + * Return: Pointer to the embedding struct ttm_buffer_object, or NULL + * if the object was not an i915 ttm object. + */ +static inline struct drm_i915_gem_object * +i915_ttm_to_gem(struct ttm_buffer_object *bo) +{ + if (GEM_WARN_ON(bo->destroy != i915_ttm_bo_destroy)) + return NULL; + + return container_of(bo, struct drm_i915_gem_object, __do_not_access); +} + +int __i915_gem_ttm_object_init(struct intel_memory_region *mem, + struct drm_i915_gem_object *obj, + resource_size_t size, + unsigned int flags); +#endif diff --git a/drivers/gpu/drm/i915/gt/intel_region_lmem.c b/drivers/gpu/drm/i915/gt/intel_region_lmem.c index f7366b054f8e..4ae1f717a94c 100644 --- a/drivers/gpu/drm/i915/gt/intel_region_lmem.c +++ b/drivers/gpu/drm/i915/gt/intel_region_lmem.c @@ -9,6 +9,7 @@ #include "intel_region_ttm.h" #include "gem/i915_gem_lmem.h" #include "gem/i915_gem_region.h" +#include "gem/i915_gem_ttm.h" #include "intel_region_lmem.h" static int init_fake_lmem_bar(struct intel_memory_region *mem) @@ -107,7 +108,7 @@ region_lmem_init(struct intel_memory_region *mem) static const struct intel_memory_region_ops intel_region_lmem_ops = { .init = region_lmem_init, .release = region_lmem_release, - .init_object = __i915_gem_lmem_object_init, + .init_object = __i915_gem_ttm_object_init, }; struct intel_memory_region * diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c index 0993d706f067..40fe9a147318 100644 --- a/drivers/gpu/drm/i915/i915_gem.c +++ b/drivers/gpu/drm/i915/i915_gem.c @@ -1005,8 +1005,11 @@ i915_gem_madvise_ioctl(struct drm_device *dev, void *data, } } - if (obj->mm.madv != __I915_MADV_PURGED) + if (obj->mm.madv != __I915_MADV_PURGED) { obj->mm.madv = args->madv; + if (obj->ops->adjust_lru) + obj->ops->adjust_lru(obj); + } if (i915_gem_object_has_pages(obj)) { unsigned long flags; diff --git a/drivers/gpu/drm/i915/intel_memory_region.c b/drivers/gpu/drm/i915/intel_memory_region.c index 4092cc987679..bd27e897d4d0 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.c +++ b/drivers/gpu/drm/i915/intel_memory_region.c @@ -149,7 +149,6 @@ intel_memory_region_create(struct drm_i915_private *i915, mutex_init(&mem->objects.lock); INIT_LIST_HEAD(&mem->objects.list); - INIT_LIST_HEAD(&mem->objects.purgeable); INIT_LIST_HEAD(&mem->reserved); mutex_init(&mem->mm_lock); diff --git a/drivers/gpu/drm/i915/intel_memory_region.h b/drivers/gpu/drm/i915/intel_memory_region.h index e69cde13daf2..7b5fa97c0b59 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.h +++ b/drivers/gpu/drm/i915/intel_memory_region.h @@ -100,7 +100,6 @@ struct intel_memory_region { struct { struct mutex lock; /* Protects access to objects */ struct list_head list; - struct list_head purgeable; } objects; size_t chunk_size; diff --git a/drivers/gpu/drm/i915/intel_region_ttm.c b/drivers/gpu/drm/i915/intel_region_ttm.c index c8ac118c21f6..0b41a1545570 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.c +++ b/drivers/gpu/drm/i915/intel_region_ttm.c @@ -10,6 +10,7 @@ #include "intel_region_ttm.h" +#include "gem/i915_gem_ttm.h" /* For the funcs/ops export only */ /** * DOC: TTM support structure * @@ -19,9 +20,6 @@ * i915 GEM regions to TTM memory types and resource managers. */ -/* A Zero-initialized driver for now. We don't have a TTM backend yet. */ -static struct ttm_device_funcs i915_ttm_bo_driver; - /** * intel_region_ttm_device_init - Initialize a TTM device * @dev_priv: Pointer to an i915 device private structure. @@ -32,7 +30,7 @@ int intel_region_ttm_device_init(struct drm_i915_private *dev_priv) { struct drm_device *drm = &dev_priv->drm; - return ttm_device_init(&dev_priv->bdev, &i915_ttm_bo_driver, + return ttm_device_init(&dev_priv->bdev, i915_ttm_driver(), drm->dev, drm->anon_inode->i_mapping, drm->vma_offset_manager, false, false); } @@ -172,6 +170,7 @@ struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, return i915_sg_from_mm_node(node, mem->region.start); } +#ifdef CONFIG_DRM_I915_SELFTEST /** * intel_region_ttm_node_alloc - Allocate memory resources from a region * @mem: The memory region, @@ -218,3 +217,4 @@ void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, ret = -ENXIO; return ret ? ERR_PTR(ret) : res.mm_node; } +#endif diff --git a/drivers/gpu/drm/i915/intel_region_ttm.h b/drivers/gpu/drm/i915/intel_region_ttm.h index 1c82c6c3429d..eaa3eccfa252 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.h +++ b/drivers/gpu/drm/i915/intel_region_ttm.h @@ -11,6 +11,7 @@ struct drm_i915_private; struct intel_memory_region; +struct ttm_device_funcs; int intel_region_ttm_device_init(struct drm_i915_private *dev_priv); @@ -23,10 +24,14 @@ void intel_region_ttm_fini(struct intel_memory_region *mem); struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, void *node); +void intel_region_ttm_node_free(struct intel_memory_region *mem, + void *node); + +struct ttm_device_funcs *i915_ttm_driver(void); + +#ifdef CONFIG_DRM_I915_SELFTEST void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, resource_size_t size, unsigned int flags); - -void intel_region_ttm_node_free(struct intel_memory_region *mem, - void *node); +#endif #endif /* _INTEL_REGION_TTM_H_ */ -- 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,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 5EFE3C4708F for ; Fri, 28 May 2021 10:58:27 +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 25E90613B5 for ; Fri, 28 May 2021 10:58:27 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 25E90613B5 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 B00118914C; Fri, 28 May 2021 10:58:18 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id E59106F595; Fri, 28 May 2021 10:58:15 +0000 (UTC) IronPort-SDR: +PJ0GPmXcJMDOYyw1ZcyfkKM1B2JnieBzRxCynG/uEA5UUFLN879qQmMaAIAUn4enIzOZQ45hr klQMdFKUgFWg== X-IronPort-AV: E=McAfee;i="6200,9189,9997"; a="266821848" X-IronPort-AV: E=Sophos;i="5.83,229,1616482800"; d="scan'208";a="266821848" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 May 2021 03:58:15 -0700 IronPort-SDR: tS/XY2RCUN8JLNd+3GdEiSpdSy1IWw3ctS16o2eCCIRDW9K/069Tqjj2hPwd4J1qKKEzLnaZI+ 5xqjHuxpwwEw== X-IronPort-AV: E=Sophos;i="5.83,229,1616482800"; d="scan'208";a="477885254" Received: from jdahlin-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.92]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 28 May 2021 03:58:14 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Fri, 28 May 2021 12:57:40 +0200 Message-Id: <20210528105744.58271-12-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210528105744.58271-1-thomas.hellstrom@linux.intel.com> References: <20210528105744.58271-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v6 11/15] drm/i915/ttm: Introduce a TTM i915 gem object backend 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 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" TW9zdCBsb2dpY2FsIHBsYWNlIHRvIGludHJvZHVjZSBUVE0gYnVmZmVyIG9iamVjdHMgaXMgYXMg YW4gaTkxNQpnZW0gb2JqZWN0IGJhY2tlbmQuIFdlIG5lZWQgdG8gYWRkIHNvbWUgb3BzIHRvIGFj Y291bnQgZm9yIGFkZGVkCmZ1bmN0aW9uYWxpdHkgbGlrZSBkZWxheWVkIGRlbGV0ZSBhbmQgTFJV IGxpc3QgbWFuaXB1bGF0aW9uLgoKSW5pdGlhbGx5IHdlIHN1cHBvcnQgb25seSBMTUVNIGFuZCBT WVNURU0gbWVtb3J5LCBidXQgU1lTVEVNCih3aGljaCBpbiB0aGlzIGNhc2UgbWVhbnMgZXZpY3Rl ZCBMTUVNIG9iamVjdHMpIGlzIG5vdAp2aXNpYmxlIHRvIGk5MTUgR0VNIHlldC4gVGhlIHBsYW4g aXMgdG8gbW92ZSB0aGUgaTkxNSBnZW0gc3lzdGVtIHJlZ2lvbgpvdmVyIHRvIHRoZSBUVE0gc3lz dGVtIG1lbW9yeSB0eXBlIGluIHVwY29taW5nIHBhdGNoZXMuCgpXZSBzZXQgdXAgR1BVIGJpbmRp bmdzIGRpcmVjdGx5IGJvdGggZnJvbSBMTUVNIGFuZCBmcm9tIHRoZSBzeXN0ZW0gcmVnaW9uLAph cyB0aGVyZSBpcyBubyBuZWVkIHRvIHVzZSB0aGUgbGVnYWN5IFRUTV9UVCBtZW1vcnkgdHlwZS4g V2UgcmVzZXJ2ZQp0aGF0IGZvciBmdXR1cmUgcG9ydGluZyBvZiBHR1RUIGJpbmRpbmdzIHRvIFRU TS4KClJlbW92ZSB0aGUgb2xkIGxtZW0gYmFja2VuZC4KClNpZ25lZC1vZmYtYnk6IFRob21hcyBI ZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNvbT4KUmV2aWV3ZWQtYnk6 IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGludGVsLmNvbT4KLS0tCnYyOgotIEJyZWFrIG91 dCBuZWVkZWQgVFRNIGZ1bmN0aW9uYWxpdHkgdG8gYSBzZXBhcmF0ZSBwYXRjaCAoUmVwb3J0ZWQg YnkKQ2hyaXN0aWFuIEvDtm5pZykuCi0gRml4IGFuIHVuaGFuZGxlZCBlcnJvciAoUmVwb3J0ZWQg YnkgTWF0dGhldyBBdWxkIGFuZCBNYWFydGVuIExhbmtob3JzdCkKLSBSZW1vdmUgYSBzdHJheSBs ZWZ0b3ZlciBzZ190YWJsZSBhbGxvY2F0aW9uIChSZXBvcnRlZCBieSBNYXR0aGV3IEF1bGQpCi0g VXNlIHR0bV90dF91bnBvcHVsYXRlKCkgcmF0aGVyIHRoYW4gdHRtX3R0X2Rlc3Ryb3koKSBpbiB0 aGUgcHVyZ2UgcGF0aAogIGFzIHNvbWUgVFRNIGZ1bmN0aW9uYWxpdHkgcmVsaWVzIG9uIGhhdmlu ZyBhIHR0bV90dCBwcmVzZW50IGZvciAhaXNfaW9tZW0uCnYzOgotIFVzZSB0dG1fYm9fdHlwZV9k ZXZpY2UgZm9yIHVzZXJzcGFjZSB2aXNpYmxlIG9iamVjdHMgc28gdGhhdCBUVE0gY2FuCiAgYWxs b2NhdGUgYW4gYWRkcmVzcyBzcGFjZSBvZmZzZXQgZm9yIG1tYXAnaW5nLgotIEZpeCB1cCB0aGUg ZGVzdHJ1Y3Rpb24gcGF0aCAoUmVwb3J0ZWQgYnkgTWF0dGhldyBBdWxkKQotIFVzZSB0dG1fYm9f dmFsaWRhdGUoKSBmb3IgcHVyZ2luZyAoUmVwb3J0ZWQgYnkgQ2hyaXN0aWFuIEvDtm5pZykKLSBD cmVhdGUgdHRtX3R0cyB3cml0ZS1jb21iaW5lZCBhcyB0aGV5IGFyZSBjdXJyZW50bHkgZm9yIGV2 aWN0aW9uIG9ubHkgYW5kCiAgd2Ugd2FudCB0byBtYWludGFpbiBjb25zaXN0ZW50IHdyaXRlLWNv bWJpbmVkIGNhY2hpbmcgZm9yIGJvcyB0aGF0IGFyZQogIG5vdCBpbiBzeXN0ZW0gb25seS4gKFN1 Z2dlc3RlZCBieSBEYW5pZWwgVmV0dGVyKQotIE1ha2Ugc3RydWN0IHR0bV9wbGFjZW1lbnRzIHN0 YXRpYy4KLSBBZGQgdGhlIHR0bSBkZXZpY2UgZnVuY3Mvb3BzIHRvIGk5MTVfZ2VtX3R0bS5oIGZv ciB0aGUgcmVnaW9uIGNvZGUuCi0gUmVuYW1lIG5ldy0+ZHN0IGFuZCBvbGQtPnNyYy4gQ2hlY2sg Zm9yIHN3YXBpbiBpbiB0aGUgbW92ZSBjYWxsYmFjay4KdjQ6Ci0gQWRhcHQgdG8gc21hbGwgaW50 ZXJmYWNlIGNoYW5nZSBpbiB0dG1fbW92ZV9tZW1jcHkuCi0gVXNlIGEgZnVuY3Rpb24gdG8gcHVs bCBvdXQgdGhlIHR0bSBkcml2ZXIgZnJvbSB0aGUgYmFja2VuZC4KdjY6Ci0gUmVtb3ZlIHRoZSB0 dG0gZGV2aWNlIHZlcmlmeV9hY2Nlc3MgYXNzaWdubWVudC4gVGhlIG1lbWJlciBpcyBnb25lCiAg dXBzdHJlYW0uCi0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgICAgICAgICAgICAg ICAgIHwgICAxICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9jcmVhdGUuYyAg ICB8ICAgOSArLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uYyAgICAg IHwgIDg0IC0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaCAgICAg IHwgICA1IC0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuYyAgICB8 IDEyNSArKy0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmggICAg fCAgIDkgKwogLi4uL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmggIHwg IDI3ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMgICAgfCAg IDYgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYyAgICAgICB8IDU0 MCArKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90 dG0uaCAgICAgICB8ICA0OCArKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9u X2xtZW0uYyAgIHwgICAzICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jICAgICAg ICAgICAgICAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdp b24uYyAgICB8ICAgMSAtCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9u LmggICAgfCAgIDEgLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5jICAg ICAgIHwgICA4ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmggICAg ICAgfCAgMTEgKy0KIDE2IGZpbGVzIGNoYW5nZWQsIDczMCBpbnNlcnRpb25zKCspLCAxNTMgZGVs ZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX3R0bS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2Vt L2k5MTVfZ2VtX3R0bS5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZp bGUgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQppbmRleCA0ZjIyY2FjMWM0OWIuLmY1 N2RmYzc0ZDZjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKKysr IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKQEAgLTE1NSw2ICsxNTUsNyBAQCBnZW0t eSArPSBcCiAJZ2VtL2k5MTVfZ2VtX3N0b2xlbi5vIFwKIAlnZW0vaTkxNV9nZW1fdGhyb3R0bGUu byBcCiAJZ2VtL2k5MTVfZ2VtX3RpbGluZy5vIFwKKwlnZW0vaTkxNV9nZW1fdHRtLm8gXAogCWdl bS9pOTE1X2dlbV91c2VycHRyLm8gXAogCWdlbS9pOTE1X2dlbV93YWl0Lm8gXAogCWdlbS9pOTE1 X2dlbWZzLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9j cmVhdGUuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9jcmVhdGUuYwppbmRl eCA1NDhkZGYzOWQ4NTMuLjkzYmY2M2JiYWZmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9jcmVhdGUuYwpAQCAtODUsMTMgKzg1LDEwIEBAIGk5MTVfZ2VtX3NldHVwKHN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosIHU2NCBzaXplKQogCQlyZXR1cm4gLUUyQklH OwogCiAJLyoKLQkgKiBGb3Igbm93IHJlc29ydCB0byBDUFUgYmFzZWQgY2xlYXJpbmcgZm9yIGRl dmljZSBsb2NhbC1tZW1vcnksIGluIHRoZQotCSAqIG5lYXIgZnV0dXJlIHRoaXMgd2lsbCB1c2Ug dGhlIGJsaXR0ZXIgZW5naW5lIGZvciBhY2NlbGVyYXRlZCwgR1BVCi0JICogYmFzZWQgY2xlYXJp bmcuCisJICogSTkxNV9CT19BTExPQ19VU0VSIHdpbGwgbWFrZSBzdXJlIHRoZSBvYmplY3QgaXMg Y2xlYXJlZCBiZWZvcmUKKwkgKiBhbnkgdXNlciBhY2Nlc3MuCiAJICovCi0JZmxhZ3MgPSAwOwot CWlmIChtci0+dHlwZSA9PSBJTlRFTF9NRU1PUllfTE9DQUwpCi0JCWZsYWdzID0gSTkxNV9CT19B TExPQ19DUFVfQ0xFQVI7CisJZmxhZ3MgPSBJOTE1X0JPX0FMTE9DX1VTRVI7CiAKIAlyZXQgPSBt ci0+b3BzLT5pbml0X29iamVjdChtciwgb2JqLCBzaXplLCBmbGFncyk7CiAJaWYgKHJldCkKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5jCmluZGV4IDNiNGFhMjhhMDc2ZC4u MmI4Y2QxNWRlMWQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9n ZW1fbG1lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMK QEAgLTQsNzQgKzQsMTAgQEAKICAqLwogCiAjaW5jbHVkZSAiaW50ZWxfbWVtb3J5X3JlZ2lvbi5o IgotI2luY2x1ZGUgImludGVsX3JlZ2lvbl90dG0uaCIKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1f cmVnaW9uLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX2xtZW0uaCIKICNpbmNsdWRlICJpOTE1 X2Rydi5oIgogCi1zdGF0aWMgdm9pZCBsbWVtX3B1dF9wYWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCAqb2JqLAotCQkJICAgc3RydWN0IHNnX3RhYmxlICpwYWdlcykKLXsKLQlpbnRlbF9y ZWdpb25fdHRtX25vZGVfZnJlZShvYmotPm1tLnJlZ2lvbiwgb2JqLT5tbS5zdF9tbV9ub2RlKTsK LQlvYmotPm1tLmRpcnR5ID0gZmFsc2U7Ci0Jc2dfZnJlZV90YWJsZShwYWdlcyk7Ci0Ja2ZyZWUo cGFnZXMpOwotfQotCi1zdGF0aWMgaW50IGxtZW1fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9n ZW1fb2JqZWN0ICpvYmopCi17Ci0JdW5zaWduZWQgaW50IGZsYWdzOwotCXN0cnVjdCBzZ190YWJs ZSAqcGFnZXM7Ci0KLQlmbGFncyA9IEk5MTVfQUxMT0NfTUlOX1BBR0VfU0laRTsKLQlpZiAob2Jq LT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ09OVElHVU9VUykKLQkJZmxhZ3MgfD0gSTkxNV9BTExP Q19DT05USUdVT1VTOwotCi0Jb2JqLT5tbS5zdF9tbV9ub2RlID0gaW50ZWxfcmVnaW9uX3R0bV9u b2RlX2FsbG9jKG9iai0+bW0ucmVnaW9uLAotCQkJCQkJCSBvYmotPmJhc2Uuc2l6ZSwKLQkJCQkJ CQkgZmxhZ3MpOwotCWlmIChJU19FUlIob2JqLT5tbS5zdF9tbV9ub2RlKSkKLQkJcmV0dXJuIFBU Ul9FUlIob2JqLT5tbS5zdF9tbV9ub2RlKTsKLQotCS8qIFJhbmdlIG1hbmFnZXIgaXMgYWx3YXlz IGNvbnRpZ291cyAqLwotCWlmIChvYmotPm1tLnJlZ2lvbi0+aXNfcmFuZ2VfbWFuYWdlcikKLQkJ b2JqLT5mbGFncyB8PSBJOTE1X0JPX0FMTE9DX0NPTlRJR1VPVVM7Ci0JcGFnZXMgPSBpbnRlbF9y ZWdpb25fdHRtX25vZGVfdG9fc3Qob2JqLT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7 Ci0JaWYgKElTX0VSUihwYWdlcykpIHsKLQkJaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2ZyZWUob2Jq LT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7Ci0JCXJldHVybiBQVFJfRVJSKHBhZ2Vz KTsKLQl9Ci0KLQlfX2k5MTVfZ2VtX29iamVjdF9zZXRfcGFnZXMob2JqLCBwYWdlcywgaTkxNV9z Z19kbWFfc2l6ZXMocGFnZXMtPnNnbCkpOwotCi0JaWYgKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FM TE9DX0NQVV9DTEVBUikgewotCQl2b2lkIF9faW9tZW0gKnZhZGRyID0KLQkJCWk5MTVfZ2VtX29i amVjdF9sbWVtX2lvX21hcChvYmosIDAsIG9iai0+YmFzZS5zaXplKTsKLQotCQlpZiAoIXZhZGRy KSB7Ci0JCQlzdHJ1Y3Qgc2dfdGFibGUgKnBhZ2VzID0KLQkJCQlfX2k5MTVfZ2VtX29iamVjdF91 bnNldF9wYWdlcyhvYmopOwotCi0JCQlpZiAoIUlTX0VSUl9PUl9OVUxMKHBhZ2VzKSkKLQkJCQls bWVtX3B1dF9wYWdlcyhvYmosIHBhZ2VzKTsKLQkJfQotCi0JCW1lbXNldF9pbyh2YWRkciwgMCwg b2JqLT5iYXNlLnNpemUpOwotCQlpb19tYXBwaW5nX3VubWFwKHZhZGRyKTsKLQl9Ci0KLQlyZXR1 cm4gMDsKLX0KLQotY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIGk5MTVfZ2Vt X2xtZW1fb2JqX29wcyA9IHsKLQkubmFtZSA9ICJpOTE1X2dlbV9vYmplY3RfbG1lbSIsCi0JLmZs YWdzID0gSTkxNV9HRU1fT0JKRUNUX0hBU19JT01FTSwKLQotCS5nZXRfcGFnZXMgPSBsbWVtX2dl dF9wYWdlcywKLQkucHV0X3BhZ2VzID0gbG1lbV9wdXRfcGFnZXMsCi0JLnJlbGVhc2UgPSBpOTE1 X2dlbV9vYmplY3RfcmVsZWFzZV9tZW1vcnlfcmVnaW9uLAotfTsKLQogdm9pZCBfX2lvbWVtICoK IGk5MTVfZ2VtX29iamVjdF9sbWVtX2lvX21hcChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAq b2JqLAogCQkJICAgIHVuc2lnbmVkIGxvbmcgbiwKQEAgLTEwMywyMyArMzksMyBAQCBpOTE1X2dl bV9vYmplY3RfY3JlYXRlX2xtZW0oc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJcmV0 dXJuIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKGk5MTUtPm1tLnJlZ2lvbnNbSU5URUxf UkVHSU9OX0xNRU1dLAogCQkJCQkgICAgIHNpemUsIGZsYWdzKTsKIH0KLQotaW50IF9faTkxNV9n ZW1fbG1lbV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJ CXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkJcmVzb3VyY2Vfc2l6ZV90IHNp emUsCi0JCQkJdW5zaWduZWQgaW50IGZsYWdzKQotewotCXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFz c19rZXkgbG9ja19jbGFzczsKLQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IG1lbS0+ aTkxNTsKLQotCWRybV9nZW1fcHJpdmF0ZV9vYmplY3RfaW5pdCgmaTkxNS0+ZHJtLCAmb2JqLT5i YXNlLCBzaXplKTsKLQlpOTE1X2dlbV9vYmplY3RfaW5pdChvYmosICZpOTE1X2dlbV9sbWVtX29i al9vcHMsICZsb2NrX2NsYXNzLCBmbGFncyk7Ci0KLQlvYmotPnJlYWRfZG9tYWlucyA9IEk5MTVf R0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RPTUFJTl9HVFQ7Ci0KLQlpOTE1X2dlbV9vYmplY3Rf c2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIEk5MTVfQ0FDSEVfTk9ORSk7Ci0KLQlpOTE1X2dlbV9v YmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKG9iaiwgbWVtKTsKLQotCXJldHVybiAwOwotfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaCBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmgKaW5kZXggZmFjNmJjNWE1ZWJiLi5l YTc2ZmQxMWNjYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV9sbWVtLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaApA QCAtMjYsOSArMjYsNCBAQCBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX2xtZW0oc3RydWN0IGRybV9p OTE1X3ByaXZhdGUgKmk5MTUsCiAJCQkgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCiAJCQkgICAg dW5zaWduZWQgaW50IGZsYWdzKTsKIAotaW50IF9faTkxNV9nZW1fbG1lbV9vYmplY3RfaW5pdChz dHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJCXN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmosCi0JCQkJcmVzb3VyY2Vfc2l6ZV90IHNpemUsCi0JCQkJdW5zaWduZWQgaW50 IGZsYWdzKTsKLQogI2VuZGlmIC8qICFfX0k5MTVfR0VNX0xNRU1fSCAqLwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCmluZGV4IDU3MDZkNDcxNjkyZC4uMTZlYWM1 ZWE5MjM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2Jq ZWN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCkBA IC0xNzIsNyArMTcyLDcgQEAgc3RhdGljIHZvaWQgaTkxNV9nZW1fY2xvc2Vfb2JqZWN0KHN0cnVj dCBkcm1fZ2VtX29iamVjdCAqZ2VtLCBzdHJ1Y3QgZHJtX2ZpbGUgKmYKIAl9CiB9CiAKLXN0YXRp YyB2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KHN0cnVjdCByY3VfaGVhZCAqaGVhZCkK K3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQog ewogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPQogCQljb250YWluZXJfb2YoaGVh ZCwgdHlwZW9mKCpvYmopLCByY3UpOwpAQCAtMjA4LDU5ICsyMDgsNjkgQEAgc3RhdGljIHZvaWQg X19pOTE1X2dlbV9vYmplY3RfZnJlZV9tbWFwcyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAq b2JqKQogCX0KIH0KIAotc3RhdGljIHZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdHMoc3RydWN0 IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCi0JCQkJICAgIHN0cnVjdCBsbGlzdF9ub2RlICpmcmVl ZCkKK3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqKQogewotCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosICpvbjsKKwl0cmFj ZV9pOTE1X2dlbV9vYmplY3RfZGVzdHJveShvYmopOwogCi0JbGxpc3RfZm9yX2VhY2hfZW50cnlf c2FmZShvYmosIG9uLCBmcmVlZCwgZnJlZWQpIHsKLQkJdHJhY2VfaTkxNV9nZW1fb2JqZWN0X2Rl c3Ryb3kob2JqKTsKKwlpZiAoIWxpc3RfZW1wdHkoJm9iai0+dm1hLmxpc3QpKSB7CisJCXN0cnVj dCBpOTE1X3ZtYSAqdm1hOworCisJCS8qCisJCSAqIE5vdGUgdGhhdCB0aGUgdm1hIGtlZXBzIGFu IG9iamVjdCByZWZlcmVuY2Ugd2hpbGUKKwkJICogaXQgaXMgYWN0aXZlLCBzbyBpdCAqc2hvdWxk KiBub3Qgc2xlZXAgd2hpbGUgd2UKKwkJICogZGVzdHJveSBpdC4gT3VyIGRlYnVnIGNvZGUgZXJy cyBpbnNpdHMgaXQgKm1pZ2h0Ki4KKwkJICogRm9yIHRoZSBtb21lbnQsIHBsYXkgYWxvbmcuCisJ CSAqLworCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2spOworCQl3aGlsZSAoKHZtYSA9IGxpc3Rf Zmlyc3RfZW50cnlfb3JfbnVsbCgmb2JqLT52bWEubGlzdCwKKwkJCQkJCSAgICAgICBzdHJ1Y3Qg aTkxNV92bWEsCisJCQkJCQkgICAgICAgb2JqX2xpbmspKSkgeworCQkJR0VNX0JVR19PTih2bWEt Pm9iaiAhPSBvYmopOworCQkJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOwogCi0JCWlmICgh bGlzdF9lbXB0eSgmb2JqLT52bWEubGlzdCkpIHsKLQkJCXN0cnVjdCBpOTE1X3ZtYSAqdm1hOwor CQkJX19pOTE1X3ZtYV9wdXQodm1hKTsKIAotCQkJLyoKLQkJCSAqIE5vdGUgdGhhdCB0aGUgdm1h IGtlZXBzIGFuIG9iamVjdCByZWZlcmVuY2Ugd2hpbGUKLQkJCSAqIGl0IGlzIGFjdGl2ZSwgc28g aXQgKnNob3VsZCogbm90IHNsZWVwIHdoaWxlIHdlCi0JCQkgKiBkZXN0cm95IGl0LiBPdXIgZGVi dWcgY29kZSBlcnJzIGluc2l0cyBpdCAqbWlnaHQqLgotCQkJICogRm9yIHRoZSBtb21lbnQsIHBs YXkgYWxvbmcuCi0JCQkgKi8KIAkJCXNwaW5fbG9jaygmb2JqLT52bWEubG9jayk7Ci0JCQl3aGls ZSAoKHZtYSA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVsbCgmb2JqLT52bWEubGlzdCwKLQkJCQkJ CQkgICAgICAgc3RydWN0IGk5MTVfdm1hLAotCQkJCQkJCSAgICAgICBvYmpfbGluaykpKSB7Ci0J CQkJR0VNX0JVR19PTih2bWEtPm9iaiAhPSBvYmopOwotCQkJCXNwaW5fdW5sb2NrKCZvYmotPnZt YS5sb2NrKTsKKwkJfQorCQlzcGluX3VubG9jaygmb2JqLT52bWEubG9jayk7CisJfQogCi0JCQkJ X19pOTE1X3ZtYV9wdXQodm1hKTsKKwlfX2k5MTVfZ2VtX29iamVjdF9mcmVlX21tYXBzKG9iaik7 CiAKLQkJCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2spOwotCQkJfQotCQkJc3Bpbl91bmxvY2so Jm9iai0+dm1hLmxvY2spOwotCQl9CisJR0VNX0JVR19PTighbGlzdF9lbXB0eSgmb2JqLT5sdXRf bGlzdCkpOwogCi0JCV9faTkxNV9nZW1fb2JqZWN0X2ZyZWVfbW1hcHMob2JqKTsKKwlhdG9taWNf c2V0KCZvYmotPm1tLnBhZ2VzX3Bpbl9jb3VudCwgMCk7CisJX19pOTE1X2dlbV9vYmplY3RfcHV0 X3BhZ2VzKG9iaik7CisJR0VNX0JVR19PTihpOTE1X2dlbV9vYmplY3RfaGFzX3BhZ2VzKG9iaikp OworCWJpdG1hcF9mcmVlKG9iai0+Yml0XzE3KTsKIAotCQlHRU1fQlVHX09OKCFsaXN0X2VtcHR5 KCZvYmotPmx1dF9saXN0KSk7CisJaWYgKG9iai0+YmFzZS5pbXBvcnRfYXR0YWNoKQorCQlkcm1f cHJpbWVfZ2VtX2Rlc3Ryb3koJm9iai0+YmFzZSwgTlVMTCk7CiAKLQkJYXRvbWljX3NldCgmb2Jq LT5tbS5wYWdlc19waW5fY291bnQsIDApOwotCQlfX2k5MTVfZ2VtX29iamVjdF9wdXRfcGFnZXMo b2JqKTsKLQkJR0VNX0JVR19PTihpOTE1X2dlbV9vYmplY3RfaGFzX3BhZ2VzKG9iaikpOwotCQli aXRtYXBfZnJlZShvYmotPmJpdF8xNyk7CisJZHJtX2dlbV9mcmVlX21tYXBfb2Zmc2V0KCZvYmot PmJhc2UpOwogCi0JCWlmIChvYmotPmJhc2UuaW1wb3J0X2F0dGFjaCkKLQkJCWRybV9wcmltZV9n ZW1fZGVzdHJveSgmb2JqLT5iYXNlLCBOVUxMKTsKKwlpZiAob2JqLT5vcHMtPnJlbGVhc2UpCisJ CW9iai0+b3BzLT5yZWxlYXNlKG9iaik7CiAKLQkJZHJtX2dlbV9mcmVlX21tYXBfb2Zmc2V0KCZv YmotPmJhc2UpOworCWlmIChvYmotPm1tLm5fcGxhY2VtZW50cyA+IDEpCisJCWtmcmVlKG9iai0+ bW0ucGxhY2VtZW50cyk7CiAKLQkJaWYgKG9iai0+b3BzLT5yZWxlYXNlKQotCQkJb2JqLT5vcHMt PnJlbGVhc2Uob2JqKTsKKwlpZiAob2JqLT5zaGFyZXNfcmVzdl9mcm9tKQorCQlpOTE1X3ZtX3Jl c3ZfcHV0KG9iai0+c2hhcmVzX3Jlc3ZfZnJvbSk7Cit9CiAKLQkJaWYgKG9iai0+bW0ubl9wbGFj ZW1lbnRzID4gMSkKLQkJCWtmcmVlKG9iai0+bW0ucGxhY2VtZW50cyk7CitzdGF0aWMgdm9pZCBf X2k5MTVfZ2VtX2ZyZWVfb2JqZWN0cyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKKwkJ CQkgICAgc3RydWN0IGxsaXN0X25vZGUgKmZyZWVkKQoreworCXN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmosICpvbjsKIAotCQlpZiAob2JqLT5zaGFyZXNfcmVzdl9mcm9tKQotCQkJaTkx NV92bV9yZXN2X3B1dChvYmotPnNoYXJlc19yZXN2X2Zyb20pOworCWxsaXN0X2Zvcl9lYWNoX2Vu dHJ5X3NhZmUob2JqLCBvbiwgZnJlZWQsIGZyZWVkKSB7CisJCW1pZ2h0X3NsZWVwKCk7CisJCWlm IChvYmotPm9wcy0+ZGVsYXllZF9mcmVlKSB7CisJCQlvYmotPm9wcy0+ZGVsYXllZF9mcmVlKG9i aik7CisJCQljb250aW51ZTsKKwkJfQorCQlfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0KG9iaik7CiAK IAkJLyogQnV0IGtlZXAgdGhlIHBvaW50ZXIgYWxpdmUgZm9yIFJDVS1wcm90ZWN0ZWQgbG9va3Vw cyAqLwogCQljYWxsX3JjdSgmb2JqLT5yY3UsIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KTsK QEAgLTMxOCw2ICszMjgsNyBAQCBzdGF0aWMgdm9pZCBpOTE1X2dlbV9mcmVlX29iamVjdChzdHJ1 Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCiAJICogd29ya2VyIGFuZCBwZXJmb3JtaW5nIGZy ZWVzIGRpcmVjdGx5IGZyb20gc3Vic2VxdWVudCBhbGxvY2F0aW9ucyBmb3IKIAkgKiBjcnVkZSBi dXQgZWZmZWN0aXZlIG1lbW9yeSB0aHJvdHRsaW5nLgogCSAqLworCiAJaWYgKGxsaXN0X2FkZCgm b2JqLT5mcmVlZCwgJmk5MTUtPm1tLmZyZWVfbGlzdCkpCiAJCXF1ZXVlX3dvcmsoaTkxNS0+d3Es ICZpOTE1LT5tbS5mcmVlX3dvcmspOwogfQpAQCAtNDEwLDYgKzQyMSw0MiBAQCBpbnQgaTkxNV9n ZW1fb2JqZWN0X3JlYWRfZnJvbV9wYWdlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmos IHU2NCBvZmZzZXQsCiAJcmV0dXJuIDA7CiB9CiAKKy8qKgorICogaTkxNV9nZW1fb2JqZWN0X2V2 aWN0YWJsZSAtIFdoZXRoZXIgb2JqZWN0IGlzIGxpa2VseSBldmljdGFibGUgYWZ0ZXIgdW5iaW5k LgorICogQG9iajogVGhlIG9iamVjdCB0byBjaGVjaworICoKKyAqIFRoaXMgZnVuY3Rpb24gY2hl Y2tzIHdoZXRoZXIgdGhlIG9iamVjdCBpcyBsaWtlbHkgdW52aWN0YWJsZSBhZnRlciB1bmJpbmQu CisgKiBJZiB0aGUgb2JqZWN0IGlzIG5vdCBsb2NrZWQgd2hlbiBjaGVja2luZywgdGhlIHJlc3Vs dCBpcyBvbmx5IGFkdmlzb3J5LgorICogSWYgdGhlIG9iamVjdCBpcyBsb2NrZWQgd2hlbiBjaGVj a2luZywgYW5kIHRoZSBmdW5jdGlvbiByZXR1cm5zIHRydWUsCisgKiB0aGVuIGFuIGV2aWN0aW9u IHNob3VsZCBpbmRlZWQgYmUgcG9zc2libGUuIEJ1dCBzaW5jZSB1bmxvY2tlZCB2bWEKKyAqIHVu cGlubmluZyBhbmQgdW5iaW5kaW5nIGlzIGN1cnJlbnRseSBwb3NzaWJsZSwgdGhlIG9iamVjdCBj YW4gYWN0dWFsbHkKKyAqIGJlY29tZSBldmljdGFibGUgZXZlbiBpZiB0aGlzIGZ1bmN0aW9uIHJl dHVybnMgZmFsc2UuCisgKgorICogUmV0dXJuOiB0cnVlIGlmIHRoZSBvYmplY3QgbWF5IGJlIGV2 aWN0YWJsZS4gRmFsc2Ugb3RoZXJ3aXNlLgorICovCitib29sIGk5MTVfZ2VtX29iamVjdF9ldmlj dGFibGUoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwlzdHJ1Y3QgaTkxNV92 bWEgKnZtYTsKKwlpbnQgcGluX2NvdW50ID0gYXRvbWljX3JlYWQoJm9iai0+bW0ucGFnZXNfcGlu X2NvdW50KTsKKworCWlmICghcGluX2NvdW50KQorCQlyZXR1cm4gdHJ1ZTsKKworCXNwaW5fbG9j aygmb2JqLT52bWEubG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeSh2bWEsICZvYmotPnZtYS5s aXN0LCBvYmpfbGluaykgeworCQlpZiAoaTkxNV92bWFfaXNfcGlubmVkKHZtYSkpIHsKKwkJCXNw aW5fdW5sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwkJCXJldHVybiBmYWxzZTsKKwkJfQorCQlpZiAo YXRvbWljX3JlYWQoJnZtYS0+cGFnZXNfY291bnQpKQorCQkJcGluX2NvdW50LS07CisJfQorCXNw aW5fdW5sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwlHRU1fV0FSTl9PTihwaW5fY291bnQgPCAwKTsK KworCXJldHVybiBwaW5fY291bnQgPT0gMDsKK30KKwogdm9pZCBpOTE1X2dlbV9pbml0X19vYmpl Y3RzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQogewogCUlOSVRfV09SSygmaTkxNS0+ bW0uZnJlZV93b3JrLCBfX2k5MTVfZ2VtX2ZyZWVfd29yayk7CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fb2JqZWN0LmgKaW5kZXggMmViZDc5NTM3YWVhLi5hZTU5MzBlMzA3ZDUg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmgKQEAgLTIwMCw2 ICsyMDAsOSBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaTkxNV9nZW1fb2JqZWN0X3RyeWxvY2soc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKIAogc3RhdGljIGlubGluZSB2b2lkIGk5MTVf Z2VtX29iamVjdF91bmxvY2soc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKIHsKKwlp ZiAob2JqLT5vcHMtPmFkanVzdF9scnUpCisJCW9iai0+b3BzLT5hZGp1c3RfbHJ1KG9iaik7CisK IAlkbWFfcmVzdl91bmxvY2sob2JqLT5iYXNlLnJlc3YpOwogfQogCkBAIC01ODcsNiArNTkwLDEy IEBAIGludCBpOTE1X2dlbV9vYmplY3RfcmVhZF9mcm9tX3BhZ2Uoc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaiwgdTY0IG9mZnNldCwKIAogYm9vbCBpOTE1X2dlbV9vYmplY3RfaXNfc2ht ZW0oY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CiAKK3ZvaWQgX19pOTE1 X2dlbV9mcmVlX29iamVjdF9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKTsKKwordm9pZCBfX2k5 MTVfZ2VtX2ZyZWVfb2JqZWN0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopOworCiti b29sIGk5MTVfZ2VtX29iamVjdF9ldmljdGFibGUoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaik7CisKICNpZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCiBzdGF0aWMgaW5saW5lIGJvb2wK IGk5MTVfZ2VtX29iamVjdF9pc191c2VycHRyKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv YmopCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0 X3R5cGVzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVz LmgKaW5kZXggZDA0N2VhMTI2MDI5Li42ODMxMzQ3NGU2YTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaAorKysgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmgKQEAgLTYzLDYgKzYzLDIwIEBA IHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0X29wcyB7CiAJCSAgICAgIGNvbnN0IHN0cnVjdCBk cm1faTkxNV9nZW1fcHdyaXRlICphcmcpOwogCiAJaW50ICgqZG1hYnVmX2V4cG9ydCkoc3RydWN0 IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKKwkvKioKKwkgKiBhZGp1c3RfbHJ1IC0gbm90 aWZ5IHRoYXQgdGhlIG1hZHZpc2UgdmFsdWUgd2FzIHVwZGF0ZWQKKwkgKiBAb2JqOiBUaGUgZ2Vt IG9iamVjdAorCSAqCisJICogVGhlIG1hZHZpc2UgdmFsdWUgbWF5IGhhdmUgYmVlbiB1cGRhdGVk LCBvciBvYmplY3Qgd2FzIHJlY2VudGx5CisJICogcmVmZXJlbmNlZCBzbyBhY3QgYWNjb3JkaW5n bHkgKFBlcmhhcHMgY2hhbmdpbmcgYW4gTFJVIGxpc3QgZXRjKS4KKwkgKi8KKwl2b2lkICgqYWRq dXN0X2xydSkoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKKwkvKioKKwkgKiBk ZWxheWVkX2ZyZWUgLSBPdmVycmlkZSB0aGUgZGVmYXVsdCBkZWxheWVkIGZyZWUgaW1wbGVtZW50 YXRpb24KKwkgKi8KKwl2b2lkICgqZGVsYXllZF9mcmVlKShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdCAqb2JqKTsKIAl2b2lkICgqcmVsZWFzZSkoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaik7CiAKIAljb25zdCBjaGFyICpuYW1lOyAvKiBmcmllbmRseSBuYW1lIGZvciBkZWJ1Zywg ZS5nLiBsb2NrZGVwIGNsYXNzZXMgKi8KQEAgLTE4NywxMiArMjAxLDE0IEBAIHN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0IHsKICNkZWZpbmUgSTkxNV9CT19BTExPQ19WT0xBVElMRSAgIEJJVCgx KQogI2RlZmluZSBJOTE1X0JPX0FMTE9DX1NUUlVDVF9QQUdFIEJJVCgyKQogI2RlZmluZSBJOTE1 X0JPX0FMTE9DX0NQVV9DTEVBUiAgQklUKDMpCisjZGVmaW5lIEk5MTVfQk9fQUxMT0NfVVNFUiAg ICAgICBCSVQoNCkKICNkZWZpbmUgSTkxNV9CT19BTExPQ19GTEFHUyAoSTkxNV9CT19BTExPQ19D T05USUdVT1VTIHwgXAogCQkJICAgICBJOTE1X0JPX0FMTE9DX1ZPTEFUSUxFIHwgXAogCQkJICAg ICBJOTE1X0JPX0FMTE9DX1NUUlVDVF9QQUdFIHwgXAotCQkJICAgICBJOTE1X0JPX0FMTE9DX0NQ VV9DTEVBUikKLSNkZWZpbmUgSTkxNV9CT19SRUFET05MWSAgICAgICAgIEJJVCg0KQotI2RlZmlu ZSBJOTE1X1RJTElOR19RVUlSS19CSVQgICAgNSAvKiB1bmtub3duIHN3aXp6bGluZzsgZG8gbm90 IHJlbGVhc2UhICovCisJCQkgICAgIEk5MTVfQk9fQUxMT0NfQ1BVX0NMRUFSIHwgXAorCQkJICAg ICBJOTE1X0JPX0FMTE9DX1VTRVIpCisjZGVmaW5lIEk5MTVfQk9fUkVBRE9OTFkgICAgICAgICBC SVQoNSkKKyNkZWZpbmUgSTkxNV9USUxJTkdfUVVJUktfQklUICAgIDYgLyogdW5rbm93biBzd2l6 emxpbmc7IGRvIG5vdCByZWxlYXNlISAqLwogCiAJLyoKIAkgKiBJcyB0aGUgb2JqZWN0IHRvIGJl IG1hcHBlZCBhcyByZWFkLW9ubHkgdG8gdGhlIEdQVQpAQCAtMzEwLDYgKzMyNiwxMSBAQCBzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCB7CiAJCWJvb2wgZGlydHk6MTsKIAl9IG1tOwogCisJc3Ry dWN0IHsKKwkJc3RydWN0IHNnX3RhYmxlICpjYWNoZWRfaW9fc3Q7CisJCWJvb2wgY3JlYXRlZDox OworCX0gdHRtOworCiAJLyoqIFJlY29yZCBvZiBhZGRyZXNzIGJpdCAxNyBvZiBlYWNoIHBhZ2Ug YXQgbGFzdCB1bmJpbmQuICovCiAJdW5zaWduZWQgbG9uZyAqYml0XzE3OwogCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMKaW5kZXggZjI1ZTY2NDZjNWI3Li5kMWYx ODQwNTQwZGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9y ZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMK QEAgLTE4LDExICsxOCw3IEBAIHZvaWQgaTkxNV9nZW1fb2JqZWN0X2luaXRfbWVtb3J5X3JlZ2lv bihzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCiAJbXV0ZXhfbG9jaygmbWVtLT5v YmplY3RzLmxvY2spOwogCi0JaWYgKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FMTE9DX1ZPTEFUSUxF KQotCQlsaXN0X2FkZCgmb2JqLT5tbS5yZWdpb25fbGluaywgJm1lbS0+b2JqZWN0cy5wdXJnZWFi bGUpOwotCWVsc2UKLQkJbGlzdF9hZGQoJm9iai0+bW0ucmVnaW9uX2xpbmssICZtZW0tPm9iamVj dHMubGlzdCk7Ci0KKwlsaXN0X2FkZCgmb2JqLT5tbS5yZWdpb25fbGluaywgJm1lbS0+b2JqZWN0 cy5saXN0KTsKIAltdXRleF91bmxvY2soJm1lbS0+b2JqZWN0cy5sb2NrKTsKIH0KIApkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uZmJiMzJiMTQ4YmUzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCkBAIC0wLDAgKzEsNTQwIEBACisvLyBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUCisvKgorICogQ29weXJpZ2h0IMKpIDIwMjEgSW50ZWwg Q29ycG9yYXRpb24KKyAqLworCisjaW5jbHVkZSA8ZHJtL3R0bS90dG1fYm9fZHJpdmVyLmg+Cisj aW5jbHVkZSA8ZHJtL3R0bS90dG1fcGxhY2VtZW50Lmg+CisKKyNpbmNsdWRlICJpOTE1X2Rydi5o IgorI2luY2x1ZGUgImludGVsX21lbW9yeV9yZWdpb24uaCIKKyNpbmNsdWRlICJpbnRlbF9yZWdp b25fdHRtLmgiCisKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1fb2JqZWN0LmgiCisjaW5jbHVkZSAi Z2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIgorI2luY2x1ZGUgImdlbS9pOTE1X2dlbV90dG0uaCIKKwor I2RlZmluZSBJOTE1X1BMX0xNRU0wIFRUTV9QTF9QUklWCisjZGVmaW5lIEk5MTVfUExfU1lTVEVN IFRUTV9QTF9TWVNURU0KKyNkZWZpbmUgSTkxNV9QTF9TVE9MRU4gVFRNX1BMX1ZSQU0KKyNkZWZp bmUgSTkxNV9QTF9HR1RUIFRUTV9QTF9UVAorCisjZGVmaW5lIEk5MTVfVFRNX1BSSU9fUFVSR0Ug ICAgIDAKKyNkZWZpbmUgSTkxNV9UVE1fUFJJT19OT19QQUdFUyAgMQorI2RlZmluZSBJOTE1X1RU TV9QUklPX0hBU19QQUdFUyAyCisKKy8qKgorICogc3RydWN0IGk5MTVfdHRtX3R0IC0gVFRNIHBh Z2UgdmVjdG9yIHdpdGggYWRkaXRpb25hbCBwcml2YXRlIGluZm9ybWF0aW9uCisgKiBAdHRtOiBU aGUgYmFzZSBUVE0gcGFnZSB2ZWN0b3IuCisgKiBAZGV2OiBUaGUgc3RydWN0IGRldmljZSB1c2Vk IGZvciBkbWEgbWFwcGluZyBhbmQgdW5tYXBwaW5nLgorICogQGNhY2hlZF9zdDogVGhlIGNhY2hl ZCBzY2F0dGVyLWdhdGhlciB0YWJsZS4KKyAqCisgKiBOb3RlIHRoYXQgRE1BIG1heSBiZSBnb2lu ZyBvbiByaWdodCB1cCB0byB0aGUgcG9pbnQgd2hlcmUgdGhlIHBhZ2UtCisgKiB2ZWN0b3IgaXMg dW5wb3B1bGF0ZWQgaW4gZGVsYXllZCBkZXN0cm95LiBIZW5jZSBrZWVwIHRoZQorICogc2NhdHRl ci1nYXRoZXIgdGFibGUgbWFwcGVkIGFuZCBjYWNoZWQgdXAgdG8gdGhhdCBwb2ludC4gVGhpcyBp cworICogZGlmZmVyZW50IGZyb20gdGhlIGNhY2hlZCBnZW0gb2JqZWN0IGlvIHNjYXR0ZXItZ2F0 aGVyIHRhYmxlIHdoaWNoCisgKiBkb2Vzbid0IGhhdmUgYW4gYXNzb2NpYXRlZCBkbWEgbWFwcGlu Zy4KKyAqLworc3RydWN0IGk5MTVfdHRtX3R0IHsKKwlzdHJ1Y3QgdHRtX3R0IHR0bTsKKwlzdHJ1 Y3QgZGV2aWNlICpkZXY7CisJc3RydWN0IHNnX3RhYmxlICpjYWNoZWRfc3Q7Cit9OworCitzdGF0 aWMgY29uc3Qgc3RydWN0IHR0bV9wbGFjZSBsbWVtMF9zeXNfcGxhY2VtZW50X2ZsYWdzW10gPSB7 CisJeworCQkuZnBmbiA9IDAsCisJCS5scGZuID0gMCwKKwkJLm1lbV90eXBlID0gSTkxNV9QTF9M TUVNMCwKKwkJLmZsYWdzID0gMCwKKwl9LCB7CisJCS5mcGZuID0gMCwKKwkJLmxwZm4gPSAwLAor CQkubWVtX3R5cGUgPSBJOTE1X1BMX1NZU1RFTSwKKwkJLmZsYWdzID0gMCwKKwl9Cit9OworCitz dGF0aWMgc3RydWN0IHR0bV9wbGFjZW1lbnQgaTkxNV9sbWVtMF9wbGFjZW1lbnQgPSB7CisJLm51 bV9wbGFjZW1lbnQgPSAxLAorCS5wbGFjZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFn c1swXSwKKwkubnVtX2J1c3lfcGxhY2VtZW50ID0gMSwKKwkuYnVzeV9wbGFjZW1lbnQgPSAmbG1l bTBfc3lzX3BsYWNlbWVudF9mbGFnc1swXSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgdHRtX3BsYWNl bWVudCBpOTE1X3N5c19wbGFjZW1lbnQgPSB7CisJLm51bV9wbGFjZW1lbnQgPSAxLAorCS5wbGFj ZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFnc1sxXSwKKwkubnVtX2J1c3lfcGxhY2Vt ZW50ID0gMSwKKwkuYnVzeV9wbGFjZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFnc1sx XSwKK307CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX2FkanVzdF9scnUoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaik7CisKK3N0YXRpYyBzdHJ1Y3QgdHRtX3R0ICppOTE1X3R0bV90dF9j cmVhdGUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKKwkJCQkJIHVpbnQzMl90IHBhZ2Vf ZmxhZ3MpCit7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICptYW4gPQorCQl0dG1fbWFu YWdlcl90eXBlKGJvLT5iZGV2LCBiby0+bWVtLm1lbV90eXBlKTsKKwlzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKwlzdHJ1Y3QgaTkxNV90dG1f dHQgKmk5MTVfdHQ7CisJaW50IHJldDsKKworCWk5MTVfdHQgPSBremFsbG9jKHNpemVvZigqaTkx NV90dCksIEdGUF9LRVJORUwpOworCWlmICghaTkxNV90dCkKKwkJcmV0dXJuIE5VTEw7CisKKwlp ZiAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ1BVX0NMRUFSICYmCisJICAgIG1hbi0+dXNl X3R0KQorCQlwYWdlX2ZsYWdzIHw9IFRUTV9QQUdFX0ZMQUdfWkVST19BTExPQzsKKworCXJldCA9 IHR0bV90dF9pbml0KCZpOTE1X3R0LT50dG0sIGJvLCBwYWdlX2ZsYWdzLCB0dG1fd3JpdGVfY29t YmluZWQpOworCWlmIChyZXQpIHsKKwkJa2ZyZWUoaTkxNV90dCk7CisJCXJldHVybiBOVUxMOwor CX0KKworCWk5MTVfdHQtPmRldiA9IG9iai0+YmFzZS5kZXYtPmRldjsKKworCXJldHVybiAmaTkx NV90dC0+dHRtOworfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV90dF91bnBvcHVsYXRlKHN0cnVj dCB0dG1fZGV2aWNlICpiZGV2LCBzdHJ1Y3QgdHRtX3R0ICp0dG0pCit7CisJc3RydWN0IGk5MTVf dHRtX3R0ICppOTE1X3R0ID0gY29udGFpbmVyX29mKHR0bSwgdHlwZW9mKCppOTE1X3R0KSwgdHRt KTsKKworCWlmIChpOTE1X3R0LT5jYWNoZWRfc3QpIHsKKwkJZG1hX3VubWFwX3NndGFibGUoaTkx NV90dC0+ZGV2LCBpOTE1X3R0LT5jYWNoZWRfc3QsCisJCQkJICBETUFfQklESVJFQ1RJT05BTCwg MCk7CisJCXNnX2ZyZWVfdGFibGUoaTkxNV90dC0+Y2FjaGVkX3N0KTsKKwkJa2ZyZWUoaTkxNV90 dC0+Y2FjaGVkX3N0KTsKKwkJaTkxNV90dC0+Y2FjaGVkX3N0ID0gTlVMTDsKKwl9CisJdHRtX3Bv b2xfZnJlZSgmYmRldi0+cG9vbCwgdHRtKTsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fdHRf ZGVzdHJveShzdHJ1Y3QgdHRtX2RldmljZSAqYmRldiwgc3RydWN0IHR0bV90dCAqdHRtKQorewor CXN0cnVjdCBpOTE1X3R0bV90dCAqaTkxNV90dCA9IGNvbnRhaW5lcl9vZih0dG0sIHR5cGVvZigq aTkxNV90dCksIHR0bSk7CisKKwl0dG1fdHRfZGVzdHJveV9jb21tb24oYmRldiwgdHRtKTsKKwlr ZnJlZShpOTE1X3R0KTsKK30KKworc3RhdGljIGJvb2wgaTkxNV90dG1fZXZpY3Rpb25fdmFsdWFi bGUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKKwkJCQkgICAgICAgY29uc3Qgc3RydWN0 IHR0bV9wbGFjZSAqcGxhY2UpCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9 IGk5MTVfdHRtX3RvX2dlbShibyk7CisKKwkvKiBXaWxsIGRvIGZvciBub3cuIE91ciBwaW5uZWQg b2JqZWN0cyBhcmUgc3RpbGwgb24gVFRNJ3MgTFJVIGxpc3RzICovCisJaWYgKCFpOTE1X2dlbV9v YmplY3RfZXZpY3RhYmxlKG9iaikpCisJCXJldHVybiBmYWxzZTsKKworCS8qIFRoaXMgaXNuJ3Qg dmFsaWQgd2l0aCBhIGJ1ZGR5IGFsbG9jYXRvciAqLworCXJldHVybiB0dG1fYm9fZXZpY3Rpb25f dmFsdWFibGUoYm8sIHBsYWNlKTsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fZXZpY3RfZmxh Z3Moc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKKwkJCQkgc3RydWN0IHR0bV9wbGFjZW1l bnQgKnBsYWNlbWVudCkKK3sKKwkqcGxhY2VtZW50ID0gaTkxNV9zeXNfcGxhY2VtZW50OworfQor CitzdGF0aWMgaW50IGk5MTVfdHRtX21vdmVfbm90aWZ5KHN0cnVjdCB0dG1fYnVmZmVyX29iamVj dCAqYm8pCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3Rv X2dlbShibyk7CisJaW50IHJldDsKKworCXJldCA9IGk5MTVfZ2VtX29iamVjdF91bmJpbmQob2Jq LCBJOTE1X0dFTV9PQkpFQ1RfVU5CSU5EX0FDVElWRSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJl dDsKKworCXJldCA9IF9faTkxNV9nZW1fb2JqZWN0X3B1dF9wYWdlcyhvYmopOworCWlmIChyZXQp CisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1f ZnJlZV9jYWNoZWRfaW9fc3Qoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwlp ZiAob2JqLT50dG0uY2FjaGVkX2lvX3N0KSB7CisJCXNnX2ZyZWVfdGFibGUob2JqLT50dG0uY2Fj aGVkX2lvX3N0KTsKKwkJa2ZyZWUob2JqLT50dG0uY2FjaGVkX2lvX3N0KTsKKwkJb2JqLT50dG0u Y2FjaGVkX2lvX3N0ID0gTlVMTDsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX3B1cmdl KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0bV9idWZmZXJf b2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCXN0cnVjdCB0dG1fb3BlcmF0aW9u X2N0eCBjdHggPSB7CisJCS5pbnRlcnJ1cHRpYmxlID0gdHJ1ZSwKKwkJLm5vX3dhaXRfZ3B1ID0g ZmFsc2UsCisJfTsKKwlzdHJ1Y3QgdHRtX3BsYWNlbWVudCBwbGFjZSA9IHt9OworCWludCByZXQ7 CisKKwlpZiAob2JqLT5tbS5tYWR2ID09IF9fSTkxNV9NQURWX1BVUkdFRCkKKwkJcmV0dXJuOwor CisJLyogVFRNJ3MgcHVyZ2UgaW50ZXJmYWNlLiBOb3RlIHRoYXQgd2UgbWlnaHQgYmUgcmVlbnRl cmluZy4gKi8KKwlyZXQgPSB0dG1fYm9fdmFsaWRhdGUoYm8sICZwbGFjZSwgJmN0eCk7CisKKwlp ZiAoIXJldCkgeworCQlpOTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChvYmopOworCQlvYmotPm1t Lm1hZHYgPSBfX0k5MTVfTUFEVl9QVVJHRUQ7CisJfQorfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0 bV9zd2FwX25vdGlmeShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCXN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCWludCByZXQg PSBpOTE1X3R0bV9tb3ZlX25vdGlmeShibyk7CisKKwlHRU1fV0FSTl9PTihyZXQpOworCUdFTV9X QVJOX09OKG9iai0+dHRtLmNhY2hlZF9pb19zdCk7CisJaWYgKCFyZXQgJiYgb2JqLT5tbS5tYWR2 ICE9IEk5MTVfTUFEVl9XSUxMTkVFRCkKKwkJaTkxNV90dG1fcHVyZ2Uob2JqKTsKK30KKworc3Rh dGljIHZvaWQgaTkxNV90dG1fZGVsZXRlX21lbV9ub3RpZnkoc3RydWN0IHR0bV9idWZmZXJfb2Jq ZWN0ICpibykKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1f dG9fZ2VtKGJvKTsKKworCWlmIChsaWtlbHkob2JqKSkgeworCQkvKiBUaGlzIHJlbGVhc2VzIGFs bCBnZW0gb2JqZWN0IGJpbmRpbmdzIHRvIHRoZSBiYWNrZW5kLiAqLworCQlfX2k5MTVfZ2VtX2Zy ZWVfb2JqZWN0KG9iaik7CisJfQorfQorCitzdGF0aWMgc3RydWN0IGludGVsX21lbW9yeV9yZWdp b24gKgoraTkxNV90dG1fcmVnaW9uKHN0cnVjdCB0dG1fZGV2aWNlICpiZGV2LCBpbnQgdHRtX21l bV90eXBlKQoreworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1ID0gY29udGFpbmVyX29m KGJkZXYsIHR5cGVvZigqaTkxNSksIGJkZXYpOworCisJLyogVGhlcmUncyBzb21lIHJvb20gZm9y IG9wdGltaXphdGlvbiBoZXJlLi4uICovCisJR0VNX0JVR19PTih0dG1fbWVtX3R5cGUgIT0gSTkx NV9QTF9TWVNURU0gJiYKKwkJICAgdHRtX21lbV90eXBlIDwgSTkxNV9QTF9MTUVNMCk7CisJaWYg KHR0bV9tZW1fdHlwZSA9PSBJOTE1X1BMX1NZU1RFTSkKKwkJcmV0dXJuIGludGVsX21lbW9yeV9y ZWdpb25fbG9va3VwKGk5MTUsIElOVEVMX01FTU9SWV9TWVNURU0sCisJCQkJCQkgIDApOworCisJ cmV0dXJuIGludGVsX21lbW9yeV9yZWdpb25fbG9va3VwKGk5MTUsIElOVEVMX01FTU9SWV9MT0NB TCwKKwkJCQkJICB0dG1fbWVtX3R5cGUgLSBJOTE1X1BMX0xNRU0wKTsKK30KKworc3RhdGljIHN0 cnVjdCBzZ190YWJsZSAqaTkxNV90dG1fdHRfZ2V0X3N0KHN0cnVjdCB0dG1fdHQgKnR0bSkKK3sK KwlzdHJ1Y3QgaTkxNV90dG1fdHQgKmk5MTVfdHQgPSBjb250YWluZXJfb2YodHRtLCB0eXBlb2Yo Kmk5MTVfdHQpLCB0dG0pOworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7CisJc3RydWN0IHNnX3Rh YmxlICpzdDsKKwlpbnQgcmV0OworCisJaWYgKGk5MTVfdHQtPmNhY2hlZF9zdCkKKwkJcmV0dXJu IGk5MTVfdHQtPmNhY2hlZF9zdDsKKworCXN0ID0ga3phbGxvYyhzaXplb2YoKnN0KSwgR0ZQX0tF Uk5FTCk7CisJaWYgKCFzdCkKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwlzZyA9IF9f c2dfYWxsb2NfdGFibGVfZnJvbV9wYWdlcworCQkoc3QsIHR0bS0+cGFnZXMsIHR0bS0+bnVtX3Bh Z2VzLCAwLAorCQkgKHVuc2lnbmVkIGxvbmcpdHRtLT5udW1fcGFnZXMgPDwgUEFHRV9TSElGVCwK KwkJIGk5MTVfc2dfc2VnbWVudF9zaXplKCksIE5VTEwsIDAsIEdGUF9LRVJORUwpOworCWlmIChJ U19FUlIoc2cpKSB7CisJCWtmcmVlKHN0KTsKKwkJcmV0dXJuIEVSUl9DQVNUKHNnKTsKKwl9CisK KwlyZXQgPSBkbWFfbWFwX3NndGFibGUoaTkxNV90dC0+ZGV2LCBzdCwgRE1BX0JJRElSRUNUSU9O QUwsIDApOworCWlmIChyZXQpIHsKKwkJc2dfZnJlZV90YWJsZShzdCk7CisJCWtmcmVlKHN0KTsK KwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisKKwlpOTE1X3R0LT5jYWNoZWRfc3QgPSBzdDsK KwlyZXR1cm4gc3Q7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2dfdGFibGUgKgoraTkxNV90dG1fcmVz b3VyY2VfZ2V0X3N0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgc3RydWN0 IHR0bV9yZXNvdXJjZSAqcmVzKQoreworCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBp OTE1X2dlbV90b190dG0ob2JqKTsKKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9 CisJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIHJlcy0+bWVtX3R5cGUpOworCisJaWYgKG1h bi0+dXNlX3R0KQorCQlyZXR1cm4gaTkxNV90dG1fdHRfZ2V0X3N0KGJvLT50dG0pOworCisJcmV0 dXJuIGludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChvYmotPm1tLnJlZ2lvbiwgcmVzLT5tbV9u b2RlKTsKK30KKworc3RhdGljIGludCBpOTE1X3R0bV9tb3ZlKHN0cnVjdCB0dG1fYnVmZmVyX29i amVjdCAqYm8sIGJvb2wgZXZpY3QsCisJCQkgc3RydWN0IHR0bV9vcGVyYXRpb25fY3R4ICpjdHgs CisJCQkgc3RydWN0IHR0bV9yZXNvdXJjZSAqZHN0X21lbSwKKwkJCSBzdHJ1Y3QgdHRtX3BsYWNl ICpob3ApCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3Rv X2dlbShibyk7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICpkc3RfbWFuID0KKwkJdHRt X21hbmFnZXJfdHlwZShiby0+YmRldiwgZHN0X21lbS0+bWVtX3R5cGUpOworCXN0cnVjdCB0dG1f cmVzb3VyY2VfbWFuYWdlciAqc3JjX21hbiA9CisJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYs IGJvLT5tZW0ubWVtX3R5cGUpOworCXN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpkc3RfcmVn LCAqc3JjX3JlZzsKKwl1bmlvbiB7CisJCXN0cnVjdCB0dG1fa21hcF9pdGVyX3R0IHR0OworCQlz dHJ1Y3QgdHRtX2ttYXBfaXRlcl9pb21hcCBpbzsKKwl9IF9kc3RfaXRlciwgX3NyY19pdGVyOwor CXN0cnVjdCB0dG1fa21hcF9pdGVyICpkc3RfaXRlciwgKnNyY19pdGVyOworCXN0cnVjdCBzZ190 YWJsZSAqZHN0X3N0OworCWludCByZXQ7CisKKwlkc3RfcmVnID0gaTkxNV90dG1fcmVnaW9uKGJv LT5iZGV2LCBkc3RfbWVtLT5tZW1fdHlwZSk7CisJc3JjX3JlZyA9IGk5MTVfdHRtX3JlZ2lvbihi by0+YmRldiwgYm8tPm1lbS5tZW1fdHlwZSk7CisJR0VNX0JVR19PTighZHN0X3JlZyB8fCAhc3Jj X3JlZyk7CisKKwkvKiBTeW5jIGZvciBub3cuIFdlIGNvdWxkIGRvIHRoZSBhY3R1YWwgY29weSBh c3luYy4gKi8KKwlyZXQgPSB0dG1fYm9fd2FpdF9jdHgoYm8sIGN0eCk7CisJaWYgKHJldCkKKwkJ cmV0dXJuIHJldDsKKworCXJldCA9IGk5MTVfdHRtX21vdmVfbm90aWZ5KGJvKTsKKwlpZiAocmV0 KQorCQlyZXR1cm4gcmV0OworCisJaWYgKG9iai0+bW0ubWFkdiAhPSBJOTE1X01BRFZfV0lMTE5F RUQpIHsKKwkJaTkxNV90dG1fcHVyZ2Uob2JqKTsKKwkJdHRtX3Jlc291cmNlX2ZyZWUoYm8sIGRz dF9tZW0pOworCQlyZXR1cm4gMDsKKwl9CisKKwkvKiBQb3B1bGF0ZSB0dG0gd2l0aCBwYWdlcyBp ZiBuZWVkZWQuIFR5cGljYWxseSBzeXN0ZW0gbWVtb3J5LiAqLworCWlmIChiby0+dHRtICYmIChk c3RfbWFuLT51c2VfdHQgfHwKKwkJCShiby0+dHRtLT5wYWdlX2ZsYWdzICYgVFRNX1BBR0VfRkxB R19TV0FQUEVEKSkpIHsKKwkJcmV0ID0gdHRtX3R0X3BvcHVsYXRlKGJvLT5iZGV2LCBiby0+dHRt LCBjdHgpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwlkc3Rfc3QgPSBpOTE1 X3R0bV9yZXNvdXJjZV9nZXRfc3Qob2JqLCBkc3RfbWVtKTsKKwlpZiAoSVNfRVJSKGRzdF9zdCkp CisJCXJldHVybiBQVFJfRVJSKGRzdF9zdCk7CisKKwkvKiBJZiB3ZSBzdGFydCBtYXBwaW5nIEdH VFQsIHdlIGNhbiBubyBsb25nZXIgdXNlIG1hbjo6dXNlX3R0IGhlcmUuICovCisJZHN0X2l0ZXIg PSBkc3RfbWFuLT51c2VfdHQgPworCQl0dG1fa21hcF9pdGVyX3R0X2luaXQoJl9kc3RfaXRlci50 dCwgYm8tPnR0bSkgOgorCQl0dG1fa21hcF9pdGVyX2lvbWFwX2luaXQoJl9kc3RfaXRlci5pbywg JmRzdF9yZWctPmlvbWFwLAorCQkJCQkgZHN0X3N0LCBkc3RfcmVnLT5yZWdpb24uc3RhcnQpOwor CisJc3JjX2l0ZXIgPSBzcmNfbWFuLT51c2VfdHQgPworCQl0dG1fa21hcF9pdGVyX3R0X2luaXQo Jl9zcmNfaXRlci50dCwgYm8tPnR0bSkgOgorCQl0dG1fa21hcF9pdGVyX2lvbWFwX2luaXQoJl9z cmNfaXRlci5pbywgJnNyY19yZWctPmlvbWFwLAorCQkJCQkgb2JqLT50dG0uY2FjaGVkX2lvX3N0 LAorCQkJCQkgc3JjX3JlZy0+cmVnaW9uLnN0YXJ0KTsKKworCXR0bV9tb3ZlX21lbWNweShibywg ZHN0X21lbS0+bnVtX3BhZ2VzLCBkc3RfaXRlciwgc3JjX2l0ZXIpOworCXR0bV9ib19tb3ZlX3N5 bmNfY2xlYW51cChibywgZHN0X21lbSk7CisJaTkxNV90dG1fZnJlZV9jYWNoZWRfaW9fc3Qob2Jq KTsKKworCWlmICghZHN0X21hbi0+dXNlX3R0KQorCQlvYmotPnR0bS5jYWNoZWRfaW9fc3QgPSBk c3Rfc3Q7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCB0dG1fZGV2aWNlX2Z1bmNz IGk5MTVfdHRtX2JvX2RyaXZlciA9IHsKKwkudHRtX3R0X2NyZWF0ZSA9IGk5MTVfdHRtX3R0X2Ny ZWF0ZSwKKwkudHRtX3R0X3VucG9wdWxhdGUgPSBpOTE1X3R0bV90dF91bnBvcHVsYXRlLAorCS50 dG1fdHRfZGVzdHJveSA9IGk5MTVfdHRtX3R0X2Rlc3Ryb3ksCisJLmV2aWN0aW9uX3ZhbHVhYmxl ID0gaTkxNV90dG1fZXZpY3Rpb25fdmFsdWFibGUsCisJLmV2aWN0X2ZsYWdzID0gaTkxNV90dG1f ZXZpY3RfZmxhZ3MsCisJLm1vdmUgPSBpOTE1X3R0bV9tb3ZlLAorCS5zd2FwX25vdGlmeSA9IGk5 MTVfdHRtX3N3YXBfbm90aWZ5LAorCS5kZWxldGVfbWVtX25vdGlmeSA9IGk5MTVfdHRtX2RlbGV0 ZV9tZW1fbm90aWZ5LAorfTsKKworLyoqCisgKiBpOTE1X3R0bV9kcml2ZXIgLSBSZXR1cm4gYSBw b2ludGVyIHRvIHRoZSBUVE0gZGV2aWNlIGZ1bmNzCisgKgorICogUmV0dXJuOiBQb2ludGVyIHRv IHN0YXRpY2FsbHkgYWxsb2NhdGVkIFRUTSBkZXZpY2UgZnVuY3MuCisgKi8KK3N0cnVjdCB0dG1f ZGV2aWNlX2Z1bmNzICppOTE1X3R0bV9kcml2ZXIodm9pZCkKK3sKKwlyZXR1cm4gJmk5MTVfdHRt X2JvX2RyaXZlcjsKK30KKworc3RhdGljIGludCBpOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRy bV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJv ID0gaTkxNV9nZW1fdG9fdHRtKG9iaik7CisJc3RydWN0IHR0bV9vcGVyYXRpb25fY3R4IGN0eCA9 IHsKKwkJLmludGVycnVwdGlibGUgPSB0cnVlLAorCQkubm9fd2FpdF9ncHUgPSBmYWxzZSwKKwl9 OworCXN0cnVjdCBzZ190YWJsZSAqc3Q7CisJaW50IHJldDsKKworCS8qIE1vdmUgdG8gdGhlIHJl cXVlc3RlZCBwbGFjZW1lbnQuICovCisJcmV0ID0gdHRtX2JvX3ZhbGlkYXRlKGJvLCAmaTkxNV9s bWVtMF9wbGFjZW1lbnQsICZjdHgpOworCWlmIChyZXQpCisJCXJldHVybiByZXQgPT0gLUVOT1NQ QyA/IC1FTlhJTyA6IHJldDsKKworCS8qIE9iamVjdCBlaXRoZXIgaGFzIGEgcGFnZSB2ZWN0b3Ig b3IgaXMgYW4gaW9tZW0gb2JqZWN0ICovCisJc3QgPSBiby0+dHRtID8gaTkxNV90dG1fdHRfZ2V0 X3N0KGJvLT50dG0pIDogb2JqLT50dG0uY2FjaGVkX2lvX3N0OworCWlmIChJU19FUlIoc3QpKQor CQlyZXR1cm4gUFRSX0VSUihzdCk7CisKKwlfX2k5MTVfZ2VtX29iamVjdF9zZXRfcGFnZXMob2Jq LCBzdCwgaTkxNV9zZ19kbWFfc2l6ZXMoc3QtPnNnbCkpOworCisJaTkxNV90dG1fYWRqdXN0X2xy dShvYmopOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fcHV0X3Bh Z2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgICAgICAgc3RydWN0IHNn X3RhYmxlICpzdCkKK3sKKwkvKgorCSAqIFdlJ3JlIGN1cnJlbnRseSBub3QgY2FsbGVkIGZyb20g YSBzaHJpbmtlciwgc28gcHV0X3BhZ2VzKCkKKwkgKiB0eXBpY2FsbHkgbWVhbnMgdGhlIG9iamVj dCBpcyBhYm91dCB0byBkZXN0cm95ZWQsIG9yIGNhbGxlZAorCSAqIGZyb20gbW92ZV9ub3RpZnko KS4gU28ganVzdCBhdm9pZCBkb2luZyBtdWNoIGZvciBub3cuCisJICogSWYgdGhlIG9iamVjdCBp cyBub3QgZGVzdHJveWVkIG5leHQsIFRoZSBUVE0gZXZpY3Rpb24gbG9naWMKKwkgKiBhbmQgc2hy aW5rZXJzIHdpbGwgbW92ZSBpdCBvdXQgaWYgbmVlZGVkLgorCSAqLworCisJaTkxNV90dG1fYWRq dXN0X2xydShvYmopOworfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV9hZGp1c3RfbHJ1KHN0cnVj dCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0 ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCisJLyoKKwkgKiBEb24ndCBtYW5pcHVsYXRl IHRoZSBUVE0gTFJVcyB3aGlsZSBpbiBUVE0gYm8gZGVzdHJ1Y3Rpb24uCisJICogV2UncmUgY2Fs bGVkIHRocm91Z2ggaTkxNV90dG1fZGVsZXRlX21lbV9ub3RpZnkoKS4KKwkgKi8KKwlpZiAoIWty ZWZfcmVhZCgmYm8tPmtyZWYpKQorCQlyZXR1cm47CisKKwkvKgorCSAqIFB1dCBvbiB0aGUgY29y cmVjdCBMUlUgbGlzdCBkZXBlbmRpbmcgb24gdGhlIE1BRFYgc3RhdHVzCisJICovCisJc3Bpbl9s b2NrKCZiby0+YmRldi0+bHJ1X2xvY2spOworCWlmIChvYmotPm1tLm1hZHYgIT0gSTkxNV9NQURW X1dJTExORUVEKSB7CisJCWJvLT5wcmlvcml0eSA9IEk5MTVfVFRNX1BSSU9fUFVSR0U7CisJfSBl bHNlIGlmICghaTkxNV9nZW1fb2JqZWN0X2hhc19wYWdlcyhvYmopKSB7CisJCWlmIChiby0+cHJp b3JpdHkgPCBJOTE1X1RUTV9QUklPX0hBU19QQUdFUykKKwkJCWJvLT5wcmlvcml0eSA9IEk5MTVf VFRNX1BSSU9fSEFTX1BBR0VTOworCX0gZWxzZSB7CisJCWlmIChiby0+cHJpb3JpdHkgPiBJOTE1 X1RUTV9QUklPX05PX1BBR0VTKQorCQkJYm8tPnByaW9yaXR5ID0gSTkxNV9UVE1fUFJJT19OT19Q QUdFUzsKKwl9CisKKwl0dG1fYm9fbW92ZV90b19scnVfdGFpbChibywgJmJvLT5tZW0sIE5VTEwp OworCXNwaW5fdW5sb2NrKCZiby0+YmRldi0+bHJ1X2xvY2spOworfQorCisvKgorICogVFRNLWJh Y2tlZCBnZW0gb2JqZWN0IGRlc3RydWN0aW9uIHJlcXVpcmVzIHNvbWUgY2xhcmlmaWNhdGlvbi4K KyAqIEJhc2ljYWxseSB3ZSBoYXZlIHR3byBwb3NzaWJpbGl0aWVzIGhlcmUuIFdlIGNhbiBlaXRo ZXIgcmVseSBvbiB0aGUKKyAqIGk5MTUgZGVsYXllZCBkZXN0cnVjdGlvbiBhbmQgcHV0IHRoZSBU VE0gb2JqZWN0IHdoZW4gdGhlIG9iamVjdAorICogaXMgaWRsZS4gVGhpcyB3b3VsZCBiZSBkZXRl Y3RlZCBieSBUVE0gd2hpY2ggd291bGQgYnlwYXNzIHRoZQorICogVFRNIGRlbGF5ZWQgZGVzdHJv eSBoYW5kbGluZy4gVGhlIG90aGVyIGFwcHJvYWNoIGlzIHRvIHB1dCB0aGUgVFRNCisgKiBvYmpl Y3QgZWFybHkgYW5kIHJlbHkgb24gdGhlIFRUTSBkZXN0cm95ZWQgaGFuZGxpbmcsIGFuZCB0aGVu IGZyZWUKKyAqIHRoZSBsZWZ0b3ZlciBwYXJ0cyBvZiB0aGUgR0VNIG9iamVjdCBvbmNlIFRUTSdz IGRlc3Ryb3llZCBsaXN0IGhhbmRsaW5nIGlzCisgKiBjb21wbGV0ZS4gRm9yIG5vdywgd2UgcmVs eSBvbiB0aGUgbGF0dGVyIGZvciB0d28gcmVhc29uczoKKyAqIGEpIFRUTSBjYW4gZXZpY3QgYW4g b2JqZWN0IGV2ZW4gd2hlbiBpdCdzIG9uIHRoZSBkZWxheWVkIGRlc3Ryb3kgbGlzdCwKKyAqIHdo aWNoIGluIHRoZW9yeSBhbGxvd3MgZm9yIGNvbXBsZXRlIGV2aWN0aW9uLgorICogYikgVGhlcmUg aXMgd29yayBnb2luZyBvbiBpbiBUVE0gdG8gYWxsb3cgZnJlZWluZyBhbiBvYmplY3QgZXZlbiB3 aGVuCisgKiBpdCdzIG5vdCBpZGxlLCBhbmQgdXNpbmcgdGhlIFRUTSBkZXN0cm95ZWQgbGlzdCBo YW5kbGluZyBjb3VsZCBoZWxwIHVzCisgKiBiZW5lZml0IGZyb20gdGhhdC4KKyAqLworc3RhdGlj IHZvaWQgaTkxNV90dG1fZGVsYXllZF9mcmVlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv YmopCit7CisJaWYgKG9iai0+dHRtLmNyZWF0ZWQpIHsKKwkJdHRtX2JvX3B1dChpOTE1X2dlbV90 b190dG0ob2JqKSk7CisJfSBlbHNlIHsKKwkJX19pOTE1X2dlbV9mcmVlX29iamVjdChvYmopOwor CQljYWxsX3JjdSgmb2JqLT5yY3UsIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KTsKKwl9Cit9 CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgaTkxNV9nZW1f dHRtX29ial9vcHMgPSB7CisJLm5hbWUgPSAiaTkxNV9nZW1fb2JqZWN0X3R0bSIsCisJLmZsYWdz ID0gSTkxNV9HRU1fT0JKRUNUX0hBU19JT01FTSwKKworCS5nZXRfcGFnZXMgPSBpOTE1X3R0bV9n ZXRfcGFnZXMsCisJLnB1dF9wYWdlcyA9IGk5MTVfdHRtX3B1dF9wYWdlcywKKwkudHJ1bmNhdGUg PSBpOTE1X3R0bV9wdXJnZSwKKwkuYWRqdXN0X2xydSA9IGk5MTVfdHRtX2FkanVzdF9scnUsCisJ LmRlbGF5ZWRfZnJlZSA9IGk5MTVfdHRtX2RlbGF5ZWRfZnJlZSwKK307CisKK3ZvaWQgaTkxNV90 dG1fYm9fZGVzdHJveShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCXN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCisJaTkxNV9n ZW1fb2JqZWN0X3JlbGVhc2VfbWVtb3J5X3JlZ2lvbihvYmopOworCWlmIChvYmotPnR0bS5jcmVh dGVkKQorCQljYWxsX3JjdSgmb2JqLT5yY3UsIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KTsK K30KKworLyoqCisgKiBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdCAtIEluaXRpYWxpemUgYSB0 dG0tYmFja2VkIGk5MTUgZ2VtIG9iamVjdAorICogQG1lbTogVGhlIGluaXRpYWwgbWVtb3J5IHJl Z2lvbiBmb3IgdGhlIG9iamVjdC4KKyAqIEBvYmo6IFRoZSBnZW0gb2JqZWN0LgorICogQHNpemU6 IE9iamVjdCBzaXplIGluIGJ5dGVzLgorICogQGZsYWdzOiBnZW0gb2JqZWN0IGZsYWdzLgorICoK KyAqIFJldHVybjogMCBvbiBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUu CisgKi8KK2ludCBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5 X3JlZ2lvbiAqbWVtLAorCQkJICAgICAgIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmos CisJCQkgICAgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCisJCQkgICAgICAgdW5zaWduZWQgaW50 IGZsYWdzKQoreworCXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgbG9ja19jbGFzczsKKwlz dHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSA9IG1lbS0+aTkxNTsKKwllbnVtIHR0bV9ib190 eXBlIGJvX3R5cGU7CisJc2l6ZV90IGFsaWdubWVudCA9IDA7CisJaW50IHJldDsKKworCS8qIEFk anVzdCBhbGlnbm1lbnQgdG8gR1BVLSBhbmQgQ1BVIGh1Z2UgcGFnZSBzaXplcy4gKi8KKworCWlm IChtZW0tPmlzX3JhbmdlX21hbmFnZXIpIHsKKwkJaWYgKHNpemUgPj0gU1pfMUcpCisJCQlhbGln bm1lbnQgPSBTWl8xRyA+PiBQQUdFX1NISUZUOworCQllbHNlIGlmIChzaXplID49IFNaXzJNKQor CQkJYWxpZ25tZW50ID0gU1pfMk0gPj4gUEFHRV9TSElGVDsKKwkJZWxzZSBpZiAoc2l6ZSA+PSBT Wl82NEspCisJCQlhbGlnbm1lbnQgPSBTWl82NEsgPj4gUEFHRV9TSElGVDsKKwl9CisKKwlkcm1f Z2VtX3ByaXZhdGVfb2JqZWN0X2luaXQoJmk5MTUtPmRybSwgJm9iai0+YmFzZSwgc2l6ZSk7CisJ aTkxNV9nZW1fb2JqZWN0X2luaXQob2JqLCAmaTkxNV9nZW1fdHRtX29ial9vcHMsICZsb2NrX2Ns YXNzLCBmbGFncyk7CisJaTkxNV9nZW1fb2JqZWN0X2luaXRfbWVtb3J5X3JlZ2lvbihvYmosIG1l bSk7CisJaTkxNV9nZW1fb2JqZWN0X21ha2VfdW5zaHJpbmthYmxlKG9iaik7CisJb2JqLT5yZWFk X2RvbWFpbnMgPSBJOTE1X0dFTV9ET01BSU5fV0MgfCBJOTE1X0dFTV9ET01BSU5fR1RUOworCWk5 MTVfZ2VtX29iamVjdF9zZXRfY2FjaGVfY29oZXJlbmN5KG9iaiwgSTkxNV9DQUNIRV9OT05FKTsK KworCWJvX3R5cGUgPSAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfVVNFUikgPyB0dG1fYm9f dHlwZV9kZXZpY2UgOgorCQl0dG1fYm9fdHlwZV9rZXJuZWw7CisKKwkvKgorCSAqIElmIHRoaXMg ZnVuY3Rpb24gZmFpbHMsIGl0IHdpbGwgY2FsbCB0aGUgZGVzdHJ1Y3RvciwgYnV0CisJICogb3Vy IGNhbGxlciBzdGlsbCBvd25zIHRoZSBvYmplY3QuIFNvIG5vIGZyZWVpbmcgaW4gdGhlCisJICog ZGVzdHJ1Y3RvciB1bnRpbCBvYmotPnR0bS5jcmVhdGVkIGlzIHRydWUuCisJICogU2ltaWxhcmx5 LCBpbiBkZWxheWVkX2Rlc3Ryb3ksIHdlIGNhbid0IGNhbGwgdHRtX2JvX3B1dCgpCisJICogdW50 aWwgc3VjY2Vzc2Z1bCBpbml0aWFsaXphdGlvbi4KKwkgKi8KKwlyZXQgPSB0dG1fYm9faW5pdCgm aTkxNS0+YmRldiwgaTkxNV9nZW1fdG9fdHRtKG9iaiksIHNpemUsCisJCQkgIGJvX3R5cGUsICZp OTE1X3N5c19wbGFjZW1lbnQsIGFsaWdubWVudCwKKwkJCSAgdHJ1ZSwgTlVMTCwgTlVMTCwgaTkx NV90dG1fYm9fZGVzdHJveSk7CisKKwlpZiAoIXJldCkKKwkJb2JqLT50dG0uY3JlYXRlZCA9IHRy dWU7CisKKwkvKiBpOTE1IHdhbnRzIC1FTlhJTyB3aGVuIG91dCBvZiBtZW1vcnkgcmVnaW9uIHNw YWNlLiAqLworCXJldHVybiAocmV0ID09IC1FTk9TUEMpID8gLUVOWElPIDogcmV0OworfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uYjhkM2RjYmI1MGRmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oCkBAIC0wLDAgKzEsNDggQEAKKy8qIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQgKi8KKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAyMSBJ bnRlbCBDb3Jwb3JhdGlvbgorICovCisjaWZuZGVmIF9JOTE1X0dFTV9UVE1fSF8KKyNkZWZpbmUg X0k5MTVfR0VNX1RUTV9IXworCisjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5o IgorCisvKioKKyAqIGk5MTVfZ2VtX3RvX3R0bSAtIENvbnZlcnQgYSBzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCB0byBhCisgKiBzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QuCisgKiBAb2JqOiBQ b2ludGVyIHRvIHRoZSBnZW0gb2JqZWN0LgorICoKKyAqIFJldHVybjogUG9pbnRlciB0byB0aGUg ZW1iZWRkZWQgc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0LgorICovCitzdGF0aWMgaW5saW5lIHN0 cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqCitpOTE1X2dlbV90b190dG0oc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaikKK3sKKwlyZXR1cm4gJm9iai0+X19kb19ub3RfYWNjZXNzOworfQor CisvKgorICogaTkxNSB0dG0gZ2VtIG9iamVjdCBkZXN0cnVjdG9yLiBJbnRlcm5hbCB1c2Ugb25s eS4KKyAqLwordm9pZCBpOTE1X3R0bV9ib19kZXN0cm95KHN0cnVjdCB0dG1fYnVmZmVyX29iamVj dCAqYm8pOworCisvKioKKyAqIGk5MTVfdHRtX3RvX2dlbSAtIENvbnZlcnQgYSBzdHJ1Y3QgdHRt X2J1ZmZlcl9vYmplY3QgdG8gYW4gZW1iZWRkaW5nCisgKiBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdC4KKyAqCisgKiBSZXR1cm46IFBvaW50ZXIgdG8gdGhlIGVtYmVkZGluZyBzdHJ1Y3QgdHRt X2J1ZmZlcl9vYmplY3QsIG9yIE5VTEwKKyAqIGlmIHRoZSBvYmplY3Qgd2FzIG5vdCBhbiBpOTE1 IHR0bSBvYmplY3QuCisgKi8KK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKgoraTkxNV90dG1fdG9fZ2VtKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCit7CisJ aWYgKEdFTV9XQVJOX09OKGJvLT5kZXN0cm95ICE9IGk5MTVfdHRtX2JvX2Rlc3Ryb3kpKQorCQly ZXR1cm4gTlVMTDsKKworCXJldHVybiBjb250YWluZXJfb2YoYm8sIHN0cnVjdCBkcm1faTkxNV9n ZW1fb2JqZWN0LCBfX2RvX25vdF9hY2Nlc3MpOworfQorCitpbnQgX19pOTE1X2dlbV90dG1fb2Jq ZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKKwkJCSAgICAgICBzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAorCQkJICAgICAgIHJlc291cmNlX3NpemVfdCBz aXplLAorCQkJICAgICAgIHVuc2lnbmVkIGludCBmbGFncyk7CisjZW5kaWYKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3JlZ2lvbl9sbWVtLmMgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9yZWdpb25fbG1lbS5jCmluZGV4IGY3MzY2YjA1NGY4ZS4uNGFl MWY3MTdhOTRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yZWdp b25fbG1lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3JlZ2lvbl9sbWVt LmMKQEAgLTksNiArOSw3IEBACiAjaW5jbHVkZSAiaW50ZWxfcmVnaW9uX3R0bS5oIgogI2luY2x1 ZGUgImdlbS9pOTE1X2dlbV9sbWVtLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5o IgorI2luY2x1ZGUgImdlbS9pOTE1X2dlbV90dG0uaCIKICNpbmNsdWRlICJpbnRlbF9yZWdpb25f bG1lbS5oIgogCiBzdGF0aWMgaW50IGluaXRfZmFrZV9sbWVtX2JhcihzdHJ1Y3QgaW50ZWxfbWVt b3J5X3JlZ2lvbiAqbWVtKQpAQCAtMTA3LDcgKzEwOCw3IEBAIHJlZ2lvbl9sbWVtX2luaXQoc3Ry dWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSkKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbl9vcHMgaW50ZWxfcmVnaW9uX2xtZW1fb3BzID0gewogCS5pbml0ID0gcmVn aW9uX2xtZW1faW5pdCwKIAkucmVsZWFzZSA9IHJlZ2lvbl9sbWVtX3JlbGVhc2UsCi0JLmluaXRf b2JqZWN0ID0gX19pOTE1X2dlbV9sbWVtX29iamVjdF9pbml0LAorCS5pbml0X29iamVjdCA9IF9f aTkxNV9nZW1fdHRtX29iamVjdF9pbml0LAogfTsKIAogc3RydWN0IGludGVsX21lbW9yeV9yZWdp b24gKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKaW5kZXggMDk5M2Q3MDZmMDY3Li40MGZlOWExNDcz MTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKKysrIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwpAQCAtMTAwNSw4ICsxMDA1LDExIEBAIGk5MTVf Z2VtX21hZHZpc2VfaW9jdGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdm9pZCAqZGF0YSwKIAkJ fQogCX0KIAotCWlmIChvYmotPm1tLm1hZHYgIT0gX19JOTE1X01BRFZfUFVSR0VEKQorCWlmIChv YmotPm1tLm1hZHYgIT0gX19JOTE1X01BRFZfUFVSR0VEKSB7CiAJCW9iai0+bW0ubWFkdiA9IGFy Z3MtPm1hZHY7CisJCWlmIChvYmotPm9wcy0+YWRqdXN0X2xydSkKKwkJCW9iai0+b3BzLT5hZGp1 c3RfbHJ1KG9iaik7CisJfQogCiAJaWYgKGk5MTVfZ2VtX29iamVjdF9oYXNfcGFnZXMob2JqKSkg ewogCQl1bnNpZ25lZCBsb25nIGZsYWdzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVt b3J5X3JlZ2lvbi5jCmluZGV4IDQwOTJjYzk4NzY3OS4uYmQyN2U4OTdkNGQwIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jCkBAIC0xNDksNyArMTQ5LDYgQEAg aW50ZWxfbWVtb3J5X3JlZ2lvbl9jcmVhdGUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUs CiAKIAltdXRleF9pbml0KCZtZW0tPm9iamVjdHMubG9jayk7CiAJSU5JVF9MSVNUX0hFQUQoJm1l bS0+b2JqZWN0cy5saXN0KTsKLQlJTklUX0xJU1RfSEVBRCgmbWVtLT5vYmplY3RzLnB1cmdlYWJs ZSk7CiAJSU5JVF9MSVNUX0hFQUQoJm1lbS0+cmVzZXJ2ZWQpOwogCiAJbXV0ZXhfaW5pdCgmbWVt LT5tbV9sb2NrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9y eV9yZWdpb24uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uaApp bmRleCBlNjljZGUxM2RhZjIuLjdiNWZhOTdjMGI1OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX21lbW9yeV9yZWdpb24uaApAQCAtMTAwLDcgKzEwMCw2IEBAIHN0cnVjdCBpbnRlbF9t ZW1vcnlfcmVnaW9uIHsKIAlzdHJ1Y3QgewogCQlzdHJ1Y3QgbXV0ZXggbG9jazsgLyogUHJvdGVj dHMgYWNjZXNzIHRvIG9iamVjdHMgKi8KIAkJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwotCQlzdHJ1 Y3QgbGlzdF9oZWFkIHB1cmdlYWJsZTsKIAl9IG9iamVjdHM7CiAKIAlzaXplX3QgY2h1bmtfc2l6 ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYwppbmRleCBjOGFjMTE4YzIx ZjYuLjBiNDFhMTU0NTU3MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf cmVnaW9uX3R0bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0u YwpAQCAtMTAsNiArMTAsNyBAQAogCiAjaW5jbHVkZSAiaW50ZWxfcmVnaW9uX3R0bS5oIgogCisj aW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3R0bS5oIiAvKiBGb3IgdGhlIGZ1bmNzL29wcyBleHBvcnQg b25seSAqLwogLyoqCiAgKiBET0M6IFRUTSBzdXBwb3J0IHN0cnVjdHVyZQogICoKQEAgLTE5LDkg KzIwLDYgQEAKICAqIGk5MTUgR0VNIHJlZ2lvbnMgdG8gVFRNIG1lbW9yeSB0eXBlcyBhbmQgcmVz b3VyY2UgbWFuYWdlcnMuCiAgKi8KIAotLyogQSBaZXJvLWluaXRpYWxpemVkIGRyaXZlciBmb3Ig bm93LiBXZSBkb24ndCBoYXZlIGEgVFRNIGJhY2tlbmQgeWV0LiAqLwotc3RhdGljIHN0cnVjdCB0 dG1fZGV2aWNlX2Z1bmNzIGk5MTVfdHRtX2JvX2RyaXZlcjsKLQogLyoqCiAgKiBpbnRlbF9yZWdp b25fdHRtX2RldmljZV9pbml0IC0gSW5pdGlhbGl6ZSBhIFRUTSBkZXZpY2UKICAqIEBkZXZfcHJp djogUG9pbnRlciB0byBhbiBpOTE1IGRldmljZSBwcml2YXRlIHN0cnVjdHVyZS4KQEAgLTMyLDcg KzMwLDcgQEAgaW50IGludGVsX3JlZ2lvbl90dG1fZGV2aWNlX2luaXQoc3RydWN0IGRybV9pOTE1 X3ByaXZhdGUgKmRldl9wcml2KQogewogCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSAmZGV2X3By aXYtPmRybTsKIAotCXJldHVybiB0dG1fZGV2aWNlX2luaXQoJmRldl9wcml2LT5iZGV2LCAmaTkx NV90dG1fYm9fZHJpdmVyLAorCXJldHVybiB0dG1fZGV2aWNlX2luaXQoJmRldl9wcml2LT5iZGV2 LCBpOTE1X3R0bV9kcml2ZXIoKSwKIAkJCSAgICAgICBkcm0tPmRldiwgZHJtLT5hbm9uX2lub2Rl LT5pX21hcHBpbmcsCiAJCQkgICAgICAgZHJtLT52bWFfb2Zmc2V0X21hbmFnZXIsIGZhbHNlLCBm YWxzZSk7CiB9CkBAIC0xNzIsNiArMTcwLDcgQEAgc3RydWN0IHNnX3RhYmxlICppbnRlbF9yZWdp b25fdHRtX25vZGVfdG9fc3Qoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAlyZXR1 cm4gaTkxNV9zZ19mcm9tX21tX25vZGUobm9kZSwgbWVtLT5yZWdpb24uc3RhcnQpOwogfQogCisj aWZkZWYgQ09ORklHX0RSTV9JOTE1X1NFTEZURVNUCiAvKioKICAqIGludGVsX3JlZ2lvbl90dG1f bm9kZV9hbGxvYyAtIEFsbG9jYXRlIG1lbW9yeSByZXNvdXJjZXMgZnJvbSBhIHJlZ2lvbgogICog QG1lbTogVGhlIG1lbW9yeSByZWdpb24sCkBAIC0yMTgsMyArMjE3LDQgQEAgdm9pZCAqaW50ZWxf cmVnaW9uX3R0bV9ub2RlX2FsbG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJ CXJldCA9IC1FTlhJTzsKIAlyZXR1cm4gcmV0ID8gRVJSX1BUUihyZXQpIDogcmVzLm1tX25vZGU7 CiB9CisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lv bl90dG0uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uaAppbmRleCAx YzgyYzZjMzQyOWQuLmVhYTNlY2NmYTI1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfcmVnaW9uX3R0bS5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Jl Z2lvbl90dG0uaApAQCAtMTEsNiArMTEsNyBAQAogCiBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZTsK IHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uOworc3RydWN0IHR0bV9kZXZpY2VfZnVuY3M7CiAK IGludCBpbnRlbF9yZWdpb25fdHRtX2RldmljZV9pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdik7CiAKQEAgLTIzLDEwICsyNCwxNCBAQCB2b2lkIGludGVsX3JlZ2lvbl90dG1f ZmluaShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKTsKIHN0cnVjdCBzZ190YWJsZSAq aW50ZWxfcmVnaW9uX3R0bV9ub2RlX3RvX3N0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpt ZW0sCiAJCQkJCSAgICAgdm9pZCAqbm9kZSk7CiAKK3ZvaWQgaW50ZWxfcmVnaW9uX3R0bV9ub2Rl X2ZyZWUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKKwkJCQl2b2lkICpub2RlKTsK Kworc3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgKmk5MTVfdHRtX2RyaXZlcih2b2lkKTsKKworI2lm ZGVmIENPTkZJR19EUk1fSTkxNV9TRUxGVEVTVAogdm9pZCAqaW50ZWxfcmVnaW9uX3R0bV9ub2Rl X2FsbG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCQkJICByZXNvdXJjZV9z aXplX3Qgc2l6ZSwKIAkJCQkgIHVuc2lnbmVkIGludCBmbGFncyk7Ci0KLXZvaWQgaW50ZWxfcmVn aW9uX3R0bV9ub2RlX2ZyZWUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKLQkJCQl2 b2lkICpub2RlKTsKKyNlbmRpZgogI2VuZGlmIC8qIF9JTlRFTF9SRUdJT05fVFRNX0hfICovCi0t IAoyLjMxLjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=