From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 644E0C4707A for ; Fri, 21 May 2021 15:33:40 +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 245CC613D9 for ; Fri, 21 May 2021 15:33:40 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 245CC613D9 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 6D40E6F3C2; Fri, 21 May 2021 15:33:29 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id BD5156E194; Fri, 21 May 2021 15:33:26 +0000 (UTC) IronPort-SDR: y3H8BRKuDPR1SUONFB1eFzMkwldoxYe9tK99oSPIo4HX1oA1nhOOxoYHY3nINEzqyBJyOfHmah U+DxY8VchWYw== X-IronPort-AV: E=McAfee;i="6200,9189,9990"; a="265415736" X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="265415736" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:26 -0700 IronPort-SDR: 0HpkVnhx5DAqf/12vY1oK6PGkXph5dIWKbHtJItGdyd0wdPvllmwzp6HR6ih+eveCclJ03CuSo xvzIOv8EfhsQ== X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="441125509" Received: from imarinmo-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.34]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:24 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v3 11/12] drm/i915/ttm: Introduce a TTM i915 gem object backend Date: Fri, 21 May 2021 17:32:52 +0200 Message-Id: <20210521153253.518037-12-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> References: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , 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. --- 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 | 531 ++++++++++++++++++ drivers/gpu/drm/i915/gem/i915_gem_ttm.h | 50 ++ 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 | 6 +- drivers/gpu/drm/i915/intel_region_ttm.h | 8 +- 16 files changed, 717 insertions(+), 154 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 998606b7f49f..2022e763f8f7 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -154,6 +154,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 e9247afb0320..df2b4e6b9bcc 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -173,7 +173,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); @@ -209,59 +209,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); @@ -319,6 +329,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); } @@ -411,6 +422,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..3cec777be346 --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -0,0 +1,531 @@ +// 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, 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; +} + +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, + .verify_access = NULL, + .swap_notify = i915_ttm_swap_notify, + .delete_mem_notify = i915_ttm_delete_mem_notify, +}; + +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..05c114e35b4d --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h @@ -0,0 +1,50 @@ +/* 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); + +extern struct ttm_device_funcs i915_ttm_bo_driver; +#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 180f6e9107d4..350283ab9a83 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)) { struct list_head *list; 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 69c98298326b..52352dbe047d 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 * @@ -31,9 +32,6 @@ struct intel_region_ttm_private { I915_SELFTEST_DECLARE(struct drm_vma_offset_manager mock_vma); }; -/* A Zero-initialized driver for now. We don't have a TTM backend yet. */ -static struct ttm_device_funcs i915_ttm_bo_driver; - static struct intel_region_ttm_private *to_ttm_private(void *data) { return (struct intel_region_ttm_private *)data; @@ -219,6 +217,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, @@ -267,7 +266,6 @@ void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, return ret ? ERR_PTR(ret) : res.mm_node; } -#ifdef CONFIG_DRM_I915_SELFTEST /** * intel_region_ttm_init_mock - Initialize a mock memory region for TTM. * @mem: The region to initialize. diff --git a/drivers/gpu/drm/i915/intel_region_ttm.h b/drivers/gpu/drm/i915/intel_region_ttm.h index 23c6c2d4b1cd..a08998c3a3d8 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.h +++ b/drivers/gpu/drm/i915/intel_region_ttm.h @@ -23,14 +23,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_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); #ifdef CONFIG_DRM_I915_SELFTEST +void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, + resource_size_t size, + unsigned int flags); + int intel_region_ttm_init_mock(struct intel_memory_region *mem); void intel_region_ttm_fini_mock(struct intel_memory_region *mem); -- 2.31.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 10216C47076 for ; Fri, 21 May 2021 15:33:42 +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 D609A6135B for ; Fri, 21 May 2021 15:33:41 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D609A6135B 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 3D7D66F58D; Fri, 21 May 2021 15:33:34 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id BD5156E194; Fri, 21 May 2021 15:33:26 +0000 (UTC) IronPort-SDR: y3H8BRKuDPR1SUONFB1eFzMkwldoxYe9tK99oSPIo4HX1oA1nhOOxoYHY3nINEzqyBJyOfHmah U+DxY8VchWYw== X-IronPort-AV: E=McAfee;i="6200,9189,9990"; a="265415736" X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="265415736" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:26 -0700 IronPort-SDR: 0HpkVnhx5DAqf/12vY1oK6PGkXph5dIWKbHtJItGdyd0wdPvllmwzp6HR6ih+eveCclJ03CuSo xvzIOv8EfhsQ== X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="441125509" Received: from imarinmo-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.34]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:24 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Fri, 21 May 2021 17:32:52 +0200 Message-Id: <20210521153253.518037-12-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> References: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v3 11/12] 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 Zm9yIHN3YXBpbiBpbiB0aGUgbW92ZSBjYWxsYmFjay4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX2NyZWF0ZS5jICAgIHwgICA5ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fbG1lbS5jICAgICAgfCAgODQgLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fbG1lbS5oICAgICAgfCAgIDUgLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2Vt L2k5MTVfZ2VtX29iamVjdC5jICAgIHwgMTI1ICsrKy0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fb2JqZWN0LmggICAgfCAgIDkgKwogLi4uL2dwdS9kcm0vaTkxNS9nZW0vaTkx NV9nZW1fb2JqZWN0X3R5cGVzLmggIHwgIDI3ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0v aTkxNV9nZW1fcmVnaW9uLmMgICAgfCAgIDYgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV90dG0uYyAgICAgICB8IDUzMSArKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uaCAgICAgICB8ICA1MCArKwogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9uX2xtZW0uYyAgIHwgICAzICstCiBkcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X2dlbS5jICAgICAgICAgICAgICAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uYyAgICB8ICAgMSAtCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmggICAgfCAgIDEgLQogZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfcmVnaW9uX3R0bS5jICAgICAgIHwgICA2ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9yZWdpb25fdHRtLmggICAgICAgfCAgIDggKy0KIDE2IGZpbGVzIGNoYW5nZWQsIDcx NyBpbnNlcnRpb25zKCspLCAxNTQgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJp dmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmls ZQppbmRleCA5OTg2MDZiN2Y0OWYuLjIwMjJlNzYzZjhmNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUK QEAgLTE1NCw2ICsxNTQsNyBAQCBnZW0teSArPSBcCiAJZ2VtL2k5MTVfZ2VtX3N0b2xlbi5vIFwK IAlnZW0vaTkxNV9nZW1fdGhyb3R0bGUubyBcCiAJZ2VtL2k5MTVfZ2VtX3RpbGluZy5vIFwKKwln ZW0vaTkxNV9nZW1fdHRtLm8gXAogCWdlbS9pOTE1X2dlbV91c2VycHRyLm8gXAogCWdlbS9pOTE1 X2dlbV93YWl0Lm8gXAogCWdlbS9pOTE1X2dlbWZzLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9jcmVhdGUuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9jcmVhdGUuYwppbmRleCA1NDhkZGYzOWQ4NTMuLjkzYmY2M2JiYWZmMSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9jcmVhdGUuYwpAQCAtODUsMTMgKzg1 LDEwIEBAIGk5MTVfZ2VtX3NldHVwKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosIHU2 NCBzaXplKQogCQlyZXR1cm4gLUUyQklHOwogCiAJLyoKLQkgKiBGb3Igbm93IHJlc29ydCB0byBD UFUgYmFzZWQgY2xlYXJpbmcgZm9yIGRldmljZSBsb2NhbC1tZW1vcnksIGluIHRoZQotCSAqIG5l YXIgZnV0dXJlIHRoaXMgd2lsbCB1c2UgdGhlIGJsaXR0ZXIgZW5naW5lIGZvciBhY2NlbGVyYXRl ZCwgR1BVCi0JICogYmFzZWQgY2xlYXJpbmcuCisJICogSTkxNV9CT19BTExPQ19VU0VSIHdpbGwg bWFrZSBzdXJlIHRoZSBvYmplY3QgaXMgY2xlYXJlZCBiZWZvcmUKKwkgKiBhbnkgdXNlciBhY2Nl c3MuCiAJICovCi0JZmxhZ3MgPSAwOwotCWlmIChtci0+dHlwZSA9PSBJTlRFTF9NRU1PUllfTE9D QUwpCi0JCWZsYWdzID0gSTkxNV9CT19BTExPQ19DUFVfQ0xFQVI7CisJZmxhZ3MgPSBJOTE1X0JP X0FMTE9DX1VTRVI7CiAKIAlyZXQgPSBtci0+b3BzLT5pbml0X29iamVjdChtciwgb2JqLCBzaXpl LCBmbGFncyk7CiAJaWYgKHJldCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9sbWVtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1l bS5jCmluZGV4IDNiNGFhMjhhMDc2ZC4uMmI4Y2QxNWRlMWQ5IDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMKQEAgLTQsNzQgKzQsMTAgQEAKICAqLwogCiAjaW5jbHVk ZSAiaW50ZWxfbWVtb3J5X3JlZ2lvbi5oIgotI2luY2x1ZGUgImludGVsX3JlZ2lvbl90dG0uaCIK ICNpbmNsdWRlICJnZW0vaTkxNV9nZW1fcmVnaW9uLmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2Vt X2xtZW0uaCIKICNpbmNsdWRlICJpOTE1X2Rydi5oIgogCi1zdGF0aWMgdm9pZCBsbWVtX3B1dF9w YWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAotCQkJICAgc3RydWN0IHNnX3Rh YmxlICpwYWdlcykKLXsKLQlpbnRlbF9yZWdpb25fdHRtX25vZGVfZnJlZShvYmotPm1tLnJlZ2lv biwgb2JqLT5tbS5zdF9tbV9ub2RlKTsKLQlvYmotPm1tLmRpcnR5ID0gZmFsc2U7Ci0Jc2dfZnJl ZV90YWJsZShwYWdlcyk7Ci0Ja2ZyZWUocGFnZXMpOwotfQotCi1zdGF0aWMgaW50IGxtZW1fZ2V0 X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCi17Ci0JdW5zaWduZWQgaW50 IGZsYWdzOwotCXN0cnVjdCBzZ190YWJsZSAqcGFnZXM7Ci0KLQlmbGFncyA9IEk5MTVfQUxMT0Nf TUlOX1BBR0VfU0laRTsKLQlpZiAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ09OVElHVU9V UykKLQkJZmxhZ3MgfD0gSTkxNV9BTExPQ19DT05USUdVT1VTOwotCi0Jb2JqLT5tbS5zdF9tbV9u b2RlID0gaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2FsbG9jKG9iai0+bW0ucmVnaW9uLAotCQkJCQkJ CSBvYmotPmJhc2Uuc2l6ZSwKLQkJCQkJCQkgZmxhZ3MpOwotCWlmIChJU19FUlIob2JqLT5tbS5z dF9tbV9ub2RlKSkKLQkJcmV0dXJuIFBUUl9FUlIob2JqLT5tbS5zdF9tbV9ub2RlKTsKLQotCS8q IFJhbmdlIG1hbmFnZXIgaXMgYWx3YXlzIGNvbnRpZ291cyAqLwotCWlmIChvYmotPm1tLnJlZ2lv bi0+aXNfcmFuZ2VfbWFuYWdlcikKLQkJb2JqLT5mbGFncyB8PSBJOTE1X0JPX0FMTE9DX0NPTlRJ R1VPVVM7Ci0JcGFnZXMgPSBpbnRlbF9yZWdpb25fdHRtX25vZGVfdG9fc3Qob2JqLT5tbS5yZWdp b24sIG9iai0+bW0uc3RfbW1fbm9kZSk7Ci0JaWYgKElTX0VSUihwYWdlcykpIHsKLQkJaW50ZWxf cmVnaW9uX3R0bV9ub2RlX2ZyZWUob2JqLT5tbS5yZWdpb24sIG9iai0+bW0uc3RfbW1fbm9kZSk7 Ci0JCXJldHVybiBQVFJfRVJSKHBhZ2VzKTsKLQl9Ci0KLQlfX2k5MTVfZ2VtX29iamVjdF9zZXRf cGFnZXMob2JqLCBwYWdlcywgaTkxNV9zZ19kbWFfc2l6ZXMocGFnZXMtPnNnbCkpOwotCi0JaWYg KG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FMTE9DX0NQVV9DTEVBUikgewotCQl2b2lkIF9faW9tZW0g KnZhZGRyID0KLQkJCWk5MTVfZ2VtX29iamVjdF9sbWVtX2lvX21hcChvYmosIDAsIG9iai0+YmFz ZS5zaXplKTsKLQotCQlpZiAoIXZhZGRyKSB7Ci0JCQlzdHJ1Y3Qgc2dfdGFibGUgKnBhZ2VzID0K LQkJCQlfX2k5MTVfZ2VtX29iamVjdF91bnNldF9wYWdlcyhvYmopOwotCi0JCQlpZiAoIUlTX0VS Ul9PUl9OVUxMKHBhZ2VzKSkKLQkJCQlsbWVtX3B1dF9wYWdlcyhvYmosIHBhZ2VzKTsKLQkJfQot Ci0JCW1lbXNldF9pbyh2YWRkciwgMCwgb2JqLT5iYXNlLnNpemUpOwotCQlpb19tYXBwaW5nX3Vu bWFwKHZhZGRyKTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotY29uc3Qgc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3Rfb3BzIGk5MTVfZ2VtX2xtZW1fb2JqX29wcyA9IHsKLQkubmFtZSA9ICJpOTE1 X2dlbV9vYmplY3RfbG1lbSIsCi0JLmZsYWdzID0gSTkxNV9HRU1fT0JKRUNUX0hBU19JT01FTSwK LQotCS5nZXRfcGFnZXMgPSBsbWVtX2dldF9wYWdlcywKLQkucHV0X3BhZ2VzID0gbG1lbV9wdXRf cGFnZXMsCi0JLnJlbGVhc2UgPSBpOTE1X2dlbV9vYmplY3RfcmVsZWFzZV9tZW1vcnlfcmVnaW9u LAotfTsKLQogdm9pZCBfX2lvbWVtICoKIGk5MTVfZ2VtX29iamVjdF9sbWVtX2lvX21hcChzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCQkJICAgIHVuc2lnbmVkIGxvbmcgbiwKQEAg LTEwMywyMyArMzksMyBAQCBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX2xtZW0oc3RydWN0IGRybV9p OTE1X3ByaXZhdGUgKmk5MTUsCiAJcmV0dXJuIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9u KGk5MTUtPm1tLnJlZ2lvbnNbSU5URUxfUkVHSU9OX0xNRU1dLAogCQkJCQkgICAgIHNpemUsIGZs YWdzKTsKIH0KLQotaW50IF9faTkxNV9nZW1fbG1lbV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmos Ci0JCQkJcmVzb3VyY2Vfc2l6ZV90IHNpemUsCi0JCQkJdW5zaWduZWQgaW50IGZsYWdzKQotewot CXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgbG9ja19jbGFzczsKLQlzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqaTkxNSA9IG1lbS0+aTkxNTsKLQotCWRybV9nZW1fcHJpdmF0ZV9vYmplY3Rf aW5pdCgmaTkxNS0+ZHJtLCAmb2JqLT5iYXNlLCBzaXplKTsKLQlpOTE1X2dlbV9vYmplY3RfaW5p dChvYmosICZpOTE1X2dlbV9sbWVtX29ial9vcHMsICZsb2NrX2NsYXNzLCBmbGFncyk7Ci0KLQlv YmotPnJlYWRfZG9tYWlucyA9IEk5MTVfR0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RPTUFJTl9H VFQ7Ci0KLQlpOTE1X2dlbV9vYmplY3Rfc2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIEk5MTVfQ0FD SEVfTk9ORSk7Ci0KLQlpOTE1X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKG9iaiwgbWVt KTsKLQotCXJldHVybiAwOwotfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2Vt L2k5MTVfZ2VtX2xtZW0uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVt LmgKaW5kZXggZmFjNmJjNWE1ZWJiLi5lYTc2ZmQxMWNjYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaApAQCAtMjYsOSArMjYsNCBAQCBpOTE1X2dlbV9vYmplY3Rf Y3JlYXRlX2xtZW0oc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJCQkgICAgcmVzb3Vy Y2Vfc2l6ZV90IHNpemUsCiAJCQkgICAgdW5zaWduZWQgaW50IGZsYWdzKTsKIAotaW50IF9faTkx NV9nZW1fbG1lbV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAot CQkJCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkJcmVzb3VyY2Vfc2l6ZV90 IHNpemUsCi0JCQkJdW5zaWduZWQgaW50IGZsYWdzKTsKLQogI2VuZGlmIC8qICFfX0k5MTVfR0VN X0xNRU1fSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X29iamVjdC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCmlu ZGV4IGU5MjQ3YWZiMDMyMC4uZGYyYjRlNmI5YmNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX29iamVjdC5jCkBAIC0xNzMsNyArMTczLDcgQEAgc3RhdGljIHZvaWQgaTkx NV9nZW1fY2xvc2Vfb2JqZWN0KHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtLCBzdHJ1Y3QgZHJt X2ZpbGUgKmYKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1 KHN0cnVjdCByY3VfaGVhZCAqaGVhZCkKK3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3Uo c3RydWN0IHJjdV9oZWFkICpoZWFkKQogewogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv YmogPQogCQljb250YWluZXJfb2YoaGVhZCwgdHlwZW9mKCpvYmopLCByY3UpOwpAQCAtMjA5LDU5 ICsyMDksNjkgQEAgc3RhdGljIHZvaWQgX19pOTE1X2dlbV9vYmplY3RfZnJlZV9tbWFwcyhzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogCX0KIH0KIAotc3RhdGljIHZvaWQgX19pOTE1 X2dlbV9mcmVlX29iamVjdHMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCi0JCQkJICAg IHN0cnVjdCBsbGlzdF9ub2RlICpmcmVlZCkKK3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdChz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogewotCXN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmosICpvbjsKKwl0cmFjZV9pOTE1X2dlbV9vYmplY3RfZGVzdHJveShvYmopOwog Ci0JbGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShvYmosIG9uLCBmcmVlZCwgZnJlZWQpIHsKLQkJ dHJhY2VfaTkxNV9nZW1fb2JqZWN0X2Rlc3Ryb3kob2JqKTsKKwlpZiAoIWxpc3RfZW1wdHkoJm9i ai0+dm1hLmxpc3QpKSB7CisJCXN0cnVjdCBpOTE1X3ZtYSAqdm1hOworCisJCS8qCisJCSAqIE5v dGUgdGhhdCB0aGUgdm1hIGtlZXBzIGFuIG9iamVjdCByZWZlcmVuY2Ugd2hpbGUKKwkJICogaXQg aXMgYWN0aXZlLCBzbyBpdCAqc2hvdWxkKiBub3Qgc2xlZXAgd2hpbGUgd2UKKwkJICogZGVzdHJv eSBpdC4gT3VyIGRlYnVnIGNvZGUgZXJycyBpbnNpdHMgaXQgKm1pZ2h0Ki4KKwkJICogRm9yIHRo ZSBtb21lbnQsIHBsYXkgYWxvbmcuCisJCSAqLworCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2sp OworCQl3aGlsZSAoKHZtYSA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVsbCgmb2JqLT52bWEubGlz dCwKKwkJCQkJCSAgICAgICBzdHJ1Y3QgaTkxNV92bWEsCisJCQkJCQkgICAgICAgb2JqX2xpbmsp KSkgeworCQkJR0VNX0JVR19PTih2bWEtPm9iaiAhPSBvYmopOworCQkJc3Bpbl91bmxvY2soJm9i ai0+dm1hLmxvY2spOwogCi0JCWlmICghbGlzdF9lbXB0eSgmb2JqLT52bWEubGlzdCkpIHsKLQkJ CXN0cnVjdCBpOTE1X3ZtYSAqdm1hOworCQkJX19pOTE1X3ZtYV9wdXQodm1hKTsKIAotCQkJLyoK LQkJCSAqIE5vdGUgdGhhdCB0aGUgdm1hIGtlZXBzIGFuIG9iamVjdCByZWZlcmVuY2Ugd2hpbGUK LQkJCSAqIGl0IGlzIGFjdGl2ZSwgc28gaXQgKnNob3VsZCogbm90IHNsZWVwIHdoaWxlIHdlCi0J CQkgKiBkZXN0cm95IGl0LiBPdXIgZGVidWcgY29kZSBlcnJzIGluc2l0cyBpdCAqbWlnaHQqLgot CQkJICogRm9yIHRoZSBtb21lbnQsIHBsYXkgYWxvbmcuCi0JCQkgKi8KIAkJCXNwaW5fbG9jaygm b2JqLT52bWEubG9jayk7Ci0JCQl3aGlsZSAoKHZtYSA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVs bCgmb2JqLT52bWEubGlzdCwKLQkJCQkJCQkgICAgICAgc3RydWN0IGk5MTVfdm1hLAotCQkJCQkJ CSAgICAgICBvYmpfbGluaykpKSB7Ci0JCQkJR0VNX0JVR19PTih2bWEtPm9iaiAhPSBvYmopOwot CQkJCXNwaW5fdW5sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwkJfQorCQlzcGluX3VubG9jaygmb2Jq LT52bWEubG9jayk7CisJfQogCi0JCQkJX19pOTE1X3ZtYV9wdXQodm1hKTsKKwlfX2k5MTVfZ2Vt X29iamVjdF9mcmVlX21tYXBzKG9iaik7CiAKLQkJCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2sp OwotCQkJfQotCQkJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOwotCQl9CisJR0VNX0JVR19P TighbGlzdF9lbXB0eSgmb2JqLT5sdXRfbGlzdCkpOwogCi0JCV9faTkxNV9nZW1fb2JqZWN0X2Zy ZWVfbW1hcHMob2JqKTsKKwlhdG9taWNfc2V0KCZvYmotPm1tLnBhZ2VzX3Bpbl9jb3VudCwgMCk7 CisJX19pOTE1X2dlbV9vYmplY3RfcHV0X3BhZ2VzKG9iaik7CisJR0VNX0JVR19PTihpOTE1X2dl bV9vYmplY3RfaGFzX3BhZ2VzKG9iaikpOworCWJpdG1hcF9mcmVlKG9iai0+Yml0XzE3KTsKIAot CQlHRU1fQlVHX09OKCFsaXN0X2VtcHR5KCZvYmotPmx1dF9saXN0KSk7CisJaWYgKG9iai0+YmFz ZS5pbXBvcnRfYXR0YWNoKQorCQlkcm1fcHJpbWVfZ2VtX2Rlc3Ryb3koJm9iai0+YmFzZSwgTlVM TCk7CiAKLQkJYXRvbWljX3NldCgmb2JqLT5tbS5wYWdlc19waW5fY291bnQsIDApOwotCQlfX2k5 MTVfZ2VtX29iamVjdF9wdXRfcGFnZXMob2JqKTsKLQkJR0VNX0JVR19PTihpOTE1X2dlbV9vYmpl Y3RfaGFzX3BhZ2VzKG9iaikpOwotCQliaXRtYXBfZnJlZShvYmotPmJpdF8xNyk7CisJZHJtX2dl bV9mcmVlX21tYXBfb2Zmc2V0KCZvYmotPmJhc2UpOwogCi0JCWlmIChvYmotPmJhc2UuaW1wb3J0 X2F0dGFjaCkKLQkJCWRybV9wcmltZV9nZW1fZGVzdHJveSgmb2JqLT5iYXNlLCBOVUxMKTsKKwlp ZiAob2JqLT5vcHMtPnJlbGVhc2UpCisJCW9iai0+b3BzLT5yZWxlYXNlKG9iaik7CiAKLQkJZHJt X2dlbV9mcmVlX21tYXBfb2Zmc2V0KCZvYmotPmJhc2UpOworCWlmIChvYmotPm1tLm5fcGxhY2Vt ZW50cyA+IDEpCisJCWtmcmVlKG9iai0+bW0ucGxhY2VtZW50cyk7CiAKLQkJaWYgKG9iai0+b3Bz LT5yZWxlYXNlKQotCQkJb2JqLT5vcHMtPnJlbGVhc2Uob2JqKTsKKwlpZiAob2JqLT5zaGFyZXNf cmVzdl9mcm9tKQorCQlpOTE1X3ZtX3Jlc3ZfcHV0KG9iai0+c2hhcmVzX3Jlc3ZfZnJvbSk7Cit9 CiAKLQkJaWYgKG9iai0+bW0ubl9wbGFjZW1lbnRzID4gMSkKLQkJCWtmcmVlKG9iai0+bW0ucGxh Y2VtZW50cyk7CitzdGF0aWMgdm9pZCBfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0cyhzdHJ1Y3QgZHJt X2k5MTVfcHJpdmF0ZSAqaTkxNSwKKwkJCQkgICAgc3RydWN0IGxsaXN0X25vZGUgKmZyZWVkKQor eworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosICpvbjsKIAotCQlpZiAob2JqLT5z aGFyZXNfcmVzdl9mcm9tKQotCQkJaTkxNV92bV9yZXN2X3B1dChvYmotPnNoYXJlc19yZXN2X2Zy b20pOworCWxsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUob2JqLCBvbiwgZnJlZWQsIGZyZWVkKSB7 CisJCW1pZ2h0X3NsZWVwKCk7CisJCWlmIChvYmotPm9wcy0+ZGVsYXllZF9mcmVlKSB7CisJCQlv YmotPm9wcy0+ZGVsYXllZF9mcmVlKG9iaik7CisJCQljb250aW51ZTsKKwkJfQorCQlfX2k5MTVf Z2VtX2ZyZWVfb2JqZWN0KG9iaik7CiAKIAkJLyogQnV0IGtlZXAgdGhlIHBvaW50ZXIgYWxpdmUg Zm9yIFJDVS1wcm90ZWN0ZWQgbG9va3VwcyAqLwogCQljYWxsX3JjdSgmb2JqLT5yY3UsIF9faTkx NV9nZW1fZnJlZV9vYmplY3RfcmN1KTsKQEAgLTMxOSw2ICszMjksNyBAQCBzdGF0aWMgdm9pZCBp OTE1X2dlbV9mcmVlX29iamVjdChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCiAJICog d29ya2VyIGFuZCBwZXJmb3JtaW5nIGZyZWVzIGRpcmVjdGx5IGZyb20gc3Vic2VxdWVudCBhbGxv Y2F0aW9ucyBmb3IKIAkgKiBjcnVkZSBidXQgZWZmZWN0aXZlIG1lbW9yeSB0aHJvdHRsaW5nLgog CSAqLworCiAJaWYgKGxsaXN0X2FkZCgmb2JqLT5mcmVlZCwgJmk5MTUtPm1tLmZyZWVfbGlzdCkp CiAJCXF1ZXVlX3dvcmsoaTkxNS0+d3EsICZpOTE1LT5tbS5mcmVlX3dvcmspOwogfQpAQCAtNDEx LDYgKzQyMiw0MiBAQCBpbnQgaTkxNV9nZW1fb2JqZWN0X3JlYWRfZnJvbV9wYWdlKHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmosIHU2NCBvZmZzZXQsCiAJcmV0dXJuIDA7CiB9CiAKKy8q KgorICogaTkxNV9nZW1fb2JqZWN0X2V2aWN0YWJsZSAtIFdoZXRoZXIgb2JqZWN0IGlzIGxpa2Vs eSBldmljdGFibGUgYWZ0ZXIgdW5iaW5kLgorICogQG9iajogVGhlIG9iamVjdCB0byBjaGVjawor ICoKKyAqIFRoaXMgZnVuY3Rpb24gY2hlY2tzIHdoZXRoZXIgdGhlIG9iamVjdCBpcyBsaWtlbHkg dW52aWN0YWJsZSBhZnRlciB1bmJpbmQuCisgKiBJZiB0aGUgb2JqZWN0IGlzIG5vdCBsb2NrZWQg d2hlbiBjaGVja2luZywgdGhlIHJlc3VsdCBpcyBvbmx5IGFkdmlzb3J5LgorICogSWYgdGhlIG9i amVjdCBpcyBsb2NrZWQgd2hlbiBjaGVja2luZywgYW5kIHRoZSBmdW5jdGlvbiByZXR1cm5zIHRy dWUsCisgKiB0aGVuIGFuIGV2aWN0aW9uIHNob3VsZCBpbmRlZWQgYmUgcG9zc2libGUuIEJ1dCBz aW5jZSB1bmxvY2tlZCB2bWEKKyAqIHVucGlubmluZyBhbmQgdW5iaW5kaW5nIGlzIGN1cnJlbnRs eSBwb3NzaWJsZSwgdGhlIG9iamVjdCBjYW4gYWN0dWFsbHkKKyAqIGJlY29tZSBldmljdGFibGUg ZXZlbiBpZiB0aGlzIGZ1bmN0aW9uIHJldHVybnMgZmFsc2UuCisgKgorICogUmV0dXJuOiB0cnVl IGlmIHRoZSBvYmplY3QgbWF5IGJlIGV2aWN0YWJsZS4gRmFsc2Ugb3RoZXJ3aXNlLgorICovCiti b29sIGk5MTVfZ2VtX29iamVjdF9ldmljdGFibGUoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaikKK3sKKwlzdHJ1Y3QgaTkxNV92bWEgKnZtYTsKKwlpbnQgcGluX2NvdW50ID0gYXRvbWlj X3JlYWQoJm9iai0+bW0ucGFnZXNfcGluX2NvdW50KTsKKworCWlmICghcGluX2NvdW50KQorCQly ZXR1cm4gdHJ1ZTsKKworCXNwaW5fbG9jaygmb2JqLT52bWEubG9jayk7CisJbGlzdF9mb3JfZWFj aF9lbnRyeSh2bWEsICZvYmotPnZtYS5saXN0LCBvYmpfbGluaykgeworCQlpZiAoaTkxNV92bWFf aXNfcGlubmVkKHZtYSkpIHsKKwkJCXNwaW5fdW5sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwkJCXJl dHVybiBmYWxzZTsKKwkJfQorCQlpZiAoYXRvbWljX3JlYWQoJnZtYS0+cGFnZXNfY291bnQpKQor CQkJcGluX2NvdW50LS07CisJfQorCXNwaW5fdW5sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwlHRU1f V0FSTl9PTihwaW5fY291bnQgPCAwKTsKKworCXJldHVybiBwaW5fY291bnQgPT0gMDsKK30KKwog dm9pZCBpOTE1X2dlbV9pbml0X19vYmplY3RzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1 KQogewogCUlOSVRfV09SSygmaTkxNS0+bW0uZnJlZV93b3JrLCBfX2k5MTVfZ2VtX2ZyZWVfd29y ayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0 LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0LmgKaW5kZXggMmVi ZDc5NTM3YWVhLi5hZTU5MzBlMzA3ZDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9pOTE1X2dlbV9vYmplY3QuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkx NV9nZW1fb2JqZWN0LmgKQEAgLTIwMCw2ICsyMDAsOSBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaTkx NV9nZW1fb2JqZWN0X3RyeWxvY2soc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKIAog c3RhdGljIGlubGluZSB2b2lkIGk5MTVfZ2VtX29iamVjdF91bmxvY2soc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaikKIHsKKwlpZiAob2JqLT5vcHMtPmFkanVzdF9scnUpCisJCW9iai0+ b3BzLT5hZGp1c3RfbHJ1KG9iaik7CisKIAlkbWFfcmVzdl91bmxvY2sob2JqLT5iYXNlLnJlc3Yp OwogfQogCkBAIC01ODcsNiArNTkwLDEyIEBAIGludCBpOTE1X2dlbV9vYmplY3RfcmVhZF9mcm9t X3BhZ2Uoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwgdTY0IG9mZnNldCwKIAogYm9v bCBpOTE1X2dlbV9vYmplY3RfaXNfc2htZW0oY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKm9iaik7CiAKK3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3Uoc3RydWN0IHJjdV9o ZWFkICpoZWFkKTsKKwordm9pZCBfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0KHN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmopOworCitib29sIGk5MTVfZ2VtX29iamVjdF9ldmljdGFibGUoc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKICNpZmRlZiBDT05GSUdfTU1VX05PVElG SUVSCiBzdGF0aWMgaW5saW5lIGJvb2wKIGk5MTVfZ2VtX29iamVjdF9pc191c2VycHRyKHN0cnVj dCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmgKaW5kZXggZDA0N2VhMTI2MDI5Li42ODMxMzQ3NGU2 YTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3Rf dHlwZXMuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5 cGVzLmgKQEAgLTYzLDYgKzYzLDIwIEBAIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0X29wcyB7 CiAJCSAgICAgIGNvbnN0IHN0cnVjdCBkcm1faTkxNV9nZW1fcHdyaXRlICphcmcpOwogCiAJaW50 ICgqZG1hYnVmX2V4cG9ydCkoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKKwkv KioKKwkgKiBhZGp1c3RfbHJ1IC0gbm90aWZ5IHRoYXQgdGhlIG1hZHZpc2UgdmFsdWUgd2FzIHVw ZGF0ZWQKKwkgKiBAb2JqOiBUaGUgZ2VtIG9iamVjdAorCSAqCisJICogVGhlIG1hZHZpc2UgdmFs dWUgbWF5IGhhdmUgYmVlbiB1cGRhdGVkLCBvciBvYmplY3Qgd2FzIHJlY2VudGx5CisJICogcmVm ZXJlbmNlZCBzbyBhY3QgYWNjb3JkaW5nbHkgKFBlcmhhcHMgY2hhbmdpbmcgYW4gTFJVIGxpc3Qg ZXRjKS4KKwkgKi8KKwl2b2lkICgqYWRqdXN0X2xydSkoc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKm9iaik7CisKKwkvKioKKwkgKiBkZWxheWVkX2ZyZWUgLSBPdmVycmlkZSB0aGUgZGVmYXVs dCBkZWxheWVkIGZyZWUgaW1wbGVtZW50YXRpb24KKwkgKi8KKwl2b2lkICgqZGVsYXllZF9mcmVl KShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKIAl2b2lkICgqcmVsZWFzZSkoc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CiAKIAljb25zdCBjaGFyICpuYW1lOyAvKiBm cmllbmRseSBuYW1lIGZvciBkZWJ1ZywgZS5nLiBsb2NrZGVwIGNsYXNzZXMgKi8KQEAgLTE4Nywx MiArMjAxLDE0IEBAIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0IHsKICNkZWZpbmUgSTkxNV9C T19BTExPQ19WT0xBVElMRSAgIEJJVCgxKQogI2RlZmluZSBJOTE1X0JPX0FMTE9DX1NUUlVDVF9Q QUdFIEJJVCgyKQogI2RlZmluZSBJOTE1X0JPX0FMTE9DX0NQVV9DTEVBUiAgQklUKDMpCisjZGVm aW5lIEk5MTVfQk9fQUxMT0NfVVNFUiAgICAgICBCSVQoNCkKICNkZWZpbmUgSTkxNV9CT19BTExP Q19GTEFHUyAoSTkxNV9CT19BTExPQ19DT05USUdVT1VTIHwgXAogCQkJICAgICBJOTE1X0JPX0FM TE9DX1ZPTEFUSUxFIHwgXAogCQkJICAgICBJOTE1X0JPX0FMTE9DX1NUUlVDVF9QQUdFIHwgXAot CQkJICAgICBJOTE1X0JPX0FMTE9DX0NQVV9DTEVBUikKLSNkZWZpbmUgSTkxNV9CT19SRUFET05M WSAgICAgICAgIEJJVCg0KQotI2RlZmluZSBJOTE1X1RJTElOR19RVUlSS19CSVQgICAgNSAvKiB1 bmtub3duIHN3aXp6bGluZzsgZG8gbm90IHJlbGVhc2UhICovCisJCQkgICAgIEk5MTVfQk9fQUxM T0NfQ1BVX0NMRUFSIHwgXAorCQkJICAgICBJOTE1X0JPX0FMTE9DX1VTRVIpCisjZGVmaW5lIEk5 MTVfQk9fUkVBRE9OTFkgICAgICAgICBCSVQoNSkKKyNkZWZpbmUgSTkxNV9USUxJTkdfUVVJUktf QklUICAgIDYgLyogdW5rbm93biBzd2l6emxpbmc7IGRvIG5vdCByZWxlYXNlISAqLwogCiAJLyoK IAkgKiBJcyB0aGUgb2JqZWN0IHRvIGJlIG1hcHBlZCBhcyByZWFkLW9ubHkgdG8gdGhlIEdQVQpA QCAtMzEwLDYgKzMyNiwxMSBAQCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCB7CiAJCWJvb2wg ZGlydHk6MTsKIAl9IG1tOwogCisJc3RydWN0IHsKKwkJc3RydWN0IHNnX3RhYmxlICpjYWNoZWRf aW9fc3Q7CisJCWJvb2wgY3JlYXRlZDoxOworCX0gdHRtOworCiAJLyoqIFJlY29yZCBvZiBhZGRy ZXNzIGJpdCAxNyBvZiBlYWNoIHBhZ2UgYXQgbGFzdCB1bmJpbmQuICovCiAJdW5zaWduZWQgbG9u ZyAqYml0XzE3OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9n ZW1fcmVnaW9uLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMK aW5kZXggZjI1ZTY2NDZjNWI3Li5kMWYxODQwNTQwZGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMKQEAgLTE4LDExICsxOCw3IEBAIHZvaWQgaTkxNV9nZW1f b2JqZWN0X2luaXRfbWVtb3J5X3JlZ2lvbihzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2Jq LAogCiAJbXV0ZXhfbG9jaygmbWVtLT5vYmplY3RzLmxvY2spOwogCi0JaWYgKG9iai0+ZmxhZ3Mg JiBJOTE1X0JPX0FMTE9DX1ZPTEFUSUxFKQotCQlsaXN0X2FkZCgmb2JqLT5tbS5yZWdpb25fbGlu aywgJm1lbS0+b2JqZWN0cy5wdXJnZWFibGUpOwotCWVsc2UKLQkJbGlzdF9hZGQoJm9iai0+bW0u cmVnaW9uX2xpbmssICZtZW0tPm9iamVjdHMubGlzdCk7Ci0KKwlsaXN0X2FkZCgmb2JqLT5tbS5y ZWdpb25fbGluaywgJm1lbS0+b2JqZWN0cy5saXN0KTsKIAltdXRleF91bmxvY2soJm1lbS0+b2Jq ZWN0cy5sb2NrKTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uM2NlYzc3N2JlMzQ2Ci0tLSAv ZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jCkBA IC0wLDAgKzEsNTMxIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUCisvKgorICog Q29weXJpZ2h0IMKpIDIwMjEgSW50ZWwgQ29ycG9yYXRpb24KKyAqLworCisjaW5jbHVkZSA8ZHJt L3R0bS90dG1fYm9fZHJpdmVyLmg+CisjaW5jbHVkZSA8ZHJtL3R0bS90dG1fcGxhY2VtZW50Lmg+ CisKKyNpbmNsdWRlICJpOTE1X2Rydi5oIgorI2luY2x1ZGUgImludGVsX21lbW9yeV9yZWdpb24u aCIKKyNpbmNsdWRlICJpbnRlbF9yZWdpb25fdHRtLmgiCisKKyNpbmNsdWRlICJnZW0vaTkxNV9n ZW1fb2JqZWN0LmgiCisjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIgorI2luY2x1ZGUg ImdlbS9pOTE1X2dlbV90dG0uaCIKKworI2RlZmluZSBJOTE1X1BMX0xNRU0wIFRUTV9QTF9QUklW CisjZGVmaW5lIEk5MTVfUExfU1lTVEVNIFRUTV9QTF9TWVNURU0KKyNkZWZpbmUgSTkxNV9QTF9T VE9MRU4gVFRNX1BMX1ZSQU0KKyNkZWZpbmUgSTkxNV9QTF9HR1RUIFRUTV9QTF9UVAorCisjZGVm aW5lIEk5MTVfVFRNX1BSSU9fUFVSR0UgICAgIDAKKyNkZWZpbmUgSTkxNV9UVE1fUFJJT19OT19Q QUdFUyAgMQorI2RlZmluZSBJOTE1X1RUTV9QUklPX0hBU19QQUdFUyAyCisKKy8qKgorICogc3Ry dWN0IGk5MTVfdHRtX3R0IC0gVFRNIHBhZ2UgdmVjdG9yIHdpdGggYWRkaXRpb25hbCBwcml2YXRl IGluZm9ybWF0aW9uCisgKiBAdHRtOiBUaGUgYmFzZSBUVE0gcGFnZSB2ZWN0b3IuCisgKiBAZGV2 OiBUaGUgc3RydWN0IGRldmljZSB1c2VkIGZvciBkbWEgbWFwcGluZyBhbmQgdW5tYXBwaW5nLgor ICogQGNhY2hlZF9zdDogVGhlIGNhY2hlZCBzY2F0dGVyLWdhdGhlciB0YWJsZS4KKyAqCisgKiBO b3RlIHRoYXQgRE1BIG1heSBiZSBnb2luZyBvbiByaWdodCB1cCB0byB0aGUgcG9pbnQgd2hlcmUg dGhlIHBhZ2UtCisgKiB2ZWN0b3IgaXMgdW5wb3B1bGF0ZWQgaW4gZGVsYXllZCBkZXN0cm95LiBI ZW5jZSBrZWVwIHRoZQorICogc2NhdHRlci1nYXRoZXIgdGFibGUgbWFwcGVkIGFuZCBjYWNoZWQg dXAgdG8gdGhhdCBwb2ludC4gVGhpcyBpcworICogZGlmZmVyZW50IGZyb20gdGhlIGNhY2hlZCBn ZW0gb2JqZWN0IGlvIHNjYXR0ZXItZ2F0aGVyIHRhYmxlIHdoaWNoCisgKiBkb2Vzbid0IGhhdmUg YW4gYXNzb2NpYXRlZCBkbWEgbWFwcGluZy4KKyAqLworc3RydWN0IGk5MTVfdHRtX3R0IHsKKwlz dHJ1Y3QgdHRtX3R0IHR0bTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXY7CisJc3RydWN0IHNnX3RhYmxl ICpjYWNoZWRfc3Q7Cit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IHR0bV9wbGFjZSBsbWVtMF9z eXNfcGxhY2VtZW50X2ZsYWdzW10gPSB7CisJeworCQkuZnBmbiA9IDAsCisJCS5scGZuID0gMCwK KwkJLm1lbV90eXBlID0gSTkxNV9QTF9MTUVNMCwKKwkJLmZsYWdzID0gMCwKKwl9LCB7CisJCS5m cGZuID0gMCwKKwkJLmxwZm4gPSAwLAorCQkubWVtX3R5cGUgPSBJOTE1X1BMX1NZU1RFTSwKKwkJ LmZsYWdzID0gMCwKKwl9Cit9OworCitzdGF0aWMgc3RydWN0IHR0bV9wbGFjZW1lbnQgaTkxNV9s bWVtMF9wbGFjZW1lbnQgPSB7CisJLm51bV9wbGFjZW1lbnQgPSAxLAorCS5wbGFjZW1lbnQgPSAm bG1lbTBfc3lzX3BsYWNlbWVudF9mbGFnc1swXSwKKwkubnVtX2J1c3lfcGxhY2VtZW50ID0gMSwK KwkuYnVzeV9wbGFjZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFnc1swXSwKK307CisK K3N0YXRpYyBzdHJ1Y3QgdHRtX3BsYWNlbWVudCBpOTE1X3N5c19wbGFjZW1lbnQgPSB7CisJLm51 bV9wbGFjZW1lbnQgPSAxLAorCS5wbGFjZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFn c1sxXSwKKwkubnVtX2J1c3lfcGxhY2VtZW50ID0gMSwKKwkuYnVzeV9wbGFjZW1lbnQgPSAmbG1l bTBfc3lzX3BsYWNlbWVudF9mbGFnc1sxXSwKK307CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX2Fk anVzdF9scnUoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaik7CisKK3N0YXRpYyBzdHJ1 Y3QgdHRtX3R0ICppOTE1X3R0bV90dF9jcmVhdGUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpi bywKKwkJCQkJIHVpbnQzMl90IHBhZ2VfZmxhZ3MpCit7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9t YW5hZ2VyICptYW4gPQorCQl0dG1fbWFuYWdlcl90eXBlKGJvLT5iZGV2LCBiby0+bWVtLm1lbV90 eXBlKTsKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2Vt KGJvKTsKKwlzdHJ1Y3QgaTkxNV90dG1fdHQgKmk5MTVfdHQ7CisJaW50IHJldDsKKworCWk5MTVf dHQgPSBremFsbG9jKHNpemVvZigqaTkxNV90dCksIEdGUF9LRVJORUwpOworCWlmICghaTkxNV90 dCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfQ1BV X0NMRUFSICYmCisJICAgIG1hbi0+dXNlX3R0KQorCQlwYWdlX2ZsYWdzIHw9IFRUTV9QQUdFX0ZM QUdfWkVST19BTExPQzsKKworCXJldCA9IHR0bV90dF9pbml0KCZpOTE1X3R0LT50dG0sIGJvLCBw YWdlX2ZsYWdzLCB0dG1fd3JpdGVfY29tYmluZWQpOworCWlmIChyZXQpIHsKKwkJa2ZyZWUoaTkx NV90dCk7CisJCXJldHVybiBOVUxMOworCX0KKworCWk5MTVfdHQtPmRldiA9IG9iai0+YmFzZS5k ZXYtPmRldjsKKworCXJldHVybiAmaTkxNV90dC0+dHRtOworfQorCitzdGF0aWMgdm9pZCBpOTE1 X3R0bV90dF91bnBvcHVsYXRlKHN0cnVjdCB0dG1fZGV2aWNlICpiZGV2LCBzdHJ1Y3QgdHRtX3R0 ICp0dG0pCit7CisJc3RydWN0IGk5MTVfdHRtX3R0ICppOTE1X3R0ID0gY29udGFpbmVyX29mKHR0 bSwgdHlwZW9mKCppOTE1X3R0KSwgdHRtKTsKKworCWlmIChpOTE1X3R0LT5jYWNoZWRfc3QpIHsK KwkJZG1hX3VubWFwX3NndGFibGUoaTkxNV90dC0+ZGV2LCBpOTE1X3R0LT5jYWNoZWRfc3QsCisJ CQkJICBETUFfQklESVJFQ1RJT05BTCwgMCk7CisJCXNnX2ZyZWVfdGFibGUoaTkxNV90dC0+Y2Fj aGVkX3N0KTsKKwkJa2ZyZWUoaTkxNV90dC0+Y2FjaGVkX3N0KTsKKwkJaTkxNV90dC0+Y2FjaGVk X3N0ID0gTlVMTDsKKwl9CisJdHRtX3Bvb2xfZnJlZSgmYmRldi0+cG9vbCwgdHRtKTsKK30KKwor c3RhdGljIHZvaWQgaTkxNV90dG1fdHRfZGVzdHJveShzdHJ1Y3QgdHRtX2RldmljZSAqYmRldiwg c3RydWN0IHR0bV90dCAqdHRtKQoreworCXN0cnVjdCBpOTE1X3R0bV90dCAqaTkxNV90dCA9IGNv bnRhaW5lcl9vZih0dG0sIHR5cGVvZigqaTkxNV90dCksIHR0bSk7CisKKwl0dG1fdHRfZGVzdHJv eV9jb21tb24oYmRldiwgdHRtKTsKKwlrZnJlZShpOTE1X3R0KTsKK30KKworc3RhdGljIGJvb2wg aTkxNV90dG1fZXZpY3Rpb25fdmFsdWFibGUoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywK KwkJCQkgICAgICAgY29uc3Qgc3RydWN0IHR0bV9wbGFjZSAqcGxhY2UpCit7CisJc3RydWN0IGRy bV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CisKKwkvKiBXaWxs IGRvIGZvciBub3cuIE91ciBwaW5uZWQgb2JqZWN0cyBhcmUgc3RpbGwgb24gVFRNJ3MgTFJVIGxp c3RzICovCisJaWYgKCFpOTE1X2dlbV9vYmplY3RfZXZpY3RhYmxlKG9iaikpCisJCXJldHVybiBm YWxzZTsKKworCS8qIFRoaXMgaXNuJ3QgdmFsaWQgd2l0aCBhIGJ1ZGR5IGFsbG9jYXRvciAqLwor CXJldHVybiB0dG1fYm9fZXZpY3Rpb25fdmFsdWFibGUoYm8sIHBsYWNlKTsKK30KKworc3RhdGlj IHZvaWQgaTkxNV90dG1fZXZpY3RfZmxhZ3Moc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywK KwkJCQkgc3RydWN0IHR0bV9wbGFjZW1lbnQgKnBsYWNlbWVudCkKK3sKKwkqcGxhY2VtZW50ID0g aTkxNV9zeXNfcGxhY2VtZW50OworfQorCitzdGF0aWMgaW50IGk5MTVfdHRtX21vdmVfbm90aWZ5 KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CisJaW50IHJldDsKKworCXJldCA9IGk5 MTVfZ2VtX29iamVjdF91bmJpbmQob2JqLCBJOTE1X0dFTV9PQkpFQ1RfVU5CSU5EX0FDVElWRSk7 CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9IF9faTkxNV9nZW1fb2JqZWN0X3B1 dF9wYWdlcyhvYmopOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30K Kworc3RhdGljIHZvaWQgaTkxNV90dG1fZnJlZV9jYWNoZWRfaW9fc3Qoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaikKK3sKKwlpZiAob2JqLT50dG0uY2FjaGVkX2lvX3N0KSB7CisJCXNn X2ZyZWVfdGFibGUob2JqLT50dG0uY2FjaGVkX2lvX3N0KTsKKwkJa2ZyZWUob2JqLT50dG0uY2Fj aGVkX2lvX3N0KTsKKwkJb2JqLT50dG0uY2FjaGVkX2lvX3N0ID0gTlVMTDsKKwl9Cit9CisKK3N0 YXRpYyB2b2lkIGk5MTVfdHRtX3B1cmdlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmop Cit7CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmop OworCXN0cnVjdCB0dG1fb3BlcmF0aW9uX2N0eCBjdHggPSB7CisJCS5pbnRlcnJ1cHRpYmxlID0g dHJ1ZSwKKwkJLm5vX3dhaXRfZ3B1ID0gZmFsc2UsCisJfTsKKwlzdHJ1Y3QgdHRtX3BsYWNlbWVu dCBwbGFjZSA9IHt9OworCWludCByZXQ7CisKKwlpZiAob2JqLT5tbS5tYWR2ID09IF9fSTkxNV9N QURWX1BVUkdFRCkKKwkJcmV0dXJuOworCisJLyogVFRNJ3MgcHVyZ2UgaW50ZXJmYWNlLiBOb3Rl IHRoYXQgd2UgbWlnaHQgYmUgcmVlbnRlcmluZy4gKi8KKwlyZXQgPSB0dG1fYm9fdmFsaWRhdGUo Ym8sICZwbGFjZSwgJmN0eCk7CisKKwlpZiAoIXJldCkgeworCQlpOTE1X3R0bV9mcmVlX2NhY2hl ZF9pb19zdChvYmopOworCQlvYmotPm1tLm1hZHYgPSBfX0k5MTVfTUFEVl9QVVJHRUQ7CisJfQor fQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV9zd2FwX25vdGlmeShzdHJ1Y3QgdHRtX2J1ZmZlcl9v YmplY3QgKmJvKQoreworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0 bV90b19nZW0oYm8pOworCWludCByZXQgPSBpOTE1X3R0bV9tb3ZlX25vdGlmeShibyk7CisKKwlH RU1fV0FSTl9PTihyZXQpOworCUdFTV9XQVJOX09OKG9iai0+dHRtLmNhY2hlZF9pb19zdCk7CisJ aWYgKCFyZXQgJiYgb2JqLT5tbS5tYWR2ICE9IEk5MTVfTUFEVl9XSUxMTkVFRCkKKwkJaTkxNV90 dG1fcHVyZ2Uob2JqKTsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fZGVsZXRlX21lbV9ub3Rp Znkoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibykKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKworCWlmIChsaWtlbHkob2JqKSkg eworCQkvKiBUaGlzIHJlbGVhc2VzIGFsbCBnZW0gb2JqZWN0IGJpbmRpbmdzIHRvIHRoZSBiYWNr ZW5kLiAqLworCQlfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0KG9iaik7CisJfQorfQorCitzdGF0aWMg c3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKgoraTkxNV90dG1fcmVnaW9uKHN0cnVjdCB0dG1f ZGV2aWNlICpiZGV2LCBpbnQgdHRtX21lbV90eXBlKQoreworCXN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICppOTE1ID0gY29udGFpbmVyX29mKGJkZXYsIHR5cGVvZigqaTkxNSksIGJkZXYpOworCisJ LyogVGhlcmUncyBzb21lIHJvb20gZm9yIG9wdGltaXphdGlvbiBoZXJlLi4uICovCisJR0VNX0JV R19PTih0dG1fbWVtX3R5cGUgIT0gSTkxNV9QTF9TWVNURU0gJiYKKwkJICAgdHRtX21lbV90eXBl IDwgSTkxNV9QTF9MTUVNMCk7CisJaWYgKHR0bV9tZW1fdHlwZSA9PSBJOTE1X1BMX1NZU1RFTSkK KwkJcmV0dXJuIGludGVsX21lbW9yeV9yZWdpb25fbG9va3VwKGk5MTUsIElOVEVMX01FTU9SWV9T WVNURU0sCisJCQkJCQkgIDApOworCisJcmV0dXJuIGludGVsX21lbW9yeV9yZWdpb25fbG9va3Vw KGk5MTUsIElOVEVMX01FTU9SWV9MT0NBTCwKKwkJCQkJICB0dG1fbWVtX3R5cGUgLSBJOTE1X1BM X0xNRU0wKTsKK30KKworc3RhdGljIHN0cnVjdCBzZ190YWJsZSAqaTkxNV90dG1fdHRfZ2V0X3N0 KHN0cnVjdCB0dG1fdHQgKnR0bSkKK3sKKwlzdHJ1Y3QgaTkxNV90dG1fdHQgKmk5MTVfdHQgPSBj b250YWluZXJfb2YodHRtLCB0eXBlb2YoKmk5MTVfdHQpLCB0dG0pOworCXN0cnVjdCBzY2F0dGVy bGlzdCAqc2c7CisJc3RydWN0IHNnX3RhYmxlICpzdDsKKwlpbnQgcmV0OworCisJaWYgKGk5MTVf dHQtPmNhY2hlZF9zdCkKKwkJcmV0dXJuIGk5MTVfdHQtPmNhY2hlZF9zdDsKKworCXN0ID0ga3ph bGxvYyhzaXplb2YoKnN0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFzdCkKKwkJcmV0dXJuIEVSUl9Q VFIoLUVOT01FTSk7CisKKwlzZyA9IF9fc2dfYWxsb2NfdGFibGVfZnJvbV9wYWdlcworCQkoc3Qs IHR0bS0+cGFnZXMsIHR0bS0+bnVtX3BhZ2VzLCAwLAorCQkgKHVuc2lnbmVkIGxvbmcpdHRtLT5u dW1fcGFnZXMgPDwgUEFHRV9TSElGVCwKKwkJIGk5MTVfc2dfc2VnbWVudF9zaXplKCksIE5VTEws IDAsIEdGUF9LRVJORUwpOworCWlmIChJU19FUlIoc2cpKSB7CisJCWtmcmVlKHN0KTsKKwkJcmV0 dXJuIEVSUl9DQVNUKHNnKTsKKwl9CisKKwlyZXQgPSBkbWFfbWFwX3NndGFibGUoaTkxNV90dC0+ ZGV2LCBzdCwgRE1BX0JJRElSRUNUSU9OQUwsIDApOworCWlmIChyZXQpIHsKKwkJc2dfZnJlZV90 YWJsZShzdCk7CisJCWtmcmVlKHN0KTsKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisKKwlp OTE1X3R0LT5jYWNoZWRfc3QgPSBzdDsKKwlyZXR1cm4gc3Q7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qg c2dfdGFibGUgKgoraTkxNV90dG1fcmVzb3VyY2VfZ2V0X3N0KHN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmosCisJCQkgc3RydWN0IHR0bV9yZXNvdXJjZSAqcmVzKQoreworCXN0cnVjdCB0 dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190dG0ob2JqKTsKKwlzdHJ1Y3QgdHRt X3Jlc291cmNlX21hbmFnZXIgKm1hbiA9CisJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIHJl cy0+bWVtX3R5cGUpOworCisJaWYgKG1hbi0+dXNlX3R0KQorCQlyZXR1cm4gaTkxNV90dG1fdHRf Z2V0X3N0KGJvLT50dG0pOworCisJcmV0dXJuIGludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChv YmotPm1tLnJlZ2lvbiwgcmVzLT5tbV9ub2RlKTsKK30KKworc3RhdGljIGludCBpOTE1X3R0bV9t b3ZlKHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sIGJvb2wgZXZpY3QsCisJCQkgc3RydWN0 IHR0bV9vcGVyYXRpb25fY3R4ICpjdHgsCisJCQkgc3RydWN0IHR0bV9yZXNvdXJjZSAqZHN0X21l bSwKKwkJCSBzdHJ1Y3QgdHRtX3BsYWNlICpob3ApCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CisJc3RydWN0IHR0bV9yZXNvdXJjZV9t YW5hZ2VyICpkc3RfbWFuID0KKwkJdHRtX21hbmFnZXJfdHlwZShiby0+YmRldiwgZHN0X21lbS0+ bWVtX3R5cGUpOworCXN0cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdlciAqc3JjX21hbiA9CisJCXR0 bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIGJvLT5tZW0ubWVtX3R5cGUpOworCXN0cnVjdCBpbnRl bF9tZW1vcnlfcmVnaW9uICpkc3RfcmVnLCAqc3JjX3JlZzsKKwl1bmlvbiB7CisJCXN0cnVjdCB0 dG1fa21hcF9pdGVyX3R0IHR0OworCQlzdHJ1Y3QgdHRtX2ttYXBfaXRlcl9pb21hcCBpbzsKKwl9 IF9kc3RfaXRlciwgX3NyY19pdGVyOworCXN0cnVjdCB0dG1fa21hcF9pdGVyICpkc3RfaXRlciwg KnNyY19pdGVyOworCXN0cnVjdCBzZ190YWJsZSAqZHN0X3N0OworCWludCByZXQ7CisKKwlkc3Rf cmVnID0gaTkxNV90dG1fcmVnaW9uKGJvLT5iZGV2LCBkc3RfbWVtLT5tZW1fdHlwZSk7CisJc3Jj X3JlZyA9IGk5MTVfdHRtX3JlZ2lvbihiby0+YmRldiwgYm8tPm1lbS5tZW1fdHlwZSk7CisJR0VN X0JVR19PTighZHN0X3JlZyB8fCAhc3JjX3JlZyk7CisKKwkvKiBTeW5jIGZvciBub3cuIFdlIGNv dWxkIGRvIHRoZSBhY3R1YWwgY29weSBhc3luYy4gKi8KKwlyZXQgPSB0dG1fYm9fd2FpdF9jdHgo Ym8sIGN0eCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9IGk5MTVfdHRtX21v dmVfbm90aWZ5KGJvKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJaWYgKG9iai0+bW0u bWFkdiAhPSBJOTE1X01BRFZfV0lMTE5FRUQpIHsKKwkJaTkxNV90dG1fcHVyZ2Uob2JqKTsKKwkJ dHRtX3Jlc291cmNlX2ZyZWUoYm8sIGRzdF9tZW0pOworCQlyZXR1cm4gMDsKKwl9CisKKwkvKiBQ b3B1bGF0ZSB0dG0gd2l0aCBwYWdlcyBpZiBuZWVkZWQuIFR5cGljYWxseSBzeXN0ZW0gbWVtb3J5 LiAqLworCWlmIChiby0+dHRtICYmIChkc3RfbWFuLT51c2VfdHQgfHwKKwkJCShiby0+dHRtLT5w YWdlX2ZsYWdzICYgVFRNX1BBR0VfRkxBR19TV0FQUEVEKSkpIHsKKwkJcmV0ID0gdHRtX3R0X3Bv cHVsYXRlKGJvLT5iZGV2LCBiby0+dHRtLCBjdHgpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJl dDsKKwl9CisKKwlkc3Rfc3QgPSBpOTE1X3R0bV9yZXNvdXJjZV9nZXRfc3Qob2JqLCBkc3RfbWVt KTsKKwlpZiAoSVNfRVJSKGRzdF9zdCkpCisJCXJldHVybiBQVFJfRVJSKGRzdF9zdCk7CisKKwkv KiBJZiB3ZSBzdGFydCBtYXBwaW5nIEdHVFQsIHdlIGNhbiBubyBsb25nZXIgdXNlIG1hbjo6dXNl X3R0IGhlcmUuICovCisJZHN0X2l0ZXIgPSBkc3RfbWFuLT51c2VfdHQgPworCQl0dG1fa21hcF9p dGVyX3R0X2luaXQoJl9kc3RfaXRlci50dCwgYm8tPnR0bSkgOgorCQl0dG1fa21hcF9pdGVyX2lv bWFwX2luaXQoJl9kc3RfaXRlci5pbywgJmRzdF9yZWctPmlvbWFwLAorCQkJCQkgZHN0X3N0LCBk c3RfcmVnLT5yZWdpb24uc3RhcnQpOworCisJc3JjX2l0ZXIgPSBzcmNfbWFuLT51c2VfdHQgPwor CQl0dG1fa21hcF9pdGVyX3R0X2luaXQoJl9zcmNfaXRlci50dCwgYm8tPnR0bSkgOgorCQl0dG1f a21hcF9pdGVyX2lvbWFwX2luaXQoJl9zcmNfaXRlci5pbywgJnNyY19yZWctPmlvbWFwLAorCQkJ CQkgb2JqLT50dG0uY2FjaGVkX2lvX3N0LAorCQkJCQkgc3JjX3JlZy0+cmVnaW9uLnN0YXJ0KTsK KworCXR0bV9tb3ZlX21lbWNweShibywgZHN0X21lbSwgZHN0X2l0ZXIsIHNyY19pdGVyKTsKKwl0 dG1fYm9fbW92ZV9zeW5jX2NsZWFudXAoYm8sIGRzdF9tZW0pOworCWk5MTVfdHRtX2ZyZWVfY2Fj aGVkX2lvX3N0KG9iaik7CisKKwlpZiAoIWRzdF9tYW4tPnVzZV90dCkKKwkJb2JqLT50dG0uY2Fj aGVkX2lvX3N0ID0gZHN0X3N0OworCisJcmV0dXJuIDA7Cit9CisKK3N0cnVjdCB0dG1fZGV2aWNl X2Z1bmNzIGk5MTVfdHRtX2JvX2RyaXZlciA9IHsKKwkudHRtX3R0X2NyZWF0ZSA9IGk5MTVfdHRt X3R0X2NyZWF0ZSwKKwkudHRtX3R0X3VucG9wdWxhdGUgPSBpOTE1X3R0bV90dF91bnBvcHVsYXRl LAorCS50dG1fdHRfZGVzdHJveSA9IGk5MTVfdHRtX3R0X2Rlc3Ryb3ksCisJLmV2aWN0aW9uX3Zh bHVhYmxlID0gaTkxNV90dG1fZXZpY3Rpb25fdmFsdWFibGUsCisJLmV2aWN0X2ZsYWdzID0gaTkx NV90dG1fZXZpY3RfZmxhZ3MsCisJLm1vdmUgPSBpOTE1X3R0bV9tb3ZlLAorCS52ZXJpZnlfYWNj ZXNzID0gTlVMTCwKKwkuc3dhcF9ub3RpZnkgPSBpOTE1X3R0bV9zd2FwX25vdGlmeSwKKwkuZGVs ZXRlX21lbV9ub3RpZnkgPSBpOTE1X3R0bV9kZWxldGVfbWVtX25vdGlmeSwKK307CisKK3N0YXRp YyBpbnQgaTkxNV90dG1fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmop Cit7CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmop OworCXN0cnVjdCB0dG1fb3BlcmF0aW9uX2N0eCBjdHggPSB7CisJCS5pbnRlcnJ1cHRpYmxlID0g dHJ1ZSwKKwkJLm5vX3dhaXRfZ3B1ID0gZmFsc2UsCisJfTsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnN0 OworCWludCByZXQ7CisKKwkvKiBNb3ZlIHRvIHRoZSByZXF1ZXN0ZWQgcGxhY2VtZW50LiAqLwor CXJldCA9IHR0bV9ib192YWxpZGF0ZShibywgJmk5MTVfbG1lbTBfcGxhY2VtZW50LCAmY3R4KTsK KwlpZiAocmV0KQorCQlyZXR1cm4gcmV0ID09IC1FTk9TUEMgPyAtRU5YSU8gOiByZXQ7CisKKwkv KiBPYmplY3QgZWl0aGVyIGhhcyBhIHBhZ2UgdmVjdG9yIG9yIGlzIGFuIGlvbWVtIG9iamVjdCAq LworCXN0ID0gYm8tPnR0bSA/IGk5MTVfdHRtX3R0X2dldF9zdChiby0+dHRtKSA6IG9iai0+dHRt LmNhY2hlZF9pb19zdDsKKwlpZiAoSVNfRVJSKHN0KSkKKwkJcmV0dXJuIFBUUl9FUlIoc3QpOwor CisJX19pOTE1X2dlbV9vYmplY3Rfc2V0X3BhZ2VzKG9iaiwgc3QsIGk5MTVfc2dfZG1hX3NpemVz KHN0LT5zZ2wpKTsKKworCWk5MTVfdHRtX2FkanVzdF9scnUob2JqKTsKKworCXJldHVybiByZXQ7 Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX3B1dF9wYWdlcyhzdHJ1Y3QgZHJtX2k5MTVfZ2Vt X29iamVjdCAqb2JqLAorCQkJICAgICAgIHN0cnVjdCBzZ190YWJsZSAqc3QpCit7CisJLyoKKwkg KiBXZSdyZSBjdXJyZW50bHkgbm90IGNhbGxlZCBmcm9tIGEgc2hyaW5rZXIsIHNvIHB1dF9wYWdl cygpCisJICogdHlwaWNhbGx5IG1lYW5zIHRoZSBvYmplY3QgaXMgYWJvdXQgdG8gZGVzdHJveWVk LCBvciBjYWxsZWQKKwkgKiBmcm9tIG1vdmVfbm90aWZ5KCkuIFNvIGp1c3QgYXZvaWQgZG9pbmcg bXVjaCBmb3Igbm93LgorCSAqIElmIHRoZSBvYmplY3QgaXMgbm90IGRlc3Ryb3llZCBuZXh0LCBU aGUgVFRNIGV2aWN0aW9uIGxvZ2ljCisJICogYW5kIHNocmlua2VycyB3aWxsIG1vdmUgaXQgb3V0 IGlmIG5lZWRlZC4KKwkgKi8KKworCWk5MTVfdHRtX2FkanVzdF9scnUob2JqKTsKK30KKworc3Rh dGljIHZvaWQgaTkxNV90dG1fYWRqdXN0X2xydShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAq b2JqKQoreworCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190dG0o b2JqKTsKKworCS8qCisJICogRG9uJ3QgbWFuaXB1bGF0ZSB0aGUgVFRNIExSVXMgd2hpbGUgaW4g VFRNIGJvIGRlc3RydWN0aW9uLgorCSAqIFdlJ3JlIGNhbGxlZCB0aHJvdWdoIGk5MTVfdHRtX2Rl bGV0ZV9tZW1fbm90aWZ5KCkuCisJICovCisJaWYgKCFrcmVmX3JlYWQoJmJvLT5rcmVmKSkKKwkJ cmV0dXJuOworCisJLyoKKwkgKiBQdXQgb24gdGhlIGNvcnJlY3QgTFJVIGxpc3QgZGVwZW5kaW5n IG9uIHRoZSBNQURWIHN0YXR1cworCSAqLworCXNwaW5fbG9jaygmYm8tPmJkZXYtPmxydV9sb2Nr KTsKKwlpZiAob2JqLT5tbS5tYWR2ICE9IEk5MTVfTUFEVl9XSUxMTkVFRCkgeworCQliby0+cHJp b3JpdHkgPSBJOTE1X1RUTV9QUklPX1BVUkdFOworCX0gZWxzZSBpZiAoIWk5MTVfZ2VtX29iamVj dF9oYXNfcGFnZXMob2JqKSkgeworCQlpZiAoYm8tPnByaW9yaXR5IDwgSTkxNV9UVE1fUFJJT19I QVNfUEFHRVMpCisJCQliby0+cHJpb3JpdHkgPSBJOTE1X1RUTV9QUklPX0hBU19QQUdFUzsKKwl9 IGVsc2UgeworCQlpZiAoYm8tPnByaW9yaXR5ID4gSTkxNV9UVE1fUFJJT19OT19QQUdFUykKKwkJ CWJvLT5wcmlvcml0eSA9IEk5MTVfVFRNX1BSSU9fTk9fUEFHRVM7CisJfQorCisJdHRtX2JvX21v dmVfdG9fbHJ1X3RhaWwoYm8sICZiby0+bWVtLCBOVUxMKTsKKwlzcGluX3VubG9jaygmYm8tPmJk ZXYtPmxydV9sb2NrKTsKK30KKworLyoKKyAqIFRUTS1iYWNrZWQgZ2VtIG9iamVjdCBkZXN0cnVj dGlvbiByZXF1aXJlcyBzb21lIGNsYXJpZmljYXRpb24uCisgKiBCYXNpY2FsbHkgd2UgaGF2ZSB0 d28gcG9zc2liaWxpdGllcyBoZXJlLiBXZSBjYW4gZWl0aGVyIHJlbHkgb24gdGhlCisgKiBpOTE1 IGRlbGF5ZWQgZGVzdHJ1Y3Rpb24gYW5kIHB1dCB0aGUgVFRNIG9iamVjdCB3aGVuIHRoZSBvYmpl Y3QKKyAqIGlzIGlkbGUuIFRoaXMgd291bGQgYmUgZGV0ZWN0ZWQgYnkgVFRNIHdoaWNoIHdvdWxk IGJ5cGFzcyB0aGUKKyAqIFRUTSBkZWxheWVkIGRlc3Ryb3kgaGFuZGxpbmcuIFRoZSBvdGhlciBh cHByb2FjaCBpcyB0byBwdXQgdGhlIFRUTQorICogb2JqZWN0IGVhcmx5IGFuZCByZWx5IG9uIHRo ZSBUVE0gZGVzdHJveWVkIGhhbmRsaW5nLCBhbmQgdGhlbiBmcmVlCisgKiB0aGUgbGVmdG92ZXIg cGFydHMgb2YgdGhlIEdFTSBvYmplY3Qgb25jZSBUVE0ncyBkZXN0cm95ZWQgbGlzdCBoYW5kbGlu ZyBpcworICogY29tcGxldGUuIEZvciBub3csIHdlIHJlbHkgb24gdGhlIGxhdHRlciBmb3IgdHdv IHJlYXNvbnM6CisgKiBhKSBUVE0gY2FuIGV2aWN0IGFuIG9iamVjdCBldmVuIHdoZW4gaXQncyBv biB0aGUgZGVsYXllZCBkZXN0cm95IGxpc3QsCisgKiB3aGljaCBpbiB0aGVvcnkgYWxsb3dzIGZv ciBjb21wbGV0ZSBldmljdGlvbi4KKyAqIGIpIFRoZXJlIGlzIHdvcmsgZ29pbmcgb24gaW4gVFRN IHRvIGFsbG93IGZyZWVpbmcgYW4gb2JqZWN0IGV2ZW4gd2hlbgorICogaXQncyBub3QgaWRsZSwg YW5kIHVzaW5nIHRoZSBUVE0gZGVzdHJveWVkIGxpc3QgaGFuZGxpbmcgY291bGQgaGVscCB1cwor ICogYmVuZWZpdCBmcm9tIHRoYXQuCisgKi8KK3N0YXRpYyB2b2lkIGk5MTVfdHRtX2RlbGF5ZWRf ZnJlZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQoreworCWlmIChvYmotPnR0bS5j cmVhdGVkKSB7CisJCXR0bV9ib19wdXQoaTkxNV9nZW1fdG9fdHRtKG9iaikpOworCX0gZWxzZSB7 CisJCV9faTkxNV9nZW1fZnJlZV9vYmplY3Qob2JqKTsKKwkJY2FsbF9yY3UoJm9iai0+cmN1LCBf X2k5MTVfZ2VtX2ZyZWVfb2JqZWN0X3JjdSk7CisJfQorfQorCitzdGF0aWMgY29uc3Qgc3RydWN0 IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIGk5MTVfZ2VtX3R0bV9vYmpfb3BzID0geworCS5uYW1l ID0gImk5MTVfZ2VtX29iamVjdF90dG0iLAorCS5mbGFncyA9IEk5MTVfR0VNX09CSkVDVF9IQVNf SU9NRU0sCisKKwkuZ2V0X3BhZ2VzID0gaTkxNV90dG1fZ2V0X3BhZ2VzLAorCS5wdXRfcGFnZXMg PSBpOTE1X3R0bV9wdXRfcGFnZXMsCisJLnRydW5jYXRlID0gaTkxNV90dG1fcHVyZ2UsCisJLmFk anVzdF9scnUgPSBpOTE1X3R0bV9hZGp1c3RfbHJ1LAorCS5kZWxheWVkX2ZyZWUgPSBpOTE1X3R0 bV9kZWxheWVkX2ZyZWUsCit9OworCit2b2lkIGk5MTVfdHRtX2JvX2Rlc3Ryb3koc3RydWN0IHR0 bV9idWZmZXJfb2JqZWN0ICpibykKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2Jq ID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKworCWk5MTVfZ2VtX29iamVjdF9yZWxlYXNlX21lbW9y eV9yZWdpb24ob2JqKTsKKwlpZiAob2JqLT50dG0uY3JlYXRlZCkKKwkJY2FsbF9yY3UoJm9iai0+ cmN1LCBfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0X3JjdSk7Cit9CisKKy8qKgorICogX19pOTE1X2dl bV90dG1fb2JqZWN0X2luaXQgLSBJbml0aWFsaXplIGEgdHRtLWJhY2tlZCBpOTE1IGdlbSBvYmpl Y3QKKyAqIEBtZW06IFRoZSBpbml0aWFsIG1lbW9yeSByZWdpb24gZm9yIHRoZSBvYmplY3QuCisg KiBAb2JqOiBUaGUgZ2VtIG9iamVjdC4KKyAqIEBzaXplOiBPYmplY3Qgc2l6ZSBpbiBieXRlcy4K KyAqIEBmbGFnczogZ2VtIG9iamVjdCBmbGFncy4KKyAqCisgKiBSZXR1cm46IDAgb24gc3VjY2Vz cywgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgX19pOTE1X2dlbV90 dG1fb2JqZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKKwkJCSAgICAg ICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAorCQkJICAgICAgIHJlc291cmNlX3Np emVfdCBzaXplLAorCQkJICAgICAgIHVuc2lnbmVkIGludCBmbGFncykKK3sKKwlzdGF0aWMgc3Ry dWN0IGxvY2tfY2xhc3Nfa2V5IGxvY2tfY2xhc3M7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg Kmk5MTUgPSBtZW0tPmk5MTU7CisJZW51bSB0dG1fYm9fdHlwZSBib190eXBlOworCXNpemVfdCBh bGlnbm1lbnQgPSAwOworCWludCByZXQ7CisKKwkvKiBBZGp1c3QgYWxpZ25tZW50IHRvIEdQVS0g YW5kIENQVSBodWdlIHBhZ2Ugc2l6ZXMuICovCisKKwlpZiAobWVtLT5pc19yYW5nZV9tYW5hZ2Vy KSB7CisJCWlmIChzaXplID49IFNaXzFHKQorCQkJYWxpZ25tZW50ID0gU1pfMUcgPj4gUEFHRV9T SElGVDsKKwkJZWxzZSBpZiAoc2l6ZSA+PSBTWl8yTSkKKwkJCWFsaWdubWVudCA9IFNaXzJNID4+ IFBBR0VfU0hJRlQ7CisJCWVsc2UgaWYgKHNpemUgPj0gU1pfNjRLKQorCQkJYWxpZ25tZW50ID0g U1pfNjRLID4+IFBBR0VfU0hJRlQ7CisJfQorCisJZHJtX2dlbV9wcml2YXRlX29iamVjdF9pbml0 KCZpOTE1LT5kcm0sICZvYmotPmJhc2UsIHNpemUpOworCWk5MTVfZ2VtX29iamVjdF9pbml0KG9i aiwgJmk5MTVfZ2VtX3R0bV9vYmpfb3BzLCAmbG9ja19jbGFzcywgZmxhZ3MpOworCWk5MTVfZ2Vt X29iamVjdF9pbml0X21lbW9yeV9yZWdpb24ob2JqLCBtZW0pOworCWk5MTVfZ2VtX29iamVjdF9t YWtlX3Vuc2hyaW5rYWJsZShvYmopOworCW9iai0+cmVhZF9kb21haW5zID0gSTkxNV9HRU1fRE9N QUlOX1dDIHwgSTkxNV9HRU1fRE9NQUlOX0dUVDsKKwlpOTE1X2dlbV9vYmplY3Rfc2V0X2NhY2hl X2NvaGVyZW5jeShvYmosIEk5MTVfQ0FDSEVfTk9ORSk7CisKKwlib190eXBlID0gKG9iai0+Zmxh Z3MgJiBJOTE1X0JPX0FMTE9DX1VTRVIpID8gdHRtX2JvX3R5cGVfZGV2aWNlIDoKKwkJdHRtX2Jv X3R5cGVfa2VybmVsOworCisJLyoKKwkgKiBJZiB0aGlzIGZ1bmN0aW9uIGZhaWxzLCBpdCB3aWxs IGNhbGwgdGhlIGRlc3RydWN0b3IsIGJ1dAorCSAqIG91ciBjYWxsZXIgc3RpbGwgb3ducyB0aGUg b2JqZWN0LiBTbyBubyBmcmVlaW5nIGluIHRoZQorCSAqIGRlc3RydWN0b3IgdW50aWwgb2JqLT50 dG0uY3JlYXRlZCBpcyB0cnVlLgorCSAqIFNpbWlsYXJseSwgaW4gZGVsYXllZF9kZXN0cm95LCB3 ZSBjYW4ndCBjYWxsIHR0bV9ib19wdXQoKQorCSAqIHVudGlsIHN1Y2Nlc3NmdWwgaW5pdGlhbGl6 YXRpb24uCisJICovCisJcmV0ID0gdHRtX2JvX2luaXQoJmk5MTUtPmJkZXYsIGk5MTVfZ2VtX3Rv X3R0bShvYmopLCBzaXplLAorCQkJICBib190eXBlLCAmaTkxNV9zeXNfcGxhY2VtZW50LCBhbGln bm1lbnQsCisJCQkgIHRydWUsIE5VTEwsIE5VTEwsIGk5MTVfdHRtX2JvX2Rlc3Ryb3kpOworCisJ aWYgKCFyZXQpCisJCW9iai0+dHRtLmNyZWF0ZWQgPSB0cnVlOworCisJLyogaTkxNSB3YW50cyAt RU5YSU8gd2hlbiBvdXQgb2YgbWVtb3J5IHJlZ2lvbiBzcGFjZS4gKi8KKwlyZXR1cm4gKHJldCA9 PSAtRU5PU1BDKSA/IC1FTlhJTyA6IHJldDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV90dG0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjA1YzEx NGUzNWI0ZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV90dG0uaApAQCAtMCwwICsxLDUwIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog TUlUICovCisvKgorICogQ29weXJpZ2h0IMKpIDIwMjEgSW50ZWwgQ29ycG9yYXRpb24KKyAqLwor I2lmbmRlZiBfSTkxNV9HRU1fVFRNX0hfCisjZGVmaW5lIF9JOTE1X0dFTV9UVE1fSF8KKworI2lu Y2x1ZGUgImdlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaCIKKworLyoqCisgKiBpOTE1X2dlbV90 b190dG0gLSBDb252ZXJ0IGEgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgdG8gYQorICogc3Ry dWN0IHR0bV9idWZmZXJfb2JqZWN0LgorICogQG9iajogUG9pbnRlciB0byB0aGUgZ2VtIG9iamVj dC4KKyAqCisgKiBSZXR1cm46IFBvaW50ZXIgdG8gdGhlIGVtYmVkZGVkIHN0cnVjdCB0dG1fYnVm ZmVyX29iamVjdC4KKyAqLworc3RhdGljIGlubGluZSBzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3Qg KgoraTkxNV9nZW1fdG9fdHRtKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJ cmV0dXJuICZvYmotPl9fZG9fbm90X2FjY2VzczsKK30KKworLyoKKyAqIGk5MTUgdHRtIGdlbSBv YmplY3QgZGVzdHJ1Y3Rvci4gSW50ZXJuYWwgdXNlIG9ubHkuCisgKi8KK3ZvaWQgaTkxNV90dG1f Ym9fZGVzdHJveShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKTsKKworLyoqCisgKiBpOTE1 X3R0bV90b19nZW0gLSBDb252ZXJ0IGEgc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0IHRvIGFuIGVt YmVkZGluZworICogc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QuCisgKgorICogUmV0dXJuOiBQ b2ludGVyIHRvIHRoZSBlbWJlZGRpbmcgc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0LCBvciBOVUxM CisgKiBpZiB0aGUgb2JqZWN0IHdhcyBub3QgYW4gaTkxNSB0dG0gb2JqZWN0LgorICovCitzdGF0 aWMgaW5saW5lIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICoKK2k5MTVfdHRtX3RvX2dlbShz dHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCWlmIChHRU1fV0FSTl9PTihiby0+ZGVz dHJveSAhPSBpOTE1X3R0bV9ib19kZXN0cm95KSkKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXR1cm4g Y29udGFpbmVyX29mKGJvLCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCwgX19kb19ub3RfYWNj ZXNzKTsKK30KKworaW50IF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9t ZW1vcnlfcmVnaW9uICptZW0sCisJCQkgICAgICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaiwKKwkJCSAgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCSAgICAgICB1bnNpZ25l ZCBpbnQgZmxhZ3MpOworCitleHRlcm4gc3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgaTkxNV90dG1f Ym9fZHJpdmVyOworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9p bnRlbF9yZWdpb25fbG1lbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9u X2xtZW0uYwppbmRleCBmNzM2NmIwNTRmOGUuLjRhZTFmNzE3YTk0YyAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9uX2xtZW0uYworKysgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9yZWdpb25fbG1lbS5jCkBAIC05LDYgKzksNyBAQAogI2luY2x1 ZGUgImludGVsX3JlZ2lvbl90dG0uaCIKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1fbG1lbS5oIgog I2luY2x1ZGUgImdlbS9pOTE1X2dlbV9yZWdpb24uaCIKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1f dHRtLmgiCiAjaW5jbHVkZSAiaW50ZWxfcmVnaW9uX2xtZW0uaCIKIAogc3RhdGljIGludCBpbml0 X2Zha2VfbG1lbV9iYXIoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSkKQEAgLTEwNyw3 ICsxMDgsNyBAQCByZWdpb25fbG1lbV9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICpt ZW0pCiBzdGF0aWMgY29uc3Qgc3RydWN0IGludGVsX21lbW9yeV9yZWdpb25fb3BzIGludGVsX3Jl Z2lvbl9sbWVtX29wcyA9IHsKIAkuaW5pdCA9IHJlZ2lvbl9sbWVtX2luaXQsCiAJLnJlbGVhc2Ug PSByZWdpb25fbG1lbV9yZWxlYXNlLAotCS5pbml0X29iamVjdCA9IF9faTkxNV9nZW1fbG1lbV9v YmplY3RfaW5pdCwKKwkuaW5pdF9vYmplY3QgPSBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdCwK IH07CiAKIHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5j CmluZGV4IDE4MGY2ZTkxMDdkNC4uMzUwMjgzYWI5YTgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X2dlbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2Vt LmMKQEAgLTEwMDUsOCArMTAwNSwxMSBAQCBpOTE1X2dlbV9tYWR2aXNlX2lvY3RsKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCiAJCX0KIAl9CiAKLQlpZiAob2JqLT5tbS5tYWR2 ICE9IF9fSTkxNV9NQURWX1BVUkdFRCkKKwlpZiAob2JqLT5tbS5tYWR2ICE9IF9fSTkxNV9NQURW X1BVUkdFRCkgewogCQlvYmotPm1tLm1hZHYgPSBhcmdzLT5tYWR2OworCQlpZiAob2JqLT5vcHMt PmFkanVzdF9scnUpCisJCQlvYmotPm9wcy0+YWRqdXN0X2xydShvYmopOworCX0KIAogCWlmIChp OTE1X2dlbV9vYmplY3RfaGFzX3BhZ2VzKG9iaikpIHsKIAkJc3RydWN0IGxpc3RfaGVhZCAqbGlz dDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24u YyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uYwppbmRleCA0MDky Y2M5ODc2NzkuLmJkMjdlODk3ZDRkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfbWVtb3J5X3JlZ2lvbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21l bW9yeV9yZWdpb24uYwpAQCAtMTQ5LDcgKzE0OSw2IEBAIGludGVsX21lbW9yeV9yZWdpb25fY3Jl YXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAogCiAJbXV0ZXhfaW5pdCgmbWVtLT5v YmplY3RzLmxvY2spOwogCUlOSVRfTElTVF9IRUFEKCZtZW0tPm9iamVjdHMubGlzdCk7Ci0JSU5J VF9MSVNUX0hFQUQoJm1lbS0+b2JqZWN0cy5wdXJnZWFibGUpOwogCUlOSVRfTElTVF9IRUFEKCZt ZW0tPnJlc2VydmVkKTsKIAogCW11dGV4X2luaXQoJm1lbS0+bW1fbG9jayk7CmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmggYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmgKaW5kZXggZTY5Y2RlMTNkYWYyLi43YjVm YTk3YzBiNTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9y ZWdpb24uaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmgK QEAgLTEwMCw3ICsxMDAsNiBAQCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiB7CiAJc3RydWN0 IHsKIAkJc3RydWN0IG11dGV4IGxvY2s7IC8qIFByb3RlY3RzIGFjY2VzcyB0byBvYmplY3RzICov CiAJCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKLQkJc3RydWN0IGxpc3RfaGVhZCBwdXJnZWFibGU7 CiAJfSBvYmplY3RzOwogCiAJc2l6ZV90IGNodW5rX3NpemU7CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9yZWdpb25fdHRtLmMKaW5kZXggNjljOTgyOTgzMjZiLi41MjM1MmRiZTA0N2QgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYworKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMKQEAgLTEwLDYgKzEwLDcgQEAKIAog I2luY2x1ZGUgImludGVsX3JlZ2lvbl90dG0uaCIKIAorI2luY2x1ZGUgImdlbS9pOTE1X2dlbV90 dG0uaCIgLyogRm9yIHRoZSBmdW5jcy9vcHMgZXhwb3J0IG9ubHkgKi8KIC8qKgogICogRE9DOiBU VE0gc3VwcG9ydCBzdHJ1Y3R1cmUKICAqCkBAIC0zMSw5ICszMiw2IEBAIHN0cnVjdCBpbnRlbF9y ZWdpb25fdHRtX3ByaXZhdGUgewogCUk5MTVfU0VMRlRFU1RfREVDTEFSRShzdHJ1Y3QgZHJtX3Zt YV9vZmZzZXRfbWFuYWdlciBtb2NrX3ZtYSk7CiB9OwogCi0vKiBBIFplcm8taW5pdGlhbGl6ZWQg ZHJpdmVyIGZvciBub3cuIFdlIGRvbid0IGhhdmUgYSBUVE0gYmFja2VuZCB5ZXQuICovCi1zdGF0 aWMgc3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgaTkxNV90dG1fYm9fZHJpdmVyOwotCiBzdGF0aWMg c3RydWN0IGludGVsX3JlZ2lvbl90dG1fcHJpdmF0ZSAqdG9fdHRtX3ByaXZhdGUodm9pZCAqZGF0 YSkKIHsKIAlyZXR1cm4gKHN0cnVjdCBpbnRlbF9yZWdpb25fdHRtX3ByaXZhdGUgKilkYXRhOwpA QCAtMjE5LDYgKzIxNyw3IEBAIHN0cnVjdCBzZ190YWJsZSAqaW50ZWxfcmVnaW9uX3R0bV9ub2Rl X3RvX3N0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJcmV0dXJuIGk5MTVfc2df ZnJvbV9tbV9ub2RlKG5vZGUsIG1lbS0+cmVnaW9uLnN0YXJ0KTsKIH0KIAorI2lmZGVmIENPTkZJ R19EUk1fSTkxNV9TRUxGVEVTVAogLyoqCiAgKiBpbnRlbF9yZWdpb25fdHRtX25vZGVfYWxsb2Mg LSBBbGxvY2F0ZSBtZW1vcnkgcmVzb3VyY2VzIGZyb20gYSByZWdpb24KICAqIEBtZW06IFRoZSBt ZW1vcnkgcmVnaW9uLApAQCAtMjY3LDcgKzI2Niw2IEBAIHZvaWQgKmludGVsX3JlZ2lvbl90dG1f bm9kZV9hbGxvYyhzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAogCXJldHVybiByZXQg PyBFUlJfUFRSKHJldCkgOiByZXMubW1fbm9kZTsKIH0KIAotI2lmZGVmIENPTkZJR19EUk1fSTkx NV9TRUxGVEVTVAogLyoqCiAgKiBpbnRlbF9yZWdpb25fdHRtX2luaXRfbW9jayAtIEluaXRpYWxp emUgYSBtb2NrIG1lbW9yeSByZWdpb24gZm9yIFRUTS4KICAqIEBtZW06IFRoZSByZWdpb24gdG8g aW5pdGlhbGl6ZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lv bl90dG0uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uaAppbmRleCAy M2M2YzJkNGIxY2QuLmEwODk5OGMzYTNkOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfcmVnaW9uX3R0bS5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Jl Z2lvbl90dG0uaApAQCAtMjMsMTQgKzIzLDE0IEBAIHZvaWQgaW50ZWxfcmVnaW9uX3R0bV9maW5p KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pOwogc3RydWN0IHNnX3RhYmxlICppbnRl bF9yZWdpb25fdHRtX25vZGVfdG9fc3Qoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwK IAkJCQkJICAgICB2b2lkICpub2RlKTsKIAotdm9pZCAqaW50ZWxfcmVnaW9uX3R0bV9ub2RlX2Fs bG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCi0JCQkJICByZXNvdXJjZV9zaXpl X3Qgc2l6ZSwKLQkJCQkgIHVuc2lnbmVkIGludCBmbGFncyk7Ci0KIHZvaWQgaW50ZWxfcmVnaW9u X3R0bV9ub2RlX2ZyZWUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAkJCQl2b2lk ICpub2RlKTsKIAogI2lmZGVmIENPTkZJR19EUk1fSTkxNV9TRUxGVEVTVAordm9pZCAqaW50ZWxf cmVnaW9uX3R0bV9ub2RlX2FsbG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCisJ CQkJICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCQkgIHVuc2lnbmVkIGludCBmbGFncyk7CisK IGludCBpbnRlbF9yZWdpb25fdHRtX2luaXRfbW9jayhzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lv biAqbWVtKTsKIAogdm9pZCBpbnRlbF9yZWdpb25fdHRtX2ZpbmlfbW9jayhzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiAqbWVtKTsKLS0gCjIuMzEuMQoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==