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=-8.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7ECF4C31E49 for ; Wed, 12 Jun 2019 15:20:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 4BEAF21019 for ; Wed, 12 Jun 2019 15:20:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2501973AbfFLPUe (ORCPT ); Wed, 12 Jun 2019 11:20:34 -0400 Received: from pio-pvt-msa3.bahnhof.se ([79.136.2.42]:51448 "EHLO pio-pvt-msa3.bahnhof.se" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2439843AbfFLPUb (ORCPT ); Wed, 12 Jun 2019 11:20:31 -0400 Received: from localhost (localhost [127.0.0.1]) by pio-pvt-msa3.bahnhof.se (Postfix) with ESMTP id DFEA53FBE3; Wed, 12 Jun 2019 17:20:23 +0200 (CEST) Authentication-Results: pio-pvt-msa3.bahnhof.se; dkim=pass (1024-bit key; unprotected) header.d=vmwopensource.org header.i=@vmwopensource.org header.b=RVNg3akK; dkim-atps=neutral X-Virus-Scanned: Debian amavisd-new at bahnhof.se Received: from pio-pvt-msa3.bahnhof.se ([127.0.0.1]) by localhost (pio-pvt-msa3.bahnhof.se [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id YLyNFb20sf1h; Wed, 12 Jun 2019 17:20:11 +0200 (CEST) Received: from mail1.shipmail.org (h-205-35.A357.priv.bahnhof.se [155.4.205.35]) (Authenticated sender: mb878879) by pio-pvt-msa3.bahnhof.se (Postfix) with ESMTPA id 024093FBDC; Wed, 12 Jun 2019 17:20:10 +0200 (CEST) Received: from localhost.localdomain.localdomain (h-205-35.A357.priv.bahnhof.se [155.4.205.35]) by mail1.shipmail.org (Postfix) with ESMTPSA id 83A013620E9; Wed, 12 Jun 2019 17:20:10 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=vmwopensource.org; s=mail; t=1560352810; bh=aoCEU51Mmy35TCfq2QFa8Fwf99tU96Ns5lgdueVokuQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=RVNg3akK1jtPMHCVWGHmW8NG8bkcnTYjEXk4NUq8V0qlJxNSch9jJZ/H+oqDHeNnR xFPgJMZ6bXjpykHLOwcdMtukpTZ0bdzpCkXHEc6JyjdI+IQOS+hfPKnutw7k+mEsux uHUNORny9y6D65WnDZX86d4Oea9MBvDpwI7TAaHo= From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m=20=28VMware=29?= To: dri-devel@lists.freedesktop.org Cc: linux-graphics-maintainer@vmware.com, pv-drivers@vmware.com, linux-kernel@vger.kernel.org, hch@infradead.org, Thomas Hellstrom , Deepak Rawat Subject: [PATCH v6 8/9] drm/vmwgfx: Implement an infrastructure for read-coherent resources Date: Wed, 12 Jun 2019 17:19:49 +0200 Message-Id: <20190612151950.2870-9-thellstrom@vmwopensource.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190612151950.2870-1-thellstrom@vmwopensource.org> References: <20190612151950.2870-1-thellstrom@vmwopensource.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Thomas Hellstrom Similar to write-coherent resources, make sure that from the user-space point of view, GPU rendered contents is automatically available for reading by the CPU. Signed-off-by: Thomas Hellstrom Reviewed-by: Deepak Rawat --- drivers/gpu/drm/vmwgfx/vmwgfx_drv.h | 7 +- drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c | 73 ++++++++++++- drivers/gpu/drm/vmwgfx/vmwgfx_resource.c | 103 +++++++++++++++++- drivers/gpu/drm/vmwgfx/vmwgfx_resource_priv.h | 2 + drivers/gpu/drm/vmwgfx/vmwgfx_validation.c | 3 +- 5 files changed, 177 insertions(+), 11 deletions(-) diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h index 9b347923196f..dae3a39bf402 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h @@ -689,7 +689,8 @@ extern void vmw_resource_unreference(struct vmw_resource **p_res); extern struct vmw_resource *vmw_resource_reference(struct vmw_resource *res); extern struct vmw_resource * vmw_resource_reference_unless_doomed(struct vmw_resource *res); -extern int vmw_resource_validate(struct vmw_resource *res, bool intr); +extern int vmw_resource_validate(struct vmw_resource *res, bool intr, + bool dirtying); extern int vmw_resource_reserve(struct vmw_resource *res, bool interruptible, bool no_backup); extern bool vmw_resource_needs_backup(const struct vmw_resource *res); @@ -733,6 +734,8 @@ void vmw_resource_mob_attach(struct vmw_resource *res); void vmw_resource_mob_detach(struct vmw_resource *res); void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start, pgoff_t end); +int vmw_resources_clean(struct vmw_buffer_object *vbo, pgoff_t start, + pgoff_t end, pgoff_t *num_prefault); /** * vmw_resource_mob_attached - Whether a resource currently has a mob attached @@ -1427,6 +1430,8 @@ int vmw_bo_dirty_add(struct vmw_buffer_object *vbo); void vmw_bo_dirty_transfer_to_res(struct vmw_resource *res); void vmw_bo_dirty_clear_res(struct vmw_resource *res); void vmw_bo_dirty_release(struct vmw_buffer_object *vbo); +void vmw_bo_dirty_unmap(struct vmw_buffer_object *vbo, + pgoff_t start, pgoff_t end); vm_fault_t vmw_bo_vm_fault(struct vm_fault *vmf); vm_fault_t vmw_bo_vm_mkwrite(struct vm_fault *vmf); diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c b/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c index 8d154f90bdc0..730c51e397dd 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c @@ -153,7 +153,6 @@ static void vmw_bo_dirty_scan_mkwrite(struct vmw_buffer_object *vbo) } } - /** * vmw_bo_dirty_scan - Scan for dirty pages and add them to the dirty * tracking structure @@ -171,6 +170,51 @@ void vmw_bo_dirty_scan(struct vmw_buffer_object *vbo) vmw_bo_dirty_scan_mkwrite(vbo); } +/** + * vmw_bo_dirty_pre_unmap - write-protect and pick up dirty pages before + * an unmap_mapping_range operation. + * @vbo: The buffer object, + * @start: First page of the range within the buffer object. + * @end: Last page of the range within the buffer object + 1. + * + * If we're using the _PAGETABLE scan method, we may leak dirty pages + * when calling unmap_mapping_range(). This function makes sure we pick + * up all dirty pages. + */ +static void vmw_bo_dirty_pre_unmap(struct vmw_buffer_object *vbo, + pgoff_t start, pgoff_t end) +{ + struct vmw_bo_dirty *dirty = vbo->dirty; + unsigned long offset = drm_vma_node_start(&vbo->base.vma_node); + struct address_space *mapping = vbo->base.bdev->dev_mapping; + + if (dirty->method != VMW_BO_DIRTY_PAGETABLE || start >= end) + return; + + apply_as_wrprotect(mapping, start + offset, end - start); + apply_as_clean(mapping, start + offset, end - start, offset, + &dirty->bitmap[0], &dirty->start, &dirty->end); +} + +/** + * vmw_bo_dirty_unmap - Clear all ptes pointing to a range within a bo + * @vbo: The buffer object, + * @start: First page of the range within the buffer object. + * @end: Last page of the range within the buffer object + 1. + * + * This is similar to ttm_bo_unmap_virtual_locked() except it takes a subrange. + */ +void vmw_bo_dirty_unmap(struct vmw_buffer_object *vbo, + pgoff_t start, pgoff_t end) +{ + unsigned long offset = drm_vma_node_start(&vbo->base.vma_node); + struct address_space *mapping = vbo->base.bdev->dev_mapping; + + vmw_bo_dirty_pre_unmap(vbo, start, end); + unmap_shared_mapping_range(mapping, (offset + start) << PAGE_SHIFT, + (loff_t) (end - start) << PAGE_SHIFT); +} + /** * vmw_bo_dirty_add - Add a dirty-tracking user to a buffer object * @vbo: The buffer object @@ -389,21 +433,40 @@ vm_fault_t vmw_bo_vm_fault(struct vm_fault *vmf) if (ret) return ret; + num_prefault = (vma->vm_flags & VM_RAND_READ) ? 1 : + TTM_BO_VM_NUM_PREFAULT; + + if (vbo->dirty) { + pgoff_t allowed_prefault; + unsigned long page_offset; + + page_offset = vmf->pgoff - drm_vma_node_start(&bo->vma_node); + if (page_offset >= bo->num_pages || + vmw_resources_clean(vbo, page_offset, + page_offset + PAGE_SIZE, + &allowed_prefault)) { + ret = VM_FAULT_SIGBUS; + goto out_unlock; + } + + num_prefault = min(num_prefault, allowed_prefault); + } + /* - * This will cause mkwrite() to be called for each pte on - * write-enable vmas. + * If we don't track dirty using the MKWRITE method, make sure + * sure the page protection is write-enabled so we don't get + * a lot of unnecessary write faults. */ if (vbo->dirty && vbo->dirty->method == VMW_BO_DIRTY_MKWRITE) prot = vma->vm_page_prot; else prot = vm_get_page_prot(vma->vm_flags); - num_prefault = (vma->vm_flags & VM_RAND_READ) ? 0 : - TTM_BO_VM_NUM_PREFAULT; ret = ttm_bo_vm_fault_reserved(vmf, prot, num_prefault); if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) return ret; +out_unlock: reservation_object_unlock(bo->resv); return ret; } diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c index b84dd5953886..d70ee0df5c13 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c @@ -395,7 +395,8 @@ static int vmw_resource_buf_alloc(struct vmw_resource *res, * should be retried once resources have been freed up. */ static int vmw_resource_do_validate(struct vmw_resource *res, - struct ttm_validate_buffer *val_buf) + struct ttm_validate_buffer *val_buf, + bool dirtying) { int ret = 0; const struct vmw_res_func *func = res->func; @@ -437,6 +438,15 @@ static int vmw_resource_do_validate(struct vmw_resource *res, * the resource. */ if (res->dirty) { + if (dirtying && !res->res_dirty) { + pgoff_t start = res->backup_offset >> PAGE_SHIFT; + pgoff_t end = __KERNEL_DIV_ROUND_UP + (res->backup_offset + res->backup_size, + PAGE_SIZE); + + vmw_bo_dirty_unmap(res->backup, start, end); + } + vmw_bo_dirty_transfer_to_res(res); return func->dirty_sync(res); } @@ -681,6 +691,7 @@ static int vmw_resource_do_evict(struct ww_acquire_ctx *ticket, * to the device. * @res: The resource to make visible to the device. * @intr: Perform waits interruptible if possible. + * @dirtying: Pending GPU operation will dirty the resource * * On succesful return, any backup DMA buffer pointed to by @res->backup will * be reserved and validated. @@ -690,7 +701,8 @@ static int vmw_resource_do_evict(struct ww_acquire_ctx *ticket, * Return: Zero on success, -ERESTARTSYS if interrupted, negative error code * on failure. */ -int vmw_resource_validate(struct vmw_resource *res, bool intr) +int vmw_resource_validate(struct vmw_resource *res, bool intr, + bool dirtying) { int ret; struct vmw_resource *evict_res; @@ -707,7 +719,7 @@ int vmw_resource_validate(struct vmw_resource *res, bool intr) if (res->backup) val_buf.bo = &res->backup->base; do { - ret = vmw_resource_do_validate(res, &val_buf); + ret = vmw_resource_do_validate(res, &val_buf, dirtying); if (likely(ret != -EBUSY)) break; @@ -1007,7 +1019,7 @@ int vmw_resource_pin(struct vmw_resource *res, bool interruptible) /* Do we really need to pin the MOB as well? */ vmw_bo_pin_reserved(vbo, true); } - ret = vmw_resource_validate(res, interruptible); + ret = vmw_resource_validate(res, interruptible, true); if (vbo) ttm_bo_unreserve(&vbo->base); if (ret) @@ -1082,3 +1094,86 @@ void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start, res->func->dirty_range_add(res, start << PAGE_SHIFT, end << PAGE_SHIFT); } + +/** + * vmw_resources_clean - Clean resources intersecting a mob range + * @vbo: The mob buffer object + * @start: The mob page offset starting the range + * @end: The mob page offset ending the range + * @num_prefault: Returns how many pages including the first have been + * cleaned and are ok to prefault + */ +int vmw_resources_clean(struct vmw_buffer_object *vbo, pgoff_t start, + pgoff_t end, pgoff_t *num_prefault) +{ + struct rb_node *cur = vbo->res_tree.rb_node; + struct vmw_resource *found = NULL; + unsigned long res_start = start << PAGE_SHIFT; + unsigned long res_end = end << PAGE_SHIFT; + unsigned long last_cleaned = 0; + + /* + * Find the resource with lowest backup_offset that intersects the + * range. + */ + while (cur) { + struct vmw_resource *cur_res = + container_of(cur, struct vmw_resource, mob_node); + + if (cur_res->backup_offset >= res_end) { + cur = cur->rb_left; + } else if (cur_res->backup_offset + cur_res->backup_size <= + res_start) { + cur = cur->rb_right; + } else { + found = cur_res; + cur = cur->rb_left; + /* Continue to look for resources with lower offsets */ + } + } + + /* + * In order of increasing backup_offset, clean dirty resorces + * intersecting the range. + */ + while (found) { + if (found->res_dirty) { + int ret; + + if (!found->func->clean) + return -EINVAL; + + ret = found->func->clean(found); + if (ret) + return ret; + + found->res_dirty = false; + } + last_cleaned = found->backup_offset + found->backup_size; + cur = rb_next(&found->mob_node); + if (!cur) + break; + + found = container_of(cur, struct vmw_resource, mob_node); + if (found->backup_offset >= res_end) + break; + } + + /* + * Set number of pages allowed prefaulting and fence the buffer object + */ + *num_prefault = 1; + if (last_cleaned > res_start) { + struct ttm_buffer_object *bo = &vbo->base; + + *num_prefault = __KERNEL_DIV_ROUND_UP(last_cleaned - res_start, + PAGE_SIZE); + vmw_bo_fence_single(bo, NULL); + if (bo->moving) + dma_fence_put(bo->moving); + bo->moving = dma_fence_get + (reservation_object_get_excl(bo->resv)); + } + + return 0; +} diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_resource_priv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_resource_priv.h index c85144286cfe..3b7438b2d289 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_resource_priv.h +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_resource_priv.h @@ -77,6 +77,7 @@ struct vmw_user_resource_conv { * @dirty_sync: Upload the dirty mob contents to the resource. * @dirty_add_range: Add a sequential dirty range to the resource * dirty tracker. + * @clean: Clean the resource. */ struct vmw_res_func { enum vmw_res_type res_type; @@ -101,6 +102,7 @@ struct vmw_res_func { int (*dirty_sync)(struct vmw_resource *res); void (*dirty_range_add)(struct vmw_resource *res, size_t start, size_t end); + int (*clean)(struct vmw_resource *res); }; /** diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c b/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c index 71349a7bae90..9aaf807ed73c 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c @@ -641,7 +641,8 @@ int vmw_validation_res_validate(struct vmw_validation_context *ctx, bool intr) struct vmw_resource *res = val->res; struct vmw_buffer_object *backup = res->backup; - ret = vmw_resource_validate(res, intr); + ret = vmw_resource_validate(res, intr, val->dirty_set && + val->dirty); if (ret) { if (ret != -ERESTARTSYS) DRM_ERROR("Failed to validate resource.\n"); -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m=20=28VMware=29?= Subject: [PATCH v6 8/9] drm/vmwgfx: Implement an infrastructure for read-coherent resources Date: Wed, 12 Jun 2019 17:19:49 +0200 Message-ID: <20190612151950.2870-9-thellstrom@vmwopensource.org> References: <20190612151950.2870-1-thellstrom@vmwopensource.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from pio-pvt-msa3.bahnhof.se (pio-pvt-msa3.bahnhof.se [79.136.2.42]) by gabe.freedesktop.org (Postfix) with ESMTPS id E148F892FA for ; Wed, 12 Jun 2019 15:20:25 +0000 (UTC) In-Reply-To: <20190612151950.2870-1-thellstrom@vmwopensource.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: Thomas Hellstrom , pv-drivers@vmware.com, linux-kernel@vger.kernel.org, hch@infradead.org, linux-graphics-maintainer@vmware.com, Deepak Rawat List-Id: dri-devel@lists.freedesktop.org RnJvbTogVGhvbWFzIEhlbGxzdHJvbSA8dGhlbGxzdHJvbUB2bXdhcmUuY29tPgoKU2ltaWxhciB0 byB3cml0ZS1jb2hlcmVudCByZXNvdXJjZXMsIG1ha2Ugc3VyZSB0aGF0IGZyb20gdGhlIHVzZXIt c3BhY2UKcG9pbnQgb2YgdmlldywgR1BVIHJlbmRlcmVkIGNvbnRlbnRzIGlzIGF1dG9tYXRpY2Fs bHkgYXZhaWxhYmxlIGZvcgpyZWFkaW5nIGJ5IHRoZSBDUFUuCgpTaWduZWQtb2ZmLWJ5OiBUaG9t YXMgSGVsbHN0cm9tIDx0aGVsbHN0cm9tQHZtd2FyZS5jb20+ClJldmlld2VkLWJ5OiBEZWVwYWsg UmF3YXQgPGRyYXdhdEB2bXdhcmUuY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13 Z2Z4X2Rydi5oICAgICAgICAgICB8ICAgNyArLQogZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdn ZnhfcGFnZV9kaXJ0eS5jICAgIHwgIDczICsrKysrKysrKysrKy0KIGRyaXZlcnMvZ3B1L2RybS92 bXdnZngvdm13Z2Z4X3Jlc291cmNlLmMgICAgICB8IDEwMyArKysrKysrKysrKysrKysrKy0KIGRy aXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X3Jlc291cmNlX3ByaXYuaCB8ICAgMiArCiBkcml2 ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF92YWxpZGF0aW9uLmMgICAgfCAgIDMgKy0KIDUgZmls ZXMgY2hhbmdlZCwgMTc3IGluc2VydGlvbnMoKyksIDExIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2Rydi5oIGIvZHJpdmVycy9ncHUvZHJt L3Ztd2dmeC92bXdnZnhfZHJ2LmgKaW5kZXggOWIzNDc5MjMxOTZmLi5kYWUzYTM5YmY0MDIgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2Rydi5oCisrKyBiL2RyaXZl cnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2Rydi5oCkBAIC02ODksNyArNjg5LDggQEAgZXh0ZXJu IHZvaWQgdm13X3Jlc291cmNlX3VucmVmZXJlbmNlKHN0cnVjdCB2bXdfcmVzb3VyY2UgKipwX3Jl cyk7CiBleHRlcm4gc3RydWN0IHZtd19yZXNvdXJjZSAqdm13X3Jlc291cmNlX3JlZmVyZW5jZShz dHJ1Y3Qgdm13X3Jlc291cmNlICpyZXMpOwogZXh0ZXJuIHN0cnVjdCB2bXdfcmVzb3VyY2UgKgog dm13X3Jlc291cmNlX3JlZmVyZW5jZV91bmxlc3NfZG9vbWVkKHN0cnVjdCB2bXdfcmVzb3VyY2Ug KnJlcyk7Ci1leHRlcm4gaW50IHZtd19yZXNvdXJjZV92YWxpZGF0ZShzdHJ1Y3Qgdm13X3Jlc291 cmNlICpyZXMsIGJvb2wgaW50cik7CitleHRlcm4gaW50IHZtd19yZXNvdXJjZV92YWxpZGF0ZShz dHJ1Y3Qgdm13X3Jlc291cmNlICpyZXMsIGJvb2wgaW50ciwKKwkJCQkgYm9vbCBkaXJ0eWluZyk7 CiBleHRlcm4gaW50IHZtd19yZXNvdXJjZV9yZXNlcnZlKHN0cnVjdCB2bXdfcmVzb3VyY2UgKnJl cywgYm9vbCBpbnRlcnJ1cHRpYmxlLAogCQkJCWJvb2wgbm9fYmFja3VwKTsKIGV4dGVybiBib29s IHZtd19yZXNvdXJjZV9uZWVkc19iYWNrdXAoY29uc3Qgc3RydWN0IHZtd19yZXNvdXJjZSAqcmVz KTsKQEAgLTczMyw2ICs3MzQsOCBAQCB2b2lkIHZtd19yZXNvdXJjZV9tb2JfYXR0YWNoKHN0cnVj dCB2bXdfcmVzb3VyY2UgKnJlcyk7CiB2b2lkIHZtd19yZXNvdXJjZV9tb2JfZGV0YWNoKHN0cnVj dCB2bXdfcmVzb3VyY2UgKnJlcyk7CiB2b2lkIHZtd19yZXNvdXJjZV9kaXJ0eV91cGRhdGUoc3Ry dWN0IHZtd19yZXNvdXJjZSAqcmVzLCBwZ29mZl90IHN0YXJ0LAogCQkJICAgICAgIHBnb2ZmX3Qg ZW5kKTsKK2ludCB2bXdfcmVzb3VyY2VzX2NsZWFuKHN0cnVjdCB2bXdfYnVmZmVyX29iamVjdCAq dmJvLCBwZ29mZl90IHN0YXJ0LAorCQkJcGdvZmZfdCBlbmQsIHBnb2ZmX3QgKm51bV9wcmVmYXVs dCk7CiAKIC8qKgogICogdm13X3Jlc291cmNlX21vYl9hdHRhY2hlZCAtIFdoZXRoZXIgYSByZXNv dXJjZSBjdXJyZW50bHkgaGFzIGEgbW9iIGF0dGFjaGVkCkBAIC0xNDI3LDYgKzE0MzAsOCBAQCBp bnQgdm13X2JvX2RpcnR5X2FkZChzdHJ1Y3Qgdm13X2J1ZmZlcl9vYmplY3QgKnZibyk7CiB2b2lk IHZtd19ib19kaXJ0eV90cmFuc2Zlcl90b19yZXMoc3RydWN0IHZtd19yZXNvdXJjZSAqcmVzKTsK IHZvaWQgdm13X2JvX2RpcnR5X2NsZWFyX3JlcyhzdHJ1Y3Qgdm13X3Jlc291cmNlICpyZXMpOwog dm9pZCB2bXdfYm9fZGlydHlfcmVsZWFzZShzdHJ1Y3Qgdm13X2J1ZmZlcl9vYmplY3QgKnZibyk7 Cit2b2lkIHZtd19ib19kaXJ0eV91bm1hcChzdHJ1Y3Qgdm13X2J1ZmZlcl9vYmplY3QgKnZibywK KwkJCXBnb2ZmX3Qgc3RhcnQsIHBnb2ZmX3QgZW5kKTsKIHZtX2ZhdWx0X3Qgdm13X2JvX3ZtX2Zh dWx0KHN0cnVjdCB2bV9mYXVsdCAqdm1mKTsKIHZtX2ZhdWx0X3Qgdm13X2JvX3ZtX21rd3JpdGUo c3RydWN0IHZtX2ZhdWx0ICp2bWYpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdm13 Z2Z4L3Ztd2dmeF9wYWdlX2RpcnR5LmMgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9w YWdlX2RpcnR5LmMKaW5kZXggOGQxNTRmOTBiZGMwLi43MzBjNTFlMzk3ZGQgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X3BhZ2VfZGlydHkuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9wYWdlX2RpcnR5LmMKQEAgLTE1Myw3ICsxNTMsNiBAQCBz dGF0aWMgdm9pZCB2bXdfYm9fZGlydHlfc2Nhbl9ta3dyaXRlKHN0cnVjdCB2bXdfYnVmZmVyX29i amVjdCAqdmJvKQogCX0KIH0KIAotCiAvKioKICAqIHZtd19ib19kaXJ0eV9zY2FuIC0gU2NhbiBm b3IgZGlydHkgcGFnZXMgYW5kIGFkZCB0aGVtIHRvIHRoZSBkaXJ0eQogICogdHJhY2tpbmcgc3Ry dWN0dXJlCkBAIC0xNzEsNiArMTcwLDUxIEBAIHZvaWQgdm13X2JvX2RpcnR5X3NjYW4oc3RydWN0 IHZtd19idWZmZXJfb2JqZWN0ICp2Ym8pCiAJCXZtd19ib19kaXJ0eV9zY2FuX21rd3JpdGUodmJv KTsKIH0KIAorLyoqCisgKiB2bXdfYm9fZGlydHlfcHJlX3VubWFwIC0gd3JpdGUtcHJvdGVjdCBh bmQgcGljayB1cCBkaXJ0eSBwYWdlcyBiZWZvcmUKKyAqIGFuIHVubWFwX21hcHBpbmdfcmFuZ2Ug b3BlcmF0aW9uLgorICogQHZibzogVGhlIGJ1ZmZlciBvYmplY3QsCisgKiBAc3RhcnQ6IEZpcnN0 IHBhZ2Ugb2YgdGhlIHJhbmdlIHdpdGhpbiB0aGUgYnVmZmVyIG9iamVjdC4KKyAqIEBlbmQ6IExh c3QgcGFnZSBvZiB0aGUgcmFuZ2Ugd2l0aGluIHRoZSBidWZmZXIgb2JqZWN0ICsgMS4KKyAqCisg KiBJZiB3ZSdyZSB1c2luZyB0aGUgX1BBR0VUQUJMRSBzY2FuIG1ldGhvZCwgd2UgbWF5IGxlYWsg ZGlydHkgcGFnZXMKKyAqIHdoZW4gY2FsbGluZyB1bm1hcF9tYXBwaW5nX3JhbmdlKCkuIFRoaXMg ZnVuY3Rpb24gbWFrZXMgc3VyZSB3ZSBwaWNrCisgKiB1cCBhbGwgZGlydHkgcGFnZXMuCisgKi8K K3N0YXRpYyB2b2lkIHZtd19ib19kaXJ0eV9wcmVfdW5tYXAoc3RydWN0IHZtd19idWZmZXJfb2Jq ZWN0ICp2Ym8sCisJCQkJICAgcGdvZmZfdCBzdGFydCwgcGdvZmZfdCBlbmQpCit7CisJc3RydWN0 IHZtd19ib19kaXJ0eSAqZGlydHkgPSB2Ym8tPmRpcnR5OworCXVuc2lnbmVkIGxvbmcgb2Zmc2V0 ID0gZHJtX3ZtYV9ub2RlX3N0YXJ0KCZ2Ym8tPmJhc2Uudm1hX25vZGUpOworCXN0cnVjdCBhZGRy ZXNzX3NwYWNlICptYXBwaW5nID0gdmJvLT5iYXNlLmJkZXYtPmRldl9tYXBwaW5nOworCisJaWYg KGRpcnR5LT5tZXRob2QgIT0gVk1XX0JPX0RJUlRZX1BBR0VUQUJMRSB8fCBzdGFydCA+PSBlbmQp CisJCXJldHVybjsKKworCWFwcGx5X2FzX3dycHJvdGVjdChtYXBwaW5nLCBzdGFydCArIG9mZnNl dCwgZW5kIC0gc3RhcnQpOworCWFwcGx5X2FzX2NsZWFuKG1hcHBpbmcsIHN0YXJ0ICsgb2Zmc2V0 LCBlbmQgLSBzdGFydCwgb2Zmc2V0LAorCQkgICAgICAgJmRpcnR5LT5iaXRtYXBbMF0sICZkaXJ0 eS0+c3RhcnQsICZkaXJ0eS0+ZW5kKTsKK30KKworLyoqCisgKiB2bXdfYm9fZGlydHlfdW5tYXAg LSBDbGVhciBhbGwgcHRlcyBwb2ludGluZyB0byBhIHJhbmdlIHdpdGhpbiBhIGJvCisgKiBAdmJv OiBUaGUgYnVmZmVyIG9iamVjdCwKKyAqIEBzdGFydDogRmlyc3QgcGFnZSBvZiB0aGUgcmFuZ2Ug d2l0aGluIHRoZSBidWZmZXIgb2JqZWN0LgorICogQGVuZDogTGFzdCBwYWdlIG9mIHRoZSByYW5n ZSB3aXRoaW4gdGhlIGJ1ZmZlciBvYmplY3QgKyAxLgorICoKKyAqIFRoaXMgaXMgc2ltaWxhciB0 byB0dG1fYm9fdW5tYXBfdmlydHVhbF9sb2NrZWQoKSBleGNlcHQgaXQgdGFrZXMgYSBzdWJyYW5n ZS4KKyAqLwordm9pZCB2bXdfYm9fZGlydHlfdW5tYXAoc3RydWN0IHZtd19idWZmZXJfb2JqZWN0 ICp2Ym8sCisJCQlwZ29mZl90IHN0YXJ0LCBwZ29mZl90IGVuZCkKK3sKKwl1bnNpZ25lZCBsb25n IG9mZnNldCA9IGRybV92bWFfbm9kZV9zdGFydCgmdmJvLT5iYXNlLnZtYV9ub2RlKTsKKwlzdHJ1 Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZyA9IHZiby0+YmFzZS5iZGV2LT5kZXZfbWFwcGluZzsK KworCXZtd19ib19kaXJ0eV9wcmVfdW5tYXAodmJvLCBzdGFydCwgZW5kKTsKKwl1bm1hcF9zaGFy ZWRfbWFwcGluZ19yYW5nZShtYXBwaW5nLCAob2Zmc2V0ICsgc3RhcnQpIDw8IFBBR0VfU0hJRlQs CisJCQkJICAgKGxvZmZfdCkgKGVuZCAtIHN0YXJ0KSA8PCBQQUdFX1NISUZUKTsKK30KKwogLyoq CiAgKiB2bXdfYm9fZGlydHlfYWRkIC0gQWRkIGEgZGlydHktdHJhY2tpbmcgdXNlciB0byBhIGJ1 ZmZlciBvYmplY3QKICAqIEB2Ym86IFRoZSBidWZmZXIgb2JqZWN0CkBAIC0zODksMjEgKzQzMyw0 MCBAQCB2bV9mYXVsdF90IHZtd19ib192bV9mYXVsdChzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKIAlp ZiAocmV0KQogCQlyZXR1cm4gcmV0OwogCisJbnVtX3ByZWZhdWx0ID0gKHZtYS0+dm1fZmxhZ3Mg JiBWTV9SQU5EX1JFQUQpID8gMSA6CisJCVRUTV9CT19WTV9OVU1fUFJFRkFVTFQ7CisKKwlpZiAo dmJvLT5kaXJ0eSkgeworCQlwZ29mZl90IGFsbG93ZWRfcHJlZmF1bHQ7CisJCXVuc2lnbmVkIGxv bmcgcGFnZV9vZmZzZXQ7CisKKwkJcGFnZV9vZmZzZXQgPSB2bWYtPnBnb2ZmIC0gZHJtX3ZtYV9u b2RlX3N0YXJ0KCZiby0+dm1hX25vZGUpOworCQlpZiAocGFnZV9vZmZzZXQgPj0gYm8tPm51bV9w YWdlcyB8fAorCQkgICAgdm13X3Jlc291cmNlc19jbGVhbih2Ym8sIHBhZ2Vfb2Zmc2V0LAorCQkJ CQlwYWdlX29mZnNldCArIFBBR0VfU0laRSwKKwkJCQkJJmFsbG93ZWRfcHJlZmF1bHQpKSB7CisJ CQlyZXQgPSBWTV9GQVVMVF9TSUdCVVM7CisJCQlnb3RvIG91dF91bmxvY2s7CisJCX0KKworCQlu dW1fcHJlZmF1bHQgPSBtaW4obnVtX3ByZWZhdWx0LCBhbGxvd2VkX3ByZWZhdWx0KTsKKwl9CisK IAkvKgotCSAqIFRoaXMgd2lsbCBjYXVzZSBta3dyaXRlKCkgdG8gYmUgY2FsbGVkIGZvciBlYWNo IHB0ZSBvbgotCSAqIHdyaXRlLWVuYWJsZSB2bWFzLgorCSAqIElmIHdlIGRvbid0IHRyYWNrIGRp cnR5IHVzaW5nIHRoZSBNS1dSSVRFIG1ldGhvZCwgbWFrZSBzdXJlCisJICogc3VyZSB0aGUgcGFn ZSBwcm90ZWN0aW9uIGlzIHdyaXRlLWVuYWJsZWQgc28gd2UgZG9uJ3QgZ2V0CisJICogYSBsb3Qg b2YgdW5uZWNlc3Nhcnkgd3JpdGUgZmF1bHRzLgogCSAqLwogCWlmICh2Ym8tPmRpcnR5ICYmIHZi by0+ZGlydHktPm1ldGhvZCA9PSBWTVdfQk9fRElSVFlfTUtXUklURSkKIAkJcHJvdCA9IHZtYS0+ dm1fcGFnZV9wcm90OwogCWVsc2UKIAkJcHJvdCA9IHZtX2dldF9wYWdlX3Byb3Qodm1hLT52bV9m bGFncyk7CiAKLQludW1fcHJlZmF1bHQgPSAodm1hLT52bV9mbGFncyAmIFZNX1JBTkRfUkVBRCkg PyAwIDoKLQkJVFRNX0JPX1ZNX05VTV9QUkVGQVVMVDsKIAlyZXQgPSB0dG1fYm9fdm1fZmF1bHRf cmVzZXJ2ZWQodm1mLCBwcm90LCBudW1fcHJlZmF1bHQpOwogCWlmIChyZXQgPT0gVk1fRkFVTFRf UkVUUlkgJiYgISh2bWYtPmZsYWdzICYgRkFVTFRfRkxBR19SRVRSWV9OT1dBSVQpKQogCQlyZXR1 cm4gcmV0OwogCitvdXRfdW5sb2NrOgogCXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYm8tPnJl c3YpOwogCXJldHVybiByZXQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4 L3Ztd2dmeF9yZXNvdXJjZS5jIGIvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfcmVzb3Vy Y2UuYwppbmRleCBiODRkZDU5NTM4ODYuLmQ3MGVlMGRmNWMxMyAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfcmVzb3VyY2UuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v dm13Z2Z4L3Ztd2dmeF9yZXNvdXJjZS5jCkBAIC0zOTUsNyArMzk1LDggQEAgc3RhdGljIGludCB2 bXdfcmVzb3VyY2VfYnVmX2FsbG9jKHN0cnVjdCB2bXdfcmVzb3VyY2UgKnJlcywKICAqIHNob3Vs ZCBiZSByZXRyaWVkIG9uY2UgcmVzb3VyY2VzIGhhdmUgYmVlbiBmcmVlZCB1cC4KICAqLwogc3Rh dGljIGludCB2bXdfcmVzb3VyY2VfZG9fdmFsaWRhdGUoc3RydWN0IHZtd19yZXNvdXJjZSAqcmVz LAotCQkJCSAgICBzdHJ1Y3QgdHRtX3ZhbGlkYXRlX2J1ZmZlciAqdmFsX2J1ZikKKwkJCQkgICAg c3RydWN0IHR0bV92YWxpZGF0ZV9idWZmZXIgKnZhbF9idWYsCisJCQkJICAgIGJvb2wgZGlydHlp bmcpCiB7CiAJaW50IHJldCA9IDA7CiAJY29uc3Qgc3RydWN0IHZtd19yZXNfZnVuYyAqZnVuYyA9 IHJlcy0+ZnVuYzsKQEAgLTQzNyw2ICs0MzgsMTUgQEAgc3RhdGljIGludCB2bXdfcmVzb3VyY2Vf ZG9fdmFsaWRhdGUoc3RydWN0IHZtd19yZXNvdXJjZSAqcmVzLAogCSAqIHRoZSByZXNvdXJjZS4K IAkgKi8KIAlpZiAocmVzLT5kaXJ0eSkgeworCQlpZiAoZGlydHlpbmcgJiYgIXJlcy0+cmVzX2Rp cnR5KSB7CisJCQlwZ29mZl90IHN0YXJ0ID0gcmVzLT5iYWNrdXBfb2Zmc2V0ID4+IFBBR0VfU0hJ RlQ7CisJCQlwZ29mZl90IGVuZCA9IF9fS0VSTkVMX0RJVl9ST1VORF9VUAorCQkJCShyZXMtPmJh Y2t1cF9vZmZzZXQgKyByZXMtPmJhY2t1cF9zaXplLAorCQkJCSBQQUdFX1NJWkUpOworCisJCQl2 bXdfYm9fZGlydHlfdW5tYXAocmVzLT5iYWNrdXAsIHN0YXJ0LCBlbmQpOworCQl9CisKIAkJdm13 X2JvX2RpcnR5X3RyYW5zZmVyX3RvX3JlcyhyZXMpOwogCQlyZXR1cm4gZnVuYy0+ZGlydHlfc3lu YyhyZXMpOwogCX0KQEAgLTY4MSw2ICs2OTEsNyBAQCBzdGF0aWMgaW50IHZtd19yZXNvdXJjZV9k b19ldmljdChzdHJ1Y3Qgd3dfYWNxdWlyZV9jdHggKnRpY2tldCwKICAqICAgICAgICAgICAgICAg ICAgICAgICAgIHRvIHRoZSBkZXZpY2UuCiAgKiBAcmVzOiBUaGUgcmVzb3VyY2UgdG8gbWFrZSB2 aXNpYmxlIHRvIHRoZSBkZXZpY2UuCiAgKiBAaW50cjogUGVyZm9ybSB3YWl0cyBpbnRlcnJ1cHRp YmxlIGlmIHBvc3NpYmxlLgorICogQGRpcnR5aW5nOiBQZW5kaW5nIEdQVSBvcGVyYXRpb24gd2ls bCBkaXJ0eSB0aGUgcmVzb3VyY2UKICAqCiAgKiBPbiBzdWNjZXNmdWwgcmV0dXJuLCBhbnkgYmFj a3VwIERNQSBidWZmZXIgcG9pbnRlZCB0byBieSBAcmVzLT5iYWNrdXAgd2lsbAogICogYmUgcmVz ZXJ2ZWQgYW5kIHZhbGlkYXRlZC4KQEAgLTY5MCw3ICs3MDEsOCBAQCBzdGF0aWMgaW50IHZtd19y ZXNvdXJjZV9kb19ldmljdChzdHJ1Y3Qgd3dfYWNxdWlyZV9jdHggKnRpY2tldCwKICAqIFJldHVy bjogWmVybyBvbiBzdWNjZXNzLCAtRVJFU1RBUlRTWVMgaWYgaW50ZXJydXB0ZWQsIG5lZ2F0aXZl IGVycm9yIGNvZGUKICAqIG9uIGZhaWx1cmUuCiAgKi8KLWludCB2bXdfcmVzb3VyY2VfdmFsaWRh dGUoc3RydWN0IHZtd19yZXNvdXJjZSAqcmVzLCBib29sIGludHIpCitpbnQgdm13X3Jlc291cmNl X3ZhbGlkYXRlKHN0cnVjdCB2bXdfcmVzb3VyY2UgKnJlcywgYm9vbCBpbnRyLAorCQkJICBib29s IGRpcnR5aW5nKQogewogCWludCByZXQ7CiAJc3RydWN0IHZtd19yZXNvdXJjZSAqZXZpY3RfcmVz OwpAQCAtNzA3LDcgKzcxOSw3IEBAIGludCB2bXdfcmVzb3VyY2VfdmFsaWRhdGUoc3RydWN0IHZt d19yZXNvdXJjZSAqcmVzLCBib29sIGludHIpCiAJaWYgKHJlcy0+YmFja3VwKQogCQl2YWxfYnVm LmJvID0gJnJlcy0+YmFja3VwLT5iYXNlOwogCWRvIHsKLQkJcmV0ID0gdm13X3Jlc291cmNlX2Rv X3ZhbGlkYXRlKHJlcywgJnZhbF9idWYpOworCQlyZXQgPSB2bXdfcmVzb3VyY2VfZG9fdmFsaWRh dGUocmVzLCAmdmFsX2J1ZiwgZGlydHlpbmcpOwogCQlpZiAobGlrZWx5KHJldCAhPSAtRUJVU1kp KQogCQkJYnJlYWs7CiAKQEAgLTEwMDcsNyArMTAxOSw3IEBAIGludCB2bXdfcmVzb3VyY2VfcGlu KHN0cnVjdCB2bXdfcmVzb3VyY2UgKnJlcywgYm9vbCBpbnRlcnJ1cHRpYmxlKQogCQkJLyogRG8g d2UgcmVhbGx5IG5lZWQgdG8gcGluIHRoZSBNT0IgYXMgd2VsbD8gKi8KIAkJCXZtd19ib19waW5f cmVzZXJ2ZWQodmJvLCB0cnVlKTsKIAkJfQotCQlyZXQgPSB2bXdfcmVzb3VyY2VfdmFsaWRhdGUo cmVzLCBpbnRlcnJ1cHRpYmxlKTsKKwkJcmV0ID0gdm13X3Jlc291cmNlX3ZhbGlkYXRlKHJlcywg aW50ZXJydXB0aWJsZSwgdHJ1ZSk7CiAJCWlmICh2Ym8pCiAJCQl0dG1fYm9fdW5yZXNlcnZlKCZ2 Ym8tPmJhc2UpOwogCQlpZiAocmV0KQpAQCAtMTA4MiwzICsxMDk0LDg2IEBAIHZvaWQgdm13X3Jl c291cmNlX2RpcnR5X3VwZGF0ZShzdHJ1Y3Qgdm13X3Jlc291cmNlICpyZXMsIHBnb2ZmX3Qgc3Rh cnQsCiAJCXJlcy0+ZnVuYy0+ZGlydHlfcmFuZ2VfYWRkKHJlcywgc3RhcnQgPDwgUEFHRV9TSElG VCwKIAkJCQkJICAgZW5kIDw8IFBBR0VfU0hJRlQpOwogfQorCisvKioKKyAqIHZtd19yZXNvdXJj ZXNfY2xlYW4gLSBDbGVhbiByZXNvdXJjZXMgaW50ZXJzZWN0aW5nIGEgbW9iIHJhbmdlCisgKiBA dmJvOiBUaGUgbW9iIGJ1ZmZlciBvYmplY3QKKyAqIEBzdGFydDogVGhlIG1vYiBwYWdlIG9mZnNl dCBzdGFydGluZyB0aGUgcmFuZ2UKKyAqIEBlbmQ6IFRoZSBtb2IgcGFnZSBvZmZzZXQgZW5kaW5n IHRoZSByYW5nZQorICogQG51bV9wcmVmYXVsdDogUmV0dXJucyBob3cgbWFueSBwYWdlcyBpbmNs dWRpbmcgdGhlIGZpcnN0IGhhdmUgYmVlbgorICogY2xlYW5lZCBhbmQgYXJlIG9rIHRvIHByZWZh dWx0CisgKi8KK2ludCB2bXdfcmVzb3VyY2VzX2NsZWFuKHN0cnVjdCB2bXdfYnVmZmVyX29iamVj dCAqdmJvLCBwZ29mZl90IHN0YXJ0LAorCQkJcGdvZmZfdCBlbmQsIHBnb2ZmX3QgKm51bV9wcmVm YXVsdCkKK3sKKwlzdHJ1Y3QgcmJfbm9kZSAqY3VyID0gdmJvLT5yZXNfdHJlZS5yYl9ub2RlOwor CXN0cnVjdCB2bXdfcmVzb3VyY2UgKmZvdW5kID0gTlVMTDsKKwl1bnNpZ25lZCBsb25nIHJlc19z dGFydCA9IHN0YXJ0IDw8IFBBR0VfU0hJRlQ7CisJdW5zaWduZWQgbG9uZyByZXNfZW5kID0gZW5k IDw8IFBBR0VfU0hJRlQ7CisJdW5zaWduZWQgbG9uZyBsYXN0X2NsZWFuZWQgPSAwOworCisJLyoK KwkgKiBGaW5kIHRoZSByZXNvdXJjZSB3aXRoIGxvd2VzdCBiYWNrdXBfb2Zmc2V0IHRoYXQgaW50 ZXJzZWN0cyB0aGUKKwkgKiByYW5nZS4KKwkgKi8KKwl3aGlsZSAoY3VyKSB7CisJCXN0cnVjdCB2 bXdfcmVzb3VyY2UgKmN1cl9yZXMgPQorCQkJY29udGFpbmVyX29mKGN1ciwgc3RydWN0IHZtd19y ZXNvdXJjZSwgbW9iX25vZGUpOworCisJCWlmIChjdXJfcmVzLT5iYWNrdXBfb2Zmc2V0ID49IHJl c19lbmQpIHsKKwkJCWN1ciA9IGN1ci0+cmJfbGVmdDsKKwkJfSBlbHNlIGlmIChjdXJfcmVzLT5i YWNrdXBfb2Zmc2V0ICsgY3VyX3Jlcy0+YmFja3VwX3NpemUgPD0KKwkJCSAgIHJlc19zdGFydCkg eworCQkJY3VyID0gY3VyLT5yYl9yaWdodDsKKwkJfSBlbHNlIHsKKwkJCWZvdW5kID0gY3VyX3Jl czsKKwkJCWN1ciA9IGN1ci0+cmJfbGVmdDsKKwkJCS8qIENvbnRpbnVlIHRvIGxvb2sgZm9yIHJl c291cmNlcyB3aXRoIGxvd2VyIG9mZnNldHMgKi8KKwkJfQorCX0KKworCS8qCisJICogSW4gb3Jk ZXIgb2YgaW5jcmVhc2luZyBiYWNrdXBfb2Zmc2V0LCBjbGVhbiBkaXJ0eSByZXNvcmNlcworCSAq IGludGVyc2VjdGluZyB0aGUgcmFuZ2UuCisJICovCisJd2hpbGUgKGZvdW5kKSB7CisJCWlmIChm b3VuZC0+cmVzX2RpcnR5KSB7CisJCQlpbnQgcmV0OworCisJCQlpZiAoIWZvdW5kLT5mdW5jLT5j bGVhbikKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKworCQkJcmV0ID0gZm91bmQtPmZ1bmMtPmNsZWFu KGZvdW5kKTsKKwkJCWlmIChyZXQpCisJCQkJcmV0dXJuIHJldDsKKworCQkJZm91bmQtPnJlc19k aXJ0eSA9IGZhbHNlOworCQl9CisJCWxhc3RfY2xlYW5lZCA9IGZvdW5kLT5iYWNrdXBfb2Zmc2V0 ICsgZm91bmQtPmJhY2t1cF9zaXplOworCQljdXIgPSByYl9uZXh0KCZmb3VuZC0+bW9iX25vZGUp OworCQlpZiAoIWN1cikKKwkJCWJyZWFrOworCisJCWZvdW5kID0gY29udGFpbmVyX29mKGN1ciwg c3RydWN0IHZtd19yZXNvdXJjZSwgbW9iX25vZGUpOworCQlpZiAoZm91bmQtPmJhY2t1cF9vZmZz ZXQgPj0gcmVzX2VuZCkKKwkJCWJyZWFrOworCX0KKworCS8qCisJICogU2V0IG51bWJlciBvZiBw YWdlcyBhbGxvd2VkIHByZWZhdWx0aW5nIGFuZCBmZW5jZSB0aGUgYnVmZmVyIG9iamVjdAorCSAq LworCSpudW1fcHJlZmF1bHQgPSAxOworCWlmIChsYXN0X2NsZWFuZWQgPiByZXNfc3RhcnQpIHsK KwkJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9ICZ2Ym8tPmJhc2U7CisKKwkJKm51bV9w cmVmYXVsdCA9IF9fS0VSTkVMX0RJVl9ST1VORF9VUChsYXN0X2NsZWFuZWQgLSByZXNfc3RhcnQs CisJCQkJCQkgICAgICBQQUdFX1NJWkUpOworCQl2bXdfYm9fZmVuY2Vfc2luZ2xlKGJvLCBOVUxM KTsKKwkJaWYgKGJvLT5tb3ZpbmcpCisJCQlkbWFfZmVuY2VfcHV0KGJvLT5tb3ZpbmcpOworCQli by0+bW92aW5nID0gZG1hX2ZlbmNlX2dldAorCQkJKHJlc2VydmF0aW9uX29iamVjdF9nZXRfZXhj bChiby0+cmVzdikpOworCX0KKworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3Ztd2dmeC92bXdnZnhfcmVzb3VyY2VfcHJpdi5oIGIvZHJpdmVycy9ncHUvZHJtL3Zt d2dmeC92bXdnZnhfcmVzb3VyY2VfcHJpdi5oCmluZGV4IGM4NTE0NDI4NmNmZS4uM2I3NDM4YjJk Mjg5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9yZXNvdXJjZV9w cml2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfcmVzb3VyY2VfcHJpdi5o CkBAIC03Nyw2ICs3Nyw3IEBAIHN0cnVjdCB2bXdfdXNlcl9yZXNvdXJjZV9jb252IHsKICAqIEBk aXJ0eV9zeW5jOiAgICAgICAgVXBsb2FkIHRoZSBkaXJ0eSBtb2IgY29udGVudHMgdG8gdGhlIHJl c291cmNlLgogICogQGRpcnR5X2FkZF9yYW5nZTogICBBZGQgYSBzZXF1ZW50aWFsIGRpcnR5IHJh bmdlIHRvIHRoZSByZXNvdXJjZQogICogICAgICAgICAgICAgICAgICAgICBkaXJ0eSB0cmFja2Vy LgorICogQGNsZWFuOiAgICAgICAgICAgICBDbGVhbiB0aGUgcmVzb3VyY2UuCiAgKi8KIHN0cnVj dCB2bXdfcmVzX2Z1bmMgewogCWVudW0gdm13X3Jlc190eXBlIHJlc190eXBlOwpAQCAtMTAxLDYg KzEwMiw3IEBAIHN0cnVjdCB2bXdfcmVzX2Z1bmMgewogCWludCAoKmRpcnR5X3N5bmMpKHN0cnVj dCB2bXdfcmVzb3VyY2UgKnJlcyk7CiAJdm9pZCAoKmRpcnR5X3JhbmdlX2FkZCkoc3RydWN0IHZt d19yZXNvdXJjZSAqcmVzLCBzaXplX3Qgc3RhcnQsCiAJCQkJIHNpemVfdCBlbmQpOworCWludCAo KmNsZWFuKShzdHJ1Y3Qgdm13X3Jlc291cmNlICpyZXMpOwogfTsKIAogLyoqCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF92YWxpZGF0aW9uLmMgYi9kcml2ZXJzL2dw dS9kcm0vdm13Z2Z4L3Ztd2dmeF92YWxpZGF0aW9uLmMKaW5kZXggNzEzNDlhN2JhZTkwLi45YWFm ODA3ZWQ3M2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X3ZhbGlk YXRpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF92YWxpZGF0aW9uLmMK QEAgLTY0MSw3ICs2NDEsOCBAQCBpbnQgdm13X3ZhbGlkYXRpb25fcmVzX3ZhbGlkYXRlKHN0cnVj dCB2bXdfdmFsaWRhdGlvbl9jb250ZXh0ICpjdHgsIGJvb2wgaW50cikKIAkJc3RydWN0IHZtd19y ZXNvdXJjZSAqcmVzID0gdmFsLT5yZXM7CiAJCXN0cnVjdCB2bXdfYnVmZmVyX29iamVjdCAqYmFj a3VwID0gcmVzLT5iYWNrdXA7CiAKLQkJcmV0ID0gdm13X3Jlc291cmNlX3ZhbGlkYXRlKHJlcywg aW50cik7CisJCXJldCA9IHZtd19yZXNvdXJjZV92YWxpZGF0ZShyZXMsIGludHIsIHZhbC0+ZGly dHlfc2V0ICYmCisJCQkJCSAgICB2YWwtPmRpcnR5KTsKIAkJaWYgKHJldCkgewogCQkJaWYgKHJl dCAhPSAtRVJFU1RBUlRTWVMpCiAJCQkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gdmFsaWRhdGUgcmVz b3VyY2UuXG4iKTsKLS0gCjIuMjAuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpLWRldmVs