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=-12.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_PASS 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 39842C43381 for ; Wed, 6 Mar 2019 16:28:03 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id DEC05206DD for ; Wed, 6 Mar 2019 16:28:02 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ti.com header.i=@ti.com header.b="lItDvPI5" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729654AbfCFQ2B (ORCPT ); Wed, 6 Mar 2019 11:28:01 -0500 Received: from lelv0142.ext.ti.com ([198.47.23.249]:38434 "EHLO lelv0142.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726127AbfCFQ2A (ORCPT ); Wed, 6 Mar 2019 11:28:00 -0500 Received: from fllv0034.itg.ti.com ([10.64.40.246]) by lelv0142.ext.ti.com (8.15.2/8.15.2) with ESMTP id x26GRaXG088164; Wed, 6 Mar 2019 10:27:36 -0600 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ti.com; s=ti-com-17Q1; t=1551889656; bh=GFtA1WVTXkEvZF9ttsy/ei+tARYzCwLjXNQ0v8YedUU=; h=Subject:To:CC:References:From:Date:In-Reply-To; b=lItDvPI5m/QmrQemnWfBMIf0FdynvqAljQv0ojBzYBhouM5V6dkK6T8XxUDbRRfmh PBkOg+7nSThb8flRUSolRLCHREg9NsKVp7oKuuzNy1ckupm9rszcwMw35Pq+Do/Zmb nxiLn3ktZ+hnAaKhT+9QKXRs+evlw9y5AY6Fb0S8= Received: from DFLE102.ent.ti.com (dfle102.ent.ti.com [10.64.6.23]) by fllv0034.itg.ti.com (8.15.2/8.15.2) with ESMTPS id x26GRad8099863 (version=TLSv1.2 cipher=AES256-GCM-SHA384 bits=256 verify=FAIL); Wed, 6 Mar 2019 10:27:36 -0600 Received: from DFLE109.ent.ti.com (10.64.6.30) by DFLE102.ent.ti.com (10.64.6.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1591.10; Wed, 6 Mar 2019 10:27:35 -0600 Received: from dflp33.itg.ti.com (10.64.6.16) by DFLE109.ent.ti.com (10.64.6.30) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1591.10 via Frontend Transport; Wed, 6 Mar 2019 10:27:35 -0600 Received: from [172.22.114.173] (ileax41-snat.itg.ti.com [10.172.224.153]) by dflp33.itg.ti.com (8.14.3/8.13.8) with ESMTP id x26GRYt6014104; Wed, 6 Mar 2019 10:27:35 -0600 Subject: Re: [RFC][PATCH 1/5 v2] dma-buf: Add dma-buf heaps framework To: John Stultz , lkml CC: Laura Abbott , Benjamin Gaignard , Greg KH , Sumit Semwal , Liam Mark , Brian Starkey , Chenbo Feng , Alistair Strachan , References: <1551819273-640-1-git-send-email-john.stultz@linaro.org> <1551819273-640-2-git-send-email-john.stultz@linaro.org> From: "Andrew F. Davis" Message-ID: Date: Wed, 6 Mar 2019 10:27:34 -0600 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.4.0 MIME-Version: 1.0 In-Reply-To: <1551819273-640-2-git-send-email-john.stultz@linaro.org> Content-Type: text/plain; charset="utf-8" Content-Language: en-US Content-Transfer-Encoding: 7bit X-EXCLAIMER-MD-CONFIG: e1e8a2fd-e40a-4ac6-ac9b-f7e9cc9ee180 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 3/5/19 2:54 PM, John Stultz wrote: > From: "Andrew F. Davis" > > This framework allows a unified userspace interface for dma-buf > exporters, allowing userland to allocate specific types of > memory for use in dma-buf sharing. > > Each heap is given its own device node, which a user can > allocate a dma-buf fd from using the DMA_HEAP_IOC_ALLOC. > > This code is an evoluiton of the Android ION implementation, > and a big thanks is due to its authors/maintainers over time > for their effort: > Rebecca Schultz Zavin, Colin Cross, Benjamin Gaignard, > Laura Abbott, and many other contributors! > > Cc: Laura Abbott > Cc: Benjamin Gaignard > Cc: Greg KH > Cc: Sumit Semwal > Cc: Liam Mark > Cc: Brian Starkey > Cc: Andrew F. Davis > Cc: Chenbo Feng > Cc: Alistair Strachan > Cc: dri-devel@lists.freedesktop.org > Signed-off-by: Andrew F. Davis > [jstultz: reworded commit message, and lots of cleanups] > Signed-off-by: John Stultz > --- > v2: > * Folded down fixes I had previously shared in implementing > heaps > * Make flags a u64 (Suggested by Laura) > * Add PAGE_ALIGN() fix to the core alloc funciton > * IOCTL fixups suggested by Brian > * Added fixes suggested by Benjamin > * Removed core stats mgmt, as that should be implemented by > per-heap code > * Changed alloc to return a dma-buf fd, rather then a buffer > (as it simplifies error handling) > --- > MAINTAINERS | 16 ++++ > drivers/dma-buf/Kconfig | 8 ++ > drivers/dma-buf/Makefile | 1 + > drivers/dma-buf/dma-heap.c | 191 ++++++++++++++++++++++++++++++++++++++++++ > include/linux/dma-heap.h | 65 ++++++++++++++ > include/uapi/linux/dma-heap.h | 52 ++++++++++++ > 6 files changed, 333 insertions(+) > create mode 100644 drivers/dma-buf/dma-heap.c > create mode 100644 include/linux/dma-heap.h > create mode 100644 include/uapi/linux/dma-heap.h > > diff --git a/MAINTAINERS b/MAINTAINERS > index ac2e518..a661e19 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -4621,6 +4621,22 @@ F: include/linux/*fence.h > F: Documentation/driver-api/dma-buf.rst > T: git git://anongit.freedesktop.org/drm/drm-misc > > +DMA-BUF HEAPS FRAMEWORK > +M: Laura Abbott > +R: Liam Mark > +R: Brian Starkey > +R: "Andrew F. Davis" Quotes not needed in maintainers file. > +R: John Stultz > +S: Maintained > +L: linux-media@vger.kernel.org > +L: dri-devel@lists.freedesktop.org > +L: linaro-mm-sig@lists.linaro.org (moderated for non-subscribers) > +F: include/uapi/linux/dma-heap.h > +F: include/linux/dma-heap.h > +F: drivers/dma-buf/dma-heap.c > +F: drivers/dma-buf/heaps/* > +T: git git://anongit.freedesktop.org/drm/drm-misc > + > DMA GENERIC OFFLOAD ENGINE SUBSYSTEM > M: Vinod Koul > L: dmaengine@vger.kernel.org > diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig > index 2e5a0fa..09c61db 100644 > --- a/drivers/dma-buf/Kconfig > +++ b/drivers/dma-buf/Kconfig > @@ -39,4 +39,12 @@ config UDMABUF > A driver to let userspace turn memfd regions into dma-bufs. > Qemu can use this to create host dmabufs for guest framebuffers. > > +menuconfig DMABUF_HEAPS > + bool "DMA-BUF Userland Memory Heaps" > + select DMA_SHARED_BUFFER > + help > + Choose this option to enable the DMA-BUF userland memory heaps, > + this allows userspace to allocate dma-bufs that can be shared between > + drivers. > + > endmenu > diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile > index 0913a6c..b0332f1 100644 > --- a/drivers/dma-buf/Makefile > +++ b/drivers/dma-buf/Makefile > @@ -1,4 +1,5 @@ > obj-y := dma-buf.o dma-fence.o dma-fence-array.o reservation.o seqno-fence.o > +obj-$(CONFIG_DMABUF_HEAPS) += dma-heap.o > 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/dma-heap.c b/drivers/dma-buf/dma-heap.c > new file mode 100644 > index 0000000..14b3975 > --- /dev/null > +++ b/drivers/dma-buf/dma-heap.c > @@ -0,0 +1,191 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Framework for userspace DMA-BUF allocations > + * > + * Copyright (C) 2011 Google, Inc. > + * Copyright (C) 2019 Linaro Ltd. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +#define DEVNAME "dma_heap" > + > +#define NUM_HEAP_MINORS 128 > +static DEFINE_IDR(dma_heap_idr); > +static DEFINE_MUTEX(minor_lock); /* Protect idr accesses */ > + > +dev_t dma_heap_devt; > +struct class *dma_heap_class; > +struct list_head dma_heap_list; > +struct dentry *dma_heap_debug_root; > + > +static int dma_heap_buffer_alloc(struct dma_heap *heap, size_t len, > + unsigned int flags) > +{ > + len = PAGE_ALIGN(len); > + if (!len) > + return -EINVAL; > + > + return heap->ops->allocate(heap, len, flags); > +} > + > +static int dma_heap_open(struct inode *inode, struct file *filp) > +{ > + struct dma_heap *heap; > + > + mutex_lock(&minor_lock); > + heap = idr_find(&dma_heap_idr, iminor(inode)); > + mutex_unlock(&minor_lock); > + if (!heap) { > + pr_err("dma_heap: minor %d unknown.\n", iminor(inode)); > + return -ENODEV; > + } > + > + /* instance data as context */ > + filp->private_data = heap; > + nonseekable_open(inode, filp); > + > + return 0; > +} > + > +static int dma_heap_release(struct inode *inode, struct file *filp) > +{ > + filp->private_data = NULL; > + > + return 0; > +} > + > +static long dma_heap_ioctl(struct file *filp, unsigned int cmd, > + unsigned long arg) > +{ > + switch (cmd) { > + case DMA_HEAP_IOC_ALLOC: > + { > + struct dma_heap_allocation_data heap_allocation; > + struct dma_heap *heap = filp->private_data; > + int fd; > + > + if (copy_from_user(&heap_allocation, (void __user *)arg, > + sizeof(heap_allocation))) > + return -EFAULT; > + > + if (heap_allocation.fd || > + heap_allocation.reserved0 || > + heap_allocation.reserved1 || > + heap_allocation.reserved2) { Seems too many reserved, I can understand one, but if we ever needed all of these we would be better off just adding another alloc ioctl. > + pr_warn_once("dma_heap: ioctl data not valid\n"); > + return -EINVAL; > + } > + if (heap_allocation.flags & ~DMA_HEAP_VALID_FLAGS) { > + pr_warn_once("dma_heap: flags has invalid or unsupported flags set\n"); > + return -EINVAL; > + } > + > + fd = dma_heap_buffer_alloc(heap, heap_allocation.len, > + heap_allocation.flags); > + if (fd < 0) > + return fd; > + > + heap_allocation.fd = fd; > + > + if (copy_to_user((void __user *)arg, &heap_allocation, > + sizeof(heap_allocation))) > + return -EFAULT; > + > + break; > + } > + default: > + return -ENOTTY; > + } > + > + return 0; > +} > + > +static const struct file_operations dma_heap_fops = { > + .owner = THIS_MODULE, > + .open = dma_heap_open, > + .release = dma_heap_release, > + .unlocked_ioctl = dma_heap_ioctl, > +#ifdef CONFIG_COMPAT > + .compat_ioctl = dma_heap_ioctl, > +#endif > +}; > + > +int dma_heap_add(struct dma_heap *heap) > +{ > + struct device *dev_ret; > + int ret; > + > + if (!heap->name || !strcmp(heap->name, "")) { > + pr_err("dma_heap: Cannot add heap without a name\n"); As these names end up as the dev name in the file system we may want to check for invalid names, there is probably a helper for that somewhere. > + return -EINVAL; > + } > + > + if (!heap->ops || !heap->ops->allocate) { > + pr_err("dma_heap: Cannot add heap with invalid ops struct\n"); > + return -EINVAL; > + } > + > + /* Find unused minor number */ > + mutex_lock(&minor_lock); > + ret = idr_alloc(&dma_heap_idr, heap, 0, NUM_HEAP_MINORS, GFP_KERNEL); > + mutex_unlock(&minor_lock); > + if (ret < 0) { > + pr_err("dma_heap: Unable to get minor number for heap\n"); > + return ret; > + } > + heap->minor = ret; > + > + /* Create device */ > + heap->heap_devt = MKDEV(MAJOR(dma_heap_devt), heap->minor); > + dev_ret = device_create(dma_heap_class, > + NULL, > + heap->heap_devt, > + NULL, > + heap->name); > + if (IS_ERR(dev_ret)) { > + pr_err("dma_heap: Unable to create char device\n"); > + return PTR_ERR(dev_ret); > + } > + > + /* Add device */ > + cdev_init(&heap->heap_cdev, &dma_heap_fops); > + ret = cdev_add(&heap->heap_cdev, dma_heap_devt, NUM_HEAP_MINORS); > + if (ret < 0) { > + device_destroy(dma_heap_class, heap->heap_devt); > + pr_err("dma_heap: Unable to add char device\n"); > + return ret; > + } > + > + return 0; > +} > +EXPORT_SYMBOL(dma_heap_add); > + > +static int dma_heap_init(void) > +{ > + int ret; > + > + ret = alloc_chrdev_region(&dma_heap_devt, 0, NUM_HEAP_MINORS, DEVNAME); > + if (ret) > + return ret; > + > + dma_heap_class = class_create(THIS_MODULE, DEVNAME); > + if (IS_ERR(dma_heap_class)) { > + unregister_chrdev_region(dma_heap_devt, NUM_HEAP_MINORS); > + return PTR_ERR(dma_heap_class); > + } > + > + return 0; > +} > +subsys_initcall(dma_heap_init); > diff --git a/include/linux/dma-heap.h b/include/linux/dma-heap.h > new file mode 100644 > index 0000000..ed86a8e > --- /dev/null > +++ b/include/linux/dma-heap.h > @@ -0,0 +1,65 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * DMABUF Heaps Allocation Infrastructure > + * > + * Copyright (C) 2011 Google, Inc. > + * Copyright (C) 2019 Linaro Ltd. > + */ > + > +#ifndef _DMA_HEAPS_H > +#define _DMA_HEAPS_H > + > +#include > +#include > + > +/** > + * struct dma_heap_buffer - metadata for a particular buffer > + * @heap: back pointer to the heap the buffer came from > + * @dmabuf: backing dma-buf for this buffer > + * @size: size of the buffer > + * @flags: buffer specific flags > + */ > +struct dma_heap_buffer { > + struct dma_heap *heap; > + struct dma_buf *dmabuf; > + size_t size; > + unsigned long flags; > +}; > + > +/** > + * struct dma_heap - represents a dmabuf heap in the system > + * @name: used for debugging/device-node name > + * @ops: ops struct for this heap > + * @minor minor number of this heap device > + * @heap_devt heap device node > + * @heap_cdev heap char device > + * > + * Represents a heap of memory from which buffers can be made. > + */ > +struct dma_heap { > + const char *name; > + struct dma_heap_ops *ops; > + unsigned int minor; > + dev_t heap_devt; > + struct cdev heap_cdev; > +}; Still not sure about this, all of the members in this struct are strictly internally used by the framework. The users of this framework should not have access to them and only need to deal with an opaque pointer for tracking themselves (can store it in a private struct of their own then container_of to get back out their struct). Anyway, not a big deal, and if it really bugs me enough I can always go fix it later, it's all kernel internal so not a blocker here. :) Andrew > + > +/** > + * struct dma_heap_ops - ops to operate on a given heap > + * @allocate: allocate dmabuf and return fd > + * > + * allocate returns dmabuf fd on success, -errno on error. > + */ > +struct dma_heap_ops { > + int (*allocate)(struct dma_heap *heap, > + unsigned long len, > + unsigned long flags); > +}; > + > +/** > + * dma_heap_add - adds a heap to dmabuf heaps > + * @heap: the heap to add > + */ > +int dma_heap_add(struct dma_heap *heap); > + > +#endif /* _DMA_HEAPS_H */ > diff --git a/include/uapi/linux/dma-heap.h b/include/uapi/linux/dma-heap.h > new file mode 100644 > index 0000000..75c5d3f > --- /dev/null > +++ b/include/uapi/linux/dma-heap.h > @@ -0,0 +1,52 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * DMABUF Heaps Userspace API > + * > + * Copyright (C) 2011 Google, Inc. > + * Copyright (C) 2019 Linaro Ltd. > + */ > +#ifndef _UAPI_LINUX_DMABUF_POOL_H > +#define _UAPI_LINUX_DMABUF_POOL_H > + > +#include > +#include > + > +/** > + * DOC: DMABUF Heaps Userspace API > + * > + */ > + > +/* Currently no flags */ > +#define DMA_HEAP_VALID_FLAGS (0) > + > +/** > + * struct dma_heap_allocation_data - metadata passed from userspace for > + * allocations > + * @len: size of the allocation > + * @flags: flags passed to pool > + * @fd: will be populated with a fd which provdes the > + * handle to the allocated dma-buf > + * > + * Provided by userspace as an argument to the ioctl > + */ > +struct dma_heap_allocation_data { > + __u64 len; > + __u64 flags; > + __u32 fd; > + __u32 reserved0; > + __u32 reserved1; > + __u32 reserved2; > +}; > + > +#define DMA_HEAP_IOC_MAGIC 'H' > + > +/** > + * DOC: DMA_HEAP_IOC_ALLOC - allocate memory from pool > + * > + * Takes an dma_heap_allocation_data struct and returns it with the fd field > + * populated with the dmabuf handle of the allocation. > + */ > +#define DMA_HEAP_IOC_ALLOC _IOWR(DMA_HEAP_IOC_MAGIC, 0, \ > + struct dma_heap_allocation_data) > + > +#endif /* _UAPI_LINUX_DMABUF_POOL_H */ > From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Andrew F. Davis" Subject: Re: [RFC][PATCH 1/5 v2] dma-buf: Add dma-buf heaps framework Date: Wed, 6 Mar 2019 10:27:34 -0600 Message-ID: References: <1551819273-640-1-git-send-email-john.stultz@linaro.org> <1551819273-640-2-git-send-email-john.stultz@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from lelv0142.ext.ti.com (lelv0142.ext.ti.com [198.47.23.249]) by gabe.freedesktop.org (Postfix) with ESMTPS id E3BB96E12D for ; Wed, 6 Mar 2019 16:27:43 +0000 (UTC) In-Reply-To: <1551819273-640-2-git-send-email-john.stultz@linaro.org> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: John Stultz , lkml Cc: Greg KH , Chenbo Feng , Alistair Strachan , Liam Mark , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gMy81LzE5IDI6NTQgUE0sIEpvaG4gU3R1bHR6IHdyb3RlOgo+IEZyb206ICJBbmRyZXcgRi4g RGF2aXMiIDxhZmRAdGkuY29tPgo+IAo+IFRoaXMgZnJhbWV3b3JrIGFsbG93cyBhIHVuaWZpZWQg dXNlcnNwYWNlIGludGVyZmFjZSBmb3IgZG1hLWJ1Zgo+IGV4cG9ydGVycywgYWxsb3dpbmcgdXNl cmxhbmQgdG8gYWxsb2NhdGUgc3BlY2lmaWMgdHlwZXMgb2YKPiBtZW1vcnkgZm9yIHVzZSBpbiBk bWEtYnVmIHNoYXJpbmcuCj4gCj4gRWFjaCBoZWFwIGlzIGdpdmVuIGl0cyBvd24gZGV2aWNlIG5v ZGUsIHdoaWNoIGEgdXNlciBjYW4KPiBhbGxvY2F0ZSBhIGRtYS1idWYgZmQgZnJvbSB1c2luZyB0 aGUgRE1BX0hFQVBfSU9DX0FMTE9DLgo+IAo+IFRoaXMgY29kZSBpcyBhbiBldm9sdWl0b24gb2Yg dGhlIEFuZHJvaWQgSU9OIGltcGxlbWVudGF0aW9uLAo+IGFuZCBhIGJpZyB0aGFua3MgaXMgZHVl IHRvIGl0cyBhdXRob3JzL21haW50YWluZXJzIG92ZXIgdGltZQo+IGZvciB0aGVpciBlZmZvcnQ6 Cj4gICBSZWJlY2NhIFNjaHVsdHogWmF2aW4sIENvbGluIENyb3NzLCBCZW5qYW1pbiBHYWlnbmFy ZCwKPiAgIExhdXJhIEFiYm90dCwgYW5kIG1hbnkgb3RoZXIgY29udHJpYnV0b3JzIQo+IAo+IENj OiBMYXVyYSBBYmJvdHQgPGxhYmJvdHRAcmVkaGF0LmNvbT4KPiBDYzogQmVuamFtaW4gR2FpZ25h cmQgPGJlbmphbWluLmdhaWduYXJkQGxpbmFyby5vcmc+Cj4gQ2M6IEdyZWcgS0ggPGdyZWdraEBs aW51eGZvdW5kYXRpb24ub3JnPgo+IENjOiBTdW1pdCBTZW13YWwgPHN1bWl0LnNlbXdhbEBsaW5h cm8ub3JnPgo+IENjOiBMaWFtIE1hcmsgPGxtYXJrQGNvZGVhdXJvcmEub3JnPgo+IENjOiBCcmlh biBTdGFya2V5IDxCcmlhbi5TdGFya2V5QGFybS5jb20+Cj4gQ2M6IEFuZHJldyBGLiBEYXZpcyA8 YWZkQHRpLmNvbT4KPiBDYzogQ2hlbmJvIEZlbmcgPGZlbmdjQGdvb2dsZS5jb20+Cj4gQ2M6IEFs aXN0YWlyIFN0cmFjaGFuIDxhc3RyYWNoYW5AZ29vZ2xlLmNvbT4KPiBDYzogZHJpLWRldmVsQGxp c3RzLmZyZWVkZXNrdG9wLm9yZwo+IFNpZ25lZC1vZmYtYnk6IEFuZHJldyBGLiBEYXZpcyA8YWZk QHRpLmNvbT4KPiBbanN0dWx0ejogcmV3b3JkZWQgY29tbWl0IG1lc3NhZ2UsIGFuZCBsb3RzIG9m IGNsZWFudXBzXQo+IFNpZ25lZC1vZmYtYnk6IEpvaG4gU3R1bHR6IDxqb2huLnN0dWx0ekBsaW5h cm8ub3JnPgo+IC0tLQo+IHYyOgo+ICogRm9sZGVkIGRvd24gZml4ZXMgSSBoYWQgcHJldmlvdXNs eSBzaGFyZWQgaW4gaW1wbGVtZW50aW5nCj4gICBoZWFwcwo+ICogTWFrZSBmbGFncyBhIHU2NCAo U3VnZ2VzdGVkIGJ5IExhdXJhKQo+ICogQWRkIFBBR0VfQUxJR04oKSBmaXggdG8gdGhlIGNvcmUg YWxsb2MgZnVuY2l0b24KPiAqIElPQ1RMIGZpeHVwcyBzdWdnZXN0ZWQgYnkgQnJpYW4KPiAqIEFk ZGVkIGZpeGVzIHN1Z2dlc3RlZCBieSBCZW5qYW1pbgo+ICogUmVtb3ZlZCBjb3JlIHN0YXRzIG1n bXQsIGFzIHRoYXQgc2hvdWxkIGJlIGltcGxlbWVudGVkIGJ5Cj4gICBwZXItaGVhcCBjb2RlCj4g KiBDaGFuZ2VkIGFsbG9jIHRvIHJldHVybiBhIGRtYS1idWYgZmQsIHJhdGhlciB0aGVuIGEgYnVm ZmVyCj4gICAoYXMgaXQgc2ltcGxpZmllcyBlcnJvciBoYW5kbGluZykKPiAtLS0KPiAgTUFJTlRB SU5FUlMgICAgICAgICAgICAgICAgICAgfCAgMTYgKysrKwo+ICBkcml2ZXJzL2RtYS1idWYvS2Nv bmZpZyAgICAgICB8ICAgOCArKwo+ICBkcml2ZXJzL2RtYS1idWYvTWFrZWZpbGUgICAgICB8ICAg MSArCj4gIGRyaXZlcnMvZG1hLWJ1Zi9kbWEtaGVhcC5jICAgIHwgMTkxICsrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBpbmNsdWRlL2xpbnV4L2RtYS1oZWFwLmgg ICAgICB8ICA2NSArKysrKysrKysrKysrKwo+ICBpbmNsdWRlL3VhcGkvbGludXgvZG1hLWhlYXAu aCB8ICA1MiArKysrKysrKysrKysKPiAgNiBmaWxlcyBjaGFuZ2VkLCAzMzMgaW5zZXJ0aW9ucygr KQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2RtYS1oZWFwLmMKPiAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgvZG1hLWhlYXAuaAo+ICBjcmVhdGUgbW9kZSAx MDA2NDQgaW5jbHVkZS91YXBpL2xpbnV4L2RtYS1oZWFwLmgKPiAKPiBkaWZmIC0tZ2l0IGEvTUFJ TlRBSU5FUlMgYi9NQUlOVEFJTkVSUwo+IGluZGV4IGFjMmU1MTguLmE2NjFlMTkgMTAwNjQ0Cj4g LS0tIGEvTUFJTlRBSU5FUlMKPiArKysgYi9NQUlOVEFJTkVSUwo+IEBAIC00NjIxLDYgKzQ2MjEs MjIgQEAgRjoJaW5jbHVkZS9saW51eC8qZmVuY2UuaAo+ICBGOglEb2N1bWVudGF0aW9uL2RyaXZl ci1hcGkvZG1hLWJ1Zi5yc3QKPiAgVDoJZ2l0IGdpdDovL2Fub25naXQuZnJlZWRlc2t0b3Aub3Jn L2RybS9kcm0tbWlzYwo+ICAKPiArRE1BLUJVRiBIRUFQUyBGUkFNRVdPUksKPiArTToJTGF1cmEg QWJib3R0IDxsYWJib3R0QHJlZGhhdC5jb20+Cj4gK1I6CUxpYW0gTWFyayA8bG1hcmtAY29kZWF1 cm9yYS5vcmc+Cj4gK1I6CUJyaWFuIFN0YXJrZXkgPEJyaWFuLlN0YXJrZXlAYXJtLmNvbT4KPiAr UjoJIkFuZHJldyBGLiBEYXZpcyIgPGFmZEB0aS5jb20+CgpRdW90ZXMgbm90IG5lZWRlZCBpbiBt YWludGFpbmVycyBmaWxlLgoKPiArUjoJSm9obiBTdHVsdHogPGpvaG4uc3R1bHR6QGxpbmFyby5v cmc+Cj4gK1M6CU1haW50YWluZWQKPiArTDoJbGludXgtbWVkaWFAdmdlci5rZXJuZWwub3JnCj4g K0w6CWRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKPiArTDoJbGluYXJvLW1tLXNpZ0Bs aXN0cy5saW5hcm8ub3JnIChtb2RlcmF0ZWQgZm9yIG5vbi1zdWJzY3JpYmVycykKPiArRjoJaW5j bHVkZS91YXBpL2xpbnV4L2RtYS1oZWFwLmgKPiArRjoJaW5jbHVkZS9saW51eC9kbWEtaGVhcC5o Cj4gK0Y6CWRyaXZlcnMvZG1hLWJ1Zi9kbWEtaGVhcC5jCj4gK0Y6CWRyaXZlcnMvZG1hLWJ1Zi9o ZWFwcy8qCj4gK1Q6CWdpdCBnaXQ6Ly9hbm9uZ2l0LmZyZWVkZXNrdG9wLm9yZy9kcm0vZHJtLW1p c2MKPiArCj4gIERNQSBHRU5FUklDIE9GRkxPQUQgRU5HSU5FIFNVQlNZU1RFTQo+ICBNOglWaW5v ZCBLb3VsIDx2a291bEBrZXJuZWwub3JnPgo+ICBMOglkbWFlbmdpbmVAdmdlci5rZXJuZWwub3Jn Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnIGIvZHJpdmVycy9kbWEtYnVm L0tjb25maWcKPiBpbmRleCAyZTVhMGZhLi4wOWM2MWRiIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv ZG1hLWJ1Zi9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9kbWEtYnVmL0tjb25maWcKPiBAQCAtMzks NCArMzksMTIgQEAgY29uZmlnIFVETUFCVUYKPiAgCSAgQSBkcml2ZXIgdG8gbGV0IHVzZXJzcGFj ZSB0dXJuIG1lbWZkIHJlZ2lvbnMgaW50byBkbWEtYnVmcy4KPiAgCSAgUWVtdSBjYW4gdXNlIHRo aXMgdG8gY3JlYXRlIGhvc3QgZG1hYnVmcyBmb3IgZ3Vlc3QgZnJhbWVidWZmZXJzLgo+ICAKPiAr bWVudWNvbmZpZyBETUFCVUZfSEVBUFMKPiArCWJvb2wgIkRNQS1CVUYgVXNlcmxhbmQgTWVtb3J5 IEhlYXBzIgo+ICsJc2VsZWN0IERNQV9TSEFSRURfQlVGRkVSCj4gKwloZWxwCj4gKwkgIENob29z ZSB0aGlzIG9wdGlvbiB0byBlbmFibGUgdGhlIERNQS1CVUYgdXNlcmxhbmQgbWVtb3J5IGhlYXBz LAo+ICsJICB0aGlzIGFsbG93cyB1c2Vyc3BhY2UgdG8gYWxsb2NhdGUgZG1hLWJ1ZnMgdGhhdCBj YW4gYmUgc2hhcmVkIGJldHdlZW4KPiArCSAgZHJpdmVycy4KPiArCj4gIGVuZG1lbnUKPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlIGIvZHJpdmVycy9kbWEtYnVmL01ha2Vm aWxlCj4gaW5kZXggMDkxM2E2Yy4uYjAzMzJmMSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2RtYS1i dWYvTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL2RtYS1idWYvTWFrZWZpbGUKPiBAQCAtMSw0ICsx LDUgQEAKPiAgb2JqLXkgOj0gZG1hLWJ1Zi5vIGRtYS1mZW5jZS5vIGRtYS1mZW5jZS1hcnJheS5v IHJlc2VydmF0aW9uLm8gc2Vxbm8tZmVuY2Uubwo+ICtvYmotJChDT05GSUdfRE1BQlVGX0hFQVBT KQkrPSBkbWEtaGVhcC5vCj4gIG9iai0kKENPTkZJR19TWU5DX0ZJTEUpCQkrPSBzeW5jX2ZpbGUu bwo+ICBvYmotJChDT05GSUdfU1dfU1lOQykJCSs9IHN3X3N5bmMubyBzeW5jX2RlYnVnLm8KPiAg b2JqLSQoQ09ORklHX1VETUFCVUYpCQkrPSB1ZG1hYnVmLm8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9kbWEtYnVmL2RtYS1oZWFwLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWhlYXAuYwo+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uMTRiMzk3NQo+IC0tLSAvZGV2L251bGwK PiArKysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWhlYXAuYwo+IEBAIC0wLDAgKzEsMTkxIEBACj4g Ky8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCj4gKy8qCj4gKyAqIEZyYW1ld29y ayBmb3IgdXNlcnNwYWNlIERNQS1CVUYgYWxsb2NhdGlvbnMKPiArICoKPiArICogQ29weXJpZ2h0 IChDKSAyMDExIEdvb2dsZSwgSW5jLgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTkgTGluYXJvIEx0 ZC4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvY2Rldi5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvZGVidWdmcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9kbWEtYnVmLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxp bnV4L2lkci5oPgo+ICsjaW5jbHVkZSA8bGludXgvbGlzdC5oPgo+ICsjaW5jbHVkZSA8bGludXgv c2xhYi5oPgo+ICsjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgo+ICsKPiArI2luY2x1ZGUgPGxp bnV4L2RtYS1oZWFwLmg+Cj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L2RtYS1oZWFwLmg+Cj4gKwo+ ICsjZGVmaW5lIERFVk5BTUUgImRtYV9oZWFwIgo+ICsKPiArI2RlZmluZSBOVU1fSEVBUF9NSU5P UlMgMTI4Cj4gK3N0YXRpYyBERUZJTkVfSURSKGRtYV9oZWFwX2lkcik7Cj4gK3N0YXRpYyBERUZJ TkVfTVVURVgobWlub3JfbG9jayk7IC8qIFByb3RlY3QgaWRyIGFjY2Vzc2VzICovCj4gKwo+ICtk ZXZfdCBkbWFfaGVhcF9kZXZ0Owo+ICtzdHJ1Y3QgY2xhc3MgKmRtYV9oZWFwX2NsYXNzOwo+ICtz dHJ1Y3QgbGlzdF9oZWFkIGRtYV9oZWFwX2xpc3Q7Cj4gK3N0cnVjdCBkZW50cnkgKmRtYV9oZWFw X2RlYnVnX3Jvb3Q7Cj4gKwo+ICtzdGF0aWMgaW50IGRtYV9oZWFwX2J1ZmZlcl9hbGxvYyhzdHJ1 Y3QgZG1hX2hlYXAgKmhlYXAsIHNpemVfdCBsZW4sCj4gKwkJCQkgdW5zaWduZWQgaW50IGZsYWdz KQo+ICt7Cj4gKwlsZW4gPSBQQUdFX0FMSUdOKGxlbik7Cj4gKwlpZiAoIWxlbikKPiArCQlyZXR1 cm4gLUVJTlZBTDsKPiArCj4gKwlyZXR1cm4gaGVhcC0+b3BzLT5hbGxvY2F0ZShoZWFwLCBsZW4s IGZsYWdzKTsKPiArfQo+ICsKPiArc3RhdGljIGludCBkbWFfaGVhcF9vcGVuKHN0cnVjdCBpbm9k ZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQo+ICt7Cj4gKwlzdHJ1Y3QgZG1hX2hlYXAgKmhl YXA7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmbWlub3JfbG9jayk7Cj4gKwloZWFwID0gaWRyX2ZpbmQo JmRtYV9oZWFwX2lkciwgaW1pbm9yKGlub2RlKSk7Cj4gKwltdXRleF91bmxvY2soJm1pbm9yX2xv Y2spOwo+ICsJaWYgKCFoZWFwKSB7Cj4gKwkJcHJfZXJyKCJkbWFfaGVhcDogbWlub3IgJWQgdW5r bm93bi5cbiIsIGltaW5vcihpbm9kZSkpOwo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJfQo+ICsK PiArCS8qIGluc3RhbmNlIGRhdGEgYXMgY29udGV4dCAqLwo+ICsJZmlscC0+cHJpdmF0ZV9kYXRh ID0gaGVhcDsKPiArCW5vbnNlZWthYmxlX29wZW4oaW5vZGUsIGZpbHApOwo+ICsKPiArCXJldHVy biAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGRtYV9oZWFwX3JlbGVhc2Uoc3RydWN0IGlub2Rl ICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbHApCj4gK3sKPiArCWZpbHAtPnByaXZhdGVfZGF0YSA9 IE5VTEw7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBsb25nIGRtYV9oZWFw X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLAo+ICsJCQkgICB1bnNp Z25lZCBsb25nIGFyZykKPiArewo+ICsJc3dpdGNoIChjbWQpIHsKPiArCWNhc2UgRE1BX0hFQVBf SU9DX0FMTE9DOgo+ICsJewo+ICsJCXN0cnVjdCBkbWFfaGVhcF9hbGxvY2F0aW9uX2RhdGEgaGVh cF9hbGxvY2F0aW9uOwo+ICsJCXN0cnVjdCBkbWFfaGVhcCAqaGVhcCA9IGZpbHAtPnByaXZhdGVf ZGF0YTsKPiArCQlpbnQgZmQ7Cj4gKwo+ICsJCWlmIChjb3B5X2Zyb21fdXNlcigmaGVhcF9hbGxv Y2F0aW9uLCAodm9pZCBfX3VzZXIgKilhcmcsCj4gKwkJCQkgICBzaXplb2YoaGVhcF9hbGxvY2F0 aW9uKSkpCj4gKwkJCXJldHVybiAtRUZBVUxUOwo+ICsKPiArCQlpZiAoaGVhcF9hbGxvY2F0aW9u LmZkIHx8Cj4gKwkJICAgIGhlYXBfYWxsb2NhdGlvbi5yZXNlcnZlZDAgfHwKPiArCQkgICAgaGVh cF9hbGxvY2F0aW9uLnJlc2VydmVkMSB8fAo+ICsJCSAgICBoZWFwX2FsbG9jYXRpb24ucmVzZXJ2 ZWQyKSB7CgpTZWVtcyB0b28gbWFueSByZXNlcnZlZCwgSSBjYW4gdW5kZXJzdGFuZCBvbmUsIGJ1 dCBpZiB3ZSBldmVyIG5lZWRlZCBhbGwKb2YgdGhlc2Ugd2Ugd291bGQgYmUgYmV0dGVyIG9mZiBq dXN0IGFkZGluZyBhbm90aGVyIGFsbG9jIGlvY3RsLgoKPiArCQkJcHJfd2Fybl9vbmNlKCJkbWFf aGVhcDogaW9jdGwgZGF0YSBub3QgdmFsaWRcbiIpOwo+ICsJCQlyZXR1cm4gLUVJTlZBTDsKPiAr CQl9Cj4gKwkJaWYgKGhlYXBfYWxsb2NhdGlvbi5mbGFncyAmIH5ETUFfSEVBUF9WQUxJRF9GTEFH Uykgewo+ICsJCQlwcl93YXJuX29uY2UoImRtYV9oZWFwOiBmbGFncyBoYXMgaW52YWxpZCBvciB1 bnN1cHBvcnRlZCBmbGFncyBzZXRcbiIpOwo+ICsJCQlyZXR1cm4gLUVJTlZBTDsKPiArCQl9Cj4g Kwo+ICsJCWZkID0gZG1hX2hlYXBfYnVmZmVyX2FsbG9jKGhlYXAsIGhlYXBfYWxsb2NhdGlvbi5s ZW4sCj4gKwkJCQkJICAgaGVhcF9hbGxvY2F0aW9uLmZsYWdzKTsKPiArCQlpZiAoZmQgPCAwKQo+ ICsJCQlyZXR1cm4gZmQ7Cj4gKwo+ICsJCWhlYXBfYWxsb2NhdGlvbi5mZCA9IGZkOwo+ICsKPiAr CQlpZiAoY29weV90b191c2VyKCh2b2lkIF9fdXNlciAqKWFyZywgJmhlYXBfYWxsb2NhdGlvbiwK PiArCQkJCSBzaXplb2YoaGVhcF9hbGxvY2F0aW9uKSkpCj4gKwkJCXJldHVybiAtRUZBVUxUOwo+ ICsKPiArCQlicmVhazsKPiArCX0KPiArCWRlZmF1bHQ6Cj4gKwkJcmV0dXJuIC1FTk9UVFk7Cj4g Kwl9Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmls ZV9vcGVyYXRpb25zIGRtYV9oZWFwX2ZvcHMgPSB7Cj4gKwkub3duZXIgICAgICAgICAgPSBUSElT X01PRFVMRSwKPiArCS5vcGVuCQk9IGRtYV9oZWFwX29wZW4sCj4gKwkucmVsZWFzZQk9IGRtYV9o ZWFwX3JlbGVhc2UsCj4gKwkudW5sb2NrZWRfaW9jdGwgPSBkbWFfaGVhcF9pb2N0bCwKPiArI2lm ZGVmIENPTkZJR19DT01QQVQKPiArCS5jb21wYXRfaW9jdGwJPSBkbWFfaGVhcF9pb2N0bCwKPiAr I2VuZGlmCj4gK307Cj4gKwo+ICtpbnQgZG1hX2hlYXBfYWRkKHN0cnVjdCBkbWFfaGVhcCAqaGVh cCkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2X3JldDsKPiArCWludCByZXQ7Cj4gKwo+ICsJ aWYgKCFoZWFwLT5uYW1lIHx8ICFzdHJjbXAoaGVhcC0+bmFtZSwgIiIpKSB7Cj4gKwkJcHJfZXJy KCJkbWFfaGVhcDogQ2Fubm90IGFkZCBoZWFwIHdpdGhvdXQgYSBuYW1lXG4iKTsKCkFzIHRoZXNl IG5hbWVzIGVuZCB1cCBhcyB0aGUgZGV2IG5hbWUgaW4gdGhlIGZpbGUgc3lzdGVtIHdlIG1heSB3 YW50IHRvCmNoZWNrIGZvciBpbnZhbGlkIG5hbWVzLCB0aGVyZSBpcyBwcm9iYWJseSBhIGhlbHBl ciBmb3IgdGhhdCBzb21ld2hlcmUuCgo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiAr CWlmICghaGVhcC0+b3BzIHx8ICFoZWFwLT5vcHMtPmFsbG9jYXRlKSB7Cj4gKwkJcHJfZXJyKCJk bWFfaGVhcDogQ2Fubm90IGFkZCBoZWFwIHdpdGggaW52YWxpZCBvcHMgc3RydWN0XG4iKTsKPiAr CQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwkvKiBGaW5kIHVudXNlZCBtaW5vciBudW1i ZXIgKi8KPiArCW11dGV4X2xvY2soJm1pbm9yX2xvY2spOwo+ICsJcmV0ID0gaWRyX2FsbG9jKCZk bWFfaGVhcF9pZHIsIGhlYXAsIDAsIE5VTV9IRUFQX01JTk9SUywgR0ZQX0tFUk5FTCk7Cj4gKwlt dXRleF91bmxvY2soJm1pbm9yX2xvY2spOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlwcl9lcnIo ImRtYV9oZWFwOiBVbmFibGUgdG8gZ2V0IG1pbm9yIG51bWJlciBmb3IgaGVhcFxuIik7Cj4gKwkJ cmV0dXJuIHJldDsKPiArCX0KPiArCWhlYXAtPm1pbm9yID0gcmV0Owo+ICsKPiArCS8qIENyZWF0 ZSBkZXZpY2UgKi8KPiArCWhlYXAtPmhlYXBfZGV2dCA9IE1LREVWKE1BSk9SKGRtYV9oZWFwX2Rl dnQpLCBoZWFwLT5taW5vcik7Cj4gKwlkZXZfcmV0ID0gZGV2aWNlX2NyZWF0ZShkbWFfaGVhcF9j bGFzcywKPiArCQkJCU5VTEwsCj4gKwkJCQloZWFwLT5oZWFwX2RldnQsCj4gKwkJCQlOVUxMLAo+ ICsJCQkJaGVhcC0+bmFtZSk7Cj4gKwlpZiAoSVNfRVJSKGRldl9yZXQpKSB7Cj4gKwkJcHJfZXJy KCJkbWFfaGVhcDogVW5hYmxlIHRvIGNyZWF0ZSBjaGFyIGRldmljZVxuIik7Cj4gKwkJcmV0dXJu IFBUUl9FUlIoZGV2X3JldCk7Cj4gKwl9Cj4gKwo+ICsJLyogQWRkIGRldmljZSAqLwo+ICsJY2Rl dl9pbml0KCZoZWFwLT5oZWFwX2NkZXYsICZkbWFfaGVhcF9mb3BzKTsKPiArCXJldCA9IGNkZXZf YWRkKCZoZWFwLT5oZWFwX2NkZXYsIGRtYV9oZWFwX2RldnQsIE5VTV9IRUFQX01JTk9SUyk7Cj4g KwlpZiAocmV0IDwgMCkgewo+ICsJCWRldmljZV9kZXN0cm95KGRtYV9oZWFwX2NsYXNzLCBoZWFw LT5oZWFwX2RldnQpOwo+ICsJCXByX2VycigiZG1hX2hlYXA6IFVuYWJsZSB0byBhZGQgY2hhciBk ZXZpY2VcbiIpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30K PiArRVhQT1JUX1NZTUJPTChkbWFfaGVhcF9hZGQpOwo+ICsKPiArc3RhdGljIGludCBkbWFfaGVh cF9pbml0KHZvaWQpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gYWxsb2NfY2hyZGV2 X3JlZ2lvbigmZG1hX2hlYXBfZGV2dCwgMCwgTlVNX0hFQVBfTUlOT1JTLCBERVZOQU1FKTsKPiAr CWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlkbWFfaGVhcF9jbGFzcyA9IGNsYXNz X2NyZWF0ZShUSElTX01PRFVMRSwgREVWTkFNRSk7Cj4gKwlpZiAoSVNfRVJSKGRtYV9oZWFwX2Ns YXNzKSkgewo+ICsJCXVucmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbihkbWFfaGVhcF9kZXZ0LCBOVU1f SEVBUF9NSU5PUlMpOwo+ICsJCXJldHVybiBQVFJfRVJSKGRtYV9oZWFwX2NsYXNzKTsKPiArCX0K PiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICtzdWJzeXNfaW5pdGNhbGwoZG1hX2hlYXBfaW5pdCk7 Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWhlYXAuaCBiL2luY2x1ZGUvbGludXgv ZG1hLWhlYXAuaAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uZWQ4NmE4 ZQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9pbmNsdWRlL2xpbnV4L2RtYS1oZWFwLmgKPiBAQCAt MCwwICsxLDY1IEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCj4g Ky8qCj4gKyAqIERNQUJVRiBIZWFwcyBBbGxvY2F0aW9uIEluZnJhc3RydWN0dXJlCj4gKyAqCj4g KyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUsIEluYy4KPiArICogQ29weXJpZ2h0IChDKSAy MDE5IExpbmFybyBMdGQuCj4gKyAqLwo+ICsKPiArI2lmbmRlZiBfRE1BX0hFQVBTX0gKPiArI2Rl ZmluZSBfRE1BX0hFQVBTX0gKPiArCj4gKyNpbmNsdWRlIDxsaW51eC9jZGV2Lmg+Cj4gKyNpbmNs dWRlIDxsaW51eC90eXBlcy5oPgo+ICsKPiArLyoqCj4gKyAqIHN0cnVjdCBkbWFfaGVhcF9idWZm ZXIgLSBtZXRhZGF0YSBmb3IgYSBwYXJ0aWN1bGFyIGJ1ZmZlcgo+ICsgKiBAaGVhcDoJCWJhY2sg cG9pbnRlciB0byB0aGUgaGVhcCB0aGUgYnVmZmVyIGNhbWUgZnJvbQo+ICsgKiBAZG1hYnVmOgkJ YmFja2luZyBkbWEtYnVmIGZvciB0aGlzIGJ1ZmZlcgo+ICsgKiBAc2l6ZToJCXNpemUgb2YgdGhl IGJ1ZmZlcgo+ICsgKiBAZmxhZ3M6CQlidWZmZXIgc3BlY2lmaWMgZmxhZ3MKPiArICovCj4gK3N0 cnVjdCBkbWFfaGVhcF9idWZmZXIgewo+ICsJc3RydWN0IGRtYV9oZWFwICpoZWFwOwo+ICsJc3Ry dWN0IGRtYV9idWYgKmRtYWJ1ZjsKPiArCXNpemVfdCBzaXplOwo+ICsJdW5zaWduZWQgbG9uZyBm bGFnczsKPiArfTsKPiArCj4gKy8qKgo+ICsgKiBzdHJ1Y3QgZG1hX2hlYXAgLSByZXByZXNlbnRz IGEgZG1hYnVmIGhlYXAgaW4gdGhlIHN5c3RlbQo+ICsgKiBAbmFtZToJCXVzZWQgZm9yIGRlYnVn Z2luZy9kZXZpY2Utbm9kZSBuYW1lCj4gKyAqIEBvcHM6CQlvcHMgc3RydWN0IGZvciB0aGlzIGhl YXAKPiArICogQG1pbm9yCQltaW5vciBudW1iZXIgb2YgdGhpcyBoZWFwIGRldmljZQo+ICsgKiBA aGVhcF9kZXZ0CQloZWFwIGRldmljZSBub2RlCj4gKyAqIEBoZWFwX2NkZXYJCWhlYXAgY2hhciBk ZXZpY2UKPiArICoKPiArICogUmVwcmVzZW50cyBhIGhlYXAgb2YgbWVtb3J5IGZyb20gd2hpY2gg YnVmZmVycyBjYW4gYmUgbWFkZS4KPiArICovCj4gK3N0cnVjdCBkbWFfaGVhcCB7Cj4gKwljb25z dCBjaGFyICpuYW1lOwo+ICsJc3RydWN0IGRtYV9oZWFwX29wcyAqb3BzOwo+ICsJdW5zaWduZWQg aW50IG1pbm9yOwo+ICsJZGV2X3QgaGVhcF9kZXZ0Owo+ICsJc3RydWN0IGNkZXYgaGVhcF9jZGV2 Owo+ICt9OwoKU3RpbGwgbm90IHN1cmUgYWJvdXQgdGhpcywgYWxsIG9mIHRoZSBtZW1iZXJzIGlu IHRoaXMgc3RydWN0IGFyZQpzdHJpY3RseSBpbnRlcm5hbGx5IHVzZWQgYnkgdGhlIGZyYW1ld29y ay4gVGhlIHVzZXJzIG9mIHRoaXMgZnJhbWV3b3JrCnNob3VsZCBub3QgaGF2ZSBhY2Nlc3MgdG8g dGhlbSBhbmQgb25seSBuZWVkIHRvIGRlYWwgd2l0aCBhbiBvcGFxdWUKcG9pbnRlciBmb3IgdHJh Y2tpbmcgdGhlbXNlbHZlcyAoY2FuIHN0b3JlIGl0IGluIGEgcHJpdmF0ZSBzdHJ1Y3Qgb2YKdGhl aXIgb3duIHRoZW4gY29udGFpbmVyX29mIHRvIGdldCBiYWNrIG91dCB0aGVpciBzdHJ1Y3QpLgoK QW55d2F5LCBub3QgYSBiaWcgZGVhbCwgYW5kIGlmIGl0IHJlYWxseSBidWdzIG1lIGVub3VnaCBJ IGNhbiBhbHdheXMgZ28KZml4IGl0IGxhdGVyLCBpdCdzIGFsbCBrZXJuZWwgaW50ZXJuYWwgc28g bm90IGEgYmxvY2tlciBoZXJlLiA6KQoKQW5kcmV3Cgo+ICsKPiArLyoqCj4gKyAqIHN0cnVjdCBk bWFfaGVhcF9vcHMgLSBvcHMgdG8gb3BlcmF0ZSBvbiBhIGdpdmVuIGhlYXAKPiArICogQGFsbG9j YXRlOgkJYWxsb2NhdGUgZG1hYnVmIGFuZCByZXR1cm4gZmQKPiArICoKPiArICogYWxsb2NhdGUg cmV0dXJucyBkbWFidWYgZmQgIG9uIHN1Y2Nlc3MsIC1lcnJubyBvbiBlcnJvci4KPiArICovCj4g K3N0cnVjdCBkbWFfaGVhcF9vcHMgewo+ICsJaW50ICgqYWxsb2NhdGUpKHN0cnVjdCBkbWFfaGVh cCAqaGVhcCwKPiArCQkJdW5zaWduZWQgbG9uZyBsZW4sCj4gKwkJCXVuc2lnbmVkIGxvbmcgZmxh Z3MpOwo+ICt9Owo+ICsKPiArLyoqCj4gKyAqIGRtYV9oZWFwX2FkZCAtIGFkZHMgYSBoZWFwIHRv IGRtYWJ1ZiBoZWFwcwo+ICsgKiBAaGVhcDoJCXRoZSBoZWFwIHRvIGFkZAo+ICsgKi8KPiAraW50 IGRtYV9oZWFwX2FkZChzdHJ1Y3QgZG1hX2hlYXAgKmhlYXApOwo+ICsKPiArI2VuZGlmIC8qIF9E TUFfSEVBUFNfSCAqLwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgvZG1hLWhlYXAu aCBiL2luY2x1ZGUvdWFwaS9saW51eC9kbWEtaGVhcC5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQK PiBpbmRleCAwMDAwMDAwLi43NWM1ZDNmCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2luY2x1ZGUv dWFwaS9saW51eC9kbWEtaGVhcC5oCj4gQEAgLTAsMCArMSw1MiBAQAo+ICsvKiBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLwo+ICsvKgo+ICsgKiBETUFCVUYgSGVhcHMgVXNlcnNw YWNlIEFQSQo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlLCBJbmMuCj4gKyAq IENvcHlyaWdodCAoQykgMjAxOSBMaW5hcm8gTHRkLgo+ICsgKi8KPiArI2lmbmRlZiBfVUFQSV9M SU5VWF9ETUFCVUZfUE9PTF9ICj4gKyNkZWZpbmUgX1VBUElfTElOVVhfRE1BQlVGX1BPT0xfSAo+ ICsKPiArI2luY2x1ZGUgPGxpbnV4L2lvY3RsLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC90eXBlcy5o Pgo+ICsKPiArLyoqCj4gKyAqIERPQzogRE1BQlVGIEhlYXBzIFVzZXJzcGFjZSBBUEkKPiArICoK PiArICovCj4gKwo+ICsvKiBDdXJyZW50bHkgbm8gZmxhZ3MgKi8KPiArI2RlZmluZSBETUFfSEVB UF9WQUxJRF9GTEFHUyAoMCkKPiArCj4gKy8qKgo+ICsgKiBzdHJ1Y3QgZG1hX2hlYXBfYWxsb2Nh dGlvbl9kYXRhIC0gbWV0YWRhdGEgcGFzc2VkIGZyb20gdXNlcnNwYWNlIGZvcgo+ICsgKiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWxsb2NhdGlvbnMKPiArICogQGxlbjoJ CXNpemUgb2YgdGhlIGFsbG9jYXRpb24KPiArICogQGZsYWdzOgkJZmxhZ3MgcGFzc2VkIHRvIHBv b2wKPiArICogQGZkOgkJCXdpbGwgYmUgcG9wdWxhdGVkIHdpdGggYSBmZCB3aGljaCBwcm92ZGVz IHRoZQo+ICsgKgkJCWhhbmRsZSB0byB0aGUgYWxsb2NhdGVkIGRtYS1idWYKPiArICoKPiArICog UHJvdmlkZWQgYnkgdXNlcnNwYWNlIGFzIGFuIGFyZ3VtZW50IHRvIHRoZSBpb2N0bAo+ICsgKi8K PiArc3RydWN0IGRtYV9oZWFwX2FsbG9jYXRpb25fZGF0YSB7Cj4gKwlfX3U2NCBsZW47Cj4gKwlf X3U2NCBmbGFnczsKPiArCV9fdTMyIGZkOwo+ICsJX191MzIgcmVzZXJ2ZWQwOwo+ICsJX191MzIg cmVzZXJ2ZWQxOwo+ICsJX191MzIgcmVzZXJ2ZWQyOwo+ICt9Owo+ICsKPiArI2RlZmluZSBETUFf SEVBUF9JT0NfTUFHSUMJCSdIJwo+ICsKPiArLyoqCj4gKyAqIERPQzogRE1BX0hFQVBfSU9DX0FM TE9DIC0gYWxsb2NhdGUgbWVtb3J5IGZyb20gcG9vbAo+ICsgKgo+ICsgKiBUYWtlcyBhbiBkbWFf aGVhcF9hbGxvY2F0aW9uX2RhdGEgc3RydWN0IGFuZCByZXR1cm5zIGl0IHdpdGggdGhlIGZkIGZp ZWxkCj4gKyAqIHBvcHVsYXRlZCB3aXRoIHRoZSBkbWFidWYgaGFuZGxlIG9mIHRoZSBhbGxvY2F0 aW9uLgo+ICsgKi8KPiArI2RlZmluZSBETUFfSEVBUF9JT0NfQUxMT0MJX0lPV1IoRE1BX0hFQVBf SU9DX01BR0lDLCAwLCBcCj4gKwkJCQkgICAgICBzdHJ1Y3QgZG1hX2hlYXBfYWxsb2NhdGlvbl9k YXRhKQo+ICsKPiArI2VuZGlmIC8qIF9VQVBJX0xJTlVYX0RNQUJVRl9QT09MX0ggKi8KPiAKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1h aWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMu ZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs