From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752006AbeBUIEM (ORCPT ); Wed, 21 Feb 2018 03:04:12 -0500 Received: from mail-lf0-f66.google.com ([209.85.215.66]:44913 "EHLO mail-lf0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751843AbeBUIEH (ORCPT ); Wed, 21 Feb 2018 03:04:07 -0500 X-Google-Smtp-Source: AH8x224+TtG5mvA/sPr7CZZCjIg7/NoATE07Kvfi0TkbFRHDySMx90om/mC19wZpKNEh+z3Gr52Keg== From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko Subject: [PATCH 8/9] drm/xen-front: Implement GEM operations Date: Wed, 21 Feb 2018 10:03:41 +0200 Message-Id: <1519200222-20623-9-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1519200222-20623-1-git-send-email-andr2000@gmail.com> References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Implement GEM handling depending on driver mode of operation: depending on the requirements for the para-virtualized environment, namely requirements dictated by the accompanying DRM/(v)GPU drivers running in both host and guest environments, number of operating modes of para-virtualized display driver are supported: - display buffers can be allocated by either frontend driver or backend - display buffers can be allocated to be contiguous in memory or not Note! Frontend driver itself has no dependency on contiguous memory for its operation. 1. Buffers allocated by the frontend driver. The below modes of operation are configured at compile-time via frontend driver's kernel configuration. 1.1. Front driver configured to use GEM CMA helpers This use-case is useful when used with accompanying DRM/vGPU driver in guest domain which was designed to only work with contiguous buffers, e.g. DRM driver based on GEM CMA helpers: such drivers can only import contiguous PRIME buffers, thus requiring frontend driver to provide such. In order to implement this mode of operation para-virtualized frontend driver can be configured to use GEM CMA helpers. 1.2. Front driver doesn't use GEM CMA If accompanying drivers can cope with non-contiguous memory then, to lower pressure on CMA subsystem of the kernel, driver can allocate buffers from system memory. Note! If used with accompanying DRM/(v)GPU drivers this mode of operation may require IOMMU support on the platform, so accompanying DRM/vGPU hardware can still reach display buffer memory while importing PRIME buffers from the frontend driver. 2. Buffers allocated by the backend This mode of operation is run-time configured via guest domain configuration through XenStore entries. For systems which do not provide IOMMU support, but having specific requirements for display buffers it is possible to allocate such buffers at backend side and share those with the frontend. For example, if host domain is 1:1 mapped and has DRM/GPU hardware expecting physically contiguous memory, this allows implementing zero-copying use-cases. Note! Configuration options 1.1 (contiguous display buffers) and 2 (backend allocated buffers) are not supported at the same time. Signed-off-by: Oleksandr Andrushchenko --- drivers/gpu/drm/xen/Kconfig | 13 + drivers/gpu/drm/xen/Makefile | 6 + drivers/gpu/drm/xen/xen_drm_front.h | 74 ++++++ drivers/gpu/drm/xen/xen_drm_front_drv.c | 80 ++++++- drivers/gpu/drm/xen/xen_drm_front_drv.h | 1 + drivers/gpu/drm/xen/xen_drm_front_gem.c | 360 ++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_gem.h | 46 ++++ drivers/gpu/drm/xen/xen_drm_front_gem_cma.c | 93 +++++++ 8 files changed, 667 insertions(+), 6 deletions(-) create mode 100644 drivers/gpu/drm/xen/xen_drm_front_gem.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_gem.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_gem_cma.c diff --git a/drivers/gpu/drm/xen/Kconfig b/drivers/gpu/drm/xen/Kconfig index 4cca160782ab..4f4abc91f3b6 100644 --- a/drivers/gpu/drm/xen/Kconfig +++ b/drivers/gpu/drm/xen/Kconfig @@ -15,3 +15,16 @@ config DRM_XEN_FRONTEND help Choose this option if you want to enable a para-virtualized frontend DRM/KMS driver for Xen guest OSes. + +config DRM_XEN_FRONTEND_CMA + bool "Use DRM CMA to allocate dumb buffers" + depends on DRM_XEN_FRONTEND + select DRM_KMS_CMA_HELPER + select DRM_GEM_CMA_HELPER + help + Use DRM CMA helpers to allocate display buffers. + This is useful for the use-cases when guest driver needs to + share or export buffers to other drivers which only expect + contiguous buffers. + Note: in this mode driver cannot use buffers allocated + by the backend. diff --git a/drivers/gpu/drm/xen/Makefile b/drivers/gpu/drm/xen/Makefile index 4fcb0da1a9c5..12376ec78fbc 100644 --- a/drivers/gpu/drm/xen/Makefile +++ b/drivers/gpu/drm/xen/Makefile @@ -8,4 +8,10 @@ drm_xen_front-objs := xen_drm_front.o \ xen_drm_front_shbuf.o \ xen_drm_front_cfg.o +ifeq ($(CONFIG_DRM_XEN_FRONTEND_CMA),y) + drm_xen_front-objs += xen_drm_front_gem_cma.o +else + drm_xen_front-objs += xen_drm_front_gem.o +endif + obj-$(CONFIG_DRM_XEN_FRONTEND) += drm_xen_front.o diff --git a/drivers/gpu/drm/xen/xen_drm_front.h b/drivers/gpu/drm/xen/xen_drm_front.h index 9ed5bfb248d0..c6f52c892434 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.h +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -34,6 +34,80 @@ struct xen_drm_front_drm_pipeline; +/* + ******************************************************************************* + * Para-virtualized DRM/KMS frontend driver + ******************************************************************************* + * This frontend driver implements Xen para-virtualized display + * according to the display protocol described at + * include/xen/interface/io/displif.h + * + ******************************************************************************* + * Driver modes of operation in terms of display buffers used + ******************************************************************************* + * Depending on the requirements for the para-virtualized environment, namely + * requirements dictated by the accompanying DRM/(v)GPU drivers running in both + * host and guest environments, number of operating modes of para-virtualized + * display driver are supported: + * - display buffers can be allocated by either frontend driver or backend + * - display buffers can be allocated to be contiguous in memory or not + * + * Note! Frontend driver itself has no dependency on contiguous memory for + * its operation. + * + ******************************************************************************* + * 1. Buffers allocated by the frontend driver. + ******************************************************************************* + * + * The below modes of operation are configured at compile-time via + * frontend driver's kernel configuration. + * + * 1.1. Front driver configured to use GEM CMA helpers + * This use-case is useful when used with accompanying DRM/vGPU driver in + * guest domain which was designed to only work with contiguous buffers, + * e.g. DRM driver based on GEM CMA helpers: such drivers can only import + * contiguous PRIME buffers, thus requiring frontend driver to provide + * such. In order to implement this mode of operation para-virtualized + * frontend driver can be configured to use GEM CMA helpers. + * + * 1.2. Front driver doesn't use GEM CMA + * If accompanying drivers can cope with non-contiguous memory then, to + * lower pressure on CMA subsystem of the kernel, driver can allocate + * buffers from system memory. + * + * Note! If used with accompanying DRM/(v)GPU drivers this mode of operation + * may require IOMMU support on the platform, so accompanying DRM/vGPU + * hardware can still reach display buffer memory while importing PRIME + * buffers from the frontend driver. + * + ******************************************************************************* + * 2. Buffers allocated by the backend + ******************************************************************************* + * + * This mode of operation is run-time configured via guest domain configuration + * through XenStore entries. + * + * For systems which do not provide IOMMU support, but having specific + * requirements for display buffers it is possible to allocate such buffers + * at backend side and share those with the frontend. + * For example, if host domain is 1:1 mapped and has DRM/GPU hardware expecting + * physically contiguous memory, this allows implementing zero-copying + * use-cases. + * + ******************************************************************************* + * Driver limitations + ******************************************************************************* + * 1. Configuration options 1.1 (contiguous display buffers) and 2 (backend + * allocated buffers) are not supported at the same time. + * + * 2. Only primary plane without additional properties is supported. + * + * 3. Only one video mode supported which is configured via XenStore. + * + * 4. All CRTCs operate at fixed frequency of 60Hz. + * + ******************************************************************************/ + struct xen_drm_front_ops { int (*mode_set)(struct xen_drm_front_drm_pipeline *pipeline, uint32_t x, uint32_t y, uint32_t width, uint32_t height, diff --git a/drivers/gpu/drm/xen/xen_drm_front_drv.c b/drivers/gpu/drm/xen/xen_drm_front_drv.c index e8862d26ba27..35e7e9cda9d1 100644 --- a/drivers/gpu/drm/xen/xen_drm_front_drv.c +++ b/drivers/gpu/drm/xen/xen_drm_front_drv.c @@ -23,12 +23,58 @@ #include "xen_drm_front.h" #include "xen_drm_front_cfg.h" #include "xen_drm_front_drv.h" +#include "xen_drm_front_gem.h" #include "xen_drm_front_kms.h" static int dumb_create(struct drm_file *filp, struct drm_device *dev, struct drm_mode_create_dumb *args) { - return -EINVAL; + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + struct drm_gem_object *obj; + int ret; + + ret = drm_info->gem_ops->dumb_create(filp, dev, args); + if (ret) + goto fail; + + obj = drm_gem_object_lookup(filp, args->handle); + if (!obj) { + ret = -ENOENT; + goto fail_destroy; + } + + drm_gem_object_unreference_unlocked(obj); + + /* + * In case of CONFIG_DRM_XEN_FRONTEND_CMA gem_obj is constructed + * via DRM CMA helpers and doesn't have ->pages allocated + * (xendrm_gem_get_pages will return NULL), but instead can provide + * sg table + */ + if (drm_info->gem_ops->get_pages(obj)) + ret = drm_info->front_ops->dbuf_create_from_pages( + drm_info->front_info, + xen_drm_front_dbuf_to_cookie(obj), + args->width, args->height, args->bpp, + args->size, + drm_info->gem_ops->get_pages(obj)); + else + ret = drm_info->front_ops->dbuf_create_from_sgt( + drm_info->front_info, + xen_drm_front_dbuf_to_cookie(obj), + args->width, args->height, args->bpp, + args->size, + drm_info->gem_ops->prime_get_sg_table(obj)); + if (ret) + goto fail_destroy; + + return 0; + +fail_destroy: + drm_gem_dumb_destroy(filp, dev, args->handle); +fail: + DRM_ERROR("Failed to create dumb buffer: %d\n", ret); + return ret; } static void free_object(struct drm_gem_object *obj) @@ -37,6 +83,7 @@ static void free_object(struct drm_gem_object *obj) drm_info->front_ops->dbuf_destroy(drm_info->front_info, xen_drm_front_dbuf_to_cookie(obj)); + drm_info->gem_ops->free_object_unlocked(obj); } static void on_frame_done(struct platform_device *pdev, @@ -60,32 +107,52 @@ static void lastclose(struct drm_device *dev) static int gem_mmap(struct file *filp, struct vm_area_struct *vma) { - return -EINVAL; + struct drm_file *file_priv = filp->private_data; + struct drm_device *dev = file_priv->minor->dev; + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + + return drm_info->gem_ops->mmap(filp, vma); } static struct sg_table *prime_get_sg_table(struct drm_gem_object *obj) { - return NULL; + struct xen_drm_front_drm_info *drm_info; + + drm_info = obj->dev->dev_private; + return drm_info->gem_ops->prime_get_sg_table(obj); } static struct drm_gem_object *prime_import_sg_table(struct drm_device *dev, struct dma_buf_attachment *attach, struct sg_table *sgt) { - return NULL; + struct xen_drm_front_drm_info *drm_info; + + drm_info = dev->dev_private; + return drm_info->gem_ops->prime_import_sg_table(dev, attach, sgt); } static void *prime_vmap(struct drm_gem_object *obj) { - return NULL; + struct xen_drm_front_drm_info *drm_info; + + drm_info = obj->dev->dev_private; + return drm_info->gem_ops->prime_vmap(obj); } static void prime_vunmap(struct drm_gem_object *obj, void *vaddr) { + struct xen_drm_front_drm_info *drm_info; + + drm_info = obj->dev->dev_private; + drm_info->gem_ops->prime_vunmap(obj, vaddr); } static int prime_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma) { - return -EINVAL; + struct xen_drm_front_drm_info *drm_info; + + drm_info = obj->dev->dev_private; + return drm_info->gem_ops->prime_mmap(obj, vma); } static const struct file_operations xendrm_fops = { @@ -147,6 +214,7 @@ int xen_drm_front_drv_probe(struct platform_device *pdev, drm_info->front_ops = front_ops; drm_info->front_ops->on_frame_done = on_frame_done; + drm_info->gem_ops = xen_drm_front_gem_get_ops(); drm_info->front_info = cfg->front_info; dev = drm_dev_alloc(&xen_drm_driver, &pdev->dev); diff --git a/drivers/gpu/drm/xen/xen_drm_front_drv.h b/drivers/gpu/drm/xen/xen_drm_front_drv.h index 563318b19f34..34228eb86255 100644 --- a/drivers/gpu/drm/xen/xen_drm_front_drv.h +++ b/drivers/gpu/drm/xen/xen_drm_front_drv.h @@ -43,6 +43,7 @@ struct xen_drm_front_drm_pipeline { struct xen_drm_front_drm_info { struct xen_drm_front_info *front_info; struct xen_drm_front_ops *front_ops; + const struct xen_drm_front_gem_ops *gem_ops; struct drm_device *drm_dev; struct xen_drm_front_cfg *cfg; diff --git a/drivers/gpu/drm/xen/xen_drm_front_gem.c b/drivers/gpu/drm/xen/xen_drm_front_gem.c new file mode 100644 index 000000000000..367e08f6a9ef --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_gem.c @@ -0,0 +1,360 @@ +/* + * Xen para-virtual DRM device + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#include "xen_drm_front_gem.h" + +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_drv.h" +#include "xen_drm_front_shbuf.h" + +struct xen_gem_object { + struct drm_gem_object base; + + size_t num_pages; + struct page **pages; + + /* set for buffers allocated by the backend */ + bool be_alloc; + + /* this is for imported PRIME buffer */ + struct sg_table *sgt_imported; +}; + +static inline struct xen_gem_object *to_xen_gem_obj( + struct drm_gem_object *gem_obj) +{ + return container_of(gem_obj, struct xen_gem_object, base); +} + +static int gem_alloc_pages_array(struct xen_gem_object *xen_obj, + size_t buf_size) +{ + xen_obj->num_pages = DIV_ROUND_UP(buf_size, PAGE_SIZE); + xen_obj->pages = kvmalloc_array(xen_obj->num_pages, + sizeof(struct page *), GFP_KERNEL); + return xen_obj->pages == NULL ? -ENOMEM : 0; +} + +static void gem_free_pages_array(struct xen_gem_object *xen_obj) +{ + kvfree(xen_obj->pages); + xen_obj->pages = NULL; +} + +static struct xen_gem_object *gem_create_obj(struct drm_device *dev, + size_t size) +{ + struct xen_gem_object *xen_obj; + int ret; + + xen_obj = kzalloc(sizeof(*xen_obj), GFP_KERNEL); + if (!xen_obj) + return ERR_PTR(-ENOMEM); + + ret = drm_gem_object_init(dev, &xen_obj->base, size); + if (ret < 0) { + kfree(xen_obj); + return ERR_PTR(ret); + } + + return xen_obj; +} + +static struct xen_gem_object *gem_create(struct drm_device *dev, size_t size) +{ + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + struct xen_gem_object *xen_obj; + int ret; + + size = round_up(size, PAGE_SIZE); + xen_obj = gem_create_obj(dev, size); + if (IS_ERR_OR_NULL(xen_obj)) + return xen_obj; + + if (drm_info->cfg->be_alloc) { + /* + * backend will allocate space for this buffer, so + * only allocate array of pointers to pages + */ + xen_obj->be_alloc = true; + ret = gem_alloc_pages_array(xen_obj, size); + if (ret < 0) { + gem_free_pages_array(xen_obj); + goto fail; + } + + ret = alloc_xenballooned_pages(xen_obj->num_pages, + xen_obj->pages); + if (ret < 0) { + DRM_ERROR("Cannot allocate %zu ballooned pages: %d\n", + xen_obj->num_pages, ret); + goto fail; + } + + return xen_obj; + } + /* + * need to allocate backing pages now, so we can share those + * with the backend + */ + xen_obj->num_pages = DIV_ROUND_UP(size, PAGE_SIZE); + xen_obj->pages = drm_gem_get_pages(&xen_obj->base); + if (IS_ERR_OR_NULL(xen_obj->pages)) { + ret = PTR_ERR(xen_obj->pages); + xen_obj->pages = NULL; + goto fail; + } + + return xen_obj; + +fail: + DRM_ERROR("Failed to allocate buffer with size %zu\n", size); + return ERR_PTR(ret); +} + +static struct xen_gem_object *gem_create_with_handle(struct drm_file *filp, + struct drm_device *dev, size_t size, uint32_t *handle) +{ + struct xen_gem_object *xen_obj; + struct drm_gem_object *gem_obj; + int ret; + + xen_obj = gem_create(dev, size); + if (IS_ERR_OR_NULL(xen_obj)) + return xen_obj; + + gem_obj = &xen_obj->base; + ret = drm_gem_handle_create(filp, gem_obj, handle); + /* handle holds the reference */ + drm_gem_object_unreference_unlocked(gem_obj); + if (ret < 0) + return ERR_PTR(ret); + + return xen_obj; +} + +static int gem_dumb_create(struct drm_file *filp, struct drm_device *dev, + struct drm_mode_create_dumb *args) +{ + struct xen_gem_object *xen_obj; + + args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8); + args->size = args->pitch * args->height; + + xen_obj = gem_create_with_handle(filp, dev, args->size, &args->handle); + if (IS_ERR_OR_NULL(xen_obj)) + return xen_obj == NULL ? -ENOMEM : PTR_ERR(xen_obj); + + return 0; +} + +static void gem_free_object(struct drm_gem_object *gem_obj) +{ + struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj); + + if (xen_obj->base.import_attach) { + drm_prime_gem_destroy(&xen_obj->base, xen_obj->sgt_imported); + gem_free_pages_array(xen_obj); + } else { + if (xen_obj->pages) { + if (xen_obj->be_alloc) { + free_xenballooned_pages(xen_obj->num_pages, + xen_obj->pages); + gem_free_pages_array(xen_obj); + } else + drm_gem_put_pages(&xen_obj->base, + xen_obj->pages, true, false); + } + } + drm_gem_object_release(gem_obj); + kfree(xen_obj); +} + +static struct page **gem_get_pages(struct drm_gem_object *gem_obj) +{ + struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj); + + return xen_obj->pages; +} + +static struct sg_table *gem_get_sg_table(struct drm_gem_object *gem_obj) +{ + struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj); + + if (!xen_obj->pages) + return NULL; + + return drm_prime_pages_to_sg(xen_obj->pages, xen_obj->num_pages); +} + +static struct drm_gem_object *gem_import_sg_table(struct drm_device *dev, + struct dma_buf_attachment *attach, struct sg_table *sgt) +{ + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + struct xen_gem_object *xen_obj; + size_t size; + int ret; + + size = attach->dmabuf->size; + xen_obj = gem_create_obj(dev, size); + if (IS_ERR_OR_NULL(xen_obj)) + return ERR_CAST(xen_obj); + + ret = gem_alloc_pages_array(xen_obj, size); + if (ret < 0) + return ERR_PTR(ret); + + xen_obj->sgt_imported = sgt; + + ret = drm_prime_sg_to_page_addr_arrays(sgt, xen_obj->pages, + NULL, xen_obj->num_pages); + if (ret < 0) + return ERR_PTR(ret); + + /* + * N.B. Although we have an API to create display buffer from sgt + * we use pages API, because we still need those for GEM handling, + * e.g. for mapping etc. + */ + ret = drm_info->front_ops->dbuf_create_from_pages( + drm_info->front_info, + xen_drm_front_dbuf_to_cookie(&xen_obj->base), + 0, 0, 0, size, xen_obj->pages); + if (ret < 0) + return ERR_PTR(ret); + + DRM_DEBUG("Imported buffer of size %zu with nents %u\n", + size, sgt->nents); + + return &xen_obj->base; +} + +static int gem_mmap_obj(struct xen_gem_object *xen_obj, + struct vm_area_struct *vma) +{ + unsigned long addr = vma->vm_start; + int i; + + /* + * clear the VM_PFNMAP flag that was set by drm_gem_mmap(), and set the + * vm_pgoff (used as a fake buffer offset by DRM) to 0 as we want to map + * the whole buffer. + */ + vma->vm_flags &= ~VM_PFNMAP; + vma->vm_flags |= VM_MIXEDMAP; + vma->vm_pgoff = 0; + vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags)); + + /* + * vm_operations_struct.fault handler will be called if CPU access + * to VM is here. For GPUs this isn't the case, because CPU + * doesn't touch the memory. Insert pages now, so both CPU and GPU are + * happy. + * FIXME: as we insert all the pages now then no .fault handler must + * be called, so don't provide one + */ + for (i = 0; i < xen_obj->num_pages; i++) { + int ret; + + ret = vm_insert_page(vma, addr, xen_obj->pages[i]); + if (ret < 0) { + DRM_ERROR("Failed to insert pages into vma: %d\n", ret); + return ret; + } + + addr += PAGE_SIZE; + } + return 0; +} + +static int gem_mmap(struct file *filp, struct vm_area_struct *vma) +{ + struct xen_gem_object *xen_obj; + struct drm_gem_object *gem_obj; + int ret; + + ret = drm_gem_mmap(filp, vma); + if (ret < 0) + return ret; + + gem_obj = vma->vm_private_data; + xen_obj = to_xen_gem_obj(gem_obj); + return gem_mmap_obj(xen_obj, vma); +} + +static void *gem_prime_vmap(struct drm_gem_object *gem_obj) +{ + struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj); + + if (!xen_obj->pages) + return NULL; + + return vmap(xen_obj->pages, xen_obj->num_pages, + VM_MAP, pgprot_writecombine(PAGE_KERNEL)); +} + +static void gem_prime_vunmap(struct drm_gem_object *gem_obj, void *vaddr) +{ + vunmap(vaddr); +} + +static int gem_prime_mmap(struct drm_gem_object *gem_obj, + struct vm_area_struct *vma) +{ + struct xen_gem_object *xen_obj; + int ret; + + ret = drm_gem_mmap_obj(gem_obj, gem_obj->size, vma); + if (ret < 0) + return ret; + + xen_obj = to_xen_gem_obj(gem_obj); + return gem_mmap_obj(xen_obj, vma); +} + +static const struct xen_drm_front_gem_ops xen_drm_gem_ops = { + .free_object_unlocked = gem_free_object, + .prime_get_sg_table = gem_get_sg_table, + .prime_import_sg_table = gem_import_sg_table, + + .prime_vmap = gem_prime_vmap, + .prime_vunmap = gem_prime_vunmap, + .prime_mmap = gem_prime_mmap, + + .dumb_create = gem_dumb_create, + + .mmap = gem_mmap, + + .get_pages = gem_get_pages, +}; + +const struct xen_drm_front_gem_ops *xen_drm_front_gem_get_ops(void) +{ + return &xen_drm_gem_ops; +} diff --git a/drivers/gpu/drm/xen/xen_drm_front_gem.h b/drivers/gpu/drm/xen/xen_drm_front_gem.h new file mode 100644 index 000000000000..d1e1711cc3fc --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_gem.h @@ -0,0 +1,46 @@ +/* + * Xen para-virtual DRM device + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#ifndef __XEN_DRM_FRONT_GEM_H +#define __XEN_DRM_FRONT_GEM_H + +#include + +struct xen_drm_front_gem_ops { + void (*free_object_unlocked)(struct drm_gem_object *obj); + + struct sg_table *(*prime_get_sg_table)(struct drm_gem_object *obj); + struct drm_gem_object *(*prime_import_sg_table)(struct drm_device *dev, + struct dma_buf_attachment *attach, + struct sg_table *sgt); + void *(*prime_vmap)(struct drm_gem_object *obj); + void (*prime_vunmap)(struct drm_gem_object *obj, void *vaddr); + int (*prime_mmap)(struct drm_gem_object *obj, + struct vm_area_struct *vma); + + int (*dumb_create)(struct drm_file *file_priv, struct drm_device *dev, + struct drm_mode_create_dumb *args); + + int (*mmap)(struct file *filp, struct vm_area_struct *vma); + + struct page **(*get_pages)(struct drm_gem_object *obj); +}; + +const struct xen_drm_front_gem_ops *xen_drm_front_gem_get_ops(void); + +#endif /* __XEN_DRM_FRONT_GEM_H */ diff --git a/drivers/gpu/drm/xen/xen_drm_front_gem_cma.c b/drivers/gpu/drm/xen/xen_drm_front_gem_cma.c new file mode 100644 index 000000000000..5ffcbfa652d5 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_gem_cma.c @@ -0,0 +1,93 @@ +/* + * Xen para-virtual DRM device + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#include +#include +#include +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_drv.h" +#include "xen_drm_front_gem.h" + +static struct drm_gem_object *gem_import_sg_table(struct drm_device *dev, + struct dma_buf_attachment *attach, struct sg_table *sgt) +{ + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + struct drm_gem_object *gem_obj; + struct drm_gem_cma_object *cma_obj; + int ret; + + gem_obj = drm_gem_cma_prime_import_sg_table(dev, attach, sgt); + if (IS_ERR_OR_NULL(gem_obj)) + return gem_obj; + + cma_obj = to_drm_gem_cma_obj(gem_obj); + + ret = drm_info->front_ops->dbuf_create_from_sgt( + drm_info->front_info, + xen_drm_front_dbuf_to_cookie(gem_obj), + 0, 0, 0, gem_obj->size, + drm_gem_cma_prime_get_sg_table(gem_obj)); + if (ret < 0) + return ERR_PTR(ret); + + DRM_DEBUG("Imported CMA buffer of size %zu\n", gem_obj->size); + + return gem_obj; +} + +static int gem_dumb_create(struct drm_file *filp, struct drm_device *dev, + struct drm_mode_create_dumb *args) +{ + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + + if (drm_info->cfg->be_alloc) { + /* This use-case is not yet supported and probably won't be */ + DRM_ERROR("Backend allocated buffers and CMA helpers are not supported at the same time\n"); + return -EINVAL; + } + + return drm_gem_cma_dumb_create(filp, dev, args); +} + +static struct page **gem_get_pages(struct drm_gem_object *gem_obj) +{ + return NULL; +} + +static const struct xen_drm_front_gem_ops xen_drm_front_gem_cma_ops = { + .free_object_unlocked = drm_gem_cma_free_object, + .prime_get_sg_table = drm_gem_cma_prime_get_sg_table, + .prime_import_sg_table = gem_import_sg_table, + + .prime_vmap = drm_gem_cma_prime_vmap, + .prime_vunmap = drm_gem_cma_prime_vunmap, + .prime_mmap = drm_gem_cma_prime_mmap, + + .dumb_create = gem_dumb_create, + + .mmap = drm_gem_cma_mmap, + + .get_pages = gem_get_pages, +}; + +const struct xen_drm_front_gem_ops *xen_drm_front_gem_get_ops(void) +{ + return &xen_drm_front_gem_cma_ops; +} -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 8/9] drm/xen-front: Implement GEM operations Date: Wed, 21 Feb 2018 10:03:41 +0200 Message-ID: <1519200222-20623-9-git-send-email-andr2000@gmail.com> References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x241.google.com (mail-lf0-x241.google.com [IPv6:2a00:1450:4010:c07::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id 76A246E535 for ; Wed, 21 Feb 2018 08:04:07 +0000 (UTC) Received: by mail-lf0-x241.google.com with SMTP id t79so1080061lfe.3 for ; Wed, 21 Feb 2018 00:04:07 -0800 (PST) In-Reply-To: <1519200222-20623-1-git-send-email-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, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKSW1wbGVtZW50IEdFTSBoYW5kbGluZyBkZXBlbmRpbmcgb24gZHJpdmVyIG1vZGUg b2Ygb3BlcmF0aW9uOgpkZXBlbmRpbmcgb24gdGhlIHJlcXVpcmVtZW50cyBmb3IgdGhlIHBhcmEt dmlydHVhbGl6ZWQgZW52aXJvbm1lbnQsIG5hbWVseQpyZXF1aXJlbWVudHMgZGljdGF0ZWQgYnkg dGhlIGFjY29tcGFueWluZyBEUk0vKHYpR1BVIGRyaXZlcnMgcnVubmluZyBpbiBib3RoCmhvc3Qg YW5kIGd1ZXN0IGVudmlyb25tZW50cywgbnVtYmVyIG9mIG9wZXJhdGluZyBtb2RlcyBvZiBwYXJh LXZpcnR1YWxpemVkCmRpc3BsYXkgZHJpdmVyIGFyZSBzdXBwb3J0ZWQ6CiAtIGRpc3BsYXkgYnVm ZmVycyBjYW4gYmUgYWxsb2NhdGVkIGJ5IGVpdGhlciBmcm9udGVuZCBkcml2ZXIgb3IgYmFja2Vu ZAogLSBkaXNwbGF5IGJ1ZmZlcnMgY2FuIGJlIGFsbG9jYXRlZCB0byBiZSBjb250aWd1b3VzIGlu IG1lbW9yeSBvciBub3QKCk5vdGUhIEZyb250ZW5kIGRyaXZlciBpdHNlbGYgaGFzIG5vIGRlcGVu ZGVuY3kgb24gY29udGlndW91cyBtZW1vcnkgZm9yCml0cyBvcGVyYXRpb24uCgoxLiBCdWZmZXJz IGFsbG9jYXRlZCBieSB0aGUgZnJvbnRlbmQgZHJpdmVyLgoKVGhlIGJlbG93IG1vZGVzIG9mIG9w ZXJhdGlvbiBhcmUgY29uZmlndXJlZCBhdCBjb21waWxlLXRpbWUgdmlhCmZyb250ZW5kIGRyaXZl cidzIGtlcm5lbCBjb25maWd1cmF0aW9uLgoKMS4xLiBGcm9udCBkcml2ZXIgY29uZmlndXJlZCB0 byB1c2UgR0VNIENNQSBoZWxwZXJzCiAgICAgVGhpcyB1c2UtY2FzZSBpcyB1c2VmdWwgd2hlbiB1 c2VkIHdpdGggYWNjb21wYW55aW5nIERSTS92R1BVIGRyaXZlciBpbgogICAgIGd1ZXN0IGRvbWFp biB3aGljaCB3YXMgZGVzaWduZWQgdG8gb25seSB3b3JrIHdpdGggY29udGlndW91cyBidWZmZXJz LAogICAgIGUuZy4gRFJNIGRyaXZlciBiYXNlZCBvbiBHRU0gQ01BIGhlbHBlcnM6IHN1Y2ggZHJp dmVycyBjYW4gb25seSBpbXBvcnQKICAgICBjb250aWd1b3VzIFBSSU1FIGJ1ZmZlcnMsIHRodXMg cmVxdWlyaW5nIGZyb250ZW5kIGRyaXZlciB0byBwcm92aWRlCiAgICAgc3VjaC4gSW4gb3JkZXIg dG8gaW1wbGVtZW50IHRoaXMgbW9kZSBvZiBvcGVyYXRpb24gcGFyYS12aXJ0dWFsaXplZAogICAg IGZyb250ZW5kIGRyaXZlciBjYW4gYmUgY29uZmlndXJlZCB0byB1c2UgR0VNIENNQSBoZWxwZXJz LgoKMS4yLiBGcm9udCBkcml2ZXIgZG9lc24ndCB1c2UgR0VNIENNQQogICAgIElmIGFjY29tcGFu eWluZyBkcml2ZXJzIGNhbiBjb3BlIHdpdGggbm9uLWNvbnRpZ3VvdXMgbWVtb3J5IHRoZW4sIHRv CiAgICAgbG93ZXIgcHJlc3N1cmUgb24gQ01BIHN1YnN5c3RlbSBvZiB0aGUga2VybmVsLCBkcml2 ZXIgY2FuIGFsbG9jYXRlCiAgICAgYnVmZmVycyBmcm9tIHN5c3RlbSBtZW1vcnkuCgpOb3RlISBJ ZiB1c2VkIHdpdGggYWNjb21wYW55aW5nIERSTS8odilHUFUgZHJpdmVycyB0aGlzIG1vZGUgb2Yg b3BlcmF0aW9uCm1heSByZXF1aXJlIElPTU1VIHN1cHBvcnQgb24gdGhlIHBsYXRmb3JtLCBzbyBh Y2NvbXBhbnlpbmcgRFJNL3ZHUFUKaGFyZHdhcmUgY2FuIHN0aWxsIHJlYWNoIGRpc3BsYXkgYnVm ZmVyIG1lbW9yeSB3aGlsZSBpbXBvcnRpbmcgUFJJTUUKYnVmZmVycyBmcm9tIHRoZSBmcm9udGVu ZCBkcml2ZXIuCgoyLiBCdWZmZXJzIGFsbG9jYXRlZCBieSB0aGUgYmFja2VuZAoKVGhpcyBtb2Rl IG9mIG9wZXJhdGlvbiBpcyBydW4tdGltZSBjb25maWd1cmVkIHZpYSBndWVzdCBkb21haW4gY29u ZmlndXJhdGlvbgp0aHJvdWdoIFhlblN0b3JlIGVudHJpZXMuCgpGb3Igc3lzdGVtcyB3aGljaCBk byBub3QgcHJvdmlkZSBJT01NVSBzdXBwb3J0LCBidXQgaGF2aW5nIHNwZWNpZmljCnJlcXVpcmVt ZW50cyBmb3IgZGlzcGxheSBidWZmZXJzIGl0IGlzIHBvc3NpYmxlIHRvIGFsbG9jYXRlIHN1Y2gg YnVmZmVycwphdCBiYWNrZW5kIHNpZGUgYW5kIHNoYXJlIHRob3NlIHdpdGggdGhlIGZyb250ZW5k LgpGb3IgZXhhbXBsZSwgaWYgaG9zdCBkb21haW4gaXMgMToxIG1hcHBlZCBhbmQgaGFzIERSTS9H UFUgaGFyZHdhcmUgZXhwZWN0aW5nCnBoeXNpY2FsbHkgY29udGlndW91cyBtZW1vcnksIHRoaXMg YWxsb3dzIGltcGxlbWVudGluZyB6ZXJvLWNvcHlpbmcKdXNlLWNhc2VzLgoKTm90ZSEgQ29uZmln dXJhdGlvbiBvcHRpb25zIDEuMSAoY29udGlndW91cyBkaXNwbGF5IGJ1ZmZlcnMpIGFuZCAyIChi YWNrZW5kCmFsbG9jYXRlZCBidWZmZXJzKSBhcmUgbm90IHN1cHBvcnRlZCBhdCB0aGUgc2FtZSB0 aW1lLgoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9h bmRydXNoY2hlbmtvQGVwYW0uY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZyAg ICAgICAgICAgICAgICAgfCAgMTMgKwogZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSAgICAg ICAgICAgICAgICB8ICAgNiArCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaCAg ICAgICAgIHwgIDc0ICsrKysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Ry di5jICAgICB8ICA4MCArKysrKystCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf ZHJ2LmggICAgIHwgICAxICsKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0u YyAgICAgfCAzNjAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250X2dlbS5oICAgICB8ICA0NiArKysrCiBkcml2ZXJzL2dwdS9kcm0v eGVuL3hlbl9kcm1fZnJvbnRfZ2VtX2NtYS5jIHwgIDkzICsrKysrKysKIDggZmlsZXMgY2hhbmdl ZCwgNjY3IGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5oCiBjcmVhdGUgbW9kZSAx MDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEuYwoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4v S2NvbmZpZwppbmRleCA0Y2NhMTYwNzgyYWIuLjRmNGFiYzkxZjNiNiAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL3hlbi9LY29uZmlnCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZp ZwpAQCAtMTUsMyArMTUsMTYgQEAgY29uZmlnIERSTV9YRU5fRlJPTlRFTkQKIAloZWxwCiAJICBD aG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5hYmxlIGEgcGFyYS12aXJ0dWFsaXpl ZAogCSAgZnJvbnRlbmQgRFJNL0tNUyBkcml2ZXIgZm9yIFhlbiBndWVzdCBPU2VzLgorCitjb25m aWcgRFJNX1hFTl9GUk9OVEVORF9DTUEKKwlib29sICJVc2UgRFJNIENNQSB0byBhbGxvY2F0ZSBk dW1iIGJ1ZmZlcnMiCisJZGVwZW5kcyBvbiBEUk1fWEVOX0ZST05URU5ECisJc2VsZWN0IERSTV9L TVNfQ01BX0hFTFBFUgorCXNlbGVjdCBEUk1fR0VNX0NNQV9IRUxQRVIKKwloZWxwCisJICBVc2Ug RFJNIENNQSBoZWxwZXJzIHRvIGFsbG9jYXRlIGRpc3BsYXkgYnVmZmVycy4KKwkgIFRoaXMgaXMg dXNlZnVsIGZvciB0aGUgdXNlLWNhc2VzIHdoZW4gZ3Vlc3QgZHJpdmVyIG5lZWRzIHRvCisJICBz aGFyZSBvciBleHBvcnQgYnVmZmVycyB0byBvdGhlciBkcml2ZXJzIHdoaWNoIG9ubHkgZXhwZWN0 CisJICBjb250aWd1b3VzIGJ1ZmZlcnMuCisJICBOb3RlOiBpbiB0aGlzIG1vZGUgZHJpdmVyIGNh bm5vdCB1c2UgYnVmZmVycyBhbGxvY2F0ZWQKKwkgIGJ5IHRoZSBiYWNrZW5kLgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS94ZW4vTWFr ZWZpbGUKaW5kZXggNGZjYjBkYTFhOWM1Li4xMjM3NmVjNzhmYmMgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmls ZQpAQCAtOCw0ICs4LDEwIEBAIGRybV94ZW5fZnJvbnQtb2JqcyA6PSB4ZW5fZHJtX2Zyb250Lm8g XAogCQkgICAgICB4ZW5fZHJtX2Zyb250X3NoYnVmLm8gXAogCQkgICAgICB4ZW5fZHJtX2Zyb250 X2NmZy5vCiAKK2lmZXEgKCQoQ09ORklHX0RSTV9YRU5fRlJPTlRFTkRfQ01BKSx5KQorCWRybV94 ZW5fZnJvbnQtb2JqcyArPSB4ZW5fZHJtX2Zyb250X2dlbV9jbWEubworZWxzZQorCWRybV94ZW5f ZnJvbnQtb2JqcyArPSB4ZW5fZHJtX2Zyb250X2dlbS5vCitlbmRpZgorCiBvYmotJChDT05GSUdf RFJNX1hFTl9GUk9OVEVORCkgKz0gZHJtX3hlbl9mcm9udC5vCmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udC5oCmluZGV4IDllZDViZmIyNDhkMC4uYzZmNTJjODkyNDM0IDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0v eGVuL3hlbl9kcm1fZnJvbnQuaApAQCAtMzQsNiArMzQsODAgQEAKIAogc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX3BpcGVsaW5lOwogCisvKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIFBh cmEtdmlydHVhbGl6ZWQgRFJNL0tNUyBmcm9udGVuZCBkcml2ZXIKKyAqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqCisgKiBUaGlzIGZyb250ZW5kIGRyaXZlciBpbXBsZW1lbnRzIFhlbiBwYXJhLXZpcnR1 YWxpemVkIGRpc3BsYXkKKyAqIGFjY29yZGluZyB0byB0aGUgZGlzcGxheSBwcm90b2NvbCBkZXNj cmliZWQgYXQKKyAqIGluY2x1ZGUveGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmgKKyAqCisgKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKgorICogRHJpdmVyIG1vZGVzIG9mIG9wZXJhdGlvbiBpbiB0ZXJt cyBvZiBkaXNwbGF5IGJ1ZmZlcnMgdXNlZAorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIERl cGVuZGluZyBvbiB0aGUgcmVxdWlyZW1lbnRzIGZvciB0aGUgcGFyYS12aXJ0dWFsaXplZCBlbnZp cm9ubWVudCwgbmFtZWx5CisgKiByZXF1aXJlbWVudHMgZGljdGF0ZWQgYnkgdGhlIGFjY29tcGFu eWluZyBEUk0vKHYpR1BVIGRyaXZlcnMgcnVubmluZyBpbiBib3RoCisgKiBob3N0IGFuZCBndWVz dCBlbnZpcm9ubWVudHMsIG51bWJlciBvZiBvcGVyYXRpbmcgbW9kZXMgb2YgcGFyYS12aXJ0dWFs aXplZAorICogZGlzcGxheSBkcml2ZXIgYXJlIHN1cHBvcnRlZDoKKyAqICAtIGRpc3BsYXkgYnVm ZmVycyBjYW4gYmUgYWxsb2NhdGVkIGJ5IGVpdGhlciBmcm9udGVuZCBkcml2ZXIgb3IgYmFja2Vu ZAorICogIC0gZGlzcGxheSBidWZmZXJzIGNhbiBiZSBhbGxvY2F0ZWQgdG8gYmUgY29udGlndW91 cyBpbiBtZW1vcnkgb3Igbm90CisgKgorICogTm90ZSEgRnJvbnRlbmQgZHJpdmVyIGl0c2VsZiBo YXMgbm8gZGVwZW5kZW5jeSBvbiBjb250aWd1b3VzIG1lbW9yeSBmb3IKKyAqICAgICAgIGl0cyBv cGVyYXRpb24uCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIDEuIEJ1ZmZlcnMgYWxs b2NhdGVkIGJ5IHRoZSBmcm9udGVuZCBkcml2ZXIuCisgKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgor ICoKKyAqIFRoZSBiZWxvdyBtb2RlcyBvZiBvcGVyYXRpb24gYXJlIGNvbmZpZ3VyZWQgYXQgY29t cGlsZS10aW1lIHZpYQorICogZnJvbnRlbmQgZHJpdmVyJ3Mga2VybmVsIGNvbmZpZ3VyYXRpb24u CisgKgorICogMS4xLiBGcm9udCBkcml2ZXIgY29uZmlndXJlZCB0byB1c2UgR0VNIENNQSBoZWxw ZXJzCisgKiAgICAgIFRoaXMgdXNlLWNhc2UgaXMgdXNlZnVsIHdoZW4gdXNlZCB3aXRoIGFjY29t cGFueWluZyBEUk0vdkdQVSBkcml2ZXIgaW4KKyAqICAgICAgZ3Vlc3QgZG9tYWluIHdoaWNoIHdh cyBkZXNpZ25lZCB0byBvbmx5IHdvcmsgd2l0aCBjb250aWd1b3VzIGJ1ZmZlcnMsCisgKiAgICAg IGUuZy4gRFJNIGRyaXZlciBiYXNlZCBvbiBHRU0gQ01BIGhlbHBlcnM6IHN1Y2ggZHJpdmVycyBj YW4gb25seSBpbXBvcnQKKyAqICAgICAgY29udGlndW91cyBQUklNRSBidWZmZXJzLCB0aHVzIHJl cXVpcmluZyBmcm9udGVuZCBkcml2ZXIgdG8gcHJvdmlkZQorICogICAgICBzdWNoLiBJbiBvcmRl ciB0byBpbXBsZW1lbnQgdGhpcyBtb2RlIG9mIG9wZXJhdGlvbiBwYXJhLXZpcnR1YWxpemVkCisg KiAgICAgIGZyb250ZW5kIGRyaXZlciBjYW4gYmUgY29uZmlndXJlZCB0byB1c2UgR0VNIENNQSBo ZWxwZXJzLgorICoKKyAqIDEuMi4gRnJvbnQgZHJpdmVyIGRvZXNuJ3QgdXNlIEdFTSBDTUEKKyAq ICAgICAgSWYgYWNjb21wYW55aW5nIGRyaXZlcnMgY2FuIGNvcGUgd2l0aCBub24tY29udGlndW91 cyBtZW1vcnkgdGhlbiwgdG8KKyAqICAgICAgbG93ZXIgcHJlc3N1cmUgb24gQ01BIHN1YnN5c3Rl bSBvZiB0aGUga2VybmVsLCBkcml2ZXIgY2FuIGFsbG9jYXRlCisgKiAgICAgIGJ1ZmZlcnMgZnJv bSBzeXN0ZW0gbWVtb3J5LgorICoKKyAqIE5vdGUhIElmIHVzZWQgd2l0aCBhY2NvbXBhbnlpbmcg RFJNLyh2KUdQVSBkcml2ZXJzIHRoaXMgbW9kZSBvZiBvcGVyYXRpb24KKyAqICAgbWF5IHJlcXVp cmUgSU9NTVUgc3VwcG9ydCBvbiB0aGUgcGxhdGZvcm0sIHNvIGFjY29tcGFueWluZyBEUk0vdkdQ VQorICogICBoYXJkd2FyZSBjYW4gc3RpbGwgcmVhY2ggZGlzcGxheSBidWZmZXIgbWVtb3J5IHdo aWxlIGltcG9ydGluZyBQUklNRQorICogICBidWZmZXJzIGZyb20gdGhlIGZyb250ZW5kIGRyaXZl ci4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogMi4gQnVmZmVycyBhbGxvY2F0ZWQg YnkgdGhlIGJhY2tlbmQKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogVGhpcyBtb2Rl IG9mIG9wZXJhdGlvbiBpcyBydW4tdGltZSBjb25maWd1cmVkIHZpYSBndWVzdCBkb21haW4gY29u ZmlndXJhdGlvbgorICogdGhyb3VnaCBYZW5TdG9yZSBlbnRyaWVzLgorICoKKyAqIEZvciBzeXN0 ZW1zIHdoaWNoIGRvIG5vdCBwcm92aWRlIElPTU1VIHN1cHBvcnQsIGJ1dCBoYXZpbmcgc3BlY2lm aWMKKyAqIHJlcXVpcmVtZW50cyBmb3IgZGlzcGxheSBidWZmZXJzIGl0IGlzIHBvc3NpYmxlIHRv IGFsbG9jYXRlIHN1Y2ggYnVmZmVycworICogYXQgYmFja2VuZCBzaWRlIGFuZCBzaGFyZSB0aG9z ZSB3aXRoIHRoZSBmcm9udGVuZC4KKyAqIEZvciBleGFtcGxlLCBpZiBob3N0IGRvbWFpbiBpcyAx OjEgbWFwcGVkIGFuZCBoYXMgRFJNL0dQVSBoYXJkd2FyZSBleHBlY3RpbmcKKyAqIHBoeXNpY2Fs bHkgY29udGlndW91cyBtZW1vcnksIHRoaXMgYWxsb3dzIGltcGxlbWVudGluZyB6ZXJvLWNvcHlp bmcKKyAqIHVzZS1jYXNlcy4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRHJpdmVy IGxpbWl0YXRpb25zCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogMS4gQ29uZmlndXJhdGlv biBvcHRpb25zIDEuMSAoY29udGlndW91cyBkaXNwbGF5IGJ1ZmZlcnMpIGFuZCAyIChiYWNrZW5k CisgKiAgICBhbGxvY2F0ZWQgYnVmZmVycykgYXJlIG5vdCBzdXBwb3J0ZWQgYXQgdGhlIHNhbWUg dGltZS4KKyAqCisgKiAyLiBPbmx5IHByaW1hcnkgcGxhbmUgd2l0aG91dCBhZGRpdGlvbmFsIHBy b3BlcnRpZXMgaXMgc3VwcG9ydGVkLgorICoKKyAqIDMuIE9ubHkgb25lIHZpZGVvIG1vZGUgc3Vw cG9ydGVkIHdoaWNoIGlzIGNvbmZpZ3VyZWQgdmlhIFhlblN0b3JlLgorICoKKyAqIDQuIEFsbCBD UlRDcyBvcGVyYXRlIGF0IGZpeGVkIGZyZXF1ZW5jeSBvZiA2MEh6LgorICoKKyAqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKiovCisKIHN0cnVjdCB4ZW5fZHJtX2Zyb250X29wcyB7CiAJaW50ICgqbW9kZV9z ZXQpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUsCiAJCQl1aW50 MzJfdCB4LCB1aW50MzJfdCB5LCB1aW50MzJfdCB3aWR0aCwgdWludDMyX3QgaGVpZ2h0LApkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5jIGIvZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5jCmluZGV4IGU4ODYyZDI2YmEyNy4uMzVl N2U5Y2RhOWQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf ZHJ2LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5jCkBAIC0y MywxMiArMjMsNTggQEAKICNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCiAjaW5jbHVkZSAieGVu X2RybV9mcm9udF9jZmcuaCIKICNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2Rydi5oIgorI2luY2x1 ZGUgInhlbl9kcm1fZnJvbnRfZ2VtLmgiCiAjaW5jbHVkZSAieGVuX2RybV9mcm9udF9rbXMuaCIK IAogc3RhdGljIGludCBkdW1iX2NyZWF0ZShzdHJ1Y3QgZHJtX2ZpbGUgKmZpbHAsCiAJCXN0cnVj dCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fbW9kZV9jcmVhdGVfZHVtYiAqYXJncykKIHsK LQlyZXR1cm4gLUVJTlZBTDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2lu Zm8gPSBkZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqOworCWlu dCByZXQ7CisKKwlyZXQgPSBkcm1faW5mby0+Z2VtX29wcy0+ZHVtYl9jcmVhdGUoZmlscCwgZGV2 LCBhcmdzKTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWw7CisKKwlvYmogPSBkcm1fZ2VtX29iamVj dF9sb29rdXAoZmlscCwgYXJncy0+aGFuZGxlKTsKKwlpZiAoIW9iaikgeworCQlyZXQgPSAtRU5P RU5UOworCQlnb3RvIGZhaWxfZGVzdHJveTsKKwl9CisKKwlkcm1fZ2VtX29iamVjdF91bnJlZmVy ZW5jZV91bmxvY2tlZChvYmopOworCisJLyoKKwkgKiBJbiBjYXNlIG9mIENPTkZJR19EUk1fWEVO X0ZST05URU5EX0NNQSBnZW1fb2JqIGlzIGNvbnN0cnVjdGVkCisJICogdmlhIERSTSBDTUEgaGVs cGVycyBhbmQgZG9lc24ndCBoYXZlIC0+cGFnZXMgYWxsb2NhdGVkCisJICogKHhlbmRybV9nZW1f Z2V0X3BhZ2VzIHdpbGwgcmV0dXJuIE5VTEwpLCBidXQgaW5zdGVhZCBjYW4gcHJvdmlkZQorCSAq IHNnIHRhYmxlCisJICovCisJaWYgKGRybV9pbmZvLT5nZW1fb3BzLT5nZXRfcGFnZXMob2JqKSkK KwkJcmV0ID0gZHJtX2luZm8tPmZyb250X29wcy0+ZGJ1Zl9jcmVhdGVfZnJvbV9wYWdlcygKKwkJ CQlkcm1faW5mby0+ZnJvbnRfaW5mbywKKwkJCQl4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29va2ll KG9iaiksCisJCQkJYXJncy0+d2lkdGgsIGFyZ3MtPmhlaWdodCwgYXJncy0+YnBwLAorCQkJCWFy Z3MtPnNpemUsCisJCQkJZHJtX2luZm8tPmdlbV9vcHMtPmdldF9wYWdlcyhvYmopKTsKKwllbHNl CisJCXJldCA9IGRybV9pbmZvLT5mcm9udF9vcHMtPmRidWZfY3JlYXRlX2Zyb21fc2d0KAorCQkJ CWRybV9pbmZvLT5mcm9udF9pbmZvLAorCQkJCXhlbl9kcm1fZnJvbnRfZGJ1Zl90b19jb29raWUo b2JqKSwKKwkJCQlhcmdzLT53aWR0aCwgYXJncy0+aGVpZ2h0LCBhcmdzLT5icHAsCisJCQkJYXJn cy0+c2l6ZSwKKwkJCQlkcm1faW5mby0+Z2VtX29wcy0+cHJpbWVfZ2V0X3NnX3RhYmxlKG9iaikp OworCWlmIChyZXQpCisJCWdvdG8gZmFpbF9kZXN0cm95OworCisJcmV0dXJuIDA7CisKK2ZhaWxf ZGVzdHJveToKKwlkcm1fZ2VtX2R1bWJfZGVzdHJveShmaWxwLCBkZXYsIGFyZ3MtPmhhbmRsZSk7 CitmYWlsOgorCURSTV9FUlJPUigiRmFpbGVkIHRvIGNyZWF0ZSBkdW1iIGJ1ZmZlcjogJWRcbiIs IHJldCk7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIHZvaWQgZnJlZV9vYmplY3Qoc3RydWN0 IGRybV9nZW1fb2JqZWN0ICpvYmopCkBAIC0zNyw2ICs4Myw3IEBAIHN0YXRpYyB2b2lkIGZyZWVf b2JqZWN0KHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKQogCiAJZHJtX2luZm8tPmZyb250X29w cy0+ZGJ1Zl9kZXN0cm95KGRybV9pbmZvLT5mcm9udF9pbmZvLAogCQkJeGVuX2RybV9mcm9udF9k YnVmX3RvX2Nvb2tpZShvYmopKTsKKwlkcm1faW5mby0+Z2VtX29wcy0+ZnJlZV9vYmplY3RfdW5s b2NrZWQob2JqKTsKIH0KIAogc3RhdGljIHZvaWQgb25fZnJhbWVfZG9uZShzdHJ1Y3QgcGxhdGZv cm1fZGV2aWNlICpwZGV2LApAQCAtNjAsMzIgKzEwNyw1MiBAQCBzdGF0aWMgdm9pZCBsYXN0Y2xv c2Uoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAogc3RhdGljIGludCBnZW1fbW1hcChzdHJ1Y3Qg ZmlsZSAqZmlscCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiB7Ci0JcmV0dXJuIC1FSU5W QUw7CisJc3RydWN0IGRybV9maWxlICpmaWxlX3ByaXYgPSBmaWxwLT5wcml2YXRlX2RhdGE7CisJ c3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGZpbGVfcHJpdi0+bWlub3ItPmRldjsKKwlzdHJ1Y3Qg eGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBkZXYtPmRldl9wcml2YXRlOworCisJ cmV0dXJuIGRybV9pbmZvLT5nZW1fb3BzLT5tbWFwKGZpbHAsIHZtYSk7CiB9CiAKIHN0YXRpYyBz dHJ1Y3Qgc2dfdGFibGUgKnByaW1lX2dldF9zZ190YWJsZShzdHJ1Y3QgZHJtX2dlbV9vYmplY3Qg Km9iaikKIHsKLQlyZXR1cm4gTlVMTDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAq ZHJtX2luZm87CisKKwlkcm1faW5mbyA9IG9iai0+ZGV2LT5kZXZfcHJpdmF0ZTsKKwlyZXR1cm4g ZHJtX2luZm8tPmdlbV9vcHMtPnByaW1lX2dldF9zZ190YWJsZShvYmopOwogfQogCiBzdGF0aWMg c3RydWN0IGRybV9nZW1fb2JqZWN0ICpwcmltZV9pbXBvcnRfc2dfdGFibGUoc3RydWN0IGRybV9k ZXZpY2UgKmRldiwKIAkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoLCBzdHJ1Y3Qg c2dfdGFibGUgKnNndCkKIHsKLQlyZXR1cm4gTlVMTDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1faW5mbyAqZHJtX2luZm87CisKKwlkcm1faW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJcmV0 dXJuIGRybV9pbmZvLT5nZW1fb3BzLT5wcmltZV9pbXBvcnRfc2dfdGFibGUoZGV2LCBhdHRhY2gs IHNndCk7CiB9CiAKIHN0YXRpYyB2b2lkICpwcmltZV92bWFwKHN0cnVjdCBkcm1fZ2VtX29iamVj dCAqb2JqKQogewotCXJldHVybiBOVUxMOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZv ICpkcm1faW5mbzsKKworCWRybV9pbmZvID0gb2JqLT5kZXYtPmRldl9wcml2YXRlOworCXJldHVy biBkcm1faW5mby0+Z2VtX29wcy0+cHJpbWVfdm1hcChvYmopOwogfQogCiBzdGF0aWMgdm9pZCBw cmltZV92dW5tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmosIHZvaWQgKnZhZGRyKQogewor CXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbzsKKworCWRybV9pbmZvID0g b2JqLT5kZXYtPmRldl9wcml2YXRlOworCWRybV9pbmZvLT5nZW1fb3BzLT5wcmltZV92dW5tYXAo b2JqLCB2YWRkcik7CiB9CiAKIHN0YXRpYyBpbnQgcHJpbWVfbW1hcChzdHJ1Y3QgZHJtX2dlbV9v YmplY3QgKm9iaiwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiB7Ci0JcmV0dXJuIC1FSU5W QUw7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvOworCisJZHJtX2lu Zm8gPSBvYmotPmRldi0+ZGV2X3ByaXZhdGU7CisJcmV0dXJuIGRybV9pbmZvLT5nZW1fb3BzLT5w cmltZV9tbWFwKG9iaiwgdm1hKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJh dGlvbnMgeGVuZHJtX2ZvcHMgPSB7CkBAIC0xNDcsNiArMjE0LDcgQEAgaW50IHhlbl9kcm1fZnJv bnRfZHJ2X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCiAKIAlkcm1faW5mby0+ ZnJvbnRfb3BzID0gZnJvbnRfb3BzOwogCWRybV9pbmZvLT5mcm9udF9vcHMtPm9uX2ZyYW1lX2Rv bmUgPSBvbl9mcmFtZV9kb25lOworCWRybV9pbmZvLT5nZW1fb3BzID0geGVuX2RybV9mcm9udF9n ZW1fZ2V0X29wcygpOwogCWRybV9pbmZvLT5mcm9udF9pbmZvID0gY2ZnLT5mcm9udF9pbmZvOwog CiAJZGV2ID0gZHJtX2Rldl9hbGxvYygmeGVuX2RybV9kcml2ZXIsICZwZGV2LT5kZXYpOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5oIGIvZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5oCmluZGV4IDU2MzMxOGIxOWYzNC4uMzQy MjhlYjg2MjU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf ZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5oCkBAIC00 Myw2ICs0Myw3IEBAIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSB7CiBzdHJ1Y3Qg eGVuX2RybV9mcm9udF9kcm1faW5mbyB7CiAJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJv bnRfaW5mbzsKIAlzdHJ1Y3QgeGVuX2RybV9mcm9udF9vcHMgKmZyb250X29wczsKKwljb25zdCBz dHJ1Y3QgeGVuX2RybV9mcm9udF9nZW1fb3BzICpnZW1fb3BzOwogCXN0cnVjdCBkcm1fZGV2aWNl ICpkcm1fZGV2OwogCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqY2ZnOwogCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMgYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi4zNjdlMDhmNmE5ZWYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMKQEAgLTAsMCArMSwzNjAgQEAKKy8qCisgKiAgWGVu IHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBz b2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogICBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxp c2hlZCBieQorICogICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lv biAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorICoKKyAqICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3Bl IHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgIE1FUkNIQU5UQUJJTElU WSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqICAgR05V IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBDb3B5cmln aHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3Nh bmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICov CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgorCisjaW5jbHVkZSA8ZHJtL2RybVAu aD4KKyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9m Yl9oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbS5oPgorCisjaW5jbHVkZSA8bGludXgv ZG1hLWJ1Zi5oPgorI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+CisjaW5jbHVkZSA8bGlu dXgvc2htZW1fZnMuaD4KKworI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CisKKyNpbmNsdWRlICJ4 ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9kcnYuaCIKKyNpbmNsdWRl ICJ4ZW5fZHJtX2Zyb250X3NoYnVmLmgiCisKK3N0cnVjdCB4ZW5fZ2VtX29iamVjdCB7CisJc3Ry dWN0IGRybV9nZW1fb2JqZWN0IGJhc2U7CisKKwlzaXplX3QgbnVtX3BhZ2VzOworCXN0cnVjdCBw YWdlICoqcGFnZXM7CisKKwkvKiBzZXQgZm9yIGJ1ZmZlcnMgYWxsb2NhdGVkIGJ5IHRoZSBiYWNr ZW5kICovCisJYm9vbCBiZV9hbGxvYzsKKworCS8qIHRoaXMgaXMgZm9yIGltcG9ydGVkIFBSSU1F IGJ1ZmZlciAqLworCXN0cnVjdCBzZ190YWJsZSAqc2d0X2ltcG9ydGVkOworfTsKKworc3RhdGlj IGlubGluZSBzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnRvX3hlbl9nZW1fb2JqKAorCQlzdHJ1Y3Qg ZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihnZW1fb2Jq LCBzdHJ1Y3QgeGVuX2dlbV9vYmplY3QsIGJhc2UpOworfQorCitzdGF0aWMgaW50IGdlbV9hbGxv Y19wYWdlc19hcnJheShzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmosCisJCXNpemVfdCBi dWZfc2l6ZSkKK3sKKwl4ZW5fb2JqLT5udW1fcGFnZXMgPSBESVZfUk9VTkRfVVAoYnVmX3NpemUs IFBBR0VfU0laRSk7CisJeGVuX29iai0+cGFnZXMgPSBrdm1hbGxvY19hcnJheSh4ZW5fb2JqLT5u dW1fcGFnZXMsCisJCQlzaXplb2Yoc3RydWN0IHBhZ2UgKiksIEdGUF9LRVJORUwpOworCXJldHVy biB4ZW5fb2JqLT5wYWdlcyA9PSBOVUxMID8gLUVOT01FTSA6IDA7Cit9CisKK3N0YXRpYyB2b2lk IGdlbV9mcmVlX3BhZ2VzX2FycmF5KHN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaikKK3sK KwlrdmZyZWUoeGVuX29iai0+cGFnZXMpOworCXhlbl9vYmotPnBhZ2VzID0gTlVMTDsKK30KKwor c3RhdGljIHN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqZ2VtX2NyZWF0ZV9vYmooc3RydWN0IGRybV9k ZXZpY2UgKmRldiwKKwlzaXplX3Qgc2l6ZSkKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhl bl9vYmo7CisJaW50IHJldDsKKworCXhlbl9vYmogPSBremFsbG9jKHNpemVvZigqeGVuX29iaiks IEdGUF9LRVJORUwpOworCWlmICgheGVuX29iaikKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7 CisKKwlyZXQgPSBkcm1fZ2VtX29iamVjdF9pbml0KGRldiwgJnhlbl9vYmotPmJhc2UsIHNpemUp OworCWlmIChyZXQgPCAwKSB7CisJCWtmcmVlKHhlbl9vYmopOworCQlyZXR1cm4gRVJSX1BUUihy ZXQpOworCX0KKworCXJldHVybiB4ZW5fb2JqOworfQorCitzdGF0aWMgc3RydWN0IHhlbl9nZW1f b2JqZWN0ICpnZW1fY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHNpemVfdCBzaXplKQor eworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IGRldi0+ZGV2X3By aXZhdGU7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOworCWludCByZXQ7CisKKwlz aXplID0gcm91bmRfdXAoc2l6ZSwgUEFHRV9TSVpFKTsKKwl4ZW5fb2JqID0gZ2VtX2NyZWF0ZV9v YmooZGV2LCBzaXplKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoeGVuX29iaikpCisJCXJldHVybiB4 ZW5fb2JqOworCisJaWYgKGRybV9pbmZvLT5jZmctPmJlX2FsbG9jKSB7CisJCS8qCisJCSAqIGJh Y2tlbmQgd2lsbCBhbGxvY2F0ZSBzcGFjZSBmb3IgdGhpcyBidWZmZXIsIHNvCisJCSAqIG9ubHkg YWxsb2NhdGUgYXJyYXkgb2YgcG9pbnRlcnMgdG8gcGFnZXMKKwkJICovCisJCXhlbl9vYmotPmJl X2FsbG9jID0gdHJ1ZTsKKwkJcmV0ID0gZ2VtX2FsbG9jX3BhZ2VzX2FycmF5KHhlbl9vYmosIHNp emUpOworCQlpZiAocmV0IDwgMCkgeworCQkJZ2VtX2ZyZWVfcGFnZXNfYXJyYXkoeGVuX29iaik7 CisJCQlnb3RvIGZhaWw7CisJCX0KKworCQlyZXQgPSBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMo eGVuX29iai0+bnVtX3BhZ2VzLAorCQkJCXhlbl9vYmotPnBhZ2VzKTsKKwkJaWYgKHJldCA8IDAp IHsKKwkJCURSTV9FUlJPUigiQ2Fubm90IGFsbG9jYXRlICV6dSBiYWxsb29uZWQgcGFnZXM6ICVk XG4iLAorCQkJCQl4ZW5fb2JqLT5udW1fcGFnZXMsIHJldCk7CisJCQlnb3RvIGZhaWw7CisJCX0K KworCQlyZXR1cm4geGVuX29iajsKKwl9CisJLyoKKwkgKiBuZWVkIHRvIGFsbG9jYXRlIGJhY2tp bmcgcGFnZXMgbm93LCBzbyB3ZSBjYW4gc2hhcmUgdGhvc2UKKwkgKiB3aXRoIHRoZSBiYWNrZW5k CisJICovCisJeGVuX29iai0+bnVtX3BhZ2VzID0gRElWX1JPVU5EX1VQKHNpemUsIFBBR0VfU0la RSk7CisJeGVuX29iai0+cGFnZXMgPSBkcm1fZ2VtX2dldF9wYWdlcygmeGVuX29iai0+YmFzZSk7 CisJaWYgKElTX0VSUl9PUl9OVUxMKHhlbl9vYmotPnBhZ2VzKSkgeworCQlyZXQgPSBQVFJfRVJS KHhlbl9vYmotPnBhZ2VzKTsKKwkJeGVuX29iai0+cGFnZXMgPSBOVUxMOworCQlnb3RvIGZhaWw7 CisJfQorCisJcmV0dXJuIHhlbl9vYmo7CisKK2ZhaWw6CisJRFJNX0VSUk9SKCJGYWlsZWQgdG8g YWxsb2NhdGUgYnVmZmVyIHdpdGggc2l6ZSAlenVcbiIsIHNpemUpOworCXJldHVybiBFUlJfUFRS KHJldCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKmdlbV9jcmVhdGVfd2l0 aF9oYW5kbGUoc3RydWN0IGRybV9maWxlICpmaWxwLAorCQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LCBzaXplX3Qgc2l6ZSwgdWludDMyX3QgKmhhbmRsZSkKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmpl Y3QgKnhlbl9vYmo7CisJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqOworCWludCByZXQ7 CisKKwl4ZW5fb2JqID0gZ2VtX2NyZWF0ZShkZXYsIHNpemUpOworCWlmIChJU19FUlJfT1JfTlVM TCh4ZW5fb2JqKSkKKwkJcmV0dXJuIHhlbl9vYmo7CisKKwlnZW1fb2JqID0gJnhlbl9vYmotPmJh c2U7CisJcmV0ID0gZHJtX2dlbV9oYW5kbGVfY3JlYXRlKGZpbHAsIGdlbV9vYmosIGhhbmRsZSk7 CisJLyogaGFuZGxlIGhvbGRzIHRoZSByZWZlcmVuY2UgKi8KKwlkcm1fZ2VtX29iamVjdF91bnJl ZmVyZW5jZV91bmxvY2tlZChnZW1fb2JqKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIEVSUl9Q VFIocmV0KTsKKworCXJldHVybiB4ZW5fb2JqOworfQorCitzdGF0aWMgaW50IGdlbV9kdW1iX2Ny ZWF0ZShzdHJ1Y3QgZHJtX2ZpbGUgKmZpbHAsIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCXN0 cnVjdCBkcm1fbW9kZV9jcmVhdGVfZHVtYiAqYXJncykKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmpl Y3QgKnhlbl9vYmo7CisKKwlhcmdzLT5waXRjaCA9IERJVl9ST1VORF9VUChhcmdzLT53aWR0aCAq IGFyZ3MtPmJwcCwgOCk7CisJYXJncy0+c2l6ZSA9IGFyZ3MtPnBpdGNoICogYXJncy0+aGVpZ2h0 OworCisJeGVuX29iaiA9IGdlbV9jcmVhdGVfd2l0aF9oYW5kbGUoZmlscCwgZGV2LCBhcmdzLT5z aXplLCAmYXJncy0+aGFuZGxlKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoeGVuX29iaikpCisJCXJl dHVybiB4ZW5fb2JqID09IE5VTEwgPyAtRU5PTUVNIDogUFRSX0VSUih4ZW5fb2JqKTsKKworCXJl dHVybiAwOworfQorCitzdGF0aWMgdm9pZCBnZW1fZnJlZV9vYmplY3Qoc3RydWN0IGRybV9nZW1f b2JqZWN0ICpnZW1fb2JqKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiA9IHRv X3hlbl9nZW1fb2JqKGdlbV9vYmopOworCisJaWYgKHhlbl9vYmotPmJhc2UuaW1wb3J0X2F0dGFj aCkgeworCQlkcm1fcHJpbWVfZ2VtX2Rlc3Ryb3koJnhlbl9vYmotPmJhc2UsIHhlbl9vYmotPnNn dF9pbXBvcnRlZCk7CisJCWdlbV9mcmVlX3BhZ2VzX2FycmF5KHhlbl9vYmopOworCX0gZWxzZSB7 CisJCWlmICh4ZW5fb2JqLT5wYWdlcykgeworCQkJaWYgKHhlbl9vYmotPmJlX2FsbG9jKSB7CisJ CQkJZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMoeGVuX29iai0+bnVtX3BhZ2VzLAorCQkJCQkJeGVu X29iai0+cGFnZXMpOworCQkJCWdlbV9mcmVlX3BhZ2VzX2FycmF5KHhlbl9vYmopOworCQkJfSBl bHNlCisJCQkJZHJtX2dlbV9wdXRfcGFnZXMoJnhlbl9vYmotPmJhc2UsCisJCQkJCQl4ZW5fb2Jq LT5wYWdlcywgdHJ1ZSwgZmFsc2UpOworCQl9CisJfQorCWRybV9nZW1fb2JqZWN0X3JlbGVhc2Uo Z2VtX29iaik7CisJa2ZyZWUoeGVuX29iaik7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGFnZSAqKmdl bV9nZXRfcGFnZXMoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqKQoreworCXN0cnVjdCB4 ZW5fZ2VtX29iamVjdCAqeGVuX29iaiA9IHRvX3hlbl9nZW1fb2JqKGdlbV9vYmopOworCisJcmV0 dXJuIHhlbl9vYmotPnBhZ2VzOworfQorCitzdGF0aWMgc3RydWN0IHNnX3RhYmxlICpnZW1fZ2V0 X3NnX3RhYmxlKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKK3sKKwlzdHJ1Y3QgeGVu X2dlbV9vYmplY3QgKnhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1fb2JqKTsKKworCWlmICgh eGVuX29iai0+cGFnZXMpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJuIGRybV9wcmltZV9wYWdl c190b19zZyh4ZW5fb2JqLT5wYWdlcywgeGVuX29iai0+bnVtX3BhZ2VzKTsKK30KKworc3RhdGlj IHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX2ltcG9ydF9zZ190YWJsZShzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LAorCQlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gsIHN0cnVjdCBz Z190YWJsZSAqc2d0KQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5m byA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOwor CXNpemVfdCBzaXplOworCWludCByZXQ7CisKKwlzaXplID0gYXR0YWNoLT5kbWFidWYtPnNpemU7 CisJeGVuX29iaiA9IGdlbV9jcmVhdGVfb2JqKGRldiwgc2l6ZSk7CisJaWYgKElTX0VSUl9PUl9O VUxMKHhlbl9vYmopKQorCQlyZXR1cm4gRVJSX0NBU1QoeGVuX29iaik7CisKKwlyZXQgPSBnZW1f YWxsb2NfcGFnZXNfYXJyYXkoeGVuX29iaiwgc2l6ZSk7CisJaWYgKHJldCA8IDApCisJCXJldHVy biBFUlJfUFRSKHJldCk7CisKKwl4ZW5fb2JqLT5zZ3RfaW1wb3J0ZWQgPSBzZ3Q7CisKKwlyZXQg PSBkcm1fcHJpbWVfc2dfdG9fcGFnZV9hZGRyX2FycmF5cyhzZ3QsIHhlbl9vYmotPnBhZ2VzLAor CQkJTlVMTCwgeGVuX29iai0+bnVtX3BhZ2VzKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIEVS Ul9QVFIocmV0KTsKKworCS8qCisJICogTi5CLiBBbHRob3VnaCB3ZSBoYXZlIGFuIEFQSSB0byBj cmVhdGUgZGlzcGxheSBidWZmZXIgZnJvbSBzZ3QKKwkgKiB3ZSB1c2UgcGFnZXMgQVBJLCBiZWNh dXNlIHdlIHN0aWxsIG5lZWQgdGhvc2UgZm9yIEdFTSBoYW5kbGluZywKKwkgKiBlLmcuIGZvciBt YXBwaW5nIGV0Yy4KKwkgKi8KKwlyZXQgPSBkcm1faW5mby0+ZnJvbnRfb3BzLT5kYnVmX2NyZWF0 ZV9mcm9tX3BhZ2VzKAorCQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJCQl4ZW5fZHJtX2Zyb250 X2RidWZfdG9fY29va2llKCZ4ZW5fb2JqLT5iYXNlKSwKKwkJCTAsIDAsIDAsIHNpemUsIHhlbl9v YmotPnBhZ2VzKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKworCURS TV9ERUJVRygiSW1wb3J0ZWQgYnVmZmVyIG9mIHNpemUgJXp1IHdpdGggbmVudHMgJXVcbiIsCisJ CXNpemUsIHNndC0+bmVudHMpOworCisJcmV0dXJuICZ4ZW5fb2JqLT5iYXNlOworfQorCitzdGF0 aWMgaW50IGdlbV9tbWFwX29iaihzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmosCisJCXN0 cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworCXVuc2lnbmVkIGxvbmcgYWRkciA9IHZtYS0+ dm1fc3RhcnQ7CisJaW50IGk7CisKKwkvKgorCSAqIGNsZWFyIHRoZSBWTV9QRk5NQVAgZmxhZyB0 aGF0IHdhcyBzZXQgYnkgZHJtX2dlbV9tbWFwKCksIGFuZCBzZXQgdGhlCisJICogdm1fcGdvZmYg KHVzZWQgYXMgYSBmYWtlIGJ1ZmZlciBvZmZzZXQgYnkgRFJNKSB0byAwIGFzIHdlIHdhbnQgdG8g bWFwCisJICogdGhlIHdob2xlIGJ1ZmZlci4KKwkgKi8KKwl2bWEtPnZtX2ZsYWdzICY9IH5WTV9Q Rk5NQVA7CisJdm1hLT52bV9mbGFncyB8PSBWTV9NSVhFRE1BUDsKKwl2bWEtPnZtX3Bnb2ZmID0g MDsKKwl2bWEtPnZtX3BhZ2VfcHJvdCA9IHBncHJvdF93cml0ZWNvbWJpbmUodm1fZ2V0X3BhZ2Vf cHJvdCh2bWEtPnZtX2ZsYWdzKSk7CisKKwkvKgorCSAqIHZtX29wZXJhdGlvbnNfc3RydWN0LmZh dWx0IGhhbmRsZXIgd2lsbCBiZSBjYWxsZWQgaWYgQ1BVIGFjY2VzcworCSAqIHRvIFZNIGlzIGhl cmUuIEZvciBHUFVzIHRoaXMgaXNuJ3QgdGhlIGNhc2UsIGJlY2F1c2UgQ1BVCisJICogZG9lc24n dCB0b3VjaCB0aGUgbWVtb3J5LiBJbnNlcnQgcGFnZXMgbm93LCBzbyBib3RoIENQVSBhbmQgR1BV IGFyZQorCSAqIGhhcHB5LgorCSAqIEZJWE1FOiBhcyB3ZSBpbnNlcnQgYWxsIHRoZSBwYWdlcyBu b3cgdGhlbiBubyAuZmF1bHQgaGFuZGxlciBtdXN0CisJICogYmUgY2FsbGVkLCBzbyBkb24ndCBw cm92aWRlIG9uZQorCSAqLworCWZvciAoaSA9IDA7IGkgPCB4ZW5fb2JqLT5udW1fcGFnZXM7IGkr KykgeworCQlpbnQgcmV0OworCisJCXJldCA9IHZtX2luc2VydF9wYWdlKHZtYSwgYWRkciwgeGVu X29iai0+cGFnZXNbaV0pOworCQlpZiAocmV0IDwgMCkgeworCQkJRFJNX0VSUk9SKCJGYWlsZWQg dG8gaW5zZXJ0IHBhZ2VzIGludG8gdm1hOiAlZFxuIiwgcmV0KTsKKwkJCXJldHVybiByZXQ7CisJ CX0KKworCQlhZGRyICs9IFBBR0VfU0laRTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBp bnQgZ2VtX21tYXAoc3RydWN0IGZpbGUgKmZpbHAsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1h KQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsKKwlzdHJ1Y3QgZHJtX2dlbV9v YmplY3QgKmdlbV9vYmo7CisJaW50IHJldDsKKworCXJldCA9IGRybV9nZW1fbW1hcChmaWxwLCB2 bWEpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJZ2VtX29iaiA9IHZtYS0+dm1f cHJpdmF0ZV9kYXRhOworCXhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1fb2JqKTsKKwlyZXR1 cm4gZ2VtX21tYXBfb2JqKHhlbl9vYmosIHZtYSk7Cit9CisKK3N0YXRpYyB2b2lkICpnZW1fcHJp bWVfdm1hcChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJc3RydWN0IHhlbl9n ZW1fb2JqZWN0ICp4ZW5fb2JqID0gdG9feGVuX2dlbV9vYmooZ2VtX29iaik7CisKKwlpZiAoIXhl bl9vYmotPnBhZ2VzKQorCQlyZXR1cm4gTlVMTDsKKworCXJldHVybiB2bWFwKHhlbl9vYmotPnBh Z2VzLCB4ZW5fb2JqLT5udW1fcGFnZXMsCisJCQlWTV9NQVAsIHBncHJvdF93cml0ZWNvbWJpbmUo UEFHRV9LRVJORUwpKTsKK30KKworc3RhdGljIHZvaWQgZ2VtX3ByaW1lX3Z1bm1hcChzdHJ1Y3Qg ZHJtX2dlbV9vYmplY3QgKmdlbV9vYmosIHZvaWQgKnZhZGRyKQoreworCXZ1bm1hcCh2YWRkcik7 Cit9CisKK3N0YXRpYyBpbnQgZ2VtX3ByaW1lX21tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpn ZW1fb2JqLAorCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworCXN0cnVjdCB4ZW5fZ2Vt X29iamVjdCAqeGVuX29iajsKKwlpbnQgcmV0OworCisJcmV0ID0gZHJtX2dlbV9tbWFwX29iaihn ZW1fb2JqLCBnZW1fb2JqLT5zaXplLCB2bWEpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0 OworCisJeGVuX29iaiA9IHRvX3hlbl9nZW1fb2JqKGdlbV9vYmopOworCXJldHVybiBnZW1fbW1h cF9vYmooeGVuX29iaiwgdm1hKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCB4ZW5fZHJtX2Zy b250X2dlbV9vcHMgeGVuX2RybV9nZW1fb3BzID0geworCS5mcmVlX29iamVjdF91bmxvY2tlZCAg PSBnZW1fZnJlZV9vYmplY3QsCisJLnByaW1lX2dldF9zZ190YWJsZSAgICA9IGdlbV9nZXRfc2df dGFibGUsCisJLnByaW1lX2ltcG9ydF9zZ190YWJsZSA9IGdlbV9pbXBvcnRfc2dfdGFibGUsCisK KwkucHJpbWVfdm1hcCAgICAgICAgICAgID0gZ2VtX3ByaW1lX3ZtYXAsCisJLnByaW1lX3Z1bm1h cCAgICAgICAgICA9IGdlbV9wcmltZV92dW5tYXAsCisJLnByaW1lX21tYXAgICAgICAgICAgICA9 IGdlbV9wcmltZV9tbWFwLAorCisJLmR1bWJfY3JlYXRlICAgICAgICAgICA9IGdlbV9kdW1iX2Ny ZWF0ZSwKKworCS5tbWFwICAgICAgICAgICAgICAgICAgPSBnZW1fbW1hcCwKKworCS5nZXRfcGFn ZXMgICAgICAgICAgICAgPSBnZW1fZ2V0X3BhZ2VzLAorfTsKKworY29uc3Qgc3RydWN0IHhlbl9k cm1fZnJvbnRfZ2VtX29wcyAqeGVuX2RybV9mcm9udF9nZW1fZ2V0X29wcyh2b2lkKQoreworCXJl dHVybiAmeGVuX2RybV9nZW1fb3BzOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hl bi94ZW5fZHJtX2Zyb250X2dlbS5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 X2dlbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZDFlMTcxMWNj M2ZjCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 X2dlbS5oCkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2 aWNlCisgKgorICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogICB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBv cgorICogICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICAgVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgKiAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFN IFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9s ZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYgX19YRU5fRFJN X0ZST05UX0dFTV9ICisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9HRU1fSAorCisjaW5jbHVkZSA8 ZHJtL2RybVAuaD4KKworc3RydWN0IHhlbl9kcm1fZnJvbnRfZ2VtX29wcyB7CisJdm9pZCAoKmZy ZWVfb2JqZWN0X3VubG9ja2VkKShzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iaik7CisKKwlzdHJ1 Y3Qgc2dfdGFibGUgKigqcHJpbWVfZ2V0X3NnX3RhYmxlKShzdHJ1Y3QgZHJtX2dlbV9vYmplY3Qg Km9iaik7CisJc3RydWN0IGRybV9nZW1fb2JqZWN0ICooKnByaW1lX2ltcG9ydF9zZ190YWJsZSko c3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0 dGFjaCwKKwkJCXN0cnVjdCBzZ190YWJsZSAqc2d0KTsKKwl2b2lkICooKnByaW1lX3ZtYXApKHN0 cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKTsKKwl2b2lkICgqcHJpbWVfdnVubWFwKShzdHJ1Y3Qg ZHJtX2dlbV9vYmplY3QgKm9iaiwgdm9pZCAqdmFkZHIpOworCWludCAoKnByaW1lX21tYXApKHN0 cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqLAorCQkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEp OworCisJaW50ICgqZHVtYl9jcmVhdGUpKHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2LCBzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2LAorCQkJc3RydWN0IGRybV9tb2RlX2NyZWF0ZV9kdW1iICphcmdz KTsKKworCWludCAoKm1tYXApKHN0cnVjdCBmaWxlICpmaWxwLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1 Y3QgKnZtYSk7CisKKwlzdHJ1Y3QgcGFnZSAqKigqZ2V0X3BhZ2VzKShzdHJ1Y3QgZHJtX2dlbV9v YmplY3QgKm9iaik7Cit9OworCitjb25zdCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9nZW1fb3BzICp4 ZW5fZHJtX2Zyb250X2dlbV9nZXRfb3BzKHZvaWQpOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZS T05UX0dFTV9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnRfZ2VtX2NtYS5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEu YwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjVmZmNiZmE2NTJkNQot LS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW1f Y21hLmMKQEAgLTAsMCArMSw5MyBAQAorLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZp Y2UKKyAqCisgKiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiAgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiAgIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y CisgKiAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogICBUaGlz IHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0g U3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xl a3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2luY2x1ZGUgPGRybS9kcm1Q Lmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2NtYV9o ZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+CisKKyNpbmNsdWRl ICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9kcnYuaCIKKyNpbmNs dWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgorCitzdGF0aWMgc3RydWN0IGRybV9nZW1fb2JqZWN0 ICpnZW1faW1wb3J0X3NnX3RhYmxlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCXN0cnVjdCBk bWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwgc3RydWN0IHNnX3RhYmxlICpzZ3QpCit7CisJc3Ry dWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsK KwlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmo7CisJc3RydWN0IGRybV9nZW1fY21hX29i amVjdCAqY21hX29iajsKKwlpbnQgcmV0OworCisJZ2VtX29iaiA9IGRybV9nZW1fY21hX3ByaW1l X2ltcG9ydF9zZ190YWJsZShkZXYsIGF0dGFjaCwgc2d0KTsKKwlpZiAoSVNfRVJSX09SX05VTEwo Z2VtX29iaikpCisJCXJldHVybiBnZW1fb2JqOworCisJY21hX29iaiA9IHRvX2RybV9nZW1fY21h X29iaihnZW1fb2JqKTsKKworCXJldCA9IGRybV9pbmZvLT5mcm9udF9vcHMtPmRidWZfY3JlYXRl X2Zyb21fc2d0KAorCQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJCQl4ZW5fZHJtX2Zyb250X2Ri dWZfdG9fY29va2llKGdlbV9vYmopLAorCQkJMCwgMCwgMCwgZ2VtX29iai0+c2l6ZSwKKwkJCWRy bV9nZW1fY21hX3ByaW1lX2dldF9zZ190YWJsZShnZW1fb2JqKSk7CisJaWYgKHJldCA8IDApCisJ CXJldHVybiBFUlJfUFRSKHJldCk7CisKKwlEUk1fREVCVUcoIkltcG9ydGVkIENNQSBidWZmZXIg b2Ygc2l6ZSAlenVcbiIsIGdlbV9vYmotPnNpemUpOworCisJcmV0dXJuIGdlbV9vYmo7Cit9CisK K3N0YXRpYyBpbnQgZ2VtX2R1bWJfY3JlYXRlKHN0cnVjdCBkcm1fZmlsZSAqZmlscCwgc3RydWN0 IGRybV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3QgZHJtX21vZGVfY3JlYXRlX2R1bWIgKmFyZ3MpCit7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJp dmF0ZTsKKworCWlmIChkcm1faW5mby0+Y2ZnLT5iZV9hbGxvYykgeworCQkvKiBUaGlzIHVzZS1j YXNlIGlzIG5vdCB5ZXQgc3VwcG9ydGVkIGFuZCBwcm9iYWJseSB3b24ndCBiZSAqLworCQlEUk1f RVJST1IoIkJhY2tlbmQgYWxsb2NhdGVkIGJ1ZmZlcnMgYW5kIENNQSBoZWxwZXJzIGFyZSBub3Qg c3VwcG9ydGVkIGF0IHRoZSBzYW1lIHRpbWVcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisK KwlyZXR1cm4gZHJtX2dlbV9jbWFfZHVtYl9jcmVhdGUoZmlscCwgZGV2LCBhcmdzKTsKK30KKwor c3RhdGljIHN0cnVjdCBwYWdlICoqZ2VtX2dldF9wYWdlcyhzdHJ1Y3QgZHJtX2dlbV9vYmplY3Qg KmdlbV9vYmopCit7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgeGVu X2RybV9mcm9udF9nZW1fb3BzIHhlbl9kcm1fZnJvbnRfZ2VtX2NtYV9vcHMgPSB7CisJLmZyZWVf b2JqZWN0X3VubG9ja2VkICA9IGRybV9nZW1fY21hX2ZyZWVfb2JqZWN0LAorCS5wcmltZV9nZXRf c2dfdGFibGUgICAgPSBkcm1fZ2VtX2NtYV9wcmltZV9nZXRfc2dfdGFibGUsCisJLnByaW1lX2lt cG9ydF9zZ190YWJsZSA9IGdlbV9pbXBvcnRfc2dfdGFibGUsCisKKwkucHJpbWVfdm1hcCAgICAg ICAgICAgID0gZHJtX2dlbV9jbWFfcHJpbWVfdm1hcCwKKwkucHJpbWVfdnVubWFwICAgICAgICAg ID0gZHJtX2dlbV9jbWFfcHJpbWVfdnVubWFwLAorCS5wcmltZV9tbWFwICAgICAgICAgICAgPSBk cm1fZ2VtX2NtYV9wcmltZV9tbWFwLAorCisJLmR1bWJfY3JlYXRlICAgICAgICAgICA9IGdlbV9k dW1iX2NyZWF0ZSwKKworCS5tbWFwICAgICAgICAgICAgICAgICAgPSBkcm1fZ2VtX2NtYV9tbWFw LAorCisJLmdldF9wYWdlcyAgICAgICAgICAgICA9IGdlbV9nZXRfcGFnZXMsCit9OworCitjb25z dCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9nZW1fb3BzICp4ZW5fZHJtX2Zyb250X2dlbV9nZXRfb3Bz KHZvaWQpCit7CisJcmV0dXJuICZ4ZW5fZHJtX2Zyb250X2dlbV9jbWFfb3BzOworfQotLSAKMi43 LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1k ZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=