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 315A7C47083 for ; Mon, 31 May 2021 17:23: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 F1E1C61186 for ; Mon, 31 May 2021 17:23:23 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F1E1C61186 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 51DDD6E96B; Mon, 31 May 2021 17:23:08 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id C78626E97F; Mon, 31 May 2021 17:23:04 +0000 (UTC) IronPort-SDR: /owQB58AkF9h2IxUptI8lqnkW9MHGyR/XGU+mLWgdx3YpuDeU6THIBPXAHUE8J0IQqO2NQrhIE NHB+q4xOHXAg== X-IronPort-AV: E=McAfee;i="6200,9189,10001"; a="201520260" X-IronPort-AV: E=Sophos;i="5.83,237,1616482800"; d="scan'208";a="201520260" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 31 May 2021 10:23:04 -0700 IronPort-SDR: VN3NU4oxt1eFkkRxDjytVJfYbUszdL0EBNyunIuZEZoB3sMSatOeYMBVtNBe3cOSEFK9X7rrh9 Xrifyc8BXhJA== X-IronPort-AV: E=Sophos;i="5.83,237,1616482800"; d="scan'208";a="416211062" Received: from fnygreen-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.142]) by orsmga002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 31 May 2021 10:23:03 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v8 15/15] drm/i915: Use ttm mmap handling for ttm bo's. Date: Mon, 31 May 2021 19:22:28 +0200 Message-Id: <20210531172228.70846-16-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210531172228.70846-1-thomas.hellstrom@linux.intel.com> References: <20210531172228.70846-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?= Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Maarten Lankhorst Use the ttm handlers for servicing page faults, and vm_access. We do our own validation of read-only access, otherwise use the ttm handlers as much as possible. Because the ttm handlers expect the vma_node at vma->base, we slightly need to massage the mmap handlers to look at vma_node->driver_private to fetch the bo, if it's NULL, we assume i915's normal mmap_offset uapi is used. This is the easiest way to achieve compatibility without changing ttm's semantics. Signed-off-by: Maarten Lankhorst Reviewed-by: Thomas Hellström --- - Fixed some minor style issues. (Thomas Hellström) - Added a mutex Destroy (Thomas Hellström) --- drivers/gpu/drm/i915/gem/i915_gem_mman.c | 83 ++++++++---- drivers/gpu/drm/i915/gem/i915_gem_object.h | 6 +- .../gpu/drm/i915/gem/i915_gem_object_types.h | 3 + drivers/gpu/drm/i915/gem/i915_gem_pages.c | 3 +- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 121 +++++++++++++++++- .../drm/i915/gem/selftests/i915_gem_mman.c | 90 ++++++------- drivers/gpu/drm/i915/selftests/igt_mmap.c | 25 +++- drivers/gpu/drm/i915/selftests/igt_mmap.h | 12 +- 8 files changed, 251 insertions(+), 92 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_mman.c b/drivers/gpu/drm/i915/gem/i915_gem_mman.c index fd1c9714f8d8..d1de97e4adfd 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_mman.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_mman.c @@ -19,6 +19,7 @@ #include "i915_gem_mman.h" #include "i915_trace.h" #include "i915_user_extensions.h" +#include "i915_gem_ttm.h" #include "i915_vma.h" static inline bool @@ -622,6 +623,8 @@ mmap_offset_attach(struct drm_i915_gem_object *obj, struct i915_mmap_offset *mmo; int err; + GEM_BUG_ON(obj->ops->mmap_offset || obj->ops->mmap_ops); + mmo = lookup_mmo(obj, mmap_type); if (mmo) goto out; @@ -664,40 +667,47 @@ mmap_offset_attach(struct drm_i915_gem_object *obj, } static int -__assign_mmap_offset(struct drm_file *file, - u32 handle, +__assign_mmap_offset(struct drm_i915_gem_object *obj, enum i915_mmap_type mmap_type, - u64 *offset) + u64 *offset, struct drm_file *file) { - struct drm_i915_gem_object *obj; struct i915_mmap_offset *mmo; - int err; - obj = i915_gem_object_lookup(file, handle); - if (!obj) - return -ENOENT; + if (i915_gem_object_never_mmap(obj)) + return -ENODEV; - if (i915_gem_object_never_mmap(obj)) { - err = -ENODEV; - goto out; + if (obj->ops->mmap_offset) { + *offset = obj->ops->mmap_offset(obj); + return 0; } if (mmap_type != I915_MMAP_TYPE_GTT && !i915_gem_object_has_struct_page(obj) && - !i915_gem_object_type_has(obj, I915_GEM_OBJECT_HAS_IOMEM)) { - err = -ENODEV; - goto out; - } + !i915_gem_object_type_has(obj, I915_GEM_OBJECT_HAS_IOMEM)) + return -ENODEV; mmo = mmap_offset_attach(obj, mmap_type, file); - if (IS_ERR(mmo)) { - err = PTR_ERR(mmo); - goto out; - } + if (IS_ERR(mmo)) + return PTR_ERR(mmo); *offset = drm_vma_node_offset_addr(&mmo->vma_node); - err = 0; -out: + return 0; +} + +static int +__assign_mmap_offset_handle(struct drm_file *file, + u32 handle, + enum i915_mmap_type mmap_type, + u64 *offset) +{ + struct drm_i915_gem_object *obj; + int err; + + obj = i915_gem_object_lookup(file, handle); + if (!obj) + return -ENOENT; + + err = __assign_mmap_offset(obj, mmap_type, offset, file); i915_gem_object_put(obj); return err; } @@ -717,7 +727,7 @@ i915_gem_dumb_mmap_offset(struct drm_file *file, else mmap_type = I915_MMAP_TYPE_GTT; - return __assign_mmap_offset(file, handle, mmap_type, offset); + return __assign_mmap_offset_handle(file, handle, mmap_type, offset); } /** @@ -785,7 +795,7 @@ i915_gem_mmap_offset_ioctl(struct drm_device *dev, void *data, return -EINVAL; } - return __assign_mmap_offset(file, args->handle, type, &args->offset); + return __assign_mmap_offset_handle(file, args->handle, type, &args->offset); } static void vm_open(struct vm_area_struct *vma) @@ -889,8 +899,18 @@ int i915_gem_mmap(struct file *filp, struct vm_area_struct *vma) * destroyed and will be invalid when the vma manager lock * is released. */ - mmo = container_of(node, struct i915_mmap_offset, vma_node); - obj = i915_gem_object_get_rcu(mmo->obj); + if (!node->driver_private) { + mmo = container_of(node, struct i915_mmap_offset, vma_node); + obj = i915_gem_object_get_rcu(mmo->obj); + + GEM_BUG_ON(obj && obj->ops->mmap_ops); + } else { + obj = i915_gem_object_get_rcu + (container_of(node, struct drm_i915_gem_object, + base.vma_node)); + + GEM_BUG_ON(obj && !obj->ops->mmap_ops); + } } drm_vma_offset_unlock_lookup(dev->vma_offset_manager); rcu_read_unlock(); @@ -912,7 +932,9 @@ int i915_gem_mmap(struct file *filp, struct vm_area_struct *vma) } vma->vm_flags |= VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP; - vma->vm_private_data = mmo; + + if (i915_gem_object_has_iomem(obj)) + vma->vm_flags |= VM_IO; /* * We keep the ref on mmo->obj, not vm_file, but we require @@ -926,6 +948,15 @@ int i915_gem_mmap(struct file *filp, struct vm_area_struct *vma) /* Drop the initial creation reference, the vma is now holding one. */ fput(anon); + if (obj->ops->mmap_ops) { + vma->vm_page_prot = pgprot_decrypted(vm_get_page_prot(vma->vm_flags)); + vma->vm_ops = obj->ops->mmap_ops; + vma->vm_private_data = node->driver_private; + return 0; + } + + vma->vm_private_data = mmo; + switch (mmo->mmap_type) { case I915_MMAP_TYPE_WC: vma->vm_page_prot = diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.h b/drivers/gpu/drm/i915/gem/i915_gem_object.h index a3ad8cf4eefd..ff59e6c640e6 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.h @@ -342,14 +342,14 @@ struct scatterlist * __i915_gem_object_get_sg(struct drm_i915_gem_object *obj, struct i915_gem_object_page_iter *iter, unsigned int n, - unsigned int *offset, bool allow_alloc); + unsigned int *offset, bool allow_alloc, bool dma); static inline struct scatterlist * i915_gem_object_get_sg(struct drm_i915_gem_object *obj, unsigned int n, unsigned int *offset, bool allow_alloc) { - return __i915_gem_object_get_sg(obj, &obj->mm.get_page, n, offset, allow_alloc); + return __i915_gem_object_get_sg(obj, &obj->mm.get_page, n, offset, allow_alloc, false); } static inline struct scatterlist * @@ -357,7 +357,7 @@ i915_gem_object_get_sg_dma(struct drm_i915_gem_object *obj, unsigned int n, unsigned int *offset, bool allow_alloc) { - return __i915_gem_object_get_sg(obj, &obj->mm.get_dma_page, n, offset, allow_alloc); + return __i915_gem_object_get_sg(obj, &obj->mm.get_dma_page, n, offset, allow_alloc, true); } struct page * 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 68313474e6a6..2a23b77424b3 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h @@ -61,6 +61,7 @@ struct drm_i915_gem_object_ops { const struct drm_i915_gem_pread *arg); int (*pwrite)(struct drm_i915_gem_object *obj, const struct drm_i915_gem_pwrite *arg); + u64 (*mmap_offset)(struct drm_i915_gem_object *obj); int (*dmabuf_export)(struct drm_i915_gem_object *obj); @@ -79,6 +80,7 @@ struct drm_i915_gem_object_ops { void (*delayed_free)(struct drm_i915_gem_object *obj); void (*release)(struct drm_i915_gem_object *obj); + const struct vm_operations_struct *mmap_ops; const char *name; /* friendly name for debug, e.g. lockdep classes */ }; @@ -328,6 +330,7 @@ struct drm_i915_gem_object { struct { struct sg_table *cached_io_st; + struct i915_gem_object_page_iter get_io_page; bool created:1; } ttm; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_pages.c b/drivers/gpu/drm/i915/gem/i915_gem_pages.c index 6444e097016d..086005c1c7ea 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_pages.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_pages.c @@ -467,9 +467,8 @@ __i915_gem_object_get_sg(struct drm_i915_gem_object *obj, struct i915_gem_object_page_iter *iter, unsigned int n, unsigned int *offset, - bool allow_alloc) + bool allow_alloc, bool dma) { - const bool dma = iter == &obj->mm.get_dma_page; struct scatterlist *sg; unsigned int idx, count; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c index fbb32b148be3..3748098b42d5 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -13,6 +13,7 @@ #include "gem/i915_gem_object.h" #include "gem/i915_gem_region.h" #include "gem/i915_gem_ttm.h" +#include "gem/i915_gem_mman.h" #define I915_PL_LMEM0 TTM_PL_PRIV #define I915_PL_SYSTEM TTM_PL_SYSTEM @@ -158,11 +159,20 @@ static int i915_ttm_move_notify(struct ttm_buffer_object *bo) 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; - } + struct radix_tree_iter iter; + void __rcu **slot; + + if (!obj->ttm.cached_io_st) + return; + + rcu_read_lock(); + radix_tree_for_each_slot(slot, &obj->ttm.get_io_page.radix, &iter, 0) + radix_tree_delete(&obj->ttm.get_io_page.radix, iter.index); + rcu_read_unlock(); + + 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) @@ -338,12 +348,41 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, ttm_bo_move_sync_cleanup(bo, dst_mem); i915_ttm_free_cached_io_st(obj); - if (!dst_man->use_tt) + if (!dst_man->use_tt) { obj->ttm.cached_io_st = dst_st; + obj->ttm.get_io_page.sg_pos = dst_st->sgl; + obj->ttm.get_io_page.sg_idx = 0; + } return 0; } +static int i915_ttm_io_mem_reserve(struct ttm_device *bdev, struct ttm_resource *mem) +{ + if (mem->mem_type < I915_PL_LMEM0) + return 0; + + mem->bus.caching = ttm_write_combined; + mem->bus.is_iomem = true; + + return 0; +} + +static unsigned long i915_ttm_io_mem_pfn(struct ttm_buffer_object *bo, + unsigned long page_offset) +{ + struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); + unsigned long base = obj->mm.region->iomap.base - obj->mm.region->region.start; + struct scatterlist *sg; + unsigned int ofs; + + GEM_WARN_ON(bo->ttm); + + sg = __i915_gem_object_get_sg(obj, &obj->ttm.get_io_page, page_offset, &ofs, true, true); + + return ((base + sg_dma_address(sg)) >> PAGE_SHIFT) + ofs; +} + static struct ttm_device_funcs i915_ttm_bo_driver = { .ttm_tt_create = i915_ttm_tt_create, .ttm_tt_unpopulate = i915_ttm_tt_unpopulate, @@ -353,6 +392,8 @@ static struct ttm_device_funcs i915_ttm_bo_driver = { .move = i915_ttm_move, .swap_notify = i915_ttm_swap_notify, .delete_mem_notify = i915_ttm_delete_mem_notify, + .io_mem_reserve = i915_ttm_io_mem_reserve, + .io_mem_pfn = i915_ttm_io_mem_pfn, }; /** @@ -460,7 +501,67 @@ static void i915_ttm_delayed_free(struct drm_i915_gem_object *obj) } } -static const struct drm_i915_gem_object_ops i915_gem_ttm_obj_ops = { +static vm_fault_t vm_fault_ttm(struct vm_fault *vmf) +{ + struct vm_area_struct *area = vmf->vma; + struct drm_i915_gem_object *obj = + i915_ttm_to_gem(area->vm_private_data); + + /* Sanity check that we allow writing into this object */ + if (unlikely(i915_gem_object_is_readonly(obj) && + area->vm_flags & VM_WRITE)) + return VM_FAULT_SIGBUS; + + return ttm_bo_vm_fault(vmf); +} + +static int +vm_access_ttm(struct vm_area_struct *area, unsigned long addr, + void *buf, int len, int write) +{ + struct drm_i915_gem_object *obj = + i915_ttm_to_gem(area->vm_private_data); + + if (i915_gem_object_is_readonly(obj) && write) + return -EACCES; + + return ttm_bo_vm_access(area, addr, buf, len, write); +} + +static void ttm_vm_open(struct vm_area_struct *vma) +{ + struct drm_i915_gem_object *obj = + i915_ttm_to_gem(vma->vm_private_data); + + GEM_BUG_ON(!obj); + i915_gem_object_get(obj); +} + +static void ttm_vm_close(struct vm_area_struct *vma) +{ + struct drm_i915_gem_object *obj = + i915_ttm_to_gem(vma->vm_private_data); + + GEM_BUG_ON(!obj); + i915_gem_object_put(obj); +} + +static const struct vm_operations_struct vm_ops_ttm = { + .fault = vm_fault_ttm, + .access = vm_access_ttm, + .open = ttm_vm_open, + .close = ttm_vm_close, +}; + +static u64 i915_ttm_mmap_offset(struct drm_i915_gem_object *obj) +{ + /* The ttm_bo must be allocated with I915_BO_ALLOC_USER */ + GEM_BUG_ON(!drm_mm_node_allocated(&obj->base.vma_node.vm_node)); + + return drm_vma_node_offset_addr(&obj->base.vma_node); +} + +const struct drm_i915_gem_object_ops i915_gem_ttm_obj_ops = { .name = "i915_gem_object_ttm", .flags = I915_GEM_OBJECT_HAS_IOMEM, @@ -469,6 +570,8 @@ static const struct drm_i915_gem_object_ops i915_gem_ttm_obj_ops = { .truncate = i915_ttm_purge, .adjust_lru = i915_ttm_adjust_lru, .delayed_free = i915_ttm_delayed_free, + .mmap_offset = i915_ttm_mmap_offset, + .mmap_ops = &vm_ops_ttm, }; void i915_ttm_bo_destroy(struct ttm_buffer_object *bo) @@ -476,6 +579,7 @@ 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); + mutex_destroy(&obj->ttm.get_io_page.lock); if (obj->ttm.created) call_rcu(&obj->rcu, __i915_gem_free_object_rcu); } @@ -517,6 +621,8 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *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); + INIT_RADIX_TREE(&obj->ttm.get_io_page.radix, GFP_KERNEL | __GFP_NOWARN); + mutex_init(&obj->ttm.get_io_page.lock); bo_type = (obj->flags & I915_BO_ALLOC_USER) ? ttm_bo_type_device : ttm_bo_type_kernel; @@ -528,6 +634,7 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, * Similarly, in delayed_destroy, we can't call ttm_bo_put() * until successful initialization. */ + obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, bo_type, &i915_sys_placement, alignment, true, NULL, NULL, i915_ttm_bo_destroy); diff --git a/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c b/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c index 05a3b29f545e..ca69a29b7f2a 100644 --- a/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c +++ b/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c @@ -578,16 +578,17 @@ static bool assert_mmap_offset(struct drm_i915_private *i915, int expected) { struct drm_i915_gem_object *obj; - struct i915_mmap_offset *mmo; + u64 offset; + int ret; obj = i915_gem_object_create_internal(i915, size); if (IS_ERR(obj)) - return false; + return expected && expected == PTR_ERR(obj); - mmo = mmap_offset_attach(obj, I915_MMAP_OFFSET_GTT, NULL); + ret = __assign_mmap_offset(obj, I915_MMAP_TYPE_GTT, &offset, NULL); i915_gem_object_put(obj); - return PTR_ERR_OR_ZERO(mmo) == expected; + return ret == expected; } static void disable_retire_worker(struct drm_i915_private *i915) @@ -622,8 +623,8 @@ static int igt_mmap_offset_exhaustion(void *arg) struct drm_mm *mm = &i915->drm.vma_offset_manager->vm_addr_space_mm; struct drm_i915_gem_object *obj; struct drm_mm_node *hole, *next; - struct i915_mmap_offset *mmo; int loop, err = 0; + u64 offset; /* Disable background reaper */ disable_retire_worker(i915); @@ -684,13 +685,13 @@ static int igt_mmap_offset_exhaustion(void *arg) obj = i915_gem_object_create_internal(i915, PAGE_SIZE); if (IS_ERR(obj)) { err = PTR_ERR(obj); + pr_err("Unable to create object for reclaimed hole\n"); goto out; } - mmo = mmap_offset_attach(obj, I915_MMAP_OFFSET_GTT, NULL); - if (IS_ERR(mmo)) { + err = __assign_mmap_offset(obj, I915_MMAP_TYPE_GTT, &offset, NULL); + if (err) { pr_err("Unable to insert object into reclaimed hole\n"); - err = PTR_ERR(mmo); goto err_obj; } @@ -865,10 +866,10 @@ static int __igt_mmap(struct drm_i915_private *i915, struct drm_i915_gem_object *obj, enum i915_mmap_type type) { - struct i915_mmap_offset *mmo; struct vm_area_struct *area; unsigned long addr; int err, i; + u64 offset; if (!can_mmap(obj, type)) return 0; @@ -879,11 +880,11 @@ static int __igt_mmap(struct drm_i915_private *i915, if (err) return err; - mmo = mmap_offset_attach(obj, type, NULL); - if (IS_ERR(mmo)) - return PTR_ERR(mmo); + err = __assign_mmap_offset(obj, type, &offset, NULL); + if (err) + return err; - addr = igt_mmap_node(i915, &mmo->vma_node, 0, PROT_WRITE, MAP_SHARED); + addr = igt_mmap_offset(i915, offset, obj->base.size, PROT_WRITE, MAP_SHARED); if (IS_ERR_VALUE(addr)) return addr; @@ -897,13 +898,6 @@ static int __igt_mmap(struct drm_i915_private *i915, goto out_unmap; } - if (area->vm_private_data != mmo) { - pr_err("%s: vm_area_struct did not point back to our mmap_offset object!\n", - obj->mm.region->name); - err = -EINVAL; - goto out_unmap; - } - for (i = 0; i < obj->base.size / sizeof(u32); i++) { u32 __user *ux = u64_to_user_ptr((u64)(addr + i * sizeof(*ux))); u32 x; @@ -961,7 +955,7 @@ static int igt_mmap(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, sizes[i], 0); + obj = i915_gem_object_create_region(mr, sizes[i], I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; @@ -1004,12 +998,12 @@ static int __igt_mmap_access(struct drm_i915_private *i915, struct drm_i915_gem_object *obj, enum i915_mmap_type type) { - struct i915_mmap_offset *mmo; unsigned long __user *ptr; unsigned long A, B; unsigned long x, y; unsigned long addr; int err; + u64 offset; memset(&A, 0xAA, sizeof(A)); memset(&B, 0xBB, sizeof(B)); @@ -1017,11 +1011,11 @@ static int __igt_mmap_access(struct drm_i915_private *i915, if (!can_mmap(obj, type) || !can_access(obj)) return 0; - mmo = mmap_offset_attach(obj, type, NULL); - if (IS_ERR(mmo)) - return PTR_ERR(mmo); + err = __assign_mmap_offset(obj, type, &offset, NULL); + if (err) + return err; - addr = igt_mmap_node(i915, &mmo->vma_node, 0, PROT_WRITE, MAP_SHARED); + addr = igt_mmap_offset(i915, offset, obj->base.size, PROT_WRITE, MAP_SHARED); if (IS_ERR_VALUE(addr)) return addr; ptr = (unsigned long __user *)addr; @@ -1081,7 +1075,7 @@ static int igt_mmap_access(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, PAGE_SIZE, 0); + obj = i915_gem_object_create_region(mr, PAGE_SIZE, I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; @@ -1111,11 +1105,11 @@ static int __igt_mmap_gpu(struct drm_i915_private *i915, enum i915_mmap_type type) { struct intel_engine_cs *engine; - struct i915_mmap_offset *mmo; unsigned long addr; u32 __user *ux; u32 bbe; int err; + u64 offset; /* * Verify that the mmap access into the backing store aligns with @@ -1132,11 +1126,11 @@ static int __igt_mmap_gpu(struct drm_i915_private *i915, if (err) return err; - mmo = mmap_offset_attach(obj, type, NULL); - if (IS_ERR(mmo)) - return PTR_ERR(mmo); + err = __assign_mmap_offset(obj, type, &offset, NULL); + if (err) + return err; - addr = igt_mmap_node(i915, &mmo->vma_node, 0, PROT_WRITE, MAP_SHARED); + addr = igt_mmap_offset(i915, offset, obj->base.size, PROT_WRITE, MAP_SHARED); if (IS_ERR_VALUE(addr)) return addr; @@ -1226,7 +1220,7 @@ static int igt_mmap_gpu(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, PAGE_SIZE, 0); + obj = i915_gem_object_create_region(mr, PAGE_SIZE, I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; @@ -1303,18 +1297,18 @@ static int __igt_mmap_revoke(struct drm_i915_private *i915, struct drm_i915_gem_object *obj, enum i915_mmap_type type) { - struct i915_mmap_offset *mmo; unsigned long addr; int err; + u64 offset; if (!can_mmap(obj, type)) return 0; - mmo = mmap_offset_attach(obj, type, NULL); - if (IS_ERR(mmo)) - return PTR_ERR(mmo); + err = __assign_mmap_offset(obj, type, &offset, NULL); + if (err) + return err; - addr = igt_mmap_node(i915, &mmo->vma_node, 0, PROT_WRITE, MAP_SHARED); + addr = igt_mmap_offset(i915, offset, obj->base.size, PROT_WRITE, MAP_SHARED); if (IS_ERR_VALUE(addr)) return addr; @@ -1350,10 +1344,20 @@ static int __igt_mmap_revoke(struct drm_i915_private *i915, } } - err = check_absent(addr, obj->base.size); - if (err) { - pr_err("%s: was not absent\n", obj->mm.region->name); - goto out_unmap; + if (!obj->ops->mmap_ops) { + err = check_absent(addr, obj->base.size); + if (err) { + pr_err("%s: was not absent\n", obj->mm.region->name); + goto out_unmap; + } + } else { + /* ttm allows access to evicted regions by design */ + + err = check_present(addr, obj->base.size); + if (err) { + pr_err("%s: was not present\n", obj->mm.region->name); + goto out_unmap; + } } out_unmap: @@ -1371,7 +1375,7 @@ static int igt_mmap_revoke(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, PAGE_SIZE, 0); + obj = i915_gem_object_create_region(mr, PAGE_SIZE, I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; diff --git a/drivers/gpu/drm/i915/selftests/igt_mmap.c b/drivers/gpu/drm/i915/selftests/igt_mmap.c index 583a4ff8b8c9..e920a461bd36 100644 --- a/drivers/gpu/drm/i915/selftests/igt_mmap.c +++ b/drivers/gpu/drm/i915/selftests/igt_mmap.c @@ -9,15 +9,28 @@ #include "i915_drv.h" #include "igt_mmap.h" -unsigned long igt_mmap_node(struct drm_i915_private *i915, - struct drm_vma_offset_node *node, - unsigned long addr, - unsigned long prot, - unsigned long flags) +unsigned long igt_mmap_offset(struct drm_i915_private *i915, + u64 offset, + unsigned long size, + unsigned long prot, + unsigned long flags) { + struct drm_vma_offset_node *node; struct file *file; + unsigned long addr; int err; + /* no need to refcount, we own this object */ + drm_vma_offset_lock_lookup(i915->drm.vma_offset_manager); + node = drm_vma_offset_exact_lookup_locked(i915->drm.vma_offset_manager, + offset / PAGE_SIZE, size / PAGE_SIZE); + drm_vma_offset_unlock_lookup(i915->drm.vma_offset_manager); + + if (GEM_WARN_ON(!node)) { + pr_info("Failed to lookup %llx\n", offset); + return -ENOENT; + } + /* Pretend to open("/dev/dri/card0") */ file = mock_drm_getfile(i915->drm.primary, O_RDWR); if (IS_ERR(file)) @@ -29,7 +42,7 @@ unsigned long igt_mmap_node(struct drm_i915_private *i915, goto out_file; } - addr = vm_mmap(file, addr, drm_vma_node_size(node) << PAGE_SHIFT, + addr = vm_mmap(file, 0, drm_vma_node_size(node) << PAGE_SHIFT, prot, flags, drm_vma_node_offset_addr(node)); drm_vma_node_revoke(node, file->private_data); diff --git a/drivers/gpu/drm/i915/selftests/igt_mmap.h b/drivers/gpu/drm/i915/selftests/igt_mmap.h index 6e716cb59d7e..acbe34d81a6d 100644 --- a/drivers/gpu/drm/i915/selftests/igt_mmap.h +++ b/drivers/gpu/drm/i915/selftests/igt_mmap.h @@ -7,13 +7,15 @@ #ifndef IGT_MMAP_H #define IGT_MMAP_H +#include + struct drm_i915_private; struct drm_vma_offset_node; -unsigned long igt_mmap_node(struct drm_i915_private *i915, - struct drm_vma_offset_node *node, - unsigned long addr, - unsigned long prot, - unsigned long flags); +unsigned long igt_mmap_offset(struct drm_i915_private *i915, + u64 offset, + unsigned long size, + unsigned long prot, + unsigned long flags); #endif /* IGT_MMAP_H */ -- 2.31.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 8959FC47082 for ; Mon, 31 May 2021 17:23:21 +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 59175610A8 for ; Mon, 31 May 2021 17:23:21 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 59175610A8 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 043CF6E982; Mon, 31 May 2021 17:23:07 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id C78626E97F; Mon, 31 May 2021 17:23:04 +0000 (UTC) IronPort-SDR: /owQB58AkF9h2IxUptI8lqnkW9MHGyR/XGU+mLWgdx3YpuDeU6THIBPXAHUE8J0IQqO2NQrhIE NHB+q4xOHXAg== X-IronPort-AV: E=McAfee;i="6200,9189,10001"; a="201520260" X-IronPort-AV: E=Sophos;i="5.83,237,1616482800"; d="scan'208";a="201520260" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 31 May 2021 10:23:04 -0700 IronPort-SDR: VN3NU4oxt1eFkkRxDjytVJfYbUszdL0EBNyunIuZEZoB3sMSatOeYMBVtNBe3cOSEFK9X7rrh9 Xrifyc8BXhJA== X-IronPort-AV: E=Sophos;i="5.83,237,1616482800"; d="scan'208";a="416211062" Received: from fnygreen-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.142]) by orsmga002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 31 May 2021 10:23:03 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Mon, 31 May 2021 19:22:28 +0200 Message-Id: <20210531172228.70846-16-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210531172228.70846-1-thomas.hellstrom@linux.intel.com> References: <20210531172228.70846-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v8 15/15] drm/i915: Use ttm mmap handling for ttm bo's. 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?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogTWFhcnRlbiBMYW5raG9yc3QgPG1hYXJ0ZW4ubGFua2hvcnN0QGxpbnV4LmludGVsLmNv bT4KClVzZSB0aGUgdHRtIGhhbmRsZXJzIGZvciBzZXJ2aWNpbmcgcGFnZSBmYXVsdHMsIGFuZCB2 bV9hY2Nlc3MuCgpXZSBkbyBvdXIgb3duIHZhbGlkYXRpb24gb2YgcmVhZC1vbmx5IGFjY2Vzcywg b3RoZXJ3aXNlIHVzZSB0aGUKdHRtIGhhbmRsZXJzIGFzIG11Y2ggYXMgcG9zc2libGUuCgpCZWNh dXNlIHRoZSB0dG0gaGFuZGxlcnMgZXhwZWN0IHRoZSB2bWFfbm9kZSBhdCB2bWEtPmJhc2UsIHdl IHNsaWdodGx5Cm5lZWQgdG8gbWFzc2FnZSB0aGUgbW1hcCBoYW5kbGVycyB0byBsb29rIGF0IHZt YV9ub2RlLT5kcml2ZXJfcHJpdmF0ZQp0byBmZXRjaCB0aGUgYm8sIGlmIGl0J3MgTlVMTCwgd2Ug YXNzdW1lIGk5MTUncyBub3JtYWwgbW1hcF9vZmZzZXQgdWFwaQppcyB1c2VkLgoKVGhpcyBpcyB0 aGUgZWFzaWVzdCB3YXkgdG8gYWNoaWV2ZSBjb21wYXRpYmlsaXR5IHdpdGhvdXQgY2hhbmdpbmcg dHRtJ3MKc2VtYW50aWNzLgoKU2lnbmVkLW9mZi1ieTogTWFhcnRlbiBMYW5raG9yc3QgPG1hYXJ0 ZW4ubGFua2hvcnN0QGxpbnV4LmludGVsLmNvbT4KUmV2aWV3ZWQtYnk6IFRob21hcyBIZWxsc3Ry w7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNvbT4KLS0tCi0gRml4ZWQgc29tZSBt aW5vciBzdHlsZSBpc3N1ZXMuIChUaG9tYXMgSGVsbHN0csO2bSkKLSBBZGRlZCBhIG11dGV4IERl c3Ryb3kgKFRob21hcyBIZWxsc3Ryw7ZtKQotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV9tbWFuLmMgICAgICB8ICA4MyArKysrKysrKy0tLS0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaCAgICB8ICAgNiArLQogLi4uL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmggIHwgICAzICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9pOTE1X2dlbV9wYWdlcy5jICAgICB8ICAgMyArLQogZHJpdmVycy9ncHUvZHJtL2k5MTUv Z2VtL2k5MTVfZ2VtX3R0bS5jICAgICAgIHwgMTIxICsrKysrKysrKysrKysrKysrLQogLi4uL2Ry bS9pOTE1L2dlbS9zZWxmdGVzdHMvaTkxNV9nZW1fbW1hbi5jICAgIHwgIDkwICsrKysrKy0tLS0t LS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfbW1hcC5jICAgICB8ICAyNSAr KystCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaWd0X21tYXAuaCAgICAgfCAgMTIg Ky0KIDggZmlsZXMgY2hhbmdlZCwgMjUxIGluc2VydGlvbnMoKyksIDkyIGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9tbWFuLmMgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fbW1hbi5jCmluZGV4IGZkMWM5NzE0Zjhk OC4uZDFkZTk3ZTRhZGZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkx NV9nZW1fbW1hbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9tbWFu LmMKQEAgLTE5LDYgKzE5LDcgQEAKICNpbmNsdWRlICJpOTE1X2dlbV9tbWFuLmgiCiAjaW5jbHVk ZSAiaTkxNV90cmFjZS5oIgogI2luY2x1ZGUgImk5MTVfdXNlcl9leHRlbnNpb25zLmgiCisjaW5j bHVkZSAiaTkxNV9nZW1fdHRtLmgiCiAjaW5jbHVkZSAiaTkxNV92bWEuaCIKIAogc3RhdGljIGlu bGluZSBib29sCkBAIC02MjIsNiArNjIzLDggQEAgbW1hcF9vZmZzZXRfYXR0YWNoKHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCiAJc3RydWN0IGk5MTVfbW1hcF9vZmZzZXQgKm1tbzsK IAlpbnQgZXJyOwogCisJR0VNX0JVR19PTihvYmotPm9wcy0+bW1hcF9vZmZzZXQgfHwgb2JqLT5v cHMtPm1tYXBfb3BzKTsKKwogCW1tbyA9IGxvb2t1cF9tbW8ob2JqLCBtbWFwX3R5cGUpOwogCWlm IChtbW8pCiAJCWdvdG8gb3V0OwpAQCAtNjY0LDQwICs2NjcsNDcgQEAgbW1hcF9vZmZzZXRfYXR0 YWNoKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCiB9CiAKIHN0YXRpYyBpbnQKLV9f YXNzaWduX21tYXBfb2Zmc2V0KHN0cnVjdCBkcm1fZmlsZSAqZmlsZSwKLQkJICAgICB1MzIgaGFu ZGxlLAorX19hc3NpZ25fbW1hcF9vZmZzZXQoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9i aiwKIAkJICAgICBlbnVtIGk5MTVfbW1hcF90eXBlIG1tYXBfdHlwZSwKLQkJICAgICB1NjQgKm9m ZnNldCkKKwkJICAgICB1NjQgKm9mZnNldCwgc3RydWN0IGRybV9maWxlICpmaWxlKQogewotCXN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7CiAJc3RydWN0IGk5MTVfbW1hcF9vZmZzZXQg Km1tbzsKLQlpbnQgZXJyOwogCi0Jb2JqID0gaTkxNV9nZW1fb2JqZWN0X2xvb2t1cChmaWxlLCBo YW5kbGUpOwotCWlmICghb2JqKQotCQlyZXR1cm4gLUVOT0VOVDsKKwlpZiAoaTkxNV9nZW1fb2Jq ZWN0X25ldmVyX21tYXAob2JqKSkKKwkJcmV0dXJuIC1FTk9ERVY7CiAKLQlpZiAoaTkxNV9nZW1f b2JqZWN0X25ldmVyX21tYXAob2JqKSkgewotCQllcnIgPSAtRU5PREVWOwotCQlnb3RvIG91dDsK KwlpZiAob2JqLT5vcHMtPm1tYXBfb2Zmc2V0KSAgeworCQkqb2Zmc2V0ID0gb2JqLT5vcHMtPm1t YXBfb2Zmc2V0KG9iaik7CisJCXJldHVybiAwOwogCX0KIAogCWlmIChtbWFwX3R5cGUgIT0gSTkx NV9NTUFQX1RZUEVfR1RUICYmCiAJICAgICFpOTE1X2dlbV9vYmplY3RfaGFzX3N0cnVjdF9wYWdl KG9iaikgJiYKLQkgICAgIWk5MTVfZ2VtX29iamVjdF90eXBlX2hhcyhvYmosIEk5MTVfR0VNX09C SkVDVF9IQVNfSU9NRU0pKSB7Ci0JCWVyciA9IC1FTk9ERVY7Ci0JCWdvdG8gb3V0OwotCX0KKwkg ICAgIWk5MTVfZ2VtX29iamVjdF90eXBlX2hhcyhvYmosIEk5MTVfR0VNX09CSkVDVF9IQVNfSU9N RU0pKQorCQlyZXR1cm4gLUVOT0RFVjsKIAogCW1tbyA9IG1tYXBfb2Zmc2V0X2F0dGFjaChvYmos IG1tYXBfdHlwZSwgZmlsZSk7Ci0JaWYgKElTX0VSUihtbW8pKSB7Ci0JCWVyciA9IFBUUl9FUlIo bW1vKTsKLQkJZ290byBvdXQ7Ci0JfQorCWlmIChJU19FUlIobW1vKSkKKwkJcmV0dXJuIFBUUl9F UlIobW1vKTsKIAogCSpvZmZzZXQgPSBkcm1fdm1hX25vZGVfb2Zmc2V0X2FkZHIoJm1tby0+dm1h X25vZGUpOwotCWVyciA9IDA7Ci1vdXQ6CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK19f YXNzaWduX21tYXBfb2Zmc2V0X2hhbmRsZShzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGUsCisJCQkgICAg dTMyIGhhbmRsZSwKKwkJCSAgICBlbnVtIGk5MTVfbW1hcF90eXBlIG1tYXBfdHlwZSwKKwkJCSAg ICB1NjQgKm9mZnNldCkKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqOworCWlu dCBlcnI7CisKKwlvYmogPSBpOTE1X2dlbV9vYmplY3RfbG9va3VwKGZpbGUsIGhhbmRsZSk7CisJ aWYgKCFvYmopCisJCXJldHVybiAtRU5PRU5UOworCisJZXJyID0gX19hc3NpZ25fbW1hcF9vZmZz ZXQob2JqLCBtbWFwX3R5cGUsIG9mZnNldCwgZmlsZSk7CiAJaTkxNV9nZW1fb2JqZWN0X3B1dChv YmopOwogCXJldHVybiBlcnI7CiB9CkBAIC03MTcsNyArNzI3LDcgQEAgaTkxNV9nZW1fZHVtYl9t bWFwX29mZnNldChzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGUsCiAJZWxzZQogCQltbWFwX3R5cGUgPSBJ OTE1X01NQVBfVFlQRV9HVFQ7CiAKLQlyZXR1cm4gX19hc3NpZ25fbW1hcF9vZmZzZXQoZmlsZSwg aGFuZGxlLCBtbWFwX3R5cGUsIG9mZnNldCk7CisJcmV0dXJuIF9fYXNzaWduX21tYXBfb2Zmc2V0 X2hhbmRsZShmaWxlLCBoYW5kbGUsIG1tYXBfdHlwZSwgb2Zmc2V0KTsKIH0KIAogLyoqCkBAIC03 ODUsNyArNzk1LDcgQEAgaTkxNV9nZW1fbW1hcF9vZmZzZXRfaW9jdGwoc3RydWN0IGRybV9kZXZp Y2UgKmRldiwgdm9pZCAqZGF0YSwKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCi0JcmV0dXJuIF9f YXNzaWduX21tYXBfb2Zmc2V0KGZpbGUsIGFyZ3MtPmhhbmRsZSwgdHlwZSwgJmFyZ3MtPm9mZnNl dCk7CisJcmV0dXJuIF9fYXNzaWduX21tYXBfb2Zmc2V0X2hhbmRsZShmaWxlLCBhcmdzLT5oYW5k bGUsIHR5cGUsICZhcmdzLT5vZmZzZXQpOwogfQogCiBzdGF0aWMgdm9pZCB2bV9vcGVuKHN0cnVj dCB2bV9hcmVhX3N0cnVjdCAqdm1hKQpAQCAtODg5LDggKzg5OSwxOCBAQCBpbnQgaTkxNV9nZW1f bW1hcChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiAJCSAq IGRlc3Ryb3llZCBhbmQgd2lsbCBiZSBpbnZhbGlkIHdoZW4gdGhlIHZtYSBtYW5hZ2VyIGxvY2sK IAkJICogaXMgcmVsZWFzZWQuCiAJCSAqLwotCQltbW8gPSBjb250YWluZXJfb2Yobm9kZSwgc3Ry dWN0IGk5MTVfbW1hcF9vZmZzZXQsIHZtYV9ub2RlKTsKLQkJb2JqID0gaTkxNV9nZW1fb2JqZWN0 X2dldF9yY3UobW1vLT5vYmopOworCQlpZiAoIW5vZGUtPmRyaXZlcl9wcml2YXRlKSB7CisJCQlt bW8gPSBjb250YWluZXJfb2Yobm9kZSwgc3RydWN0IGk5MTVfbW1hcF9vZmZzZXQsIHZtYV9ub2Rl KTsKKwkJCW9iaiA9IGk5MTVfZ2VtX29iamVjdF9nZXRfcmN1KG1tby0+b2JqKTsKKworCQkJR0VN X0JVR19PTihvYmogJiYgb2JqLT5vcHMtPm1tYXBfb3BzKTsKKwkJfSBlbHNlIHsKKwkJCW9iaiA9 IGk5MTVfZ2VtX29iamVjdF9nZXRfcmN1CisJCQkJKGNvbnRhaW5lcl9vZihub2RlLCBzdHJ1Y3Qg ZHJtX2k5MTVfZ2VtX29iamVjdCwKKwkJCQkJICAgICAgYmFzZS52bWFfbm9kZSkpOworCisJCQlH RU1fQlVHX09OKG9iaiAmJiAhb2JqLT5vcHMtPm1tYXBfb3BzKTsKKwkJfQogCX0KIAlkcm1fdm1h X29mZnNldF91bmxvY2tfbG9va3VwKGRldi0+dm1hX29mZnNldF9tYW5hZ2VyKTsKIAlyY3VfcmVh ZF91bmxvY2soKTsKQEAgLTkxMiw3ICs5MzIsOSBAQCBpbnQgaTkxNV9nZW1fbW1hcChzdHJ1Y3Qg ZmlsZSAqZmlscCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiAJfQogCiAJdm1hLT52bV9m bGFncyB8PSBWTV9QRk5NQVAgfCBWTV9ET05URVhQQU5EIHwgVk1fRE9OVERVTVA7Ci0Jdm1hLT52 bV9wcml2YXRlX2RhdGEgPSBtbW87CisKKwlpZiAoaTkxNV9nZW1fb2JqZWN0X2hhc19pb21lbShv YmopKQorCQl2bWEtPnZtX2ZsYWdzIHw9IFZNX0lPOwogCiAJLyoKIAkgKiBXZSBrZWVwIHRoZSBy ZWYgb24gbW1vLT5vYmosIG5vdCB2bV9maWxlLCBidXQgd2UgcmVxdWlyZQpAQCAtOTI2LDYgKzk0 OCwxNSBAQCBpbnQgaTkxNV9nZW1fbW1hcChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IHZtX2Fy ZWFfc3RydWN0ICp2bWEpCiAJLyogRHJvcCB0aGUgaW5pdGlhbCBjcmVhdGlvbiByZWZlcmVuY2Us IHRoZSB2bWEgaXMgbm93IGhvbGRpbmcgb25lLiAqLwogCWZwdXQoYW5vbik7CiAKKwlpZiAob2Jq LT5vcHMtPm1tYXBfb3BzKSB7CisJCXZtYS0+dm1fcGFnZV9wcm90ID0gcGdwcm90X2RlY3J5cHRl ZCh2bV9nZXRfcGFnZV9wcm90KHZtYS0+dm1fZmxhZ3MpKTsKKwkJdm1hLT52bV9vcHMgPSBvYmot Pm9wcy0+bW1hcF9vcHM7CisJCXZtYS0+dm1fcHJpdmF0ZV9kYXRhID0gbm9kZS0+ZHJpdmVyX3By aXZhdGU7CisJCXJldHVybiAwOworCX0KKworCXZtYS0+dm1fcHJpdmF0ZV9kYXRhID0gbW1vOwor CiAJc3dpdGNoIChtbW8tPm1tYXBfdHlwZSkgewogCWNhc2UgSTkxNV9NTUFQX1RZUEVfV0M6CiAJ CXZtYS0+dm1fcGFnZV9wcm90ID0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dl bS9pOTE1X2dlbV9vYmplY3QuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9v YmplY3QuaAppbmRleCBhM2FkOGNmNGVlZmQuLmZmNTllNmM2NDBlNiAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5oCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuaApAQCAtMzQyLDE0ICszNDIsMTQgQEAgc3Ry dWN0IHNjYXR0ZXJsaXN0ICoKIF9faTkxNV9nZW1fb2JqZWN0X2dldF9zZyhzdHJ1Y3QgZHJtX2k5 MTVfZ2VtX29iamVjdCAqb2JqLAogCQkJIHN0cnVjdCBpOTE1X2dlbV9vYmplY3RfcGFnZV9pdGVy ICppdGVyLAogCQkJIHVuc2lnbmVkIGludCBuLAotCQkJIHVuc2lnbmVkIGludCAqb2Zmc2V0LCBi b29sIGFsbG93X2FsbG9jKTsKKwkJCSB1bnNpZ25lZCBpbnQgKm9mZnNldCwgYm9vbCBhbGxvd19h bGxvYywgYm9vbCBkbWEpOwogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBzY2F0dGVybGlzdCAqCiBp OTE1X2dlbV9vYmplY3RfZ2V0X3NnKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCiAJ CSAgICAgICB1bnNpZ25lZCBpbnQgbiwKIAkJICAgICAgIHVuc2lnbmVkIGludCAqb2Zmc2V0LCBi b29sIGFsbG93X2FsbG9jKQogewotCXJldHVybiBfX2k5MTVfZ2VtX29iamVjdF9nZXRfc2cob2Jq LCAmb2JqLT5tbS5nZXRfcGFnZSwgbiwgb2Zmc2V0LCBhbGxvd19hbGxvYyk7CisJcmV0dXJuIF9f aTkxNV9nZW1fb2JqZWN0X2dldF9zZyhvYmosICZvYmotPm1tLmdldF9wYWdlLCBuLCBvZmZzZXQs IGFsbG93X2FsbG9jLCBmYWxzZSk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgc3RydWN0IHNjYXR0ZXJs aXN0ICoKQEAgLTM1Nyw3ICszNTcsNyBAQCBpOTE1X2dlbV9vYmplY3RfZ2V0X3NnX2RtYShzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCQkJICAgdW5zaWduZWQgaW50IG4sCiAJCQkg ICB1bnNpZ25lZCBpbnQgKm9mZnNldCwgYm9vbCBhbGxvd19hbGxvYykKIHsKLQlyZXR1cm4gX19p OTE1X2dlbV9vYmplY3RfZ2V0X3NnKG9iaiwgJm9iai0+bW0uZ2V0X2RtYV9wYWdlLCBuLCBvZmZz ZXQsIGFsbG93X2FsbG9jKTsKKwlyZXR1cm4gX19pOTE1X2dlbV9vYmplY3RfZ2V0X3NnKG9iaiwg Jm9iai0+bW0uZ2V0X2RtYV9wYWdlLCBuLCBvZmZzZXQsIGFsbG93X2FsbG9jLCB0cnVlKTsKIH0K IAogc3RydWN0IHBhZ2UgKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX29iamVjdF90eXBlcy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2Vt X29iamVjdF90eXBlcy5oCmluZGV4IDY4MzEzNDc0ZTZhNi4uMmEyM2I3NzQyNGIzIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmgKKysr IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oCkBAIC02 MSw2ICs2MSw3IEBAIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0X29wcyB7CiAJCSAgICAgY29u c3Qgc3RydWN0IGRybV9pOTE1X2dlbV9wcmVhZCAqYXJnKTsKIAlpbnQgKCpwd3JpdGUpKHN0cnVj dCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCiAJCSAgICAgIGNvbnN0IHN0cnVjdCBkcm1faTkx NV9nZW1fcHdyaXRlICphcmcpOworCXU2NCAoKm1tYXBfb2Zmc2V0KShzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqKTsKIAogCWludCAoKmRtYWJ1Zl9leHBvcnQpKHN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmopOwogCkBAIC03OSw2ICs4MCw3IEBAIHN0cnVjdCBkcm1faTkxNV9n ZW1fb2JqZWN0X29wcyB7CiAJdm9pZCAoKmRlbGF5ZWRfZnJlZSkoc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaik7CiAJdm9pZCAoKnJlbGVhc2UpKHN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0ICpvYmopOwogCisJY29uc3Qgc3RydWN0IHZtX29wZXJhdGlvbnNfc3RydWN0ICptbWFwX29w czsKIAljb25zdCBjaGFyICpuYW1lOyAvKiBmcmllbmRseSBuYW1lIGZvciBkZWJ1ZywgZS5nLiBs b2NrZGVwIGNsYXNzZXMgKi8KIH07CiAKQEAgLTMyOCw2ICszMzAsNyBAQCBzdHJ1Y3QgZHJtX2k5 MTVfZ2VtX29iamVjdCB7CiAKIAlzdHJ1Y3QgewogCQlzdHJ1Y3Qgc2dfdGFibGUgKmNhY2hlZF9p b19zdDsKKwkJc3RydWN0IGk5MTVfZ2VtX29iamVjdF9wYWdlX2l0ZXIgZ2V0X2lvX3BhZ2U7CiAJ CWJvb2wgY3JlYXRlZDoxOwogCX0gdHRtOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fcGFnZXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV9wYWdlcy5jCmluZGV4IDY0NDRlMDk3MDE2ZC4uMDg2MDA1YzFjN2VhIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcGFnZXMuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcGFnZXMuYwpAQCAtNDY3LDkgKzQ2Nyw4IEBAIF9f aTkxNV9nZW1fb2JqZWN0X2dldF9zZyhzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAog CQkJIHN0cnVjdCBpOTE1X2dlbV9vYmplY3RfcGFnZV9pdGVyICppdGVyLAogCQkJIHVuc2lnbmVk IGludCBuLAogCQkJIHVuc2lnbmVkIGludCAqb2Zmc2V0LAotCQkJIGJvb2wgYWxsb3dfYWxsb2Mp CisJCQkgYm9vbCBhbGxvd19hbGxvYywgYm9vbCBkbWEpCiB7Ci0JY29uc3QgYm9vbCBkbWEgPSBp dGVyID09ICZvYmotPm1tLmdldF9kbWFfcGFnZTsKIAlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOwog CXVuc2lnbmVkIGludCBpZHgsIGNvdW50OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9n ZW1fdHRtLmMKaW5kZXggZmJiMzJiMTQ4YmUzLi4zNzQ4MDk4YjQyZDUgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYworKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlICJn ZW0vaTkxNV9nZW1fb2JqZWN0LmgiCiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIgog I2luY2x1ZGUgImdlbS9pOTE1X2dlbV90dG0uaCIKKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1fbW1h bi5oIgogCiAjZGVmaW5lIEk5MTVfUExfTE1FTTAgVFRNX1BMX1BSSVYKICNkZWZpbmUgSTkxNV9Q TF9TWVNURU0gVFRNX1BMX1NZU1RFTQpAQCAtMTU4LDExICsxNTksMjAgQEAgc3RhdGljIGludCBp OTE1X3R0bV9tb3ZlX25vdGlmeShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvKQogCiBzdGF0 aWMgdm9pZCBpOTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29i amVjdCAqb2JqKQogewotCWlmIChvYmotPnR0bS5jYWNoZWRfaW9fc3QpIHsKLQkJc2dfZnJlZV90 YWJsZShvYmotPnR0bS5jYWNoZWRfaW9fc3QpOwotCQlrZnJlZShvYmotPnR0bS5jYWNoZWRfaW9f c3QpOwotCQlvYmotPnR0bS5jYWNoZWRfaW9fc3QgPSBOVUxMOwotCX0KKwlzdHJ1Y3QgcmFkaXhf dHJlZV9pdGVyIGl0ZXI7CisJdm9pZCBfX3JjdSAqKnNsb3Q7CisKKwlpZiAoIW9iai0+dHRtLmNh Y2hlZF9pb19zdCkKKwkJcmV0dXJuOworCisJcmN1X3JlYWRfbG9jaygpOworCXJhZGl4X3RyZWVf Zm9yX2VhY2hfc2xvdChzbG90LCAmb2JqLT50dG0uZ2V0X2lvX3BhZ2UucmFkaXgsICZpdGVyLCAw KQorCQlyYWRpeF90cmVlX2RlbGV0ZSgmb2JqLT50dG0uZ2V0X2lvX3BhZ2UucmFkaXgsIGl0ZXIu aW5kZXgpOworCXJjdV9yZWFkX3VubG9jaygpOworCisJc2dfZnJlZV90YWJsZShvYmotPnR0bS5j YWNoZWRfaW9fc3QpOworCWtmcmVlKG9iai0+dHRtLmNhY2hlZF9pb19zdCk7CisJb2JqLT50dG0u Y2FjaGVkX2lvX3N0ID0gTlVMTDsKIH0KIAogc3RhdGljIHZvaWQgaTkxNV90dG1fcHVyZ2Uoc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKQEAgLTMzOCwxMiArMzQ4LDQxIEBAIHN0YXRp YyBpbnQgaTkxNV90dG1fbW92ZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLCBib29sIGV2 aWN0LAogCXR0bV9ib19tb3ZlX3N5bmNfY2xlYW51cChibywgZHN0X21lbSk7CiAJaTkxNV90dG1f ZnJlZV9jYWNoZWRfaW9fc3Qob2JqKTsKIAotCWlmICghZHN0X21hbi0+dXNlX3R0KQorCWlmICgh ZHN0X21hbi0+dXNlX3R0KSB7CiAJCW9iai0+dHRtLmNhY2hlZF9pb19zdCA9IGRzdF9zdDsKKwkJ b2JqLT50dG0uZ2V0X2lvX3BhZ2Uuc2dfcG9zID0gZHN0X3N0LT5zZ2w7CisJCW9iai0+dHRtLmdl dF9pb19wYWdlLnNnX2lkeCA9IDA7CisJfQogCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBpbnQg aTkxNV90dG1faW9fbWVtX3Jlc2VydmUoc3RydWN0IHR0bV9kZXZpY2UgKmJkZXYsIHN0cnVjdCB0 dG1fcmVzb3VyY2UgKm1lbSkKK3sKKwlpZiAobWVtLT5tZW1fdHlwZSA8IEk5MTVfUExfTE1FTTAp CisJCXJldHVybiAwOworCisJbWVtLT5idXMuY2FjaGluZyA9IHR0bV93cml0ZV9jb21iaW5lZDsK KwltZW0tPmJ1cy5pc19pb21lbSA9IHRydWU7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHVu c2lnbmVkIGxvbmcgaTkxNV90dG1faW9fbWVtX3BmbihzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3Qg KmJvLAorCQkJCQkgdW5zaWduZWQgbG9uZyBwYWdlX29mZnNldCkKK3sKKwlzdHJ1Y3QgZHJtX2k5 MTVfZ2VtX29iamVjdCAqb2JqID0gaTkxNV90dG1fdG9fZ2VtKGJvKTsKKwl1bnNpZ25lZCBsb25n IGJhc2UgPSBvYmotPm1tLnJlZ2lvbi0+aW9tYXAuYmFzZSAtIG9iai0+bW0ucmVnaW9uLT5yZWdp b24uc3RhcnQ7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwl1bnNpZ25lZCBpbnQgb2ZzOwor CisJR0VNX1dBUk5fT04oYm8tPnR0bSk7CisKKwlzZyA9IF9faTkxNV9nZW1fb2JqZWN0X2dldF9z ZyhvYmosICZvYmotPnR0bS5nZXRfaW9fcGFnZSwgcGFnZV9vZmZzZXQsICZvZnMsIHRydWUsIHRy dWUpOworCisJcmV0dXJuICgoYmFzZSArIHNnX2RtYV9hZGRyZXNzKHNnKSkgPj4gUEFHRV9TSElG VCkgKyBvZnM7Cit9CisKIHN0YXRpYyBzdHJ1Y3QgdHRtX2RldmljZV9mdW5jcyBpOTE1X3R0bV9i b19kcml2ZXIgPSB7CiAJLnR0bV90dF9jcmVhdGUgPSBpOTE1X3R0bV90dF9jcmVhdGUsCiAJLnR0 bV90dF91bnBvcHVsYXRlID0gaTkxNV90dG1fdHRfdW5wb3B1bGF0ZSwKQEAgLTM1Myw2ICszOTIs OCBAQCBzdGF0aWMgc3RydWN0IHR0bV9kZXZpY2VfZnVuY3MgaTkxNV90dG1fYm9fZHJpdmVyID0g ewogCS5tb3ZlID0gaTkxNV90dG1fbW92ZSwKIAkuc3dhcF9ub3RpZnkgPSBpOTE1X3R0bV9zd2Fw X25vdGlmeSwKIAkuZGVsZXRlX21lbV9ub3RpZnkgPSBpOTE1X3R0bV9kZWxldGVfbWVtX25vdGlm eSwKKwkuaW9fbWVtX3Jlc2VydmUgPSBpOTE1X3R0bV9pb19tZW1fcmVzZXJ2ZSwKKwkuaW9fbWVt X3BmbiA9IGk5MTVfdHRtX2lvX21lbV9wZm4sCiB9OwogCiAvKioKQEAgLTQ2MCw3ICs1MDEsNjcg QEAgc3RhdGljIHZvaWQgaTkxNV90dG1fZGVsYXllZF9mcmVlKHN0cnVjdCBkcm1faTkxNV9nZW1f b2JqZWN0ICpvYmopCiAJfQogfQogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3Rfb3BzIGk5MTVfZ2VtX3R0bV9vYmpfb3BzID0geworc3RhdGljIHZtX2ZhdWx0X3Qgdm1f ZmF1bHRfdHRtKHN0cnVjdCB2bV9mYXVsdCAqdm1mKQoreworCXN0cnVjdCB2bV9hcmVhX3N0cnVj dCAqYXJlYSA9IHZtZi0+dm1hOworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmogPQor CQlpOTE1X3R0bV90b19nZW0oYXJlYS0+dm1fcHJpdmF0ZV9kYXRhKTsKKworCS8qIFNhbml0eSBj aGVjayB0aGF0IHdlIGFsbG93IHdyaXRpbmcgaW50byB0aGlzIG9iamVjdCAqLworCWlmICh1bmxp a2VseShpOTE1X2dlbV9vYmplY3RfaXNfcmVhZG9ubHkob2JqKSAmJgorCQkgICAgIGFyZWEtPnZt X2ZsYWdzICYgVk1fV1JJVEUpKQorCQlyZXR1cm4gVk1fRkFVTFRfU0lHQlVTOworCisJcmV0dXJu IHR0bV9ib192bV9mYXVsdCh2bWYpOworfQorCitzdGF0aWMgaW50Cit2bV9hY2Nlc3NfdHRtKHN0 cnVjdCB2bV9hcmVhX3N0cnVjdCAqYXJlYSwgdW5zaWduZWQgbG9uZyBhZGRyLAorCSAgICAgIHZv aWQgKmJ1ZiwgaW50IGxlbiwgaW50IHdyaXRlKQoreworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0ICpvYmogPQorCQlpOTE1X3R0bV90b19nZW0oYXJlYS0+dm1fcHJpdmF0ZV9kYXRhKTsKKwor CWlmIChpOTE1X2dlbV9vYmplY3RfaXNfcmVhZG9ubHkob2JqKSAmJiB3cml0ZSkKKwkJcmV0dXJu IC1FQUNDRVM7CisKKwlyZXR1cm4gdHRtX2JvX3ZtX2FjY2VzcyhhcmVhLCBhZGRyLCBidWYsIGxl biwgd3JpdGUpOworfQorCitzdGF0aWMgdm9pZCB0dG1fdm1fb3BlbihzdHJ1Y3Qgdm1fYXJlYV9z dHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqID0KKwkJaTkx NV90dG1fdG9fZ2VtKHZtYS0+dm1fcHJpdmF0ZV9kYXRhKTsKKworCUdFTV9CVUdfT04oIW9iaik7 CisJaTkxNV9nZW1fb2JqZWN0X2dldChvYmopOworfQorCitzdGF0aWMgdm9pZCB0dG1fdm1fY2xv c2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKm9iaiA9CisJCWk5MTVfdHRtX3RvX2dlbSh2bWEtPnZtX3ByaXZhdGVfZGF0YSk7CisK KwlHRU1fQlVHX09OKCFvYmopOworCWk5MTVfZ2VtX29iamVjdF9wdXQob2JqKTsKK30KKworc3Rh dGljIGNvbnN0IHN0cnVjdCB2bV9vcGVyYXRpb25zX3N0cnVjdCB2bV9vcHNfdHRtID0geworCS5m YXVsdCA9IHZtX2ZhdWx0X3R0bSwKKwkuYWNjZXNzID0gdm1fYWNjZXNzX3R0bSwKKwkub3BlbiA9 IHR0bV92bV9vcGVuLAorCS5jbG9zZSA9IHR0bV92bV9jbG9zZSwKK307CisKK3N0YXRpYyB1NjQg aTkxNV90dG1fbW1hcF9vZmZzZXQoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sK KwkvKiBUaGUgdHRtX2JvIG11c3QgYmUgYWxsb2NhdGVkIHdpdGggSTkxNV9CT19BTExPQ19VU0VS ICovCisJR0VNX0JVR19PTighZHJtX21tX25vZGVfYWxsb2NhdGVkKCZvYmotPmJhc2Uudm1hX25v ZGUudm1fbm9kZSkpOworCisJcmV0dXJuIGRybV92bWFfbm9kZV9vZmZzZXRfYWRkcigmb2JqLT5i YXNlLnZtYV9ub2RlKTsKK30KKworY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3Bz IGk5MTVfZ2VtX3R0bV9vYmpfb3BzID0gewogCS5uYW1lID0gImk5MTVfZ2VtX29iamVjdF90dG0i LAogCS5mbGFncyA9IEk5MTVfR0VNX09CSkVDVF9IQVNfSU9NRU0sCiAKQEAgLTQ2OSw2ICs1NzAs OCBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIGk5MTVfZ2Vt X3R0bV9vYmpfb3BzID0gewogCS50cnVuY2F0ZSA9IGk5MTVfdHRtX3B1cmdlLAogCS5hZGp1c3Rf bHJ1ID0gaTkxNV90dG1fYWRqdXN0X2xydSwKIAkuZGVsYXllZF9mcmVlID0gaTkxNV90dG1fZGVs YXllZF9mcmVlLAorCS5tbWFwX29mZnNldCA9IGk5MTVfdHRtX21tYXBfb2Zmc2V0LAorCS5tbWFw X29wcyA9ICZ2bV9vcHNfdHRtLAogfTsKIAogdm9pZCBpOTE1X3R0bV9ib19kZXN0cm95KHN0cnVj dCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCkBAIC00NzYsNiArNTc5LDcgQEAgdm9pZCBpOTE1X3R0 bV9ib19kZXN0cm95KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCiAJc3RydWN0IGRybV9p OTE1X2dlbV9vYmplY3QgKm9iaiA9IGk5MTVfdHRtX3RvX2dlbShibyk7CiAKIAlpOTE1X2dlbV9v YmplY3RfcmVsZWFzZV9tZW1vcnlfcmVnaW9uKG9iaik7CisJbXV0ZXhfZGVzdHJveSgmb2JqLT50 dG0uZ2V0X2lvX3BhZ2UubG9jayk7CiAJaWYgKG9iai0+dHRtLmNyZWF0ZWQpCiAJCWNhbGxfcmN1 KCZvYmotPnJjdSwgX19pOTE1X2dlbV9mcmVlX29iamVjdF9yY3UpOwogfQpAQCAtNTE3LDYgKzYy MSw4IEBAIGludCBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxfbWVtb3J5 X3JlZ2lvbiAqbWVtLAogCWk5MTVfZ2VtX29iamVjdF9tYWtlX3Vuc2hyaW5rYWJsZShvYmopOwog CW9iai0+cmVhZF9kb21haW5zID0gSTkxNV9HRU1fRE9NQUlOX1dDIHwgSTkxNV9HRU1fRE9NQUlO X0dUVDsKIAlpOTE1X2dlbV9vYmplY3Rfc2V0X2NhY2hlX2NvaGVyZW5jeShvYmosIEk5MTVfQ0FD SEVfTk9ORSk7CisJSU5JVF9SQURJWF9UUkVFKCZvYmotPnR0bS5nZXRfaW9fcGFnZS5yYWRpeCwg R0ZQX0tFUk5FTCB8IF9fR0ZQX05PV0FSTik7CisJbXV0ZXhfaW5pdCgmb2JqLT50dG0uZ2V0X2lv X3BhZ2UubG9jayk7CiAKIAlib190eXBlID0gKG9iai0+ZmxhZ3MgJiBJOTE1X0JPX0FMTE9DX1VT RVIpID8gdHRtX2JvX3R5cGVfZGV2aWNlIDoKIAkJdHRtX2JvX3R5cGVfa2VybmVsOwpAQCAtNTI4 LDYgKzYzNCw3IEBAIGludCBfX2k5MTVfZ2VtX3R0bV9vYmplY3RfaW5pdChzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiAqbWVtLAogCSAqIFNpbWlsYXJseSwgaW4gZGVsYXllZF9kZXN0cm95LCB3 ZSBjYW4ndCBjYWxsIHR0bV9ib19wdXQoKQogCSAqIHVudGlsIHN1Y2Nlc3NmdWwgaW5pdGlhbGl6 YXRpb24uCiAJICovCisJb2JqLT5iYXNlLnZtYV9ub2RlLmRyaXZlcl9wcml2YXRlID0gaTkxNV9n ZW1fdG9fdHRtKG9iaik7CiAJcmV0ID0gdHRtX2JvX2luaXQoJmk5MTUtPmJkZXYsIGk5MTVfZ2Vt X3RvX3R0bShvYmopLCBzaXplLAogCQkJICBib190eXBlLCAmaTkxNV9zeXNfcGxhY2VtZW50LCBh bGlnbm1lbnQsCiAJCQkgIHRydWUsIE5VTEwsIE5VTEwsIGk5MTVfdHRtX2JvX2Rlc3Ryb3kpOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL3NlbGZ0ZXN0cy9pOTE1X2dlbV9t bWFuLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vc2VsZnRlc3RzL2k5MTVfZ2VtX21tYW4u YwppbmRleCAwNWEzYjI5ZjU0NWUuLmNhNjlhMjliN2YyYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL3NlbGZ0ZXN0cy9pOTE1X2dlbV9tbWFuLmMKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL3NlbGZ0ZXN0cy9pOTE1X2dlbV9tbWFuLmMKQEAgLTU3OCwxNiArNTc4 LDE3IEBAIHN0YXRpYyBib29sIGFzc2VydF9tbWFwX29mZnNldChzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqaTkxNSwKIAkJCSAgICAgICBpbnQgZXhwZWN0ZWQpCiB7CiAJc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iajsKLQlzdHJ1Y3QgaTkxNV9tbWFwX29mZnNldCAqbW1vOworCXU2NCBv ZmZzZXQ7CisJaW50IHJldDsKIAogCW9iaiA9IGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfaW50ZXJu YWwoaTkxNSwgc2l6ZSk7CiAJaWYgKElTX0VSUihvYmopKQotCQlyZXR1cm4gZmFsc2U7CisJCXJl dHVybiBleHBlY3RlZCAmJiBleHBlY3RlZCA9PSBQVFJfRVJSKG9iaik7CiAKLQltbW8gPSBtbWFw X29mZnNldF9hdHRhY2gob2JqLCBJOTE1X01NQVBfT0ZGU0VUX0dUVCwgTlVMTCk7CisJcmV0ID0g X19hc3NpZ25fbW1hcF9vZmZzZXQob2JqLCBJOTE1X01NQVBfVFlQRV9HVFQsICZvZmZzZXQsIE5V TEwpOwogCWk5MTVfZ2VtX29iamVjdF9wdXQob2JqKTsKIAotCXJldHVybiBQVFJfRVJSX09SX1pF Uk8obW1vKSA9PSBleHBlY3RlZDsKKwlyZXR1cm4gcmV0ID09IGV4cGVjdGVkOwogfQogCiBzdGF0 aWMgdm9pZCBkaXNhYmxlX3JldGlyZV93b3JrZXIoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5 MTUpCkBAIC02MjIsOCArNjIzLDggQEAgc3RhdGljIGludCBpZ3RfbW1hcF9vZmZzZXRfZXhoYXVz dGlvbih2b2lkICphcmcpCiAJc3RydWN0IGRybV9tbSAqbW0gPSAmaTkxNS0+ZHJtLnZtYV9vZmZz ZXRfbWFuYWdlci0+dm1fYWRkcl9zcGFjZV9tbTsKIAlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqb2JqOwogCXN0cnVjdCBkcm1fbW1fbm9kZSAqaG9sZSwgKm5leHQ7Ci0Jc3RydWN0IGk5MTVf bW1hcF9vZmZzZXQgKm1tbzsKIAlpbnQgbG9vcCwgZXJyID0gMDsKKwl1NjQgb2Zmc2V0OwogCiAJ LyogRGlzYWJsZSBiYWNrZ3JvdW5kIHJlYXBlciAqLwogCWRpc2FibGVfcmV0aXJlX3dvcmtlcihp OTE1KTsKQEAgLTY4NCwxMyArNjg1LDEzIEBAIHN0YXRpYyBpbnQgaWd0X21tYXBfb2Zmc2V0X2V4 aGF1c3Rpb24odm9pZCAqYXJnKQogCW9iaiA9IGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfaW50ZXJu YWwoaTkxNSwgUEFHRV9TSVpFKTsKIAlpZiAoSVNfRVJSKG9iaikpIHsKIAkJZXJyID0gUFRSX0VS UihvYmopOworCQlwcl9lcnIoIlVuYWJsZSB0byBjcmVhdGUgb2JqZWN0IGZvciByZWNsYWltZWQg aG9sZVxuIik7CiAJCWdvdG8gb3V0OwogCX0KIAotCW1tbyA9IG1tYXBfb2Zmc2V0X2F0dGFjaChv YmosIEk5MTVfTU1BUF9PRkZTRVRfR1RULCBOVUxMKTsKLQlpZiAoSVNfRVJSKG1tbykpIHsKKwll cnIgPSBfX2Fzc2lnbl9tbWFwX29mZnNldChvYmosIEk5MTVfTU1BUF9UWVBFX0dUVCwgJm9mZnNl dCwgTlVMTCk7CisJaWYgKGVycikgewogCQlwcl9lcnIoIlVuYWJsZSB0byBpbnNlcnQgb2JqZWN0 IGludG8gcmVjbGFpbWVkIGhvbGVcbiIpOwotCQllcnIgPSBQVFJfRVJSKG1tbyk7CiAJCWdvdG8g ZXJyX29iajsKIAl9CiAKQEAgLTg2NSwxMCArODY2LDEwIEBAIHN0YXRpYyBpbnQgX19pZ3RfbW1h cChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAkJICAgICAgc3RydWN0IGRybV9pOTE1 X2dlbV9vYmplY3QgKm9iaiwKIAkJICAgICAgZW51bSBpOTE1X21tYXBfdHlwZSB0eXBlKQogewot CXN0cnVjdCBpOTE1X21tYXBfb2Zmc2V0ICptbW87CiAJc3RydWN0IHZtX2FyZWFfc3RydWN0ICph cmVhOwogCXVuc2lnbmVkIGxvbmcgYWRkcjsKIAlpbnQgZXJyLCBpOworCXU2NCBvZmZzZXQ7CiAK IAlpZiAoIWNhbl9tbWFwKG9iaiwgdHlwZSkpCiAJCXJldHVybiAwOwpAQCAtODc5LDExICs4ODAs MTEgQEAgc3RhdGljIGludCBfX2lndF9tbWFwKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1 LAogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQltbW8gPSBtbWFwX29mZnNldF9hdHRhY2go b2JqLCB0eXBlLCBOVUxMKTsKLQlpZiAoSVNfRVJSKG1tbykpCi0JCXJldHVybiBQVFJfRVJSKG1t byk7CisJZXJyID0gX19hc3NpZ25fbW1hcF9vZmZzZXQob2JqLCB0eXBlLCAmb2Zmc2V0LCBOVUxM KTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOwogCi0JYWRkciA9IGlndF9tbWFwX25vZGUoaTkx NSwgJm1tby0+dm1hX25vZGUsIDAsIFBST1RfV1JJVEUsIE1BUF9TSEFSRUQpOworCWFkZHIgPSBp Z3RfbW1hcF9vZmZzZXQoaTkxNSwgb2Zmc2V0LCBvYmotPmJhc2Uuc2l6ZSwgUFJPVF9XUklURSwg TUFQX1NIQVJFRCk7CiAJaWYgKElTX0VSUl9WQUxVRShhZGRyKSkKIAkJcmV0dXJuIGFkZHI7CiAK QEAgLTg5NywxMyArODk4LDYgQEAgc3RhdGljIGludCBfX2lndF9tbWFwKHN0cnVjdCBkcm1faTkx NV9wcml2YXRlICppOTE1LAogCQlnb3RvIG91dF91bm1hcDsKIAl9CiAKLQlpZiAoYXJlYS0+dm1f cHJpdmF0ZV9kYXRhICE9IG1tbykgewotCQlwcl9lcnIoIiVzOiB2bV9hcmVhX3N0cnVjdCBkaWQg bm90IHBvaW50IGJhY2sgdG8gb3VyIG1tYXBfb2Zmc2V0IG9iamVjdCFcbiIsCi0JCSAgICAgICBv YmotPm1tLnJlZ2lvbi0+bmFtZSk7Ci0JCWVyciA9IC1FSU5WQUw7Ci0JCWdvdG8gb3V0X3VubWFw OwotCX0KLQogCWZvciAoaSA9IDA7IGkgPCBvYmotPmJhc2Uuc2l6ZSAvIHNpemVvZih1MzIpOyBp KyspIHsKIAkJdTMyIF9fdXNlciAqdXggPSB1NjRfdG9fdXNlcl9wdHIoKHU2NCkoYWRkciArIGkg KiBzaXplb2YoKnV4KSkpOwogCQl1MzIgeDsKQEAgLTk2MSw3ICs5NTUsNyBAQCBzdGF0aWMgaW50 IGlndF9tbWFwKHZvaWQgKmFyZykKIAkJCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7 CiAJCQlpbnQgZXJyOwogCi0JCQlvYmogPSBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX3JlZ2lvbiht ciwgc2l6ZXNbaV0sIDApOworCQkJb2JqID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24o bXIsIHNpemVzW2ldLCBJOTE1X0JPX0FMTE9DX1VTRVIpOwogCQkJaWYgKG9iaiA9PSBFUlJfUFRS KC1FTk9ERVYpKQogCQkJCWNvbnRpbnVlOwogCkBAIC0xMDA0LDEyICs5OTgsMTIgQEAgc3RhdGlj IGludCBfX2lndF9tbWFwX2FjY2VzcyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAkJ CSAgICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKIAkJCSAgICAgZW51bSBpOTE1 X21tYXBfdHlwZSB0eXBlKQogewotCXN0cnVjdCBpOTE1X21tYXBfb2Zmc2V0ICptbW87CiAJdW5z aWduZWQgbG9uZyBfX3VzZXIgKnB0cjsKIAl1bnNpZ25lZCBsb25nIEEsIEI7CiAJdW5zaWduZWQg bG9uZyB4LCB5OwogCXVuc2lnbmVkIGxvbmcgYWRkcjsKIAlpbnQgZXJyOworCXU2NCBvZmZzZXQ7 CiAKIAltZW1zZXQoJkEsIDB4QUEsIHNpemVvZihBKSk7CiAJbWVtc2V0KCZCLCAweEJCLCBzaXpl b2YoQikpOwpAQCAtMTAxNywxMSArMTAxMSwxMSBAQCBzdGF0aWMgaW50IF9faWd0X21tYXBfYWNj ZXNzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAogCWlmICghY2FuX21tYXAob2JqLCB0 eXBlKSB8fCAhY2FuX2FjY2VzcyhvYmopKQogCQlyZXR1cm4gMDsKIAotCW1tbyA9IG1tYXBfb2Zm c2V0X2F0dGFjaChvYmosIHR5cGUsIE5VTEwpOwotCWlmIChJU19FUlIobW1vKSkKLQkJcmV0dXJu IFBUUl9FUlIobW1vKTsKKwllcnIgPSBfX2Fzc2lnbl9tbWFwX29mZnNldChvYmosIHR5cGUsICZv ZmZzZXQsIE5VTEwpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CiAKLQlhZGRyID0gaWd0X21t YXBfbm9kZShpOTE1LCAmbW1vLT52bWFfbm9kZSwgMCwgUFJPVF9XUklURSwgTUFQX1NIQVJFRCk7 CisJYWRkciA9IGlndF9tbWFwX29mZnNldChpOTE1LCBvZmZzZXQsIG9iai0+YmFzZS5zaXplLCBQ Uk9UX1dSSVRFLCBNQVBfU0hBUkVEKTsKIAlpZiAoSVNfRVJSX1ZBTFVFKGFkZHIpKQogCQlyZXR1 cm4gYWRkcjsKIAlwdHIgPSAodW5zaWduZWQgbG9uZyBfX3VzZXIgKilhZGRyOwpAQCAtMTA4MSw3 ICsxMDc1LDcgQEAgc3RhdGljIGludCBpZ3RfbW1hcF9hY2Nlc3Modm9pZCAqYXJnKQogCQlzdHJ1 Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqOwogCQlpbnQgZXJyOwogCi0JCW9iaiA9IGk5MTVf Z2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKG1yLCBQQUdFX1NJWkUsIDApOworCQlvYmogPSBpOTE1 X2dlbV9vYmplY3RfY3JlYXRlX3JlZ2lvbihtciwgUEFHRV9TSVpFLCBJOTE1X0JPX0FMTE9DX1VT RVIpOwogCQlpZiAob2JqID09IEVSUl9QVFIoLUVOT0RFVikpCiAJCQljb250aW51ZTsKIApAQCAt MTExMSwxMSArMTEwNSwxMSBAQCBzdGF0aWMgaW50IF9faWd0X21tYXBfZ3B1KHN0cnVjdCBkcm1f aTkxNV9wcml2YXRlICppOTE1LAogCQkJICBlbnVtIGk5MTVfbW1hcF90eXBlIHR5cGUpCiB7CiAJ c3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOwotCXN0cnVjdCBpOTE1X21tYXBfb2Zmc2V0 ICptbW87CiAJdW5zaWduZWQgbG9uZyBhZGRyOwogCXUzMiBfX3VzZXIgKnV4OwogCXUzMiBiYmU7 CiAJaW50IGVycjsKKwl1NjQgb2Zmc2V0OwogCiAJLyoKIAkgKiBWZXJpZnkgdGhhdCB0aGUgbW1h cCBhY2Nlc3MgaW50byB0aGUgYmFja2luZyBzdG9yZSBhbGlnbnMgd2l0aApAQCAtMTEzMiwxMSAr MTEyNiwxMSBAQCBzdGF0aWMgaW50IF9faWd0X21tYXBfZ3B1KHN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICppOTE1LAogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQltbW8gPSBtbWFwX29mZnNl dF9hdHRhY2gob2JqLCB0eXBlLCBOVUxMKTsKLQlpZiAoSVNfRVJSKG1tbykpCi0JCXJldHVybiBQ VFJfRVJSKG1tbyk7CisJZXJyID0gX19hc3NpZ25fbW1hcF9vZmZzZXQob2JqLCB0eXBlLCAmb2Zm c2V0LCBOVUxMKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOwogCi0JYWRkciA9IGlndF9tbWFw X25vZGUoaTkxNSwgJm1tby0+dm1hX25vZGUsIDAsIFBST1RfV1JJVEUsIE1BUF9TSEFSRUQpOwor CWFkZHIgPSBpZ3RfbW1hcF9vZmZzZXQoaTkxNSwgb2Zmc2V0LCBvYmotPmJhc2Uuc2l6ZSwgUFJP VF9XUklURSwgTUFQX1NIQVJFRCk7CiAJaWYgKElTX0VSUl9WQUxVRShhZGRyKSkKIAkJcmV0dXJu IGFkZHI7CiAKQEAgLTEyMjYsNyArMTIyMCw3IEBAIHN0YXRpYyBpbnQgaWd0X21tYXBfZ3B1KHZv aWQgKmFyZykKIAkJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKIAkJaW50IGVycjsK IAotCQlvYmogPSBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX3JlZ2lvbihtciwgUEFHRV9TSVpFLCAw KTsKKwkJb2JqID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24obXIsIFBBR0VfU0laRSwg STkxNV9CT19BTExPQ19VU0VSKTsKIAkJaWYgKG9iaiA9PSBFUlJfUFRSKC1FTk9ERVYpKQogCQkJ Y29udGludWU7CiAKQEAgLTEzMDMsMTggKzEyOTcsMTggQEAgc3RhdGljIGludCBfX2lndF9tbWFw X3Jldm9rZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAkJCSAgICAgc3RydWN0IGRy bV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKIAkJCSAgICAgZW51bSBpOTE1X21tYXBfdHlwZSB0eXBl KQogewotCXN0cnVjdCBpOTE1X21tYXBfb2Zmc2V0ICptbW87CiAJdW5zaWduZWQgbG9uZyBhZGRy OwogCWludCBlcnI7CisJdTY0IG9mZnNldDsKIAogCWlmICghY2FuX21tYXAob2JqLCB0eXBlKSkK IAkJcmV0dXJuIDA7CiAKLQltbW8gPSBtbWFwX29mZnNldF9hdHRhY2gob2JqLCB0eXBlLCBOVUxM KTsKLQlpZiAoSVNfRVJSKG1tbykpCi0JCXJldHVybiBQVFJfRVJSKG1tbyk7CisJZXJyID0gX19h c3NpZ25fbW1hcF9vZmZzZXQob2JqLCB0eXBlLCAmb2Zmc2V0LCBOVUxMKTsKKwlpZiAoZXJyKQor CQlyZXR1cm4gZXJyOwogCi0JYWRkciA9IGlndF9tbWFwX25vZGUoaTkxNSwgJm1tby0+dm1hX25v ZGUsIDAsIFBST1RfV1JJVEUsIE1BUF9TSEFSRUQpOworCWFkZHIgPSBpZ3RfbW1hcF9vZmZzZXQo aTkxNSwgb2Zmc2V0LCBvYmotPmJhc2Uuc2l6ZSwgUFJPVF9XUklURSwgTUFQX1NIQVJFRCk7CiAJ aWYgKElTX0VSUl9WQUxVRShhZGRyKSkKIAkJcmV0dXJuIGFkZHI7CiAKQEAgLTEzNTAsMTAgKzEz NDQsMjAgQEAgc3RhdGljIGludCBfX2lndF9tbWFwX3Jldm9rZShzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqaTkxNSwKIAkJfQogCX0KIAotCWVyciA9IGNoZWNrX2Fic2VudChhZGRyLCBvYmotPmJh c2Uuc2l6ZSk7Ci0JaWYgKGVycikgewotCQlwcl9lcnIoIiVzOiB3YXMgbm90IGFic2VudFxuIiwg b2JqLT5tbS5yZWdpb24tPm5hbWUpOwotCQlnb3RvIG91dF91bm1hcDsKKwlpZiAoIW9iai0+b3Bz LT5tbWFwX29wcykgeworCQllcnIgPSBjaGVja19hYnNlbnQoYWRkciwgb2JqLT5iYXNlLnNpemUp OworCQlpZiAoZXJyKSB7CisJCQlwcl9lcnIoIiVzOiB3YXMgbm90IGFic2VudFxuIiwgb2JqLT5t bS5yZWdpb24tPm5hbWUpOworCQkJZ290byBvdXRfdW5tYXA7CisJCX0KKwl9IGVsc2UgeworCQkv KiB0dG0gYWxsb3dzIGFjY2VzcyB0byBldmljdGVkIHJlZ2lvbnMgYnkgZGVzaWduICovCisKKwkJ ZXJyID0gY2hlY2tfcHJlc2VudChhZGRyLCBvYmotPmJhc2Uuc2l6ZSk7CisJCWlmIChlcnIpIHsK KwkJCXByX2VycigiJXM6IHdhcyBub3QgcHJlc2VudFxuIiwgb2JqLT5tbS5yZWdpb24tPm5hbWUp OworCQkJZ290byBvdXRfdW5tYXA7CisJCX0KIAl9CiAKIG91dF91bm1hcDoKQEAgLTEzNzEsNyAr MTM3NSw3IEBAIHN0YXRpYyBpbnQgaWd0X21tYXBfcmV2b2tlKHZvaWQgKmFyZykKIAkJc3RydWN0 IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKIAkJaW50IGVycjsKIAotCQlvYmogPSBpOTE1X2dl bV9vYmplY3RfY3JlYXRlX3JlZ2lvbihtciwgUEFHRV9TSVpFLCAwKTsKKwkJb2JqID0gaTkxNV9n ZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24obXIsIFBBR0VfU0laRSwgSTkxNV9CT19BTExPQ19VU0VS KTsKIAkJaWYgKG9iaiA9PSBFUlJfUFRSKC1FTk9ERVYpKQogCQkJY29udGludWU7CiAKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfbW1hcC5jIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2lndF9tbWFwLmMKaW5kZXggNTgzYTRmZjhiOGM5Li5l OTIwYTQ2MWJkMzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9p Z3RfbW1hcC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfbW1hcC5j CkBAIC05LDE1ICs5LDI4IEBACiAjaW5jbHVkZSAiaTkxNV9kcnYuaCIKICNpbmNsdWRlICJpZ3Rf bW1hcC5oIgogCi11bnNpZ25lZCBsb25nIGlndF9tbWFwX25vZGUoc3RydWN0IGRybV9pOTE1X3By aXZhdGUgKmk5MTUsCi0JCQkgICAgc3RydWN0IGRybV92bWFfb2Zmc2V0X25vZGUgKm5vZGUsCi0J CQkgICAgdW5zaWduZWQgbG9uZyBhZGRyLAotCQkJICAgIHVuc2lnbmVkIGxvbmcgcHJvdCwKLQkJ CSAgICB1bnNpZ25lZCBsb25nIGZsYWdzKQordW5zaWduZWQgbG9uZyBpZ3RfbW1hcF9vZmZzZXQo c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCisJCQkgICAgICB1NjQgb2Zmc2V0LAorCQkJ ICAgICAgdW5zaWduZWQgbG9uZyBzaXplLAorCQkJICAgICAgdW5zaWduZWQgbG9uZyBwcm90LAor CQkJICAgICAgdW5zaWduZWQgbG9uZyBmbGFncykKIHsKKwlzdHJ1Y3QgZHJtX3ZtYV9vZmZzZXRf bm9kZSAqbm9kZTsKIAlzdHJ1Y3QgZmlsZSAqZmlsZTsKKwl1bnNpZ25lZCBsb25nIGFkZHI7CiAJ aW50IGVycjsKIAorCS8qIG5vIG5lZWQgdG8gcmVmY291bnQsIHdlIG93biB0aGlzIG9iamVjdCAq LworCWRybV92bWFfb2Zmc2V0X2xvY2tfbG9va3VwKGk5MTUtPmRybS52bWFfb2Zmc2V0X21hbmFn ZXIpOworCW5vZGUgPSBkcm1fdm1hX29mZnNldF9leGFjdF9sb29rdXBfbG9ja2VkKGk5MTUtPmRy bS52bWFfb2Zmc2V0X21hbmFnZXIsCisJCQkJCQkgIG9mZnNldCAvIFBBR0VfU0laRSwgc2l6ZSAv IFBBR0VfU0laRSk7CisJZHJtX3ZtYV9vZmZzZXRfdW5sb2NrX2xvb2t1cChpOTE1LT5kcm0udm1h X29mZnNldF9tYW5hZ2VyKTsKKworCWlmIChHRU1fV0FSTl9PTighbm9kZSkpIHsKKwkJcHJfaW5m bygiRmFpbGVkIHRvIGxvb2t1cCAlbGx4XG4iLCBvZmZzZXQpOworCQlyZXR1cm4gLUVOT0VOVDsK Kwl9CisKIAkvKiBQcmV0ZW5kIHRvIG9wZW4oIi9kZXYvZHJpL2NhcmQwIikgKi8KIAlmaWxlID0g bW9ja19kcm1fZ2V0ZmlsZShpOTE1LT5kcm0ucHJpbWFyeSwgT19SRFdSKTsKIAlpZiAoSVNfRVJS KGZpbGUpKQpAQCAtMjksNyArNDIsNyBAQCB1bnNpZ25lZCBsb25nIGlndF9tbWFwX25vZGUoc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJCWdvdG8gb3V0X2ZpbGU7CiAJfQogCi0JYWRk ciA9IHZtX21tYXAoZmlsZSwgYWRkciwgZHJtX3ZtYV9ub2RlX3NpemUobm9kZSkgPDwgUEFHRV9T SElGVCwKKwlhZGRyID0gdm1fbW1hcChmaWxlLCAwLCBkcm1fdm1hX25vZGVfc2l6ZShub2RlKSA8 PCBQQUdFX1NISUZULAogCQkgICAgICAgcHJvdCwgZmxhZ3MsIGRybV92bWFfbm9kZV9vZmZzZXRf YWRkcihub2RlKSk7CiAKIAlkcm1fdm1hX25vZGVfcmV2b2tlKG5vZGUsIGZpbGUtPnByaXZhdGVf ZGF0YSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaWd0X21t YXAuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pZ3RfbW1hcC5oCmluZGV4IDZl NzE2Y2I1OWQ3ZS4uYWNiZTM0ZDgxYTZkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9zZWxmdGVzdHMvaWd0X21tYXAuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVz dHMvaWd0X21tYXAuaApAQCAtNywxMyArNywxNSBAQAogI2lmbmRlZiBJR1RfTU1BUF9ICiAjZGVm aW5lIElHVF9NTUFQX0gKIAorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKIHN0cnVjdCBkcm1f aTkxNV9wcml2YXRlOwogc3RydWN0IGRybV92bWFfb2Zmc2V0X25vZGU7CiAKLXVuc2lnbmVkIGxv bmcgaWd0X21tYXBfbm9kZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKLQkJCSAgICBz dHJ1Y3QgZHJtX3ZtYV9vZmZzZXRfbm9kZSAqbm9kZSwKLQkJCSAgICB1bnNpZ25lZCBsb25nIGFk ZHIsCi0JCQkgICAgdW5zaWduZWQgbG9uZyBwcm90LAotCQkJICAgIHVuc2lnbmVkIGxvbmcgZmxh Z3MpOwordW5zaWduZWQgbG9uZyBpZ3RfbW1hcF9vZmZzZXQoc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgKmk5MTUsCisJCQkgICAgICB1NjQgb2Zmc2V0LAorCQkJICAgICAgdW5zaWduZWQgbG9uZyBz aXplLAorCQkJICAgICAgdW5zaWduZWQgbG9uZyBwcm90LAorCQkJICAgICAgdW5zaWduZWQgbG9u ZyBmbGFncyk7CiAKICNlbmRpZiAvKiBJR1RfTU1BUF9IICovCi0tIAoyLjMxLjEKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5n IGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVk ZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=