From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752076AbeBUIFZ (ORCPT ); Wed, 21 Feb 2018 03:05:25 -0500 Received: from mail-lf0-f68.google.com ([209.85.215.68]:34607 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751800AbeBUIEB (ORCPT ); Wed, 21 Feb 2018 03:04:01 -0500 X-Google-Smtp-Source: AH8x225bLKKjbk/1bxzNg4zMP/GHNoTGvezToAGYLxtq5cywqNwo+5Gr5BMUaZ93xVR529aj2OmOCA== 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 5/9] drm/xen-front: Implement handling of shared display buffers Date: Wed, 21 Feb 2018 10:03:38 +0200 Message-Id: <1519200222-20623-6-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 shared buffer handling according to the para-virtualized display device protocol at xen/interface/io/displif.h: - handle page directories according to displif protocol: - allocate and share page directories - grant references to the required set of pages for the page directory - allocate xen balllooned pages via Xen balloon driver with alloc_xenballooned_pages/free_xenballooned_pages - grant references to the required set of pages for the shared buffer itself - implement pages map/unmap for the buffers allocated by the backend (gnttab_map_refs/gnttab_unmap_refs) Signed-off-by: Oleksandr Andrushchenko --- drivers/gpu/drm/xen/Makefile | 1 + drivers/gpu/drm/xen/xen_drm_front.c | 4 + drivers/gpu/drm/xen/xen_drm_front_shbuf.c | 430 ++++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_shbuf.h | 80 ++++++ 4 files changed, 515 insertions(+) create mode 100644 drivers/gpu/drm/xen/xen_drm_front_shbuf.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_shbuf.h diff --git a/drivers/gpu/drm/xen/Makefile b/drivers/gpu/drm/xen/Makefile index 4ce7756b8437..f1823cb596c5 100644 --- a/drivers/gpu/drm/xen/Makefile +++ b/drivers/gpu/drm/xen/Makefile @@ -2,6 +2,7 @@ drm_xen_front-objs := xen_drm_front.o \ xen_drm_front_evtchnl.o \ + xen_drm_front_shbuf.o \ xen_drm_front_cfg.o obj-$(CONFIG_DRM_XEN_FRONTEND) += drm_xen_front.o diff --git a/drivers/gpu/drm/xen/xen_drm_front.c b/drivers/gpu/drm/xen/xen_drm_front.c index b558e0ae3b33..0d94ff272da3 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.c +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -26,6 +26,7 @@ #include "xen_drm_front.h" #include "xen_drm_front_evtchnl.h" +#include "xen_drm_front_shbuf.h" static struct xen_drm_front_ops front_ops = { /* placeholder for now */ @@ -199,6 +200,9 @@ static struct xenbus_driver xen_driver = { static int __init xen_drv_init(void) { + /* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */ + BUILD_BUG_ON(XEN_PAGE_SIZE != PAGE_SIZE); + if (!xen_domain()) return -ENODEV; diff --git a/drivers/gpu/drm/xen/xen_drm_front_shbuf.c b/drivers/gpu/drm/xen/xen_drm_front_shbuf.c new file mode 100644 index 000000000000..fb8dd40dd5f5 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_shbuf.c @@ -0,0 +1,430 @@ +/* + * 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 + +#if defined(CONFIG_X86) +#include +#endif +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_shbuf.h" + +struct xen_drm_front_shbuf_ops { + /* + * Calculate number of grefs required to handle this buffer, + * e.g. if grefs are required for page directory only or the buffer + * pages as well. + */ + void (*calc_num_grefs)(struct xen_drm_front_shbuf *buf); + /* Fill page directory according to para-virtual display protocol. */ + void (*fill_page_dir)(struct xen_drm_front_shbuf *buf); + /* Claim grant references for the pages of the buffer. */ + int (*grant_refs_for_buffer)(struct xen_drm_front_shbuf *buf, + grant_ref_t *priv_gref_head, int gref_idx); + /* Map grant references of the buffer. */ + int (*map)(struct xen_drm_front_shbuf *buf); + /* Unmap grant references of the buffer. */ + int (*unmap)(struct xen_drm_front_shbuf *buf); +}; + +grant_ref_t xen_drm_front_shbuf_get_dir_start(struct xen_drm_front_shbuf *buf) +{ + if (!buf->grefs) + return GRANT_INVALID_REF; + + return buf->grefs[0]; +} + +int xen_drm_front_shbuf_map(struct xen_drm_front_shbuf *buf) +{ + if (buf->ops->map) + return buf->ops->map(buf); + + /* no need to map own grant references */ + return 0; +} + +int xen_drm_front_shbuf_unmap(struct xen_drm_front_shbuf *buf) +{ + if (buf->ops->unmap) + return buf->ops->unmap(buf); + + /* no need to unmap own grant references */ + return 0; +} + +void xen_drm_front_shbuf_flush(struct xen_drm_front_shbuf *buf) +{ +#if defined(CONFIG_X86) + drm_clflush_pages(buf->pages, buf->num_pages); +#endif +} + +void xen_drm_front_shbuf_free(struct xen_drm_front_shbuf *buf) +{ + if (buf->grefs) { + int i; + + for (i = 0; i < buf->num_grefs; i++) + if (buf->grefs[i] != GRANT_INVALID_REF) + gnttab_end_foreign_access(buf->grefs[i], + 0, 0UL); + } + kfree(buf->grefs); + kfree(buf->directory); + if (buf->sgt) { + sg_free_table(buf->sgt); + kvfree(buf->pages); + } + kfree(buf); +} + +/* + * number of grefs a page can hold with respect to the + * struct xendispl_page_directory header + */ +#define XEN_DRM_NUM_GREFS_PER_PAGE ((PAGE_SIZE - \ + offsetof(struct xendispl_page_directory, gref)) / \ + sizeof(grant_ref_t)) + +static int get_num_pages_dir(struct xen_drm_front_shbuf *buf) +{ + /* number of pages the page directory consumes itself */ + return DIV_ROUND_UP(buf->num_pages, XEN_DRM_NUM_GREFS_PER_PAGE); +} + +static void backend_calc_num_grefs(struct xen_drm_front_shbuf *buf) +{ + /* only for pages the page directory consumes itself */ + buf->num_grefs = get_num_pages_dir(buf); +} + +static void guest_calc_num_grefs(struct xen_drm_front_shbuf *buf) +{ + /* + * number of pages the page directory consumes itself + * plus grefs for the buffer pages + */ + buf->num_grefs = get_num_pages_dir(buf) + buf->num_pages; +} + +#define xen_page_to_vaddr(page) \ + ((phys_addr_t)pfn_to_kaddr(page_to_xen_pfn(page))) + +static int backend_map(struct xen_drm_front_shbuf *buf) +{ + struct gnttab_map_grant_ref *map_ops = NULL; + unsigned char *ptr; + int ret, cur_gref, cur_dir_page, cur_page, grefs_left; + + map_ops = kcalloc(buf->num_pages, sizeof(*map_ops), GFP_KERNEL); + if (!map_ops) + return -ENOMEM; + + buf->backend_map_handles = kcalloc(buf->num_pages, + sizeof(*buf->backend_map_handles), GFP_KERNEL); + if (!buf->backend_map_handles) { + kfree(map_ops); + return -ENOMEM; + } + + /* + * read page directory to get grefs from the backend: for external + * buffer we only allocate buf->grefs for the page directory, + * so buf->num_grefs has number of pages in the page directory itself + */ + ptr = buf->directory; + grefs_left = buf->num_pages; + cur_page = 0; + for (cur_dir_page = 0; cur_dir_page < buf->num_grefs; cur_dir_page++) { + struct xendispl_page_directory *page_dir = + (struct xendispl_page_directory *)ptr; + int to_copy = XEN_DRM_NUM_GREFS_PER_PAGE; + + if (to_copy > grefs_left) + to_copy = grefs_left; + + for (cur_gref = 0; cur_gref < to_copy; cur_gref++) { + phys_addr_t addr; + + addr = xen_page_to_vaddr(buf->pages[cur_page]); + gnttab_set_map_op(&map_ops[cur_page], addr, + GNTMAP_host_map, + page_dir->gref[cur_gref], + buf->xb_dev->otherend_id); + cur_page++; + } + + grefs_left -= to_copy; + ptr += PAGE_SIZE; + } + ret = gnttab_map_refs(map_ops, NULL, buf->pages, buf->num_pages); + BUG_ON(ret); + + /* save handles so we can unmap on free */ + for (cur_page = 0; cur_page < buf->num_pages; cur_page++) { + buf->backend_map_handles[cur_page] = map_ops[cur_page].handle; + if (unlikely(map_ops[cur_page].status != GNTST_okay)) + DRM_ERROR("Failed to map page %d: %d\n", + cur_page, map_ops[cur_page].status); + } + + kfree(map_ops); + return 0; +} + +static int backend_unmap(struct xen_drm_front_shbuf *buf) +{ + struct gnttab_unmap_grant_ref *unmap_ops; + int i; + + if (!buf->pages || !buf->backend_map_handles || !buf->grefs) + return 0; + + unmap_ops = kcalloc(buf->num_pages, sizeof(*unmap_ops), + GFP_KERNEL); + if (!unmap_ops) { + DRM_ERROR("Failed to get memory while unmapping\n"); + return -ENOMEM; + } + + for (i = 0; i < buf->num_pages; i++) { + phys_addr_t addr; + + addr = xen_page_to_vaddr(buf->pages[i]); + gnttab_set_unmap_op(&unmap_ops[i], addr, GNTMAP_host_map, + buf->backend_map_handles[i]); + } + + BUG_ON(gnttab_unmap_refs(unmap_ops, NULL, buf->pages, + buf->num_pages)); + + for (i = 0; i < buf->num_pages; i++) { + if (unlikely(unmap_ops[i].status != GNTST_okay)) + DRM_ERROR("Failed to unmap page %d: %d\n", + i, unmap_ops[i].status); + } + + kfree(unmap_ops); + kfree(buf->backend_map_handles); + buf->backend_map_handles = NULL; + return 0; +} + +static void backend_fill_page_dir(struct xen_drm_front_shbuf *buf) +{ + struct xendispl_page_directory *page_dir; + unsigned char *ptr; + int i, num_pages_dir; + + ptr = buf->directory; + num_pages_dir = get_num_pages_dir(buf); + + /* fill only grefs for the page directory itself */ + for (i = 0; i < num_pages_dir - 1; i++) { + page_dir = (struct xendispl_page_directory *)ptr; + + page_dir->gref_dir_next_page = buf->grefs[i + 1]; + ptr += PAGE_SIZE; + } + /* last page must say there is no more pages */ + page_dir = (struct xendispl_page_directory *)ptr; + page_dir->gref_dir_next_page = GRANT_INVALID_REF; +} + +static void guest_fill_page_dir(struct xen_drm_front_shbuf *buf) +{ + unsigned char *ptr; + int cur_gref, grefs_left, to_copy, i, num_pages_dir; + + ptr = buf->directory; + num_pages_dir = get_num_pages_dir(buf); + + /* + * while copying, skip grefs at start, they are for pages + * granted for the page directory itself + */ + cur_gref = num_pages_dir; + grefs_left = buf->num_pages; + for (i = 0; i < num_pages_dir; i++) { + struct xendispl_page_directory *page_dir = + (struct xendispl_page_directory *)ptr; + + if (grefs_left <= XEN_DRM_NUM_GREFS_PER_PAGE) { + to_copy = grefs_left; + page_dir->gref_dir_next_page = GRANT_INVALID_REF; + } else { + to_copy = XEN_DRM_NUM_GREFS_PER_PAGE; + page_dir->gref_dir_next_page = buf->grefs[i + 1]; + } + memcpy(&page_dir->gref, &buf->grefs[cur_gref], + to_copy * sizeof(grant_ref_t)); + ptr += PAGE_SIZE; + grefs_left -= to_copy; + cur_gref += to_copy; + } +} + +static int guest_grant_refs_for_buffer(struct xen_drm_front_shbuf *buf, + grant_ref_t *priv_gref_head, int gref_idx) +{ + int i, cur_ref, otherend_id; + + otherend_id = buf->xb_dev->otherend_id; + for (i = 0; i < buf->num_pages; i++) { + cur_ref = gnttab_claim_grant_reference(priv_gref_head); + if (cur_ref < 0) + return cur_ref; + gnttab_grant_foreign_access_ref(cur_ref, otherend_id, + xen_page_to_gfn(buf->pages[i]), 0); + buf->grefs[gref_idx++] = cur_ref; + } + return 0; +} + +static int grant_references(struct xen_drm_front_shbuf *buf) +{ + grant_ref_t priv_gref_head; + int ret, i, j, cur_ref; + int otherend_id, num_pages_dir; + + ret = gnttab_alloc_grant_references(buf->num_grefs, &priv_gref_head); + if (ret < 0) { + DRM_ERROR("Cannot allocate grant references\n"); + return ret; + } + otherend_id = buf->xb_dev->otherend_id; + j = 0; + num_pages_dir = get_num_pages_dir(buf); + for (i = 0; i < num_pages_dir; i++) { + unsigned long frame; + + cur_ref = gnttab_claim_grant_reference(&priv_gref_head); + if (cur_ref < 0) + return cur_ref; + + frame = xen_page_to_gfn(virt_to_page(buf->directory + + PAGE_SIZE * i)); + gnttab_grant_foreign_access_ref(cur_ref, otherend_id, + frame, 0); + buf->grefs[j++] = cur_ref; + } + + if (buf->ops->grant_refs_for_buffer) { + ret = buf->ops->grant_refs_for_buffer(buf, &priv_gref_head, j); + if (ret) + return ret; + } + + gnttab_free_grant_references(priv_gref_head); + return 0; +} + +static int alloc_storage(struct xen_drm_front_shbuf *buf) +{ + if (buf->sgt) { + buf->pages = kvmalloc_array(buf->num_pages, + sizeof(struct page *), GFP_KERNEL); + if (!buf->pages) + return -ENOMEM; + + if (drm_prime_sg_to_page_addr_arrays(buf->sgt, buf->pages, + NULL, buf->num_pages) < 0) + return -EINVAL; + } + + buf->grefs = kcalloc(buf->num_grefs, sizeof(*buf->grefs), GFP_KERNEL); + if (!buf->grefs) + return -ENOMEM; + + buf->directory = kcalloc(get_num_pages_dir(buf), PAGE_SIZE, GFP_KERNEL); + if (!buf->directory) + return -ENOMEM; + + return 0; +} + +/* + * For be allocated buffers we don't need grant_refs_for_buffer as those + * grant references are allocated at backend side + */ +static const struct xen_drm_front_shbuf_ops backend_ops = { + .calc_num_grefs = backend_calc_num_grefs, + .fill_page_dir = backend_fill_page_dir, + .map = backend_map, + .unmap = backend_unmap +}; + +/* For locally granted references we do not need to map/unmap the references */ +static const struct xen_drm_front_shbuf_ops local_ops = { + .calc_num_grefs = guest_calc_num_grefs, + .fill_page_dir = guest_fill_page_dir, + .grant_refs_for_buffer = guest_grant_refs_for_buffer, +}; + +struct xen_drm_front_shbuf *xen_drm_front_shbuf_alloc( + struct xen_drm_front_shbuf_cfg *cfg) +{ + struct xen_drm_front_shbuf *buf; + int ret; + + /* either pages or sgt, not both */ + BUG_ON(cfg->pages && cfg->sgt); + + buf = kzalloc(sizeof(*buf), GFP_KERNEL); + if (!buf) + return NULL; + + if (cfg->be_alloc) + buf->ops = &backend_ops; + else + buf->ops = &local_ops; + + buf->xb_dev = cfg->xb_dev; + buf->num_pages = DIV_ROUND_UP(cfg->size, PAGE_SIZE); + buf->sgt = cfg->sgt; + buf->pages = cfg->pages; + + buf->ops->calc_num_grefs(buf); + + ret = alloc_storage(buf); + if (ret) + goto fail; + + ret = grant_references(buf); + if (ret) + goto fail; + + buf->ops->fill_page_dir(buf); + + return buf; + +fail: + xen_drm_front_shbuf_free(buf); + return ERR_PTR(ret); +} diff --git a/drivers/gpu/drm/xen/xen_drm_front_shbuf.h b/drivers/gpu/drm/xen/xen_drm_front_shbuf.h new file mode 100644 index 000000000000..48151fc18f0a --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_shbuf.h @@ -0,0 +1,80 @@ +/* + * 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_SHBUF_H_ +#define __XEN_DRM_FRONT_SHBUF_H_ + +#include +#include + +#include + +struct xen_drm_front_shbuf { + /* + * number of references granted for the backend use: + * - for allocated/imported dma-buf's this holds number of grant + * references for the page directory and pages of the buffer + * - for the buffer provided by the backend this holds number of + * grant references for the page directory as grant references for + * the buffer will be provided by the backend + */ + int num_grefs; + grant_ref_t *grefs; + unsigned char *directory; + + /* + * there are 2 ways to provide backing storage for this shared buffer: + * either pages or sgt. if buffer created from sgt then we own + * the pages and must free those ourselves on closure + */ + int num_pages; + struct page **pages; + + struct sg_table *sgt; + + struct xenbus_device *xb_dev; + + /* these are the ops used internally depending on be_alloc mode */ + const struct xen_drm_front_shbuf_ops *ops; + + /* Xen map handles for the buffer allocated by the backend */ + grant_handle_t *backend_map_handles; +}; + +struct xen_drm_front_shbuf_cfg { + struct xenbus_device *xb_dev; + size_t size; + struct page **pages; + struct sg_table *sgt; + bool be_alloc; +}; + +struct xen_drm_front_shbuf *xen_drm_front_shbuf_alloc( + struct xen_drm_front_shbuf_cfg *cfg); + +grant_ref_t xen_drm_front_shbuf_get_dir_start(struct xen_drm_front_shbuf *buf); + +int xen_drm_front_shbuf_map(struct xen_drm_front_shbuf *buf); + +int xen_drm_front_shbuf_unmap(struct xen_drm_front_shbuf *buf); + +void xen_drm_front_shbuf_flush(struct xen_drm_front_shbuf *buf); + +void xen_drm_front_shbuf_free(struct xen_drm_front_shbuf *buf); + +#endif /* __XEN_DRM_FRONT_SHBUF_H_ */ -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 5/9] drm/xen-front: Implement handling of shared display buffers Date: Wed, 21 Feb 2018 10:03:38 +0200 Message-ID: <1519200222-20623-6-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-x243.google.com (mail-lf0-x243.google.com [IPv6:2a00:1450:4010:c07::243]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8F1846E526 for ; Wed, 21 Feb 2018 08:04:01 +0000 (UTC) Received: by mail-lf0-x243.google.com with SMTP id r80so1057978lfe.13 for ; Wed, 21 Feb 2018 00:04:01 -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 YW0uY29tPgoKSW1wbGVtZW50IHNoYXJlZCBidWZmZXIgaGFuZGxpbmcgYWNjb3JkaW5nIHRvIHRo ZQpwYXJhLXZpcnR1YWxpemVkIGRpc3BsYXkgZGV2aWNlIHByb3RvY29sIGF0IHhlbi9pbnRlcmZh Y2UvaW8vZGlzcGxpZi5oOgogIC0gaGFuZGxlIHBhZ2UgZGlyZWN0b3JpZXMgYWNjb3JkaW5nIHRv IGRpc3BsaWYgcHJvdG9jb2w6CiAgICAtIGFsbG9jYXRlIGFuZCBzaGFyZSBwYWdlIGRpcmVjdG9y aWVzCiAgICAtIGdyYW50IHJlZmVyZW5jZXMgdG8gdGhlIHJlcXVpcmVkIHNldCBvZiBwYWdlcyBm b3IgdGhlCiAgICAgIHBhZ2UgZGlyZWN0b3J5CiAgLSBhbGxvY2F0ZSB4ZW4gYmFsbGxvb25lZCBw YWdlcyB2aWEgWGVuIGJhbGxvb24gZHJpdmVyCiAgICB3aXRoIGFsbG9jX3hlbmJhbGxvb25lZF9w YWdlcy9mcmVlX3hlbmJhbGxvb25lZF9wYWdlcwogIC0gZ3JhbnQgcmVmZXJlbmNlcyB0byB0aGUg cmVxdWlyZWQgc2V0IG9mIHBhZ2VzIGZvciB0aGUKICAgIHNoYXJlZCBidWZmZXIgaXRzZWxmCiAg LSBpbXBsZW1lbnQgcGFnZXMgbWFwL3VubWFwIGZvciB0aGUgYnVmZmVycyBhbGxvY2F0ZWQgYnkg dGhlCiAgICBiYWNrZW5kIChnbnR0YWJfbWFwX3JlZnMvZ250dGFiX3VubWFwX3JlZnMpCgpTaWdu ZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVu a29AZXBhbS5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSAgICAgICAgICAg ICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMgICAgICAgfCAg IDQgKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmMgfCA0MzAgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnRfc2hidWYuaCB8ICA4MCArKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgNTE1IGluc2VydGlv bnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnRfc2hidWYuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9zaGJ1Zi5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmls ZSBiL2RyaXZlcnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKaW5kZXggNGNlNzc1NmI4NDM3Li5mMTgy M2NiNTk2YzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKKysrIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZQpAQCAtMiw2ICsyLDcgQEAKIAogZHJtX3hlbl9m cm9udC1vYmpzIDo9IHhlbl9kcm1fZnJvbnQubyBcCiAJCSAgICAgIHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubC5vIFwKKwkJICAgICAgeGVuX2RybV9mcm9udF9zaGJ1Zi5vIFwKIAkJICAgICAgeGVuX2Ry bV9mcm9udF9jZmcubwogCiBvYmotJChDT05GSUdfRFJNX1hFTl9GUk9OVEVORCkgKz0gZHJtX3hl bl9mcm9udC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQu YyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5jCmluZGV4IGI1NThlMGFlM2Iz My4uMGQ5NGZmMjcyZGEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwpAQCAtMjYs NiArMjYsNyBAQAogCiAjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgogI2luY2x1ZGUgInhlbl9k cm1fZnJvbnRfZXZ0Y2hubC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfc2hidWYuaCIKIAog c3RhdGljIHN0cnVjdCB4ZW5fZHJtX2Zyb250X29wcyBmcm9udF9vcHMgPSB7CiAJLyogcGxhY2Vo b2xkZXIgZm9yIG5vdyAqLwpAQCAtMTk5LDYgKzIwMCw5IEBAIHN0YXRpYyBzdHJ1Y3QgeGVuYnVz X2RyaXZlciB4ZW5fZHJpdmVyID0gewogCiBzdGF0aWMgaW50IF9faW5pdCB4ZW5fZHJ2X2luaXQo dm9pZCkKIHsKKwkvKiBBdCB0aGUgbW9tZW50IHdlIG9ubHkgc3VwcG9ydCBjYXNlIHdpdGggWEVO X1BBR0VfU0laRSA9PSBQQUdFX1NJWkUgKi8KKwlCVUlMRF9CVUdfT04oWEVOX1BBR0VfU0laRSAh PSBQQUdFX1NJWkUpOworCiAJaWYgKCF4ZW5fZG9tYWluKCkpCiAJCXJldHVybiAtRU5PREVWOwog CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYuYyBi L2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5jCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZmI4ZGQ0MGRkNWY1Ci0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmMKQEAgLTAsMCArMSw0 MzAgQEAKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogICBUaGlz IHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y IG1vZGlmeQorICogICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogICAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICAgVGhpcyBwcm9ncmFtIGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgIGJ1dCBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisg KiAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUKKyAqICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoK KyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hl bmtvQGVwYW0uY29tPgorICovCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorCisjaWYgZGVmaW5l ZChDT05GSUdfWDg2KQorI2luY2x1ZGUgPGRybS9kcm1fY2FjaGUuaD4KKyNlbmRpZgorI2luY2x1 ZGUgPGxpbnV4L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvbW0uaD4KKworI2luY2x1ZGUgPGFz bS94ZW4vaHlwZXJ2aXNvci5oPgorI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CisjaW5jbHVkZSA8 eGVuL3hlbi5oPgorI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KKyNpbmNsdWRlIDx4ZW4vaW50ZXJm YWNlL2lvL3JpbmcuaD4KKyNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL2lvL2Rpc3BsaWYuaD4KKwor I2luY2x1ZGUgInhlbl9kcm1fZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X3NoYnVm LmgiCisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX29wcyB7CisJLyoKKwkgKiBDYWxjdWxh dGUgbnVtYmVyIG9mIGdyZWZzIHJlcXVpcmVkIHRvIGhhbmRsZSB0aGlzIGJ1ZmZlciwKKwkgKiBl LmcuIGlmIGdyZWZzIGFyZSByZXF1aXJlZCBmb3IgcGFnZSBkaXJlY3Rvcnkgb25seSBvciB0aGUg YnVmZmVyCisJICogcGFnZXMgYXMgd2VsbC4KKwkgKi8KKwl2b2lkICgqY2FsY19udW1fZ3JlZnMp KHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCS8qIEZpbGwgcGFnZSBkaXJlY3Rv cnkgYWNjb3JkaW5nIHRvIHBhcmEtdmlydHVhbCBkaXNwbGF5IHByb3RvY29sLiAqLworCXZvaWQg KCpmaWxsX3BhZ2VfZGlyKShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKTsKKwkvKiBD bGFpbSBncmFudCByZWZlcmVuY2VzIGZvciB0aGUgcGFnZXMgb2YgdGhlIGJ1ZmZlci4gKi8KKwlp bnQgKCpncmFudF9yZWZzX2Zvcl9idWZmZXIpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpi dWYsCisJCQlncmFudF9yZWZfdCAqcHJpdl9ncmVmX2hlYWQsIGludCBncmVmX2lkeCk7CisJLyog TWFwIGdyYW50IHJlZmVyZW5jZXMgb2YgdGhlIGJ1ZmZlci4gKi8KKwlpbnQgKCptYXApKHN0cnVj dCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCS8qIFVubWFwIGdyYW50IHJlZmVyZW5jZXMg b2YgdGhlIGJ1ZmZlci4gKi8KKwlpbnQgKCp1bm1hcCkoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hi dWYgKmJ1Zik7Cit9OworCitncmFudF9yZWZfdCB4ZW5fZHJtX2Zyb250X3NoYnVmX2dldF9kaXJf c3RhcnQoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwlpZiAoIWJ1Zi0+Z3Jl ZnMpCisJCXJldHVybiBHUkFOVF9JTlZBTElEX1JFRjsKKworCXJldHVybiBidWYtPmdyZWZzWzBd OworfQorCitpbnQgeGVuX2RybV9mcm9udF9zaGJ1Zl9tYXAoc3RydWN0IHhlbl9kcm1fZnJvbnRf c2hidWYgKmJ1ZikKK3sKKwlpZiAoYnVmLT5vcHMtPm1hcCkKKwkJcmV0dXJuIGJ1Zi0+b3BzLT5t YXAoYnVmKTsKKworCS8qIG5vIG5lZWQgdG8gbWFwIG93biBncmFudCByZWZlcmVuY2VzICovCisJ cmV0dXJuIDA7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X3NoYnVmX3VubWFwKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJaWYgKGJ1Zi0+b3BzLT51bm1hcCkKKwkJcmV0dXJu IGJ1Zi0+b3BzLT51bm1hcChidWYpOworCisJLyogbm8gbmVlZCB0byB1bm1hcCBvd24gZ3JhbnQg cmVmZXJlbmNlcyAqLworCXJldHVybiAwOworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfc2hidWZf Zmx1c2goc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKyNpZiBkZWZpbmVkKENP TkZJR19YODYpCisJZHJtX2NsZmx1c2hfcGFnZXMoYnVmLT5wYWdlcywgYnVmLT5udW1fcGFnZXMp OworI2VuZGlmCit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mcmVlKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJaWYgKGJ1Zi0+Z3JlZnMpIHsKKwkJaW50IGk7CisK KwkJZm9yIChpID0gMDsgaSA8IGJ1Zi0+bnVtX2dyZWZzOyBpKyspCisJCQlpZiAoYnVmLT5ncmVm c1tpXSAhPSBHUkFOVF9JTlZBTElEX1JFRikKKwkJCQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNz KGJ1Zi0+Z3JlZnNbaV0sCisJCQkJCTAsIDBVTCk7CisJfQorCWtmcmVlKGJ1Zi0+Z3JlZnMpOwor CWtmcmVlKGJ1Zi0+ZGlyZWN0b3J5KTsKKwlpZiAoYnVmLT5zZ3QpIHsKKwkJc2dfZnJlZV90YWJs ZShidWYtPnNndCk7CisJCWt2ZnJlZShidWYtPnBhZ2VzKTsKKwl9CisJa2ZyZWUoYnVmKTsKK30K KworLyoKKyAqIG51bWJlciBvZiBncmVmcyBhIHBhZ2UgY2FuIGhvbGQgd2l0aCByZXNwZWN0IHRv IHRoZQorICogc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5IGhlYWRlcgorICovCisjZGVm aW5lIFhFTl9EUk1fTlVNX0dSRUZTX1BFUl9QQUdFICgoUEFHRV9TSVpFIC0gXAorCW9mZnNldG9m KHN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSwgZ3JlZikpIC8gXAorCXNpemVvZihncmFu dF9yZWZfdCkpCisKK3N0YXRpYyBpbnQgZ2V0X251bV9wYWdlc19kaXIoc3RydWN0IHhlbl9kcm1f ZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwkvKiBudW1iZXIgb2YgcGFnZXMgdGhlIHBhZ2UgZGlyZWN0 b3J5IGNvbnN1bWVzIGl0c2VsZiAqLworCXJldHVybiBESVZfUk9VTkRfVVAoYnVmLT5udW1fcGFn ZXMsIFhFTl9EUk1fTlVNX0dSRUZTX1BFUl9QQUdFKTsKK30KKworc3RhdGljIHZvaWQgYmFja2Vu ZF9jYWxjX251bV9ncmVmcyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCS8q IG9ubHkgZm9yIHBhZ2VzIHRoZSBwYWdlIGRpcmVjdG9yeSBjb25zdW1lcyBpdHNlbGYgKi8KKwli dWYtPm51bV9ncmVmcyA9IGdldF9udW1fcGFnZXNfZGlyKGJ1Zik7Cit9CisKK3N0YXRpYyB2b2lk IGd1ZXN0X2NhbGNfbnVtX2dyZWZzKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7 CisJLyoKKwkgKiBudW1iZXIgb2YgcGFnZXMgdGhlIHBhZ2UgZGlyZWN0b3J5IGNvbnN1bWVzIGl0 c2VsZgorCSAqIHBsdXMgZ3JlZnMgZm9yIHRoZSBidWZmZXIgcGFnZXMKKwkgKi8KKwlidWYtPm51 bV9ncmVmcyA9IGdldF9udW1fcGFnZXNfZGlyKGJ1ZikgKyBidWYtPm51bV9wYWdlczsKK30KKwor I2RlZmluZSB4ZW5fcGFnZV90b192YWRkcihwYWdlKSBcCisJCSgocGh5c19hZGRyX3QpcGZuX3Rv X2thZGRyKHBhZ2VfdG9feGVuX3BmbihwYWdlKSkpCisKK3N0YXRpYyBpbnQgYmFja2VuZF9tYXAo c3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwlzdHJ1Y3QgZ250dGFiX21hcF9n cmFudF9yZWYgKm1hcF9vcHMgPSBOVUxMOworCXVuc2lnbmVkIGNoYXIgKnB0cjsKKwlpbnQgcmV0 LCBjdXJfZ3JlZiwgY3VyX2Rpcl9wYWdlLCBjdXJfcGFnZSwgZ3JlZnNfbGVmdDsKKworCW1hcF9v cHMgPSBrY2FsbG9jKGJ1Zi0+bnVtX3BhZ2VzLCBzaXplb2YoKm1hcF9vcHMpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIW1hcF9vcHMpCisJCXJldHVybiAtRU5PTUVNOworCisJYnVmLT5iYWNrZW5kX21h cF9oYW5kbGVzID0ga2NhbGxvYyhidWYtPm51bV9wYWdlcywKKwkJCXNpemVvZigqYnVmLT5iYWNr ZW5kX21hcF9oYW5kbGVzKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFidWYtPmJhY2tlbmRfbWFwX2hh bmRsZXMpIHsKKwkJa2ZyZWUobWFwX29wcyk7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCS8q CisJICogcmVhZCBwYWdlIGRpcmVjdG9yeSB0byBnZXQgZ3JlZnMgZnJvbSB0aGUgYmFja2VuZDog Zm9yIGV4dGVybmFsCisJICogYnVmZmVyIHdlIG9ubHkgYWxsb2NhdGUgYnVmLT5ncmVmcyBmb3Ig dGhlIHBhZ2UgZGlyZWN0b3J5LAorCSAqIHNvIGJ1Zi0+bnVtX2dyZWZzIGhhcyBudW1iZXIgb2Yg cGFnZXMgaW4gdGhlIHBhZ2UgZGlyZWN0b3J5IGl0c2VsZgorCSAqLworCXB0ciA9IGJ1Zi0+ZGly ZWN0b3J5OworCWdyZWZzX2xlZnQgPSBidWYtPm51bV9wYWdlczsKKwljdXJfcGFnZSA9IDA7CisJ Zm9yIChjdXJfZGlyX3BhZ2UgPSAwOyBjdXJfZGlyX3BhZ2UgPCBidWYtPm51bV9ncmVmczsgY3Vy X2Rpcl9wYWdlKyspIHsKKwkJc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICpwYWdlX2Rp ciA9CisJCQkJKHN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAqKXB0cjsKKwkJaW50IHRv X2NvcHkgPSBYRU5fRFJNX05VTV9HUkVGU19QRVJfUEFHRTsKKworCQlpZiAodG9fY29weSA+IGdy ZWZzX2xlZnQpCisJCQl0b19jb3B5ID0gZ3JlZnNfbGVmdDsKKworCQlmb3IgKGN1cl9ncmVmID0g MDsgY3VyX2dyZWYgPCB0b19jb3B5OyBjdXJfZ3JlZisrKSB7CisJCQlwaHlzX2FkZHJfdCBhZGRy OworCisJCQlhZGRyID0geGVuX3BhZ2VfdG9fdmFkZHIoYnVmLT5wYWdlc1tjdXJfcGFnZV0pOwor CQkJZ250dGFiX3NldF9tYXBfb3AoJm1hcF9vcHNbY3VyX3BhZ2VdLCBhZGRyLAorCQkJCQlHTlRN QVBfaG9zdF9tYXAsCisJCQkJCXBhZ2VfZGlyLT5ncmVmW2N1cl9ncmVmXSwKKwkJCQkJYnVmLT54 Yl9kZXYtPm90aGVyZW5kX2lkKTsKKwkJCWN1cl9wYWdlKys7CisJCX0KKworCQlncmVmc19sZWZ0 IC09IHRvX2NvcHk7CisJCXB0ciArPSBQQUdFX1NJWkU7CisJfQorCXJldCA9IGdudHRhYl9tYXBf cmVmcyhtYXBfb3BzLCBOVUxMLCBidWYtPnBhZ2VzLCBidWYtPm51bV9wYWdlcyk7CisJQlVHX09O KHJldCk7CisKKwkvKiBzYXZlIGhhbmRsZXMgc28gd2UgY2FuIHVubWFwIG9uIGZyZWUgKi8KKwlm b3IgKGN1cl9wYWdlID0gMDsgY3VyX3BhZ2UgPCBidWYtPm51bV9wYWdlczsgY3VyX3BhZ2UrKykg eworCQlidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXNbY3VyX3BhZ2VdID0gbWFwX29wc1tjdXJfcGFn ZV0uaGFuZGxlOworCQlpZiAodW5saWtlbHkobWFwX29wc1tjdXJfcGFnZV0uc3RhdHVzICE9IEdO VFNUX29rYXkpKQorCQkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gbWFwIHBhZ2UgJWQ6ICVkXG4iLAor CQkJCQljdXJfcGFnZSwgbWFwX29wc1tjdXJfcGFnZV0uc3RhdHVzKTsKKwl9CisKKwlrZnJlZSht YXBfb3BzKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiYWNrZW5kX3VubWFwKHN0cnVj dCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJc3RydWN0IGdudHRhYl91bm1hcF9ncmFu dF9yZWYgKnVubWFwX29wczsKKwlpbnQgaTsKKworCWlmICghYnVmLT5wYWdlcyB8fCAhYnVmLT5i YWNrZW5kX21hcF9oYW5kbGVzIHx8ICFidWYtPmdyZWZzKQorCQlyZXR1cm4gMDsKKworCXVubWFw X29wcyA9IGtjYWxsb2MoYnVmLT5udW1fcGFnZXMsIHNpemVvZigqdW5tYXBfb3BzKSwKKwkJR0ZQ X0tFUk5FTCk7CisJaWYgKCF1bm1hcF9vcHMpIHsKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gZ2V0 IG1lbW9yeSB3aGlsZSB1bm1hcHBpbmdcbiIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlm b3IgKGkgPSAwOyBpIDwgYnVmLT5udW1fcGFnZXM7IGkrKykgeworCQlwaHlzX2FkZHJfdCBhZGRy OworCisJCWFkZHIgPSB4ZW5fcGFnZV90b192YWRkcihidWYtPnBhZ2VzW2ldKTsKKwkJZ250dGFi X3NldF91bm1hcF9vcCgmdW5tYXBfb3BzW2ldLCBhZGRyLCBHTlRNQVBfaG9zdF9tYXAsCisJCQkJ YnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzW2ldKTsKKwl9CisKKwlCVUdfT04oZ250dGFiX3VubWFw X3JlZnModW5tYXBfb3BzLCBOVUxMLCBidWYtPnBhZ2VzLAorCQkJYnVmLT5udW1fcGFnZXMpKTsK KworCWZvciAoaSA9IDA7IGkgPCBidWYtPm51bV9wYWdlczsgaSsrKSB7CisJCWlmICh1bmxpa2Vs eSh1bm1hcF9vcHNbaV0uc3RhdHVzICE9IEdOVFNUX29rYXkpKQorCQkJRFJNX0VSUk9SKCJGYWls ZWQgdG8gdW5tYXAgcGFnZSAlZDogJWRcbiIsCisJCQkJCWksIHVubWFwX29wc1tpXS5zdGF0dXMp OworCX0KKworCWtmcmVlKHVubWFwX29wcyk7CisJa2ZyZWUoYnVmLT5iYWNrZW5kX21hcF9oYW5k bGVzKTsKKwlidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXMgPSBOVUxMOworCXJldHVybiAwOworfQor CitzdGF0aWMgdm9pZCBiYWNrZW5kX2ZpbGxfcGFnZV9kaXIoc3RydWN0IHhlbl9kcm1fZnJvbnRf c2hidWYgKmJ1ZikKK3sKKwlzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKnBhZ2VfZGly OworCXVuc2lnbmVkIGNoYXIgKnB0cjsKKwlpbnQgaSwgbnVtX3BhZ2VzX2RpcjsKKworCXB0ciA9 IGJ1Zi0+ZGlyZWN0b3J5OworCW51bV9wYWdlc19kaXIgPSBnZXRfbnVtX3BhZ2VzX2RpcihidWYp OworCisJLyogZmlsbCBvbmx5IGdyZWZzIGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgaXRzZWxmICov CisJZm9yIChpID0gMDsgaSA8IG51bV9wYWdlc19kaXIgLSAxOyBpKyspIHsKKwkJcGFnZV9kaXIg PSAoc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICopcHRyOworCisJCXBhZ2VfZGlyLT5n cmVmX2Rpcl9uZXh0X3BhZ2UgPSBidWYtPmdyZWZzW2kgKyAxXTsKKwkJcHRyICs9IFBBR0VfU0la RTsKKwl9CisJLyogbGFzdCBwYWdlIG11c3Qgc2F5IHRoZXJlIGlzIG5vIG1vcmUgcGFnZXMgKi8K KwlwYWdlX2RpciA9IChzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKilwdHI7CisJcGFn ZV9kaXItPmdyZWZfZGlyX25leHRfcGFnZSA9IEdSQU5UX0lOVkFMSURfUkVGOworfQorCitzdGF0 aWMgdm9pZCBndWVzdF9maWxsX3BhZ2VfZGlyKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpi dWYpCit7CisJdW5zaWduZWQgY2hhciAqcHRyOworCWludCBjdXJfZ3JlZiwgZ3JlZnNfbGVmdCwg dG9fY29weSwgaSwgbnVtX3BhZ2VzX2RpcjsKKworCXB0ciA9IGJ1Zi0+ZGlyZWN0b3J5OworCW51 bV9wYWdlc19kaXIgPSBnZXRfbnVtX3BhZ2VzX2RpcihidWYpOworCisJLyoKKwkgKiB3aGlsZSBj b3B5aW5nLCBza2lwIGdyZWZzIGF0IHN0YXJ0LCB0aGV5IGFyZSBmb3IgcGFnZXMKKwkgKiBncmFu dGVkIGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgaXRzZWxmCisJICovCisJY3VyX2dyZWYgPSBudW1f cGFnZXNfZGlyOworCWdyZWZzX2xlZnQgPSBidWYtPm51bV9wYWdlczsKKwlmb3IgKGkgPSAwOyBp IDwgbnVtX3BhZ2VzX2RpcjsgaSsrKSB7CisJCXN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9y eSAqcGFnZV9kaXIgPQorCQkJCShzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKilwdHI7 CisKKwkJaWYgKGdyZWZzX2xlZnQgPD0gWEVOX0RSTV9OVU1fR1JFRlNfUEVSX1BBR0UpIHsKKwkJ CXRvX2NvcHkgPSBncmVmc19sZWZ0OworCQkJcGFnZV9kaXItPmdyZWZfZGlyX25leHRfcGFnZSA9 IEdSQU5UX0lOVkFMSURfUkVGOworCQl9IGVsc2UgeworCQkJdG9fY29weSA9IFhFTl9EUk1fTlVN X0dSRUZTX1BFUl9QQUdFOworCQkJcGFnZV9kaXItPmdyZWZfZGlyX25leHRfcGFnZSA9IGJ1Zi0+ Z3JlZnNbaSArIDFdOworCQl9CisJCW1lbWNweSgmcGFnZV9kaXItPmdyZWYsICZidWYtPmdyZWZz W2N1cl9ncmVmXSwKKwkJCQl0b19jb3B5ICogc2l6ZW9mKGdyYW50X3JlZl90KSk7CisJCXB0ciAr PSBQQUdFX1NJWkU7CisJCWdyZWZzX2xlZnQgLT0gdG9fY29weTsKKwkJY3VyX2dyZWYgKz0gdG9f Y29weTsKKwl9Cit9CisKK3N0YXRpYyBpbnQgZ3Vlc3RfZ3JhbnRfcmVmc19mb3JfYnVmZmVyKHN0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYsCisJCWdyYW50X3JlZl90ICpwcml2X2dyZWZf aGVhZCwgaW50IGdyZWZfaWR4KQoreworCWludCBpLCBjdXJfcmVmLCBvdGhlcmVuZF9pZDsKKwor CW90aGVyZW5kX2lkID0gYnVmLT54Yl9kZXYtPm90aGVyZW5kX2lkOworCWZvciAoaSA9IDA7IGkg PCBidWYtPm51bV9wYWdlczsgaSsrKSB7CisJCWN1cl9yZWYgPSBnbnR0YWJfY2xhaW1fZ3JhbnRf cmVmZXJlbmNlKHByaXZfZ3JlZl9oZWFkKTsKKwkJaWYgKGN1cl9yZWYgPCAwKQorCQkJcmV0dXJu IGN1cl9yZWY7CisJCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYoY3VyX3JlZiwgb3Ro ZXJlbmRfaWQsCisJCQkJeGVuX3BhZ2VfdG9fZ2ZuKGJ1Zi0+cGFnZXNbaV0pLCAwKTsKKwkJYnVm LT5ncmVmc1tncmVmX2lkeCsrXSA9IGN1cl9yZWY7CisJfQorCXJldHVybiAwOworfQorCitzdGF0 aWMgaW50IGdyYW50X3JlZmVyZW5jZXMoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikK K3sKKwlncmFudF9yZWZfdCBwcml2X2dyZWZfaGVhZDsKKwlpbnQgcmV0LCBpLCBqLCBjdXJfcmVm OworCWludCBvdGhlcmVuZF9pZCwgbnVtX3BhZ2VzX2RpcjsKKworCXJldCA9IGdudHRhYl9hbGxv Y19ncmFudF9yZWZlcmVuY2VzKGJ1Zi0+bnVtX2dyZWZzLCAmcHJpdl9ncmVmX2hlYWQpOworCWlm IChyZXQgPCAwKSB7CisJCURSTV9FUlJPUigiQ2Fubm90IGFsbG9jYXRlIGdyYW50IHJlZmVyZW5j ZXNcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKwlvdGhlcmVuZF9pZCA9IGJ1Zi0+eGJfZGV2LT5v dGhlcmVuZF9pZDsKKwlqID0gMDsKKwludW1fcGFnZXNfZGlyID0gZ2V0X251bV9wYWdlc19kaXIo YnVmKTsKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3BhZ2VzX2RpcjsgaSsrKSB7CisJCXVuc2lnbmVk IGxvbmcgZnJhbWU7CisKKwkJY3VyX3JlZiA9IGdudHRhYl9jbGFpbV9ncmFudF9yZWZlcmVuY2Uo JnByaXZfZ3JlZl9oZWFkKTsKKwkJaWYgKGN1cl9yZWYgPCAwKQorCQkJcmV0dXJuIGN1cl9yZWY7 CisKKwkJZnJhbWUgPSB4ZW5fcGFnZV90b19nZm4odmlydF90b19wYWdlKGJ1Zi0+ZGlyZWN0b3J5 ICsKKwkJCQlQQUdFX1NJWkUgKiBpKSk7CisJCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19y ZWYoY3VyX3JlZiwgb3RoZXJlbmRfaWQsCisJCQkJZnJhbWUsIDApOworCQlidWYtPmdyZWZzW2or K10gPSBjdXJfcmVmOworCX0KKworCWlmIChidWYtPm9wcy0+Z3JhbnRfcmVmc19mb3JfYnVmZmVy KSB7CisJCXJldCA9IGJ1Zi0+b3BzLT5ncmFudF9yZWZzX2Zvcl9idWZmZXIoYnVmLCAmcHJpdl9n cmVmX2hlYWQsIGopOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwlnbnR0YWJf ZnJlZV9ncmFudF9yZWZlcmVuY2VzKHByaXZfZ3JlZl9oZWFkKTsKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBhbGxvY19zdG9yYWdlKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYp Cit7CisJaWYgKGJ1Zi0+c2d0KSB7CisJCWJ1Zi0+cGFnZXMgPSBrdm1hbGxvY19hcnJheShidWYt Pm51bV9wYWdlcywKKwkJCQlzaXplb2Yoc3RydWN0IHBhZ2UgKiksIEdGUF9LRVJORUwpOworCQlp ZiAoIWJ1Zi0+cGFnZXMpCisJCQlyZXR1cm4gLUVOT01FTTsKKworCQlpZiAoZHJtX3ByaW1lX3Nn X3RvX3BhZ2VfYWRkcl9hcnJheXMoYnVmLT5zZ3QsIGJ1Zi0+cGFnZXMsCisJCQkJTlVMTCwgYnVm LT5udW1fcGFnZXMpIDwgMCkKKwkJCXJldHVybiAtRUlOVkFMOworCX0KKworCWJ1Zi0+Z3JlZnMg PSBrY2FsbG9jKGJ1Zi0+bnVtX2dyZWZzLCBzaXplb2YoKmJ1Zi0+Z3JlZnMpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIWJ1Zi0+Z3JlZnMpCisJCXJldHVybiAtRU5PTUVNOworCisJYnVmLT5kaXJlY3Rv cnkgPSBrY2FsbG9jKGdldF9udW1fcGFnZXNfZGlyKGJ1ZiksIFBBR0VfU0laRSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFidWYtPmRpcmVjdG9yeSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlyZXR1cm4g MDsKK30KKworLyoKKyAqIEZvciBiZSBhbGxvY2F0ZWQgYnVmZmVycyB3ZSBkb24ndCBuZWVkIGdy YW50X3JlZnNfZm9yX2J1ZmZlciBhcyB0aG9zZQorICogZ3JhbnQgcmVmZXJlbmNlcyBhcmUgYWxs b2NhdGVkIGF0IGJhY2tlbmQgc2lkZQorICovCitzdGF0aWMgY29uc3Qgc3RydWN0IHhlbl9kcm1f ZnJvbnRfc2hidWZfb3BzIGJhY2tlbmRfb3BzID0geworCS5jYWxjX251bV9ncmVmcyA9IGJhY2tl bmRfY2FsY19udW1fZ3JlZnMsCisJLmZpbGxfcGFnZV9kaXIgPSBiYWNrZW5kX2ZpbGxfcGFnZV9k aXIsCisJLm1hcCA9IGJhY2tlbmRfbWFwLAorCS51bm1hcCA9IGJhY2tlbmRfdW5tYXAKK307CisK Ky8qIEZvciBsb2NhbGx5IGdyYW50ZWQgcmVmZXJlbmNlcyB3ZSBkbyBub3QgbmVlZCB0byBtYXAv dW5tYXAgdGhlIHJlZmVyZW5jZXMgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgeGVuX2RybV9mcm9u dF9zaGJ1Zl9vcHMgbG9jYWxfb3BzID0geworCS5jYWxjX251bV9ncmVmcyA9IGd1ZXN0X2NhbGNf bnVtX2dyZWZzLAorCS5maWxsX3BhZ2VfZGlyID0gZ3Vlc3RfZmlsbF9wYWdlX2RpciwKKwkuZ3Jh bnRfcmVmc19mb3JfYnVmZmVyID0gZ3Vlc3RfZ3JhbnRfcmVmc19mb3JfYnVmZmVyLAorfTsKKwor c3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKnhlbl9kcm1fZnJvbnRfc2hidWZfYWxsb2MoCisJ CXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX2NmZyAqY2ZnKQoreworCXN0cnVjdCB4ZW5fZHJt X2Zyb250X3NoYnVmICpidWY7CisJaW50IHJldDsKKworCS8qIGVpdGhlciBwYWdlcyBvciBzZ3Qs IG5vdCBib3RoICovCisJQlVHX09OKGNmZy0+cGFnZXMgJiYgY2ZnLT5zZ3QpOworCisJYnVmID0g a3phbGxvYyhzaXplb2YoKmJ1ZiksIEdGUF9LRVJORUwpOworCWlmICghYnVmKQorCQlyZXR1cm4g TlVMTDsKKworCWlmIChjZmctPmJlX2FsbG9jKQorCQlidWYtPm9wcyA9ICZiYWNrZW5kX29wczsK KwllbHNlCisJCWJ1Zi0+b3BzID0gJmxvY2FsX29wczsKKworCWJ1Zi0+eGJfZGV2ID0gY2ZnLT54 Yl9kZXY7CisJYnVmLT5udW1fcGFnZXMgPSBESVZfUk9VTkRfVVAoY2ZnLT5zaXplLCBQQUdFX1NJ WkUpOworCWJ1Zi0+c2d0ID0gY2ZnLT5zZ3Q7CisJYnVmLT5wYWdlcyA9IGNmZy0+cGFnZXM7CisK KwlidWYtPm9wcy0+Y2FsY19udW1fZ3JlZnMoYnVmKTsKKworCXJldCA9IGFsbG9jX3N0b3JhZ2Uo YnVmKTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWw7CisKKwlyZXQgPSBncmFudF9yZWZlcmVuY2Vz KGJ1Zik7CisJaWYgKHJldCkKKwkJZ290byBmYWlsOworCisJYnVmLT5vcHMtPmZpbGxfcGFnZV9k aXIoYnVmKTsKKworCXJldHVybiBidWY7CisKK2ZhaWw6CisJeGVuX2RybV9mcm9udF9zaGJ1Zl9m cmVlKGJ1Zik7CisJcmV0dXJuIEVSUl9QVFIocmV0KTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X3NoYnVmLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi40ODE1MWZjMThmMGEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfc2hidWYuaApAQCAtMCwwICsxLDgwIEBACisvKgorICogIFhlbiBwYXJh LXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqICAgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkKKyAqICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IKKyAqICAgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogICBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiAgIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogQ29weXJpZ2h0IChD KSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBB bmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisj aWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9TSEJVRl9IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRf U0hCVUZfSF8KKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L3Nj YXR0ZXJsaXN0Lmg+CisKKyNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUuaD4KKworc3RydWN0IHhl bl9kcm1fZnJvbnRfc2hidWYgeworCS8qCisJICogbnVtYmVyIG9mIHJlZmVyZW5jZXMgZ3JhbnRl ZCBmb3IgdGhlIGJhY2tlbmQgdXNlOgorCSAqICAtIGZvciBhbGxvY2F0ZWQvaW1wb3J0ZWQgZG1h LWJ1ZidzIHRoaXMgaG9sZHMgbnVtYmVyIG9mIGdyYW50CisJICogICAgcmVmZXJlbmNlcyBmb3Ig dGhlIHBhZ2UgZGlyZWN0b3J5IGFuZCBwYWdlcyBvZiB0aGUgYnVmZmVyCisJICogIC0gZm9yIHRo ZSBidWZmZXIgcHJvdmlkZWQgYnkgdGhlIGJhY2tlbmQgdGhpcyBob2xkcyBudW1iZXIgb2YKKwkg KiAgICBncmFudCByZWZlcmVuY2VzIGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgYXMgZ3JhbnQgcmVm ZXJlbmNlcyBmb3IKKwkgKiAgICB0aGUgYnVmZmVyIHdpbGwgYmUgcHJvdmlkZWQgYnkgdGhlIGJh Y2tlbmQKKwkgKi8KKwlpbnQgbnVtX2dyZWZzOworCWdyYW50X3JlZl90ICpncmVmczsKKwl1bnNp Z25lZCBjaGFyICpkaXJlY3Rvcnk7CisKKwkvKgorCSAqIHRoZXJlIGFyZSAyIHdheXMgdG8gcHJv dmlkZSBiYWNraW5nIHN0b3JhZ2UgZm9yIHRoaXMgc2hhcmVkIGJ1ZmZlcjoKKwkgKiBlaXRoZXIg cGFnZXMgb3Igc2d0LiBpZiBidWZmZXIgY3JlYXRlZCBmcm9tIHNndCB0aGVuIHdlIG93bgorCSAq IHRoZSBwYWdlcyBhbmQgbXVzdCBmcmVlIHRob3NlIG91cnNlbHZlcyBvbiBjbG9zdXJlCisJICov CisJaW50IG51bV9wYWdlczsKKwlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOworCisJc3RydWN0IHNnX3Rh YmxlICpzZ3Q7CisKKwlzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2OworCisJLyogdGhlc2Ug YXJlIHRoZSBvcHMgdXNlZCBpbnRlcm5hbGx5IGRlcGVuZGluZyBvbiBiZV9hbGxvYyBtb2RlICov CisJY29uc3Qgc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfb3BzICpvcHM7CisKKwkvKiBYZW4g bWFwIGhhbmRsZXMgZm9yIHRoZSBidWZmZXIgYWxsb2NhdGVkIGJ5IHRoZSBiYWNrZW5kICovCisJ Z3JhbnRfaGFuZGxlX3QgKmJhY2tlbmRfbWFwX2hhbmRsZXM7Cit9OworCitzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9zaGJ1Zl9jZmcgeworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXY7CisJc2l6 ZV90IHNpemU7CisJc3RydWN0IHBhZ2UgKipwYWdlczsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsK Kwlib29sIGJlX2FsbG9jOworfTsKKworc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKnhlbl9k cm1fZnJvbnRfc2hidWZfYWxsb2MoCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX2NmZyAq Y2ZnKTsKKworZ3JhbnRfcmVmX3QgeGVuX2RybV9mcm9udF9zaGJ1Zl9nZXRfZGlyX3N0YXJ0KHN0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCitpbnQgeGVuX2RybV9mcm9udF9zaGJ1 Zl9tYXAoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisKK2ludCB4ZW5fZHJtX2Zy b250X3NoYnVmX3VubWFwKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCit2b2lk IHhlbl9kcm1fZnJvbnRfc2hidWZfZmx1c2goc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1 Zik7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mcmVlKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmICpidWYpOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX1NIQlVGX0hfICovCi0t IAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K ZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==