From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 93A7BC43460 for ; Tue, 11 May 2021 13:26:27 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id A1CDD615FF for ; Tue, 11 May 2021 13:26:25 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A1CDD615FF 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 D3E8B6EA3F; Tue, 11 May 2021 13:26:20 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id B2AD16EA38; Tue, 11 May 2021 13:26:17 +0000 (UTC) IronPort-SDR: 4FBXTZ3s0WYznk1LYQSDWGsAyUTfGAt9//JEmsD6Fhz70m14q9in/nDPnVaUduzMv9sdrNJ2QM 22Zx3B5/gmLQ== X-IronPort-AV: E=McAfee;i="6200,9189,9980"; a="196345414" X-IronPort-AV: E=Sophos;i="5.82,290,1613462400"; d="scan'208";a="196345414" Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2021 06:26:17 -0700 IronPort-SDR: gMm8GAzcKMM6GTSADnPExTMCWxnLh+o45tdaFtXKpYkf84J23+NfZpo47d9LSlnAcHr1NZyctu 4GrT+IV1Q4xQ== X-IronPort-AV: E=Sophos;i="5.82,290,1613462400"; d="scan'208";a="468905437" Received: from kjeldbeg-mobl2.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.168]) by fmsmga002-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2021 06:26:16 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH 6/7] drm/i915/ttm, drm/ttm: Introduce a TTM i915 gem object backend Date: Tue, 11 May 2021 15:25:24 +0200 Message-Id: <20210511132525.377190-7-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210511132525.377190-1-thomas.hellstrom@linux.intel.com> References: <20210511132525.377190-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?= , =?UTF-8?q?Christian=20K=C3=B6nig?= 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. There are some changes to TTM to allow for purging system memory buffer objects and to refuse swapping of some objects: Unfortunately i915 gem still relies heavily on short-term object pinning, and we've chosen to keep short-term-pinned buffer objects on the TTM LRU lists for now, meaning that we need some sort of mechanism to tell TTM they are not swappable. A longer term goal is to get rid of the short-term pinning. Remove the old lmem backend. Cc: Christian König Signed-off-by: Thomas Hellström --- drivers/gpu/drm/i915/Makefile | 1 + drivers/gpu/drm/i915/gem/i915_gem_lmem.c | 83 --- drivers/gpu/drm/i915/gem/i915_gem_lmem.h | 5 - drivers/gpu/drm/i915/gem/i915_gem_object.c | 126 +++-- drivers/gpu/drm/i915/gem/i915_gem_object.h | 9 + .../gpu/drm/i915/gem/i915_gem_object_types.h | 18 + drivers/gpu/drm/i915/gem/i915_gem_region.c | 6 +- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 534 ++++++++++++++++++ drivers/gpu/drm/i915/gem/i915_gem_ttm.h | 48 ++ drivers/gpu/drm/i915/gt/intel_region_lmem.c | 3 +- drivers/gpu/drm/i915/i915_gem.c | 5 +- drivers/gpu/drm/i915/intel_memory_region.c | 1 - drivers/gpu/drm/i915/intel_memory_region.h | 1 - drivers/gpu/drm/i915/intel_region_ttm.c | 5 +- drivers/gpu/drm/i915/intel_region_ttm.h | 7 +- drivers/gpu/drm/ttm/ttm_bo.c | 12 + include/drm/ttm/ttm_device.h | 9 + 17 files changed, 733 insertions(+), 140 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 958ccc1edfed..ef0d884a9e2d 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -155,6 +155,7 @@ gem-y += \ gem/i915_gem_stolen.o \ gem/i915_gem_throttle.o \ gem/i915_gem_tiling.o \ + gem/i915_gem_ttm.o \ gem/i915_gem_ttm_bo_util.o \ gem/i915_gem_userptr.o \ gem/i915_gem_wait.o \ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c index f42803ea48f2..2b8cd15de1d9 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c @@ -4,73 +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)) - return PTR_ERR(pages); - - __i915_gem_object_set_pages(obj, pages, - i915_sg_dma_page_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, @@ -102,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 c8953e3f5c70..c53488f391dd 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -172,7 +172,7 @@ static void i915_gem_close_object(struct drm_gem_object *gem, struct drm_file *f } } -static void __i915_gem_free_object_rcu(struct rcu_head *head) +void __i915_gem_free_object_rcu(struct rcu_head *head) { struct drm_i915_gem_object *obj = container_of(head, typeof(*obj), rcu); @@ -208,59 +208,70 @@ 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->resv_shared_from) + i915_vm_resv_put(obj->resv_shared_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->resv_shared_from) - i915_vm_resv_put(obj->resv_shared_from); + llist_for_each_entry_safe(obj, on, freed, freed) { + might_sleep(); + if (obj->ops->delayed_free) { + obj->ops->delayed_free(obj); + continue; + } + __i915_gem_free_object(obj); /* But keep the pointer alive for RCU-protected lookups */ call_rcu(&obj->rcu, __i915_gem_free_object_rcu); @@ -318,6 +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); } @@ -410,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 98f69d8fd37d..b350765e1935 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 */ @@ -307,6 +321,10 @@ struct drm_i915_gem_object { bool dirty:1; } mm; + struct { + struct sg_table *cached_io_st; + } 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..e3718c3cb299 --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -0,0 +1,534 @@ +// 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" +#include "gem/i915_gem_ttm_bo_util.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, + } +}; + +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], +}; + +struct ttm_placement i915_lmem0_sys_placement = { + .num_placement = 1, + .placement = &lmem0_sys_placement_flags[0], + .num_busy_placement = 2, + .busy_placement = &lmem0_sys_placement_flags[0], +}; + +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_cached); + 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); + + if (obj->mm.madv == __I915_MADV_PURGED) + return; + + i915_ttm_free_cached_io_st(obj); + + ttm_resource_free(bo, &bo->mem); + if (bo->ttm) + ttm_bo_tt_destroy(bo); + + obj->mm.madv = __I915_MADV_PURGED; +} + +static bool i915_ttm_swap_possible(struct ttm_buffer_object *bo) +{ + /* Will do for now. Our pinned objects are still on TTM's LRU lists */ + return i915_gem_object_evictable(i915_ttm_to_gem(bo)); +} + +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); + struct sg_table *st; + + if (man->use_tt) + return i915_ttm_tt_get_st(bo->ttm); + + st = kzalloc(sizeof(*st), GFP_KERNEL); + if (!st) + return ERR_PTR(-ENOMEM); + + st = intel_region_ttm_node_to_st(obj->mm.region, res->mm_node); + if (IS_ERR(st)) + return ERR_CAST(st); + + return st; +} + +static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, + struct ttm_operation_ctx *ctx, + struct ttm_resource *new_mem, + struct ttm_place *hop) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + struct ttm_resource_manager *new_man = + ttm_manager_type(bo->bdev, new_mem->mem_type); + struct ttm_resource_manager *old_man = + ttm_manager_type(bo->bdev, bo->mem.mem_type); + struct intel_memory_region *new_reg, *old_reg; + union { + struct i915_ttm_kmap_iter_tt tt; + struct i915_ttm_kmap_iter_iomap io; + } _new_iter, _old_iter; + struct i915_ttm_kmap_iter *new_iter, *old_iter; + struct sg_table *new_st; + int ret; + + new_reg = i915_ttm_region(bo->bdev, new_mem->mem_type); + old_reg = i915_ttm_region(bo->bdev, bo->mem.mem_type); + GEM_BUG_ON(!new_reg || !old_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, new_mem); + return 0; + } + + /* Populate ttm with pages if needed. Typically system memory. */ + if (new_man->use_tt && bo->ttm) { + ret = ttm_tt_populate(bo->bdev, bo->ttm, ctx); + if (ret) + return ret; + } + + new_st = i915_ttm_resource_get_st(obj, new_mem); + if (IS_ERR(new_st)) + return PTR_ERR(new_st); + + new_iter = new_man->use_tt ? + i915_ttm_kmap_iter_tt_init(&_new_iter.tt, bo->ttm) : + i915_ttm_kmap_iter_iomap_init(&_new_iter.io, &new_reg->iomap, + new_st, new_reg->region.start); + + old_iter = old_man->use_tt ? + i915_ttm_kmap_iter_tt_init(&_old_iter.tt, bo->ttm) : + i915_ttm_kmap_iter_iomap_init(&_old_iter.io, &old_reg->iomap, + obj->ttm.cached_io_st, + old_reg->region.start); + + i915_ttm_move_memcpy(bo, new_mem, new_iter, old_iter); + i915_ttm_free_cached_io_st(obj); + + if (!new_man->use_tt) + obj->ttm.cached_io_st = new_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_possible = i915_ttm_swap_possible, + .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; + + /* Swap in. */ + if (bo->ttm && (bo->ttm->page_flags & TTM_PAGE_FLAG_SWAPPED)) { + ret = ttm_tt_populate(bo->bdev, bo->ttm, &ctx); + if (ret) + return ret; + } + + /* Move to the requested placement. */ + ret = ttm_bo_validate(bo, &i915_lmem0_placement, &ctx); + if (ret) + return 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_page_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) +{ + ttm_bo_put(i915_gem_to_ttm(obj)); +} + +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); + 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; + 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); + + ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, + ttm_bo_type_kernel, &i915_sys_placement, alignment, + true, NULL, NULL, i915_ttm_bo_destroy); + + obj->read_domains = I915_GEM_DOMAIN_WC | I915_GEM_DOMAIN_GTT; + + i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); + + return 0; +} diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.h b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h new file mode 100644 index 000000000000..b8d3dcbb50df --- /dev/null +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2021 Intel Corporation + */ +#ifndef _I915_GEM_TTM_H_ +#define _I915_GEM_TTM_H_ + +#include "gem/i915_gem_object_types.h" + +/** + * i915_gem_to_ttm - Convert a struct drm_i915_gem_object to a + * struct ttm_buffer_object. + * @obj: Pointer to the gem object. + * + * Return: Pointer to the embedded struct ttm_buffer_object. + */ +static inline struct ttm_buffer_object * +i915_gem_to_ttm(struct drm_i915_gem_object *obj) +{ + return &obj->__do_not_access; +} + +/* + * i915 ttm gem object destructor. Internal use only. + */ +void i915_ttm_bo_destroy(struct ttm_buffer_object *bo); + +/** + * i915_ttm_to_gem - Convert a struct ttm_buffer_object to an embedding + * struct drm_i915_gem_object. + * + * Return: Pointer to the embedding struct ttm_buffer_object, or NULL + * if the object was not an i915 ttm object. + */ +static inline struct drm_i915_gem_object * +i915_ttm_to_gem(struct ttm_buffer_object *bo) +{ + if (GEM_WARN_ON(bo->destroy != i915_ttm_bo_destroy)) + return NULL; + + return container_of(bo, struct drm_i915_gem_object, __do_not_access); +} + +int __i915_gem_ttm_object_init(struct intel_memory_region *mem, + struct drm_i915_gem_object *obj, + resource_size_t size, + unsigned int flags); +#endif diff --git a/drivers/gpu/drm/i915/gt/intel_region_lmem.c b/drivers/gpu/drm/i915/gt/intel_region_lmem.c index f7366b054f8e..4ae1f717a94c 100644 --- a/drivers/gpu/drm/i915/gt/intel_region_lmem.c +++ b/drivers/gpu/drm/i915/gt/intel_region_lmem.c @@ -9,6 +9,7 @@ #include "intel_region_ttm.h" #include "gem/i915_gem_lmem.h" #include "gem/i915_gem_region.h" +#include "gem/i915_gem_ttm.h" #include "intel_region_lmem.h" static int init_fake_lmem_bar(struct intel_memory_region *mem) @@ -107,7 +108,7 @@ region_lmem_init(struct intel_memory_region *mem) static const struct intel_memory_region_ops intel_region_lmem_ops = { .init = region_lmem_init, .release = region_lmem_release, - .init_object = __i915_gem_lmem_object_init, + .init_object = __i915_gem_ttm_object_init, }; struct intel_memory_region * diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c index 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 3bd9caa60298..a74cae4602b5 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.c +++ b/drivers/gpu/drm/i915/intel_region_ttm.c @@ -10,8 +10,7 @@ #include "intel_region_ttm.h" -/* A Zero-initialized driver for now. We don't have a TTM backend yet. */ -static struct ttm_device_funcs i915_ttm_bo_driver; +extern struct ttm_device_funcs i915_ttm_bo_driver; /** * DOC: TTM support structure @@ -198,6 +197,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, @@ -244,3 +244,4 @@ void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, ret = -ENXIO; return ret ? ERR_PTR(ret) : res.mm_node; } +#endif diff --git a/drivers/gpu/drm/i915/intel_region_ttm.h b/drivers/gpu/drm/i915/intel_region_ttm.h index 40129f7e0317..9a5b0437d73f 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.h +++ b/drivers/gpu/drm/i915/intel_region_ttm.h @@ -21,9 +21,12 @@ void intel_region_ttm_fini(struct intel_memory_region *mem); struct sg_table *intel_region_ttm_node_to_st(struct intel_memory_region *mem, void *node); +void intel_region_ttm_node_free(struct intel_memory_region *mem, + void *node); + +#ifdef CONFIG_DRM_I915_SELFTEST void *intel_region_ttm_node_alloc(struct intel_memory_region *mem, resource_size_t size, unsigned int flags); -void intel_region_ttm_node_free(struct intel_memory_region *mem, - void *node); +#endif #endif /* _INTEL_REGION_TTM_H_ */ diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c index 4479c55aaa1d..74004d5cbfa2 100644 --- a/drivers/gpu/drm/ttm/ttm_bo.c +++ b/drivers/gpu/drm/ttm/ttm_bo.c @@ -1150,6 +1150,14 @@ int ttm_bo_swapout(struct ttm_buffer_object *bo, struct ttm_operation_ctx *ctx, return -EBUSY; } + if (bo->bdev->funcs->swap_possible) { + if (!bo->bdev->funcs->swap_possible(bo)) { + if (locked) + dma_resv_unlock(bo->base.resv); + return -EBUSY; + } + } + if (bo->deleted) { ttm_bo_cleanup_refs(bo, false, false, locked); ttm_bo_put(bo); @@ -1200,6 +1208,10 @@ int ttm_bo_swapout(struct ttm_buffer_object *bo, struct ttm_operation_ctx *ctx, if (bo->bdev->funcs->swap_notify) bo->bdev->funcs->swap_notify(bo); + /* The call to swap_notify may have purged the bo */ + if (!bo->ttm) + goto out; + ret = ttm_tt_swapout(bo->bdev, bo->ttm, gfp_flags); out: diff --git a/include/drm/ttm/ttm_device.h b/include/drm/ttm/ttm_device.h index 7c8f87bd52d3..7c59d35e90f9 100644 --- a/include/drm/ttm/ttm_device.h +++ b/include/drm/ttm/ttm_device.h @@ -181,6 +181,15 @@ struct ttm_device_funcs { */ void (*delete_mem_notify)(struct ttm_buffer_object *bo); + /** + * struct ttm_bo_driver member swap_possible + * + * @bo: the buffer object to be evicted + * + * Check with the driver if it is possible to swap out a BO. + */ + bool (*swap_possible)(struct ttm_buffer_object *bo); + /** * notify the driver that we're about to swap out this bo */ -- 2.30.2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A661AC43461 for ; Tue, 11 May 2021 13:26:24 +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 486546191C for ; Tue, 11 May 2021 13:26:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 486546191C 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 1E7BF6EA3C; Tue, 11 May 2021 13:26:20 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id B2AD16EA38; Tue, 11 May 2021 13:26:17 +0000 (UTC) IronPort-SDR: 4FBXTZ3s0WYznk1LYQSDWGsAyUTfGAt9//JEmsD6Fhz70m14q9in/nDPnVaUduzMv9sdrNJ2QM 22Zx3B5/gmLQ== X-IronPort-AV: E=McAfee;i="6200,9189,9980"; a="196345414" X-IronPort-AV: E=Sophos;i="5.82,290,1613462400"; d="scan'208";a="196345414" Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2021 06:26:17 -0700 IronPort-SDR: gMm8GAzcKMM6GTSADnPExTMCWxnLh+o45tdaFtXKpYkf84J23+NfZpo47d9LSlnAcHr1NZyctu 4GrT+IV1Q4xQ== X-IronPort-AV: E=Sophos;i="5.82,290,1613462400"; d="scan'208";a="468905437" Received: from kjeldbeg-mobl2.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.168]) by fmsmga002-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 11 May 2021 06:26:16 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Tue, 11 May 2021 15:25:24 +0200 Message-Id: <20210511132525.377190-7-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210511132525.377190-1-thomas.hellstrom@linux.intel.com> References: <20210511132525.377190-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 6/7] drm/i915/ttm, drm/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?= , =?UTF-8?q?Christian=20K=C3=B6nig?= 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 TS4KClRoZXJlIGFyZSBzb21lIGNoYW5nZXMgdG8gVFRNIHRvIGFsbG93IGZvciBwdXJnaW5nIHN5 c3RlbSBtZW1vcnkgYnVmZmVyCm9iamVjdHMgYW5kIHRvIHJlZnVzZSBzd2FwcGluZyBvZiBzb21l IG9iamVjdHM6IFVuZm9ydHVuYXRlbHkgaTkxNSBnZW0Kc3RpbGwgcmVsaWVzIGhlYXZpbHkgb24g c2hvcnQtdGVybSBvYmplY3QgcGlubmluZywgYW5kIHdlJ3ZlIGNob3NlbiB0bwprZWVwIHNob3J0 LXRlcm0tcGlubmVkIGJ1ZmZlciBvYmplY3RzIG9uIHRoZSBUVE0gTFJVIGxpc3RzIGZvciBub3cs Cm1lYW5pbmcgdGhhdCB3ZSBuZWVkIHNvbWUgc29ydCBvZiBtZWNoYW5pc20gdG8gdGVsbCBUVE0g dGhleSBhcmUgbm90CnN3YXBwYWJsZS4gQSBsb25nZXIgdGVybSBnb2FsIGlzIHRvIGdldCByaWQg b2YgdGhlIHNob3J0LXRlcm0gcGlubmluZy4KClJlbW92ZSB0aGUgb2xkIGxtZW0gYmFja2VuZC4K CkNjOiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+ClNpZ25lZC1v ZmYtYnk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNv bT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgfCAg IDEgKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uYyAgICAgIHwgIDgz IC0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uaCAgICAgIHwgICA1 IC0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuYyAgICB8IDEyNiAr KystLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5oICAgIHwgICA5 ICsKIC4uLi9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oICB8ICAxOCAr CiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMgICAgfCAgIDYgKy0K IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYyAgICAgICB8IDUzNCArKysr KysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uaCAg ICAgICB8ICA0OCArKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9uX2xtZW0u YyAgIHwgICAzICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jICAgICAgICAgICAg ICAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uYyAg ICB8ICAgMSAtCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmggICAg fCAgIDEgLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5jICAgICAgIHwg ICA1ICstCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmggICAgICAgfCAg IDcgKy0KIGRyaXZlcnMvZ3B1L2RybS90dG0vdHRtX2JvLmMgICAgICAgICAgICAgICAgICB8ICAx MiArCiBpbmNsdWRlL2RybS90dG0vdHRtX2RldmljZS5oICAgICAgICAgICAgICAgICAgfCAgIDkg KwogMTcgZmlsZXMgY2hhbmdlZCwgNzMzIGluc2VydGlvbnMoKyksIDE0MCBkZWxldGlvbnMoLSkK IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRt LmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1f dHRtLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZSBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlCmluZGV4IDk1OGNjYzFlZGZlZC4uZWYwZDg4NGE5ZTJk IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQorKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9NYWtlZmlsZQpAQCAtMTU1LDYgKzE1NSw3IEBAIGdlbS15ICs9IFwKIAln ZW0vaTkxNV9nZW1fc3RvbGVuLm8gXAogCWdlbS9pOTE1X2dlbV90aHJvdHRsZS5vIFwKIAlnZW0v aTkxNV9nZW1fdGlsaW5nLm8gXAorCWdlbS9pOTE1X2dlbV90dG0ubyBcCiAJZ2VtL2k5MTVfZ2Vt X3R0bV9ib191dGlsLm8gXAogCWdlbS9pOTE1X2dlbV91c2VycHRyLm8gXAogCWdlbS9pOTE1X2dl bV93YWl0Lm8gXApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X2xtZW0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMKaW5kZXgg ZjQyODAzZWE0OGYyLi4yYjhjZDE1ZGUxZDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX2xtZW0uYwpAQCAtNCw3MyArNCwxMCBAQAogICovCiAKICNpbmNsdWRlICJpbnRlbF9t ZW1vcnlfcmVnaW9uLmgiCi0jaW5jbHVkZSAiaW50ZWxfcmVnaW9uX3R0bS5oIgogI2luY2x1ZGUg ImdlbS9pOTE1X2dlbV9yZWdpb24uaCIKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1fbG1lbS5oIgog I2luY2x1ZGUgImk5MTVfZHJ2LmgiCiAKLXN0YXRpYyB2b2lkIGxtZW1fcHV0X3BhZ2VzKHN0cnVj dCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkJICBzdHJ1Y3Qgc2dfdGFibGUgKnBhZ2Vz KQotewotCWludGVsX3JlZ2lvbl90dG1fbm9kZV9mcmVlKG9iai0+bW0ucmVnaW9uLCBvYmotPm1t LnN0X21tX25vZGUpOwotCW9iai0+bW0uZGlydHkgPSBmYWxzZTsKLQlzZ19mcmVlX3RhYmxlKHBh Z2VzKTsKLQlrZnJlZShwYWdlcyk7Ci19Ci0KLXN0YXRpYyBpbnQgbG1lbV9nZXRfcGFnZXMoc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKLXsKLQl1bnNpZ25lZCBpbnQgZmxhZ3M7Ci0J c3RydWN0IHNnX3RhYmxlICpwYWdlczsKLQotCWZsYWdzID0gSTkxNV9BTExPQ19NSU5fUEFHRV9T SVpFOwotCWlmIChvYmotPmZsYWdzICYgSTkxNV9CT19BTExPQ19DT05USUdVT1VTKQotCQlmbGFn cyB8PSBJOTE1X0FMTE9DX0NPTlRJR1VPVVM7Ci0KLQlvYmotPm1tLnN0X21tX25vZGUgPSBpbnRl bF9yZWdpb25fdHRtX25vZGVfYWxsb2Mob2JqLT5tbS5yZWdpb24sCi0JCQkJCQkJIG9iai0+YmFz ZS5zaXplLAotCQkJCQkJCSBmbGFncyk7Ci0JaWYgKElTX0VSUihvYmotPm1tLnN0X21tX25vZGUp KQotCQlyZXR1cm4gUFRSX0VSUihvYmotPm1tLnN0X21tX25vZGUpOwotCi0JLyogUmFuZ2UgbWFu YWdlciBpcyBhbHdheXMgY29udGlnb3VzICovCi0JaWYgKG9iai0+bW0ucmVnaW9uLT5pc19yYW5n ZV9tYW5hZ2VyKQotCQlvYmotPmZsYWdzIHw9IEk5MTVfQk9fQUxMT0NfQ09OVElHVU9VUzsKLQlw YWdlcyA9IGludGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChvYmotPm1tLnJlZ2lvbiwgb2JqLT5t bS5zdF9tbV9ub2RlKTsKLQlpZiAoSVNfRVJSKHBhZ2VzKSkKLQkJcmV0dXJuIFBUUl9FUlIocGFn ZXMpOwotCi0JX19pOTE1X2dlbV9vYmplY3Rfc2V0X3BhZ2VzKG9iaiwgcGFnZXMsCi0JCQkJICAg IGk5MTVfc2dfZG1hX3BhZ2Vfc2l6ZXMocGFnZXMtPnNnbCkpOwotCi0JaWYgKG9iai0+ZmxhZ3Mg JiBJOTE1X0JPX0FMTE9DX0NQVV9DTEVBUikgewotCQl2b2lkIF9faW9tZW0gKnZhZGRyID0KLQkJ CWk5MTVfZ2VtX29iamVjdF9sbWVtX2lvX21hcChvYmosIDAsIG9iai0+YmFzZS5zaXplKTsKLQot CQlpZiAoIXZhZGRyKSB7Ci0JCQlzdHJ1Y3Qgc2dfdGFibGUgKnBhZ2VzID0KLQkJCQlfX2k5MTVf Z2VtX29iamVjdF91bnNldF9wYWdlcyhvYmopOwotCi0JCQlpZiAoIUlTX0VSUl9PUl9OVUxMKHBh Z2VzKSkKLQkJCQlsbWVtX3B1dF9wYWdlcyhvYmosIHBhZ2VzKTsKLQkJfQotCi0JCW1lbXNldF9p byh2YWRkciwgMCwgb2JqLT5iYXNlLnNpemUpOwotCQlpb19tYXBwaW5nX3VubWFwKHZhZGRyKTsK LQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rf b3BzIGk5MTVfZ2VtX2xtZW1fb2JqX29wcyA9IHsKLQkubmFtZSA9ICJpOTE1X2dlbV9vYmplY3Rf bG1lbSIsCi0JLmZsYWdzID0gSTkxNV9HRU1fT0JKRUNUX0hBU19JT01FTSwKLQotCS5nZXRfcGFn ZXMgPSBsbWVtX2dldF9wYWdlcywKLQkucHV0X3BhZ2VzID0gbG1lbV9wdXRfcGFnZXMsCi0JLnJl bGVhc2UgPSBpOTE1X2dlbV9vYmplY3RfcmVsZWFzZV9tZW1vcnlfcmVnaW9uLAotfTsKLQogdm9p ZCBfX2lvbWVtICoKIGk5MTVfZ2VtX29iamVjdF9sbWVtX2lvX21hcChzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqLAogCQkJICAgIHVuc2lnbmVkIGxvbmcgbiwKQEAgLTEwMiwyMyArMzks MyBAQCBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX2xtZW0oc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg Kmk5MTUsCiAJcmV0dXJuIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKGk5MTUtPm1tLnJl Z2lvbnNbSU5URUxfUkVHSU9OX0xNRU1dLAogCQkJCQkgICAgIHNpemUsIGZsYWdzKTsKIH0KLQot aW50IF9faTkxNV9nZW1fbG1lbV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lv biAqbWVtLAotCQkJCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkJcmVzb3Vy Y2Vfc2l6ZV90IHNpemUsCi0JCQkJdW5zaWduZWQgaW50IGZsYWdzKQotewotCXN0YXRpYyBzdHJ1 Y3QgbG9ja19jbGFzc19rZXkgbG9ja19jbGFzczsKLQlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAq aTkxNSA9IG1lbS0+aTkxNTsKLQotCWRybV9nZW1fcHJpdmF0ZV9vYmplY3RfaW5pdCgmaTkxNS0+ ZHJtLCAmb2JqLT5iYXNlLCBzaXplKTsKLQlpOTE1X2dlbV9vYmplY3RfaW5pdChvYmosICZpOTE1 X2dlbV9sbWVtX29ial9vcHMsICZsb2NrX2NsYXNzLCBmbGFncyk7Ci0KLQlvYmotPnJlYWRfZG9t YWlucyA9IEk5MTVfR0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RPTUFJTl9HVFQ7Ci0KLQlpOTE1 X2dlbV9vYmplY3Rfc2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIEk5MTVfQ0FDSEVfTk9ORSk7Ci0K LQlpOTE1X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKG9iaiwgbWVtKTsKLQotCXJldHVy biAwOwotfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xt ZW0uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmgKaW5kZXggZmFj NmJjNWE1ZWJiLi5lYTc2ZmQxMWNjYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9pOTE1X2dlbV9sbWVtLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVf Z2VtX2xtZW0uaApAQCAtMjYsOSArMjYsNCBAQCBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX2xtZW0o c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJCQkgICAgcmVzb3VyY2Vfc2l6ZV90IHNp emUsCiAJCQkgICAgdW5zaWduZWQgaW50IGZsYWdzKTsKIAotaW50IF9faTkxNV9nZW1fbG1lbV9v YmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAotCQkJCXN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCi0JCQkJcmVzb3VyY2Vfc2l6ZV90IHNpemUsCi0JCQkJ dW5zaWduZWQgaW50IGZsYWdzKTsKLQogI2VuZGlmIC8qICFfX0k5MTVfR0VNX0xNRU1fSCAqLwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCmluZGV4IGM4OTUzZTNm NWM3MC4uYzUzNDg4ZjM5MWRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0v aTkxNV9nZW1fb2JqZWN0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X29iamVjdC5jCkBAIC0xNzIsNyArMTcyLDcgQEAgc3RhdGljIHZvaWQgaTkxNV9nZW1fY2xvc2Vf b2JqZWN0KHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtLCBzdHJ1Y3QgZHJtX2ZpbGUgKmYKIAl9 CiB9CiAKLXN0YXRpYyB2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3RfcmN1KHN0cnVjdCByY3Vf aGVhZCAqaGVhZCkKK3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3Uoc3RydWN0IHJjdV9o ZWFkICpoZWFkKQogewogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPQogCQljb250 YWluZXJfb2YoaGVhZCwgdHlwZW9mKCpvYmopLCByY3UpOwpAQCAtMjA4LDU5ICsyMDgsNzAgQEAg c3RhdGljIHZvaWQgX19pOTE1X2dlbV9vYmplY3RfZnJlZV9tbWFwcyhzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqKQogCX0KIH0KIAotc3RhdGljIHZvaWQgX19pOTE1X2dlbV9mcmVlX29i amVjdHMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCi0JCQkJICAgIHN0cnVjdCBsbGlz dF9ub2RlICpmcmVlZCkKK3ZvaWQgX19pOTE1X2dlbV9mcmVlX29iamVjdChzdHJ1Y3QgZHJtX2k5 MTVfZ2VtX29iamVjdCAqb2JqKQogewotCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmos ICpvbjsKKwl0cmFjZV9pOTE1X2dlbV9vYmplY3RfZGVzdHJveShvYmopOwogCi0JbGxpc3RfZm9y X2VhY2hfZW50cnlfc2FmZShvYmosIG9uLCBmcmVlZCwgZnJlZWQpIHsKLQkJdHJhY2VfaTkxNV9n ZW1fb2JqZWN0X2Rlc3Ryb3kob2JqKTsKKwlpZiAoIWxpc3RfZW1wdHkoJm9iai0+dm1hLmxpc3Qp KSB7CisJCXN0cnVjdCBpOTE1X3ZtYSAqdm1hOworCisJCS8qCisJCSAqIE5vdGUgdGhhdCB0aGUg dm1hIGtlZXBzIGFuIG9iamVjdCByZWZlcmVuY2Ugd2hpbGUKKwkJICogaXQgaXMgYWN0aXZlLCBz byBpdCAqc2hvdWxkKiBub3Qgc2xlZXAgd2hpbGUgd2UKKwkJICogZGVzdHJveSBpdC4gT3VyIGRl YnVnIGNvZGUgZXJycyBpbnNpdHMgaXQgKm1pZ2h0Ki4KKwkJICogRm9yIHRoZSBtb21lbnQsIHBs YXkgYWxvbmcuCisJCSAqLworCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2spOworCQl3aGlsZSAo KHZtYSA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVsbCgmb2JqLT52bWEubGlzdCwKKwkJCQkJCSAg ICAgICBzdHJ1Y3QgaTkxNV92bWEsCisJCQkJCQkgICAgICAgb2JqX2xpbmspKSkgeworCQkJR0VN X0JVR19PTih2bWEtPm9iaiAhPSBvYmopOworCQkJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2sp OwogCi0JCWlmICghbGlzdF9lbXB0eSgmb2JqLT52bWEubGlzdCkpIHsKLQkJCXN0cnVjdCBpOTE1 X3ZtYSAqdm1hOworCQkJX19pOTE1X3ZtYV9wdXQodm1hKTsKIAotCQkJLyoKLQkJCSAqIE5vdGUg dGhhdCB0aGUgdm1hIGtlZXBzIGFuIG9iamVjdCByZWZlcmVuY2Ugd2hpbGUKLQkJCSAqIGl0IGlz IGFjdGl2ZSwgc28gaXQgKnNob3VsZCogbm90IHNsZWVwIHdoaWxlIHdlCi0JCQkgKiBkZXN0cm95 IGl0LiBPdXIgZGVidWcgY29kZSBlcnJzIGluc2l0cyBpdCAqbWlnaHQqLgotCQkJICogRm9yIHRo ZSBtb21lbnQsIHBsYXkgYWxvbmcuCi0JCQkgKi8KIAkJCXNwaW5fbG9jaygmb2JqLT52bWEubG9j ayk7Ci0JCQl3aGlsZSAoKHZtYSA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVsbCgmb2JqLT52bWEu bGlzdCwKLQkJCQkJCQkgICAgICAgc3RydWN0IGk5MTVfdm1hLAotCQkJCQkJCSAgICAgICBvYmpf bGluaykpKSB7Ci0JCQkJR0VNX0JVR19PTih2bWEtPm9iaiAhPSBvYmopOwotCQkJCXNwaW5fdW5s b2NrKCZvYmotPnZtYS5sb2NrKTsKKwkJfQorCQlzcGluX3VubG9jaygmb2JqLT52bWEubG9jayk7 CisJfQogCi0JCQkJX19pOTE1X3ZtYV9wdXQodm1hKTsKKwlfX2k5MTVfZ2VtX29iamVjdF9mcmVl X21tYXBzKG9iaik7CiAKLQkJCQlzcGluX2xvY2soJm9iai0+dm1hLmxvY2spOwotCQkJfQotCQkJ c3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOwotCQl9CisJR0VNX0JVR19PTighbGlzdF9lbXB0 eSgmb2JqLT5sdXRfbGlzdCkpOwogCi0JCV9faTkxNV9nZW1fb2JqZWN0X2ZyZWVfbW1hcHMob2Jq KTsKKwlhdG9taWNfc2V0KCZvYmotPm1tLnBhZ2VzX3Bpbl9jb3VudCwgMCk7CisJX19pOTE1X2dl bV9vYmplY3RfcHV0X3BhZ2VzKG9iaik7CisJR0VNX0JVR19PTihpOTE1X2dlbV9vYmplY3RfaGFz X3BhZ2VzKG9iaikpOworCWJpdG1hcF9mcmVlKG9iai0+Yml0XzE3KTsKIAotCQlHRU1fQlVHX09O KCFsaXN0X2VtcHR5KCZvYmotPmx1dF9saXN0KSk7CisJaWYgKG9iai0+YmFzZS5pbXBvcnRfYXR0 YWNoKQorCQlkcm1fcHJpbWVfZ2VtX2Rlc3Ryb3koJm9iai0+YmFzZSwgTlVMTCk7CiAKLQkJYXRv bWljX3NldCgmb2JqLT5tbS5wYWdlc19waW5fY291bnQsIDApOwotCQlfX2k5MTVfZ2VtX29iamVj dF9wdXRfcGFnZXMob2JqKTsKLQkJR0VNX0JVR19PTihpOTE1X2dlbV9vYmplY3RfaGFzX3BhZ2Vz KG9iaikpOwotCQliaXRtYXBfZnJlZShvYmotPmJpdF8xNyk7CisJZHJtX2dlbV9mcmVlX21tYXBf b2Zmc2V0KCZvYmotPmJhc2UpOwogCi0JCWlmIChvYmotPmJhc2UuaW1wb3J0X2F0dGFjaCkKLQkJ CWRybV9wcmltZV9nZW1fZGVzdHJveSgmb2JqLT5iYXNlLCBOVUxMKTsKKwlpZiAob2JqLT5vcHMt PnJlbGVhc2UpCisJCW9iai0+b3BzLT5yZWxlYXNlKG9iaik7CiAKLQkJZHJtX2dlbV9mcmVlX21t YXBfb2Zmc2V0KCZvYmotPmJhc2UpOworCWlmIChvYmotPm1tLm5fcGxhY2VtZW50cyA+IDEpCisJ CWtmcmVlKG9iai0+bW0ucGxhY2VtZW50cyk7CiAKLQkJaWYgKG9iai0+b3BzLT5yZWxlYXNlKQot CQkJb2JqLT5vcHMtPnJlbGVhc2Uob2JqKTsKKwlpZiAob2JqLT5yZXN2X3NoYXJlZF9mcm9tKQor CQlpOTE1X3ZtX3Jlc3ZfcHV0KG9iai0+cmVzdl9zaGFyZWRfZnJvbSk7CiAKLQkJaWYgKG9iai0+ bW0ubl9wbGFjZW1lbnRzID4gMSkKLQkJCWtmcmVlKG9iai0+bW0ucGxhY2VtZW50cyk7Cit9CisK K3N0YXRpYyB2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3RzKHN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICppOTE1LAorCQkJCSAgICBzdHJ1Y3QgbGxpc3Rfbm9kZSAqZnJlZWQpCit7CisJc3RydWN0 IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwgKm9uOwogCi0JCWlmIChvYmotPnJlc3Zfc2hhcmVk X2Zyb20pCi0JCQlpOTE1X3ZtX3Jlc3ZfcHV0KG9iai0+cmVzdl9zaGFyZWRfZnJvbSk7CisJbGxp c3RfZm9yX2VhY2hfZW50cnlfc2FmZShvYmosIG9uLCBmcmVlZCwgZnJlZWQpIHsKKwkJbWlnaHRf c2xlZXAoKTsKKwkJaWYgKG9iai0+b3BzLT5kZWxheWVkX2ZyZWUpIHsKKwkJCW9iai0+b3BzLT5k ZWxheWVkX2ZyZWUob2JqKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCV9faTkxNV9nZW1fZnJlZV9v YmplY3Qob2JqKTsKIAogCQkvKiBCdXQga2VlcCB0aGUgcG9pbnRlciBhbGl2ZSBmb3IgUkNVLXBy b3RlY3RlZCBsb29rdXBzICovCiAJCWNhbGxfcmN1KCZvYmotPnJjdSwgX19pOTE1X2dlbV9mcmVl X29iamVjdF9yY3UpOwpAQCAtMzE4LDYgKzMyOSw3IEBAIHN0YXRpYyB2b2lkIGk5MTVfZ2VtX2Zy ZWVfb2JqZWN0KHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKIAkgKiB3b3JrZXIgYW5k IHBlcmZvcm1pbmcgZnJlZXMgZGlyZWN0bHkgZnJvbSBzdWJzZXF1ZW50IGFsbG9jYXRpb25zIGZv cgogCSAqIGNydWRlIGJ1dCBlZmZlY3RpdmUgbWVtb3J5IHRocm90dGxpbmcuCiAJICovCisKIAlp ZiAobGxpc3RfYWRkKCZvYmotPmZyZWVkLCAmaTkxNS0+bW0uZnJlZV9saXN0KSkKIAkJcXVldWVf d29yayhpOTE1LT53cSwgJmk5MTUtPm1tLmZyZWVfd29yayk7CiB9CkBAIC00MTAsNiArNDIyLDQy IEBAIGludCBpOTE1X2dlbV9vYmplY3RfcmVhZF9mcm9tX3BhZ2Uoc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaiwgdTY0IG9mZnNldCwKIAlyZXR1cm4gMDsKIH0KIAorLyoqCisgKiBpOTE1 X2dlbV9vYmplY3RfZXZpY3RhYmxlIC0gV2hldGhlciBvYmplY3QgaXMgbGlrZWx5IGV2aWN0YWJs ZSBhZnRlciB1bmJpbmQuCisgKiBAb2JqOiBUaGUgb2JqZWN0IHRvIGNoZWNrCisgKgorICogVGhp cyBmdW5jdGlvbiBjaGVja3Mgd2hldGhlciB0aGUgb2JqZWN0IGlzIGxpa2VseSB1bnZpY3RhYmxl IGFmdGVyIHVuYmluZC4KKyAqIElmIHRoZSBvYmplY3QgaXMgbm90IGxvY2tlZCB3aGVuIGNoZWNr aW5nLCB0aGUgcmVzdWx0IGlzIG9ubHkgYWR2aXNvcnkuCisgKiBJZiB0aGUgb2JqZWN0IGlzIGxv Y2tlZCB3aGVuIGNoZWNraW5nLCBhbmQgdGhlIGZ1bmN0aW9uIHJldHVybnMgdHJ1ZSwKKyAqIHRo ZW4gYW4gZXZpY3Rpb24gc2hvdWxkIGluZGVlZCBiZSBwb3NzaWJsZS4gQnV0IHNpbmNlIHVubG9j a2VkIHZtYQorICogdW5waW5uaW5nIGFuZCB1bmJpbmRpbmcgaXMgY3VycmVudGx5IHBvc3NpYmxl LCB0aGUgb2JqZWN0IGNhbiBhY3R1YWxseQorICogYmVjb21lIGV2aWN0YWJsZSBldmVuIGlmIHRo aXMgZnVuY3Rpb24gcmV0dXJucyBmYWxzZS4KKyAqCisgKiBSZXR1cm46IHRydWUgaWYgdGhlIG9i amVjdCBtYXkgYmUgZXZpY3RhYmxlLiBGYWxzZSBvdGhlcndpc2UuCisgKi8KK2Jvb2wgaTkxNV9n ZW1fb2JqZWN0X2V2aWN0YWJsZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQorewor CXN0cnVjdCBpOTE1X3ZtYSAqdm1hOworCWludCBwaW5fY291bnQgPSBhdG9taWNfcmVhZCgmb2Jq LT5tbS5wYWdlc19waW5fY291bnQpOworCisJaWYgKCFwaW5fY291bnQpCisJCXJldHVybiB0cnVl OworCisJc3Bpbl9sb2NrKCZvYmotPnZtYS5sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHZt YSwgJm9iai0+dm1hLmxpc3QsIG9ial9saW5rKSB7CisJCWlmIChpOTE1X3ZtYV9pc19waW5uZWQo dm1hKSkgeworCQkJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOworCQkJcmV0dXJuIGZhbHNl OworCQl9CisJCWlmIChhdG9taWNfcmVhZCgmdm1hLT5wYWdlc19jb3VudCkpCisJCQlwaW5fY291 bnQtLTsKKwl9CisJc3Bpbl91bmxvY2soJm9iai0+dm1hLmxvY2spOworCUdFTV9XQVJOX09OKHBp bl9jb3VudCA8IDApOworCisJcmV0dXJuIHBpbl9jb3VudCA9PSAwOworfQorCiB2b2lkIGk5MTVf Z2VtX2luaXRfX29iamVjdHMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUpCiB7CiAJSU5J VF9XT1JLKCZpOTE1LT5tbS5mcmVlX3dvcmssIF9faTkxNV9nZW1fZnJlZV93b3JrKTsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaCBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaAppbmRleCAyZWJkNzk1MzdhZWEu LmFlNTkzMGUzMDdkNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVf Z2VtX29iamVjdC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmpl Y3QuaApAQCAtMjAwLDYgKzIwMCw5IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBpOTE1X2dlbV9vYmpl Y3RfdHJ5bG9jayhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogCiBzdGF0aWMgaW5s aW5lIHZvaWQgaTkxNV9nZW1fb2JqZWN0X3VubG9jayhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqKQogeworCWlmIChvYmotPm9wcy0+YWRqdXN0X2xydSkKKwkJb2JqLT5vcHMtPmFkanVz dF9scnUob2JqKTsKKwogCWRtYV9yZXN2X3VubG9jayhvYmotPmJhc2UucmVzdik7CiB9CiAKQEAg LTU4Nyw2ICs1OTAsMTIgQEAgaW50IGk5MTVfZ2VtX29iamVjdF9yZWFkX2Zyb21fcGFnZShzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLCB1NjQgb2Zmc2V0LAogCiBib29sIGk5MTVfZ2Vt X29iamVjdF9pc19zaG1lbShjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsK IAordm9pZCBfX2k5MTVfZ2VtX2ZyZWVfb2JqZWN0X3JjdShzdHJ1Y3QgcmN1X2hlYWQgKmhlYWQp OworCit2b2lkIF9faTkxNV9nZW1fZnJlZV9vYmplY3Qoc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKm9iaik7CisKK2Jvb2wgaTkxNV9nZW1fb2JqZWN0X2V2aWN0YWJsZShzdHJ1Y3QgZHJtX2k5 MTVfZ2VtX29iamVjdCAqb2JqKTsKKwogI2lmZGVmIENPTkZJR19NTVVfTk9USUZJRVIKIHN0YXRp YyBpbmxpbmUgYm9vbAogaTkxNV9nZW1fb2JqZWN0X2lzX3VzZXJwdHIoc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV9vYmplY3RfdHlwZXMuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV9vYmplY3RfdHlwZXMuaAppbmRleCA5OGY2OWQ4ZmQzN2QuLmIzNTA3NjVlMTkzNSAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaApAQCAt NjMsNiArNjMsMjAgQEAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIHsKIAkJICAgICAg Y29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9wd3JpdGUgKmFyZyk7CiAKIAlpbnQgKCpkbWFidWZf ZXhwb3J0KShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKKworCS8qKgorCSAqIGFk anVzdF9scnUgLSBub3RpZnkgdGhhdCB0aGUgbWFkdmlzZSB2YWx1ZSB3YXMgdXBkYXRlZAorCSAq IEBvYmo6IFRoZSBnZW0gb2JqZWN0CisJICoKKwkgKiBUaGUgbWFkdmlzZSB2YWx1ZSBtYXkgaGF2 ZSBiZWVuIHVwZGF0ZWQsIG9yIG9iamVjdCB3YXMgcmVjZW50bHkKKwkgKiByZWZlcmVuY2VkIHNv IGFjdCBhY2NvcmRpbmdseSAoUGVyaGFwcyBjaGFuZ2luZyBhbiBMUlUgbGlzdCBldGMpLgorCSAq LworCXZvaWQgKCphZGp1c3RfbHJ1KShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsK KworCS8qKgorCSAqIGRlbGF5ZWRfZnJlZSAtIE92ZXJyaWRlIHRoZSBkZWZhdWx0IGRlbGF5ZWQg ZnJlZSBpbXBsZW1lbnRhdGlvbgorCSAqLworCXZvaWQgKCpkZWxheWVkX2ZyZWUpKHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmopOwogCXZvaWQgKCpyZWxlYXNlKShzdHJ1Y3QgZHJtX2k5 MTVfZ2VtX29iamVjdCAqb2JqKTsKIAogCWNvbnN0IGNoYXIgKm5hbWU7IC8qIGZyaWVuZGx5IG5h bWUgZm9yIGRlYnVnLCBlLmcuIGxvY2tkZXAgY2xhc3NlcyAqLwpAQCAtMzA3LDYgKzMyMSwxMCBA QCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCB7CiAJCWJvb2wgZGlydHk6MTsKIAl9IG1tOwog CisJc3RydWN0IHsKKwkJc3RydWN0IHNnX3RhYmxlICpjYWNoZWRfaW9fc3Q7CisJfSB0dG07CisK IAkvKiogUmVjb3JkIG9mIGFkZHJlc3MgYml0IDE3IG9mIGVhY2ggcGFnZSBhdCBsYXN0IHVuYmlu ZC4gKi8KIAl1bnNpZ25lZCBsb25nICpiaXRfMTc7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9yZWdpb24uYwppbmRleCBmMjVlNjY0NmM1YjcuLmQxZjE4NDA1NDBkZCAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYwpAQCAtMTgsMTEgKzE4 LDcgQEAgdm9pZCBpOTE1X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKHN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0ICpvYmosCiAKIAltdXRleF9sb2NrKCZtZW0tPm9iamVjdHMubG9jayk7 CiAKLQlpZiAob2JqLT5mbGFncyAmIEk5MTVfQk9fQUxMT0NfVk9MQVRJTEUpCi0JCWxpc3RfYWRk KCZvYmotPm1tLnJlZ2lvbl9saW5rLCAmbWVtLT5vYmplY3RzLnB1cmdlYWJsZSk7Ci0JZWxzZQot CQlsaXN0X2FkZCgmb2JqLT5tbS5yZWdpb25fbGluaywgJm1lbS0+b2JqZWN0cy5saXN0KTsKLQor CWxpc3RfYWRkKCZvYmotPm1tLnJlZ2lvbl9saW5rLCAmbWVtLT5vYmplY3RzLmxpc3QpOwogCW11 dGV4X3VubG9jaygmbWVtLT5vYmplY3RzLmxvY2spOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fdHRtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li5lMzcxOGMzY2IyOTkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fdHRtLmMKQEAgLTAsMCArMSw1MzQgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBNSVQKKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAyMSBJbnRlbCBDb3Jwb3JhdGlvbgor ICovCisKKyNpbmNsdWRlIDxkcm0vdHRtL3R0bV9ib19kcml2ZXIuaD4KKyNpbmNsdWRlIDxkcm0v dHRtL3R0bV9wbGFjZW1lbnQuaD4KKworI2luY2x1ZGUgImk5MTVfZHJ2LmgiCisjaW5jbHVkZSAi aW50ZWxfbWVtb3J5X3JlZ2lvbi5oIgorI2luY2x1ZGUgImludGVsX3JlZ2lvbl90dG0uaCIKKwor I2luY2x1ZGUgImdlbS9pOTE1X2dlbV9vYmplY3QuaCIKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1f cmVnaW9uLmgiCisjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3R0bS5oIgorI2luY2x1ZGUgImdlbS9p OTE1X2dlbV90dG1fYm9fdXRpbC5oIgorCisjZGVmaW5lIEk5MTVfUExfTE1FTTAgVFRNX1BMX1BS SVYKKyNkZWZpbmUgSTkxNV9QTF9TWVNURU0gVFRNX1BMX1NZU1RFTQorI2RlZmluZSBJOTE1X1BM X1NUT0xFTiBUVE1fUExfVlJBTQorI2RlZmluZSBJOTE1X1BMX0dHVFQgVFRNX1BMX1RUCisKKyNk ZWZpbmUgSTkxNV9UVE1fUFJJT19QVVJHRSAgICAgMAorI2RlZmluZSBJOTE1X1RUTV9QUklPX05P X1BBR0VTICAxCisjZGVmaW5lIEk5MTVfVFRNX1BSSU9fSEFTX1BBR0VTIDIKKworLyoqCisgKiBz dHJ1Y3QgaTkxNV90dG1fdHQgLSBUVE0gcGFnZSB2ZWN0b3Igd2l0aCBhZGRpdGlvbmFsIHByaXZh dGUgaW5mb3JtYXRpb24KKyAqIEB0dG06IFRoZSBiYXNlIFRUTSBwYWdlIHZlY3Rvci4KKyAqIEBk ZXY6IFRoZSBzdHJ1Y3QgZGV2aWNlIHVzZWQgZm9yIGRtYSBtYXBwaW5nIGFuZCB1bm1hcHBpbmcu CisgKiBAY2FjaGVkX3N0OiBUaGUgY2FjaGVkIHNjYXR0ZXItZ2F0aGVyIHRhYmxlLgorICoKKyAq IE5vdGUgdGhhdCBETUEgbWF5IGJlIGdvaW5nIG9uIHJpZ2h0IHVwIHRvIHRoZSBwb2ludCB3aGVy ZSB0aGUgcGFnZS0KKyAqIHZlY3RvciBpcyB1bnBvcHVsYXRlZCBpbiBkZWxheWVkIGRlc3Ryb3ku IEhlbmNlIGtlZXAgdGhlCisgKiBzY2F0dGVyLWdhdGhlciB0YWJsZSBtYXBwZWQgYW5kIGNhY2hl ZCB1cCB0byB0aGF0IHBvaW50LiBUaGlzIGlzCisgKiBkaWZmZXJlbnQgZnJvbSB0aGUgY2FjaGVk IGdlbSBvYmplY3QgaW8gc2NhdHRlci1nYXRoZXIgdGFibGUgd2hpY2gKKyAqIGRvZXNuJ3QgaGF2 ZSBhbiBhc3NvY2lhdGVkIGRtYSBtYXBwaW5nLgorICovCitzdHJ1Y3QgaTkxNV90dG1fdHQgewor CXN0cnVjdCB0dG1fdHQgdHRtOworCXN0cnVjdCBkZXZpY2UgKmRldjsKKwlzdHJ1Y3Qgc2dfdGFi bGUgKmNhY2hlZF9zdDsKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdHRtX3BsYWNlIGxtZW0w X3N5c19wbGFjZW1lbnRfZmxhZ3NbXSA9IHsKKwl7CisJCS5mcGZuID0gMCwKKwkJLmxwZm4gPSAw LAorCQkubWVtX3R5cGUgPSBJOTE1X1BMX0xNRU0wLAorCQkuZmxhZ3MgPSAwLAorCX0sIHsKKwkJ LmZwZm4gPSAwLAorCQkubHBmbiA9IDAsCisJCS5tZW1fdHlwZSA9IEk5MTVfUExfU1lTVEVNLAor CQkuZmxhZ3MgPSAwLAorCX0KK307CisKK3N0cnVjdCB0dG1fcGxhY2VtZW50IGk5MTVfbG1lbTBf cGxhY2VtZW50ID0geworCS5udW1fcGxhY2VtZW50ID0gMSwKKwkucGxhY2VtZW50ID0gJmxtZW0w X3N5c19wbGFjZW1lbnRfZmxhZ3NbMF0sCisJLm51bV9idXN5X3BsYWNlbWVudCA9IDEsCisJLmJ1 c3lfcGxhY2VtZW50ID0gJmxtZW0wX3N5c19wbGFjZW1lbnRfZmxhZ3NbMF0sCit9OworCitzdHJ1 Y3QgdHRtX3BsYWNlbWVudCBpOTE1X2xtZW0wX3N5c19wbGFjZW1lbnQgPSB7CisJLm51bV9wbGFj ZW1lbnQgPSAxLAorCS5wbGFjZW1lbnQgPSAmbG1lbTBfc3lzX3BsYWNlbWVudF9mbGFnc1swXSwK KwkubnVtX2J1c3lfcGxhY2VtZW50ID0gMiwKKwkuYnVzeV9wbGFjZW1lbnQgPSAmbG1lbTBfc3lz X3BsYWNlbWVudF9mbGFnc1swXSwKK307CisKK3N0cnVjdCB0dG1fcGxhY2VtZW50IGk5MTVfc3lz X3BsYWNlbWVudCA9IHsKKwkubnVtX3BsYWNlbWVudCA9IDEsCisJLnBsYWNlbWVudCA9ICZsbWVt MF9zeXNfcGxhY2VtZW50X2ZsYWdzWzFdLAorCS5udW1fYnVzeV9wbGFjZW1lbnQgPSAxLAorCS5i dXN5X3BsYWNlbWVudCA9ICZsbWVtMF9zeXNfcGxhY2VtZW50X2ZsYWdzWzFdLAorfTsKKworc3Rh dGljIHZvaWQgaTkxNV90dG1fYWRqdXN0X2xydShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAq b2JqKTsKKworc3RhdGljIHN0cnVjdCB0dG1fdHQgKmk5MTVfdHRtX3R0X2NyZWF0ZShzdHJ1Y3Qg dHRtX2J1ZmZlcl9vYmplY3QgKmJvLAorCQkJCQkgdWludDMyX3QgcGFnZV9mbGFncykKK3sKKwlz dHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9CisJCXR0bV9tYW5hZ2VyX3R5cGUoYm8t PmJkZXYsIGJvLT5tZW0ubWVtX3R5cGUpOworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv YmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCXN0cnVjdCBpOTE1X3R0bV90dCAqaTkxNV90dDsK KwlpbnQgcmV0OworCisJaTkxNV90dCA9IGt6YWxsb2Moc2l6ZW9mKCppOTE1X3R0KSwgR0ZQX0tF Uk5FTCk7CisJaWYgKCFpOTE1X3R0KQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChvYmotPmZsYWdz ICYgSTkxNV9CT19BTExPQ19DUFVfQ0xFQVIgJiYKKwkgICAgbWFuLT51c2VfdHQpCisJCXBhZ2Vf ZmxhZ3MgfD0gVFRNX1BBR0VfRkxBR19aRVJPX0FMTE9DOworCisJcmV0ID0gdHRtX3R0X2luaXQo Jmk5MTVfdHQtPnR0bSwgYm8sIHBhZ2VfZmxhZ3MsIHR0bV9jYWNoZWQpOworCWlmIChyZXQpIHsK KwkJa2ZyZWUoaTkxNV90dCk7CisJCXJldHVybiBOVUxMOworCX0KKworCWk5MTVfdHQtPmRldiA9 IG9iai0+YmFzZS5kZXYtPmRldjsKKworCXJldHVybiAmaTkxNV90dC0+dHRtOworfQorCitzdGF0 aWMgdm9pZCBpOTE1X3R0bV90dF91bnBvcHVsYXRlKHN0cnVjdCB0dG1fZGV2aWNlICpiZGV2LCBz dHJ1Y3QgdHRtX3R0ICp0dG0pCit7CisJc3RydWN0IGk5MTVfdHRtX3R0ICppOTE1X3R0ID0gY29u dGFpbmVyX29mKHR0bSwgdHlwZW9mKCppOTE1X3R0KSwgdHRtKTsKKworCWlmIChpOTE1X3R0LT5j YWNoZWRfc3QpIHsKKwkJZG1hX3VubWFwX3NndGFibGUoaTkxNV90dC0+ZGV2LCBpOTE1X3R0LT5j YWNoZWRfc3QsCisJCQkJICBETUFfQklESVJFQ1RJT05BTCwgMCk7CisJCXNnX2ZyZWVfdGFibGUo aTkxNV90dC0+Y2FjaGVkX3N0KTsKKwkJa2ZyZWUoaTkxNV90dC0+Y2FjaGVkX3N0KTsKKwkJaTkx NV90dC0+Y2FjaGVkX3N0ID0gTlVMTDsKKwl9CisJdHRtX3Bvb2xfZnJlZSgmYmRldi0+cG9vbCwg dHRtKTsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fdHRfZGVzdHJveShzdHJ1Y3QgdHRtX2Rl dmljZSAqYmRldiwgc3RydWN0IHR0bV90dCAqdHRtKQoreworCXN0cnVjdCBpOTE1X3R0bV90dCAq aTkxNV90dCA9IGNvbnRhaW5lcl9vZih0dG0sIHR5cGVvZigqaTkxNV90dCksIHR0bSk7CisKKwl0 dG1fdHRfZGVzdHJveV9jb21tb24oYmRldiwgdHRtKTsKKwlrZnJlZShpOTE1X3R0KTsKK30KKwor c3RhdGljIGJvb2wgaTkxNV90dG1fZXZpY3Rpb25fdmFsdWFibGUoc3RydWN0IHR0bV9idWZmZXJf b2JqZWN0ICpibywKKwkJCQkgICAgICAgY29uc3Qgc3RydWN0IHR0bV9wbGFjZSAqcGxhY2UpCit7 CisJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7 CisKKwkvKiBXaWxsIGRvIGZvciBub3cuIE91ciBwaW5uZWQgb2JqZWN0cyBhcmUgc3RpbGwgb24g VFRNJ3MgTFJVIGxpc3RzICovCisJaWYgKCFpOTE1X2dlbV9vYmplY3RfZXZpY3RhYmxlKG9iaikp CisJCXJldHVybiBmYWxzZTsKKworCS8qIFRoaXMgaXNuJ3QgdmFsaWQgd2l0aCBhIGJ1ZGR5IGFs bG9jYXRvciAqLworCXJldHVybiB0dG1fYm9fZXZpY3Rpb25fdmFsdWFibGUoYm8sIHBsYWNlKTsK K30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fZXZpY3RfZmxhZ3Moc3RydWN0IHR0bV9idWZmZXJf b2JqZWN0ICpibywKKwkJCQkgc3RydWN0IHR0bV9wbGFjZW1lbnQgKnBsYWNlbWVudCkKK3sKKwkq cGxhY2VtZW50ID0gaTkxNV9zeXNfcGxhY2VtZW50OworfQorCitzdGF0aWMgaW50IGk5MTVfdHRt X21vdmVfbm90aWZ5KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCit7CisJc3RydWN0IGRy bV9pOTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CisJaW50IHJldDsK KworCXJldCA9IGk5MTVfZ2VtX29iamVjdF91bmJpbmQob2JqLCBJOTE1X0dFTV9PQkpFQ1RfVU5C SU5EX0FDVElWRSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9IF9faTkxNV9n ZW1fb2JqZWN0X3B1dF9wYWdlcyhvYmopOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgaTkxNV90dG1fZnJlZV9jYWNoZWRfaW9fc3Qoc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwlpZiAob2JqLT50dG0uY2FjaGVkX2lv X3N0KSB7CisJCXNnX2ZyZWVfdGFibGUob2JqLT50dG0uY2FjaGVkX2lvX3N0KTsKKwkJa2ZyZWUo b2JqLT50dG0uY2FjaGVkX2lvX3N0KTsKKwkJb2JqLT50dG0uY2FjaGVkX2lvX3N0ID0gTlVMTDsK Kwl9Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX3B1cmdlKHN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2Vt X3RvX3R0bShvYmopOworCisJaWYgKG9iai0+bW0ubWFkdiA9PSBfX0k5MTVfTUFEVl9QVVJHRUQp CisJCXJldHVybjsKKworCWk5MTVfdHRtX2ZyZWVfY2FjaGVkX2lvX3N0KG9iaik7CisKKwl0dG1f cmVzb3VyY2VfZnJlZShibywgJmJvLT5tZW0pOworCWlmIChiby0+dHRtKQorCQl0dG1fYm9fdHRf ZGVzdHJveShibyk7CisKKwlvYmotPm1tLm1hZHYgPSBfX0k5MTVfTUFEVl9QVVJHRUQ7Cit9CisK K3N0YXRpYyBib29sIGk5MTVfdHRtX3N3YXBfcG9zc2libGUoc3RydWN0IHR0bV9idWZmZXJfb2Jq ZWN0ICpibykKK3sKKwkvKiBXaWxsIGRvIGZvciBub3cuIE91ciBwaW5uZWQgb2JqZWN0cyBhcmUg c3RpbGwgb24gVFRNJ3MgTFJVIGxpc3RzICovCisJcmV0dXJuIGk5MTVfZ2VtX29iamVjdF9ldmlj dGFibGUoaTkxNV90dG1fdG9fZ2VtKGJvKSk7Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX3N3 YXBfbm90aWZ5KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCit7CisJc3RydWN0IGRybV9p OTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CisJaW50IHJldCA9IGk5 MTVfdHRtX21vdmVfbm90aWZ5KGJvKTsKKworCUdFTV9XQVJOX09OKHJldCk7CisJR0VNX1dBUk5f T04ob2JqLT50dG0uY2FjaGVkX2lvX3N0KTsKKwlpZiAoIXJldCAmJiBvYmotPm1tLm1hZHYgIT0g STkxNV9NQURWX1dJTExORUVEKQorCQlpOTE1X3R0bV9wdXJnZShvYmopOworfQorCitzdGF0aWMg dm9pZCBpOTE1X3R0bV9kZWxldGVfbWVtX25vdGlmeShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3Qg KmJvKQoreworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19n ZW0oYm8pOworCisJaWYgKGxpa2VseShvYmopKSB7CisJCS8qIFRoaXMgcmVsZWFzZXMgYWxsIGdl bSBvYmplY3QgYmluZGluZ3MgdG8gdGhlIGJhY2tlbmQuICovCisJCV9faTkxNV9nZW1fZnJlZV9v YmplY3Qob2JqKTsKKwl9Cit9CisKK3N0YXRpYyBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAq CitpOTE1X3R0bV9yZWdpb24oc3RydWN0IHR0bV9kZXZpY2UgKmJkZXYsIGludCB0dG1fbWVtX3R5 cGUpCit7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUgPSBjb250YWluZXJfb2YoYmRl diwgdHlwZW9mKCppOTE1KSwgYmRldik7CisKKwkvKiBUaGVyZSdzIHNvbWUgcm9vbSBmb3Igb3B0 aW1pemF0aW9uIGhlcmUuLi4gKi8KKwlHRU1fQlVHX09OKHR0bV9tZW1fdHlwZSAhPSBJOTE1X1BM X1NZU1RFTSAmJgorCQkgICB0dG1fbWVtX3R5cGUgPCBJOTE1X1BMX0xNRU0wKTsKKwlpZiAodHRt X21lbV90eXBlID09IEk5MTVfUExfU1lTVEVNKQorCQlyZXR1cm4gaW50ZWxfbWVtb3J5X3JlZ2lv bl9sb29rdXAoaTkxNSwgSU5URUxfTUVNT1JZX1NZU1RFTSwKKwkJCQkJCSAgMCk7CisKKwlyZXR1 cm4gaW50ZWxfbWVtb3J5X3JlZ2lvbl9sb29rdXAoaTkxNSwgSU5URUxfTUVNT1JZX0xPQ0FMLAor CQkJCQkgIHR0bV9tZW1fdHlwZSAtIEk5MTVfUExfTE1FTTApOworfQorCitzdGF0aWMgc3RydWN0 IHNnX3RhYmxlICppOTE1X3R0bV90dF9nZXRfc3Qoc3RydWN0IHR0bV90dCAqdHRtKQoreworCXN0 cnVjdCBpOTE1X3R0bV90dCAqaTkxNV90dCA9IGNvbnRhaW5lcl9vZih0dG0sIHR5cGVvZigqaTkx NV90dCksIHR0bSk7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwlzdHJ1Y3Qgc2dfdGFibGUg KnN0OworCWludCByZXQ7CisKKwlpZiAoaTkxNV90dC0+Y2FjaGVkX3N0KQorCQlyZXR1cm4gaTkx NV90dC0+Y2FjaGVkX3N0OworCisJc3QgPSBremFsbG9jKHNpemVvZigqc3QpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIXN0KQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXNnID0gX19zZ19h bGxvY190YWJsZV9mcm9tX3BhZ2VzCisJCShzdCwgdHRtLT5wYWdlcywgdHRtLT5udW1fcGFnZXMs IDAsCisJCSAodW5zaWduZWQgbG9uZykgdHRtLT5udW1fcGFnZXMgPDwgUEFHRV9TSElGVCwKKwkJ IGk5MTVfc2dfc2VnbWVudF9zaXplKCksIE5VTEwsIDAsIEdGUF9LRVJORUwpOworCWlmIChJU19F UlIoc2cpKSB7CisJCWtmcmVlKHN0KTsKKwkJcmV0dXJuIEVSUl9DQVNUKHNnKTsKKwl9CisKKwly ZXQgPSBkbWFfbWFwX3NndGFibGUoaTkxNV90dC0+ZGV2LCBzdCwgRE1BX0JJRElSRUNUSU9OQUws IDApOworCWlmIChyZXQpIHsKKwkJc2dfZnJlZV90YWJsZShzdCk7CisJCWtmcmVlKHN0KTsKKwkJ cmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisKKwlpOTE1X3R0LT5jYWNoZWRfc3QgPSBzdDsKKwly ZXR1cm4gc3Q7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2dfdGFibGUgKgoraTkxNV90dG1fcmVzb3Vy Y2VfZ2V0X3N0KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkgc3RydWN0IHR0 bV9yZXNvdXJjZSAqcmVzKQoreworCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8gPSBpOTE1 X2dlbV90b190dG0ob2JqKTsKKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9CisJ CXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIHJlcy0+bWVtX3R5cGUpOworCXN0cnVjdCBzZ190 YWJsZSAqc3Q7CisKKwlpZiAobWFuLT51c2VfdHQpCisJCXJldHVybiBpOTE1X3R0bV90dF9nZXRf c3QoYm8tPnR0bSk7CisKKwlzdCA9IGt6YWxsb2Moc2l6ZW9mKCpzdCksIEdGUF9LRVJORUwpOwor CWlmICghc3QpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJc3QgPSBpbnRlbF9yZWdp b25fdHRtX25vZGVfdG9fc3Qob2JqLT5tbS5yZWdpb24sIHJlcy0+bW1fbm9kZSk7CisJaWYgKElT X0VSUihzdCkpCisJCXJldHVybiBFUlJfQ0FTVChzdCk7CisKKwlyZXR1cm4gc3Q7Cit9CisKK3N0 YXRpYyBpbnQgaTkxNV90dG1fbW92ZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLCBib29s IGV2aWN0LAorCQkJIHN0cnVjdCB0dG1fb3BlcmF0aW9uX2N0eCAqY3R4LAorCQkJIHN0cnVjdCB0 dG1fcmVzb3VyY2UgKm5ld19tZW0sCisJCQkgc3RydWN0IHR0bV9wbGFjZSAqaG9wKQoreworCXN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCXN0 cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdlciAqbmV3X21hbiA9CisJCXR0bV9tYW5hZ2VyX3R5cGUo Ym8tPmJkZXYsIG5ld19tZW0tPm1lbV90eXBlKTsKKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFn ZXIgKm9sZF9tYW4gPQorCQl0dG1fbWFuYWdlcl90eXBlKGJvLT5iZGV2LCBiby0+bWVtLm1lbV90 eXBlKTsKKwlzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbmV3X3JlZywgKm9sZF9yZWc7CisJ dW5pb24geworCQlzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyX3R0IHR0OworCQlzdHJ1Y3QgaTkx NV90dG1fa21hcF9pdGVyX2lvbWFwIGlvOworCX0gX25ld19pdGVyLCBfb2xkX2l0ZXI7CisJc3Ry dWN0IGk5MTVfdHRtX2ttYXBfaXRlciAqbmV3X2l0ZXIsICpvbGRfaXRlcjsKKwlzdHJ1Y3Qgc2df dGFibGUgKm5ld19zdDsKKwlpbnQgcmV0OworCisJbmV3X3JlZyA9IGk5MTVfdHRtX3JlZ2lvbihi by0+YmRldiwgbmV3X21lbS0+bWVtX3R5cGUpOworCW9sZF9yZWcgPSBpOTE1X3R0bV9yZWdpb24o Ym8tPmJkZXYsIGJvLT5tZW0ubWVtX3R5cGUpOworCUdFTV9CVUdfT04oIW5ld19yZWcgfHwgIW9s ZF9yZWcpOworCisJLyogU3luYyBmb3Igbm93LiBXZSBjb3VsZCBkbyB0aGUgYWN0dWFsIGNvcHkg YXN5bmMuICovCisJcmV0ID0gdHRtX2JvX3dhaXRfY3R4KGJvLCBjdHgpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKKwlyZXQgPSBpOTE1X3R0bV9tb3ZlX25vdGlmeShibyk7CisJaWYgKHJl dCkKKwkJcmV0dXJuIHJldDsKKworCWlmIChvYmotPm1tLm1hZHYgIT0gSTkxNV9NQURWX1dJTExO RUVEKSB7CisJCWk5MTVfdHRtX3B1cmdlKG9iaik7CisJCXR0bV9yZXNvdXJjZV9mcmVlKGJvLCBu ZXdfbWVtKTsKKwkJcmV0dXJuIDA7CisJfQorCisJLyogUG9wdWxhdGUgdHRtIHdpdGggcGFnZXMg aWYgbmVlZGVkLiBUeXBpY2FsbHkgc3lzdGVtIG1lbW9yeS4gKi8KKwlpZiAobmV3X21hbi0+dXNl X3R0ICYmIGJvLT50dG0pIHsKKwkJcmV0ID0gdHRtX3R0X3BvcHVsYXRlKGJvLT5iZGV2LCBiby0+ dHRtLCBjdHgpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwluZXdfc3QgPSBp OTE1X3R0bV9yZXNvdXJjZV9nZXRfc3Qob2JqLCBuZXdfbWVtKTsKKwlpZiAoSVNfRVJSKG5ld19z dCkpCisJCXJldHVybiBQVFJfRVJSKG5ld19zdCk7CisKKwluZXdfaXRlciA9IG5ld19tYW4tPnVz ZV90dCA/CisJCWk5MTVfdHRtX2ttYXBfaXRlcl90dF9pbml0KCZfbmV3X2l0ZXIudHQsIGJvLT50 dG0pIDoKKwkJaTkxNV90dG1fa21hcF9pdGVyX2lvbWFwX2luaXQoJl9uZXdfaXRlci5pbywgJm5l d19yZWctPmlvbWFwLAorCQkJCQkgICAgICBuZXdfc3QsIG5ld19yZWctPnJlZ2lvbi5zdGFydCk7 CisKKwlvbGRfaXRlciA9IG9sZF9tYW4tPnVzZV90dCA/CisJCWk5MTVfdHRtX2ttYXBfaXRlcl90 dF9pbml0KCZfb2xkX2l0ZXIudHQsIGJvLT50dG0pIDoKKwkJaTkxNV90dG1fa21hcF9pdGVyX2lv bWFwX2luaXQoJl9vbGRfaXRlci5pbywgJm9sZF9yZWctPmlvbWFwLAorCQkJCQkgICAgICBvYmot PnR0bS5jYWNoZWRfaW9fc3QsCisJCQkJCSAgICAgIG9sZF9yZWctPnJlZ2lvbi5zdGFydCk7CisK KwlpOTE1X3R0bV9tb3ZlX21lbWNweShibywgbmV3X21lbSwgbmV3X2l0ZXIsIG9sZF9pdGVyKTsK KwlpOTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChvYmopOworCisJaWYgKCFuZXdfbWFuLT51c2Vf dHQpCisJCW9iai0+dHRtLmNhY2hlZF9pb19zdCA9IG5ld19zdDsKKworCXJldHVybiAwOworfQor CitzdHJ1Y3QgdHRtX2RldmljZV9mdW5jcyBpOTE1X3R0bV9ib19kcml2ZXIgPSB7CisJLnR0bV90 dF9jcmVhdGUgPSBpOTE1X3R0bV90dF9jcmVhdGUsCisJLnR0bV90dF91bnBvcHVsYXRlID0gaTkx NV90dG1fdHRfdW5wb3B1bGF0ZSwKKwkudHRtX3R0X2Rlc3Ryb3kgPSBpOTE1X3R0bV90dF9kZXN0 cm95LAorCS5ldmljdGlvbl92YWx1YWJsZSA9IGk5MTVfdHRtX2V2aWN0aW9uX3ZhbHVhYmxlLAor CS5ldmljdF9mbGFncyA9IGk5MTVfdHRtX2V2aWN0X2ZsYWdzLAorCS5tb3ZlID0gaTkxNV90dG1f bW92ZSwKKwkudmVyaWZ5X2FjY2VzcyA9IE5VTEwsCisJLnN3YXBfcG9zc2libGUgPSBpOTE1X3R0 bV9zd2FwX3Bvc3NpYmxlLAorCS5zd2FwX25vdGlmeSA9IGk5MTVfdHRtX3N3YXBfbm90aWZ5LAor CS5kZWxldGVfbWVtX25vdGlmeSA9IGk5MTVfdHRtX2RlbGV0ZV9tZW1fbm90aWZ5LAorfTsKKwor c3RhdGljIGludCBpOTE1X3R0bV9nZXRfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Qg Km9iaikKK3sKKwlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvID0gaTkxNV9nZW1fdG9fdHRt KG9iaik7CisJc3RydWN0IHR0bV9vcGVyYXRpb25fY3R4IGN0eCA9IHsKKwkJLmludGVycnVwdGli bGUgPSB0cnVlLAorCQkubm9fd2FpdF9ncHUgPSBmYWxzZSwKKwl9OworCXN0cnVjdCBzZ190YWJs ZSAqc3Q7CisJaW50IHJldDsKKworCS8qIFN3YXAgaW4uICovCisJaWYgKGJvLT50dG0gJiYgKGJv LT50dG0tPnBhZ2VfZmxhZ3MgJiBUVE1fUEFHRV9GTEFHX1NXQVBQRUQpKSB7CisJCXJldCA9IHR0 bV90dF9wb3B1bGF0ZShiby0+YmRldiwgYm8tPnR0bSwgJmN0eCk7CisJCWlmIChyZXQpCisJCQly ZXR1cm4gcmV0OworCX0KKworCS8qIE1vdmUgdG8gdGhlIHJlcXVlc3RlZCBwbGFjZW1lbnQuICov CisJcmV0ID0gdHRtX2JvX3ZhbGlkYXRlKGJvLCAmaTkxNV9sbWVtMF9wbGFjZW1lbnQsICZjdHgp OworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwkvKiBPYmplY3QgZWl0aGVyIGhhcyBhIHBh Z2UgdmVjdG9yIG9yIGlzIGFuIGlvbWVtIG9iamVjdCAqLworCXN0ID0gYm8tPnR0bSA/IGk5MTVf dHRtX3R0X2dldF9zdChiby0+dHRtKSA6IG9iai0+dHRtLmNhY2hlZF9pb19zdDsKKwlpZiAoSVNf RVJSKHN0KSkKKwkJcmV0dXJuIFBUUl9FUlIoc3QpOworCisJX19pOTE1X2dlbV9vYmplY3Rfc2V0 X3BhZ2VzKG9iaiwgc3QsIGk5MTVfc2dfZG1hX3BhZ2Vfc2l6ZXMoc3QtPnNnbCkpOworCisJaTkx NV90dG1fYWRqdXN0X2xydShvYmopOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQg aTkxNV90dG1fcHV0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCQkg ICAgICAgc3RydWN0IHNnX3RhYmxlICpzdCkKK3sKKwkvKgorCSAqIFdlJ3JlIGN1cnJlbnRseSBu b3QgY2FsbGVkIGZyb20gYSBzaHJpbmtlciwgc28gcHV0X3BhZ2VzKCkKKwkgKiB0eXBpY2FsbHkg bWVhbnMgdGhlIG9iamVjdCBpcyBhYm91dCB0byBkZXN0cm95ZWQsIG9yIGNhbGxlZAorCSAqIGZy b20gbW92ZV9ub3RpZnkoKS4gU28ganVzdCBhdm9pZCBkb2luZyBtdWNoIGZvciBub3cuCisJICog SWYgdGhlIG9iamVjdCBpcyBub3QgZGVzdHJveWVkIG5leHQsIFRoZSBUVE0gZXZpY3Rpb24gbG9n aWMKKwkgKiBhbmQgc2hyaW5rZXJzIHdpbGwgbW92ZSBpdCBvdXQgaWYgbmVlZGVkLgorCSAqLwor CisJaTkxNV90dG1fYWRqdXN0X2xydShvYmopOworfQorCitzdGF0aWMgdm9pZCBpOTE1X3R0bV9h ZGp1c3RfbHJ1KHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0 bV9idWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCisJLyoKKwkgKiBE b24ndCBtYW5pcHVsYXRlIHRoZSBUVE0gTFJVcyB3aGlsZSBpbiBUVE0gYm8gZGVzdHJ1Y3Rpb24u CisJICogV2UncmUgY2FsbGVkIHRocm91Z2ggaTkxNV90dG1fZGVsZXRlX21lbV9ub3RpZnkoKS4K KwkgKi8KKwlpZiAoIWtyZWZfcmVhZCgmYm8tPmtyZWYpKQorCQlyZXR1cm47CisKKwkvKgorCSAq IFB1dCBvbiB0aGUgY29ycmVjdCBMUlUgbGlzdCBkZXBlbmRpbmcgb24gdGhlIE1BRFYgc3RhdHVz CisJICovCisJc3Bpbl9sb2NrKCZiby0+YmRldi0+bHJ1X2xvY2spOworCWlmIChvYmotPm1tLm1h ZHYgIT0gSTkxNV9NQURWX1dJTExORUVEKSB7CisJCWJvLT5wcmlvcml0eSA9IEk5MTVfVFRNX1BS SU9fUFVSR0U7CisJfSBlbHNlIGlmICghaTkxNV9nZW1fb2JqZWN0X2hhc19wYWdlcyhvYmopKSB7 CisJCWlmIChiby0+cHJpb3JpdHkgPCBJOTE1X1RUTV9QUklPX0hBU19QQUdFUykKKwkJCWJvLT5w cmlvcml0eSA9IEk5MTVfVFRNX1BSSU9fSEFTX1BBR0VTOworCX0gZWxzZSB7CisJCWlmIChiby0+ cHJpb3JpdHkgPiBJOTE1X1RUTV9QUklPX05PX1BBR0VTKQorCQkJYm8tPnByaW9yaXR5ID0gSTkx NV9UVE1fUFJJT19OT19QQUdFUzsKKwl9CisKKwl0dG1fYm9fbW92ZV90b19scnVfdGFpbChibywg JmJvLT5tZW0sIE5VTEwpOworCXNwaW5fdW5sb2NrKCZiby0+YmRldi0+bHJ1X2xvY2spOworfQor CisvKgorICogVFRNLWJhY2tlZCBnZW0gb2JqZWN0IGRlc3RydWN0aW9uIHJlcXVpcmVzIHNvbWUg Y2xhcmlmaWNhdGlvbi4KKyAqIEJhc2ljYWxseSB3ZSBoYXZlIHR3byBwb3NzaWJpbGl0aWVzIGhl cmUuIFdlIGNhbiBlaXRoZXIgcmVseSBvbiB0aGUKKyAqIGk5MTUgZGVsYXllZCBkZXN0cnVjdGlv biBhbmQgcHV0IHRoZSBUVE0gb2JqZWN0IHdoZW4gdGhlIG9iamVjdAorICogaXMgaWRsZS4gVGhp cyB3b3VsZCBiZSBkZXRlY3RlZCBieSBUVE0gd2hpY2ggd291bGQgYnlwYXNzIHRoZQorICogVFRN IGRlbGF5ZWQgZGVzdHJveSBoYW5kbGluZy4gVGhlIG90aGVyIGFwcHJvYWNoIGlzIHRvIHB1dCB0 aGUgVFRNCisgKiBvYmplY3QgZWFybHkgYW5kIHJlbHkgb24gdGhlIFRUTSBkZXN0cm95ZWQgaGFu ZGxpbmcsIGFuZCB0aGVuIGZyZWUKKyAqIHRoZSBsZWZ0b3ZlciBwYXJ0cyBvZiB0aGUgR0VNIG9i amVjdCBvbmNlIFRUTSdzIGRlc3Ryb3llZCBsaXN0IGhhbmRsaW5nIGlzCisgKiBjb21wbGV0ZS4g Rm9yIG5vdywgd2UgcmVseSBvbiB0aGUgbGF0dGVyIGZvciB0d28gcmVhc29uczoKKyAqIGEpIFRU TSBjYW4gZXZpY3QgYW4gb2JqZWN0IGV2ZW4gd2hlbiBpdCdzIG9uIHRoZSBkZWxheWVkIGRlc3Ry b3kgbGlzdCwKKyAqIHdoaWNoIGluIHRoZW9yeSBhbGxvd3MgZm9yIGNvbXBsZXRlIGV2aWN0aW9u LgorICogYikgVGhlcmUgaXMgd29yayBnb2luZyBvbiBpbiBUVE0gdG8gYWxsb3cgZnJlZWluZyBh biBvYmplY3QgZXZlbiB3aGVuCisgKiBpdCdzIG5vdCBpZGxlLCBhbmQgdXNpbmcgdGhlIFRUTSBk ZXN0cm95ZWQgbGlzdCBoYW5kbGluZyBjb3VsZCBoZWxwIHVzCisgKiBiZW5lZml0IGZyb20gdGhh dC4KKyAqLworc3RhdGljIHZvaWQgaTkxNV90dG1fZGVsYXllZF9mcmVlKHN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmopCit7CisJdHRtX2JvX3B1dChpOTE1X2dlbV90b190dG0ob2JqKSk7 Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgaTkxNV9n ZW1fdHRtX29ial9vcHMgPSB7CisJLm5hbWUgPSAiaTkxNV9nZW1fb2JqZWN0X3R0bSIsCisJLmZs YWdzID0gSTkxNV9HRU1fT0JKRUNUX0hBU19JT01FTSwKKworCS5nZXRfcGFnZXMgPSBpOTE1X3R0 bV9nZXRfcGFnZXMsCisJLnB1dF9wYWdlcyA9IGk5MTVfdHRtX3B1dF9wYWdlcywKKwkudHJ1bmNh dGUgPSBpOTE1X3R0bV9wdXJnZSwKKwkuYWRqdXN0X2xydSA9IGk5MTVfdHRtX2FkanVzdF9scnUs CisJLmRlbGF5ZWRfZnJlZSA9IGk5MTVfdHRtX2RlbGF5ZWRfZnJlZSwKK307CisKK3ZvaWQgaTkx NV90dG1fYm9fZGVzdHJveShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCXN0cnVj dCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPSBpOTE1X3R0bV90b19nZW0oYm8pOworCisJaTkx NV9nZW1fb2JqZWN0X3JlbGVhc2VfbWVtb3J5X3JlZ2lvbihvYmopOworCWNhbGxfcmN1KCZvYmot PnJjdSwgX19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3UpOworfQorCisvKioKKyAqIF9faTkxNV9n ZW1fdHRtX29iamVjdF9pbml0IC0gSW5pdGlhbGl6ZSBhIHR0bS1iYWNrZWQgaTkxNSBnZW0gb2Jq ZWN0CisgKiBAbWVtOiBUaGUgaW5pdGlhbCBtZW1vcnkgcmVnaW9uIGZvciB0aGUgb2JqZWN0Lgor ICogQG9iajogVGhlIGdlbSBvYmplY3QuCisgKiBAc2l6ZTogT2JqZWN0IHNpemUgaW4gYnl0ZXMu CisgKiBAZmxhZ3M6IGdlbSBvYmplY3QgZmxhZ3MuCisgKgorICogUmV0dXJuOiAwIG9uIHN1Y2Nl c3MsIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KKyAqLworaW50IF9faTkxNV9nZW1f dHRtX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCisJCQkgICAg ICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKKwkJCSAgICAgICByZXNvdXJjZV9z aXplX3Qgc2l6ZSwKKwkJCSAgICAgICB1bnNpZ25lZCBpbnQgZmxhZ3MpCit7CisJc3RhdGljIHN0 cnVjdCBsb2NrX2NsYXNzX2tleSBsb2NrX2NsYXNzOworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICppOTE1ID0gbWVtLT5pOTE1OworCXNpemVfdCBhbGlnbm1lbnQgPSAwOworCWludCByZXQ7CisK KwkvKiBBZGp1c3QgYWxpZ25tZW50IHRvIEdQVS0gYW5kIENQVSBodWdlIHBhZ2Ugc2l6ZXMuICov CisKKwlpZiAobWVtLT5pc19yYW5nZV9tYW5hZ2VyKSB7CisJCWlmIChzaXplID49IFNaXzFHKQor CQkJYWxpZ25tZW50ID0gU1pfMUcgPj4gUEFHRV9TSElGVDsKKwkJZWxzZSBpZiAoc2l6ZSA+PSBT Wl8yTSkKKwkJCWFsaWdubWVudCA9IFNaXzJNID4+IFBBR0VfU0hJRlQ7CisJCWVsc2UgaWYgKHNp emUgPj0gU1pfNjRLKQorCQkJYWxpZ25tZW50ID0gU1pfNjRLID4+IFBBR0VfU0hJRlQ7CisJfQor CisJZHJtX2dlbV9wcml2YXRlX29iamVjdF9pbml0KCZpOTE1LT5kcm0sICZvYmotPmJhc2UsIHNp emUpOworCWk5MTVfZ2VtX29iamVjdF9pbml0KG9iaiwgJmk5MTVfZ2VtX3R0bV9vYmpfb3BzLCAm bG9ja19jbGFzcywgZmxhZ3MpOworCWk5MTVfZ2VtX29iamVjdF9pbml0X21lbW9yeV9yZWdpb24o b2JqLCBtZW0pOworCWk5MTVfZ2VtX29iamVjdF9tYWtlX3Vuc2hyaW5rYWJsZShvYmopOworCisJ cmV0ID0gdHRtX2JvX2luaXQoJmk5MTUtPmJkZXYsIGk5MTVfZ2VtX3RvX3R0bShvYmopLCBzaXpl LAorCQkJICB0dG1fYm9fdHlwZV9rZXJuZWwsICZpOTE1X3N5c19wbGFjZW1lbnQsIGFsaWdubWVu dCwKKwkJCSAgdHJ1ZSwgTlVMTCwgTlVMTCwgaTkxNV90dG1fYm9fZGVzdHJveSk7CisKKwlvYmot PnJlYWRfZG9tYWlucyA9IEk5MTVfR0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RPTUFJTl9HVFQ7 CisKKwlpOTE1X2dlbV9vYmplY3Rfc2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIEk5MTVfQ0FDSEVf Tk9ORSk7CisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9pOTE1X2dlbV90dG0uaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90 dG0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmI4ZDNkY2JiNTBk ZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90 dG0uaApAQCAtMCwwICsxLDQ4IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUICov CisvKgorICogQ29weXJpZ2h0IMKpIDIwMjEgSW50ZWwgQ29ycG9yYXRpb24KKyAqLworI2lmbmRl ZiBfSTkxNV9HRU1fVFRNX0hfCisjZGVmaW5lIF9JOTE1X0dFTV9UVE1fSF8KKworI2luY2x1ZGUg ImdlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaCIKKworLyoqCisgKiBpOTE1X2dlbV90b190dG0g LSBDb252ZXJ0IGEgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgdG8gYQorICogc3RydWN0IHR0 bV9idWZmZXJfb2JqZWN0LgorICogQG9iajogUG9pbnRlciB0byB0aGUgZ2VtIG9iamVjdC4KKyAq CisgKiBSZXR1cm46IFBvaW50ZXIgdG8gdGhlIGVtYmVkZGVkIHN0cnVjdCB0dG1fYnVmZmVyX29i amVjdC4KKyAqLworc3RhdGljIGlubGluZSBzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKgoraTkx NV9nZW1fdG9fdHRtKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJcmV0dXJu ICZvYmotPl9fZG9fbm90X2FjY2VzczsKK30KKworLyoKKyAqIGk5MTUgdHRtIGdlbSBvYmplY3Qg ZGVzdHJ1Y3Rvci4gSW50ZXJuYWwgdXNlIG9ubHkuCisgKi8KK3ZvaWQgaTkxNV90dG1fYm9fZGVz dHJveShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKTsKKworLyoqCisgKiBpOTE1X3R0bV90 b19nZW0gLSBDb252ZXJ0IGEgc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0IHRvIGFuIGVtYmVkZGlu ZworICogc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QuCisgKgorICogUmV0dXJuOiBQb2ludGVy IHRvIHRoZSBlbWJlZGRpbmcgc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0LCBvciBOVUxMCisgKiBp ZiB0aGUgb2JqZWN0IHdhcyBub3QgYW4gaTkxNSB0dG0gb2JqZWN0LgorICovCitzdGF0aWMgaW5s aW5lIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICoKK2k5MTVfdHRtX3RvX2dlbShzdHJ1Y3Qg dHRtX2J1ZmZlcl9vYmplY3QgKmJvKQoreworCWlmIChHRU1fV0FSTl9PTihiby0+ZGVzdHJveSAh PSBpOTE1X3R0bV9ib19kZXN0cm95KSkKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXR1cm4gY29udGFp bmVyX29mKGJvLCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCwgX19kb19ub3RfYWNjZXNzKTsK K30KKworaW50IF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlf cmVnaW9uICptZW0sCisJCQkgICAgICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwK KwkJCSAgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCSAgICAgICB1bnNpZ25lZCBpbnQg ZmxhZ3MpOworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRl bF9yZWdpb25fbG1lbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9uX2xt ZW0uYwppbmRleCBmNzM2NmIwNTRmOGUuLjRhZTFmNzE3YTk0YyAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmVnaW9uX2xtZW0uYworKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9yZWdpb25fbG1lbS5jCkBAIC05LDYgKzksNyBAQAogI2luY2x1ZGUg ImludGVsX3JlZ2lvbl90dG0uaCIKICNpbmNsdWRlICJnZW0vaTkxNV9nZW1fbG1lbS5oIgogI2lu Y2x1ZGUgImdlbS9pOTE1X2dlbV9yZWdpb24uaCIKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1fdHRt LmgiCiAjaW5jbHVkZSAiaW50ZWxfcmVnaW9uX2xtZW0uaCIKIAogc3RhdGljIGludCBpbml0X2Zh a2VfbG1lbV9iYXIoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSkKQEAgLTEwNyw3ICsx MDgsNyBAQCByZWdpb25fbG1lbV9pbml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0p CiBzdGF0aWMgY29uc3Qgc3RydWN0IGludGVsX21lbW9yeV9yZWdpb25fb3BzIGludGVsX3JlZ2lv bl9sbWVtX29wcyA9IHsKIAkuaW5pdCA9IHJlZ2lvbl9sbWVtX2luaXQsCiAJLnJlbGVhc2UgPSBy ZWdpb25fbG1lbV9yZWxlYXNlLAotCS5pbml0X29iamVjdCA9IF9faTkxNV9nZW1fbG1lbV9vYmpl Y3RfaW5pdCwKKwkuaW5pdF9vYmplY3QgPSBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdCwKIH07 CiAKIHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jCmlu ZGV4IDE4MGY2ZTkxMDdkNC4uMzUwMjgzYWI5YTgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X2dlbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMK QEAgLTEwMDUsOCArMTAwNSwxMSBAQCBpOTE1X2dlbV9tYWR2aXNlX2lvY3RsKHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCiAJCX0KIAl9CiAKLQlpZiAob2JqLT5tbS5tYWR2ICE9 IF9fSTkxNV9NQURWX1BVUkdFRCkKKwlpZiAob2JqLT5tbS5tYWR2ICE9IF9fSTkxNV9NQURWX1BV UkdFRCkgewogCQlvYmotPm1tLm1hZHYgPSBhcmdzLT5tYWR2OworCQlpZiAob2JqLT5vcHMtPmFk anVzdF9scnUpCisJCQlvYmotPm9wcy0+YWRqdXN0X2xydShvYmopOworCX0KIAogCWlmIChpOTE1 X2dlbV9vYmplY3RfaGFzX3BhZ2VzKG9iaikpIHsKIAkJc3RydWN0IGxpc3RfaGVhZCAqbGlzdDsK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdpb24uYwppbmRleCA0MDkyY2M5 ODc2NzkuLmJkMjdlODk3ZDRkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfbWVtb3J5X3JlZ2lvbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9y eV9yZWdpb24uYwpAQCAtMTQ5LDcgKzE0OSw2IEBAIGludGVsX21lbW9yeV9yZWdpb25fY3JlYXRl KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAogCiAJbXV0ZXhfaW5pdCgmbWVtLT5vYmpl Y3RzLmxvY2spOwogCUlOSVRfTElTVF9IRUFEKCZtZW0tPm9iamVjdHMubGlzdCk7Ci0JSU5JVF9M SVNUX0hFQUQoJm1lbS0+b2JqZWN0cy5wdXJnZWFibGUpOwogCUlOSVRfTElTVF9IRUFEKCZtZW0t PnJlc2VydmVkKTsKIAogCW11dGV4X2luaXQoJm1lbS0+bW1fbG9jayk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmggYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmgKaW5kZXggZTY5Y2RlMTNkYWYyLi43YjVmYTk3 YzBiNTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX21lbW9yeV9yZWdp b24uaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1vcnlfcmVnaW9uLmgKQEAg LTEwMCw3ICsxMDAsNiBAQCBzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiB7CiAJc3RydWN0IHsK IAkJc3RydWN0IG11dGV4IGxvY2s7IC8qIFByb3RlY3RzIGFjY2VzcyB0byBvYmplY3RzICovCiAJ CXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKLQkJc3RydWN0IGxpc3RfaGVhZCBwdXJnZWFibGU7CiAJ fSBvYmplY3RzOwogCiAJc2l6ZV90IGNodW5rX3NpemU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9yZWdpb25fdHRtLmMKaW5kZXggM2JkOWNhYTYwMjk4Li5hNzRjYWU0NjAyYjUgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYworKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmMKQEAgLTEwLDggKzEwLDcgQEAKIAogI2lu Y2x1ZGUgImludGVsX3JlZ2lvbl90dG0uaCIKIAotLyogQSBaZXJvLWluaXRpYWxpemVkIGRyaXZl ciBmb3Igbm93LiBXZSBkb24ndCBoYXZlIGEgVFRNIGJhY2tlbmQgeWV0LiAqLwotc3RhdGljIHN0 cnVjdCB0dG1fZGV2aWNlX2Z1bmNzIGk5MTVfdHRtX2JvX2RyaXZlcjsKK2V4dGVybiBzdHJ1Y3Qg dHRtX2RldmljZV9mdW5jcyBpOTE1X3R0bV9ib19kcml2ZXI7CiAKIC8qKgogICogRE9DOiBUVE0g c3VwcG9ydCBzdHJ1Y3R1cmUKQEAgLTE5OCw2ICsxOTcsNyBAQCBzdHJ1Y3Qgc2dfdGFibGUgKmlu dGVsX3JlZ2lvbl90dG1fbm9kZV90b19zdChzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVt LAogCXJldHVybiBpOTE1X3NnX2Zyb21fbW1fbm9kZShub2RlLCBtZW0tPnJlZ2lvbi5zdGFydCk7 CiB9CiAKKyNpZmRlZiBDT05GSUdfRFJNX0k5MTVfU0VMRlRFU1QKIC8qKgogICogaW50ZWxfcmVn aW9uX3R0bV9ub2RlX2FsbG9jIC0gQWxsb2NhdGUgbWVtb3J5IHJlc291cmNlcyBmcm9tIGEgcmVn aW9uCiAgKiBAbWVtOiBUaGUgbWVtb3J5IHJlZ2lvbiwKQEAgLTI0NCwzICsyNDQsNCBAQCB2b2lk ICppbnRlbF9yZWdpb25fdHRtX25vZGVfYWxsb2Moc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24g Km1lbSwKIAkJcmV0ID0gLUVOWElPOwogCXJldHVybiByZXQgPyBFUlJfUFRSKHJldCkgOiByZXMu bW1fbm9kZTsKIH0KKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfcmVnaW9uX3R0bS5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5o CmluZGV4IDQwMTI5ZjdlMDMxNy4uOWE1YjA0MzdkNzNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9yZWdpb25fdHRtLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfcmVnaW9uX3R0bS5oCkBAIC0yMSw5ICsyMSwxMiBAQCB2b2lkIGludGVsX3JlZ2lvbl90 dG1fZmluaShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtKTsKIHN0cnVjdCBzZ190YWJs ZSAqaW50ZWxfcmVnaW9uX3R0bV9ub2RlX3RvX3N0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9u ICptZW0sCiAJCQkJCSAgICAgdm9pZCAqbm9kZSk7CiAKK3ZvaWQgaW50ZWxfcmVnaW9uX3R0bV9u b2RlX2ZyZWUoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKKwkJCQl2b2lkICpub2Rl KTsKKworI2lmZGVmIENPTkZJR19EUk1fSTkxNV9TRUxGVEVTVAogdm9pZCAqaW50ZWxfcmVnaW9u X3R0bV9ub2RlX2FsbG9jKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCQkJICBy ZXNvdXJjZV9zaXplX3Qgc2l6ZSwKIAkJCQkgIHVuc2lnbmVkIGludCBmbGFncyk7Ci12b2lkIGlu dGVsX3JlZ2lvbl90dG1fbm9kZV9mcmVlKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0s Ci0JCQkJdm9pZCAqbm9kZSk7CisjZW5kaWYKICNlbmRpZiAvKiBfSU5URUxfUkVHSU9OX1RUTV9I XyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm8uYyBiL2RyaXZlcnMv Z3B1L2RybS90dG0vdHRtX2JvLmMKaW5kZXggNDQ3OWM1NWFhYTFkLi43NDAwNGQ1Y2JmYTIgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX2JvLmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL3R0bS90dG1fYm8uYwpAQCAtMTE1MCw2ICsxMTUwLDE0IEBAIGludCB0dG1fYm9fc3dhcG91 dChzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLCBzdHJ1Y3QgdHRtX29wZXJhdGlvbl9jdHgg KmN0eCwKIAkJcmV0dXJuIC1FQlVTWTsKIAl9CiAKKwlpZiAoYm8tPmJkZXYtPmZ1bmNzLT5zd2Fw X3Bvc3NpYmxlKSB7CisJCWlmICghYm8tPmJkZXYtPmZ1bmNzLT5zd2FwX3Bvc3NpYmxlKGJvKSkg eworCQkJaWYgKGxvY2tlZCkKKwkJCQlkbWFfcmVzdl91bmxvY2soYm8tPmJhc2UucmVzdik7CisJ CQlyZXR1cm4gLUVCVVNZOworCQl9CisJfQorCiAJaWYgKGJvLT5kZWxldGVkKSB7CiAJCXR0bV9i b19jbGVhbnVwX3JlZnMoYm8sIGZhbHNlLCBmYWxzZSwgbG9ja2VkKTsKIAkJdHRtX2JvX3B1dChi byk7CkBAIC0xMjAwLDYgKzEyMDgsMTAgQEAgaW50IHR0bV9ib19zd2Fwb3V0KHN0cnVjdCB0dG1f YnVmZmVyX29iamVjdCAqYm8sIHN0cnVjdCB0dG1fb3BlcmF0aW9uX2N0eCAqY3R4LAogCWlmIChi by0+YmRldi0+ZnVuY3MtPnN3YXBfbm90aWZ5KQogCQliby0+YmRldi0+ZnVuY3MtPnN3YXBfbm90 aWZ5KGJvKTsKIAorCS8qIFRoZSBjYWxsIHRvIHN3YXBfbm90aWZ5IG1heSBoYXZlIHB1cmdlZCB0 aGUgYm8gKi8KKwlpZiAoIWJvLT50dG0pCisJCWdvdG8gb3V0OworCiAJcmV0ID0gdHRtX3R0X3N3 YXBvdXQoYm8tPmJkZXYsIGJvLT50dG0sIGdmcF9mbGFncyk7CiBvdXQ6CiAKZGlmZiAtLWdpdCBh L2luY2x1ZGUvZHJtL3R0bS90dG1fZGV2aWNlLmggYi9pbmNsdWRlL2RybS90dG0vdHRtX2Rldmlj ZS5oCmluZGV4IDdjOGY4N2JkNTJkMy4uN2M1OWQzNWU5MGY5IDEwMDY0NAotLS0gYS9pbmNsdWRl L2RybS90dG0vdHRtX2RldmljZS5oCisrKyBiL2luY2x1ZGUvZHJtL3R0bS90dG1fZGV2aWNlLmgK QEAgLTE4MSw2ICsxODEsMTUgQEAgc3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgewogCSAqLwogCXZv aWQgKCpkZWxldGVfbWVtX25vdGlmeSkoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyk7CiAK KwkvKioKKwkgKiBzdHJ1Y3QgdHRtX2JvX2RyaXZlciBtZW1iZXIgc3dhcF9wb3NzaWJsZQorCSAq CisJICogQGJvOiB0aGUgYnVmZmVyIG9iamVjdCB0byBiZSBldmljdGVkCisJICoKKwkgKiBDaGVj ayB3aXRoIHRoZSBkcml2ZXIgaWYgaXQgaXMgcG9zc2libGUgdG8gc3dhcCBvdXQgYSBCTy4KKwkg Ki8KKwlib29sICgqc3dhcF9wb3NzaWJsZSkoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyk7 CisKIAkvKioKIAkgKiBub3RpZnkgdGhlIGRyaXZlciB0aGF0IHdlJ3JlIGFib3V0IHRvIHN3YXAg b3V0IHRoaXMgYm8KIAkgKi8KLS0gCjIuMzAuMgoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vaW50ZWwtZ2Z4Cg==