From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753310AbdLSTug (ORCPT ); Tue, 19 Dec 2017 14:50:36 -0500 Received: from mga01.intel.com ([192.55.52.88]:17633 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752855AbdLSTgd (ORCPT ); Tue, 19 Dec 2017 14:36:33 -0500 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.45,428,1508828400"; d="scan'208";a="4018500" From: Dongwon Kim To: linux-kernel@vger.kernel.org Cc: dri-devel@lists.freedesktop.org, xen-devel@lists.xenproject.org, mateuszx.potrola@intel.com, dongwon.kim@intel.com Subject: [RFC PATCH 09/60] hyper_dmabuf: indirect DMA_BUF synchronization via shadowing Date: Tue, 19 Dec 2017 11:29:25 -0800 Message-Id: <1513711816-2618-9-git-send-email-dongwon.kim@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> References: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Importer now sends a synchronization request to the exporter when any of DMA_BUF operations on imported Hyper_DMABUF is executed (e.g dma_buf_map and dma_buf_unmap). This results in a creation of shadow DMA_BUF and exactly same DMA_BUF operation to be executed on it. The main purpose of this is to get DMA_BUF synchronized eventually between the original creator of DMA_BUF and the end consumer of it running on the importer VM. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/Makefile | 1 + drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c | 90 ++++++---- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 52 ++++-- drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c | 8 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 43 +++-- .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 189 +++++++++++++++++++++ .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.h | 6 + drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 32 +++- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 52 +++++- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h | 2 +- 10 files changed, 397 insertions(+), 78 deletions(-) create mode 100644 drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c create mode 100644 drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.h diff --git a/drivers/xen/hyper_dmabuf/Makefile b/drivers/xen/hyper_dmabuf/Makefile index 0be7445..3459382 100644 --- a/drivers/xen/hyper_dmabuf/Makefile +++ b/drivers/xen/hyper_dmabuf/Makefile @@ -7,6 +7,7 @@ ifneq ($(KERNELRELEASE),) hyper_dmabuf_list.o \ hyper_dmabuf_imp.o \ hyper_dmabuf_msg.o \ + hyper_dmabuf_remote_sync.o \ xen/hyper_dmabuf_xen_comm.o \ xen/hyper_dmabuf_xen_comm_list.o diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c index 6b16e37..2c78bc1 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c @@ -169,7 +169,8 @@ grant_ref_t hyper_dmabuf_create_addressing_tables(grant_ref_t *data_refs, int ne /* * Calculate number of pages needed for 2nd level addresing: */ - int n_2nd_level_pages = (nents/REFS_PER_PAGE + ((nents % REFS_PER_PAGE) ? 1: 0));/* rounding */ + int n_2nd_level_pages = (nents/REFS_PER_PAGE + + ((nents % REFS_PER_PAGE) ? 1: 0)); int i; unsigned long gref_page_start; grant_ref_t *tmp_page; @@ -187,7 +188,9 @@ grant_ref_t hyper_dmabuf_create_addressing_tables(grant_ref_t *data_refs, int ne /* Share 2nd level addressing pages in readonly mode*/ for (i=0; i< n_2nd_level_pages; i++) { - addr_refs[i] = gnttab_grant_foreign_access(rdomain, virt_to_mfn((unsigned long)tmp_page+i*PAGE_SIZE ), 1); + addr_refs[i] = gnttab_grant_foreign_access(rdomain, + virt_to_mfn((unsigned long)tmp_page+i*PAGE_SIZE ), + 1); } /* @@ -213,7 +216,9 @@ grant_ref_t hyper_dmabuf_create_addressing_tables(grant_ref_t *data_refs, int ne } /* Share top level addressing page in readonly mode*/ - top_level_ref = gnttab_grant_foreign_access(rdomain, virt_to_mfn((unsigned long)tmp_page), 1); + top_level_ref = gnttab_grant_foreign_access(rdomain, + virt_to_mfn((unsigned long)tmp_page), + 1); kfree(addr_refs); @@ -255,7 +260,9 @@ struct page** hyper_dmabuf_get_data_refs(grant_ref_t top_level_ref, int domid, i } addr = (unsigned long)pfn_to_kaddr(page_to_pfn(top_level_page)); - gnttab_set_map_op(&top_level_map_ops, addr, GNTMAP_host_map | GNTMAP_readonly, top_level_ref, domid); + gnttab_set_map_op(&top_level_map_ops, addr, GNTMAP_host_map | GNTMAP_readonly, + top_level_ref, domid); + gnttab_set_unmap_op(&top_level_unmap_ops, addr, GNTMAP_host_map | GNTMAP_readonly, -1); if (gnttab_map_refs(&top_level_map_ops, NULL, &top_level_page, 1)) { @@ -282,7 +289,8 @@ struct page** hyper_dmabuf_get_data_refs(grant_ref_t top_level_ref, int domid, i for (i = 0; i < n_level2_refs; i++) { addr = (unsigned long)pfn_to_kaddr(page_to_pfn(level2_pages[i])); - gnttab_set_map_op(&map_ops[i], addr, GNTMAP_host_map | GNTMAP_readonly, top_level_refs[i], domid); + gnttab_set_map_op(&map_ops[i], addr, GNTMAP_host_map | GNTMAP_readonly, + top_level_refs[i], domid); gnttab_set_unmap_op(&unmap_ops[i], addr, GNTMAP_host_map | GNTMAP_readonly, -1); } @@ -295,7 +303,7 @@ struct page** hyper_dmabuf_get_data_refs(grant_ref_t top_level_ref, int domid, i for (i = 0; i < n_level2_refs; i++) { if (map_ops[i].status) { printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d", - map_ops[i].status); + map_ops[i].status); return NULL; } else { unmap_ops[i].handle = map_ops[i].handle; @@ -331,7 +339,9 @@ grant_ref_t hyper_dmabuf_create_gref_table(struct page **pages, int rdomain, int /* share data pages in rw mode*/ for (i=0; ishared_pages_info; grant_ref_t *ref = shared_pages_info->top_level_page; - int n_2nd_level_pages = (sgt_info->sgt->nents/REFS_PER_PAGE + ((sgt_info->sgt->nents % REFS_PER_PAGE) ? 1: 0));/* rounding */ + int n_2nd_level_pages = (sgt_info->active_sgts->sgt->nents/REFS_PER_PAGE + + ((sgt_info->active_sgts->sgt->nents % REFS_PER_PAGE) ? 1: 0)); if (shared_pages_info->data_refs == NULL || @@ -384,7 +395,7 @@ int hyper_dmabuf_cleanup_gref_table(struct hyper_dmabuf_sgt_info *sgt_info) { free_pages((unsigned long)shared_pages_info->top_level_page, 1); /* End foreign access for data pages, but do not free them */ - for (i = 0; i < sgt_info->sgt->nents; i++) { + for (i = 0; i < sgt_info->active_sgts->sgt->nents; i++) { if (gnttab_query_foreign_access(shared_pages_info->data_refs[i])) { printk("refid not shared !!\n"); } @@ -404,12 +415,14 @@ int hyper_dmabuf_cleanup_gref_table(struct hyper_dmabuf_sgt_info *sgt_info) { int hyper_dmabuf_cleanup_imported_pages(struct hyper_dmabuf_imported_sgt_info *sgt_info) { struct hyper_dmabuf_shared_pages_info *shared_pages_info = &sgt_info->shared_pages_info; - if(shared_pages_info->unmap_ops == NULL || shared_pages_info->data_pages == NULL) { + if(shared_pages_info->unmap_ops == NULL || + shared_pages_info->data_pages == NULL) { printk("Imported pages already cleaned up or buffer was not imported yet\n"); return 0; } - if (gnttab_unmap_refs(shared_pages_info->unmap_ops, NULL, shared_pages_info->data_pages, sgt_info->nents) ) { + if (gnttab_unmap_refs(shared_pages_info->unmap_ops, NULL, + shared_pages_info->data_pages, sgt_info->nents) ) { printk("Cannot unmap data pages\n"); return -EINVAL; } @@ -424,7 +437,8 @@ int hyper_dmabuf_cleanup_imported_pages(struct hyper_dmabuf_imported_sgt_info *s } /* map and construct sg_lists from reference numbers */ -struct sg_table* hyper_dmabuf_map_pages(grant_ref_t top_level_gref, int frst_ofst, int last_len, int nents, int sdomain, +struct sg_table* hyper_dmabuf_map_pages(grant_ref_t top_level_gref, int frst_ofst, + int last_len, int nents, int sdomain, struct hyper_dmabuf_shared_pages_info *shared_pages_info) { struct sg_table *st; @@ -451,13 +465,16 @@ struct sg_table* hyper_dmabuf_map_pages(grant_ref_t top_level_gref, int frst_ofs return NULL; } - ops = (struct gnttab_map_grant_ref *)kcalloc(nents, sizeof(struct gnttab_map_grant_ref), GFP_KERNEL); - unmap_ops = (struct gnttab_unmap_grant_ref *)kcalloc(nents, sizeof(struct gnttab_unmap_grant_ref), GFP_KERNEL); + ops = kcalloc(nents, sizeof(struct gnttab_map_grant_ref), + GFP_KERNEL); + unmap_ops = kcalloc(nents, sizeof(struct gnttab_unmap_grant_ref), + GFP_KERNEL); for (i=0; iunmap_ops, NULL, refid_pages, n_level2_refs) ) { + if (gnttab_unmap_refs(shared_pages_info->unmap_ops, NULL, refid_pages, + n_level2_refs) ) { printk("Cannot unmap 2nd level refs\n"); return NULL; } @@ -507,10 +525,8 @@ inline int hyper_dmabuf_sync_request_and_wait(int id, int ops) hyper_dmabuf_create_request(req, HYPER_DMABUF_OPS_TO_SOURCE, &operands[0]); - /* send request */ - ret = hyper_dmabuf_send_request(id, req); - - /* TODO: wait until it gets response.. or can we just move on? */ + /* send request and wait for a response */ + ret = hyper_dmabuf_send_request(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(id), req, true); kfree(req); @@ -528,14 +544,14 @@ static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf, struct device* dev, sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), - HYPER_DMABUF_OPS_ATTACH); + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, + HYPER_DMABUF_OPS_ATTACH); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); + return ret; } - /* Ignoring ret for now */ return 0; } @@ -549,8 +565,8 @@ static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf, struct dma_buf_attac sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), - HYPER_DMABUF_OPS_DETACH); + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, + HYPER_DMABUF_OPS_DETACH); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -583,7 +599,7 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme goto err_free_sg; } - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_MAP); if (ret < 0) { @@ -615,7 +631,7 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment, sg_free_table(sg); kfree(sg); - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_UNMAP); if (ret < 0) { @@ -633,7 +649,7 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dmabuf) sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_RELEASE); if (ret < 0) { @@ -651,7 +667,7 @@ static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_da sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -670,7 +686,7 @@ static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_END_CPU_ACCESS); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -689,7 +705,7 @@ static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_KMAP_ATOMIC); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -708,7 +724,7 @@ static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf, unsigned long sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_KUNMAP_ATOMIC); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -725,7 +741,7 @@ static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum) sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_KMAP); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -744,7 +760,7 @@ static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum, sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_KUNMAP); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -761,7 +777,7 @@ static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf, struct vm_area_struct * sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_MMAP); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -780,7 +796,7 @@ static void *hyper_dmabuf_ops_vmap(struct dma_buf *dmabuf) sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_VMAP); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -799,7 +815,7 @@ static void hyper_dmabuf_ops_vunmap(struct dma_buf *dmabuf, void *vaddr) sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request_and_wait(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(sgt_info->hyper_dmabuf_id), + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_VUNMAP); if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index 44a153b..bace8b2 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -6,6 +6,7 @@ #include #include #include +#include #include "hyper_dmabuf_struct.h" #include "hyper_dmabuf_imp.h" #include "hyper_dmabuf_list.h" @@ -121,7 +122,9 @@ static int hyper_dmabuf_export_remote(void *data) return -1; } - /* Clear ret, as that will cause whole ioctl to return failure to userspace, which is not true */ + /* Clear ret, as that will cause whole ioctl to return failure + * to userspace, which is not true + */ ret = 0; sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL); @@ -131,10 +134,26 @@ static int hyper_dmabuf_export_remote(void *data) sgt_info->hyper_dmabuf_id = hyper_dmabuf_id_gen(); /* TODO: We might need to consider using port number on event channel? */ sgt_info->hyper_dmabuf_rdomain = export_remote_attr->remote_domain; - sgt_info->sgt = sgt; - sgt_info->attachment = attachment; sgt_info->dma_buf = dma_buf; + sgt_info->active_sgts = kcalloc(1, sizeof(struct sgt_list), GFP_KERNEL); + sgt_info->active_attached = kcalloc(1, sizeof(struct attachment_list), GFP_KERNEL); + sgt_info->va_kmapped = kcalloc(1, sizeof(struct kmap_vaddr_list), GFP_KERNEL); + sgt_info->va_vmapped = kcalloc(1, sizeof(struct vmap_vaddr_list), GFP_KERNEL); + + sgt_info->active_sgts->sgt = sgt; + sgt_info->active_attached->attach = attachment; + sgt_info->va_kmapped->vaddr = NULL; /* first vaddr is NULL */ + sgt_info->va_vmapped->vaddr = NULL; /* first vaddr is NULL */ + + /* initialize list of sgt, attachment and vaddr for dmabuf sync + * via shadow dma-buf + */ + INIT_LIST_HEAD(&sgt_info->active_sgts->list); + INIT_LIST_HEAD(&sgt_info->active_attached->list); + INIT_LIST_HEAD(&sgt_info->va_kmapped->list); + INIT_LIST_HEAD(&sgt_info->va_vmapped->list); + page_info = hyper_dmabuf_ext_pgs(sgt); if (page_info == NULL) goto fail_export; @@ -155,7 +174,7 @@ static int hyper_dmabuf_export_remote(void *data) operands[2] = page_info->frst_ofst; operands[3] = page_info->last_len; operands[4] = hyper_dmabuf_create_gref_table(page_info->pages, export_remote_attr->remote_domain, - page_info->nents, &sgt_info->shared_pages_info); + page_info->nents, &sgt_info->shared_pages_info); /* driver/application specific private info, max 32 bytes */ operands[5] = export_remote_attr->private[0]; operands[6] = export_remote_attr->private[1]; @@ -166,7 +185,7 @@ static int hyper_dmabuf_export_remote(void *data) /* composing a message to the importer */ hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]); - if(hyper_dmabuf_send_request(export_remote_attr->remote_domain, req)) + if(hyper_dmabuf_send_request(export_remote_attr->remote_domain, req, false)) goto fail_send_request; /* free msg */ @@ -181,10 +200,17 @@ static int hyper_dmabuf_export_remote(void *data) hyper_dmabuf_remove_exported(sgt_info->hyper_dmabuf_id); fail_export: - dma_buf_unmap_attachment(sgt_info->attachment, sgt_info->sgt, DMA_BIDIRECTIONAL); - dma_buf_detach(sgt_info->dma_buf, sgt_info->attachment); + dma_buf_unmap_attachment(sgt_info->active_attached->attach, + sgt_info->active_sgts->sgt, + DMA_BIDIRECTIONAL); + dma_buf_detach(sgt_info->dma_buf, sgt_info->active_attached->attach); dma_buf_put(sgt_info->dma_buf); + kfree(sgt_info->active_attached); + kfree(sgt_info->active_sgts); + kfree(sgt_info->va_kmapped); + kfree(sgt_info->va_vmapped); + return -EINVAL; } @@ -233,7 +259,8 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) } /* removing dmabuf from the database and send int req to the source domain -* to unmap it. */ + * to unmap it. + */ static int hyper_dmabuf_destroy(void *data) { struct ioctl_hyper_dmabuf_destroy *destroy_attr; @@ -250,7 +277,9 @@ static int hyper_dmabuf_destroy(void *data) /* find dmabuf in export list */ sgt_info = hyper_dmabuf_find_exported(destroy_attr->hyper_dmabuf_id); - if (sgt_info == NULL) { /* failed to find corresponding entry in export list */ + + /* failed to find corresponding entry in export list */ + if (sgt_info == NULL) { destroy_attr->status = -EINVAL; return -EFAULT; } @@ -260,8 +289,9 @@ static int hyper_dmabuf_destroy(void *data) hyper_dmabuf_create_request(req, HYPER_DMABUF_DESTROY, &destroy_attr->hyper_dmabuf_id); /* now send destroy request to remote domain - * currently assuming there's only one importer exist */ - ret = hyper_dmabuf_send_request(sgt_info->hyper_dmabuf_rdomain, req); + * currently assuming there's only one importer exist + */ + ret = hyper_dmabuf_send_request(sgt_info->hyper_dmabuf_rdomain, req, true); if (ret < 0) { kfree(req); return -EFAULT; diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c index ad2109c..2b3ef6b 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c @@ -33,7 +33,7 @@ int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info) info_entry->info = info; hash_add(hyper_dmabuf_hash_exported, &info_entry->node, - info_entry->info->hyper_dmabuf_id); + info_entry->info->hyper_dmabuf_id); return 0; } @@ -47,7 +47,7 @@ int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info) info_entry->info = info; hash_add(hyper_dmabuf_hash_imported, &info_entry->node, - info_entry->info->hyper_dmabuf_id); + info_entry->info->hyper_dmabuf_id); return 0; } @@ -71,8 +71,8 @@ int hyper_dmabuf_find_id(struct dma_buf *dmabuf, int domid) int bkt; hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) - if(info_entry->info->attachment->dmabuf == dmabuf && - info_entry->info->hyper_dmabuf_rdomain == domid) + if(info_entry->info->dma_buf == dmabuf && + info_entry->info->hyper_dmabuf_rdomain == domid) return info_entry->info->hyper_dmabuf_id; return -1; diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c index 8a059c8..2432a4e 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c @@ -7,7 +7,7 @@ #include #include "hyper_dmabuf_drv.h" #include "hyper_dmabuf_imp.h" -//#include "hyper_dmabuf_remote_sync.h" +#include "hyper_dmabuf_remote_sync.h" #include "xen/hyper_dmabuf_xen_comm.h" #include "hyper_dmabuf_msg.h" #include "hyper_dmabuf_list.h" @@ -125,7 +125,9 @@ void cmd_process_work(struct work_struct *work) * operands0 : hyper_dmabuf_id */ - /* TODO: that should be done on workqueue, when received ack from all importers that buffer is no longer used */ + /* TODO: that should be done on workqueue, when received ack from + * all importers that buffer is no longer used + */ sgt_info = hyper_dmabuf_find_exported(req->operands[0]); @@ -133,8 +135,10 @@ void cmd_process_work(struct work_struct *work) hyper_dmabuf_cleanup_gref_table(sgt_info); /* unmap dmabuf */ - dma_buf_unmap_attachment(sgt_info->attachment, sgt_info->sgt, DMA_BIDIRECTIONAL); - dma_buf_detach(sgt_info->dma_buf, sgt_info->attachment); + dma_buf_unmap_attachment(sgt_info->active_attached->attach, + sgt_info->active_sgts->sgt, + DMA_BIDIRECTIONAL); + dma_buf_detach(sgt_info->dma_buf, sgt_info->active_attached->attach); dma_buf_put(sgt_info->dma_buf); /* TODO: Rest of cleanup, sgt cleanup etc */ @@ -147,16 +151,6 @@ void cmd_process_work(struct work_struct *work) /* for dmabuf synchronization */ break; - /* as importer, command to exporter */ - case HYPER_DMABUF_OPS_TO_SOURCE: - /* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping - * or unmapping for synchronization with original exporter (e.g. i915) */ - /* command : DMABUF_OPS_TO_SOURCE. - * operands0 : hyper_dmabuf_id - * operands1 : map(=1)/unmap(=2)/attach(=3)/detach(=4) - */ - break; - default: /* shouldn't get here */ /* no matched command, nothing to do.. just return error */ @@ -172,6 +166,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req) struct cmd_process *proc; struct hyper_dmabuf_ring_rq *temp_req; struct hyper_dmabuf_imported_sgt_info *imported_sgt_info; + int ret; if (!req) { printk("request is NULL\n"); @@ -216,7 +211,25 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req) return req->command; } - temp_req = (struct hyper_dmabuf_ring_rq *)kmalloc(sizeof(*temp_req), GFP_KERNEL); + /* dma buf remote synchronization */ + if (req->command == HYPER_DMABUF_OPS_TO_SOURCE) { + /* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping + * or unmapping for synchronization with original exporter (e.g. i915) */ + + /* command : DMABUF_OPS_TO_SOURCE. + * operands0 : hyper_dmabuf_id + * operands1 : enum hyper_dmabuf_ops {....} + */ + ret = hyper_dmabuf_remote_sync(req->operands[0], req->operands[1]); + if (ret) + req->status = HYPER_DMABUF_REQ_ERROR; + else + req->status = HYPER_DMABUF_REQ_PROCESSED; + + return req->command; + } + + temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL); memcpy(temp_req, req, sizeof(*temp_req)); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c new file mode 100644 index 0000000..6ba932f --- /dev/null +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c @@ -0,0 +1,189 @@ +#include +#include +#include +#include +#include +#include "hyper_dmabuf_struct.h" +#include "hyper_dmabuf_list.h" +#include "hyper_dmabuf_drv.h" +#include "xen/hyper_dmabuf_xen_comm.h" +#include "hyper_dmabuf_msg.h" + +extern struct hyper_dmabuf_private hyper_dmabuf_private; + +int hyper_dmabuf_remote_sync(int id, int ops) +{ + struct hyper_dmabuf_sgt_info *sgt_info; + struct sgt_list *sgtl; + struct attachment_list *attachl; + struct kmap_vaddr_list *va_kmapl; + struct vmap_vaddr_list *va_vmapl; + int ret; + + /* find a coresponding SGT for the id */ + sgt_info = hyper_dmabuf_find_exported(id); + + if (!sgt_info) { + printk("dmabuf remote sync::can't find exported list\n"); + return -EINVAL; + } + + switch (ops) { + case HYPER_DMABUF_OPS_ATTACH: + attachl = kcalloc(1, sizeof(*attachl), GFP_KERNEL); + + attachl->attach = dma_buf_attach(sgt_info->dma_buf, + hyper_dmabuf_private.device); + + if (!attachl->attach) { + kfree(attachl); + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n"); + return -EINVAL; + } + + list_add(&attachl->list, &sgt_info->active_attached->list); + break; + + case HYPER_DMABUF_OPS_DETACH: + attachl = list_first_entry(&sgt_info->active_attached->list, + struct attachment_list, list); + + if (!attachl) { + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_DETACH\n"); + return -EINVAL; + } + dma_buf_detach(sgt_info->dma_buf, attachl->attach); + list_del(&attachl->list); + kfree(attachl); + break; + + case HYPER_DMABUF_OPS_MAP: + sgtl = kcalloc(1, sizeof(*sgtl), GFP_KERNEL); + attachl = list_first_entry(&sgt_info->active_attached->list, + struct attachment_list, list); + sgtl->sgt = dma_buf_map_attachment(attachl->attach, DMA_BIDIRECTIONAL); + if (!sgtl->sgt) { + kfree(sgtl); + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n"); + return -EINVAL; + } + list_add(&sgtl->list, &sgt_info->active_sgts->list); + break; + + case HYPER_DMABUF_OPS_UNMAP: + attachl = list_first_entry(&sgt_info->active_attached->list, + struct attachment_list, list); + sgtl = list_first_entry(&sgt_info->active_sgts->list, + struct sgt_list, list); + if (!attachl || !sgtl) { + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_UNMAP\n"); + return -EINVAL; + } + + dma_buf_unmap_attachment(attachl->attach, sgtl->sgt, + DMA_BIDIRECTIONAL); + list_del(&sgtl->list); + kfree(sgtl); + break; + + case HYPER_DMABUF_OPS_RELEASE: + /* remote importer shouldn't release dma_buf because + * exporter will hold handle to the dma_buf as + * far as dma_buf is shared with other domains. + */ + break; + + case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS: + ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL); + if (!ret) { + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n"); + ret = -EINVAL; + } + break; + + case HYPER_DMABUF_OPS_END_CPU_ACCESS: + ret = dma_buf_end_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL); + if (!ret) { + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_END_CPU_ACCESS\n"); + ret = -EINVAL; + } + break; + + case HYPER_DMABUF_OPS_KMAP_ATOMIC: + case HYPER_DMABUF_OPS_KMAP: + va_kmapl = kcalloc(1, sizeof(*va_kmapl), GFP_KERNEL); + + /* dummy kmapping of 1 page */ + if (ops == HYPER_DMABUF_OPS_KMAP_ATOMIC) + va_kmapl->vaddr = dma_buf_kmap_atomic(sgt_info->dma_buf, 1); + else + va_kmapl->vaddr = dma_buf_kmap(sgt_info->dma_buf, 1); + + if (!va_kmapl->vaddr) { + kfree(va_kmapl); + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n"); + return -EINVAL; + } + list_add(&va_kmapl->list, &sgt_info->va_kmapped->list); + break; + + case HYPER_DMABUF_OPS_KUNMAP_ATOMIC: + case HYPER_DMABUF_OPS_KUNMAP: + va_kmapl = list_first_entry(&sgt_info->va_kmapped->list, + struct kmap_vaddr_list, list); + if (!va_kmapl || va_kmapl->vaddr == NULL) { + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n"); + return -EINVAL; + } + + /* unmapping 1 page */ + if (ops == HYPER_DMABUF_OPS_KUNMAP_ATOMIC) + dma_buf_kunmap_atomic(sgt_info->dma_buf, 1, va_kmapl->vaddr); + else + dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr); + + list_del(&va_kmapl->list); + kfree(va_kmapl); + break; + + case HYPER_DMABUF_OPS_MMAP: + /* currently not supported: looking for a way to create + * a dummy vma */ + printk("dmabuf remote sync::sychronized mmap is not supported\n"); + break; + + case HYPER_DMABUF_OPS_VMAP: + va_vmapl = kcalloc(1, sizeof(*va_vmapl), GFP_KERNEL); + + /* dummy vmapping */ + va_vmapl->vaddr = dma_buf_vmap(sgt_info->dma_buf); + + if (!va_vmapl->vaddr) { + kfree(va_vmapl); + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n"); + return -EINVAL; + } + list_add(&va_vmapl->list, &sgt_info->va_vmapped->list); + break; + + case HYPER_DMABUF_OPS_VUNMAP: + va_vmapl = list_first_entry(&sgt_info->va_vmapped->list, + struct vmap_vaddr_list, list); + if (!va_vmapl || va_vmapl->vaddr == NULL) { + printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n"); + return -EINVAL; + } + + dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr); + + list_del(&va_vmapl->list); + kfree(va_vmapl); + break; + + default: + /* program should not get here */ + break; + } + + return 0; +} diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.h new file mode 100644 index 0000000..fc85fa8 --- /dev/null +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.h @@ -0,0 +1,6 @@ +#ifndef __HYPER_DMABUF_REMOTE_SYNC_H__ +#define __HYPER_DMABUF_REMOTE_SYNC_H__ + +int hyper_dmabuf_remote_sync(int id, int ops); + +#endif // __HYPER_DMABUF_REMOTE_SYNC_H__ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h index c8a2f4d..bfe80ee 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h @@ -18,6 +18,30 @@ * frame buffer) */ #define MAX_ALLOWED_NUM_PAGES_FOR_GREF_NUM_ARRAYS 4 +/* stack of mapped sgts */ +struct sgt_list { + struct sg_table *sgt; + struct list_head list; +}; + +/* stack of attachments */ +struct attachment_list { + struct dma_buf_attachment *attach; + struct list_head list; +}; + +/* stack of vaddr mapped via kmap */ +struct kmap_vaddr_list { + void *vaddr; + struct list_head list; +}; + +/* stack of vaddr mapped via vmap */ +struct vmap_vaddr_list { + void *vaddr; + struct list_head list; +}; + struct hyper_dmabuf_shared_pages_info { grant_ref_t *data_refs; /* table with shared buffer pages refid */ grant_ref_t *addr_pages; /* pages of 2nd level addressing */ @@ -46,9 +70,13 @@ struct hyper_dmabuf_pages_info { struct hyper_dmabuf_sgt_info { int hyper_dmabuf_id; /* unique id to reference dmabuf in remote domain */ int hyper_dmabuf_rdomain; /* domain importing this sgt */ - struct sg_table *sgt; /* pointer to sgt */ + struct dma_buf *dma_buf; /* needed to store this for freeing it later */ - struct dma_buf_attachment *attachment; /* needed to store this for freeing this later */ + struct sgt_list *active_sgts; + struct attachment_list *active_attached; + struct kmap_vaddr_list *va_kmapped; + struct vmap_vaddr_list *va_vmapped; + struct hyper_dmabuf_shared_pages_info shared_pages_info; int private[4]; /* device specific info (e.g. image's meta info?) */ }; diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c index 5db58b0..576085f 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -15,6 +16,8 @@ static int export_req_id = 0; +struct hyper_dmabuf_ring_rq req_pending = {0}; + /* Creates entry in xen store that will keep details of all exporter rings created by this domain */ int32_t hyper_dmabuf_setup_data_dir() { @@ -114,8 +117,8 @@ int hyper_dmabuf_next_req_id_export(void) } /* For now cache latast rings as global variables TODO: keep them in list*/ -static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *dev_id); -static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *dev_id); +static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info); +static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info); /* * Callback function that will be called on any change of xenbus path being watched. @@ -376,12 +379,13 @@ void hyper_dmabuf_cleanup_ringbufs(void) hyper_dmabuf_foreach_importer_ring(hyper_dmabuf_importer_ringbuf_cleanup); } -int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req) +int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req, int wait) { struct hyper_dmabuf_front_ring *ring; struct hyper_dmabuf_ring_rq *new_req; struct hyper_dmabuf_ring_info_export *ring_info; int notify; + int timeout = 1000; /* find a ring info for the channel */ ring_info = hyper_dmabuf_find_exporter_ring(domain); @@ -401,6 +405,10 @@ int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req) return -EIO; } + /* update req_pending with current request */ + memcpy(&req_pending, req, sizeof(req_pending)); + + /* pass current request to the ring */ memcpy(new_req, req, sizeof(*new_req)); ring->req_prod_pvt++; @@ -410,10 +418,24 @@ int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req) notify_remote_via_irq(ring_info->irq); } + if (wait) { + while (timeout--) { + if (req_pending.status != + HYPER_DMABUF_REQ_NOT_RESPONDED) + break; + usleep_range(100, 120); + } + + if (timeout < 0) { + printk("request timed-out\n"); + return -EBUSY; + } + } + return 0; } -/* ISR for request from exporter (as an importer) */ +/* ISR for handling request */ static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info) { RING_IDX rc, rp; @@ -444,6 +466,9 @@ static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info) ret = hyper_dmabuf_msg_parse(ring_info->sdomain, &req); if (ret > 0) { + /* preparing a response for the request and send it to + * the requester + */ memcpy(&resp, &req, sizeof(resp)); memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt), &resp, sizeof(resp)); @@ -465,7 +490,7 @@ static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info) return IRQ_HANDLED; } -/* ISR for responses from importer */ +/* ISR for handling responses */ static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info) { /* front ring only care about response from back */ @@ -483,10 +508,13 @@ static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info) more_to_do = 0; rp = ring->sring->rsp_prod; for (i = ring->rsp_cons; i != rp; i++) { - unsigned long id; - resp = RING_GET_RESPONSE(ring, i); - id = resp->response_id; + + /* update pending request's status with what is + * in the response + */ + if (req_pending.request_id == resp->response_id) + req_pending.status = resp->status; if (resp->status == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) { /* parsing response */ @@ -496,6 +524,14 @@ static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info) if (ret < 0) { printk("getting error while parsing response\n"); } + } else if (resp->status == HYPER_DMABUF_REQ_PROCESSED) { + /* for debugging dma_buf remote synchronization */ + printk("original request = 0x%x\n", resp->command); + printk("Just got HYPER_DMABUF_REQ_PROCESSED\n"); + } else if (resp->status == HYPER_DMABUF_REQ_ERROR) { + /* for debugging dma_buf remote synchronization */ + printk("original request = 0x%x\n", resp->command); + printk("Just got HYPER_DMABUF_REQ_ERROR\n"); } } diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h index a4819ca..4ab031a 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h @@ -61,7 +61,7 @@ void hyper_dmabuf_importer_ringbuf_cleanup(int sdomain); void hyper_dmabuf_cleanup_ringbufs(void); /* send request to the remote domain */ -int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req); +int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req, int wait); /* called by interrupt (WORKQUEUE) */ int hyper_dmabuf_send_response(struct hyper_dmabuf_ring_rp* response, int domain); -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 09/60] hyper_dmabuf: indirect DMA_BUF synchronization via shadowing Date: Tue, 19 Dec 2017 11:29:25 -0800 Message-ID: <1513711816-2618-9-git-send-email-dongwon.kim@intel.com> References: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 4222A6E325 for ; Tue, 19 Dec 2017 19:36:31 +0000 (UTC) In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-kernel@vger.kernel.org Cc: xen-devel@lists.xenproject.org, mateuszx.potrola@intel.com, dri-devel@lists.freedesktop.org, dongwon.kim@intel.com List-Id: dri-devel@lists.freedesktop.org SW1wb3J0ZXIgbm93IHNlbmRzIGEgc3luY2hyb25pemF0aW9uIHJlcXVlc3QgdG8gdGhlCmV4cG9y dGVyIHdoZW4gYW55IG9mIERNQV9CVUYgb3BlcmF0aW9ucyBvbiBpbXBvcnRlZApIeXBlcl9ETUFC VUYgaXMgZXhlY3V0ZWQgKGUuZyBkbWFfYnVmX21hcCBhbmQgZG1hX2J1Zl91bm1hcCkuClRoaXMg cmVzdWx0cyBpbiBhIGNyZWF0aW9uIG9mIHNoYWRvdyBETUFfQlVGIGFuZCBleGFjdGx5IHNhbWUK RE1BX0JVRiBvcGVyYXRpb24gdG8gYmUgZXhlY3V0ZWQgb24gaXQuCgpUaGUgbWFpbiBwdXJwb3Nl IG9mIHRoaXMgaXMgdG8gZ2V0IERNQV9CVUYgc3luY2hyb25pemVkCmV2ZW50dWFsbHkgYmV0d2Vl biB0aGUgb3JpZ2luYWwgY3JlYXRvciBvZiBETUFfQlVGIGFuZCB0aGUKZW5kIGNvbnN1bWVyIG9m IGl0IHJ1bm5pbmcgb24gdGhlIGltcG9ydGVyIFZNLgoKU2lnbmVkLW9mZi1ieTogRG9uZ3dvbiBL aW0gPGRvbmd3b24ua2ltQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv TWFrZWZpbGUgICAgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX2ltcC5jICAgICAgICB8ICA5MCArKysrKystLS0tCiBkcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMgICAgICB8ICA1MiArKysrLS0KIGRy aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5jICAgICAgIHwgICA4ICst CiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5jICAgICAgICB8ICA0 MyArKystLQogLi4uL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jLmMg ICAgfCAxODkgKysrKysrKysrKysrKysrKysrKysrCiAuLi4veGVuL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfcmVtb3RlX3N5bmMuaCAgICB8ICAgNiArCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX3N0cnVjdC5oICAgICB8ICAzMiArKystCiAuLi4veGVuL2h5cGVyX2Rt YWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMgICB8ICA1MiArKysrKy0KIC4uLi94ZW4v aHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uaCAgIHwgICAyICstCiAxMCBm aWxlcyBjaGFuZ2VkLCAzOTcgaW5zZXJ0aW9ucygrKSwgNzggZGVsZXRpb25zKC0pCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVf c3luYy5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9yZW1vdGVfc3luYy5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL01ha2VmaWxlIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL01ha2VmaWxlCmluZGV4IDBi ZTc0NDUuLjM0NTkzODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9NYWtl ZmlsZQorKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvTWFrZWZpbGUKQEAgLTcsNiArNyw3 IEBAIGlmbmVxICgkKEtFUk5FTFJFTEVBU0UpLCkKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGh5cGVyX2RtYWJ1Zl9saXN0Lm8gXAogCQkJCSBoeXBlcl9kbWFidWZfaW1wLm8gXAog CQkJCSBoeXBlcl9kbWFidWZfbXNnLm8gXAorCQkJCSBoeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMu byBcCiAJCQkJIHhlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0ubyBcCiAJCQkJIHhlbi9oeXBlcl9k bWFidWZfeGVuX2NvbW1fbGlzdC5vCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2Rt YWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX2ltcC5jCmluZGV4IDZiMTZlMzcuLjJjNzhiYzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv eGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMKKysrIGIvZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pbXAuYwpAQCAtMTY5LDcgKzE2OSw4IEBAIGdyYW50X3Jl Zl90IGh5cGVyX2RtYWJ1Zl9jcmVhdGVfYWRkcmVzc2luZ190YWJsZXMoZ3JhbnRfcmVmX3QgKmRh dGFfcmVmcywgaW50IG5lCiAJLyoKIAkgKiBDYWxjdWxhdGUgbnVtYmVyIG9mIHBhZ2VzIG5lZWRl ZCBmb3IgMm5kIGxldmVsIGFkZHJlc2luZzoKIAkgKi8KLQlpbnQgbl8ybmRfbGV2ZWxfcGFnZXMg PSAobmVudHMvUkVGU19QRVJfUEFHRSArICgobmVudHMgJSBSRUZTX1BFUl9QQUdFKSA/IDE6IDAp KTsvKiByb3VuZGluZyAqLworCWludCBuXzJuZF9sZXZlbF9wYWdlcyA9IChuZW50cy9SRUZTX1BF Ul9QQUdFICsKKwkJCQkoKG5lbnRzICUgUkVGU19QRVJfUEFHRSkgPyAxOiAwKSk7CiAJaW50IGk7 CiAJdW5zaWduZWQgbG9uZyBncmVmX3BhZ2Vfc3RhcnQ7CiAJZ3JhbnRfcmVmX3QgKnRtcF9wYWdl OwpAQCAtMTg3LDcgKzE4OCw5IEBAIGdyYW50X3JlZl90IGh5cGVyX2RtYWJ1Zl9jcmVhdGVfYWRk cmVzc2luZ190YWJsZXMoZ3JhbnRfcmVmX3QgKmRhdGFfcmVmcywgaW50IG5lCiAKIAkvKiBTaGFy ZSAybmQgbGV2ZWwgYWRkcmVzc2luZyBwYWdlcyBpbiByZWFkb25seSBtb2RlKi8KIAlmb3IgKGk9 MDsgaTwgbl8ybmRfbGV2ZWxfcGFnZXM7IGkrKykgewotCQlhZGRyX3JlZnNbaV0gPSBnbnR0YWJf Z3JhbnRfZm9yZWlnbl9hY2Nlc3MocmRvbWFpbiwgdmlydF90b19tZm4oKHVuc2lnbmVkIGxvbmcp dG1wX3BhZ2UraSpQQUdFX1NJWkUgKSwgMSk7CisJCWFkZHJfcmVmc1tpXSA9IGdudHRhYl9ncmFu dF9mb3JlaWduX2FjY2VzcyhyZG9tYWluLAorCQkJCQkJCSAgIHZpcnRfdG9fbWZuKCh1bnNpZ25l ZCBsb25nKXRtcF9wYWdlK2kqUEFHRV9TSVpFICksCisJCQkJCQkJICAgMSk7CiAJfQogCiAJLyoK QEAgLTIxMyw3ICsyMTYsOSBAQCBncmFudF9yZWZfdCBoeXBlcl9kbWFidWZfY3JlYXRlX2FkZHJl c3NpbmdfdGFibGVzKGdyYW50X3JlZl90ICpkYXRhX3JlZnMsIGludCBuZQogCX0KIAogCS8qIFNo YXJlIHRvcCBsZXZlbCBhZGRyZXNzaW5nIHBhZ2UgaW4gcmVhZG9ubHkgbW9kZSovCi0JdG9wX2xl dmVsX3JlZiA9IGdudHRhYl9ncmFudF9mb3JlaWduX2FjY2VzcyhyZG9tYWluLCB2aXJ0X3RvX21m bigodW5zaWduZWQgbG9uZyl0bXBfcGFnZSksIDEpOworCXRvcF9sZXZlbF9yZWYgPSBnbnR0YWJf Z3JhbnRfZm9yZWlnbl9hY2Nlc3MocmRvbWFpbiwKKwkJCQkJCSAgICB2aXJ0X3RvX21mbigodW5z aWduZWQgbG9uZyl0bXBfcGFnZSksCisJCQkJCQkgICAgMSk7CiAKIAlrZnJlZShhZGRyX3JlZnMp OwogCkBAIC0yNTUsNyArMjYwLDkgQEAgc3RydWN0IHBhZ2UqKiBoeXBlcl9kbWFidWZfZ2V0X2Rh dGFfcmVmcyhncmFudF9yZWZfdCB0b3BfbGV2ZWxfcmVmLCBpbnQgZG9taWQsIGkKIAl9CiAKIAlh ZGRyID0gKHVuc2lnbmVkIGxvbmcpcGZuX3RvX2thZGRyKHBhZ2VfdG9fcGZuKHRvcF9sZXZlbF9w YWdlKSk7Ci0JZ250dGFiX3NldF9tYXBfb3AoJnRvcF9sZXZlbF9tYXBfb3BzLCBhZGRyLCBHTlRN QVBfaG9zdF9tYXAgfCBHTlRNQVBfcmVhZG9ubHksIHRvcF9sZXZlbF9yZWYsIGRvbWlkKTsKKwln bnR0YWJfc2V0X21hcF9vcCgmdG9wX2xldmVsX21hcF9vcHMsIGFkZHIsIEdOVE1BUF9ob3N0X21h cCB8IEdOVE1BUF9yZWFkb25seSwKKwkJCSAgdG9wX2xldmVsX3JlZiwgZG9taWQpOworCiAJZ250 dGFiX3NldF91bm1hcF9vcCgmdG9wX2xldmVsX3VubWFwX29wcywgYWRkciwgR05UTUFQX2hvc3Rf bWFwIHwgR05UTUFQX3JlYWRvbmx5LCAtMSk7CiAKIAlpZiAoZ250dGFiX21hcF9yZWZzKCZ0b3Bf bGV2ZWxfbWFwX29wcywgTlVMTCwgJnRvcF9sZXZlbF9wYWdlLCAxKSkgewpAQCAtMjgyLDcgKzI4 OSw4IEBAIHN0cnVjdCBwYWdlKiogaHlwZXJfZG1hYnVmX2dldF9kYXRhX3JlZnMoZ3JhbnRfcmVm X3QgdG9wX2xldmVsX3JlZiwgaW50IGRvbWlkLCBpCiAKIAlmb3IgKGkgPSAwOyBpIDwgbl9sZXZl bDJfcmVmczsgaSsrKSB7CiAJCWFkZHIgPSAodW5zaWduZWQgbG9uZylwZm5fdG9fa2FkZHIocGFn ZV90b19wZm4obGV2ZWwyX3BhZ2VzW2ldKSk7Ci0JCWdudHRhYl9zZXRfbWFwX29wKCZtYXBfb3Bz W2ldLCBhZGRyLCBHTlRNQVBfaG9zdF9tYXAgfCBHTlRNQVBfcmVhZG9ubHksIHRvcF9sZXZlbF9y ZWZzW2ldLCBkb21pZCk7CisJCWdudHRhYl9zZXRfbWFwX29wKCZtYXBfb3BzW2ldLCBhZGRyLCBH TlRNQVBfaG9zdF9tYXAgfCBHTlRNQVBfcmVhZG9ubHksCisJCQkJICB0b3BfbGV2ZWxfcmVmc1tp XSwgZG9taWQpOwogCQlnbnR0YWJfc2V0X3VubWFwX29wKCZ1bm1hcF9vcHNbaV0sIGFkZHIsIEdO VE1BUF9ob3N0X21hcCB8IEdOVE1BUF9yZWFkb25seSwgLTEpOwogCX0KIApAQCAtMjk1LDcgKzMw Myw3IEBAIHN0cnVjdCBwYWdlKiogaHlwZXJfZG1hYnVmX2dldF9kYXRhX3JlZnMoZ3JhbnRfcmVm X3QgdG9wX2xldmVsX3JlZiwgaW50IGRvbWlkLCBpCiAJZm9yIChpID0gMDsgaSA8IG5fbGV2ZWwy X3JlZnM7IGkrKykgewogCQlpZiAobWFwX29wc1tpXS5zdGF0dXMpIHsKIAkJCXByaW50aygiXG54 ZW46IGRvbTA6IEhZUEVSVklTT1IgbWFwIGdyYW50IHJlZiBmYWlsZWQgc3RhdHVzID0gJWQiLAot CQkJCQltYXBfb3BzW2ldLnN0YXR1cyk7CisJCQkgICAgICAgbWFwX29wc1tpXS5zdGF0dXMpOwog CQkJcmV0dXJuIE5VTEw7CiAJCX0gZWxzZSB7CiAJCQl1bm1hcF9vcHNbaV0uaGFuZGxlID0gbWFw X29wc1tpXS5oYW5kbGU7CkBAIC0zMzEsNyArMzM5LDkgQEAgZ3JhbnRfcmVmX3QgaHlwZXJfZG1h YnVmX2NyZWF0ZV9ncmVmX3RhYmxlKHN0cnVjdCBwYWdlICoqcGFnZXMsIGludCByZG9tYWluLCBp bnQKIAogCS8qIHNoYXJlIGRhdGEgcGFnZXMgaW4gcncgbW9kZSovCiAJZm9yIChpPTA7IGk8bmVu dHM7IGkrKykgewotCQlkYXRhX3JlZnNbaV0gPSBnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3Mo cmRvbWFpbiwgcGZuX3RvX21mbihwYWdlX3RvX3BmbihwYWdlc1tpXSkpLCAwKTsKKwkJZGF0YV9y ZWZzW2ldID0gZ250dGFiX2dyYW50X2ZvcmVpZ25fYWNjZXNzKHJkb21haW4sCisJCQkJCQkJICAg cGZuX3RvX21mbihwYWdlX3RvX3BmbihwYWdlc1tpXSkpLAorCQkJCQkJCSAgIDApOwogCX0KIAog CS8qIGNyZWF0ZSBhZGRpdGlvbmFsIHNoYXJlZCBwYWdlcyB3aXRoIDIgbGV2ZWwgYWRkcmVzc2lu ZyBvZiBkYXRhIHBhZ2VzICovCkBAIC0zNTAsNyArMzYwLDggQEAgaW50IGh5cGVyX2RtYWJ1Zl9j bGVhbnVwX2dyZWZfdGFibGUoc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm8p IHsKIAlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NoYXJlZF9wYWdlc19pbmZvICpzaGFyZWRfcGFnZXNf aW5mbyA9ICZzZ3RfaW5mby0+c2hhcmVkX3BhZ2VzX2luZm87CiAKIAlncmFudF9yZWZfdCAqcmVm ID0gc2hhcmVkX3BhZ2VzX2luZm8tPnRvcF9sZXZlbF9wYWdlOwotCWludCBuXzJuZF9sZXZlbF9w YWdlcyA9IChzZ3RfaW5mby0+c2d0LT5uZW50cy9SRUZTX1BFUl9QQUdFICsgKChzZ3RfaW5mby0+ c2d0LT5uZW50cyAlIFJFRlNfUEVSX1BBR0UpID8gMTogMCkpOy8qIHJvdW5kaW5nICovCisJaW50 IG5fMm5kX2xldmVsX3BhZ2VzID0gKHNndF9pbmZvLT5hY3RpdmVfc2d0cy0+c2d0LT5uZW50cy9S RUZTX1BFUl9QQUdFICsKKwkJCQkoKHNndF9pbmZvLT5hY3RpdmVfc2d0cy0+c2d0LT5uZW50cyAl IFJFRlNfUEVSX1BBR0UpID8gMTogMCkpOwogCiAKIAlpZiAoc2hhcmVkX3BhZ2VzX2luZm8tPmRh dGFfcmVmcyA9PSBOVUxMIHx8CkBAIC0zODQsNyArMzk1LDcgQEAgaW50IGh5cGVyX2RtYWJ1Zl9j bGVhbnVwX2dyZWZfdGFibGUoc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm8p IHsKIAlmcmVlX3BhZ2VzKCh1bnNpZ25lZCBsb25nKXNoYXJlZF9wYWdlc19pbmZvLT50b3BfbGV2 ZWxfcGFnZSwgMSk7CiAKIAkvKiBFbmQgZm9yZWlnbiBhY2Nlc3MgZm9yIGRhdGEgcGFnZXMsIGJ1 dCBkbyBub3QgZnJlZSB0aGVtICovCi0JZm9yIChpID0gMDsgaSA8IHNndF9pbmZvLT5zZ3QtPm5l bnRzOyBpKyspIHsKKwlmb3IgKGkgPSAwOyBpIDwgc2d0X2luZm8tPmFjdGl2ZV9zZ3RzLT5zZ3Qt Pm5lbnRzOyBpKyspIHsKIAkJaWYgKGdudHRhYl9xdWVyeV9mb3JlaWduX2FjY2VzcyhzaGFyZWRf cGFnZXNfaW5mby0+ZGF0YV9yZWZzW2ldKSkgewogCQkJcHJpbnRrKCJyZWZpZCBub3Qgc2hhcmVk ICEhXG4iKTsKIAkJfQpAQCAtNDA0LDEyICs0MTUsMTQgQEAgaW50IGh5cGVyX2RtYWJ1Zl9jbGVh bnVwX2dyZWZfdGFibGUoc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm8pIHsK IGludCBoeXBlcl9kbWFidWZfY2xlYW51cF9pbXBvcnRlZF9wYWdlcyhzdHJ1Y3QgaHlwZXJfZG1h YnVmX2ltcG9ydGVkX3NndF9pbmZvICpzZ3RfaW5mbykgewogCXN0cnVjdCBoeXBlcl9kbWFidWZf c2hhcmVkX3BhZ2VzX2luZm8gKnNoYXJlZF9wYWdlc19pbmZvID0gJnNndF9pbmZvLT5zaGFyZWRf cGFnZXNfaW5mbzsKIAotCWlmKHNoYXJlZF9wYWdlc19pbmZvLT51bm1hcF9vcHMgPT0gTlVMTCB8 fCBzaGFyZWRfcGFnZXNfaW5mby0+ZGF0YV9wYWdlcyA9PSBOVUxMKSB7CisJaWYoc2hhcmVkX3Bh Z2VzX2luZm8tPnVubWFwX29wcyA9PSBOVUxMIHx8CisJICAgc2hhcmVkX3BhZ2VzX2luZm8tPmRh dGFfcGFnZXMgPT0gTlVMTCkgewogCQlwcmludGsoIkltcG9ydGVkIHBhZ2VzIGFscmVhZHkgY2xl YW5lZCB1cCBvciBidWZmZXIgd2FzIG5vdCBpbXBvcnRlZCB5ZXRcbiIpOwogCQlyZXR1cm4gMDsK IAl9CiAKLQlpZiAoZ250dGFiX3VubWFwX3JlZnMoc2hhcmVkX3BhZ2VzX2luZm8tPnVubWFwX29w cywgTlVMTCwgc2hhcmVkX3BhZ2VzX2luZm8tPmRhdGFfcGFnZXMsIHNndF9pbmZvLT5uZW50cykg KSB7CisJaWYgKGdudHRhYl91bm1hcF9yZWZzKHNoYXJlZF9wYWdlc19pbmZvLT51bm1hcF9vcHMs IE5VTEwsCisJCQkgICAgICBzaGFyZWRfcGFnZXNfaW5mby0+ZGF0YV9wYWdlcywgc2d0X2luZm8t Pm5lbnRzKSApIHsKIAkJcHJpbnRrKCJDYW5ub3QgdW5tYXAgZGF0YSBwYWdlc1xuIik7CiAJCXJl dHVybiAtRUlOVkFMOwogCX0KQEAgLTQyNCw3ICs0MzcsOCBAQCBpbnQgaHlwZXJfZG1hYnVmX2Ns ZWFudXBfaW1wb3J0ZWRfcGFnZXMoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5m byAqcwogfQogCiAvKiBtYXAgYW5kIGNvbnN0cnVjdCBzZ19saXN0cyBmcm9tIHJlZmVyZW5jZSBu dW1iZXJzICovCi1zdHJ1Y3Qgc2dfdGFibGUqIGh5cGVyX2RtYWJ1Zl9tYXBfcGFnZXMoZ3JhbnRf cmVmX3QgdG9wX2xldmVsX2dyZWYsIGludCBmcnN0X29mc3QsIGludCBsYXN0X2xlbiwgaW50IG5l bnRzLCBpbnQgc2RvbWFpbiwKK3N0cnVjdCBzZ190YWJsZSogaHlwZXJfZG1hYnVmX21hcF9wYWdl cyhncmFudF9yZWZfdCB0b3BfbGV2ZWxfZ3JlZiwgaW50IGZyc3Rfb2ZzdCwKKwkJCQkJaW50IGxh c3RfbGVuLCBpbnQgbmVudHMsIGludCBzZG9tYWluLAogCQkJCQlzdHJ1Y3QgaHlwZXJfZG1hYnVm X3NoYXJlZF9wYWdlc19pbmZvICpzaGFyZWRfcGFnZXNfaW5mbykKIHsKIAlzdHJ1Y3Qgc2dfdGFi bGUgKnN0OwpAQCAtNDUxLDEzICs0NjUsMTYgQEAgc3RydWN0IHNnX3RhYmxlKiBoeXBlcl9kbWFi dWZfbWFwX3BhZ2VzKGdyYW50X3JlZl90IHRvcF9sZXZlbF9ncmVmLCBpbnQgZnJzdF9vZnMKIAkJ cmV0dXJuIE5VTEw7CiAJfQogCi0Jb3BzID0gKHN0cnVjdCBnbnR0YWJfbWFwX2dyYW50X3JlZiAq KWtjYWxsb2MobmVudHMsIHNpemVvZihzdHJ1Y3QgZ250dGFiX21hcF9ncmFudF9yZWYpLCBHRlBf S0VSTkVMKTsKLQl1bm1hcF9vcHMgPSAoc3RydWN0IGdudHRhYl91bm1hcF9ncmFudF9yZWYgKilr Y2FsbG9jKG5lbnRzLCBzaXplb2Yoc3RydWN0IGdudHRhYl91bm1hcF9ncmFudF9yZWYpLCBHRlBf S0VSTkVMKTsKKwlvcHMgPSBrY2FsbG9jKG5lbnRzLCBzaXplb2Yoc3RydWN0IGdudHRhYl9tYXBf Z3JhbnRfcmVmKSwKKwkJICAgICAgR0ZQX0tFUk5FTCk7CisJdW5tYXBfb3BzID0ga2NhbGxvYyhu ZW50cywgc2l6ZW9mKHN0cnVjdCBnbnR0YWJfdW5tYXBfZ3JhbnRfcmVmKSwKKwkJCSAgICBHRlBf S0VSTkVMKTsKIAogCWZvciAoaT0wOyBpPG5lbnRzOyBpKyspIHsKIAkJYWRkciA9ICh1bnNpZ25l ZCBsb25nKXBmbl90b19rYWRkcihwYWdlX3RvX3BmbihwYWdlc1tpXSkpOwogCQlyZWZzID0gcGZu X3RvX2thZGRyKHBhZ2VfdG9fcGZuKHJlZmlkX3BhZ2VzW2kgLyBSRUZTX1BFUl9QQUdFXSkpOwot CQlnbnR0YWJfc2V0X21hcF9vcCgmb3BzW2ldLCBhZGRyLCBHTlRNQVBfaG9zdF9tYXAgfCBHTlRN QVBfcmVhZG9ubHksIHJlZnNbaSAlIFJFRlNfUEVSX1BBR0VdLCBzZG9tYWluKTsKKwkJZ250dGFi X3NldF9tYXBfb3AoJm9wc1tpXSwgYWRkciwgR05UTUFQX2hvc3RfbWFwIHwgR05UTUFQX3JlYWRv bmx5LAorCQkJCXJlZnNbaSAlIFJFRlNfUEVSX1BBR0VdLCBzZG9tYWluKTsKIAkJZ250dGFiX3Nl dF91bm1hcF9vcCgmdW5tYXBfb3BzW2ldLCBhZGRyLCBHTlRNQVBfaG9zdF9tYXAgfCBHTlRNQVBf cmVhZG9ubHksIC0xKTsKIAl9CiAKQEAgLTQ3OCw3ICs0OTUsOCBAQCBzdHJ1Y3Qgc2dfdGFibGUq IGh5cGVyX2RtYWJ1Zl9tYXBfcGFnZXMoZ3JhbnRfcmVmX3QgdG9wX2xldmVsX2dyZWYsIGludCBm cnN0X29mcwogCiAJc3QgPSBoeXBlcl9kbWFidWZfY3JlYXRlX3NndChwYWdlcywgZnJzdF9vZnN0 LCBsYXN0X2xlbiwgbmVudHMpOwogCi0JaWYgKGdudHRhYl91bm1hcF9yZWZzKHNoYXJlZF9wYWdl c19pbmZvLT51bm1hcF9vcHMsIE5VTEwsIHJlZmlkX3BhZ2VzLCBuX2xldmVsMl9yZWZzKSApIHsK KwlpZiAoZ250dGFiX3VubWFwX3JlZnMoc2hhcmVkX3BhZ2VzX2luZm8tPnVubWFwX29wcywgTlVM TCwgcmVmaWRfcGFnZXMsCisJCQluX2xldmVsMl9yZWZzKSApIHsKIAkJcHJpbnRrKCJDYW5ub3Qg dW5tYXAgMm5kIGxldmVsIHJlZnNcbiIpOwogCQlyZXR1cm4gTlVMTDsKIAl9CkBAIC01MDcsMTAg KzUyNSw4IEBAIGlubGluZSBpbnQgaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9hbmRfd2FpdChp bnQgaWQsIGludCBvcHMpCiAKIAloeXBlcl9kbWFidWZfY3JlYXRlX3JlcXVlc3QocmVxLCBIWVBF Ul9ETUFCVUZfT1BTX1RPX1NPVVJDRSwgJm9wZXJhbmRzWzBdKTsKIAotCS8qIHNlbmQgcmVxdWVz dCAqLwotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zZW5kX3JlcXVlc3QoaWQsIHJlcSk7Ci0KLQkvKiBU T0RPOiB3YWl0IHVudGlsIGl0IGdldHMgcmVzcG9uc2UuLiBvciBjYW4gd2UganVzdCBtb3ZlIG9u PyAqLworCS8qIHNlbmQgcmVxdWVzdCBhbmQgd2FpdCBmb3IgYSByZXNwb25zZSAqLworCXJldCA9 IGh5cGVyX2RtYWJ1Zl9zZW5kX3JlcXVlc3QoSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9T RE9NQUlOX0lEKGlkKSwgcmVxLCB0cnVlKTsKIAogCWtmcmVlKHJlcSk7CiAKQEAgLTUyOCwxNCAr NTQ0LDE0IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX29wc19hdHRhY2goc3RydWN0IGRtYV9i dWYqIGRtYWJ1Ziwgc3RydWN0IGRldmljZSogZGV2LAogCiAJc2d0X2luZm8gPSAoc3RydWN0IGh5 cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWF0dGFjaC0+ZG1hYnVmLT5wcml2OwogCi0J cmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9hbmRfd2FpdChIWVBFUl9ETUFCVUZfSURf SU1QT1JURVJfR0VUX1NET01BSU5fSUQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCksCi0JCQkJ CQlIWVBFUl9ETUFCVUZfT1BTX0FUVEFDSCk7CisJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVx dWVzdF9hbmRfd2FpdChzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkLAorCQkJCQkJIEhZUEVSX0RN QUJVRl9PUFNfQVRUQUNIKTsKIAogCWlmIChyZXQgPCAwKSB7CiAJCXByaW50aygiaHlwZXJfZG1h YnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1bmNf Xyk7CisJCXJldHVybiByZXQ7CiAJfQogCi0JLyogSWdub3JpbmcgcmV0IGZvciBub3cgKi8KIAly ZXR1cm4gMDsKIH0KIApAQCAtNTQ5LDggKzU2NSw4IEBAIHN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1 Zl9vcHNfZGV0YWNoKHN0cnVjdCBkbWFfYnVmKiBkbWFidWYsIHN0cnVjdCBkbWFfYnVmX2F0dGFj CiAKIAlzZ3RfaW5mbyA9IChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICop YXR0YWNoLT5kbWFidWYtPnByaXY7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0 X2FuZF93YWl0KEhZUEVSX0RNQUJVRl9JRF9JTVBPUlRFUl9HRVRfU0RPTUFJTl9JRChzZ3RfaW5m by0+aHlwZXJfZG1hYnVmX2lkKSwKLQkJCQkJCUhZUEVSX0RNQUJVRl9PUFNfREVUQUNIKTsKKwly ZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0X2FuZF93YWl0KHNndF9pbmZvLT5oeXBlcl9k bWFidWZfaWQsCisJCQkJCQkgSFlQRVJfRE1BQlVGX09QU19ERVRBQ0gpOwogCiAJaWYgKHJldCA8 IDApIHsKIAkJcHJpbnRrKCJoeXBlcl9kbWFidWY6OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMg cmVxdWVzdCBmYWlsZWRcbiIsIF9fZnVuY19fKTsKQEAgLTU4Myw3ICs1OTksNyBAQCBzdGF0aWMg c3RydWN0IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfb3BzX21hcChzdHJ1Y3QgZG1hX2J1Zl9hdHRh Y2htZW50ICphdHRhY2htZQogICAgICAgICAgICAgICAgIGdvdG8gZXJyX2ZyZWVfc2c7CiAgICAg ICAgIH0KIAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dhaXQoSFlQRVJf RE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9TRE9NQUlOX0lEKHNndF9pbmZvLT5oeXBlcl9kbWFidWZf aWQpLAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dhaXQoc2d0X2luZm8t Pmh5cGVyX2RtYWJ1Zl9pZCwKIAkJCQkJCUhZUEVSX0RNQUJVRl9PUFNfTUFQKTsKIAogCWlmIChy ZXQgPCAwKSB7CkBAIC02MTUsNyArNjMxLDcgQEAgc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX29w c191bm1hcChzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50LAogCXNnX2ZyZWVf dGFibGUoc2cpOwogCWtmcmVlKHNnKTsKIAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVl c3RfYW5kX3dhaXQoSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9TRE9NQUlOX0lEKHNndF9p bmZvLT5oeXBlcl9kbWFidWZfaWQpLAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3Rf YW5kX3dhaXQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCwKIAkJCQkJCUhZUEVSX0RNQUJVRl9P UFNfVU5NQVApOwogCiAJaWYgKHJldCA8IDApIHsKQEAgLTYzMyw3ICs2NDksNyBAQCBzdGF0aWMg dm9pZCBoeXBlcl9kbWFidWZfb3BzX3JlbGVhc2Uoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKIAog CXNndF9pbmZvID0gKHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKilkbWFi dWYtPnByaXY7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0X2FuZF93YWl0KEhZ UEVSX0RNQUJVRl9JRF9JTVBPUlRFUl9HRVRfU0RPTUFJTl9JRChzZ3RfaW5mby0+aHlwZXJfZG1h YnVmX2lkKSwKKwlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0X2FuZF93YWl0KHNndF9p bmZvLT5oeXBlcl9kbWFidWZfaWQsCiAJCQkJCQlIWVBFUl9ETUFCVUZfT1BTX1JFTEVBU0UpOwog CiAJaWYgKHJldCA8IDApIHsKQEAgLTY1MSw3ICs2NjcsNyBAQCBzdGF0aWMgaW50IGh5cGVyX2Rt YWJ1Zl9vcHNfYmVnaW5fY3B1X2FjY2VzcyhzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBlbnVtIGRt YV9kYQogCiAJc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5m byAqKWRtYWJ1Zi0+cHJpdjsKIAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5k X3dhaXQoSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9TRE9NQUlOX0lEKHNndF9pbmZvLT5o eXBlcl9kbWFidWZfaWQpLAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dh aXQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCwKIAkJCQkJCUhZUEVSX0RNQUJVRl9PUFNfQkVH SU5fQ1BVX0FDQ0VTUyk7CiAJaWYgKHJldCA8IDApIHsKIAkJcHJpbnRrKCJoeXBlcl9kbWFidWY6 OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMgcmVxdWVzdCBmYWlsZWRcbiIsIF9fZnVuY19fKTsK QEAgLTY3MCw3ICs2ODYsNyBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9vcHNfZW5kX2NwdV9h Y2Nlc3Moc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwgZW51bSBkbWFfZGF0YQogCiAJc2d0X2luZm8g PSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsK IAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dhaXQoSFlQRVJfRE1BQlVG X0lEX0lNUE9SVEVSX0dFVF9TRE9NQUlOX0lEKHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpLAor CXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dhaXQoc2d0X2luZm8tPmh5cGVy X2RtYWJ1Zl9pZCwKIAkJCQkJCUhZUEVSX0RNQUJVRl9PUFNfRU5EX0NQVV9BQ0NFU1MpOwogCWlm IChyZXQgPCAwKSB7CiAJCXByaW50aygiaHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1 ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7CkBAIC02ODksNyArNzA1LDcgQEAg c3RhdGljIHZvaWQgKmh5cGVyX2RtYWJ1Zl9vcHNfa21hcF9hdG9taWMoc3RydWN0IGRtYV9idWYg KmRtYWJ1ZiwgdW5zaWduZWQgbG9uZwogCiAJc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1 Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsKIAotCXJldCA9IGh5cGVyX2RtYWJ1 Zl9zeW5jX3JlcXVlc3RfYW5kX3dhaXQoSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9TRE9N QUlOX0lEKHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpLAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9z eW5jX3JlcXVlc3RfYW5kX3dhaXQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCwKIAkJCQkJCUhZ UEVSX0RNQUJVRl9PUFNfS01BUF9BVE9NSUMpOwogCWlmIChyZXQgPCAwKSB7CiAJCXByaW50aygi aHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4i LCBfX2Z1bmNfXyk7CkBAIC03MDgsNyArNzI0LDcgQEAgc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVm X29wc19rdW5tYXBfYXRvbWljKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHVuc2lnbmVkIGxvbmcK IAogCXNndF9pbmZvID0gKHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKilk bWFidWYtPnByaXY7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0X2FuZF93YWl0 KEhZUEVSX0RNQUJVRl9JRF9JTVBPUlRFUl9HRVRfU0RPTUFJTl9JRChzZ3RfaW5mby0+aHlwZXJf ZG1hYnVmX2lkKSwKKwlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0X2FuZF93YWl0KHNn dF9pbmZvLT5oeXBlcl9kbWFidWZfaWQsCiAJCQkJCQlIWVBFUl9ETUFCVUZfT1BTX0tVTk1BUF9B VE9NSUMpOwogCWlmIChyZXQgPCAwKSB7CiAJCXByaW50aygiaHlwZXJfZG1hYnVmOjolcyBFcnJv cjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7CkBAIC03MjUs NyArNzQxLDcgQEAgc3RhdGljIHZvaWQgKmh5cGVyX2RtYWJ1Zl9vcHNfa21hcChzdHJ1Y3QgZG1h X2J1ZiAqZG1hYnVmLCB1bnNpZ25lZCBsb25nIHBnbnVtKQogCiAJc2d0X2luZm8gPSAoc3RydWN0 IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsKIAotCXJldCA9 IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dhaXQoSFlQRVJfRE1BQlVGX0lEX0lNUE9S VEVSX0dFVF9TRE9NQUlOX0lEKHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpLAorCXJldCA9IGh5 cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dhaXQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9p ZCwKIAkJCQkJCUhZUEVSX0RNQUJVRl9PUFNfS01BUCk7CiAJaWYgKHJldCA8IDApIHsKIAkJcHJp bnRrKCJoeXBlcl9kbWFidWY6OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMgcmVxdWVzdCBmYWls ZWRcbiIsIF9fZnVuY19fKTsKQEAgLTc0NCw3ICs3NjAsNyBAQCBzdGF0aWMgdm9pZCBoeXBlcl9k bWFidWZfb3BzX2t1bm1hcChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCB1bnNpZ25lZCBsb25nIHBn bnVtLAogCiAJc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5m byAqKWRtYWJ1Zi0+cHJpdjsKIAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5k X3dhaXQoSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9TRE9NQUlOX0lEKHNndF9pbmZvLT5o eXBlcl9kbWFidWZfaWQpLAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3RfYW5kX3dh aXQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCwKIAkJCQkJCUhZUEVSX0RNQUJVRl9PUFNfS1VO TUFQKTsKIAlpZiAocmV0IDwgMCkgewogCQlwcmludGsoImh5cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6 c2VuZCBkbWFidWYgc3luYyByZXF1ZXN0IGZhaWxlZFxuIiwgX19mdW5jX18pOwpAQCAtNzYxLDcg Kzc3Nyw3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX29wc19tbWFwKHN0cnVjdCBkbWFfYnVm ICpkbWFidWYsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqCiAKIAlzZ3RfaW5mbyA9IChzdHJ1Y3Qg aHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICopZG1hYnVmLT5wcml2OwogCi0JcmV0ID0g aHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9hbmRfd2FpdChIWVBFUl9ETUFCVUZfSURfSU1QT1JU RVJfR0VUX1NET01BSU5fSUQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCksCisJcmV0ID0gaHlw ZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9hbmRfd2FpdChzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lk LAogCQkJCQkJSFlQRVJfRE1BQlVGX09QU19NTUFQKTsKIAlpZiAocmV0IDwgMCkgewogCQlwcmlu dGsoImh5cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6c2VuZCBkbWFidWYgc3luYyByZXF1ZXN0IGZhaWxl ZFxuIiwgX19mdW5jX18pOwpAQCAtNzgwLDcgKzc5Niw3IEBAIHN0YXRpYyB2b2lkICpoeXBlcl9k bWFidWZfb3BzX3ZtYXAoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKIAogCXNndF9pbmZvID0gKHN0 cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKilkbWFidWYtPnByaXY7CiAKLQly ZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0X2FuZF93YWl0KEhZUEVSX0RNQUJVRl9JRF9J TVBPUlRFUl9HRVRfU0RPTUFJTl9JRChzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkKSwKKwlyZXQg PSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0X2FuZF93YWl0KHNndF9pbmZvLT5oeXBlcl9kbWFi dWZfaWQsCiAJCQkJCQlIWVBFUl9ETUFCVUZfT1BTX1ZNQVApOwogCWlmIChyZXQgPCAwKSB7CiAJ CXByaW50aygiaHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3Qg ZmFpbGVkXG4iLCBfX2Z1bmNfXyk7CkBAIC03OTksNyArODE1LDcgQEAgc3RhdGljIHZvaWQgaHlw ZXJfZG1hYnVmX29wc192dW5tYXAoc3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgdm9pZCAqdmFkZHIp CiAKIAlzZ3RfaW5mbyA9IChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICop ZG1hYnVmLT5wcml2OwogCi0JcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9hbmRfd2Fp dChIWVBFUl9ETUFCVUZfSURfSU1QT1JURVJfR0VUX1NET01BSU5fSUQoc2d0X2luZm8tPmh5cGVy X2RtYWJ1Zl9pZCksCisJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9hbmRfd2FpdChz Z3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkLAogCQkJCQkJSFlQRVJfRE1BQlVGX09QU19WVU5NQVAp OwogCWlmIChyZXQgPCAwKSB7CiAJCXByaW50aygiaHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5k IGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMgYi9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKaW5kZXggNDRhMTUzYi4uYmFjZThi MiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0 bC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYwpA QCAtNiw2ICs2LDcgQEAKICNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CiAjaW5jbHVkZSA8bGlu dXgvZG1hLWJ1Zi5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgv bGlzdC5oPgogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaCIKICNpbmNsdWRlICJoeXBl cl9kbWFidWZfaW1wLmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2xpc3QuaCIKQEAgLTEyMSw3 ICsxMjIsOSBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlKHZvaWQgKmRh dGEpCiAJCXJldHVybiAtMTsKIAl9CiAKLQkvKiBDbGVhciByZXQsIGFzIHRoYXQgd2lsbCBjYXVz ZSB3aG9sZSBpb2N0bCB0byByZXR1cm4gZmFpbHVyZSB0byB1c2Vyc3BhY2UsIHdoaWNoIGlzIG5v dCB0cnVlICovCisJLyogQ2xlYXIgcmV0LCBhcyB0aGF0IHdpbGwgY2F1c2Ugd2hvbGUgaW9jdGwg dG8gcmV0dXJuIGZhaWx1cmUKKwkgKiB0byB1c2Vyc3BhY2UsIHdoaWNoIGlzIG5vdCB0cnVlCisJ ICovCiAJcmV0ID0gMDsKIAogCXNndCA9IGRtYV9idWZfbWFwX2F0dGFjaG1lbnQoYXR0YWNobWVu dCwgRE1BX0JJRElSRUNUSU9OQUwpOwpAQCAtMTMxLDEwICsxMzQsMjYgQEAgc3RhdGljIGludCBo eXBlcl9kbWFidWZfZXhwb3J0X3JlbW90ZSh2b2lkICpkYXRhKQogCXNndF9pbmZvLT5oeXBlcl9k bWFidWZfaWQgPSBoeXBlcl9kbWFidWZfaWRfZ2VuKCk7CiAJLyogVE9ETzogV2UgbWlnaHQgbmVl ZCB0byBjb25zaWRlciB1c2luZyBwb3J0IG51bWJlciBvbiBldmVudCBjaGFubmVsPyAqLwogCXNn dF9pbmZvLT5oeXBlcl9kbWFidWZfcmRvbWFpbiA9IGV4cG9ydF9yZW1vdGVfYXR0ci0+cmVtb3Rl X2RvbWFpbjsKLQlzZ3RfaW5mby0+c2d0ID0gc2d0OwotCXNndF9pbmZvLT5hdHRhY2htZW50ID0g YXR0YWNobWVudDsKIAlzZ3RfaW5mby0+ZG1hX2J1ZiA9IGRtYV9idWY7CiAKKwlzZ3RfaW5mby0+ YWN0aXZlX3NndHMgPSBrY2FsbG9jKDEsIHNpemVvZihzdHJ1Y3Qgc2d0X2xpc3QpLCBHRlBfS0VS TkVMKTsKKwlzZ3RfaW5mby0+YWN0aXZlX2F0dGFjaGVkID0ga2NhbGxvYygxLCBzaXplb2Yoc3Ry dWN0IGF0dGFjaG1lbnRfbGlzdCksIEdGUF9LRVJORUwpOworCXNndF9pbmZvLT52YV9rbWFwcGVk ID0ga2NhbGxvYygxLCBzaXplb2Yoc3RydWN0IGttYXBfdmFkZHJfbGlzdCksIEdGUF9LRVJORUwp OworCXNndF9pbmZvLT52YV92bWFwcGVkID0ga2NhbGxvYygxLCBzaXplb2Yoc3RydWN0IHZtYXBf dmFkZHJfbGlzdCksIEdGUF9LRVJORUwpOworCisJc2d0X2luZm8tPmFjdGl2ZV9zZ3RzLT5zZ3Qg PSBzZ3Q7CisJc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZC0+YXR0YWNoID0gYXR0YWNobWVudDsK KwlzZ3RfaW5mby0+dmFfa21hcHBlZC0+dmFkZHIgPSBOVUxMOyAvKiBmaXJzdCB2YWRkciBpcyBO VUxMICovCisJc2d0X2luZm8tPnZhX3ZtYXBwZWQtPnZhZGRyID0gTlVMTDsgLyogZmlyc3QgdmFk ZHIgaXMgTlVMTCAqLworCisJLyogaW5pdGlhbGl6ZSBsaXN0IG9mIHNndCwgYXR0YWNobWVudCBh bmQgdmFkZHIgZm9yIGRtYWJ1ZiBzeW5jCisJICogdmlhIHNoYWRvdyBkbWEtYnVmCisJICovCisJ SU5JVF9MSVNUX0hFQUQoJnNndF9pbmZvLT5hY3RpdmVfc2d0cy0+bGlzdCk7CisJSU5JVF9MSVNU X0hFQUQoJnNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQtPmxpc3QpOworCUlOSVRfTElTVF9IRUFE KCZzZ3RfaW5mby0+dmFfa21hcHBlZC0+bGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnNndF9pbmZv LT52YV92bWFwcGVkLT5saXN0KTsKKwogCXBhZ2VfaW5mbyA9IGh5cGVyX2RtYWJ1Zl9leHRfcGdz KHNndCk7CiAJaWYgKHBhZ2VfaW5mbyA9PSBOVUxMKQogCQlnb3RvIGZhaWxfZXhwb3J0OwpAQCAt MTU1LDcgKzE3NCw3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGUodm9p ZCAqZGF0YSkKIAlvcGVyYW5kc1syXSA9IHBhZ2VfaW5mby0+ZnJzdF9vZnN0OwogCW9wZXJhbmRz WzNdID0gcGFnZV9pbmZvLT5sYXN0X2xlbjsKIAlvcGVyYW5kc1s0XSA9IGh5cGVyX2RtYWJ1Zl9j cmVhdGVfZ3JlZl90YWJsZShwYWdlX2luZm8tPnBhZ2VzLCBleHBvcnRfcmVtb3RlX2F0dHItPnJl bW90ZV9kb21haW4sCi0JCQkJCQlwYWdlX2luZm8tPm5lbnRzLCAmc2d0X2luZm8tPnNoYXJlZF9w YWdlc19pbmZvKTsKKwkJCQkJCSAgICAgcGFnZV9pbmZvLT5uZW50cywgJnNndF9pbmZvLT5zaGFy ZWRfcGFnZXNfaW5mbyk7CiAJLyogZHJpdmVyL2FwcGxpY2F0aW9uIHNwZWNpZmljIHByaXZhdGUg aW5mbywgbWF4IDMyIGJ5dGVzICovCiAJb3BlcmFuZHNbNV0gPSBleHBvcnRfcmVtb3RlX2F0dHIt PnByaXZhdGVbMF07CiAJb3BlcmFuZHNbNl0gPSBleHBvcnRfcmVtb3RlX2F0dHItPnByaXZhdGVb MV07CkBAIC0xNjYsNyArMTg1LDcgQEAgc3RhdGljIGludCBoeXBlcl9kbWFidWZfZXhwb3J0X3Jl bW90ZSh2b2lkICpkYXRhKQogCiAJLyogY29tcG9zaW5nIGEgbWVzc2FnZSB0byB0aGUgaW1wb3J0 ZXIgKi8KIAloeXBlcl9kbWFidWZfY3JlYXRlX3JlcXVlc3QocmVxLCBIWVBFUl9ETUFCVUZfRVhQ T1JULCAmb3BlcmFuZHNbMF0pOwotCWlmKGh5cGVyX2RtYWJ1Zl9zZW5kX3JlcXVlc3QoZXhwb3J0 X3JlbW90ZV9hdHRyLT5yZW1vdGVfZG9tYWluLCByZXEpKQorCWlmKGh5cGVyX2RtYWJ1Zl9zZW5k X3JlcXVlc3QoZXhwb3J0X3JlbW90ZV9hdHRyLT5yZW1vdGVfZG9tYWluLCByZXEsIGZhbHNlKSkK IAkJZ290byBmYWlsX3NlbmRfcmVxdWVzdDsKIAogCS8qIGZyZWUgbXNnICovCkBAIC0xODEsMTAg KzIwMCwxNyBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlKHZvaWQgKmRh dGEpCiAJaHlwZXJfZG1hYnVmX3JlbW92ZV9leHBvcnRlZChzZ3RfaW5mby0+aHlwZXJfZG1hYnVm X2lkKTsKIAogZmFpbF9leHBvcnQ6Ci0JZG1hX2J1Zl91bm1hcF9hdHRhY2htZW50KHNndF9pbmZv LT5hdHRhY2htZW50LCBzZ3RfaW5mby0+c2d0LCBETUFfQklESVJFQ1RJT05BTCk7Ci0JZG1hX2J1 Zl9kZXRhY2goc2d0X2luZm8tPmRtYV9idWYsIHNndF9pbmZvLT5hdHRhY2htZW50KTsKKwlkbWFf YnVmX3VubWFwX2F0dGFjaG1lbnQoc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZC0+YXR0YWNoLAor CQkJCSBzZ3RfaW5mby0+YWN0aXZlX3NndHMtPnNndCwKKwkJCQkgRE1BX0JJRElSRUNUSU9OQUwp OworCWRtYV9idWZfZGV0YWNoKHNndF9pbmZvLT5kbWFfYnVmLCBzZ3RfaW5mby0+YWN0aXZlX2F0 dGFjaGVkLT5hdHRhY2gpOwogCWRtYV9idWZfcHV0KHNndF9pbmZvLT5kbWFfYnVmKTsKIAorCWtm cmVlKHNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQpOworCWtmcmVlKHNndF9pbmZvLT5hY3RpdmVf c2d0cyk7CisJa2ZyZWUoc2d0X2luZm8tPnZhX2ttYXBwZWQpOworCWtmcmVlKHNndF9pbmZvLT52 YV92bWFwcGVkKTsKKwogCXJldHVybiAtRUlOVkFMOwogfQogCkBAIC0yMzMsNyArMjU5LDggQEAg c3RhdGljIGludCBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkX2lvY3RsKHZvaWQgKmRhdGEpCiB9CiAK IC8qIHJlbW92aW5nIGRtYWJ1ZiBmcm9tIHRoZSBkYXRhYmFzZSBhbmQgc2VuZCBpbnQgcmVxIHRv IHRoZSBzb3VyY2UgZG9tYWluCi0qIHRvIHVubWFwIGl0LiAqLworICogdG8gdW5tYXAgaXQuCisg Ki8KIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2Rlc3Ryb3kodm9pZCAqZGF0YSkKIHsKIAlzdHJ1 Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX2Rlc3Ryb3kgKmRlc3Ryb3lfYXR0cjsKQEAgLTI1MCw3ICsy NzcsOSBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9kZXN0cm95KHZvaWQgKmRhdGEpCiAKIAkv KiBmaW5kIGRtYWJ1ZiBpbiBleHBvcnQgbGlzdCAqLwogCXNndF9pbmZvID0gaHlwZXJfZG1hYnVm X2ZpbmRfZXhwb3J0ZWQoZGVzdHJveV9hdHRyLT5oeXBlcl9kbWFidWZfaWQpOwotCWlmIChzZ3Rf aW5mbyA9PSBOVUxMKSB7IC8qIGZhaWxlZCB0byBmaW5kIGNvcnJlc3BvbmRpbmcgZW50cnkgaW4g ZXhwb3J0IGxpc3QgKi8KKworCS8qIGZhaWxlZCB0byBmaW5kIGNvcnJlc3BvbmRpbmcgZW50cnkg aW4gZXhwb3J0IGxpc3QgKi8KKwlpZiAoc2d0X2luZm8gPT0gTlVMTCkgewogCQlkZXN0cm95X2F0 dHItPnN0YXR1cyA9IC1FSU5WQUw7CiAJCXJldHVybiAtRUZBVUxUOwogCX0KQEAgLTI2MCw4ICsy ODksOSBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9kZXN0cm95KHZvaWQgKmRhdGEpCiAJaHlw ZXJfZG1hYnVmX2NyZWF0ZV9yZXF1ZXN0KHJlcSwgSFlQRVJfRE1BQlVGX0RFU1RST1ksICZkZXN0 cm95X2F0dHItPmh5cGVyX2RtYWJ1Zl9pZCk7CiAKIAkvKiBub3cgc2VuZCBkZXN0cm95IHJlcXVl c3QgdG8gcmVtb3RlIGRvbWFpbgotCSAqIGN1cnJlbnRseSBhc3N1bWluZyB0aGVyZSdzIG9ubHkg b25lIGltcG9ydGVyIGV4aXN0ICovCi0JcmV0ID0gaHlwZXJfZG1hYnVmX3NlbmRfcmVxdWVzdChz Z3RfaW5mby0+aHlwZXJfZG1hYnVmX3Jkb21haW4sIHJlcSk7CisJICogY3VycmVudGx5IGFzc3Vt aW5nIHRoZXJlJ3Mgb25seSBvbmUgaW1wb3J0ZXIgZXhpc3QKKwkgKi8KKwlyZXQgPSBoeXBlcl9k bWFidWZfc2VuZF9yZXF1ZXN0KHNndF9pbmZvLT5oeXBlcl9kbWFidWZfcmRvbWFpbiwgcmVxLCB0 cnVlKTsKIAlpZiAocmV0IDwgMCkgewogCQlrZnJlZShyZXEpOwogCQlyZXR1cm4gLUVGQVVMVDsK ZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5j IGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9saXN0LmMKaW5kZXggYWQy MTA5Yy4uMmIzZWY2YiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9saXN0LmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1 Zl9saXN0LmMKQEAgLTMzLDcgKzMzLDcgQEAgaW50IGh5cGVyX2RtYWJ1Zl9yZWdpc3Rlcl9leHBv cnRlZChzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvICppbmZvKQogCWluZm9fZW50cnktPmlu Zm8gPSBpbmZvOwogCiAJaGFzaF9hZGQoaHlwZXJfZG1hYnVmX2hhc2hfZXhwb3J0ZWQsICZpbmZv X2VudHJ5LT5ub2RlLAotCQlpbmZvX2VudHJ5LT5pbmZvLT5oeXBlcl9kbWFidWZfaWQpOworCQkg aW5mb19lbnRyeS0+aW5mby0+aHlwZXJfZG1hYnVmX2lkKTsKIAogCXJldHVybiAwOwogfQpAQCAt NDcsNyArNDcsNyBAQCBpbnQgaHlwZXJfZG1hYnVmX3JlZ2lzdGVyX2ltcG9ydGVkKHN0cnVjdCBo eXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8qIGluZm8pCiAJaW5mb19lbnRyeS0+aW5mbyA9 IGluZm87CiAKIAloYXNoX2FkZChoeXBlcl9kbWFidWZfaGFzaF9pbXBvcnRlZCwgJmluZm9fZW50 cnktPm5vZGUsCi0JCWluZm9fZW50cnktPmluZm8tPmh5cGVyX2RtYWJ1Zl9pZCk7CisJCSBpbmZv X2VudHJ5LT5pbmZvLT5oeXBlcl9kbWFidWZfaWQpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC03MSw4 ICs3MSw4IEBAIGludCBoeXBlcl9kbWFidWZfZmluZF9pZChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVm LCBpbnQgZG9taWQpCiAJaW50IGJrdDsKIAogCWhhc2hfZm9yX2VhY2goaHlwZXJfZG1hYnVmX2hh c2hfZXhwb3J0ZWQsIGJrdCwgaW5mb19lbnRyeSwgbm9kZSkKLQkJaWYoaW5mb19lbnRyeS0+aW5m by0+YXR0YWNobWVudC0+ZG1hYnVmID09IGRtYWJ1ZiAmJgotCQkJaW5mb19lbnRyeS0+aW5mby0+ aHlwZXJfZG1hYnVmX3Jkb21haW4gPT0gZG9taWQpCisJCWlmKGluZm9fZW50cnktPmluZm8tPmRt YV9idWYgPT0gZG1hYnVmICYmCisJCSAgIGluZm9fZW50cnktPmluZm8tPmh5cGVyX2RtYWJ1Zl9y ZG9tYWluID09IGRvbWlkKQogCQkJcmV0dXJuIGluZm9fZW50cnktPmluZm8tPmh5cGVyX2RtYWJ1 Zl9pZDsKIAogCXJldHVybiAtMTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi9oeXBlcl9kbWFidWZfbXNnLmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1h YnVmX21zZy5jCmluZGV4IDhhMDU5YzguLjI0MzJhNGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYwpAQCAtNyw3ICs3LDcgQEAKICNpbmNsdWRlIDxsaW51 eC93b3JrcXVldWUuaD4KICNpbmNsdWRlICJoeXBlcl9kbWFidWZfZHJ2LmgiCiAjaW5jbHVkZSAi aHlwZXJfZG1hYnVmX2ltcC5oIgotLy8jaW5jbHVkZSAiaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5j LmgiCisjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jLmgiCiAjaW5jbHVkZSAieGVu L2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5oIgogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9tc2cuaCIK ICNpbmNsdWRlICJoeXBlcl9kbWFidWZfbGlzdC5oIgpAQCAtMTI1LDcgKzEyNSw5IEBAIHZvaWQg Y21kX3Byb2Nlc3Nfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJCSAqIG9wZXJhbmRz MCA6IGh5cGVyX2RtYWJ1Zl9pZAogCQkgKi8KIAotCQkvKiBUT0RPOiB0aGF0IHNob3VsZCBiZSBk b25lIG9uIHdvcmtxdWV1ZSwgd2hlbiByZWNlaXZlZCBhY2sgZnJvbSBhbGwgaW1wb3J0ZXJzIHRo YXQgYnVmZmVyIGlzIG5vIGxvbmdlciB1c2VkICovCisJCS8qIFRPRE86IHRoYXQgc2hvdWxkIGJl IGRvbmUgb24gd29ya3F1ZXVlLCB3aGVuIHJlY2VpdmVkIGFjayBmcm9tCisJCSAqIGFsbCBpbXBv cnRlcnMgdGhhdCBidWZmZXIgaXMgbm8gbG9uZ2VyIHVzZWQKKwkJICovCiAJCXNndF9pbmZvID0K IAkJCWh5cGVyX2RtYWJ1Zl9maW5kX2V4cG9ydGVkKHJlcS0+b3BlcmFuZHNbMF0pOwogCkBAIC0x MzMsOCArMTM1LDEwIEBAIHZvaWQgY21kX3Byb2Nlc3Nfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3Qg KndvcmspCiAJCQloeXBlcl9kbWFidWZfY2xlYW51cF9ncmVmX3RhYmxlKHNndF9pbmZvKTsKIAog CQkJLyogdW5tYXAgZG1hYnVmICovCi0JCQlkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoc2d0X2lu Zm8tPmF0dGFjaG1lbnQsIHNndF9pbmZvLT5zZ3QsIERNQV9CSURJUkVDVElPTkFMKTsKLQkJCWRt YV9idWZfZGV0YWNoKHNndF9pbmZvLT5kbWFfYnVmLCBzZ3RfaW5mby0+YXR0YWNobWVudCk7CisJ CQlkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZC0+YXR0 YWNoLAorCQkJCQkJIHNndF9pbmZvLT5hY3RpdmVfc2d0cy0+c2d0LAorCQkJCQkJIERNQV9CSURJ UkVDVElPTkFMKTsKKwkJCWRtYV9idWZfZGV0YWNoKHNndF9pbmZvLT5kbWFfYnVmLCBzZ3RfaW5m by0+YWN0aXZlX2F0dGFjaGVkLT5hdHRhY2gpOwogCQkJZG1hX2J1Zl9wdXQoc2d0X2luZm8tPmRt YV9idWYpOwogCiAJCQkvKiBUT0RPOiBSZXN0IG9mIGNsZWFudXAsIHNndCBjbGVhbnVwIGV0YyAq LwpAQCAtMTQ3LDE2ICsxNTEsNiBAQCB2b2lkIGNtZF9wcm9jZXNzX3dvcmsoc3RydWN0IHdvcmtf c3RydWN0ICp3b3JrKQogCQkvKiBmb3IgZG1hYnVmIHN5bmNocm9uaXphdGlvbiAqLwogCQlicmVh azsKIAotCS8qIGFzIGltcG9ydGVyLCBjb21tYW5kIHRvIGV4cG9ydGVyICovCi0JY2FzZSBIWVBF Ul9ETUFCVUZfT1BTX1RPX1NPVVJDRToKLQkJLyogbm90aWZ5aW5nIGRtYWJ1ZiBtYXAvdW5tYXAg dG8gZXhwb3J0ZXIsIG1hcCB3aWxsIG1ha2UgdGhlIGRyaXZlciB0byBkbyBzaGFkb3cgbWFwcGlu ZwotCQkqIG9yIHVubWFwcGluZyBmb3Igc3luY2hyb25pemF0aW9uIHdpdGggb3JpZ2luYWwgZXhw b3J0ZXIgKGUuZy4gaTkxNSkgKi8KLQkJLyogY29tbWFuZCA6IERNQUJVRl9PUFNfVE9fU09VUkNF LgotCQkgKiBvcGVyYW5kczAgOiBoeXBlcl9kbWFidWZfaWQKLQkJICogb3BlcmFuZHMxIDogbWFw KD0xKS91bm1hcCg9MikvYXR0YWNoKD0zKS9kZXRhY2goPTQpCi0JCSAqLwotCQlicmVhazsKLQog CWRlZmF1bHQ6CiAJCS8qIHNob3VsZG4ndCBnZXQgaGVyZSAqLwogCQkvKiBubyBtYXRjaGVkIGNv bW1hbmQsIG5vdGhpbmcgdG8gZG8uLiBqdXN0IHJldHVybiBlcnJvciAqLwpAQCAtMTcyLDYgKzE2 Niw3IEBAIGludCBoeXBlcl9kbWFidWZfbXNnX3BhcnNlKGludCBkb21pZCwgc3RydWN0IGh5cGVy X2RtYWJ1Zl9yaW5nX3JxICpyZXEpCiAJc3RydWN0IGNtZF9wcm9jZXNzICpwcm9jOwogCXN0cnVj dCBoeXBlcl9kbWFidWZfcmluZ19ycSAqdGVtcF9yZXE7CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9p bXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWRfc2d0X2luZm87CisJaW50IHJldDsKIAogCWlmICgh cmVxKSB7CiAJCXByaW50aygicmVxdWVzdCBpcyBOVUxMXG4iKTsKQEAgLTIxNiw3ICsyMTEsMjUg QEAgaW50IGh5cGVyX2RtYWJ1Zl9tc2dfcGFyc2UoaW50IGRvbWlkLCBzdHJ1Y3QgaHlwZXJfZG1h YnVmX3JpbmdfcnEgKnJlcSkKIAkJcmV0dXJuIHJlcS0+Y29tbWFuZDsKIAl9CiAKLQl0ZW1wX3Jl cSA9IChzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JpbmdfcnEgKilrbWFsbG9jKHNpemVvZigqdGVtcF9y ZXEpLCBHRlBfS0VSTkVMKTsKKwkvKiBkbWEgYnVmIHJlbW90ZSBzeW5jaHJvbml6YXRpb24gKi8K KwlpZiAocmVxLT5jb21tYW5kID09IEhZUEVSX0RNQUJVRl9PUFNfVE9fU09VUkNFKSB7CisJCS8q IG5vdGlmeWluZyBkbWFidWYgbWFwL3VubWFwIHRvIGV4cG9ydGVyLCBtYXAgd2lsbCBtYWtlIHRo ZSBkcml2ZXIgdG8gZG8gc2hhZG93IG1hcHBpbmcKKwkJICogb3IgdW5tYXBwaW5nIGZvciBzeW5j aHJvbml6YXRpb24gd2l0aCBvcmlnaW5hbCBleHBvcnRlciAoZS5nLiBpOTE1KSAqLworCisJCS8q IGNvbW1hbmQgOiBETUFCVUZfT1BTX1RPX1NPVVJDRS4KKwkJICogb3BlcmFuZHMwIDogaHlwZXJf ZG1hYnVmX2lkCisJCSAqIG9wZXJhbmRzMSA6IGVudW0gaHlwZXJfZG1hYnVmX29wcyB7Li4uLn0K KwkJICovCisJCXJldCA9IGh5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYyhyZXEtPm9wZXJhbmRzWzBd LCByZXEtPm9wZXJhbmRzWzFdKTsKKwkJaWYgKHJldCkKKwkJCXJlcS0+c3RhdHVzID0gSFlQRVJf RE1BQlVGX1JFUV9FUlJPUjsKKwkJZWxzZQorCQkJcmVxLT5zdGF0dXMgPSBIWVBFUl9ETUFCVUZf UkVRX1BST0NFU1NFRDsKKworCQlyZXR1cm4gcmVxLT5jb21tYW5kOworCX0KKworCXRlbXBfcmVx ID0ga21hbGxvYyhzaXplb2YoKnRlbXBfcmVxKSwgR0ZQX0tFUk5FTCk7CiAKIAltZW1jcHkodGVt cF9yZXEsIHJlcSwgc2l6ZW9mKCp0ZW1wX3JlcSkpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jLmMgYi9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jLmMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uNmJhOTMyZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMuYwpAQCAtMCwwICsxLDE4OSBA QAorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+Cisj aW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1 ZGUgPGxpbnV4L2RtYS1idWYuaD4KKyNpbmNsdWRlICJoeXBlcl9kbWFidWZfc3RydWN0LmgiCisj aW5jbHVkZSAiaHlwZXJfZG1hYnVmX2xpc3QuaCIKKyNpbmNsdWRlICJoeXBlcl9kbWFidWZfZHJ2 LmgiCisjaW5jbHVkZSAieGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5oIgorI2luY2x1ZGUgImh5 cGVyX2RtYWJ1Zl9tc2cuaCIKKworZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfcHJpdmF0ZSBo eXBlcl9kbWFidWZfcHJpdmF0ZTsKKworaW50IGh5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYyhpbnQg aWQsIGludCBvcHMpCit7CisJc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm87 CisJc3RydWN0IHNndF9saXN0ICpzZ3RsOworCXN0cnVjdCBhdHRhY2htZW50X2xpc3QgKmF0dGFj aGw7CisJc3RydWN0IGttYXBfdmFkZHJfbGlzdCAqdmFfa21hcGw7CisJc3RydWN0IHZtYXBfdmFk ZHJfbGlzdCAqdmFfdm1hcGw7CisJaW50IHJldDsKKworCS8qIGZpbmQgYSBjb3Jlc3BvbmRpbmcg U0dUIGZvciB0aGUgaWQgKi8KKwlzZ3RfaW5mbyA9IGh5cGVyX2RtYWJ1Zl9maW5kX2V4cG9ydGVk KGlkKTsKKworCWlmICghc2d0X2luZm8pIHsKKwkJcHJpbnRrKCJkbWFidWYgcmVtb3RlIHN5bmM6 OmNhbid0IGZpbmQgZXhwb3J0ZWQgbGlzdFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwor CXN3aXRjaCAob3BzKSB7CisJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX0FUVEFDSDoKKwkJYXR0YWNo bCA9IGtjYWxsb2MoMSwgc2l6ZW9mKCphdHRhY2hsKSwgR0ZQX0tFUk5FTCk7CisKKwkJYXR0YWNo bC0+YXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goc2d0X2luZm8tPmRtYV9idWYsCisJCQkJCQloeXBl cl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UpOworCisJCWlmICghYXR0YWNobC0+YXR0YWNoKSB7CisJ CQlrZnJlZShhdHRhY2hsKTsKKwkJCXByaW50aygiZG1hYnVmIHJlbW90ZSBzeW5jOjplcnJvciB3 aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfQVRUQUNIXG4iKTsKKwkJCXJldHVybiAt RUlOVkFMOworCQl9CisKKwkJbGlzdF9hZGQoJmF0dGFjaGwtPmxpc3QsICZzZ3RfaW5mby0+YWN0 aXZlX2F0dGFjaGVkLT5saXN0KTsKKwkJYnJlYWs7CisKKwljYXNlIEhZUEVSX0RNQUJVRl9PUFNf REVUQUNIOgorCQlhdHRhY2hsID0gbGlzdF9maXJzdF9lbnRyeSgmc2d0X2luZm8tPmFjdGl2ZV9h dHRhY2hlZC0+bGlzdCwKKwkJCQkJc3RydWN0IGF0dGFjaG1lbnRfbGlzdCwgbGlzdCk7CisKKwkJ aWYgKCFhdHRhY2hsKSB7CisJCQlwcmludGsoImRtYWJ1ZiByZW1vdGUgc3luYzo6ZXJyb3Igd2hp bGUgcHJvY2Vzc2luZyBIWVBFUl9ETUFCVUZfT1BTX0RFVEFDSFxuIik7CisJCQlyZXR1cm4gLUVJ TlZBTDsKKwkJfQorCQlkbWFfYnVmX2RldGFjaChzZ3RfaW5mby0+ZG1hX2J1ZiwgYXR0YWNobC0+ YXR0YWNoKTsKKwkJbGlzdF9kZWwoJmF0dGFjaGwtPmxpc3QpOworCQlrZnJlZShhdHRhY2hsKTsK KwkJYnJlYWs7CisKKwljYXNlIEhZUEVSX0RNQUJVRl9PUFNfTUFQOgorCQlzZ3RsID0ga2NhbGxv YygxLCBzaXplb2YoKnNndGwpLCBHRlBfS0VSTkVMKTsKKwkJYXR0YWNobCA9IGxpc3RfZmlyc3Rf ZW50cnkoJnNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQtPmxpc3QsCisJCQkJCXN0cnVjdCBhdHRh Y2htZW50X2xpc3QsIGxpc3QpOworCQlzZ3RsLT5zZ3QgPSBkbWFfYnVmX21hcF9hdHRhY2htZW50 KGF0dGFjaGwtPmF0dGFjaCwgRE1BX0JJRElSRUNUSU9OQUwpOworCQlpZiAoIXNndGwtPnNndCkg eworCQkJa2ZyZWUoc2d0bCk7CisJCQlwcmludGsoImRtYWJ1ZiByZW1vdGUgc3luYzo6ZXJyb3Ig d2hpbGUgcHJvY2Vzc2luZyBIWVBFUl9ETUFCVUZfT1BTX01BUFxuIik7CisJCQlyZXR1cm4gLUVJ TlZBTDsKKwkJfQorCQlsaXN0X2FkZCgmc2d0bC0+bGlzdCwgJnNndF9pbmZvLT5hY3RpdmVfc2d0 cy0+bGlzdCk7CisJCWJyZWFrOworCisJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX1VOTUFQOgorCQlh dHRhY2hsID0gbGlzdF9maXJzdF9lbnRyeSgmc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZC0+bGlz dCwKKwkJCQkJc3RydWN0IGF0dGFjaG1lbnRfbGlzdCwgbGlzdCk7CisJCXNndGwgPSBsaXN0X2Zp cnN0X2VudHJ5KCZzZ3RfaW5mby0+YWN0aXZlX3NndHMtPmxpc3QsCisJCQkJCXN0cnVjdCBzZ3Rf bGlzdCwgbGlzdCk7CisJCWlmICghYXR0YWNobCB8fCAhc2d0bCkgeworCQkJcHJpbnRrKCJkbWFi dWYgcmVtb3RlIHN5bmM6OmVycm9yIHdoaWxlIHByb2Nlc3NpbmcgSFlQRVJfRE1BQlVGX09QU19V Tk1BUFxuIik7CisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCisJCWRtYV9idWZfdW5tYXBfYXR0 YWNobWVudChhdHRhY2hsLT5hdHRhY2gsIHNndGwtPnNndCwKKwkJCQkJRE1BX0JJRElSRUNUSU9O QUwpOworCQlsaXN0X2RlbCgmc2d0bC0+bGlzdCk7CisJCWtmcmVlKHNndGwpOworCQlicmVhazsK KworCWNhc2UgSFlQRVJfRE1BQlVGX09QU19SRUxFQVNFOgorCQkvKiByZW1vdGUgaW1wb3J0ZXIg c2hvdWxkbid0IHJlbGVhc2UgZG1hX2J1ZiBiZWNhdXNlCisJCSAqIGV4cG9ydGVyIHdpbGwgaG9s ZCBoYW5kbGUgdG8gdGhlIGRtYV9idWYgYXMKKwkJICogZmFyIGFzIGRtYV9idWYgaXMgc2hhcmVk IHdpdGggb3RoZXIgZG9tYWlucy4KKwkJICovCisJCWJyZWFrOworCisJY2FzZSBIWVBFUl9ETUFC VUZfT1BTX0JFR0lOX0NQVV9BQ0NFU1M6CisJCXJldCA9IGRtYV9idWZfYmVnaW5fY3B1X2FjY2Vz cyhzZ3RfaW5mby0+ZG1hX2J1ZiwgRE1BX0JJRElSRUNUSU9OQUwpOworCQlpZiAoIXJldCkgewor CQkJcHJpbnRrKCJkbWFidWYgcmVtb3RlIHN5bmM6OmVycm9yIHdoaWxlIHByb2Nlc3NpbmcgSFlQ RVJfRE1BQlVGX09QU19CRUdJTl9DUFVfQUNDRVNTXG4iKTsKKwkJCXJldCA9IC1FSU5WQUw7CisJ CX0KKwkJYnJlYWs7CisKKwljYXNlIEhZUEVSX0RNQUJVRl9PUFNfRU5EX0NQVV9BQ0NFU1M6CisJ CXJldCA9IGRtYV9idWZfZW5kX2NwdV9hY2Nlc3Moc2d0X2luZm8tPmRtYV9idWYsIERNQV9CSURJ UkVDVElPTkFMKTsKKwkJaWYgKCFyZXQpIHsKKwkJCXByaW50aygiZG1hYnVmIHJlbW90ZSBzeW5j OjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfRU5EX0NQVV9BQ0NFU1Nc biIpOworCQkJcmV0ID0gLUVJTlZBTDsKKwkJfQorCQlicmVhazsKKworCWNhc2UgSFlQRVJfRE1B QlVGX09QU19LTUFQX0FUT01JQzoKKwljYXNlIEhZUEVSX0RNQUJVRl9PUFNfS01BUDoKKwkJdmFf a21hcGwgPSBrY2FsbG9jKDEsIHNpemVvZigqdmFfa21hcGwpLCBHRlBfS0VSTkVMKTsKKworCQkv KiBkdW1teSBrbWFwcGluZyBvZiAxIHBhZ2UgKi8KKwkJaWYgKG9wcyA9PSBIWVBFUl9ETUFCVUZf T1BTX0tNQVBfQVRPTUlDKQorCQkJdmFfa21hcGwtPnZhZGRyID0gZG1hX2J1Zl9rbWFwX2F0b21p YyhzZ3RfaW5mby0+ZG1hX2J1ZiwgMSk7CisJCWVsc2UKKwkJCXZhX2ttYXBsLT52YWRkciA9IGRt YV9idWZfa21hcChzZ3RfaW5mby0+ZG1hX2J1ZiwgMSk7CisKKwkJaWYgKCF2YV9rbWFwbC0+dmFk ZHIpIHsKKwkJCWtmcmVlKHZhX2ttYXBsKTsKKwkJCXByaW50aygiZG1hYnVmIHJlbW90ZSBzeW5j OjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfS01BUChfQVRPTUlDKVxu Iik7CisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCQlsaXN0X2FkZCgmdmFfa21hcGwtPmxpc3Qs ICZzZ3RfaW5mby0+dmFfa21hcHBlZC0+bGlzdCk7CisJCWJyZWFrOworCisJY2FzZSBIWVBFUl9E TUFCVUZfT1BTX0tVTk1BUF9BVE9NSUM6CisJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX0tVTk1BUDoK KwkJdmFfa21hcGwgPSBsaXN0X2ZpcnN0X2VudHJ5KCZzZ3RfaW5mby0+dmFfa21hcHBlZC0+bGlz dCwKKwkJCQkJc3RydWN0IGttYXBfdmFkZHJfbGlzdCwgbGlzdCk7CisJCWlmICghdmFfa21hcGwg fHwgdmFfa21hcGwtPnZhZGRyID09IE5VTEwpIHsKKwkJCXByaW50aygiZG1hYnVmIHJlbW90ZSBz eW5jOjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfS1VOTUFQKF9BVE9N SUMpXG4iKTsKKwkJCXJldHVybiAtRUlOVkFMOworCQl9CisKKwkJLyogdW5tYXBwaW5nIDEgcGFn ZSAqLworCQlpZiAob3BzID09IEhZUEVSX0RNQUJVRl9PUFNfS1VOTUFQX0FUT01JQykKKwkJCWRt YV9idWZfa3VubWFwX2F0b21pYyhzZ3RfaW5mby0+ZG1hX2J1ZiwgMSwgdmFfa21hcGwtPnZhZGRy KTsKKwkJZWxzZQorCQkJZG1hX2J1Zl9rdW5tYXAoc2d0X2luZm8tPmRtYV9idWYsIDEsIHZhX2tt YXBsLT52YWRkcik7CisKKwkJbGlzdF9kZWwoJnZhX2ttYXBsLT5saXN0KTsKKwkJa2ZyZWUodmFf a21hcGwpOworCQlicmVhazsKKworCWNhc2UgSFlQRVJfRE1BQlVGX09QU19NTUFQOgorCQkvKiBj dXJyZW50bHkgbm90IHN1cHBvcnRlZDogbG9va2luZyBmb3IgYSB3YXkgdG8gY3JlYXRlCisJCSAq IGEgZHVtbXkgdm1hICovCisJCXByaW50aygiZG1hYnVmIHJlbW90ZSBzeW5jOjpzeWNocm9uaXpl ZCBtbWFwIGlzIG5vdCBzdXBwb3J0ZWRcbiIpOworCQlicmVhazsKKworCWNhc2UgSFlQRVJfRE1B QlVGX09QU19WTUFQOgorCQl2YV92bWFwbCA9IGtjYWxsb2MoMSwgc2l6ZW9mKCp2YV92bWFwbCks IEdGUF9LRVJORUwpOworCisJCS8qIGR1bW15IHZtYXBwaW5nICovCisJCXZhX3ZtYXBsLT52YWRk ciA9IGRtYV9idWZfdm1hcChzZ3RfaW5mby0+ZG1hX2J1Zik7CisKKwkJaWYgKCF2YV92bWFwbC0+ dmFkZHIpIHsKKwkJCWtmcmVlKHZhX3ZtYXBsKTsKKwkJCXByaW50aygiZG1hYnVmIHJlbW90ZSBz eW5jOjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfVk1BUFxuIik7CisJ CQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCQlsaXN0X2FkZCgmdmFfdm1hcGwtPmxpc3QsICZzZ3Rf aW5mby0+dmFfdm1hcHBlZC0+bGlzdCk7CisJCWJyZWFrOworCisJY2FzZSBIWVBFUl9ETUFCVUZf T1BTX1ZVTk1BUDoKKwkJdmFfdm1hcGwgPSBsaXN0X2ZpcnN0X2VudHJ5KCZzZ3RfaW5mby0+dmFf dm1hcHBlZC0+bGlzdCwKKwkJCQkJc3RydWN0IHZtYXBfdmFkZHJfbGlzdCwgbGlzdCk7CisJCWlm ICghdmFfdm1hcGwgfHwgdmFfdm1hcGwtPnZhZGRyID09IE5VTEwpIHsKKwkJCXByaW50aygiZG1h YnVmIHJlbW90ZSBzeW5jOjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNf VlVOTUFQXG4iKTsKKwkJCXJldHVybiAtRUlOVkFMOworCQl9CisKKwkJZG1hX2J1Zl92dW5tYXAo c2d0X2luZm8tPmRtYV9idWYsIHZhX3ZtYXBsLT52YWRkcik7CisKKwkJbGlzdF9kZWwoJnZhX3Zt YXBsLT5saXN0KTsKKwkJa2ZyZWUodmFfdm1hcGwpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJ CS8qIHByb2dyYW0gc2hvdWxkIG5vdCBnZXQgaGVyZSAqLworCQlicmVhazsKKwl9CisKKwlyZXR1 cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFi dWZfcmVtb3RlX3N5bmMuaCBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZf cmVtb3RlX3N5bmMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYzg1ZmE4 Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1 Zl9yZW1vdGVfc3luYy5oCkBAIC0wLDAgKzEsNiBAQAorI2lmbmRlZiBfX0hZUEVSX0RNQUJVRl9S RU1PVEVfU1lOQ19IX18KKyNkZWZpbmUgX19IWVBFUl9ETUFCVUZfUkVNT1RFX1NZTkNfSF9fCisK K2ludCBoeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMoaW50IGlkLCBpbnQgb3BzKTsKKworI2VuZGlm IC8vIF9fSFlQRVJfRE1BQlVGX1JFTU9URV9TWU5DX0hfXwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94 ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaCBiL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmgKaW5kZXggYzhhMmY0ZC4uYmZlODBlZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaAor KysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3N0cnVjdC5oCkBAIC0x OCw2ICsxOCwzMCBAQAogICogZnJhbWUgYnVmZmVyKSAqLwogI2RlZmluZSBNQVhfQUxMT1dFRF9O VU1fUEFHRVNfRk9SX0dSRUZfTlVNX0FSUkFZUyA0CiAKKy8qIHN0YWNrIG9mIG1hcHBlZCBzZ3Rz ICovCitzdHJ1Y3Qgc2d0X2xpc3QgeworCXN0cnVjdCBzZ190YWJsZSAqc2d0OworCXN0cnVjdCBs aXN0X2hlYWQgbGlzdDsKK307CisKKy8qIHN0YWNrIG9mIGF0dGFjaG1lbnRzICovCitzdHJ1Y3Qg YXR0YWNobWVudF9saXN0IHsKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2g7CisJ c3RydWN0IGxpc3RfaGVhZCBsaXN0OworfTsKKworLyogc3RhY2sgb2YgdmFkZHIgbWFwcGVkIHZp YSBrbWFwICovCitzdHJ1Y3Qga21hcF92YWRkcl9saXN0IHsKKwl2b2lkICp2YWRkcjsKKwlzdHJ1 Y3QgbGlzdF9oZWFkIGxpc3Q7Cit9OworCisvKiBzdGFjayBvZiB2YWRkciBtYXBwZWQgdmlhIHZt YXAgKi8KK3N0cnVjdCB2bWFwX3ZhZGRyX2xpc3QgeworCXZvaWQgKnZhZGRyOworCXN0cnVjdCBs aXN0X2hlYWQgbGlzdDsKK307CisKIHN0cnVjdCBoeXBlcl9kbWFidWZfc2hhcmVkX3BhZ2VzX2lu Zm8gewogCWdyYW50X3JlZl90ICpkYXRhX3JlZnM7CS8qIHRhYmxlIHdpdGggc2hhcmVkIGJ1ZmZl ciBwYWdlcyByZWZpZCAqLwogCWdyYW50X3JlZl90ICphZGRyX3BhZ2VzOyAvKiBwYWdlcyBvZiAy bmQgbGV2ZWwgYWRkcmVzc2luZyAqLwpAQCAtNDYsOSArNzAsMTMgQEAgc3RydWN0IGh5cGVyX2Rt YWJ1Zl9wYWdlc19pbmZvIHsKIHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gewogICAgICAg ICBpbnQgaHlwZXJfZG1hYnVmX2lkOyAvKiB1bmlxdWUgaWQgdG8gcmVmZXJlbmNlIGRtYWJ1ZiBp biByZW1vdGUgZG9tYWluICovCiAJaW50IGh5cGVyX2RtYWJ1Zl9yZG9tYWluOyAvKiBkb21haW4g aW1wb3J0aW5nIHRoaXMgc2d0ICovCi0gICAgICAgIHN0cnVjdCBzZ190YWJsZSAqc2d0OyAvKiBw b2ludGVyIHRvIHNndCAqLworCiAJc3RydWN0IGRtYV9idWYgKmRtYV9idWY7IC8qIG5lZWRlZCB0 byBzdG9yZSB0aGlzIGZvciBmcmVlaW5nIGl0IGxhdGVyICovCi0Jc3RydWN0IGRtYV9idWZfYXR0 YWNobWVudCAqYXR0YWNobWVudDsgLyogbmVlZGVkIHRvIHN0b3JlIHRoaXMgZm9yIGZyZWVpbmcg dGhpcyBsYXRlciAqLworCXN0cnVjdCBzZ3RfbGlzdCAqYWN0aXZlX3NndHM7CisJc3RydWN0IGF0 dGFjaG1lbnRfbGlzdCAqYWN0aXZlX2F0dGFjaGVkOworCXN0cnVjdCBrbWFwX3ZhZGRyX2xpc3Qg KnZhX2ttYXBwZWQ7CisJc3RydWN0IHZtYXBfdmFkZHJfbGlzdCAqdmFfdm1hcHBlZDsKKwogCXN0 cnVjdCBoeXBlcl9kbWFidWZfc2hhcmVkX3BhZ2VzX2luZm8gc2hhcmVkX3BhZ2VzX2luZm87CiAJ aW50IHByaXZhdGVbNF07IC8qIGRldmljZSBzcGVjaWZpYyBpbmZvIChlLmcuIGltYWdlJ3MgbWV0 YSBpbmZvPykgKi8KIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVu L2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9o eXBlcl9kbWFidWZfeGVuX2NvbW0uYwppbmRleCA1ZGI1OGIwLi41NzYwODVmIDEwMDY0NAotLS0g YS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5jCisr KyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMK QEAgLTMsNiArMyw3IEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGlu dXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgorI2luY2x1ZGUgPGxpbnV4 L2RlbGF5Lmg+CiAjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+CiAjaW5jbHVkZSA8eGVuL2V2 ZW50cy5oPgogI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KQEAgLTE1LDYgKzE2LDggQEAKIAogc3Rh dGljIGludCBleHBvcnRfcmVxX2lkID0gMDsKIAorc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3Jx IHJlcV9wZW5kaW5nID0gezB9OworCiAvKiBDcmVhdGVzIGVudHJ5IGluIHhlbiBzdG9yZSB0aGF0 IHdpbGwga2VlcCBkZXRhaWxzIG9mIGFsbCBleHBvcnRlciByaW5ncyBjcmVhdGVkIGJ5IHRoaXMg ZG9tYWluICovCiBpbnQzMl90IGh5cGVyX2RtYWJ1Zl9zZXR1cF9kYXRhX2RpcigpCiB7CkBAIC0x MTQsOCArMTE3LDggQEAgaW50IGh5cGVyX2RtYWJ1Zl9uZXh0X3JlcV9pZF9leHBvcnQodm9pZCkK IH0KIAogLyogRm9yIG5vdyBjYWNoZSBsYXRhc3QgcmluZ3MgYXMgZ2xvYmFsIHZhcmlhYmxlcyBU T0RPOiBrZWVwIHRoZW0gaW4gbGlzdCovCi1zdGF0aWMgaXJxcmV0dXJuX3QgaHlwZXJfZG1hYnVm X2Zyb250X3JpbmdfaXNyKGludCBpcnEsIHZvaWQgKmRldl9pZCk7Ci1zdGF0aWMgaXJxcmV0dXJu X3QgaHlwZXJfZG1hYnVmX2JhY2tfcmluZ19pc3IoaW50IGlycSwgdm9pZCAqZGV2X2lkKTsKK3N0 YXRpYyBpcnFyZXR1cm5fdCBoeXBlcl9kbWFidWZfZnJvbnRfcmluZ19pc3IoaW50IGlycSwgdm9p ZCAqaW5mbyk7CitzdGF0aWMgaXJxcmV0dXJuX3QgaHlwZXJfZG1hYnVmX2JhY2tfcmluZ19pc3Io aW50IGlycSwgdm9pZCAqaW5mbyk7CiAKIC8qCiAgKiBDYWxsYmFjayBmdW5jdGlvbiB0aGF0IHdp bGwgYmUgY2FsbGVkIG9uIGFueSBjaGFuZ2Ugb2YgeGVuYnVzIHBhdGggYmVpbmcgd2F0Y2hlZC4K QEAgLTM3NiwxMiArMzc5LDEzIEBAIHZvaWQgaHlwZXJfZG1hYnVmX2NsZWFudXBfcmluZ2J1ZnMo dm9pZCkKIAloeXBlcl9kbWFidWZfZm9yZWFjaF9pbXBvcnRlcl9yaW5nKGh5cGVyX2RtYWJ1Zl9p bXBvcnRlcl9yaW5nYnVmX2NsZWFudXApOwogfQogCi1pbnQgaHlwZXJfZG1hYnVmX3NlbmRfcmVx dWVzdChpbnQgZG9tYWluLCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JpbmdfcnEgKnJlcSkKK2ludCBo eXBlcl9kbWFidWZfc2VuZF9yZXF1ZXN0KGludCBkb21haW4sIHN0cnVjdCBoeXBlcl9kbWFidWZf cmluZ19ycSAqcmVxLCBpbnQgd2FpdCkKIHsKIAlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2Zyb250X3Jp bmcgKnJpbmc7CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpuZXdfcmVxOwogCXN0cnVj dCBoeXBlcl9kbWFidWZfcmluZ19pbmZvX2V4cG9ydCAqcmluZ19pbmZvOwogCWludCBub3RpZnk7 CisJaW50IHRpbWVvdXQgPSAxMDAwOwogCiAJLyogZmluZCBhIHJpbmcgaW5mbyBmb3IgdGhlIGNo YW5uZWwgKi8KIAlyaW5nX2luZm8gPSBoeXBlcl9kbWFidWZfZmluZF9leHBvcnRlcl9yaW5nKGRv bWFpbik7CkBAIC00MDEsNiArNDA1LDEwIEBAIGludCBoeXBlcl9kbWFidWZfc2VuZF9yZXF1ZXN0 KGludCBkb21haW4sIHN0cnVjdCBoeXBlcl9kbWFidWZfcmluZ19ycSAqcmVxKQogCQlyZXR1cm4g LUVJTzsKIAl9CiAKKwkvKiB1cGRhdGUgcmVxX3BlbmRpbmcgd2l0aCBjdXJyZW50IHJlcXVlc3Qg Ki8KKwltZW1jcHkoJnJlcV9wZW5kaW5nLCByZXEsIHNpemVvZihyZXFfcGVuZGluZykpOworCisJ LyogcGFzcyBjdXJyZW50IHJlcXVlc3QgdG8gdGhlIHJpbmcgKi8KIAltZW1jcHkobmV3X3JlcSwg cmVxLCBzaXplb2YoKm5ld19yZXEpKTsKIAogCXJpbmctPnJlcV9wcm9kX3B2dCsrOwpAQCAtNDEw LDEwICs0MTgsMjQgQEAgaW50IGh5cGVyX2RtYWJ1Zl9zZW5kX3JlcXVlc3QoaW50IGRvbWFpbiwg c3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpyZXEpCiAJCW5vdGlmeV9yZW1vdGVfdmlhX2ly cShyaW5nX2luZm8tPmlycSk7CiAJfQogCisJaWYgKHdhaXQpIHsKKwkJd2hpbGUgKHRpbWVvdXQt LSkgeworCQkJaWYgKHJlcV9wZW5kaW5nLnN0YXR1cyAhPQorCQkJICAgIEhZUEVSX0RNQUJVRl9S RVFfTk9UX1JFU1BPTkRFRCkKKwkJCQlicmVhazsKKwkJCXVzbGVlcF9yYW5nZSgxMDAsIDEyMCk7 CisJCX0KKworCQlpZiAodGltZW91dCA8IDApIHsKKwkJCXByaW50aygicmVxdWVzdCB0aW1lZC1v dXRcbiIpOworCQkJcmV0dXJuIC1FQlVTWTsKKwkJfQorCX0KKwogCXJldHVybiAwOwogfQogCi0v KiBJU1IgZm9yIHJlcXVlc3QgZnJvbSBleHBvcnRlciAoYXMgYW4gaW1wb3J0ZXIpICovCisvKiBJ U1IgZm9yIGhhbmRsaW5nIHJlcXVlc3QgKi8KIHN0YXRpYyBpcnFyZXR1cm5fdCBoeXBlcl9kbWFi dWZfYmFja19yaW5nX2lzcihpbnQgaXJxLCB2b2lkICppbmZvKQogewogCVJJTkdfSURYIHJjLCBy cDsKQEAgLTQ0NCw2ICs0NjYsOSBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgaHlwZXJfZG1hYnVmX2Jh Y2tfcmluZ19pc3IoaW50IGlycSwgdm9pZCAqaW5mbykKIAkJCXJldCA9IGh5cGVyX2RtYWJ1Zl9t c2dfcGFyc2UocmluZ19pbmZvLT5zZG9tYWluLCAmcmVxKTsKIAogCQkJaWYgKHJldCA+IDApIHsK KwkJCQkvKiBwcmVwYXJpbmcgYSByZXNwb25zZSBmb3IgdGhlIHJlcXVlc3QgYW5kIHNlbmQgaXQg dG8KKwkJCQkgKiB0aGUgcmVxdWVzdGVyCisJCQkJICovCiAJCQkJbWVtY3B5KCZyZXNwLCAmcmVx LCBzaXplb2YocmVzcCkpOwogCQkJCW1lbWNweShSSU5HX0dFVF9SRVNQT05TRShyaW5nLCByaW5n LT5yc3BfcHJvZF9wdnQpLCAmcmVzcCwKIAkJCQkJCQlzaXplb2YocmVzcCkpOwpAQCAtNDY1LDcg KzQ5MCw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBoeXBlcl9kbWFidWZfYmFja19yaW5nX2lzcihp bnQgaXJxLCB2b2lkICppbmZvKQogCXJldHVybiBJUlFfSEFORExFRDsKIH0KIAotLyogSVNSIGZv ciByZXNwb25zZXMgZnJvbSBpbXBvcnRlciAqLworLyogSVNSIGZvciBoYW5kbGluZyByZXNwb25z ZXMgKi8KIHN0YXRpYyBpcnFyZXR1cm5fdCBoeXBlcl9kbWFidWZfZnJvbnRfcmluZ19pc3IoaW50 IGlycSwgdm9pZCAqaW5mbykKIHsKIAkvKiBmcm9udCByaW5nIG9ubHkgY2FyZSBhYm91dCByZXNw b25zZSBmcm9tIGJhY2sgKi8KQEAgLTQ4MywxMCArNTA4LDEzIEBAIHN0YXRpYyBpcnFyZXR1cm5f dCBoeXBlcl9kbWFidWZfZnJvbnRfcmluZ19pc3IoaW50IGlycSwgdm9pZCAqaW5mbykKIAkJbW9y ZV90b19kbyA9IDA7CiAJCXJwID0gcmluZy0+c3JpbmctPnJzcF9wcm9kOwogCQlmb3IgKGkgPSBy aW5nLT5yc3BfY29uczsgaSAhPSBycDsgaSsrKSB7Ci0JCQl1bnNpZ25lZCBsb25nIGlkOwotCiAJ CQlyZXNwID0gUklOR19HRVRfUkVTUE9OU0UocmluZywgaSk7Ci0JCQlpZCA9IHJlc3AtPnJlc3Bv bnNlX2lkOworCisJCQkvKiB1cGRhdGUgcGVuZGluZyByZXF1ZXN0J3Mgc3RhdHVzIHdpdGggd2hh dCBpcworCQkJICogaW4gdGhlIHJlc3BvbnNlCisJCQkgKi8KKwkJCWlmIChyZXFfcGVuZGluZy5y ZXF1ZXN0X2lkID09IHJlc3AtPnJlc3BvbnNlX2lkKQorCQkJCXJlcV9wZW5kaW5nLnN0YXR1cyA9 IHJlc3AtPnN0YXR1czsKIAogCQkJaWYgKHJlc3AtPnN0YXR1cyA9PSBIWVBFUl9ETUFCVUZfUkVR X05FRURTX0ZPTExPV19VUCkgewogCQkJCS8qIHBhcnNpbmcgcmVzcG9uc2UgKi8KQEAgLTQ5Niw2 ICs1MjQsMTQgQEAgc3RhdGljIGlycXJldHVybl90IGh5cGVyX2RtYWJ1Zl9mcm9udF9yaW5nX2lz cihpbnQgaXJxLCB2b2lkICppbmZvKQogCQkJCWlmIChyZXQgPCAwKSB7CiAJCQkJCXByaW50aygi Z2V0dGluZyBlcnJvciB3aGlsZSBwYXJzaW5nIHJlc3BvbnNlXG4iKTsKIAkJCQl9CisJCQl9IGVs c2UgaWYgKHJlc3AtPnN0YXR1cyA9PSBIWVBFUl9ETUFCVUZfUkVRX1BST0NFU1NFRCkgeworCQkJ CS8qIGZvciBkZWJ1Z2dpbmcgZG1hX2J1ZiByZW1vdGUgc3luY2hyb25pemF0aW9uICovCisJCQkJ cHJpbnRrKCJvcmlnaW5hbCByZXF1ZXN0ID0gMHgleFxuIiwgcmVzcC0+Y29tbWFuZCk7CisJCQkJ cHJpbnRrKCJKdXN0IGdvdCBIWVBFUl9ETUFCVUZfUkVRX1BST0NFU1NFRFxuIik7CisJCQl9IGVs c2UgaWYgKHJlc3AtPnN0YXR1cyA9PSBIWVBFUl9ETUFCVUZfUkVRX0VSUk9SKSB7CisJCQkJLyog Zm9yIGRlYnVnZ2luZyBkbWFfYnVmIHJlbW90ZSBzeW5jaHJvbml6YXRpb24gKi8KKwkJCQlwcmlu dGsoIm9yaWdpbmFsIHJlcXVlc3QgPSAweCV4XG4iLCByZXNwLT5jb21tYW5kKTsKKwkJCQlwcmlu dGsoIkp1c3QgZ290IEhZUEVSX0RNQUJVRl9SRVFfRVJST1JcbiIpOwogCQkJfQogCQl9CiAKZGlm ZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9j b21tLmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29t bS5oCmluZGV4IGE0ODE5Y2EuLjRhYjAzMWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmgKKysrIGIvZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uaApAQCAtNjEsNyArNjEsNyBAQCB2 b2lkIGh5cGVyX2RtYWJ1Zl9pbXBvcnRlcl9yaW5nYnVmX2NsZWFudXAoaW50IHNkb21haW4pOwog dm9pZCBoeXBlcl9kbWFidWZfY2xlYW51cF9yaW5nYnVmcyh2b2lkKTsKIAogLyogc2VuZCByZXF1 ZXN0IHRvIHRoZSByZW1vdGUgZG9tYWluICovCi1pbnQgaHlwZXJfZG1hYnVmX3NlbmRfcmVxdWVz dChpbnQgZG9tYWluLCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JpbmdfcnEgKnJlcSk7CitpbnQgaHlw ZXJfZG1hYnVmX3NlbmRfcmVxdWVzdChpbnQgZG9tYWluLCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3Jp bmdfcnEgKnJlcSwgaW50IHdhaXQpOwogCiAvKiBjYWxsZWQgYnkgaW50ZXJydXB0IChXT1JLUVVF VUUpICovCiBpbnQgaHlwZXJfZG1hYnVmX3NlbmRfcmVzcG9uc2Uoc3RydWN0IGh5cGVyX2RtYWJ1 Zl9yaW5nX3JwKiByZXNwb25zZSwgaW50IGRvbWFpbik7Ci0tIAoyLjcuNAoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlz dApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==