From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752878AbdLSTty (ORCPT ); Tue, 19 Dec 2017 14:49:54 -0500 Received: from mga01.intel.com ([192.55.52.88]:17630 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752945AbdLSTgf (ORCPT ); Tue, 19 Dec 2017 14:36:35 -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="4018523" 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 14/60] hyper_dmabuf: clean-up process based on file->f_count Date: Tue, 19 Dec 2017 11:29:30 -0800 Message-Id: <1513711816-2618-14-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 Now relaese funcs checks f_count for the file instead of our own refcount because it can't track dma_buf_get. Also, importer now sends out HYPER_DMABUF_FIRST_EXPORT to let the exporter know corresponding dma-buf has ever exported on importer's side. This is to cover the case where exporter exports a buffer and unexport it right away before importer does first export_fd (there won't be any dma_buf_release nofication to exporter since SGT was never created by importer.) After importer creates its own SGT, only condition it is completely released is that dma_buf is unexported (so valid == 0) and user app closes all locally assigned FDs (when dma_buf_release is called.) Otherwise, it needs to stay there since previously exported FD can be reused. Also includes minor changes; 1. flag had been changed to "bool valid" for conciseness. 2. added bool importer_exported in sgt_info as an indicator for usage of buffer on the importer. 3. num of pages is added (nents) to hyper_dmabuf_sgt_info to keep the size info in EXPORT list. 3. more minor changes and clean-ups. Signed-off-by: Dongwon Kim Signed-off-by: Mateusz Polrola --- drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 1 + drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 1 + drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c | 76 ++++++++++++--------- drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h | 5 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 78 ++++++++++++---------- drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c | 2 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h | 2 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 34 ++++++++-- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 2 + .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 10 ++- drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 19 +++--- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 6 +- 12 files changed, 143 insertions(+), 93 deletions(-) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c index 5b5dae44..5a7cfa5 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c @@ -33,6 +33,7 @@ static int hyper_dmabuf_drv_init(void) /* device structure initialization */ /* currently only does work-queue initialization */ hyper_dmabuf_private.work_queue = create_workqueue("hyper_dmabuf_wqueue"); + hyper_dmabuf_private.domid = hyper_dmabuf_get_domid(); ret = hyper_dmabuf_table_init(); if (ret < 0) { diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h index 8778a19..ff883e1 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h @@ -3,6 +3,7 @@ struct hyper_dmabuf_private { struct device *device; + int domid; struct workqueue_struct *work_queue; }; diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c index f258981..fa445e5 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c @@ -13,6 +13,14 @@ #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t)) +int dmabuf_refcount(struct dma_buf *dma_buf) +{ + if ((dma_buf != NULL) && (dma_buf->file != NULL)) + return file_count(dma_buf->file); + + return -1; +} + /* return total number of pages referecned by a sgt * for pre-calculation of # of pages behind a given sgt */ @@ -368,8 +376,8 @@ int hyper_dmabuf_cleanup_gref_table(struct hyper_dmabuf_sgt_info *sgt_info) { struct hyper_dmabuf_shared_pages_info *shared_pages_info = &sgt_info->shared_pages_info; grant_ref_t *ref = shared_pages_info->top_level_page; - 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)); + int n_2nd_level_pages = (sgt_info->nents/REFS_PER_PAGE + + ((sgt_info->nents % REFS_PER_PAGE) ? 1: 0)); if (shared_pages_info->data_refs == NULL || @@ -388,26 +396,28 @@ int hyper_dmabuf_cleanup_gref_table(struct hyper_dmabuf_sgt_info *sgt_info) { if (!gnttab_end_foreign_access_ref(ref[i], 1)) { printk("refid still in use!!!\n"); } + gnttab_free_grant_reference(ref[i]); i++; } free_pages((unsigned long)shared_pages_info->addr_pages, i); + /* End foreign access for top level addressing page */ if (gnttab_query_foreign_access(shared_pages_info->top_level_ref)) { printk("refid not shared !!\n"); } - if (!gnttab_end_foreign_access_ref(shared_pages_info->top_level_ref, 1)) { - printk("refid still in use!!!\n"); - } gnttab_end_foreign_access_ref(shared_pages_info->top_level_ref, 1); + gnttab_free_grant_reference(shared_pages_info->top_level_ref); + 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->active_sgts->sgt->nents; i++) { + for (i = 0; i < sgt_info->nents; i++) { if (gnttab_query_foreign_access(shared_pages_info->data_refs[i])) { printk("refid not shared !!\n"); } gnttab_end_foreign_access_ref(shared_pages_info->data_refs[i], 0); + gnttab_free_grant_reference(shared_pages_info->data_refs[i]); } kfree(shared_pages_info->data_refs); @@ -545,6 +555,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo return -EPERM; } + /* force == 1 is not recommended */ while (!list_empty(&sgt_info->va_kmapped->list)) { va_kmapl = list_first_entry(&sgt_info->va_kmapped->list, struct kmap_vaddr_list, list); @@ -598,6 +609,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo /* close connection to dma-buf completely */ dma_buf_put(sgt_info->dma_buf); + sgt_info->dma_buf = NULL; kfree(sgt_info->active_sgts); kfree(sgt_info->active_attached); @@ -621,7 +633,7 @@ 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 and wait for a response */ - ret = hyper_dmabuf_send_request(HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(id), req, true); + ret = hyper_dmabuf_send_request(HYPER_DMABUF_DOM_ID(id), req, true); kfree(req); @@ -737,30 +749,33 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment, } } -static void hyper_dmabuf_ops_release(struct dma_buf *dmabuf) +static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf) { struct hyper_dmabuf_imported_sgt_info *sgt_info; int ret; + int final_release; - if (!dmabuf->priv) + if (!dma_buf->priv) return; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dma_buf->priv; - if (sgt_info) { - /* dmabuf fd is being released - decrease refcount */ - sgt_info->ref_count--; + final_release = sgt_info && !sgt_info->valid && + !dmabuf_refcount(sgt_info->dma_buf); - /* if no one else in that domain is using that buffer, unmap it for now */ - if (sgt_info->ref_count == 0) { - hyper_dmabuf_cleanup_imported_pages(sgt_info); - hyper_dmabuf_free_sgt(sgt_info->sgt); - sgt_info->sgt = NULL; - } + if (!dmabuf_refcount(sgt_info->dma_buf)) { + sgt_info->dma_buf = NULL; } - ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, - HYPER_DMABUF_OPS_RELEASE); + if (final_release) { + hyper_dmabuf_cleanup_imported_pages(sgt_info); + hyper_dmabuf_free_sgt(sgt_info->sgt); + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, + HYPER_DMABUF_OPS_RELEASE_FINAL); + } else { + ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, + HYPER_DMABUF_OPS_RELEASE); + } if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); @@ -770,8 +785,7 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dmabuf) * Check if buffer is still valid and if not remove it from imported list. * That has to be done after sending sync request */ - if (sgt_info && sgt_info->ref_count == 0 && - sgt_info->flags == HYPER_DMABUF_SGT_INVALID) { + if (final_release) { hyper_dmabuf_remove_imported(sgt_info->hyper_dmabuf_id); kfree(sgt_info); } @@ -962,23 +976,21 @@ static const struct dma_buf_ops hyper_dmabuf_ops = { /* exporting dmabuf as fd */ int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags) { - int fd; - struct dma_buf* dmabuf; + int fd = -1; /* call hyper_dmabuf_export_dmabuf and create * and bind a handle for it then release */ - dmabuf = hyper_dmabuf_export_dma_buf(dinfo); - - fd = dma_buf_fd(dmabuf, flags); + hyper_dmabuf_export_dma_buf(dinfo); - /* dmabuf fd is exported for given bufer - increase its ref count */ - dinfo->ref_count++; + if (dinfo->dma_buf) { + fd = dma_buf_fd(dinfo->dma_buf, flags); + } return fd; } -struct dma_buf* hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo) +void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo) { DEFINE_DMA_BUF_EXPORT_INFO(exp_info); @@ -989,5 +1001,5 @@ struct dma_buf* hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_inf exp_info.flags = /* not sure about flag */0; exp_info.priv = dinfo; - return dma_buf_export(&exp_info); + dinfo->dma_buf = dma_buf_export(&exp_info); } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h index 71c1bb0..1b0801f 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h @@ -1,6 +1,7 @@ #ifndef __HYPER_DMABUF_IMP_H__ #define __HYPER_DMABUF_IMP_H__ +#include #include "hyper_dmabuf_struct.h" /* extract pages directly from struct sg_table */ @@ -30,6 +31,8 @@ void hyper_dmabuf_free_sgt(struct sg_table *sgt); int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags); -struct dma_buf* hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo); +void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo); + +int dmabuf_refcount(struct dma_buf *dma_buf); #endif /* __HYPER_DMABUF_IMP_H__ */ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index c57acafe..e334b77 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -107,10 +107,12 @@ static int hyper_dmabuf_export_remote(void *data) } /* we check if this specific attachment was already exported - * to the same domain and if yes, it returns hyper_dmabuf_id - * of pre-exported sgt */ - ret = hyper_dmabuf_find_id(dma_buf, export_remote_attr->remote_domain); - if (ret != -1) { + * to the same domain and if yes and it's valid sgt_info, + * it returns hyper_dmabuf_id of pre-exported sgt_info + */ + ret = hyper_dmabuf_find_id_exported(dma_buf, export_remote_attr->remote_domain); + sgt_info = hyper_dmabuf_find_exported(ret); + if (ret != -1 && sgt_info->valid) { dma_buf_put(dma_buf); export_remote_attr->hyper_dmabuf_id = ret; return 0; @@ -135,12 +137,13 @@ static int hyper_dmabuf_export_remote(void *data) /* TODO: We might need to consider using port number on event channel? */ sgt_info->hyper_dmabuf_rdomain = export_remote_attr->remote_domain; sgt_info->dma_buf = dma_buf; - sgt_info->flags = 0; + sgt_info->valid = 1; + sgt_info->importer_exported = 0; - 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 = kmalloc(sizeof(struct sgt_list), GFP_KERNEL); + sgt_info->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL); + sgt_info->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL); + sgt_info->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL); sgt_info->active_sgts->sgt = sgt; sgt_info->active_attached->attach = attachment; @@ -159,6 +162,8 @@ static int hyper_dmabuf_export_remote(void *data) if (page_info == NULL) goto fail_export; + sgt_info->nents = page_info->nents; + /* now register it to export list */ hyper_dmabuf_register_exported(sgt_info); @@ -220,6 +225,8 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) { struct ioctl_hyper_dmabuf_export_fd *export_fd_attr; struct hyper_dmabuf_imported_sgt_info *imported_sgt_info; + struct hyper_dmabuf_ring_rq *req; + int operand; int ret = 0; if (!data) { @@ -234,35 +241,38 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) if (imported_sgt_info == NULL) /* can't find sgt from the table */ return -1; - /* - * Check if buffer was not unexported by exporter. - * In such exporter is waiting for importer to finish using that buffer, - * so do not allow export fd of such buffer anymore. - */ - if (imported_sgt_info->flags == HYPER_DMABUF_SGT_INVALID) { - return -EINVAL; - } - printk("%s Found buffer gref %d off %d last len %d nents %d domain %d\n", __func__, imported_sgt_info->gref, imported_sgt_info->frst_ofst, imported_sgt_info->last_len, imported_sgt_info->nents, - HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(imported_sgt_info->hyper_dmabuf_id)); + HYPER_DMABUF_DOM_ID(imported_sgt_info->hyper_dmabuf_id)); if (!imported_sgt_info->sgt) { imported_sgt_info->sgt = hyper_dmabuf_map_pages(imported_sgt_info->gref, imported_sgt_info->frst_ofst, imported_sgt_info->last_len, imported_sgt_info->nents, - HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(imported_sgt_info->hyper_dmabuf_id), + HYPER_DMABUF_DOM_ID(imported_sgt_info->hyper_dmabuf_id), &imported_sgt_info->shared_pages_info); - if (!imported_sgt_info->sgt) { - printk("Failed to create sgt\n"); + + /* send notifiticatio for first export_fd to exporter */ + operand = imported_sgt_info->hyper_dmabuf_id; + req = kcalloc(1, sizeof(*req), GFP_KERNEL); + hyper_dmabuf_create_request(req, HYPER_DMABUF_FIRST_EXPORT, &operand); + + ret = hyper_dmabuf_send_request(HYPER_DMABUF_DOM_ID(operand), req, false); + + if (!imported_sgt_info->sgt || ret) { + kfree(req); + printk("Failed to create sgt or notify exporter\n"); return -EINVAL; } + kfree(req); } export_fd_attr->fd = hyper_dmabuf_export_fd(imported_sgt_info, export_fd_attr->flags); - if (export_fd_attr < 0) { + + if (export_fd_attr->fd < 0) { + /* fail to get fd */ ret = export_fd_attr->fd; } @@ -309,23 +319,23 @@ static int hyper_dmabuf_unexport(void *data) /* free msg */ kfree(req); + /* no longer valid */ + sgt_info->valid = 0; + /* - * Check if any importer is still using buffer, if not clean it up completly, - * otherwise mark buffer as unexported and postpone its cleanup to time when - * importer will finish using it. + * Immediately clean-up if it has never been exported by importer + * (so no SGT is constructed on importer). + * clean it up later in remote sync when final release ops + * is called (importer does this only when there's no + * no consumer of locally exported FDs) */ - if (list_empty(&sgt_info->active_sgts->list) && - list_empty(&sgt_info->active_attached->list)) { + printk("before claning up buffer completly\n"); + if (!sgt_info->importer_exported) { hyper_dmabuf_cleanup_sgt_info(sgt_info, false); hyper_dmabuf_remove_exported(unexport_attr->hyper_dmabuf_id); kfree(sgt_info); - } else { - sgt_info->flags = HYPER_DMABUF_SGT_UNEXPORTED; } - /* TODO: should we mark here that buffer was destroyed immiedetaly or that was postponed ? */ - unexport_attr->status = ret; - return ret; } @@ -369,7 +379,7 @@ static int hyper_dmabuf_query(void *data) if (sgt_info) { query_attr->info = 0xFFFFFFFF; /* myself */ } else { - query_attr->info = (HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(imported_sgt_info->hyper_dmabuf_id)); + query_attr->info = (HYPER_DMABUF_DOM_ID(imported_sgt_info->hyper_dmabuf_id)); } break; diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c index 1420df9..18731de 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c @@ -65,7 +65,7 @@ struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(int id) } /* search for pre-exported sgt and return id of it if it exist */ -int hyper_dmabuf_find_id(struct dma_buf *dmabuf, int domid) +int hyper_dmabuf_find_id_exported(struct dma_buf *dmabuf, int domid) { struct hyper_dmabuf_info_entry_exported *info_entry; int bkt; diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h index 463a6da..f55d06e 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h @@ -25,7 +25,7 @@ int hyper_dmabuf_table_destroy(void); int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info); /* search for pre-exported sgt and return id of it if it exist */ -int hyper_dmabuf_find_id(struct dma_buf *dmabuf, int domid); +int hyper_dmabuf_find_id_exported(struct dma_buf *dmabuf, int domid); int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c index 97b42a4..a2d687f 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c @@ -55,6 +55,14 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request, request->operands[0] = operands[0]; break; + case HYPER_DMABUF_FIRST_EXPORT: + /* dmabuf fd is being created on imported side for first time */ + /* command : HYPER_DMABUF_FIRST_EXPORT, + * operands0 : hyper_dmabuf_id + */ + request->operands[0] = operands[0]; + break; + case HYPER_DMABUF_OPS_TO_REMOTE: /* notifying dmabuf map/unmap to importer (probably not needed) */ /* for dmabuf synchronization */ @@ -81,6 +89,7 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request, void cmd_process_work(struct work_struct *work) { struct hyper_dmabuf_imported_sgt_info *imported_sgt_info; + struct hyper_dmabuf_sgt_info *sgt_info; struct cmd_process *proc = container_of(work, struct cmd_process, work); struct hyper_dmabuf_ring_rq *req; int domid; @@ -117,11 +126,25 @@ void cmd_process_work(struct work_struct *work) for (i=0; i<4; i++) imported_sgt_info->private[i] = req->operands[5+i]; - imported_sgt_info->flags = 0; - imported_sgt_info->ref_count = 0; + imported_sgt_info->valid = 1; hyper_dmabuf_register_imported(imported_sgt_info); break; + case HYPER_DMABUF_FIRST_EXPORT: + /* find a corresponding SGT for the id */ + sgt_info = hyper_dmabuf_find_exported(req->operands[0]); + + if (!sgt_info) { + printk("critical err: requested sgt_info can't be found %d\n", req->operands[0]); + break; + } + + if (sgt_info->importer_exported) + printk("warning: exported flag is not supposed to be 1 already\n"); + + sgt_info->importer_exported = 1; + break; + case HYPER_DMABUF_OPS_TO_REMOTE: /* notifying dmabuf map/unmap to importer (probably not needed) */ /* for dmabuf synchronization */ @@ -170,13 +193,14 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req) hyper_dmabuf_find_imported(req->operands[0]); if (imported_sgt_info) { - /* check if buffer is still mapped and in use */ - if (imported_sgt_info->sgt) { + /* if anything is still using dma_buf */ + if (imported_sgt_info->dma_buf && + dmabuf_refcount(imported_sgt_info->dma_buf) > 0) { /* * Buffer is still in use, just mark that it should * not be allowed to export its fd anymore. */ - imported_sgt_info->flags = HYPER_DMABUF_SGT_INVALID; + imported_sgt_info->valid = 0; } else { /* No one is using buffer, remove it from imported list */ hyper_dmabuf_remove_imported(req->operands[0]); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h index fc1365b..1e9d827 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h @@ -3,6 +3,7 @@ enum hyper_dmabuf_command { HYPER_DMABUF_EXPORT = 0x10, + HYPER_DMABUF_FIRST_EXPORT, HYPER_DMABUF_NOTIFY_UNEXPORT, HYPER_DMABUF_OPS_TO_REMOTE, HYPER_DMABUF_OPS_TO_SOURCE, @@ -14,6 +15,7 @@ enum hyper_dmabuf_ops { HYPER_DMABUF_OPS_MAP, HYPER_DMABUF_OPS_UNMAP, HYPER_DMABUF_OPS_RELEASE, + HYPER_DMABUF_OPS_RELEASE_FINAL, HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS, HYPER_DMABUF_OPS_END_CPU_ACCESS, HYPER_DMABUF_OPS_KMAP_ATOMIC, diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c index 61ba4ed..5017b17 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c @@ -114,13 +114,13 @@ int hyper_dmabuf_remote_sync(int id, int ops) kfree(sgtl); break; - case HYPER_DMABUF_OPS_RELEASE: + case HYPER_DMABUF_OPS_RELEASE_FINAL: /* * Importer just released buffer fd, check if there is any other importer still using it. * If not and buffer was unexported, clean up shared data and remove that buffer. */ - if (list_empty(&sgt_info->active_sgts->list) && list_empty(&sgt_info->active_attached->list) && - sgt_info->flags == HYPER_DMABUF_SGT_UNEXPORTED) { + if (list_empty(&sgt_info->active_attached->list) && + !sgt_info->valid) { hyper_dmabuf_cleanup_sgt_info(sgt_info, false); hyper_dmabuf_remove_exported(id); kfree(sgt_info); @@ -128,6 +128,10 @@ int hyper_dmabuf_remote_sync(int id, int ops) break; + case HYPER_DMABUF_OPS_RELEASE: + /* place holder */ + break; + case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS: ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL); if (!ret) { diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h index 1194cf2..92e06ff 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h @@ -6,10 +6,10 @@ /* Importer combine source domain id with given hyper_dmabuf_id * to make it unique in case there are multiple exporters */ -#define HYPER_DMABUF_ID_IMPORTER(sdomain, id) \ - ((((sdomain) & 0xFF) << 24) | ((id) & 0xFFFFFF)) +#define HYPER_DMABUF_ID_IMPORTER(domid, id) \ + ((((domid) & 0xFF) << 24) | ((id) & 0xFFFFFF)) -#define HYPER_DMABUF_ID_IMPORTER_GET_SDOMAIN_ID(id) \ +#define HYPER_DMABUF_DOM_ID(id) \ (((id) >> 24) & 0xFF) /* each grant_ref_t is 4 bytes, so total 4096 grant_ref_t can be @@ -18,11 +18,6 @@ * frame buffer) */ #define MAX_ALLOWED_NUM_PAGES_FOR_GREF_NUM_ARRAYS 4 -enum hyper_dmabuf_sgt_flags { - HYPER_DMABUF_SGT_INVALID = 0x10, - HYPER_DMABUF_SGT_UNEXPORTED, -}; - /* stack of mapped sgts */ struct sgt_list { struct sg_table *sgt; @@ -77,11 +72,13 @@ struct hyper_dmabuf_sgt_info { int hyper_dmabuf_rdomain; /* domain importing this sgt */ struct dma_buf *dma_buf; /* needed to store this for freeing it later */ + int nents; /* number of pages, which may be different than sgt->nents */ struct sgt_list *active_sgts; struct attachment_list *active_attached; struct kmap_vaddr_list *va_kmapped; struct vmap_vaddr_list *va_vmapped; - int flags; + bool valid; + bool importer_exported; /* exported locally on importer's side */ struct hyper_dmabuf_shared_pages_info shared_pages_info; int private[4]; /* device specific info (e.g. image's meta info?) */ }; @@ -95,10 +92,10 @@ struct hyper_dmabuf_imported_sgt_info { int last_len; /* length of data in the last shared page */ int nents; /* number of pages to be shared */ grant_ref_t gref; /* reference number of top level addressing page of shared pages */ + struct dma_buf *dma_buf; struct sg_table *sgt; /* sgt pointer after importing buffer */ struct hyper_dmabuf_shared_pages_info shared_pages_info; - int flags; - int ref_count; + bool valid; 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 116850e..f9e0df3 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c @@ -456,13 +456,12 @@ static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info) do { rc = ring->req_cons; rp = ring->sring->req_prod; - + more_to_do = 0; while (rc != rp) { if (RING_REQUEST_CONS_OVERFLOW(ring, rc)) break; memcpy(&req, RING_GET_REQUEST(ring, rc), sizeof(req)); - printk("Got request\n"); ring->req_cons = ++rc; ret = hyper_dmabuf_msg_parse(ring_info->sdomain, &req); @@ -479,13 +478,11 @@ static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info) RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify); if (notify) { - printk("Notyfing\n"); notify_remote_via_irq(ring_info->irq); } } RING_FINAL_CHECK_FOR_REQUESTS(ring, more_to_do); - printk("Final check for requests %d\n", more_to_do); } } while (more_to_do); @@ -541,7 +538,6 @@ static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info) if (i != ring->req_prod_pvt) { RING_FINAL_CHECK_FOR_RESPONSES(ring, more_to_do); - printk("more to do %d\n", more_to_do); } else { ring->sring->rsp_event = i+1; } -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 14/60] hyper_dmabuf: clean-up process based on file->f_count Date: Tue, 19 Dec 2017 11:29:30 -0800 Message-ID: <1513711816-2618-14-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 8E0706E345 for ; Tue, 19 Dec 2017 19:36:35 +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 Tm93IHJlbGFlc2UgZnVuY3MgY2hlY2tzIGZfY291bnQgZm9yIHRoZSBmaWxlIGluc3RlYWQgb2YK b3VyIG93biByZWZjb3VudCBiZWNhdXNlIGl0IGNhbid0IHRyYWNrIGRtYV9idWZfZ2V0LgoKQWxz bywgaW1wb3J0ZXIgbm93IHNlbmRzIG91dCBIWVBFUl9ETUFCVUZfRklSU1RfRVhQT1JUCnRvIGxl dCB0aGUgZXhwb3J0ZXIga25vdyBjb3JyZXNwb25kaW5nIGRtYS1idWYgaGFzIGV2ZXIKZXhwb3J0 ZWQgb24gaW1wb3J0ZXIncyBzaWRlLiBUaGlzIGlzIHRvIGNvdmVyIHRoZSBjYXNlCndoZXJlIGV4 cG9ydGVyIGV4cG9ydHMgYSBidWZmZXIgYW5kIHVuZXhwb3J0IGl0IHJpZ2h0CmF3YXkgYmVmb3Jl IGltcG9ydGVyIGRvZXMgZmlyc3QgZXhwb3J0X2ZkICh0aGVyZSB3b24ndApiZSBhbnkgZG1hX2J1 Zl9yZWxlYXNlIG5vZmljYXRpb24gdG8gZXhwb3J0ZXIgc2luY2UgU0dUCndhcyBuZXZlciBjcmVh dGVkIGJ5IGltcG9ydGVyLikKCkFmdGVyIGltcG9ydGVyIGNyZWF0ZXMgaXRzIG93biBTR1QsIG9u bHkgY29uZGl0aW9uIGl0IGlzCmNvbXBsZXRlbHkgcmVsZWFzZWQgaXMgdGhhdCBkbWFfYnVmIGlz IHVuZXhwb3J0ZWQKKHNvIHZhbGlkID09IDApIGFuZCB1c2VyIGFwcCBjbG9zZXMgYWxsIGxvY2Fs bHkKYXNzaWduZWQgRkRzICh3aGVuIGRtYV9idWZfcmVsZWFzZSBpcyBjYWxsZWQuKQpPdGhlcndp c2UsIGl0IG5lZWRzIHRvIHN0YXkgdGhlcmUgc2luY2UgcHJldmlvdXNseSBleHBvcnRlZApGRCBj YW4gYmUgcmV1c2VkLgoKQWxzbyBpbmNsdWRlcyBtaW5vciBjaGFuZ2VzOwoKMS4gZmxhZyBoYWQg YmVlbiBjaGFuZ2VkIHRvICJib29sIHZhbGlkIiBmb3IgY29uY2lzZW5lc3MuCjIuIGFkZGVkIGJv b2wgaW1wb3J0ZXJfZXhwb3J0ZWQgaW4gc2d0X2luZm8gYXMgYW4gaW5kaWNhdG9yCiAgIGZvciB1 c2FnZSBvZiBidWZmZXIgb24gdGhlIGltcG9ydGVyLgozLiBudW0gb2YgcGFnZXMgaXMgYWRkZWQg KG5lbnRzKSB0byBoeXBlcl9kbWFidWZfc2d0X2luZm8KICAgdG8ga2VlcCB0aGUgc2l6ZSBpbmZv IGluIEVYUE9SVCBsaXN0LgozLiBtb3JlIG1pbm9yIGNoYW5nZXMgYW5kIGNsZWFuLXVwcy4KClNp Z25lZC1vZmYtYnk6IERvbmd3b24gS2ltIDxkb25nd29uLmtpbUBpbnRlbC5jb20+ClNpZ25lZC1v ZmYtYnk6IE1hdGV1c3ogUG9scm9sYSA8bWF0ZXVzengucG90cm9sYUBpbnRlbC5jb20+Ci0tLQog ZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuYyAgICAgICAgfCAgMSAr CiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5oICAgICAgICB8ICAx ICsKIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMgICAgICAgIHwg NzYgKysrKysrKysrKysrLS0tLS0tLS0tCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX2ltcC5oICAgICAgICB8ICA1ICstCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlw ZXJfZG1hYnVmX2lvY3RsLmMgICAgICB8IDc4ICsrKysrKysrKysrKy0tLS0tLS0tLS0KIGRyaXZl cnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5jICAgICAgIHwgIDIgKy0KIGRy aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5oICAgICAgIHwgIDIgKy0K IGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMgICAgICAgIHwgMzQg KysrKysrKystLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaCAg ICAgICAgfCAgMiArCiAuLi4veGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcmVtb3RlX3N5 bmMuYyAgICB8IDEwICsrLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9z dHJ1Y3QuaCAgICAgfCAxOSArKystLS0KIC4uLi94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9k bWFidWZfeGVuX2NvbW0uYyAgIHwgIDYgKy0KIDEyIGZpbGVzIGNoYW5nZWQsIDE0MyBpbnNlcnRp b25zKCspLCA5MyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9k bWFidWYvaHlwZXJfZG1hYnVmX2Rydi5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9kcnYuYwppbmRleCA1YjVkYWU0NC4uNWE3Y2ZhNSAxMDA2NDQKLS0tIGEvZHJpdmVy cy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuYworKysgYi9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5jCkBAIC0zMyw2ICszMyw3IEBAIHN0YXRpYyBp bnQgaHlwZXJfZG1hYnVmX2Rydl9pbml0KHZvaWQpCiAJLyogZGV2aWNlIHN0cnVjdHVyZSBpbml0 aWFsaXphdGlvbiAqLwogCS8qIGN1cnJlbnRseSBvbmx5IGRvZXMgd29yay1xdWV1ZSBpbml0aWFs aXphdGlvbiAqLwogCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLndvcmtfcXVldWUgPSBjcmVhdGVfd29y a3F1ZXVlKCJoeXBlcl9kbWFidWZfd3F1ZXVlIik7CisJaHlwZXJfZG1hYnVmX3ByaXZhdGUuZG9t aWQgPSBoeXBlcl9kbWFidWZfZ2V0X2RvbWlkKCk7CiAKIAlyZXQgPSBoeXBlcl9kbWFidWZfdGFi bGVfaW5pdCgpOwogCWlmIChyZXQgPCAwKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5oIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5 cGVyX2RtYWJ1Zl9kcnYuaAppbmRleCA4Nzc4YTE5Li5mZjg4M2UxIDEwMDY0NAotLS0gYS9kcml2 ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5oCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmgKQEAgLTMsNiArMyw3IEBACiAKIHN0cnVj dCBoeXBlcl9kbWFidWZfcHJpdmF0ZSB7CiAgICAgICAgIHN0cnVjdCBkZXZpY2UgKmRldmljZTsK KwlpbnQgZG9taWQ7CiAJc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKndvcmtfcXVldWU7CiB9Owog CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2ltcC5j IGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pbXAuYwppbmRleCBmMjU4 OTgxLi5mYTQ0NWU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX2ltcC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZf aW1wLmMKQEAgLTEzLDYgKzEzLDE0IEBACiAKICNkZWZpbmUgUkVGU19QRVJfUEFHRSAoUEFHRV9T SVpFL3NpemVvZihncmFudF9yZWZfdCkpCiAKK2ludCBkbWFidWZfcmVmY291bnQoc3RydWN0IGRt YV9idWYgKmRtYV9idWYpCit7CisJaWYgKChkbWFfYnVmICE9IE5VTEwpICYmIChkbWFfYnVmLT5m aWxlICE9IE5VTEwpKQorCQlyZXR1cm4gZmlsZV9jb3VudChkbWFfYnVmLT5maWxlKTsKKworCXJl dHVybiAtMTsKK30KKwogLyogcmV0dXJuIHRvdGFsIG51bWJlciBvZiBwYWdlcyByZWZlcmVjbmVk IGJ5IGEgc2d0CiAgKiBmb3IgcHJlLWNhbGN1bGF0aW9uIG9mICMgb2YgcGFnZXMgYmVoaW5kIGEg Z2l2ZW4gc2d0CiAgKi8KQEAgLTM2OCw4ICszNzYsOCBAQCBpbnQgaHlwZXJfZG1hYnVmX2NsZWFu dXBfZ3JlZl90YWJsZShzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvICpzZ3RfaW5mbykgewog CXN0cnVjdCBoeXBlcl9kbWFidWZfc2hhcmVkX3BhZ2VzX2luZm8gKnNoYXJlZF9wYWdlc19pbmZv ID0gJnNndF9pbmZvLT5zaGFyZWRfcGFnZXNfaW5mbzsKIAogCWdyYW50X3JlZl90ICpyZWYgPSBz aGFyZWRfcGFnZXNfaW5mby0+dG9wX2xldmVsX3BhZ2U7Ci0JaW50IG5fMm5kX2xldmVsX3BhZ2Vz ID0gKHNndF9pbmZvLT5hY3RpdmVfc2d0cy0+c2d0LT5uZW50cy9SRUZTX1BFUl9QQUdFICsKLQkJ CQkoKHNndF9pbmZvLT5hY3RpdmVfc2d0cy0+c2d0LT5uZW50cyAlIFJFRlNfUEVSX1BBR0UpID8g MTogMCkpOworCWludCBuXzJuZF9sZXZlbF9wYWdlcyA9IChzZ3RfaW5mby0+bmVudHMvUkVGU19Q RVJfUEFHRSArCisJCQkJKChzZ3RfaW5mby0+bmVudHMgJSBSRUZTX1BFUl9QQUdFKSA/IDE6IDAp KTsKIAogCiAJaWYgKHNoYXJlZF9wYWdlc19pbmZvLT5kYXRhX3JlZnMgPT0gTlVMTCB8fApAQCAt Mzg4LDI2ICszOTYsMjggQEAgaW50IGh5cGVyX2RtYWJ1Zl9jbGVhbnVwX2dyZWZfdGFibGUoc3Ry dWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm8pIHsKIAkJaWYgKCFnbnR0YWJfZW5k X2ZvcmVpZ25fYWNjZXNzX3JlZihyZWZbaV0sIDEpKSB7CiAJCQlwcmludGsoInJlZmlkIHN0aWxs IGluIHVzZSEhIVxuIik7CiAJCX0KKwkJZ250dGFiX2ZyZWVfZ3JhbnRfcmVmZXJlbmNlKHJlZltp XSk7CiAJCWkrKzsKIAl9CiAJZnJlZV9wYWdlcygodW5zaWduZWQgbG9uZylzaGFyZWRfcGFnZXNf aW5mby0+YWRkcl9wYWdlcywgaSk7CiAKKwogCS8qIEVuZCBmb3JlaWduIGFjY2VzcyBmb3IgdG9w IGxldmVsIGFkZHJlc3NpbmcgcGFnZSAqLwogCWlmIChnbnR0YWJfcXVlcnlfZm9yZWlnbl9hY2Nl c3Moc2hhcmVkX3BhZ2VzX2luZm8tPnRvcF9sZXZlbF9yZWYpKSB7CiAJCXByaW50aygicmVmaWQg bm90IHNoYXJlZCAhIVxuIik7CiAJfQotCWlmICghZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19y ZWYoc2hhcmVkX3BhZ2VzX2luZm8tPnRvcF9sZXZlbF9yZWYsIDEpKSB7Ci0JCXByaW50aygicmVm aWQgc3RpbGwgaW4gdXNlISEhXG4iKTsKLQl9CiAJZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19y ZWYoc2hhcmVkX3BhZ2VzX2luZm8tPnRvcF9sZXZlbF9yZWYsIDEpOworCWdudHRhYl9mcmVlX2dy YW50X3JlZmVyZW5jZShzaGFyZWRfcGFnZXNfaW5mby0+dG9wX2xldmVsX3JlZik7CisKIAlmcmVl X3BhZ2VzKCh1bnNpZ25lZCBsb25nKXNoYXJlZF9wYWdlc19pbmZvLT50b3BfbGV2ZWxfcGFnZSwg MSk7CiAKIAkvKiBFbmQgZm9yZWlnbiBhY2Nlc3MgZm9yIGRhdGEgcGFnZXMsIGJ1dCBkbyBub3Qg ZnJlZSB0aGVtICovCi0JZm9yIChpID0gMDsgaSA8IHNndF9pbmZvLT5hY3RpdmVfc2d0cy0+c2d0 LT5uZW50czsgaSsrKSB7CisJZm9yIChpID0gMDsgaSA8IHNndF9pbmZvLT5uZW50czsgaSsrKSB7 CiAJCWlmIChnbnR0YWJfcXVlcnlfZm9yZWlnbl9hY2Nlc3Moc2hhcmVkX3BhZ2VzX2luZm8tPmRh dGFfcmVmc1tpXSkpIHsKIAkJCXByaW50aygicmVmaWQgbm90IHNoYXJlZCAhIVxuIik7CiAJCX0K IAkJZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19yZWYoc2hhcmVkX3BhZ2VzX2luZm8tPmRhdGFf cmVmc1tpXSwgMCk7CisJCWdudHRhYl9mcmVlX2dyYW50X3JlZmVyZW5jZShzaGFyZWRfcGFnZXNf aW5mby0+ZGF0YV9yZWZzW2ldKTsKIAl9CiAKIAlrZnJlZShzaGFyZWRfcGFnZXNfaW5mby0+ZGF0 YV9yZWZzKTsKQEAgLTU0NSw2ICs1NTUsNyBAQCBpbnQgaHlwZXJfZG1hYnVmX2NsZWFudXBfc2d0 X2luZm8oc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm8sIGludCBmbwogCQly ZXR1cm4gLUVQRVJNOwogCX0KIAorCS8qIGZvcmNlID09IDEgaXMgbm90IHJlY29tbWVuZGVkICov CiAJd2hpbGUgKCFsaXN0X2VtcHR5KCZzZ3RfaW5mby0+dmFfa21hcHBlZC0+bGlzdCkpIHsKIAkJ dmFfa21hcGwgPSBsaXN0X2ZpcnN0X2VudHJ5KCZzZ3RfaW5mby0+dmFfa21hcHBlZC0+bGlzdCwK IAkJCQkJICAgIHN0cnVjdCBrbWFwX3ZhZGRyX2xpc3QsIGxpc3QpOwpAQCAtNTk4LDYgKzYwOSw3 IEBAIGludCBoeXBlcl9kbWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzdHJ1Y3QgaHlwZXJfZG1hYnVm X3NndF9pbmZvICpzZ3RfaW5mbywgaW50IGZvCiAKIAkvKiBjbG9zZSBjb25uZWN0aW9uIHRvIGRt YS1idWYgY29tcGxldGVseSAqLwogCWRtYV9idWZfcHV0KHNndF9pbmZvLT5kbWFfYnVmKTsKKwlz Z3RfaW5mby0+ZG1hX2J1ZiA9IE5VTEw7CiAKIAlrZnJlZShzZ3RfaW5mby0+YWN0aXZlX3NndHMp OwogCWtmcmVlKHNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQpOwpAQCAtNjIxLDcgKzYzMyw3IEBA IGlubGluZSBpbnQgaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9hbmRfd2FpdChpbnQgaWQsIGlu dCBvcHMpCiAJaHlwZXJfZG1hYnVmX2NyZWF0ZV9yZXF1ZXN0KHJlcSwgSFlQRVJfRE1BQlVGX09Q U19UT19TT1VSQ0UsICZvcGVyYW5kc1swXSk7CiAKIAkvKiBzZW5kIHJlcXVlc3QgYW5kIHdhaXQg Zm9yIGEgcmVzcG9uc2UgKi8KLQlyZXQgPSBoeXBlcl9kbWFidWZfc2VuZF9yZXF1ZXN0KEhZUEVS X0RNQUJVRl9JRF9JTVBPUlRFUl9HRVRfU0RPTUFJTl9JRChpZCksIHJlcSwgdHJ1ZSk7CisJcmV0 ID0gaHlwZXJfZG1hYnVmX3NlbmRfcmVxdWVzdChIWVBFUl9ETUFCVUZfRE9NX0lEKGlkKSwgcmVx LCB0cnVlKTsKIAogCWtmcmVlKHJlcSk7CiAKQEAgLTczNywzMCArNzQ5LDMzIEBAIHN0YXRpYyB2 b2lkIGh5cGVyX2RtYWJ1Zl9vcHNfdW5tYXAoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0 YWNobWVudCwKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9vcHNfcmVsZWFzZShz dHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKQorc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX29wc19yZWxl YXNlKHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmKQogewogCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1w b3J0ZWRfc2d0X2luZm8gKnNndF9pbmZvOwogCWludCByZXQ7CisJaW50IGZpbmFsX3JlbGVhc2U7 CiAKLQlpZiAoIWRtYWJ1Zi0+cHJpdikKKwlpZiAoIWRtYV9idWYtPnByaXYpCiAJCXJldHVybjsK IAotCXNndF9pbmZvID0gKHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKilk bWFidWYtPnByaXY7CisJc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9z Z3RfaW5mbyAqKWRtYV9idWYtPnByaXY7CiAKLQlpZiAoc2d0X2luZm8pIHsKLQkJLyogZG1hYnVm IGZkIGlzIGJlaW5nIHJlbGVhc2VkIC0gZGVjcmVhc2UgcmVmY291bnQgKi8KLQkJc2d0X2luZm8t PnJlZl9jb3VudC0tOworCWZpbmFsX3JlbGVhc2UgPSBzZ3RfaW5mbyAmJiAhc2d0X2luZm8tPnZh bGlkICYmCisJCSAgICAgICAhZG1hYnVmX3JlZmNvdW50KHNndF9pbmZvLT5kbWFfYnVmKTsKIAot CQkvKiBpZiBubyBvbmUgZWxzZSBpbiB0aGF0IGRvbWFpbiBpcyB1c2luZyB0aGF0IGJ1ZmZlciwg dW5tYXAgaXQgZm9yIG5vdyAqLwotCQlpZiAoc2d0X2luZm8tPnJlZl9jb3VudCA9PSAwKSB7Ci0J CQloeXBlcl9kbWFidWZfY2xlYW51cF9pbXBvcnRlZF9wYWdlcyhzZ3RfaW5mbyk7Ci0JCQloeXBl cl9kbWFidWZfZnJlZV9zZ3Qoc2d0X2luZm8tPnNndCk7Ci0JCQlzZ3RfaW5mby0+c2d0ID0gTlVM TDsKLQkJfQorCWlmICghZG1hYnVmX3JlZmNvdW50KHNndF9pbmZvLT5kbWFfYnVmKSkgeworCQlz Z3RfaW5mby0+ZG1hX2J1ZiA9IE5VTEw7CiAJfQogCi0JcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNf cmVxdWVzdF9hbmRfd2FpdChzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkLAotCQkJCQkJSFlQRVJf RE1BQlVGX09QU19SRUxFQVNFKTsKKwlpZiAoZmluYWxfcmVsZWFzZSkgeworCQloeXBlcl9kbWFi dWZfY2xlYW51cF9pbXBvcnRlZF9wYWdlcyhzZ3RfaW5mbyk7CisJCWh5cGVyX2RtYWJ1Zl9mcmVl X3NndChzZ3RfaW5mby0+c2d0KTsKKwkJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdF9h bmRfd2FpdChzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkLAorCQkJCQkJCUhZUEVSX0RNQUJVRl9P UFNfUkVMRUFTRV9GSU5BTCk7CisJfSBlbHNlIHsKKwkJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNf cmVxdWVzdF9hbmRfd2FpdChzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkLAorCQkJCQkJCUhZUEVS X0RNQUJVRl9PUFNfUkVMRUFTRSk7CisJfQogCiAJaWYgKHJldCA8IDApIHsKIAkJcHJpbnRrKCJo eXBlcl9kbWFidWY6OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMgcmVxdWVzdCBmYWlsZWRcbiIs IF9fZnVuY19fKTsKQEAgLTc3MCw4ICs3ODUsNyBAQCBzdGF0aWMgdm9pZCBoeXBlcl9kbWFidWZf b3BzX3JlbGVhc2Uoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKIAkgKiBDaGVjayBpZiBidWZmZXIg aXMgc3RpbGwgdmFsaWQgYW5kIGlmIG5vdCByZW1vdmUgaXQgZnJvbSBpbXBvcnRlZCBsaXN0Lgog CSAqIFRoYXQgaGFzIHRvIGJlIGRvbmUgYWZ0ZXIgc2VuZGluZyBzeW5jIHJlcXVlc3QKIAkgKi8K LQlpZiAoc2d0X2luZm8gJiYgc2d0X2luZm8tPnJlZl9jb3VudCA9PSAwICYmCi0JICAgIHNndF9p bmZvLT5mbGFncyA9PSBIWVBFUl9ETUFCVUZfU0dUX0lOVkFMSUQpIHsKKwlpZiAoZmluYWxfcmVs ZWFzZSkgewogCQloeXBlcl9kbWFidWZfcmVtb3ZlX2ltcG9ydGVkKHNndF9pbmZvLT5oeXBlcl9k bWFidWZfaWQpOwogCQlrZnJlZShzZ3RfaW5mbyk7CiAJfQpAQCAtOTYyLDIzICs5NzYsMjEgQEAg c3RhdGljIGNvbnN0IHN0cnVjdCBkbWFfYnVmX29wcyBoeXBlcl9kbWFidWZfb3BzID0gewogLyog ZXhwb3J0aW5nIGRtYWJ1ZiBhcyBmZCAqLwogaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfZmQoc3Ry dWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqZGluZm8sIGludCBmbGFncykKIHsK LQlpbnQgZmQ7Ci0Jc3RydWN0IGRtYV9idWYqIGRtYWJ1ZjsKKwlpbnQgZmQgPSAtMTsKIAogCS8q IGNhbGwgaHlwZXJfZG1hYnVmX2V4cG9ydF9kbWFidWYgYW5kIGNyZWF0ZQogCSAqIGFuZCBiaW5k IGEgaGFuZGxlIGZvciBpdCB0aGVuIHJlbGVhc2UKIAkgKi8KLQlkbWFidWYgPSBoeXBlcl9kbWFi dWZfZXhwb3J0X2RtYV9idWYoZGluZm8pOwotCi0JZmQgPSBkbWFfYnVmX2ZkKGRtYWJ1ZiwgZmxh Z3MpOworCWh5cGVyX2RtYWJ1Zl9leHBvcnRfZG1hX2J1ZihkaW5mbyk7CiAKLQkvKiBkbWFidWYg ZmQgaXMgZXhwb3J0ZWQgZm9yIGdpdmVuIGJ1ZmVyIC0gaW5jcmVhc2UgaXRzIHJlZiBjb3VudCAq LwotCWRpbmZvLT5yZWZfY291bnQrKzsKKwlpZiAoZGluZm8tPmRtYV9idWYpIHsKKwkJZmQgPSBk bWFfYnVmX2ZkKGRpbmZvLT5kbWFfYnVmLCBmbGFncyk7CisJfQogCiAJcmV0dXJuIGZkOwogfQog Ci1zdHJ1Y3QgZG1hX2J1ZiogaHlwZXJfZG1hYnVmX2V4cG9ydF9kbWFfYnVmKHN0cnVjdCBoeXBl cl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKmRpbmZvKQordm9pZCBoeXBlcl9kbWFidWZfZXhw b3J0X2RtYV9idWYoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqZGluZm8p CiB7CiAJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8oZXhwX2luZm8pOwogCkBAIC05ODksNSAr MTAwMSw1IEBAIHN0cnVjdCBkbWFfYnVmKiBoeXBlcl9kbWFidWZfZXhwb3J0X2RtYV9idWYoc3Ry dWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mCiAJZXhwX2luZm8uZmxhZ3MgPSAvKiBu b3Qgc3VyZSBhYm91dCBmbGFnICovMDsKIAlleHBfaW5mby5wcml2ID0gZGluZm87CiAKLQlyZXR1 cm4gZG1hX2J1Zl9leHBvcnQoJmV4cF9pbmZvKTsKKwlkaW5mby0+ZG1hX2J1ZiA9IGRtYV9idWZf ZXhwb3J0KCZleHBfaW5mbyk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX2ltcC5oIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2Rt YWJ1Zl9pbXAuaAppbmRleCA3MWMxYmIwLi4xYjA4MDFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2ltcC5oCisrKyBiL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmgKQEAgLTEsNiArMSw3IEBACiAjaWZuZGVmIF9fSFlQ RVJfRE1BQlVGX0lNUF9IX18KICNkZWZpbmUgX19IWVBFUl9ETUFCVUZfSU1QX0hfXwogCisjaW5j bHVkZSA8bGludXgvZnMuaD4KICNpbmNsdWRlICJoeXBlcl9kbWFidWZfc3RydWN0LmgiCiAKIC8q IGV4dHJhY3QgcGFnZXMgZGlyZWN0bHkgZnJvbSBzdHJ1Y3Qgc2dfdGFibGUgKi8KQEAgLTMwLDYg KzMxLDggQEAgdm9pZCBoeXBlcl9kbWFidWZfZnJlZV9zZ3Qoc3RydWN0IHNnX3RhYmxlICpzZ3Qp OwogCiBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9y dGVkX3NndF9pbmZvICpkaW5mbywgaW50IGZsYWdzKTsKIAotc3RydWN0IGRtYV9idWYqIGh5cGVy X2RtYWJ1Zl9leHBvcnRfZG1hX2J1ZihzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9p bmZvICpkaW5mbyk7Cit2b2lkIGh5cGVyX2RtYWJ1Zl9leHBvcnRfZG1hX2J1ZihzdHJ1Y3QgaHlw ZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICpkaW5mbyk7CisKK2ludCBkbWFidWZfcmVmY291 bnQoc3RydWN0IGRtYV9idWYgKmRtYV9idWYpOwogCiAjZW5kaWYgLyogX19IWVBFUl9ETUFCVUZf SU1QX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2Rt YWJ1Zl9pb2N0bC5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0 bC5jCmluZGV4IGM1N2FjYWZlLi5lMzM0Yjc3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jCkBAIC0xMDcsMTAgKzEwNywxMiBAQCBzdGF0aWMgaW50 IGh5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlKHZvaWQgKmRhdGEpCiAJfQogCiAJLyogd2UgY2hl Y2sgaWYgdGhpcyBzcGVjaWZpYyBhdHRhY2htZW50IHdhcyBhbHJlYWR5IGV4cG9ydGVkCi0JICog dG8gdGhlIHNhbWUgZG9tYWluIGFuZCBpZiB5ZXMsIGl0IHJldHVybnMgaHlwZXJfZG1hYnVmX2lk Ci0JICogb2YgcHJlLWV4cG9ydGVkIHNndCAqLwotCXJldCA9IGh5cGVyX2RtYWJ1Zl9maW5kX2lk KGRtYV9idWYsIGV4cG9ydF9yZW1vdGVfYXR0ci0+cmVtb3RlX2RvbWFpbik7Ci0JaWYgKHJldCAh PSAtMSkgeworCSAqIHRvIHRoZSBzYW1lIGRvbWFpbiBhbmQgaWYgeWVzIGFuZCBpdCdzIHZhbGlk IHNndF9pbmZvLAorCSAqIGl0IHJldHVybnMgaHlwZXJfZG1hYnVmX2lkIG9mIHByZS1leHBvcnRl ZCBzZ3RfaW5mbworCSAqLworCXJldCA9IGh5cGVyX2RtYWJ1Zl9maW5kX2lkX2V4cG9ydGVkKGRt YV9idWYsIGV4cG9ydF9yZW1vdGVfYXR0ci0+cmVtb3RlX2RvbWFpbik7CisJc2d0X2luZm8gPSBo eXBlcl9kbWFidWZfZmluZF9leHBvcnRlZChyZXQpOworCWlmIChyZXQgIT0gLTEgJiYgc2d0X2lu Zm8tPnZhbGlkKSB7CiAJCWRtYV9idWZfcHV0KGRtYV9idWYpOwogCQlleHBvcnRfcmVtb3RlX2F0 dHItPmh5cGVyX2RtYWJ1Zl9pZCA9IHJldDsKIAkJcmV0dXJuIDA7CkBAIC0xMzUsMTIgKzEzNywx MyBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlKHZvaWQgKmRhdGEpCiAJ LyogVE9ETzogV2UgbWlnaHQgbmVlZCB0byBjb25zaWRlciB1c2luZyBwb3J0IG51bWJlciBvbiBl dmVudCBjaGFubmVsPyAqLwogCXNndF9pbmZvLT5oeXBlcl9kbWFidWZfcmRvbWFpbiA9IGV4cG9y dF9yZW1vdGVfYXR0ci0+cmVtb3RlX2RvbWFpbjsKIAlzZ3RfaW5mby0+ZG1hX2J1ZiA9IGRtYV9i dWY7Ci0Jc2d0X2luZm8tPmZsYWdzID0gMDsKKwlzZ3RfaW5mby0+dmFsaWQgPSAxOworCXNndF9p bmZvLT5pbXBvcnRlcl9leHBvcnRlZCA9IDA7CiAKLQlzZ3RfaW5mby0+YWN0aXZlX3NndHMgPSBr Y2FsbG9jKDEsIHNpemVvZihzdHJ1Y3Qgc2d0X2xpc3QpLCBHRlBfS0VSTkVMKTsKLQlzZ3RfaW5m by0+YWN0aXZlX2F0dGFjaGVkID0ga2NhbGxvYygxLCBzaXplb2Yoc3RydWN0IGF0dGFjaG1lbnRf bGlzdCksIEdGUF9LRVJORUwpOwotCXNndF9pbmZvLT52YV9rbWFwcGVkID0ga2NhbGxvYygxLCBz aXplb2Yoc3RydWN0IGttYXBfdmFkZHJfbGlzdCksIEdGUF9LRVJORUwpOwotCXNndF9pbmZvLT52 YV92bWFwcGVkID0ga2NhbGxvYygxLCBzaXplb2Yoc3RydWN0IHZtYXBfdmFkZHJfbGlzdCksIEdG UF9LRVJORUwpOworCXNndF9pbmZvLT5hY3RpdmVfc2d0cyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVj dCBzZ3RfbGlzdCksIEdGUF9LRVJORUwpOworCXNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQgPSBr bWFsbG9jKHNpemVvZihzdHJ1Y3QgYXR0YWNobWVudF9saXN0KSwgR0ZQX0tFUk5FTCk7CisJc2d0 X2luZm8tPnZhX2ttYXBwZWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qga21hcF92YWRkcl9saXN0 KSwgR0ZQX0tFUk5FTCk7CisJc2d0X2luZm8tPnZhX3ZtYXBwZWQgPSBrbWFsbG9jKHNpemVvZihz dHJ1Y3Qgdm1hcF92YWRkcl9saXN0KSwgR0ZQX0tFUk5FTCk7CiAKIAlzZ3RfaW5mby0+YWN0aXZl X3NndHMtPnNndCA9IHNndDsKIAlzZ3RfaW5mby0+YWN0aXZlX2F0dGFjaGVkLT5hdHRhY2ggPSBh dHRhY2htZW50OwpAQCAtMTU5LDYgKzE2Miw4IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4 cG9ydF9yZW1vdGUodm9pZCAqZGF0YSkKIAlpZiAocGFnZV9pbmZvID09IE5VTEwpCiAJCWdvdG8g ZmFpbF9leHBvcnQ7CiAKKwlzZ3RfaW5mby0+bmVudHMgPSBwYWdlX2luZm8tPm5lbnRzOworCiAJ Lyogbm93IHJlZ2lzdGVyIGl0IHRvIGV4cG9ydCBsaXN0ICovCiAJaHlwZXJfZG1hYnVmX3JlZ2lz dGVyX2V4cG9ydGVkKHNndF9pbmZvKTsKIApAQCAtMjIwLDYgKzIyNSw4IEBAIHN0YXRpYyBpbnQg aHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bCh2b2lkICpkYXRhKQogewogCXN0cnVjdCBpb2N0 bF9oeXBlcl9kbWFidWZfZXhwb3J0X2ZkICpleHBvcnRfZmRfYXR0cjsKIAlzdHJ1Y3QgaHlwZXJf ZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICppbXBvcnRlZF9zZ3RfaW5mbzsKKwlzdHJ1Y3QgaHlw ZXJfZG1hYnVmX3JpbmdfcnEgKnJlcTsKKwlpbnQgb3BlcmFuZDsKIAlpbnQgcmV0ID0gMDsKIAog CWlmICghZGF0YSkgewpAQCAtMjM0LDM1ICsyNDEsMzggQEAgc3RhdGljIGludCBoeXBlcl9kbWFi dWZfZXhwb3J0X2ZkX2lvY3RsKHZvaWQgKmRhdGEpCiAJaWYgKGltcG9ydGVkX3NndF9pbmZvID09 IE5VTEwpIC8qIGNhbid0IGZpbmQgc2d0IGZyb20gdGhlIHRhYmxlICovCiAJCXJldHVybiAtMTsK IAotCS8qCi0JICogQ2hlY2sgaWYgYnVmZmVyIHdhcyBub3QgdW5leHBvcnRlZCBieSBleHBvcnRl ci4KLQkgKiBJbiBzdWNoIGV4cG9ydGVyIGlzIHdhaXRpbmcgZm9yIGltcG9ydGVyIHRvIGZpbmlz aCB1c2luZyB0aGF0IGJ1ZmZlciwKLQkgKiBzbyBkbyBub3QgYWxsb3cgZXhwb3J0IGZkIG9mIHN1 Y2ggYnVmZmVyIGFueW1vcmUuCi0JICovCi0JaWYgKGltcG9ydGVkX3NndF9pbmZvLT5mbGFncyA9 PSBIWVBFUl9ETUFCVUZfU0dUX0lOVkFMSUQpIHsKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCiAJ cHJpbnRrKCIlcyBGb3VuZCBidWZmZXIgZ3JlZiAlZCAgb2ZmICVkIGxhc3QgbGVuICVkIG5lbnRz ICVkIGRvbWFpbiAlZFxuIiwgX19mdW5jX18sCiAJCWltcG9ydGVkX3NndF9pbmZvLT5ncmVmLCBp bXBvcnRlZF9zZ3RfaW5mby0+ZnJzdF9vZnN0LAogCQlpbXBvcnRlZF9zZ3RfaW5mby0+bGFzdF9s ZW4sIGltcG9ydGVkX3NndF9pbmZvLT5uZW50cywKLQkJSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVS X0dFVF9TRE9NQUlOX0lEKGltcG9ydGVkX3NndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpKTsKKwkJ SFlQRVJfRE1BQlVGX0RPTV9JRChpbXBvcnRlZF9zZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkKSk7 CiAKIAlpZiAoIWltcG9ydGVkX3NndF9pbmZvLT5zZ3QpIHsKIAkJaW1wb3J0ZWRfc2d0X2luZm8t PnNndCA9IGh5cGVyX2RtYWJ1Zl9tYXBfcGFnZXMoaW1wb3J0ZWRfc2d0X2luZm8tPmdyZWYsCiAJ CQkJCQkJaW1wb3J0ZWRfc2d0X2luZm8tPmZyc3Rfb2ZzdCwKIAkJCQkJCQlpbXBvcnRlZF9zZ3Rf aW5mby0+bGFzdF9sZW4sCiAJCQkJCQkJaW1wb3J0ZWRfc2d0X2luZm8tPm5lbnRzLAotCQkJCQkJ CUhZUEVSX0RNQUJVRl9JRF9JTVBPUlRFUl9HRVRfU0RPTUFJTl9JRChpbXBvcnRlZF9zZ3RfaW5m by0+aHlwZXJfZG1hYnVmX2lkKSwKKwkJCQkJCQlIWVBFUl9ETUFCVUZfRE9NX0lEKGltcG9ydGVk X3NndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpLAogCQkJCQkJCSZpbXBvcnRlZF9zZ3RfaW5mby0+ c2hhcmVkX3BhZ2VzX2luZm8pOwotCQlpZiAoIWltcG9ydGVkX3NndF9pbmZvLT5zZ3QpIHsKLQkJ CXByaW50aygiRmFpbGVkIHRvIGNyZWF0ZSBzZ3RcbiIpOworCisJCS8qIHNlbmQgbm90aWZpdGlj YXRpbyBmb3IgZmlyc3QgZXhwb3J0X2ZkIHRvIGV4cG9ydGVyICovCisJCW9wZXJhbmQgPSBpbXBv cnRlZF9zZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkOworCQlyZXEgPSBrY2FsbG9jKDEsIHNpemVv ZigqcmVxKSwgR0ZQX0tFUk5FTCk7CisJCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChyZXEs IEhZUEVSX0RNQUJVRl9GSVJTVF9FWFBPUlQsICZvcGVyYW5kKTsKKworCQlyZXQgPSBoeXBlcl9k bWFidWZfc2VuZF9yZXF1ZXN0KEhZUEVSX0RNQUJVRl9ET01fSUQob3BlcmFuZCksIHJlcSwgZmFs c2UpOworCisJCWlmICghaW1wb3J0ZWRfc2d0X2luZm8tPnNndCB8fCByZXQpIHsKKwkJCWtmcmVl KHJlcSk7CisJCQlwcmludGsoIkZhaWxlZCB0byBjcmVhdGUgc2d0IG9yIG5vdGlmeSBleHBvcnRl clxuIik7CiAJCQlyZXR1cm4gLUVJTlZBTDsKIAkJfQorCQlrZnJlZShyZXEpOwogCX0KIAogCWV4 cG9ydF9mZF9hdHRyLT5mZCA9IGh5cGVyX2RtYWJ1Zl9leHBvcnRfZmQoaW1wb3J0ZWRfc2d0X2lu Zm8sIGV4cG9ydF9mZF9hdHRyLT5mbGFncyk7Ci0JaWYgKGV4cG9ydF9mZF9hdHRyIDwgMCkgewor CisJaWYgKGV4cG9ydF9mZF9hdHRyLT5mZCA8IDApIHsKKwkJLyogZmFpbCB0byBnZXQgZmQgKi8K IAkJcmV0ID0gZXhwb3J0X2ZkX2F0dHItPmZkOwogCX0KIApAQCAtMzA5LDIzICszMTksMjMgQEAg c3RhdGljIGludCBoeXBlcl9kbWFidWZfdW5leHBvcnQodm9pZCAqZGF0YSkKIAkvKiBmcmVlIG1z ZyAqLwogCWtmcmVlKHJlcSk7CiAKKwkvKiBubyBsb25nZXIgdmFsaWQgKi8KKwlzZ3RfaW5mby0+ dmFsaWQgPSAwOworCiAJLyoKLQkgKiBDaGVjayBpZiBhbnkgaW1wb3J0ZXIgaXMgc3RpbGwgdXNp bmcgYnVmZmVyLCBpZiBub3QgY2xlYW4gaXQgdXAgY29tcGxldGx5LAotCSAqIG90aGVyd2lzZSBt YXJrIGJ1ZmZlciBhcyB1bmV4cG9ydGVkIGFuZCBwb3N0cG9uZSBpdHMgY2xlYW51cCB0byB0aW1l IHdoZW4KLQkgKiBpbXBvcnRlciB3aWxsIGZpbmlzaCB1c2luZyBpdC4KKwkgKiBJbW1lZGlhdGVs eSBjbGVhbi11cCBpZiBpdCBoYXMgbmV2ZXIgYmVlbiBleHBvcnRlZCBieSBpbXBvcnRlcgorCSAq IChzbyBubyBTR1QgaXMgY29uc3RydWN0ZWQgb24gaW1wb3J0ZXIpLgorCSAqIGNsZWFuIGl0IHVw IGxhdGVyIGluIHJlbW90ZSBzeW5jIHdoZW4gZmluYWwgcmVsZWFzZSBvcHMKKwkgKiBpcyBjYWxs ZWQgKGltcG9ydGVyIGRvZXMgdGhpcyBvbmx5IHdoZW4gdGhlcmUncyBubworCSAqIG5vIGNvbnN1 bWVyIG9mIGxvY2FsbHkgZXhwb3J0ZWQgRkRzKQogCSAqLwotCWlmIChsaXN0X2VtcHR5KCZzZ3Rf aW5mby0+YWN0aXZlX3NndHMtPmxpc3QpICYmCi0JICAgIGxpc3RfZW1wdHkoJnNndF9pbmZvLT5h Y3RpdmVfYXR0YWNoZWQtPmxpc3QpKSB7CisJcHJpbnRrKCJiZWZvcmUgY2xhbmluZyB1cCBidWZm ZXIgY29tcGxldGx5XG4iKTsKKwlpZiAoIXNndF9pbmZvLT5pbXBvcnRlcl9leHBvcnRlZCkgewog CQloeXBlcl9kbWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzZ3RfaW5mbywgZmFsc2UpOwogCQloeXBl cl9kbWFidWZfcmVtb3ZlX2V4cG9ydGVkKHVuZXhwb3J0X2F0dHItPmh5cGVyX2RtYWJ1Zl9pZCk7 CiAJCWtmcmVlKHNndF9pbmZvKTsKLQl9IGVsc2UgewotCQlzZ3RfaW5mby0+ZmxhZ3MgPSBIWVBF Ul9ETUFCVUZfU0dUX1VORVhQT1JURUQ7CiAJfQogCi0JLyogVE9ETzogc2hvdWxkIHdlIG1hcmsg aGVyZSB0aGF0IGJ1ZmZlciB3YXMgZGVzdHJveWVkIGltbWllZGV0YWx5IG9yIHRoYXQgd2FzIHBv c3Rwb25lZCA/ICovCi0JdW5leHBvcnRfYXR0ci0+c3RhdHVzID0gcmV0OwotCiAJcmV0dXJuIHJl dDsKIH0KIApAQCAtMzY5LDcgKzM3OSw3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX3F1ZXJ5 KHZvaWQgKmRhdGEpCiAJCQlpZiAoc2d0X2luZm8pIHsKIAkJCQlxdWVyeV9hdHRyLT5pbmZvID0g MHhGRkZGRkZGRjsgLyogbXlzZWxmICovCiAJCQl9IGVsc2UgewotCQkJCXF1ZXJ5X2F0dHItPmlu Zm8gPSAoSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9TRE9NQUlOX0lEKGltcG9ydGVkX3Nn dF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpKTsKKwkJCQlxdWVyeV9hdHRyLT5pbmZvID0gKEhZUEVS X0RNQUJVRl9ET01fSUQoaW1wb3J0ZWRfc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCkpOwogCQkJ fQogCQkJYnJlYWs7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfbGlzdC5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9s aXN0LmMKaW5kZXggMTQyMGRmOS4uMTg3MzFkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9saXN0LmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL2h5cGVyX2RtYWJ1Zl9saXN0LmMKQEAgLTY1LDcgKzY1LDcgQEAgc3RydWN0IGh5cGVyX2Rt YWJ1Zl9zZ3RfaW5mbyAqaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQoaW50IGlkKQogfQogCiAv KiBzZWFyY2ggZm9yIHByZS1leHBvcnRlZCBzZ3QgYW5kIHJldHVybiBpZCBvZiBpdCBpZiBpdCBl eGlzdCAqLwotaW50IGh5cGVyX2RtYWJ1Zl9maW5kX2lkKHN0cnVjdCBkbWFfYnVmICpkbWFidWYs IGludCBkb21pZCkKK2ludCBoeXBlcl9kbWFidWZfZmluZF9pZF9leHBvcnRlZChzdHJ1Y3QgZG1h X2J1ZiAqZG1hYnVmLCBpbnQgZG9taWQpCiB7CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbmZvX2Vu dHJ5X2V4cG9ydGVkICppbmZvX2VudHJ5OwogCWludCBia3Q7CmRpZmYgLS1naXQgYS9kcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2xpc3QuaCBiL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5oCmluZGV4IDQ2M2E2ZGEuLmY1NWQwNmUgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5oCisrKyBi L2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5oCkBAIC0yNSw3ICsy NSw3IEBAIGludCBoeXBlcl9kbWFidWZfdGFibGVfZGVzdHJveSh2b2lkKTsKIGludCBoeXBlcl9k bWFidWZfcmVnaXN0ZXJfZXhwb3J0ZWQoc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqaW5m byk7CiAKIC8qIHNlYXJjaCBmb3IgcHJlLWV4cG9ydGVkIHNndCBhbmQgcmV0dXJuIGlkIG9mIGl0 IGlmIGl0IGV4aXN0ICovCi1pbnQgaHlwZXJfZG1hYnVmX2ZpbmRfaWQoc3RydWN0IGRtYV9idWYg KmRtYWJ1ZiwgaW50IGRvbWlkKTsKK2ludCBoeXBlcl9kbWFidWZfZmluZF9pZF9leHBvcnRlZChz dHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBpbnQgZG9taWQpOwogCiBpbnQgaHlwZXJfZG1hYnVmX3Jl Z2lzdGVyX2ltcG9ydGVkKHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8qIGlu Zm8pOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X21zZy5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYwppbmRl eCA5N2I0MmE0Li5hMmQ2ODdmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv aHlwZXJfZG1hYnVmX21zZy5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9k bWFidWZfbXNnLmMKQEAgLTU1LDYgKzU1LDE0IEBAIHZvaWQgaHlwZXJfZG1hYnVmX2NyZWF0ZV9y ZXF1ZXN0KHN0cnVjdCBoeXBlcl9kbWFidWZfcmluZ19ycSAqcmVxdWVzdCwKIAkJcmVxdWVzdC0+ b3BlcmFuZHNbMF0gPSBvcGVyYW5kc1swXTsKIAkJYnJlYWs7CiAKKwljYXNlIEhZUEVSX0RNQUJV Rl9GSVJTVF9FWFBPUlQ6CisJCS8qIGRtYWJ1ZiBmZCBpcyBiZWluZyBjcmVhdGVkIG9uIGltcG9y dGVkIHNpZGUgZm9yIGZpcnN0IHRpbWUgKi8KKwkJLyogY29tbWFuZCA6IEhZUEVSX0RNQUJVRl9G SVJTVF9FWFBPUlQsCisJCSAqIG9wZXJhbmRzMCA6IGh5cGVyX2RtYWJ1Zl9pZAorCQkgKi8KKwkJ cmVxdWVzdC0+b3BlcmFuZHNbMF0gPSBvcGVyYW5kc1swXTsKKwkJYnJlYWs7CisKIAljYXNlIEhZ UEVSX0RNQUJVRl9PUFNfVE9fUkVNT1RFOgogCQkvKiBub3RpZnlpbmcgZG1hYnVmIG1hcC91bm1h cCB0byBpbXBvcnRlciAocHJvYmFibHkgbm90IG5lZWRlZCkgKi8KIAkJLyogZm9yIGRtYWJ1ZiBz eW5jaHJvbml6YXRpb24gKi8KQEAgLTgxLDYgKzg5LDcgQEAgdm9pZCBoeXBlcl9kbWFidWZfY3Jl YXRlX3JlcXVlc3Qoc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpyZXF1ZXN0LAogdm9pZCBj bWRfcHJvY2Vzc193b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIHsKIAlzdHJ1Y3QgaHlw ZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICppbXBvcnRlZF9zZ3RfaW5mbzsKKwlzdHJ1Y3Qg aHlwZXJfZG1hYnVmX3NndF9pbmZvICpzZ3RfaW5mbzsKIAlzdHJ1Y3QgY21kX3Byb2Nlc3MgKnBy b2MgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IGNtZF9wcm9jZXNzLCB3b3JrKTsKIAlzdHJ1 Y3QgaHlwZXJfZG1hYnVmX3JpbmdfcnEgKnJlcTsKIAlpbnQgZG9taWQ7CkBAIC0xMTcsMTEgKzEy NiwyNSBAQCB2b2lkIGNtZF9wcm9jZXNzX3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQog CQlmb3IgKGk9MDsgaTw0OyBpKyspCiAJCQlpbXBvcnRlZF9zZ3RfaW5mby0+cHJpdmF0ZVtpXSA9 IHJlcS0+b3BlcmFuZHNbNStpXTsKIAotCQlpbXBvcnRlZF9zZ3RfaW5mby0+ZmxhZ3MgPSAwOwot CQlpbXBvcnRlZF9zZ3RfaW5mby0+cmVmX2NvdW50ID0gMDsKKwkJaW1wb3J0ZWRfc2d0X2luZm8t PnZhbGlkID0gMTsKIAkJaHlwZXJfZG1hYnVmX3JlZ2lzdGVyX2ltcG9ydGVkKGltcG9ydGVkX3Nn dF9pbmZvKTsKIAkJYnJlYWs7CiAKKwljYXNlIEhZUEVSX0RNQUJVRl9GSVJTVF9FWFBPUlQ6CisJ CS8qIGZpbmQgYSBjb3JyZXNwb25kaW5nIFNHVCBmb3IgdGhlIGlkICovCisJCXNndF9pbmZvID0g aHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQocmVxLT5vcGVyYW5kc1swXSk7CisKKwkJaWYgKCFz Z3RfaW5mbykgeworCQkJcHJpbnRrKCJjcml0aWNhbCBlcnI6IHJlcXVlc3RlZCBzZ3RfaW5mbyBj YW4ndCBiZSBmb3VuZCAlZFxuIiwgcmVxLT5vcGVyYW5kc1swXSk7CisJCQlicmVhazsKKwkJfQor CisJCWlmIChzZ3RfaW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQpCisJCQlwcmludGsoIndhcm5pbmc6 IGV4cG9ydGVkIGZsYWcgaXMgbm90IHN1cHBvc2VkIHRvIGJlIDEgYWxyZWFkeVxuIik7CisKKwkJ c2d0X2luZm8tPmltcG9ydGVyX2V4cG9ydGVkID0gMTsKKwkJYnJlYWs7CisKIAljYXNlIEhZUEVS X0RNQUJVRl9PUFNfVE9fUkVNT1RFOgogCQkvKiBub3RpZnlpbmcgZG1hYnVmIG1hcC91bm1hcCB0 byBpbXBvcnRlciAocHJvYmFibHkgbm90IG5lZWRlZCkgKi8KIAkJLyogZm9yIGRtYWJ1ZiBzeW5j aHJvbml6YXRpb24gKi8KQEAgLTE3MCwxMyArMTkzLDE0IEBAIGludCBoeXBlcl9kbWFidWZfbXNn X3BhcnNlKGludCBkb21pZCwgc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpyZXEpCiAJCQlo eXBlcl9kbWFidWZfZmluZF9pbXBvcnRlZChyZXEtPm9wZXJhbmRzWzBdKTsKIAogCQlpZiAoaW1w b3J0ZWRfc2d0X2luZm8pIHsKLQkJCS8qIGNoZWNrIGlmIGJ1ZmZlciBpcyBzdGlsbCBtYXBwZWQg YW5kIGluIHVzZSAqLwotCQkJaWYgKGltcG9ydGVkX3NndF9pbmZvLT5zZ3QpIHsKKwkJCS8qIGlm IGFueXRoaW5nIGlzIHN0aWxsIHVzaW5nIGRtYV9idWYgKi8KKwkJCWlmIChpbXBvcnRlZF9zZ3Rf aW5mby0+ZG1hX2J1ZiAmJgorCQkJICAgIGRtYWJ1Zl9yZWZjb3VudChpbXBvcnRlZF9zZ3RfaW5m by0+ZG1hX2J1ZikgPiAwKSB7CiAJCQkJLyoKIAkJCQkgKiBCdWZmZXIgaXMgc3RpbGwgaW4gIHVz ZSwganVzdCBtYXJrIHRoYXQgaXQgc2hvdWxkCiAJCQkJICogbm90IGJlIGFsbG93ZWQgdG8gZXhw b3J0IGl0cyBmZCBhbnltb3JlLgogCQkJCSAqLwotCQkJCWltcG9ydGVkX3NndF9pbmZvLT5mbGFn cyA9IEhZUEVSX0RNQUJVRl9TR1RfSU5WQUxJRDsKKwkJCQlpbXBvcnRlZF9zZ3RfaW5mby0+dmFs aWQgPSAwOwogCQkJfSBlbHNlIHsKIAkJCQkvKiBObyBvbmUgaXMgdXNpbmcgYnVmZmVyLCByZW1v dmUgaXQgZnJvbSBpbXBvcnRlZCBsaXN0ICovCiAJCQkJaHlwZXJfZG1hYnVmX3JlbW92ZV9pbXBv cnRlZChyZXEtPm9wZXJhbmRzWzBdKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2Rt YWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX21zZy5oCmluZGV4IGZjMTM2NWIuLjFlOWQ4MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv eGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmgKKysrIGIvZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaApAQCAtMyw2ICszLDcgQEAKIAogZW51bSBoeXBl cl9kbWFidWZfY29tbWFuZCB7CiAJSFlQRVJfRE1BQlVGX0VYUE9SVCA9IDB4MTAsCisJSFlQRVJf RE1BQlVGX0ZJUlNUX0VYUE9SVCwKIAlIWVBFUl9ETUFCVUZfTk9USUZZX1VORVhQT1JULAogCUhZ UEVSX0RNQUJVRl9PUFNfVE9fUkVNT1RFLAogCUhZUEVSX0RNQUJVRl9PUFNfVE9fU09VUkNFLApA QCAtMTQsNiArMTUsNyBAQCBlbnVtIGh5cGVyX2RtYWJ1Zl9vcHMgewogCUhZUEVSX0RNQUJVRl9P UFNfTUFQLAogCUhZUEVSX0RNQUJVRl9PUFNfVU5NQVAsCiAJSFlQRVJfRE1BQlVGX09QU19SRUxF QVNFLAorCUhZUEVSX0RNQUJVRl9PUFNfUkVMRUFTRV9GSU5BTCwKIAlIWVBFUl9ETUFCVUZfT1BT X0JFR0lOX0NQVV9BQ0NFU1MsCiAJSFlQRVJfRE1BQlVGX09QU19FTkRfQ1BVX0FDQ0VTUywKIAlI WVBFUl9ETUFCVUZfT1BTX0tNQVBfQVRPTUlDLApkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jIGIvZHJpdmVycy94ZW4vaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jCmluZGV4IDYxYmE0ZWQuLjUwMTdiMTcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcmVtb3Rl X3N5bmMuYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3JlbW90 ZV9zeW5jLmMKQEAgLTExNCwxMyArMTE0LDEzIEBAIGludCBoeXBlcl9kbWFidWZfcmVtb3RlX3N5 bmMoaW50IGlkLCBpbnQgb3BzKQogCQlrZnJlZShzZ3RsKTsKIAkJYnJlYWs7CiAKLQljYXNlIEhZ UEVSX0RNQUJVRl9PUFNfUkVMRUFTRToKKwljYXNlIEhZUEVSX0RNQUJVRl9PUFNfUkVMRUFTRV9G SU5BTDoKIAkJLyoKIAkJICogSW1wb3J0ZXIganVzdCByZWxlYXNlZCBidWZmZXIgZmQsIGNoZWNr IGlmIHRoZXJlIGlzIGFueSBvdGhlciBpbXBvcnRlciBzdGlsbCB1c2luZyBpdC4KIAkJICogSWYg bm90IGFuZCBidWZmZXIgd2FzIHVuZXhwb3J0ZWQsIGNsZWFuIHVwIHNoYXJlZCBkYXRhIGFuZCBy ZW1vdmUgdGhhdCBidWZmZXIuCiAJCSAqLwotCQkgaWYgKGxpc3RfZW1wdHkoJnNndF9pbmZvLT5h Y3RpdmVfc2d0cy0+bGlzdCkgJiYgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJICAgIGxpc3RfZW1wdHkoJnNndF9pbmZvLT5h Y3RpdmVfYXR0YWNoZWQtPmxpc3QpICYmCi0JCSAgICAgc2d0X2luZm8tPmZsYWdzID09IEhZUEVS X0RNQUJVRl9TR1RfVU5FWFBPUlRFRCkgeworCQkgaWYgKGxpc3RfZW1wdHkoJnNndF9pbmZvLT5h Y3RpdmVfYXR0YWNoZWQtPmxpc3QpICYmCisJCSAgICAgIXNndF9pbmZvLT52YWxpZCkgewogCQkJ aHlwZXJfZG1hYnVmX2NsZWFudXBfc2d0X2luZm8oc2d0X2luZm8sIGZhbHNlKTsKIAkJCWh5cGVy X2RtYWJ1Zl9yZW1vdmVfZXhwb3J0ZWQoaWQpOwogCQkJa2ZyZWUoc2d0X2luZm8pOwpAQCAtMTI4 LDYgKzEyOCwxMCBAQCBpbnQgaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jKGludCBpZCwgaW50IG9w cykKIAogCQlicmVhazsKIAorCWNhc2UgSFlQRVJfRE1BQlVGX09QU19SRUxFQVNFOgorCQkvKiBw bGFjZSBob2xkZXIgKi8KKwkJYnJlYWs7CisKIAljYXNlIEhZUEVSX0RNQUJVRl9PUFNfQkVHSU5f Q1BVX0FDQ0VTUzoKIAkJcmV0ID0gZG1hX2J1Zl9iZWdpbl9jcHVfYWNjZXNzKHNndF9pbmZvLT5k bWFfYnVmLCBETUFfQklESVJFQ1RJT05BTCk7CiAJCWlmICghcmV0KSB7CmRpZmYgLS1naXQgYS9k cml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3N0cnVjdC5oIGIvZHJpdmVycy94 ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaAppbmRleCAxMTk0Y2YyLi45MmUw NmZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3N0 cnVjdC5oCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0 LmgKQEAgLTYsMTAgKzYsMTAgQEAKIC8qIEltcG9ydGVyIGNvbWJpbmUgc291cmNlIGRvbWFpbiBp ZCB3aXRoIGdpdmVuIGh5cGVyX2RtYWJ1Zl9pZAogICogdG8gbWFrZSBpdCB1bmlxdWUgaW4gY2Fz ZSB0aGVyZSBhcmUgbXVsdGlwbGUgZXhwb3J0ZXJzICovCiAKLSNkZWZpbmUgSFlQRVJfRE1BQlVG X0lEX0lNUE9SVEVSKHNkb21haW4sIGlkKSBcCi0JKCgoKHNkb21haW4pICYgMHhGRikgPDwgMjQp IHwgKChpZCkgJiAweEZGRkZGRikpCisjZGVmaW5lIEhZUEVSX0RNQUJVRl9JRF9JTVBPUlRFUihk b21pZCwgaWQpIFwKKwkoKCgoZG9taWQpICYgMHhGRikgPDwgMjQpIHwgKChpZCkgJiAweEZGRkZG RikpCiAKLSNkZWZpbmUgSFlQRVJfRE1BQlVGX0lEX0lNUE9SVEVSX0dFVF9TRE9NQUlOX0lEKGlk KSBcCisjZGVmaW5lIEhZUEVSX0RNQUJVRl9ET01fSUQoaWQpIFwKIAkoKChpZCkgPj4gMjQpICYg MHhGRikKIAogLyogZWFjaCBncmFudF9yZWZfdCBpcyA0IGJ5dGVzLCBzbyB0b3RhbCA0MDk2IGdy YW50X3JlZl90IGNhbiBiZQpAQCAtMTgsMTEgKzE4LDYgQEAKICAqIGZyYW1lIGJ1ZmZlcikgKi8K ICNkZWZpbmUgTUFYX0FMTE9XRURfTlVNX1BBR0VTX0ZPUl9HUkVGX05VTV9BUlJBWVMgNAogCi1l bnVtIGh5cGVyX2RtYWJ1Zl9zZ3RfZmxhZ3MgewotICAgICAgICBIWVBFUl9ETUFCVUZfU0dUX0lO VkFMSUQgPSAweDEwLAotICAgICAgICBIWVBFUl9ETUFCVUZfU0dUX1VORVhQT1JURUQsCi19Owot CiAvKiBzdGFjayBvZiBtYXBwZWQgc2d0cyAqLwogc3RydWN0IHNndF9saXN0IHsKIAlzdHJ1Y3Qg c2dfdGFibGUgKnNndDsKQEAgLTc3LDExICs3MiwxMyBAQCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3Nn dF9pbmZvIHsKIAlpbnQgaHlwZXJfZG1hYnVmX3Jkb21haW47IC8qIGRvbWFpbiBpbXBvcnRpbmcg dGhpcyBzZ3QgKi8KIAogCXN0cnVjdCBkbWFfYnVmICpkbWFfYnVmOyAvKiBuZWVkZWQgdG8gc3Rv cmUgdGhpcyBmb3IgZnJlZWluZyBpdCBsYXRlciAqLworCWludCBuZW50czsgLyogbnVtYmVyIG9m IHBhZ2VzLCB3aGljaCBtYXkgYmUgZGlmZmVyZW50IHRoYW4gc2d0LT5uZW50cyAqLwogCXN0cnVj dCBzZ3RfbGlzdCAqYWN0aXZlX3NndHM7CiAJc3RydWN0IGF0dGFjaG1lbnRfbGlzdCAqYWN0aXZl X2F0dGFjaGVkOwogCXN0cnVjdCBrbWFwX3ZhZGRyX2xpc3QgKnZhX2ttYXBwZWQ7CiAJc3RydWN0 IHZtYXBfdmFkZHJfbGlzdCAqdmFfdm1hcHBlZDsKLQlpbnQgZmxhZ3M7CisJYm9vbCB2YWxpZDsK Kwlib29sIGltcG9ydGVyX2V4cG9ydGVkOyAvKiBleHBvcnRlZCBsb2NhbGx5IG9uIGltcG9ydGVy J3Mgc2lkZSAqLwogCXN0cnVjdCBoeXBlcl9kbWFidWZfc2hhcmVkX3BhZ2VzX2luZm8gc2hhcmVk X3BhZ2VzX2luZm87CiAJaW50IHByaXZhdGVbNF07IC8qIGRldmljZSBzcGVjaWZpYyBpbmZvIChl LmcuIGltYWdlJ3MgbWV0YSBpbmZvPykgKi8KIH07CkBAIC05NSwxMCArOTIsMTAgQEAgc3RydWN0 IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyB7CiAJaW50IGxhc3RfbGVuOwkvKiBsZW5n dGggb2YgZGF0YSBpbiB0aGUgbGFzdCBzaGFyZWQgcGFnZSAqLwogCWludCBuZW50czsJLyogbnVt YmVyIG9mIHBhZ2VzIHRvIGJlIHNoYXJlZCAqLwogCWdyYW50X3JlZl90IGdyZWY7IC8qIHJlZmVy ZW5jZSBudW1iZXIgb2YgdG9wIGxldmVsIGFkZHJlc3NpbmcgcGFnZSBvZiBzaGFyZWQgcGFnZXMg Ki8KKwlzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZjsKIAlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsgLyog c2d0IHBvaW50ZXIgYWZ0ZXIgaW1wb3J0aW5nIGJ1ZmZlciAqLwogCXN0cnVjdCBoeXBlcl9kbWFi dWZfc2hhcmVkX3BhZ2VzX2luZm8gc2hhcmVkX3BhZ2VzX2luZm87Ci0JaW50IGZsYWdzOwotCWlu dCByZWZfY291bnQ7CisJYm9vbCB2YWxpZDsKIAlpbnQgcHJpdmF0ZVs0XTsgLyogZGV2aWNlIHNw ZWNpZmljIGluZm8gKGUuZy4gaW1hZ2UncyBtZXRhIGluZm8/KSAqLwogfTsKIApkaWZmIC0tZ2l0 IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uYyBi L2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMKaW5k ZXggMTE2ODUwZS4uZjllMGRmMyAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVm L3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5jCkBAIC00NTYsMTMgKzQ1NiwxMiBAQCBzdGF0 aWMgaXJxcmV0dXJuX3QgaHlwZXJfZG1hYnVmX2JhY2tfcmluZ19pc3IoaW50IGlycSwgdm9pZCAq aW5mbykKIAlkbyB7CiAJCXJjID0gcmluZy0+cmVxX2NvbnM7CiAJCXJwID0gcmluZy0+c3Jpbmct PnJlcV9wcm9kOwotCisJCW1vcmVfdG9fZG8gPSAwOwogCQl3aGlsZSAocmMgIT0gcnApIHsKIAkJ CWlmIChSSU5HX1JFUVVFU1RfQ09OU19PVkVSRkxPVyhyaW5nLCByYykpCiAJCQkJYnJlYWs7CiAK IAkJCW1lbWNweSgmcmVxLCBSSU5HX0dFVF9SRVFVRVNUKHJpbmcsIHJjKSwgc2l6ZW9mKHJlcSkp OwotCQkJcHJpbnRrKCJHb3QgcmVxdWVzdFxuIik7CiAJCQlyaW5nLT5yZXFfY29ucyA9ICsrcmM7 CiAKIAkJCXJldCA9IGh5cGVyX2RtYWJ1Zl9tc2dfcGFyc2UocmluZ19pbmZvLT5zZG9tYWluLCAm cmVxKTsKQEAgLTQ3OSwxMyArNDc4LDExIEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBoeXBlcl9kbWFi dWZfYmFja19yaW5nX2lzcihpbnQgaXJxLCB2b2lkICppbmZvKQogCQkJCVJJTkdfUFVTSF9SRVNQ T05TRVNfQU5EX0NIRUNLX05PVElGWShyaW5nLCBub3RpZnkpOwogCiAJCQkJaWYgKG5vdGlmeSkg ewotCQkJCQlwcmludGsoIk5vdHlmaW5nXG4iKTsKIAkJCQkJbm90aWZ5X3JlbW90ZV92aWFfaXJx KHJpbmdfaW5mby0+aXJxKTsKIAkJCQl9CiAJCQl9CiAKIAkJCVJJTkdfRklOQUxfQ0hFQ0tfRk9S X1JFUVVFU1RTKHJpbmcsIG1vcmVfdG9fZG8pOwotCQkJcHJpbnRrKCJGaW5hbCBjaGVjayBmb3Ig cmVxdWVzdHMgJWRcbiIsIG1vcmVfdG9fZG8pOwogCQl9CiAJfSB3aGlsZSAobW9yZV90b19kbyk7 CiAKQEAgLTU0MSw3ICs1MzgsNiBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgaHlwZXJfZG1hYnVmX2Zy b250X3JpbmdfaXNyKGludCBpcnEsIHZvaWQgKmluZm8pCiAKIAkJaWYgKGkgIT0gcmluZy0+cmVx X3Byb2RfcHZ0KSB7CiAJCQlSSU5HX0ZJTkFMX0NIRUNLX0ZPUl9SRVNQT05TRVMocmluZywgbW9y ZV90b19kbyk7Ci0JCQlwcmludGsoIm1vcmUgdG8gZG8gJWRcbiIsIG1vcmVfdG9fZG8pOwogCQl9 IGVsc2UgewogCQkJcmluZy0+c3JpbmctPnJzcF9ldmVudCA9IGkrMTsKIAkJfQotLSAKMi43LjQK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZl bCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=