From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S966736AbeEYPd5 (ORCPT ); Fri, 25 May 2018 11:33:57 -0400 Received: from mail-wm0-f65.google.com ([74.125.82.65]:32922 "EHLO mail-wm0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S966646AbeEYPdw (ORCPT ); Fri, 25 May 2018 11:33:52 -0400 X-Google-Smtp-Source: ADUXVKIJG9xxQhg/CcVLrK48OSqXCG8SqIpb3PomhRj+L9goTlUFZBnF+gLnjLNJRd33Ml7ULrlgwg== From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: daniel.vetter@intel.com, andr2000@gmail.com, dongwon.kim@intel.com, matthew.d.roper@intel.com, Oleksandr Andrushchenko Subject: [PATCH 5/8] xen/gntdev: Add initial support for dma-buf UAPI Date: Fri, 25 May 2018 18:33:28 +0300 Message-Id: <20180525153331.31188-6-andr2000@gmail.com> X-Mailer: git-send-email 2.17.0 In-Reply-To: <20180525153331.31188-1-andr2000@gmail.com> References: <20180525153331.31188-1-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Add UAPI and IOCTLs for dma-buf grant device driver extension: the extension allows userspace processes and kernel modules to use Xen backed dma-buf implementation. With this extension grant references to the pages of an imported dma-buf can be exported for other domain use and grant references coming from a foreign domain can be converted into a local dma-buf for local export. Implement basic initialization and stubs for Xen DMA buffers' support. Signed-off-by: Oleksandr Andrushchenko --- drivers/xen/Kconfig | 10 +++ drivers/xen/gntdev.c | 148 ++++++++++++++++++++++++++++++++++++++ include/uapi/xen/gntdev.h | 91 +++++++++++++++++++++++ 3 files changed, 249 insertions(+) diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index 3431fe210624..eaf63a2c7ae6 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -152,6 +152,16 @@ config XEN_GNTDEV help Allows userspace processes to use grants. +config XEN_GNTDEV_DMABUF + bool "Add support for dma-buf grant access device driver extension" + depends on XEN_GNTDEV && XEN_GRANT_DMA_ALLOC + help + Allows userspace processes and kernel modules to use Xen backed + dma-buf implementation. With this extension grant references to + the pages of an imported dma-buf can be exported for other domain + use and grant references coming from a foreign domain can be + converted into a local dma-buf for local export. + config XEN_GRANT_DEV_ALLOC tristate "User-space grant reference allocator driver" depends on XEN diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c index 640a579f42ea..9e450622af1a 100644 --- a/drivers/xen/gntdev.c +++ b/drivers/xen/gntdev.c @@ -6,6 +6,7 @@ * * Copyright (c) 2006-2007, D G Murray. * (c) 2009 Gerd Hoffmann + * (c) 2018 Oleksandr Andrushchenko, EPAM Systems Inc. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -122,6 +123,17 @@ struct grant_map { #endif }; +#ifdef CONFIG_XEN_GNTDEV_DMABUF +struct xen_dmabuf { + union { + struct { + /* Granted references of the imported buffer. */ + grant_ref_t *refs; + } imp; + } u; +}; +#endif + static int unmap_grant_pages(struct grant_map *map, int offset, int pages); static struct miscdevice gntdev_miscdev; @@ -1036,6 +1048,128 @@ static long gntdev_ioctl_grant_copy(struct gntdev_priv *priv, void __user *u) return ret; } +#ifdef CONFIG_XEN_GNTDEV_DMABUF +/* ------------------------------------------------------------------ */ +/* DMA buffer export support. */ +/* ------------------------------------------------------------------ */ + +static int dmabuf_exp_wait_released(struct gntdev_priv *priv, int fd, + int wait_to_ms) +{ + return -ETIMEDOUT; +} + +static int dmabuf_exp_from_refs(struct gntdev_priv *priv, int flags, + int count, u32 domid, u32 *refs, u32 *fd) +{ + *fd = -1; + return -EINVAL; +} + +/* ------------------------------------------------------------------ */ +/* DMA buffer import support. */ +/* ------------------------------------------------------------------ */ + +static int dmabuf_imp_release(struct gntdev_priv *priv, u32 fd) +{ + return 0; +} + +static struct xen_dmabuf * +dmabuf_imp_to_refs(struct gntdev_priv *priv, int fd, int count, int domid) +{ + return ERR_PTR(-ENOMEM); +} + +/* ------------------------------------------------------------------ */ +/* DMA buffer IOCTL support. */ +/* ------------------------------------------------------------------ */ + +static long +gntdev_ioctl_dmabuf_exp_from_refs(struct gntdev_priv *priv, + struct ioctl_gntdev_dmabuf_exp_from_refs __user *u) +{ + struct ioctl_gntdev_dmabuf_exp_from_refs op; + u32 *refs; + long ret; + + if (copy_from_user(&op, u, sizeof(op)) != 0) + return -EFAULT; + + refs = kcalloc(op.count, sizeof(*refs), GFP_KERNEL); + if (!refs) + return -ENOMEM; + + if (copy_from_user(refs, u->refs, sizeof(*refs) * op.count) != 0) { + ret = -EFAULT; + goto out; + } + + ret = dmabuf_exp_from_refs(priv, op.flags, op.count, + op.domid, refs, &op.fd); + if (ret) + goto out; + + if (copy_to_user(u, &op, sizeof(op)) != 0) + ret = -EFAULT; + +out: + kfree(refs); + return ret; +} + +static long +gntdev_ioctl_dmabuf_exp_wait_released(struct gntdev_priv *priv, + struct ioctl_gntdev_dmabuf_exp_wait_released __user *u) +{ + struct ioctl_gntdev_dmabuf_exp_wait_released op; + + if (copy_from_user(&op, u, sizeof(op)) != 0) + return -EFAULT; + + return dmabuf_exp_wait_released(priv, op.fd, op.wait_to_ms); +} + +static long +gntdev_ioctl_dmabuf_imp_to_refs(struct gntdev_priv *priv, + struct ioctl_gntdev_dmabuf_imp_to_refs __user *u) +{ + struct ioctl_gntdev_dmabuf_imp_to_refs op; + struct xen_dmabuf *xen_dmabuf; + long ret; + + if (copy_from_user(&op, u, sizeof(op)) != 0) + return -EFAULT; + + xen_dmabuf = dmabuf_imp_to_refs(priv, op.fd, op.count, op.domid); + if (IS_ERR(xen_dmabuf)) + return PTR_ERR(xen_dmabuf); + + if (copy_to_user(u->refs, xen_dmabuf->u.imp.refs, + sizeof(*u->refs) * op.count) != 0) { + ret = -EFAULT; + goto out_release; + } + return 0; + +out_release: + dmabuf_imp_release(priv, op.fd); + return ret; +} + +static long +gntdev_ioctl_dmabuf_imp_release(struct gntdev_priv *priv, + struct ioctl_gntdev_dmabuf_imp_release __user *u) +{ + struct ioctl_gntdev_dmabuf_imp_release op; + + if (copy_from_user(&op, u, sizeof(op)) != 0) + return -EFAULT; + + return dmabuf_imp_release(priv, op.fd); +} +#endif + static long gntdev_ioctl(struct file *flip, unsigned int cmd, unsigned long arg) { @@ -1058,6 +1192,20 @@ static long gntdev_ioctl(struct file *flip, case IOCTL_GNTDEV_GRANT_COPY: return gntdev_ioctl_grant_copy(priv, ptr); +#ifdef CONFIG_XEN_GNTDEV_DMABUF + case IOCTL_GNTDEV_DMABUF_EXP_FROM_REFS: + return gntdev_ioctl_dmabuf_exp_from_refs(priv, ptr); + + case IOCTL_GNTDEV_DMABUF_EXP_WAIT_RELEASED: + return gntdev_ioctl_dmabuf_exp_wait_released(priv, ptr); + + case IOCTL_GNTDEV_DMABUF_IMP_TO_REFS: + return gntdev_ioctl_dmabuf_imp_to_refs(priv, ptr); + + case IOCTL_GNTDEV_DMABUF_IMP_RELEASE: + return gntdev_ioctl_dmabuf_imp_release(priv, ptr); +#endif + default: pr_debug("priv %p, unknown cmd %x\n", priv, cmd); return -ENOIOCTLCMD; diff --git a/include/uapi/xen/gntdev.h b/include/uapi/xen/gntdev.h index 2d5a4672f07c..568d5cb522e9 100644 --- a/include/uapi/xen/gntdev.h +++ b/include/uapi/xen/gntdev.h @@ -5,6 +5,7 @@ * Interface to /dev/xen/gntdev. * * Copyright (c) 2007, D G Murray + * Copyright (c) 2018, Oleksandr Andrushchenko, EPAM Systems Inc. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version 2 @@ -215,4 +216,94 @@ struct ioctl_gntdev_grant_copy { */ #define GNTDEV_DMA_FLAG_COHERENT (1 << 2) +/* + * Create a dma-buf [1] from grant references @refs of count @count provided + * by the foreign domain @domid with flags @flags. + * + * By default dma-buf is backed by system memory pages, but by providing + * one of the GNTDEV_DMA_FLAG_XXX flags it can also be created as + * a DMA write-combine or coherent buffer, e.g. allocated with dma_alloc_wc/ + * dma_alloc_coherent. + * + * Returns 0 if dma-buf was successfully created and the corresponding + * dma-buf's file descriptor is returned in @fd. + * + * [1] https://elixir.bootlin.com/linux/latest/source/Documentation/driver-api/dma-buf.rst + */ + +#define IOCTL_GNTDEV_DMABUF_EXP_FROM_REFS \ + _IOC(_IOC_NONE, 'G', 9, \ + sizeof(struct ioctl_gntdev_dmabuf_exp_from_refs)) +struct ioctl_gntdev_dmabuf_exp_from_refs { + /* IN parameters. */ + /* Specific options for this dma-buf: see GNTDEV_DMA_FLAG_XXX. */ + __u32 flags; + /* Number of grant references in @refs array. */ + __u32 count; + /* OUT parameters. */ + /* File descriptor of the dma-buf. */ + __u32 fd; + /* The domain ID of the grant references to be mapped. */ + __u32 domid; + /* Variable IN parameter. */ + /* Array of grant references of size @count. */ + __u32 refs[1]; +}; + +/* + * This will block until the dma-buf with the file descriptor @fd is + * released. This is only valid for buffers created with + * IOCTL_GNTDEV_DMABUF_EXP_FROM_REFS. + * + * If within @wait_to_ms milliseconds the buffer is not released + * then -ETIMEDOUT error is returned. + * If the buffer with the file descriptor @fd does not exist or has already + * been released, then -ENOENT is returned. For valid file descriptors + * this must not be treated as error. + */ +#define IOCTL_GNTDEV_DMABUF_EXP_WAIT_RELEASED \ + _IOC(_IOC_NONE, 'G', 10, \ + sizeof(struct ioctl_gntdev_dmabuf_exp_wait_released)) +struct ioctl_gntdev_dmabuf_exp_wait_released { + /* IN parameters */ + __u32 fd; + __u32 wait_to_ms; +}; + +/* + * Import a dma-buf with file descriptor @fd and export granted references + * to the pages of that dma-buf into array @refs of size @count. + */ +#define IOCTL_GNTDEV_DMABUF_IMP_TO_REFS \ + _IOC(_IOC_NONE, 'G', 11, \ + sizeof(struct ioctl_gntdev_dmabuf_imp_to_refs)) +struct ioctl_gntdev_dmabuf_imp_to_refs { + /* IN parameters. */ + /* File descriptor of the dma-buf. */ + __u32 fd; + /* Number of grant references in @refs array. */ + __u32 count; + /* The domain ID for which references to be granted. */ + __u32 domid; + /* Reserved - must be zero. */ + __u32 reserved; + /* OUT parameters. */ + /* Array of grant references of size @count. */ + __u32 refs[1]; +}; + +/* + * This will close all references to the imported buffer with file descriptor + * @fd, so it can be released by the owner. This is only valid for buffers + * created with IOCTL_GNTDEV_DMABUF_IMP_TO_REFS. + */ +#define IOCTL_GNTDEV_DMABUF_IMP_RELEASE \ + _IOC(_IOC_NONE, 'G', 12, \ + sizeof(struct ioctl_gntdev_dmabuf_imp_release)) +struct ioctl_gntdev_dmabuf_imp_release { + /* IN parameters */ + __u32 fd; + __u32 reserved; +}; + #endif /* __LINUX_PUBLIC_GNTDEV_H__ */ -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 5/8] xen/gntdev: Add initial support for dma-buf UAPI Date: Fri, 25 May 2018 18:33:28 +0300 Message-ID: <20180525153331.31188-6-andr2000@gmail.com> References: <20180525153331.31188-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x244.google.com (mail-wm0-x244.google.com [IPv6:2a00:1450:400c:c09::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5C5176E95A for ; Fri, 25 May 2018 15:33:52 +0000 (UTC) Received: by mail-wm0-x244.google.com with SMTP id a67-v6so15434371wmf.3 for ; Fri, 25 May 2018 08:33:52 -0700 (PDT) In-Reply-To: <20180525153331.31188-1-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, daniel.vetter@intel.com, dongwon.kim@intel.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKQWRkIFVBUEkgYW5kIElPQ1RMcyBmb3IgZG1hLWJ1ZiBncmFudCBkZXZpY2UgZHJp dmVyIGV4dGVuc2lvbjoKdGhlIGV4dGVuc2lvbiBhbGxvd3MgdXNlcnNwYWNlIHByb2Nlc3NlcyBh bmQga2VybmVsIG1vZHVsZXMgdG8KdXNlIFhlbiBiYWNrZWQgZG1hLWJ1ZiBpbXBsZW1lbnRhdGlv bi4gV2l0aCB0aGlzIGV4dGVuc2lvbiBncmFudApyZWZlcmVuY2VzIHRvIHRoZSBwYWdlcyBvZiBh biBpbXBvcnRlZCBkbWEtYnVmIGNhbiBiZSBleHBvcnRlZApmb3Igb3RoZXIgZG9tYWluIHVzZSBh bmQgZ3JhbnQgcmVmZXJlbmNlcyBjb21pbmcgZnJvbSBhIGZvcmVpZ24KZG9tYWluIGNhbiBiZSBj b252ZXJ0ZWQgaW50byBhIGxvY2FsIGRtYS1idWYgZm9yIGxvY2FsIGV4cG9ydC4KSW1wbGVtZW50 IGJhc2ljIGluaXRpYWxpemF0aW9uIGFuZCBzdHVicyBmb3IgWGVuIERNQSBidWZmZXJzJwpzdXBw b3J0LgoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9h bmRydXNoY2hlbmtvQGVwYW0uY29tPgotLS0KIGRyaXZlcnMveGVuL0tjb25maWcgICAgICAgfCAg MTAgKysrCiBkcml2ZXJzL3hlbi9nbnRkZXYuYyAgICAgIHwgMTQ4ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL3VhcGkveGVuL2dudGRldi5oIHwgIDkxICsr KysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDI0OSBpbnNlcnRpb25zKCsp CgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vS2NvbmZpZyBiL2RyaXZlcnMveGVuL0tjb25maWcK aW5kZXggMzQzMWZlMjEwNjI0Li5lYWY2M2EyYzdhZTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVu L0tjb25maWcKKysrIGIvZHJpdmVycy94ZW4vS2NvbmZpZwpAQCAtMTUyLDYgKzE1MiwxNiBAQCBj b25maWcgWEVOX0dOVERFVgogCWhlbHAKIAkgIEFsbG93cyB1c2Vyc3BhY2UgcHJvY2Vzc2VzIHRv IHVzZSBncmFudHMuCiAKK2NvbmZpZyBYRU5fR05UREVWX0RNQUJVRgorCWJvb2wgIkFkZCBzdXBw b3J0IGZvciBkbWEtYnVmIGdyYW50IGFjY2VzcyBkZXZpY2UgZHJpdmVyIGV4dGVuc2lvbiIKKwlk ZXBlbmRzIG9uIFhFTl9HTlRERVYgJiYgWEVOX0dSQU5UX0RNQV9BTExPQworCWhlbHAKKwkgIEFs bG93cyB1c2Vyc3BhY2UgcHJvY2Vzc2VzIGFuZCBrZXJuZWwgbW9kdWxlcyB0byB1c2UgWGVuIGJh Y2tlZAorCSAgZG1hLWJ1ZiBpbXBsZW1lbnRhdGlvbi4gV2l0aCB0aGlzIGV4dGVuc2lvbiBncmFu dCByZWZlcmVuY2VzIHRvCisJICB0aGUgcGFnZXMgb2YgYW4gaW1wb3J0ZWQgZG1hLWJ1ZiBjYW4g YmUgZXhwb3J0ZWQgZm9yIG90aGVyIGRvbWFpbgorCSAgdXNlIGFuZCBncmFudCByZWZlcmVuY2Vz IGNvbWluZyBmcm9tIGEgZm9yZWlnbiBkb21haW4gY2FuIGJlCisJICBjb252ZXJ0ZWQgaW50byBh IGxvY2FsIGRtYS1idWYgZm9yIGxvY2FsIGV4cG9ydC4KKwogY29uZmlnIFhFTl9HUkFOVF9ERVZf QUxMT0MKIAl0cmlzdGF0ZSAiVXNlci1zcGFjZSBncmFudCByZWZlcmVuY2UgYWxsb2NhdG9yIGRy aXZlciIKIAlkZXBlbmRzIG9uIFhFTgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vZ250ZGV2LmMg Yi9kcml2ZXJzL3hlbi9nbnRkZXYuYwppbmRleCA2NDBhNTc5ZjQyZWEuLjllNDUwNjIyYWYxYSAx MDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vZ250ZGV2LmMKKysrIGIvZHJpdmVycy94ZW4vZ250ZGV2 LmMKQEAgLTYsNiArNiw3IEBACiAgKgogICogQ29weXJpZ2h0IChjKSAyMDA2LTIwMDcsIEQgRyBN dXJyYXkuCiAgKiAgICAgICAgICAgKGMpIDIwMDkgR2VyZCBIb2ZmbWFubiA8a3JheGVsQHJlZGhh dC5jb20+CisgKiAgICAgICAgICAgKGMpIDIwMTggT2xla3NhbmRyIEFuZHJ1c2hjaGVua28sIEVQ QU0gU3lzdGVtcyBJbmMuCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgpAQCAtMTIyLDYgKzEyMywx NyBAQCBzdHJ1Y3QgZ3JhbnRfbWFwIHsKICNlbmRpZgogfTsKIAorI2lmZGVmIENPTkZJR19YRU5f R05UREVWX0RNQUJVRgorc3RydWN0IHhlbl9kbWFidWYgeworCXVuaW9uIHsKKwkJc3RydWN0IHsK KwkJCS8qIEdyYW50ZWQgcmVmZXJlbmNlcyBvZiB0aGUgaW1wb3J0ZWQgYnVmZmVyLiAqLworCQkJ Z3JhbnRfcmVmX3QgKnJlZnM7CisJCX0gaW1wOworCX0gdTsKK307CisjZW5kaWYKKwogc3RhdGlj IGludCB1bm1hcF9ncmFudF9wYWdlcyhzdHJ1Y3QgZ3JhbnRfbWFwICptYXAsIGludCBvZmZzZXQs IGludCBwYWdlcyk7CiAKIHN0YXRpYyBzdHJ1Y3QgbWlzY2RldmljZSBnbnRkZXZfbWlzY2RldjsK QEAgLTEwMzYsNiArMTA0OCwxMjggQEAgc3RhdGljIGxvbmcgZ250ZGV2X2lvY3RsX2dyYW50X2Nv cHkoc3RydWN0IGdudGRldl9wcml2ICpwcml2LCB2b2lkIF9fdXNlciAqdSkKIAlyZXR1cm4gcmV0 OwogfQogCisjaWZkZWYgQ09ORklHX1hFTl9HTlRERVZfRE1BQlVGCisvKiAtLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8K Ky8qIERNQSBidWZmZXIgZXhwb3J0IHN1cHBvcnQuICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAqLworLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisKK3N0YXRpYyBpbnQgZG1hYnVmX2V4 cF93YWl0X3JlbGVhc2VkKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwgaW50IGZkLAorCQkJCSAg ICBpbnQgd2FpdF90b19tcykKK3sKKwlyZXR1cm4gLUVUSU1FRE9VVDsKK30KKworc3RhdGljIGlu dCBkbWFidWZfZXhwX2Zyb21fcmVmcyhzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsIGludCBmbGFn cywKKwkJCQlpbnQgY291bnQsIHUzMiBkb21pZCwgdTMyICpyZWZzLCB1MzIgKmZkKQoreworCSpm ZCA9IC0xOworCXJldHVybiAtRUlOVkFMOworfQorCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKy8qIERNQSBi dWZmZXIgaW1wb3J0IHN1cHBvcnQuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAqLworLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisKK3N0YXRpYyBpbnQgZG1hYnVmX2ltcF9yZWxlYXNl KHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwgdTMyIGZkKQoreworCXJldHVybiAwOworfQorCitz dGF0aWMgc3RydWN0IHhlbl9kbWFidWYgKgorZG1hYnVmX2ltcF90b19yZWZzKHN0cnVjdCBnbnRk ZXZfcHJpdiAqcHJpdiwgaW50IGZkLCBpbnQgY291bnQsIGludCBkb21pZCkKK3sKKwlyZXR1cm4g RVJSX1BUUigtRU5PTUVNKTsKK30KKworLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKiBETUEgYnVmZmVyIElP Q1RMIHN1cHBvcnQuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8K Ky8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLSAqLworCitzdGF0aWMgbG9uZworZ250ZGV2X2lvY3RsX2RtYWJ1Zl9leHBf ZnJvbV9yZWZzKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwKKwkJCQkgIHN0cnVjdCBpb2N0bF9n bnRkZXZfZG1hYnVmX2V4cF9mcm9tX3JlZnMgX191c2VyICp1KQoreworCXN0cnVjdCBpb2N0bF9n bnRkZXZfZG1hYnVmX2V4cF9mcm9tX3JlZnMgb3A7CisJdTMyICpyZWZzOworCWxvbmcgcmV0Owor CisJaWYgKGNvcHlfZnJvbV91c2VyKCZvcCwgdSwgc2l6ZW9mKG9wKSkgIT0gMCkKKwkJcmV0dXJu IC1FRkFVTFQ7CisKKwlyZWZzID0ga2NhbGxvYyhvcC5jb3VudCwgc2l6ZW9mKCpyZWZzKSwgR0ZQ X0tFUk5FTCk7CisJaWYgKCFyZWZzKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWlmIChjb3B5X2Zy b21fdXNlcihyZWZzLCB1LT5yZWZzLCBzaXplb2YoKnJlZnMpICogb3AuY291bnQpICE9IDApIHsK KwkJcmV0ID0gLUVGQVVMVDsKKwkJZ290byBvdXQ7CisJfQorCisJcmV0ID0gZG1hYnVmX2V4cF9m cm9tX3JlZnMocHJpdiwgb3AuZmxhZ3MsIG9wLmNvdW50LAorCQkJCSAgIG9wLmRvbWlkLCByZWZz LCAmb3AuZmQpOworCWlmIChyZXQpCisJCWdvdG8gb3V0OworCisJaWYgKGNvcHlfdG9fdXNlcih1 LCAmb3AsIHNpemVvZihvcCkpICE9IDApCisJCXJldCA9IC1FRkFVTFQ7CisKK291dDoKKwlrZnJl ZShyZWZzKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgbG9uZworZ250ZGV2X2lvY3RsX2Rt YWJ1Zl9leHBfd2FpdF9yZWxlYXNlZChzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsCisJCQkJICAg ICAgc3RydWN0IGlvY3RsX2dudGRldl9kbWFidWZfZXhwX3dhaXRfcmVsZWFzZWQgX191c2VyICp1 KQoreworCXN0cnVjdCBpb2N0bF9nbnRkZXZfZG1hYnVmX2V4cF93YWl0X3JlbGVhc2VkIG9wOwor CisJaWYgKGNvcHlfZnJvbV91c2VyKCZvcCwgdSwgc2l6ZW9mKG9wKSkgIT0gMCkKKwkJcmV0dXJu IC1FRkFVTFQ7CisKKwlyZXR1cm4gZG1hYnVmX2V4cF93YWl0X3JlbGVhc2VkKHByaXYsIG9wLmZk LCBvcC53YWl0X3RvX21zKTsKK30KKworc3RhdGljIGxvbmcKK2dudGRldl9pb2N0bF9kbWFidWZf aW1wX3RvX3JlZnMoc3RydWN0IGdudGRldl9wcml2ICpwcml2LAorCQkJCXN0cnVjdCBpb2N0bF9n bnRkZXZfZG1hYnVmX2ltcF90b19yZWZzIF9fdXNlciAqdSkKK3sKKwlzdHJ1Y3QgaW9jdGxfZ250 ZGV2X2RtYWJ1Zl9pbXBfdG9fcmVmcyBvcDsKKwlzdHJ1Y3QgeGVuX2RtYWJ1ZiAqeGVuX2RtYWJ1 ZjsKKwlsb25nIHJldDsKKworCWlmIChjb3B5X2Zyb21fdXNlcigmb3AsIHUsIHNpemVvZihvcCkp ICE9IDApCisJCXJldHVybiAtRUZBVUxUOworCisJeGVuX2RtYWJ1ZiA9IGRtYWJ1Zl9pbXBfdG9f cmVmcyhwcml2LCBvcC5mZCwgb3AuY291bnQsIG9wLmRvbWlkKTsKKwlpZiAoSVNfRVJSKHhlbl9k bWFidWYpKQorCQlyZXR1cm4gUFRSX0VSUih4ZW5fZG1hYnVmKTsKKworCWlmIChjb3B5X3RvX3Vz ZXIodS0+cmVmcywgeGVuX2RtYWJ1Zi0+dS5pbXAucmVmcywKKwkJCSBzaXplb2YoKnUtPnJlZnMp ICogb3AuY291bnQpICE9IDApIHsKKwkJcmV0ID0gLUVGQVVMVDsKKwkJZ290byBvdXRfcmVsZWFz ZTsKKwl9CisJcmV0dXJuIDA7CisKK291dF9yZWxlYXNlOgorCWRtYWJ1Zl9pbXBfcmVsZWFzZShw cml2LCBvcC5mZCk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGxvbmcKK2dudGRldl9pb2N0 bF9kbWFidWZfaW1wX3JlbGVhc2Uoc3RydWN0IGdudGRldl9wcml2ICpwcml2LAorCQkJCXN0cnVj dCBpb2N0bF9nbnRkZXZfZG1hYnVmX2ltcF9yZWxlYXNlIF9fdXNlciAqdSkKK3sKKwlzdHJ1Y3Qg aW9jdGxfZ250ZGV2X2RtYWJ1Zl9pbXBfcmVsZWFzZSBvcDsKKworCWlmIChjb3B5X2Zyb21fdXNl cigmb3AsIHUsIHNpemVvZihvcCkpICE9IDApCisJCXJldHVybiAtRUZBVUxUOworCisJcmV0dXJu IGRtYWJ1Zl9pbXBfcmVsZWFzZShwcml2LCBvcC5mZCk7Cit9CisjZW5kaWYKKwogc3RhdGljIGxv bmcgZ250ZGV2X2lvY3RsKHN0cnVjdCBmaWxlICpmbGlwLAogCQkJIHVuc2lnbmVkIGludCBjbWQs IHVuc2lnbmVkIGxvbmcgYXJnKQogewpAQCAtMTA1OCw2ICsxMTkyLDIwIEBAIHN0YXRpYyBsb25n IGdudGRldl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmxpcCwKIAljYXNlIElPQ1RMX0dOVERFVl9HUkFO VF9DT1BZOgogCQlyZXR1cm4gZ250ZGV2X2lvY3RsX2dyYW50X2NvcHkocHJpdiwgcHRyKTsKIAor I2lmZGVmIENPTkZJR19YRU5fR05UREVWX0RNQUJVRgorCWNhc2UgSU9DVExfR05UREVWX0RNQUJV Rl9FWFBfRlJPTV9SRUZTOgorCQlyZXR1cm4gZ250ZGV2X2lvY3RsX2RtYWJ1Zl9leHBfZnJvbV9y ZWZzKHByaXYsIHB0cik7CisKKwljYXNlIElPQ1RMX0dOVERFVl9ETUFCVUZfRVhQX1dBSVRfUkVM RUFTRUQ6CisJCXJldHVybiBnbnRkZXZfaW9jdGxfZG1hYnVmX2V4cF93YWl0X3JlbGVhc2VkKHBy aXYsIHB0cik7CisKKwljYXNlIElPQ1RMX0dOVERFVl9ETUFCVUZfSU1QX1RPX1JFRlM6CisJCXJl dHVybiBnbnRkZXZfaW9jdGxfZG1hYnVmX2ltcF90b19yZWZzKHByaXYsIHB0cik7CisKKwljYXNl IElPQ1RMX0dOVERFVl9ETUFCVUZfSU1QX1JFTEVBU0U6CisJCXJldHVybiBnbnRkZXZfaW9jdGxf ZG1hYnVmX2ltcF9yZWxlYXNlKHByaXYsIHB0cik7CisjZW5kaWYKKwogCWRlZmF1bHQ6CiAJCXBy X2RlYnVnKCJwcml2ICVwLCB1bmtub3duIGNtZCAleFxuIiwgcHJpdiwgY21kKTsKIAkJcmV0dXJu IC1FTk9JT0NUTENNRDsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS94ZW4vZ250ZGV2LmggYi9p bmNsdWRlL3VhcGkveGVuL2dudGRldi5oCmluZGV4IDJkNWE0NjcyZjA3Yy4uNTY4ZDVjYjUyMmU5 IDEwMDY0NAotLS0gYS9pbmNsdWRlL3VhcGkveGVuL2dudGRldi5oCisrKyBiL2luY2x1ZGUvdWFw aS94ZW4vZ250ZGV2LmgKQEAgLTUsNiArNSw3IEBACiAgKiBJbnRlcmZhY2UgdG8gL2Rldi94ZW4v Z250ZGV2LgogICogCiAgKiBDb3B5cmlnaHQgKGMpIDIwMDcsIEQgRyBNdXJyYXkKKyAqIENvcHly aWdodCAoYykgMjAxOCwgT2xla3NhbmRyIEFuZHJ1c2hjaGVua28sIEVQQU0gU3lzdGVtcyBJbmMu CiAgKiAKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMgpAQCAtMjE1LDQgKzIxNiw5NCBAQCBzdHJ1 Y3QgaW9jdGxfZ250ZGV2X2dyYW50X2NvcHkgewogICovCiAjZGVmaW5lIEdOVERFVl9ETUFfRkxB R19DT0hFUkVOVAkoMSA8PCAyKQogCisvKgorICogQ3JlYXRlIGEgZG1hLWJ1ZiBbMV0gZnJvbSBn cmFudCByZWZlcmVuY2VzIEByZWZzIG9mIGNvdW50IEBjb3VudCBwcm92aWRlZAorICogYnkgdGhl IGZvcmVpZ24gZG9tYWluIEBkb21pZCB3aXRoIGZsYWdzIEBmbGFncy4KKyAqCisgKiBCeSBkZWZh dWx0IGRtYS1idWYgaXMgYmFja2VkIGJ5IHN5c3RlbSBtZW1vcnkgcGFnZXMsIGJ1dCBieSBwcm92 aWRpbmcKKyAqIG9uZSBvZiB0aGUgR05UREVWX0RNQV9GTEFHX1hYWCBmbGFncyBpdCBjYW4gYWxz byBiZSBjcmVhdGVkIGFzCisgKiBhIERNQSB3cml0ZS1jb21iaW5lIG9yIGNvaGVyZW50IGJ1ZmZl ciwgZS5nLiBhbGxvY2F0ZWQgd2l0aCBkbWFfYWxsb2Nfd2MvCisgKiBkbWFfYWxsb2NfY29oZXJl bnQuCisgKgorICogUmV0dXJucyAwIGlmIGRtYS1idWYgd2FzIHN1Y2Nlc3NmdWxseSBjcmVhdGVk IGFuZCB0aGUgY29ycmVzcG9uZGluZworICogZG1hLWJ1ZidzIGZpbGUgZGVzY3JpcHRvciBpcyBy ZXR1cm5lZCBpbiBAZmQuCisgKgorICogWzFdIGh0dHBzOi8vZWxpeGlyLmJvb3RsaW4uY29tL2xp bnV4L2xhdGVzdC9zb3VyY2UvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RtYS1idWYucnN0Cisg Ki8KKworI2RlZmluZSBJT0NUTF9HTlRERVZfRE1BQlVGX0VYUF9GUk9NX1JFRlMgXAorCV9JT0Mo X0lPQ19OT05FLCAnRycsIDksIFwKKwkgICAgIHNpemVvZihzdHJ1Y3QgaW9jdGxfZ250ZGV2X2Rt YWJ1Zl9leHBfZnJvbV9yZWZzKSkKK3N0cnVjdCBpb2N0bF9nbnRkZXZfZG1hYnVmX2V4cF9mcm9t X3JlZnMgeworCS8qIElOIHBhcmFtZXRlcnMuICovCisJLyogU3BlY2lmaWMgb3B0aW9ucyBmb3Ig dGhpcyBkbWEtYnVmOiBzZWUgR05UREVWX0RNQV9GTEFHX1hYWC4gKi8KKwlfX3UzMiBmbGFnczsK KwkvKiBOdW1iZXIgb2YgZ3JhbnQgcmVmZXJlbmNlcyBpbiBAcmVmcyBhcnJheS4gKi8KKwlfX3Uz MiBjb3VudDsKKwkvKiBPVVQgcGFyYW1ldGVycy4gKi8KKwkvKiBGaWxlIGRlc2NyaXB0b3Igb2Yg dGhlIGRtYS1idWYuICovCisJX191MzIgZmQ7CisJLyogVGhlIGRvbWFpbiBJRCBvZiB0aGUgZ3Jh bnQgcmVmZXJlbmNlcyB0byBiZSBtYXBwZWQuICovCisJX191MzIgZG9taWQ7CisJLyogVmFyaWFi bGUgSU4gcGFyYW1ldGVyLiAqLworCS8qIEFycmF5IG9mIGdyYW50IHJlZmVyZW5jZXMgb2Ygc2l6 ZSBAY291bnQuICovCisJX191MzIgcmVmc1sxXTsKK307CisKKy8qCisgKiBUaGlzIHdpbGwgYmxv Y2sgdW50aWwgdGhlIGRtYS1idWYgd2l0aCB0aGUgZmlsZSBkZXNjcmlwdG9yIEBmZCBpcworICog cmVsZWFzZWQuIFRoaXMgaXMgb25seSB2YWxpZCBmb3IgYnVmZmVycyBjcmVhdGVkIHdpdGgKKyAq IElPQ1RMX0dOVERFVl9ETUFCVUZfRVhQX0ZST01fUkVGUy4KKyAqCisgKiBJZiB3aXRoaW4gQHdh aXRfdG9fbXMgbWlsbGlzZWNvbmRzIHRoZSBidWZmZXIgaXMgbm90IHJlbGVhc2VkCisgKiB0aGVu IC1FVElNRURPVVQgZXJyb3IgaXMgcmV0dXJuZWQuCisgKiBJZiB0aGUgYnVmZmVyIHdpdGggdGhl IGZpbGUgZGVzY3JpcHRvciBAZmQgZG9lcyBub3QgZXhpc3Qgb3IgaGFzIGFscmVhZHkKKyAqIGJl ZW4gcmVsZWFzZWQsIHRoZW4gLUVOT0VOVCBpcyByZXR1cm5lZC4gRm9yIHZhbGlkIGZpbGUgZGVz Y3JpcHRvcnMKKyAqIHRoaXMgbXVzdCBub3QgYmUgdHJlYXRlZCBhcyBlcnJvci4KKyAqLworI2Rl ZmluZSBJT0NUTF9HTlRERVZfRE1BQlVGX0VYUF9XQUlUX1JFTEVBU0VEIFwKKwlfSU9DKF9JT0Nf Tk9ORSwgJ0cnLCAxMCwgXAorCSAgICAgc2l6ZW9mKHN0cnVjdCBpb2N0bF9nbnRkZXZfZG1hYnVm X2V4cF93YWl0X3JlbGVhc2VkKSkKK3N0cnVjdCBpb2N0bF9nbnRkZXZfZG1hYnVmX2V4cF93YWl0 X3JlbGVhc2VkIHsKKwkvKiBJTiBwYXJhbWV0ZXJzICovCisJX191MzIgZmQ7CisJX191MzIgd2Fp dF90b19tczsKK307CisKKy8qCisgKiBJbXBvcnQgYSBkbWEtYnVmIHdpdGggZmlsZSBkZXNjcmlw dG9yIEBmZCBhbmQgZXhwb3J0IGdyYW50ZWQgcmVmZXJlbmNlcworICogdG8gdGhlIHBhZ2VzIG9m IHRoYXQgZG1hLWJ1ZiBpbnRvIGFycmF5IEByZWZzIG9mIHNpemUgQGNvdW50LgorICovCisjZGVm aW5lIElPQ1RMX0dOVERFVl9ETUFCVUZfSU1QX1RPX1JFRlMgXAorCV9JT0MoX0lPQ19OT05FLCAn RycsIDExLCBcCisJICAgICBzaXplb2Yoc3RydWN0IGlvY3RsX2dudGRldl9kbWFidWZfaW1wX3Rv X3JlZnMpKQorc3RydWN0IGlvY3RsX2dudGRldl9kbWFidWZfaW1wX3RvX3JlZnMgeworCS8qIElO IHBhcmFtZXRlcnMuICovCisJLyogRmlsZSBkZXNjcmlwdG9yIG9mIHRoZSBkbWEtYnVmLiAqLwor CV9fdTMyIGZkOworCS8qIE51bWJlciBvZiBncmFudCByZWZlcmVuY2VzIGluIEByZWZzIGFycmF5 LiAqLworCV9fdTMyIGNvdW50OworCS8qIFRoZSBkb21haW4gSUQgZm9yIHdoaWNoIHJlZmVyZW5j ZXMgdG8gYmUgZ3JhbnRlZC4gKi8KKwlfX3UzMiBkb21pZDsKKwkvKiBSZXNlcnZlZCAtIG11c3Qg YmUgemVyby4gKi8KKwlfX3UzMiByZXNlcnZlZDsKKwkvKiBPVVQgcGFyYW1ldGVycy4gKi8KKwkv KiBBcnJheSBvZiBncmFudCByZWZlcmVuY2VzIG9mIHNpemUgQGNvdW50LiAqLworCV9fdTMyIHJl ZnNbMV07Cit9OworCisvKgorICogVGhpcyB3aWxsIGNsb3NlIGFsbCByZWZlcmVuY2VzIHRvIHRo ZSBpbXBvcnRlZCBidWZmZXIgd2l0aCBmaWxlIGRlc2NyaXB0b3IKKyAqIEBmZCwgc28gaXQgY2Fu IGJlIHJlbGVhc2VkIGJ5IHRoZSBvd25lci4gVGhpcyBpcyBvbmx5IHZhbGlkIGZvciBidWZmZXJz CisgKiBjcmVhdGVkIHdpdGggSU9DVExfR05UREVWX0RNQUJVRl9JTVBfVE9fUkVGUy4KKyAqLwor I2RlZmluZSBJT0NUTF9HTlRERVZfRE1BQlVGX0lNUF9SRUxFQVNFIFwKKwlfSU9DKF9JT0NfTk9O RSwgJ0cnLCAxMiwgXAorCSAgICAgc2l6ZW9mKHN0cnVjdCBpb2N0bF9nbnRkZXZfZG1hYnVmX2lt cF9yZWxlYXNlKSkKK3N0cnVjdCBpb2N0bF9nbnRkZXZfZG1hYnVmX2ltcF9yZWxlYXNlIHsKKwkv KiBJTiBwYXJhbWV0ZXJzICovCisJX191MzIgZmQ7CisJX191MzIgcmVzZXJ2ZWQ7Cit9OworCiAj ZW5kaWYgLyogX19MSU5VWF9QVUJMSUNfR05UREVWX0hfXyAqLwotLSAKMi4xNy4wCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGlu ZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK