From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Stultz Subject: [PATCH v15 2/5] dma-buf: heaps: Add heap helpers Date: Wed, 6 Nov 2019 04:22:49 +0000 Message-ID: <20191106042252.72452-3-john.stultz@linaro.org> References: <20191106042252.72452-1-john.stultz@linaro.org> Return-path: In-Reply-To: <20191106042252.72452-1-john.stultz@linaro.org> Sender: linux-kernel-owner@vger.kernel.org To: lkml Cc: John Stultz , Laura Abbott , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , "Andrew F . Davis" , Christoph Hellwig , Chenbo Feng , Alistair Strachan , Hridya Valsaraju , Sandeep Patil , Hillf Danton , Dave Airlie , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org Add generic helper dmabuf ops for dma heaps, so we can reduce the amount of duplicative code for the exported dmabufs. This code is an evolution of the Android ION implementation, so thanks to its original authors and maintainters: Rebecca Schultz Zavin, Colin Cross, Laura Abbott, and others! Cc: Laura Abbott Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: Hridya Valsaraju Cc: Sandeep Patil Cc: Hillf Danton Cc: Dave Airlie Cc: dri-devel@lists.freedesktop.org Reviewed-by: Benjamin Gaignard Reviewed-by: Brian Starkey Acked-by: Sandeep Patil Acked-by: Laura Abbott Tested-by: Ayan Kumar Halder Signed-off-by: John Stultz --- v2: * Removed cache management performance hack that I had accidentally folded in. * Removed stats code that was in helpers * Lots of checkpatch cleanups v3: * Uninline INIT_HEAP_HELPER_BUFFER (suggested by Christoph) * Switch to WARN on buffer destroy failure (suggested by Brian) * buffer->kmap_cnt decrementing cleanup (suggested by Christoph) * Extra buffer->vaddr checking in dma_heap_dma_buf_kmap (suggested by Brian) * Switch to_helper_buffer from macro to inline function (suggested by Benjamin) * Rename kmap->vmap (folded in from Andrew) * Use vmap for vmapping - not begin_cpu_access (folded in from Andrew) * Drop kmap for now, as its optional (folded in from Andrew) * Fold dma_heap_map_user into the single caller (foled in from Andrew) * Folded in patch from Andrew to track page list per heap not sglist, which simplifies the tracking logic v4: * Moved dma-heap.h change out to previous patch v6: * Minor cleanups and typo fixes suggested by Brian v7: * Removed stray ; * Make init_heap_helper_buffer lowercase, as suggested by Christoph * Add dmabuf export helper to reduce boilerplate code v8: * Remove unused private_flags value * Condense dma_heap_buffer and heap_helper_buffer (suggested by Christoph) * Fix indentation by using shorter argument names (suggested by Christoph) * Add flush_kernel_vmap_range/invalidate_kernel_vmap_range calls (suggested by Christoph) * Checkpatch whitespace fixups v9: * Minor cleanups suggested by Brian Starkey v10: * Fix missing vmalloc.h inclusion in heap helpers (found by kbuild test robot ) v12: * Add symbol exports for heaps as modules v13: * Re-remove symbol exports, per discussion with Brian, as I'll resubmit the change for review independently. v14: * Fix missing argment to WARN() in dma_heap_buffer_destroy() found and fixed by Dan Carpenter * Add check in fault hanlder that pgoff isn't larger then pagecount, reported by Dan Carpenter v15: * Drop unused flags field from heap_helper_buffer as suggested by Sandeep Patil --- drivers/dma-buf/Makefile | 1 + drivers/dma-buf/heaps/Makefile | 2 + drivers/dma-buf/heaps/heap-helpers.c | 271 +++++++++++++++++++++++++++ drivers/dma-buf/heaps/heap-helpers.h | 53 ++++++ 4 files changed, 327 insertions(+) create mode 100644 drivers/dma-buf/heaps/Makefile create mode 100644 drivers/dma-buf/heaps/heap-helpers.c create mode 100644 drivers/dma-buf/heaps/heap-helpers.h diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index caee5eb3d351..9c190026bfab 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -2,6 +2,7 @@ obj-y := dma-buf.o dma-fence.o dma-fence-array.o dma-fence-chain.o \ dma-resv.o seqno-fence.o obj-$(CONFIG_DMABUF_HEAPS) += dma-heap.o +obj-$(CONFIG_DMABUF_HEAPS) += heaps/ obj-$(CONFIG_SYNC_FILE) += sync_file.o obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o obj-$(CONFIG_UDMABUF) += udmabuf.o diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile new file mode 100644 index 000000000000..de49898112db --- /dev/null +++ b/drivers/dma-buf/heaps/Makefile @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0 +obj-y += heap-helpers.o diff --git a/drivers/dma-buf/heaps/heap-helpers.c b/drivers/dma-buf/heaps/heap-helpers.c new file mode 100644 index 000000000000..9f964ca3f59c --- /dev/null +++ b/drivers/dma-buf/heaps/heap-helpers.c @@ -0,0 +1,271 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "heap-helpers.h" + +void init_heap_helper_buffer(struct heap_helper_buffer *buffer, + void (*free)(struct heap_helper_buffer *)) +{ + buffer->priv_virt = NULL; + mutex_init(&buffer->lock); + buffer->vmap_cnt = 0; + buffer->vaddr = NULL; + buffer->pagecount = 0; + buffer->pages = NULL; + INIT_LIST_HEAD(&buffer->attachments); + buffer->free = free; +} + +struct dma_buf *heap_helper_export_dmabuf(struct heap_helper_buffer *buffer, + int fd_flags) +{ + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + + exp_info.ops = &heap_helper_ops; + exp_info.size = buffer->size; + exp_info.flags = fd_flags; + exp_info.priv = buffer; + + return dma_buf_export(&exp_info); +} + +static void *dma_heap_map_kernel(struct heap_helper_buffer *buffer) +{ + void *vaddr; + + vaddr = vmap(buffer->pages, buffer->pagecount, VM_MAP, PAGE_KERNEL); + if (!vaddr) + return ERR_PTR(-ENOMEM); + + return vaddr; +} + +static void dma_heap_buffer_destroy(struct heap_helper_buffer *buffer) +{ + if (buffer->vmap_cnt > 0) { + WARN(1, "%s: buffer still mapped in the kernel\n", __func__); + vunmap(buffer->vaddr); + } + + buffer->free(buffer); +} + +static void *dma_heap_buffer_vmap_get(struct heap_helper_buffer *buffer) +{ + void *vaddr; + + if (buffer->vmap_cnt) { + buffer->vmap_cnt++; + return buffer->vaddr; + } + vaddr = dma_heap_map_kernel(buffer); + if (IS_ERR(vaddr)) + return vaddr; + buffer->vaddr = vaddr; + buffer->vmap_cnt++; + return vaddr; +} + +static void dma_heap_buffer_vmap_put(struct heap_helper_buffer *buffer) +{ + if (!--buffer->vmap_cnt) { + vunmap(buffer->vaddr); + buffer->vaddr = NULL; + } +} + +struct dma_heaps_attachment { + struct device *dev; + struct sg_table table; + struct list_head list; +}; + +static int dma_heap_attach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct dma_heaps_attachment *a; + struct heap_helper_buffer *buffer = dmabuf->priv; + int ret; + + a = kzalloc(sizeof(*a), GFP_KERNEL); + if (!a) + return -ENOMEM; + + ret = sg_alloc_table_from_pages(&a->table, buffer->pages, + buffer->pagecount, 0, + buffer->pagecount << PAGE_SHIFT, + GFP_KERNEL); + if (ret) { + kfree(a); + return ret; + } + + a->dev = attachment->dev; + INIT_LIST_HEAD(&a->list); + + attachment->priv = a; + + mutex_lock(&buffer->lock); + list_add(&a->list, &buffer->attachments); + mutex_unlock(&buffer->lock); + + return 0; +} + +static void dma_heap_detach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct dma_heaps_attachment *a = attachment->priv; + struct heap_helper_buffer *buffer = dmabuf->priv; + + mutex_lock(&buffer->lock); + list_del(&a->list); + mutex_unlock(&buffer->lock); + + sg_free_table(&a->table); + kfree(a); +} + +static +struct sg_table *dma_heap_map_dma_buf(struct dma_buf_attachment *attachment, + enum dma_data_direction direction) +{ + struct dma_heaps_attachment *a = attachment->priv; + struct sg_table *table; + + table = &a->table; + + if (!dma_map_sg(attachment->dev, table->sgl, table->nents, + direction)) + table = ERR_PTR(-ENOMEM); + return table; +} + +static void dma_heap_unmap_dma_buf(struct dma_buf_attachment *attachment, + struct sg_table *table, + enum dma_data_direction direction) +{ + dma_unmap_sg(attachment->dev, table->sgl, table->nents, direction); +} + +static vm_fault_t dma_heap_vm_fault(struct vm_fault *vmf) +{ + struct vm_area_struct *vma = vmf->vma; + struct heap_helper_buffer *buffer = vma->vm_private_data; + + if (vmf->pgoff > buffer->pagecount) + return VM_FAULT_SIGBUS; + + vmf->page = buffer->pages[vmf->pgoff]; + get_page(vmf->page); + + return 0; +} + +static const struct vm_operations_struct dma_heap_vm_ops = { + .fault = dma_heap_vm_fault, +}; + +static int dma_heap_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) +{ + struct heap_helper_buffer *buffer = dmabuf->priv; + + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) + return -EINVAL; + + vma->vm_ops = &dma_heap_vm_ops; + vma->vm_private_data = buffer; + + return 0; +} + +static void dma_heap_dma_buf_release(struct dma_buf *dmabuf) +{ + struct heap_helper_buffer *buffer = dmabuf->priv; + + dma_heap_buffer_destroy(buffer); +} + +static int dma_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct heap_helper_buffer *buffer = dmabuf->priv; + struct dma_heaps_attachment *a; + int ret = 0; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + invalidate_kernel_vmap_range(buffer->vaddr, buffer->size); + + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sg_for_cpu(a->dev, a->table.sgl, a->table.nents, + direction); + } + mutex_unlock(&buffer->lock); + + return ret; +} + +static int dma_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct heap_helper_buffer *buffer = dmabuf->priv; + struct dma_heaps_attachment *a; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + flush_kernel_vmap_range(buffer->vaddr, buffer->size); + + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sg_for_device(a->dev, a->table.sgl, a->table.nents, + direction); + } + mutex_unlock(&buffer->lock); + + return 0; +} + +static void *dma_heap_dma_buf_vmap(struct dma_buf *dmabuf) +{ + struct heap_helper_buffer *buffer = dmabuf->priv; + void *vaddr; + + mutex_lock(&buffer->lock); + vaddr = dma_heap_buffer_vmap_get(buffer); + mutex_unlock(&buffer->lock); + + return vaddr; +} + +static void dma_heap_dma_buf_vunmap(struct dma_buf *dmabuf, void *vaddr) +{ + struct heap_helper_buffer *buffer = dmabuf->priv; + + mutex_lock(&buffer->lock); + dma_heap_buffer_vmap_put(buffer); + mutex_unlock(&buffer->lock); +} + +const struct dma_buf_ops heap_helper_ops = { + .map_dma_buf = dma_heap_map_dma_buf, + .unmap_dma_buf = dma_heap_unmap_dma_buf, + .mmap = dma_heap_mmap, + .release = dma_heap_dma_buf_release, + .attach = dma_heap_attach, + .detach = dma_heap_detach, + .begin_cpu_access = dma_heap_dma_buf_begin_cpu_access, + .end_cpu_access = dma_heap_dma_buf_end_cpu_access, + .vmap = dma_heap_dma_buf_vmap, + .vunmap = dma_heap_dma_buf_vunmap, +}; diff --git a/drivers/dma-buf/heaps/heap-helpers.h b/drivers/dma-buf/heaps/heap-helpers.h new file mode 100644 index 000000000000..805d2df88024 --- /dev/null +++ b/drivers/dma-buf/heaps/heap-helpers.h @@ -0,0 +1,53 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * DMABUF Heaps helper code + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ + +#ifndef _HEAP_HELPERS_H +#define _HEAP_HELPERS_H + +#include +#include + +/** + * struct heap_helper_buffer - helper buffer metadata + * @heap: back pointer to the heap the buffer came from + * @dmabuf: backing dma-buf for this buffer + * @size: size of the buffer + * @priv_virt pointer to heap specific private value + * @lock mutext to protect the data in this structure + * @vmap_cnt count of vmap references on the buffer + * @vaddr vmap'ed virtual address + * @pagecount number of pages in the buffer + * @pages list of page pointers + * @attachments list of device attachments + * + * @free heap callback to free the buffer + */ +struct heap_helper_buffer { + struct dma_heap *heap; + struct dma_buf *dmabuf; + size_t size; + + void *priv_virt; + struct mutex lock; + int vmap_cnt; + void *vaddr; + pgoff_t pagecount; + struct page **pages; + struct list_head attachments; + + void (*free)(struct heap_helper_buffer *buffer); +}; + +void init_heap_helper_buffer(struct heap_helper_buffer *buffer, + void (*free)(struct heap_helper_buffer *)); + +struct dma_buf *heap_helper_export_dmabuf(struct heap_helper_buffer *buffer, + int fd_flags); + +extern const struct dma_buf_ops heap_helper_ops; +#endif /* _HEAP_HELPERS_H */ -- 2.17.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=-9.8 required=3.0 tests=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 87183C5DF64 for ; Wed, 6 Nov 2019 04:23:17 +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 52FA02084C for ; Wed, 6 Nov 2019 04:23:17 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 52FA02084C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org 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 038A66EBEC; Wed, 6 Nov 2019 04:23:16 +0000 (UTC) Received: from mail-pf1-x443.google.com (mail-pf1-x443.google.com [IPv6:2607:f8b0:4864:20::443]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2FEC76EBEC for ; Wed, 6 Nov 2019 04:23:09 +0000 (UTC) Received: by mail-pf1-x443.google.com with SMTP id c13so17846335pfp.5 for ; Tue, 05 Nov 2019 20:23:09 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=457zRy8Q3s9wRgu8y/sPdERdJPxGVqMQEwUnz4TtqNA=; b=bMjlJo0tIXMgK2dNhQetzvahMl0NMGeWsy14eFBZI7zLG2GHngKc36nPPQugLtW0cz CVsXAyz60UIwu+AvZIT3IrwcxRjFykLUTpK9rwBPimB1aHmqJeywlABk9NDDtjfxffAZ UOjm39rWU2LFx0OCY6CQTsIIcLQytKMDPSOyn8AO09+AAZhpgGv/EZPa7zNVZq7JKDD9 oBHm/wYXZn6OojvOeSWEaOcRnmBHYU1o20GFsLu5ymTPqiau3OnLySoRdEFELrHpIFBQ 3rfGGoDRo5rXY+R6MJpWXPqFSdtFmanXhbkNq65wxrlh6T3I6zE6alLgF3ihf2dJ1kIr tYsQ== X-Gm-Message-State: APjAAAVALN22WQaUMjUGynzVo+gGy9JBDm/sJ4mPvyTFWbEFTpx6YuVv LzTIdszm8wb7Rwyav8Q+IAU3cA== X-Google-Smtp-Source: APXvYqxEVpGKes2M4yeN4NKEiS/7KmJE5pinYK2D3KkWYOw3gNOvS0Y6NZ71sMmhlImli5PsEVf4hw== X-Received: by 2002:a62:2f43:: with SMTP id v64mr730702pfv.13.1573014183726; Tue, 05 Nov 2019 20:23:03 -0800 (PST) Received: from localhost.localdomain (c-67-170-172-113.hsd1.or.comcast.net. [67.170.172.113]) by smtp.gmail.com with ESMTPSA id n15sm23730289pfq.146.2019.11.05.20.23.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Nov 2019 20:23:03 -0800 (PST) From: John Stultz To: lkml Subject: [PATCH v15 2/5] dma-buf: heaps: Add heap helpers Date: Wed, 6 Nov 2019 04:22:49 +0000 Message-Id: <20191106042252.72452-3-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20191106042252.72452-1-john.stultz@linaro.org> References: <20191106042252.72452-1-john.stultz@linaro.org> X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=457zRy8Q3s9wRgu8y/sPdERdJPxGVqMQEwUnz4TtqNA=; b=cYHuXTl9Ol149SzIVmlYNhJG5BWhM89aNnpaJd7dDgTk9piI2EoSeKuP36f3dnka4z Vk8rCOzbLDOHUZVtWH7TYE4FuPy7CcHPduI9q8ukSl7ZxvJFdhtrjFX8iFI/iaga/Rzo qZlYPTQdl5AFk5ekgab2O8My52wE6AlEhLVmdtFTJhXZlvF/9yMmcfFTdBR1i9rIO65R kc21Z6fWYaS8yftLvD9Tgfx27KI3YPj09QfJEA8tAKwjla+wp0jT1zjfzav2cHx/xRTA XHCJFzMUbUI4ubLo78i1AgFn5yop+73lpxG21WclcJtXxOoBEh7E0F5WpNPxPIv3Txjb Lp8A== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Hillf Danton , Sudipto Paul , Sandeep Patil , Vincent Donnefort , Chenbo Feng , Alistair Strachan , Liam Mark , Christoph Hellwig , dri-devel@lists.freedesktop.org, "Andrew F . Davis" , Hridya Valsaraju , Pratik Patel MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191106042249.T14mxyoBu0m9l78yxo6X2IugZwWAt4xoN7h7hQbgRu0@z> QWRkIGdlbmVyaWMgaGVscGVyIGRtYWJ1ZiBvcHMgZm9yIGRtYSBoZWFwcywgc28gd2UgY2FuIHJl ZHVjZQp0aGUgYW1vdW50IG9mIGR1cGxpY2F0aXZlIGNvZGUgZm9yIHRoZSBleHBvcnRlZCBkbWFi dWZzLgoKVGhpcyBjb2RlIGlzIGFuIGV2b2x1dGlvbiBvZiB0aGUgQW5kcm9pZCBJT04gaW1wbGVt ZW50YXRpb24sIHNvCnRoYW5rcyB0byBpdHMgb3JpZ2luYWwgYXV0aG9ycyBhbmQgbWFpbnRhaW50 ZXJzOgogIFJlYmVjY2EgU2NodWx0eiBaYXZpbiwgQ29saW4gQ3Jvc3MsIExhdXJhIEFiYm90dCwg YW5kIG90aGVycyEKCkNjOiBMYXVyYSBBYmJvdHQgPGxhYmJvdHRAcmVkaGF0LmNvbT4KQ2M6IEJl bmphbWluIEdhaWduYXJkIDxiZW5qYW1pbi5nYWlnbmFyZEBsaW5hcm8ub3JnPgpDYzogU3VtaXQg U2Vtd2FsIDxzdW1pdC5zZW13YWxAbGluYXJvLm9yZz4KQ2M6IExpYW0gTWFyayA8bG1hcmtAY29k ZWF1cm9yYS5vcmc+CkNjOiBQcmF0aWsgUGF0ZWwgPHByYXRpa3BAY29kZWF1cm9yYS5vcmc+CkNj OiBCcmlhbiBTdGFya2V5IDxCcmlhbi5TdGFya2V5QGFybS5jb20+CkNjOiBWaW5jZW50IERvbm5l Zm9ydCA8VmluY2VudC5Eb25uZWZvcnRAYXJtLmNvbT4KQ2M6IFN1ZGlwdG8gUGF1bCA8U3VkaXB0 by5QYXVsQGFybS5jb20+CkNjOiBBbmRyZXcgRi4gRGF2aXMgPGFmZEB0aS5jb20+CkNjOiBDaHJp c3RvcGggSGVsbHdpZyA8aGNoQGluZnJhZGVhZC5vcmc+CkNjOiBDaGVuYm8gRmVuZyA8ZmVuZ2NA Z29vZ2xlLmNvbT4KQ2M6IEFsaXN0YWlyIFN0cmFjaGFuIDxhc3RyYWNoYW5AZ29vZ2xlLmNvbT4K Q2M6IEhyaWR5YSBWYWxzYXJhanUgPGhyaWR5YUBnb29nbGUuY29tPgpDYzogU2FuZGVlcCBQYXRp bCA8c3NwYXRpbEBnb29nbGUuY29tPgpDYzogSGlsbGYgRGFudG9uIDxoZGFudG9uQHNpbmEuY29t PgpDYzogRGF2ZSBBaXJsaWUgPGFpcmxpZWRAZ21haWwuY29tPgpDYzogZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpSZXZpZXdlZC1ieTogQmVuamFtaW4gR2FpZ25hcmQgPGJlbmphbWlu LmdhaWduYXJkQGxpbmFyby5vcmc+ClJldmlld2VkLWJ5OiBCcmlhbiBTdGFya2V5IDxicmlhbi5z dGFya2V5QGFybS5jb20+CkFja2VkLWJ5OiBTYW5kZWVwIFBhdGlsIDxzc3BhdGlsQGFuZHJvaWQu Y29tPgpBY2tlZC1ieTogTGF1cmEgQWJib3R0IDxsYWJib3R0QHJlZGhhdC5jb20+ClRlc3RlZC1i eTogQXlhbiBLdW1hciBIYWxkZXIgPGF5YW4uaGFsZGVyQGFybS5jb20+ClNpZ25lZC1vZmYtYnk6 IEpvaG4gU3R1bHR6IDxqb2huLnN0dWx0ekBsaW5hcm8ub3JnPgotLS0KdjI6CiogUmVtb3ZlZCBj YWNoZSBtYW5hZ2VtZW50IHBlcmZvcm1hbmNlIGhhY2sgdGhhdCBJIGhhZAogIGFjY2lkZW50YWxs eSBmb2xkZWQgaW4uCiogUmVtb3ZlZCBzdGF0cyBjb2RlIHRoYXQgd2FzIGluIGhlbHBlcnMKKiBM b3RzIG9mIGNoZWNrcGF0Y2ggY2xlYW51cHMKdjM6CiogVW5pbmxpbmUgSU5JVF9IRUFQX0hFTFBF Ul9CVUZGRVIgKHN1Z2dlc3RlZCBieSBDaHJpc3RvcGgpCiogU3dpdGNoIHRvIFdBUk4gb24gYnVm ZmVyIGRlc3Ryb3kgZmFpbHVyZSAoc3VnZ2VzdGVkIGJ5IEJyaWFuKQoqIGJ1ZmZlci0+a21hcF9j bnQgZGVjcmVtZW50aW5nIGNsZWFudXAgKHN1Z2dlc3RlZCBieSBDaHJpc3RvcGgpCiogRXh0cmEg YnVmZmVyLT52YWRkciBjaGVja2luZyBpbiBkbWFfaGVhcF9kbWFfYnVmX2ttYXAKICAoc3VnZ2Vz dGVkIGJ5IEJyaWFuKQoqIFN3aXRjaCB0b19oZWxwZXJfYnVmZmVyIGZyb20gbWFjcm8gdG8gaW5s aW5lIGZ1bmN0aW9uCiAgKHN1Z2dlc3RlZCBieSBCZW5qYW1pbikKKiBSZW5hbWUga21hcC0+dm1h cCAoZm9sZGVkIGluIGZyb20gQW5kcmV3KQoqIFVzZSB2bWFwIGZvciB2bWFwcGluZyAtIG5vdCBi ZWdpbl9jcHVfYWNjZXNzIChmb2xkZWQgaW4gZnJvbQogIEFuZHJldykKKiBEcm9wIGttYXAgZm9y IG5vdywgYXMgaXRzIG9wdGlvbmFsIChmb2xkZWQgaW4gZnJvbSBBbmRyZXcpCiogRm9sZCBkbWFf aGVhcF9tYXBfdXNlciBpbnRvIHRoZSBzaW5nbGUgY2FsbGVyIChmb2xlZCBpbiBmcm9tCiAgQW5k cmV3KQoqIEZvbGRlZCBpbiBwYXRjaCBmcm9tIEFuZHJldyB0byB0cmFjayBwYWdlIGxpc3QgcGVy IGhlYXAgbm90CiAgc2dsaXN0LCB3aGljaCBzaW1wbGlmaWVzIHRoZSB0cmFja2luZyBsb2dpYwp2 NDoKKiBNb3ZlZCBkbWEtaGVhcC5oIGNoYW5nZSBvdXQgdG8gcHJldmlvdXMgcGF0Y2gKdjY6Ciog TWlub3IgY2xlYW51cHMgYW5kIHR5cG8gZml4ZXMgc3VnZ2VzdGVkIGJ5IEJyaWFuCnY3OgoqIFJl bW92ZWQgc3RyYXkgOwoqIE1ha2UgaW5pdF9oZWFwX2hlbHBlcl9idWZmZXIgbG93ZXJjYXNlLCBh cyBzdWdnZXN0ZWQgYnkgQ2hyaXN0b3BoCiogQWRkIGRtYWJ1ZiBleHBvcnQgaGVscGVyIHRvIHJl ZHVjZSBib2lsZXJwbGF0ZSBjb2RlCnY4OgoqIFJlbW92ZSB1bnVzZWQgcHJpdmF0ZV9mbGFncyB2 YWx1ZQoqIENvbmRlbnNlIGRtYV9oZWFwX2J1ZmZlciBhbmQgaGVhcF9oZWxwZXJfYnVmZmVyIChz dWdnZXN0ZWQgYnkKICBDaHJpc3RvcGgpCiogRml4IGluZGVudGF0aW9uIGJ5IHVzaW5nIHNob3J0 ZXIgYXJndW1lbnQgbmFtZXMgKHN1Z2dlc3RlZCBieQogIENocmlzdG9waCkKKiBBZGQgZmx1c2hf a2VybmVsX3ZtYXBfcmFuZ2UvaW52YWxpZGF0ZV9rZXJuZWxfdm1hcF9yYW5nZSBjYWxscwogIChz dWdnZXN0ZWQgYnkgQ2hyaXN0b3BoKQoqIENoZWNrcGF0Y2ggd2hpdGVzcGFjZSBmaXh1cHMKdjk6 CiogTWlub3IgY2xlYW51cHMgc3VnZ2VzdGVkIGJ5IEJyaWFuIFN0YXJrZXkKdjEwOgoqIEZpeCBt aXNzaW5nIHZtYWxsb2MuaCBpbmNsdXNpb24gaW4gaGVhcCBoZWxwZXJzIChmb3VuZCBieQogIGti dWlsZCB0ZXN0IHJvYm90IDxsa3BAaW50ZWwuY29tPikKdjEyOgoqIEFkZCBzeW1ib2wgZXhwb3J0 cyBmb3IgaGVhcHMgYXMgbW9kdWxlcwp2MTM6CiogUmUtcmVtb3ZlIHN5bWJvbCBleHBvcnRzLCBw ZXIgZGlzY3Vzc2lvbiB3aXRoIEJyaWFuLCBhcyBJJ2xsCiAgcmVzdWJtaXQgdGhlIGNoYW5nZSBm b3IgcmV2aWV3IGluZGVwZW5kZW50bHkuCnYxNDoKKiBGaXggbWlzc2luZyBhcmdtZW50IHRvIFdB Uk4oKSBpbiBkbWFfaGVhcF9idWZmZXJfZGVzdHJveSgpCiAgZm91bmQgYW5kIGZpeGVkIGJ5IERh biBDYXJwZW50ZXIgPGRhbi5jYXJwZW50ZXJAb3JhY2xlLmNvbT4KKiBBZGQgY2hlY2sgaW4gZmF1 bHQgaGFubGRlciB0aGF0IHBnb2ZmIGlzbid0IGxhcmdlciB0aGVuCiAgcGFnZWNvdW50LCByZXBv cnRlZCBieSBEYW4gQ2FycGVudGVyCnYxNToKKiBEcm9wIHVudXNlZCBmbGFncyBmaWVsZCBmcm9t IGhlYXBfaGVscGVyX2J1ZmZlciBhcyBzdWdnZXN0ZWQKICBieSBTYW5kZWVwIFBhdGlsCi0tLQog ZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlICAgICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvZG1h LWJ1Zi9oZWFwcy9NYWtlZmlsZSAgICAgICB8ICAgMiArCiBkcml2ZXJzL2RtYS1idWYvaGVhcHMv aGVhcC1oZWxwZXJzLmMgfCAyNzEgKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJz L2RtYS1idWYvaGVhcHMvaGVhcC1oZWxwZXJzLmggfCAgNTMgKysrKysrCiA0IGZpbGVzIGNoYW5n ZWQsIDMyNyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVm L2hlYXBzL01ha2VmaWxlCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2hlYXBz L2hlYXAtaGVscGVycy5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2hlYXBz L2hlYXAtaGVscGVycy5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlIGIv ZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlCmluZGV4IGNhZWU1ZWIzZDM1MS4uOWMxOTAwMjZiZmFi IDEwMDY0NAotLS0gYS9kcml2ZXJzL2RtYS1idWYvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9kbWEt YnVmL01ha2VmaWxlCkBAIC0yLDYgKzIsNyBAQAogb2JqLXkgOj0gZG1hLWJ1Zi5vIGRtYS1mZW5j ZS5vIGRtYS1mZW5jZS1hcnJheS5vIGRtYS1mZW5jZS1jaGFpbi5vIFwKIAkgZG1hLXJlc3YubyBz ZXFuby1mZW5jZS5vCiBvYmotJChDT05GSUdfRE1BQlVGX0hFQVBTKQkrPSBkbWEtaGVhcC5vCitv YmotJChDT05GSUdfRE1BQlVGX0hFQVBTKQkrPSBoZWFwcy8KIG9iai0kKENPTkZJR19TWU5DX0ZJ TEUpCQkrPSBzeW5jX2ZpbGUubwogb2JqLSQoQ09ORklHX1NXX1NZTkMpCQkrPSBzd19zeW5jLm8g c3luY19kZWJ1Zy5vCiBvYmotJChDT05GSUdfVURNQUJVRikJCSs9IHVkbWFidWYubwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9kbWEtYnVmL2hlYXBzL01ha2VmaWxlIGIvZHJpdmVycy9kbWEtYnVmL2hl YXBzL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZGU0 OTg5ODExMmRiCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9kbWEtYnVmL2hlYXBzL01ha2Vm aWxlCkBAIC0wLDAgKzEsMiBAQAorIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAor b2JqLXkJCQkJCSs9IGhlYXAtaGVscGVycy5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYv aGVhcHMvaGVhcC1oZWxwZXJzLmMgYi9kcml2ZXJzL2RtYS1idWYvaGVhcHMvaGVhcC1oZWxwZXJz LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45Zjk2NGNhM2Y1OWMK LS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2RtYS1idWYvaGVhcHMvaGVhcC1oZWxwZXJzLmMK QEAgLTAsMCArMSwyNzEgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisj aW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvZG1hLWJ1Zi5oPgorI2lu Y2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L2hpZ2htZW0uaD4KKyNpbmNsdWRl IDxsaW51eC9pZHIuaD4KKyNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CisjaW5jbHVkZSA8bGludXgv c2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC92bWFs bG9jLmg+CisjaW5jbHVkZSA8dWFwaS9saW51eC9kbWEtaGVhcC5oPgorCisjaW5jbHVkZSAiaGVh cC1oZWxwZXJzLmgiCisKK3ZvaWQgaW5pdF9oZWFwX2hlbHBlcl9idWZmZXIoc3RydWN0IGhlYXBf aGVscGVyX2J1ZmZlciAqYnVmZmVyLAorCQkJICAgICB2b2lkICgqZnJlZSkoc3RydWN0IGhlYXBf aGVscGVyX2J1ZmZlciAqKSkKK3sKKwlidWZmZXItPnByaXZfdmlydCA9IE5VTEw7CisJbXV0ZXhf aW5pdCgmYnVmZmVyLT5sb2NrKTsKKwlidWZmZXItPnZtYXBfY250ID0gMDsKKwlidWZmZXItPnZh ZGRyID0gTlVMTDsKKwlidWZmZXItPnBhZ2Vjb3VudCA9IDA7CisJYnVmZmVyLT5wYWdlcyA9IE5V TEw7CisJSU5JVF9MSVNUX0hFQUQoJmJ1ZmZlci0+YXR0YWNobWVudHMpOworCWJ1ZmZlci0+ZnJl ZSA9IGZyZWU7Cit9CisKK3N0cnVjdCBkbWFfYnVmICpoZWFwX2hlbHBlcl9leHBvcnRfZG1hYnVm KHN0cnVjdCBoZWFwX2hlbHBlcl9idWZmZXIgKmJ1ZmZlciwKKwkJCQkJICBpbnQgZmRfZmxhZ3Mp Cit7CisJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8oZXhwX2luZm8pOworCisJZXhwX2luZm8u b3BzID0gJmhlYXBfaGVscGVyX29wczsKKwlleHBfaW5mby5zaXplID0gYnVmZmVyLT5zaXplOwor CWV4cF9pbmZvLmZsYWdzID0gZmRfZmxhZ3M7CisJZXhwX2luZm8ucHJpdiA9IGJ1ZmZlcjsKKwor CXJldHVybiBkbWFfYnVmX2V4cG9ydCgmZXhwX2luZm8pOworfQorCitzdGF0aWMgdm9pZCAqZG1h X2hlYXBfbWFwX2tlcm5lbChzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIpCit7CisJ dm9pZCAqdmFkZHI7CisKKwl2YWRkciA9IHZtYXAoYnVmZmVyLT5wYWdlcywgYnVmZmVyLT5wYWdl Y291bnQsIFZNX01BUCwgUEFHRV9LRVJORUwpOworCWlmICghdmFkZHIpCisJCXJldHVybiBFUlJf UFRSKC1FTk9NRU0pOworCisJcmV0dXJuIHZhZGRyOworfQorCitzdGF0aWMgdm9pZCBkbWFfaGVh cF9idWZmZXJfZGVzdHJveShzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIpCit7CisJ aWYgKGJ1ZmZlci0+dm1hcF9jbnQgPiAwKSB7CisJCVdBUk4oMSwgIiVzOiBidWZmZXIgc3RpbGwg bWFwcGVkIGluIHRoZSBrZXJuZWxcbiIsIF9fZnVuY19fKTsKKwkJdnVubWFwKGJ1ZmZlci0+dmFk ZHIpOworCX0KKworCWJ1ZmZlci0+ZnJlZShidWZmZXIpOworfQorCitzdGF0aWMgdm9pZCAqZG1h X2hlYXBfYnVmZmVyX3ZtYXBfZ2V0KHN0cnVjdCBoZWFwX2hlbHBlcl9idWZmZXIgKmJ1ZmZlcikK K3sKKwl2b2lkICp2YWRkcjsKKworCWlmIChidWZmZXItPnZtYXBfY250KSB7CisJCWJ1ZmZlci0+ dm1hcF9jbnQrKzsKKwkJcmV0dXJuIGJ1ZmZlci0+dmFkZHI7CisJfQorCXZhZGRyID0gZG1hX2hl YXBfbWFwX2tlcm5lbChidWZmZXIpOworCWlmIChJU19FUlIodmFkZHIpKQorCQlyZXR1cm4gdmFk ZHI7CisJYnVmZmVyLT52YWRkciA9IHZhZGRyOworCWJ1ZmZlci0+dm1hcF9jbnQrKzsKKwlyZXR1 cm4gdmFkZHI7Cit9CisKK3N0YXRpYyB2b2lkIGRtYV9oZWFwX2J1ZmZlcl92bWFwX3B1dChzdHJ1 Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIpCit7CisJaWYgKCEtLWJ1ZmZlci0+dm1hcF9j bnQpIHsKKwkJdnVubWFwKGJ1ZmZlci0+dmFkZHIpOworCQlidWZmZXItPnZhZGRyID0gTlVMTDsK Kwl9Cit9CisKK3N0cnVjdCBkbWFfaGVhcHNfYXR0YWNobWVudCB7CisJc3RydWN0IGRldmljZSAq ZGV2OworCXN0cnVjdCBzZ190YWJsZSB0YWJsZTsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7Cit9 OworCitzdGF0aWMgaW50IGRtYV9oZWFwX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAor CQkJICAgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNobWVudCkKK3sKKwlzdHJ1Y3Qg ZG1hX2hlYXBzX2F0dGFjaG1lbnQgKmE7CisJc3RydWN0IGhlYXBfaGVscGVyX2J1ZmZlciAqYnVm ZmVyID0gZG1hYnVmLT5wcml2OworCWludCByZXQ7CisKKwlhID0ga3phbGxvYyhzaXplb2YoKmEp LCBHRlBfS0VSTkVMKTsKKwlpZiAoIWEpCisJCXJldHVybiAtRU5PTUVNOworCisJcmV0ID0gc2df YWxsb2NfdGFibGVfZnJvbV9wYWdlcygmYS0+dGFibGUsIGJ1ZmZlci0+cGFnZXMsCisJCQkJCWJ1 ZmZlci0+cGFnZWNvdW50LCAwLAorCQkJCQlidWZmZXItPnBhZ2Vjb3VudCA8PCBQQUdFX1NISUZU LAorCQkJCQlHRlBfS0VSTkVMKTsKKwlpZiAocmV0KSB7CisJCWtmcmVlKGEpOworCQlyZXR1cm4g cmV0OworCX0KKworCWEtPmRldiA9IGF0dGFjaG1lbnQtPmRldjsKKwlJTklUX0xJU1RfSEVBRCgm YS0+bGlzdCk7CisKKwlhdHRhY2htZW50LT5wcml2ID0gYTsKKworCW11dGV4X2xvY2soJmJ1ZmZl ci0+bG9jayk7CisJbGlzdF9hZGQoJmEtPmxpc3QsICZidWZmZXItPmF0dGFjaG1lbnRzKTsKKwlt dXRleF91bmxvY2soJmJ1ZmZlci0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZv aWQgZG1hX2hlYXBfZGV0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCisJCQkgICAgc3RydWN0 IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNobWVudCkKK3sKKwlzdHJ1Y3QgZG1hX2hlYXBzX2F0 dGFjaG1lbnQgKmEgPSBhdHRhY2htZW50LT5wcml2OworCXN0cnVjdCBoZWFwX2hlbHBlcl9idWZm ZXIgKmJ1ZmZlciA9IGRtYWJ1Zi0+cHJpdjsKKworCW11dGV4X2xvY2soJmJ1ZmZlci0+bG9jayk7 CisJbGlzdF9kZWwoJmEtPmxpc3QpOworCW11dGV4X3VubG9jaygmYnVmZmVyLT5sb2NrKTsKKwor CXNnX2ZyZWVfdGFibGUoJmEtPnRhYmxlKTsKKwlrZnJlZShhKTsKK30KKworc3RhdGljCitzdHJ1 Y3Qgc2dfdGFibGUgKmRtYV9oZWFwX21hcF9kbWFfYnVmKHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1l bnQgKmF0dGFjaG1lbnQsCisJCQkJICAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyZWN0 aW9uKQoreworCXN0cnVjdCBkbWFfaGVhcHNfYXR0YWNobWVudCAqYSA9IGF0dGFjaG1lbnQtPnBy aXY7CisJc3RydWN0IHNnX3RhYmxlICp0YWJsZTsKKworCXRhYmxlID0gJmEtPnRhYmxlOworCisJ aWYgKCFkbWFfbWFwX3NnKGF0dGFjaG1lbnQtPmRldiwgdGFibGUtPnNnbCwgdGFibGUtPm5lbnRz LAorCQkJZGlyZWN0aW9uKSkKKwkJdGFibGUgPSBFUlJfUFRSKC1FTk9NRU0pOworCXJldHVybiB0 YWJsZTsKK30KKworc3RhdGljIHZvaWQgZG1hX2hlYXBfdW5tYXBfZG1hX2J1ZihzdHJ1Y3QgZG1h X2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50LAorCQkJCSAgIHN0cnVjdCBzZ190YWJsZSAqdGFi bGUsCisJCQkJICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyZWN0aW9uKQoreworCWRtYV91 bm1hcF9zZyhhdHRhY2htZW50LT5kZXYsIHRhYmxlLT5zZ2wsIHRhYmxlLT5uZW50cywgZGlyZWN0 aW9uKTsKK30KKworc3RhdGljIHZtX2ZhdWx0X3QgZG1hX2hlYXBfdm1fZmF1bHQoc3RydWN0IHZt X2ZhdWx0ICp2bWYpCit7CisJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEgPSB2bWYtPnZtYTsK KwlzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIgPSB2bWEtPnZtX3ByaXZhdGVfZGF0 YTsKKworCWlmICh2bWYtPnBnb2ZmID4gYnVmZmVyLT5wYWdlY291bnQpCisJCXJldHVybiBWTV9G QVVMVF9TSUdCVVM7CisKKwl2bWYtPnBhZ2UgPSBidWZmZXItPnBhZ2VzW3ZtZi0+cGdvZmZdOwor CWdldF9wYWdlKHZtZi0+cGFnZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0 cnVjdCB2bV9vcGVyYXRpb25zX3N0cnVjdCBkbWFfaGVhcF92bV9vcHMgPSB7CisJLmZhdWx0ID0g ZG1hX2hlYXBfdm1fZmF1bHQsCit9OworCitzdGF0aWMgaW50IGRtYV9oZWFwX21tYXAoc3RydWN0 IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0 IGhlYXBfaGVscGVyX2J1ZmZlciAqYnVmZmVyID0gZG1hYnVmLT5wcml2OworCisJaWYgKCh2bWEt PnZtX2ZsYWdzICYgKFZNX1NIQVJFRCB8IFZNX01BWVNIQVJFKSkgPT0gMCkKKwkJcmV0dXJuIC1F SU5WQUw7CisKKwl2bWEtPnZtX29wcyA9ICZkbWFfaGVhcF92bV9vcHM7CisJdm1hLT52bV9wcml2 YXRlX2RhdGEgPSBidWZmZXI7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgZG1hX2hl YXBfZG1hX2J1Zl9yZWxlYXNlKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCit7CisJc3RydWN0IGhl YXBfaGVscGVyX2J1ZmZlciAqYnVmZmVyID0gZG1hYnVmLT5wcml2OworCisJZG1hX2hlYXBfYnVm ZmVyX2Rlc3Ryb3koYnVmZmVyKTsKK30KKworc3RhdGljIGludCBkbWFfaGVhcF9kbWFfYnVmX2Jl Z2luX2NwdV9hY2Nlc3Moc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwKKwkJCQkJICAgICBlbnVtIGRt YV9kYXRhX2RpcmVjdGlvbiBkaXJlY3Rpb24pCit7CisJc3RydWN0IGhlYXBfaGVscGVyX2J1ZmZl ciAqYnVmZmVyID0gZG1hYnVmLT5wcml2OworCXN0cnVjdCBkbWFfaGVhcHNfYXR0YWNobWVudCAq YTsKKwlpbnQgcmV0ID0gMDsKKworCW11dGV4X2xvY2soJmJ1ZmZlci0+bG9jayk7CisKKwlpZiAo YnVmZmVyLT52bWFwX2NudCkKKwkJaW52YWxpZGF0ZV9rZXJuZWxfdm1hcF9yYW5nZShidWZmZXIt PnZhZGRyLCBidWZmZXItPnNpemUpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShhLCAmYnVmZmVy LT5hdHRhY2htZW50cywgbGlzdCkgeworCQlkbWFfc3luY19zZ19mb3JfY3B1KGEtPmRldiwgYS0+ dGFibGUuc2dsLCBhLT50YWJsZS5uZW50cywKKwkJCQkgICAgZGlyZWN0aW9uKTsKKwl9CisJbXV0 ZXhfdW5sb2NrKCZidWZmZXItPmxvY2spOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGlu dCBkbWFfaGVhcF9kbWFfYnVmX2VuZF9jcHVfYWNjZXNzKHN0cnVjdCBkbWFfYnVmICpkbWFidWYs CisJCQkJCSAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikKK3sKKwlzdHJ1Y3Qg aGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7CisJc3RydWN0IGRtYV9o ZWFwc19hdHRhY2htZW50ICphOworCisJbXV0ZXhfbG9jaygmYnVmZmVyLT5sb2NrKTsKKworCWlm IChidWZmZXItPnZtYXBfY250KQorCQlmbHVzaF9rZXJuZWxfdm1hcF9yYW5nZShidWZmZXItPnZh ZGRyLCBidWZmZXItPnNpemUpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShhLCAmYnVmZmVyLT5h dHRhY2htZW50cywgbGlzdCkgeworCQlkbWFfc3luY19zZ19mb3JfZGV2aWNlKGEtPmRldiwgYS0+ dGFibGUuc2dsLCBhLT50YWJsZS5uZW50cywKKwkJCQkgICAgICAgZGlyZWN0aW9uKTsKKwl9CisJ bXV0ZXhfdW5sb2NrKCZidWZmZXItPmxvY2spOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2 b2lkICpkbWFfaGVhcF9kbWFfYnVmX3ZtYXAoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKK3sKKwlz dHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7CisJdm9pZCAq dmFkZHI7CisKKwltdXRleF9sb2NrKCZidWZmZXItPmxvY2spOworCXZhZGRyID0gZG1hX2hlYXBf YnVmZmVyX3ZtYXBfZ2V0KGJ1ZmZlcik7CisJbXV0ZXhfdW5sb2NrKCZidWZmZXItPmxvY2spOwor CisJcmV0dXJuIHZhZGRyOworfQorCitzdGF0aWMgdm9pZCBkbWFfaGVhcF9kbWFfYnVmX3Z1bm1h cChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCB2b2lkICp2YWRkcikKK3sKKwlzdHJ1Y3QgaGVhcF9o ZWxwZXJfYnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7CisKKwltdXRleF9sb2NrKCZidWZm ZXItPmxvY2spOworCWRtYV9oZWFwX2J1ZmZlcl92bWFwX3B1dChidWZmZXIpOworCW11dGV4X3Vu bG9jaygmYnVmZmVyLT5sb2NrKTsKK30KKworY29uc3Qgc3RydWN0IGRtYV9idWZfb3BzIGhlYXBf aGVscGVyX29wcyA9IHsKKwkubWFwX2RtYV9idWYgPSBkbWFfaGVhcF9tYXBfZG1hX2J1ZiwKKwku dW5tYXBfZG1hX2J1ZiA9IGRtYV9oZWFwX3VubWFwX2RtYV9idWYsCisJLm1tYXAgPSBkbWFfaGVh cF9tbWFwLAorCS5yZWxlYXNlID0gZG1hX2hlYXBfZG1hX2J1Zl9yZWxlYXNlLAorCS5hdHRhY2gg PSBkbWFfaGVhcF9hdHRhY2gsCisJLmRldGFjaCA9IGRtYV9oZWFwX2RldGFjaCwKKwkuYmVnaW5f Y3B1X2FjY2VzcyA9IGRtYV9oZWFwX2RtYV9idWZfYmVnaW5fY3B1X2FjY2VzcywKKwkuZW5kX2Nw dV9hY2Nlc3MgPSBkbWFfaGVhcF9kbWFfYnVmX2VuZF9jcHVfYWNjZXNzLAorCS52bWFwID0gZG1h X2hlYXBfZG1hX2J1Zl92bWFwLAorCS52dW5tYXAgPSBkbWFfaGVhcF9kbWFfYnVmX3Z1bm1hcCwK K307CmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvaGVhcHMvaGVhcC1oZWxwZXJzLmggYi9k cml2ZXJzL2RtYS1idWYvaGVhcHMvaGVhcC1oZWxwZXJzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi44MDVkMmRmODgwMjQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL2RtYS1idWYvaGVhcHMvaGVhcC1oZWxwZXJzLmgKQEAgLTAsMCArMSw1MyBAQAorLyogU1BE WC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KKy8qCisgKiBETUFCVUYgSGVhcHMgaGVs cGVyIGNvZGUKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlLCBJbmMuCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTkgTGluYXJvIEx0ZC4KKyAqLworCisjaWZuZGVmIF9IRUFQX0hFTFBFUlNf SAorI2RlZmluZSBfSEVBUF9IRUxQRVJTX0gKKworI2luY2x1ZGUgPGxpbnV4L2RtYS1oZWFwLmg+ CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorCisvKioKKyAqIHN0cnVjdCBoZWFwX2hlbHBlcl9i dWZmZXIgLSBoZWxwZXIgYnVmZmVyIG1ldGFkYXRhCisgKiBAaGVhcDoJCWJhY2sgcG9pbnRlciB0 byB0aGUgaGVhcCB0aGUgYnVmZmVyIGNhbWUgZnJvbQorICogQGRtYWJ1ZjoJCWJhY2tpbmcgZG1h LWJ1ZiBmb3IgdGhpcyBidWZmZXIKKyAqIEBzaXplOgkJc2l6ZSBvZiB0aGUgYnVmZmVyCisgKiBA cHJpdl92aXJ0CQlwb2ludGVyIHRvIGhlYXAgc3BlY2lmaWMgcHJpdmF0ZSB2YWx1ZQorICogQGxv Y2sJCW11dGV4dCB0byBwcm90ZWN0IHRoZSBkYXRhIGluIHRoaXMgc3RydWN0dXJlCisgKiBAdm1h cF9jbnQJCWNvdW50IG9mIHZtYXAgcmVmZXJlbmNlcyBvbiB0aGUgYnVmZmVyCisgKiBAdmFkZHIJ CXZtYXAnZWQgdmlydHVhbCBhZGRyZXNzCisgKiBAcGFnZWNvdW50CQludW1iZXIgb2YgcGFnZXMg aW4gdGhlIGJ1ZmZlcgorICogQHBhZ2VzCQlsaXN0IG9mIHBhZ2UgcG9pbnRlcnMKKyAqIEBhdHRh Y2htZW50cwkJbGlzdCBvZiBkZXZpY2UgYXR0YWNobWVudHMKKyAqCisgKiBAZnJlZQkJaGVhcCBj YWxsYmFjayB0byBmcmVlIHRoZSBidWZmZXIKKyAqLworc3RydWN0IGhlYXBfaGVscGVyX2J1ZmZl ciB7CisJc3RydWN0IGRtYV9oZWFwICpoZWFwOworCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7CisJ c2l6ZV90IHNpemU7CisKKwl2b2lkICpwcml2X3ZpcnQ7CisJc3RydWN0IG11dGV4IGxvY2s7CisJ aW50IHZtYXBfY250OworCXZvaWQgKnZhZGRyOworCXBnb2ZmX3QgcGFnZWNvdW50OworCXN0cnVj dCBwYWdlICoqcGFnZXM7CisJc3RydWN0IGxpc3RfaGVhZCBhdHRhY2htZW50czsKKworCXZvaWQg KCpmcmVlKShzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIpOworfTsKKwordm9pZCBp bml0X2hlYXBfaGVscGVyX2J1ZmZlcihzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIs CisJCQkgICAgIHZvaWQgKCpmcmVlKShzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICopKTsKKwor c3RydWN0IGRtYV9idWYgKmhlYXBfaGVscGVyX2V4cG9ydF9kbWFidWYoc3RydWN0IGhlYXBfaGVs cGVyX2J1ZmZlciAqYnVmZmVyLAorCQkJCQkgIGludCBmZF9mbGFncyk7CisKK2V4dGVybiBjb25z dCBzdHJ1Y3QgZG1hX2J1Zl9vcHMgaGVhcF9oZWxwZXJfb3BzOworI2VuZGlmIC8qIF9IRUFQX0hF TFBFUlNfSCAqLwotLSAKMi4xNy4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVl ZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9kcmktZGV2ZWw=