From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753258AbdLSTuB (ORCPT ); Tue, 19 Dec 2017 14:50:01 -0500 Received: from mga01.intel.com ([192.55.52.88]:17636 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752939AbdLSTgf (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="4018520" 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 13/60] hyper_dmabuf: postponing cleanup of hyper_DMABUF Date: Tue, 19 Dec 2017 11:29:29 -0800 Message-Id: <1513711816-2618-13-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 From: Mateusz Polrola Immediate clean up of buffer is not possible if the buffer is actively used by importer. In this case, we need to postpone freeing hyper_DMABUF until the last consumer unmaps and releases the buffer on impoter VM. New reference count is added for tracking usage by importers. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c | 37 ++++++++++++++-- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 34 +++++++++++---- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 49 +++++++--------------- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 1 - .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 14 +++++-- drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 9 +++- 6 files changed, 95 insertions(+), 49 deletions(-) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c index 06bd8e5..f258981 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c @@ -9,6 +9,7 @@ #include "hyper_dmabuf_imp.h" #include "xen/hyper_dmabuf_xen_comm.h" #include "hyper_dmabuf_msg.h" +#include "hyper_dmabuf_list.h" #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t)) @@ -104,7 +105,7 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pages, ret = sg_alloc_table(sgt, nents, GFP_KERNEL); if (ret) { - sg_free_table(sgt); + hyper_dmabuf_free_sgt(sgt); return NULL; } @@ -129,6 +130,7 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pages, void hyper_dmabuf_free_sgt(struct sg_table* sgt) { sg_free_table(sgt); + kfree(sgt); } /* @@ -583,6 +585,9 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo kfree(attachl); } + /* Start cleanup of buffer in reverse order to exporting */ + hyper_dmabuf_cleanup_gref_table(sgt_info); + /* unmap dma-buf */ dma_buf_unmap_attachment(sgt_info->active_attached->attach, sgt_info->active_sgts->sgt, @@ -594,8 +599,6 @@ 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); - hyper_dmabuf_cleanup_gref_table(sgt_info); - kfree(sgt_info->active_sgts); kfree(sgt_info->active_attached); kfree(sgt_info->va_kmapped); @@ -694,6 +697,9 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id, HYPER_DMABUF_OPS_MAP); + kfree(page_info->pages); + kfree(page_info); + if (ret < 0) { printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); } @@ -741,12 +747,34 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dmabuf) sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + if (sgt_info) { + /* dmabuf fd is being released - decrease refcount */ + sgt_info->ref_count--; + + /* 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; + } + } + 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__); } + + /* + * 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) { + hyper_dmabuf_remove_imported(sgt_info->hyper_dmabuf_id); + kfree(sgt_info); + } } static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir) @@ -944,6 +972,9 @@ int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int fla fd = dma_buf_fd(dmabuf, flags); + /* dmabuf fd is exported for given bufer - increase its ref count */ + dinfo->ref_count++; + return fd; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index a222c1b..c57acafe 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -135,6 +135,7 @@ 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->active_sgts = kcalloc(1, sizeof(struct sgt_list), GFP_KERNEL); sgt_info->active_attached = kcalloc(1, sizeof(struct attachment_list), GFP_KERNEL); @@ -233,6 +234,15 @@ 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, @@ -289,9 +299,7 @@ static int hyper_dmabuf_unexport(void *data) hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &unexport_attr->hyper_dmabuf_id); - /* now send destroy request to remote domain - * currently assuming there's only one importer exist - */ + /* Now send unexport request to remote domain, marking that buffer should not be used anymore */ ret = hyper_dmabuf_send_request(sgt_info->hyper_dmabuf_rdomain, req, true); if (ret < 0) { kfree(req); @@ -300,11 +308,23 @@ static int hyper_dmabuf_unexport(void *data) /* free msg */ kfree(req); - unexport_attr->status = ret; - /* Rest of cleanup will follow when importer will free it's buffer, - * current implementation assumes that there is only one importer - */ + /* + * 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. + */ + if (list_empty(&sgt_info->active_sgts->list) && + list_empty(&sgt_info->active_attached->list)) { + 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; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c index e7532b5..97b42a4 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c @@ -81,11 +81,10 @@ 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; - int i, ret; + int i; req = proc->rq; domid = proc->domid; @@ -118,31 +117,11 @@ 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; hyper_dmabuf_register_imported(imported_sgt_info); break; - case HYPER_DMABUF_UNEXPORT_FINISH: - /* destroy sg_list for hyper_dmabuf_id on local side */ - /* command : DMABUF_DESTROY_FINISH, - * operands0 : hyper_dmabuf_id - */ - - /* 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]); - hyper_dmabuf_remove_exported(req->operands[0]); - if (!sgt_info) - printk("sgt_info does not exist in the list\n"); - - ret = hyper_dmabuf_cleanup_sgt_info(sgt_info, FORCED_UNEXPORTING); - if (!ret) - kfree(sgt_info); - else - printk("failed to clean up sgt_info\n"); - - break; - case HYPER_DMABUF_OPS_TO_REMOTE: /* notifying dmabuf map/unmap to importer (probably not needed) */ /* for dmabuf synchronization */ @@ -191,16 +170,18 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req) hyper_dmabuf_find_imported(req->operands[0]); if (imported_sgt_info) { - hyper_dmabuf_free_sgt(imported_sgt_info->sgt); - - hyper_dmabuf_cleanup_imported_pages(imported_sgt_info); - hyper_dmabuf_remove_imported(req->operands[0]); - - /* Notify exporter that buffer is freed and it can - * cleanup it - */ - req->status = HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP; - req->command = HYPER_DMABUF_UNEXPORT_FINISH; + /* check if buffer is still mapped and in use */ + if (imported_sgt_info->sgt) { + /* + * 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; + } else { + /* No one is using buffer, remove it from imported list */ + hyper_dmabuf_remove_imported(req->operands[0]); + kfree(imported_sgt_info); + } } else { req->status = HYPER_DMABUF_REQ_ERROR; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h index 39a114a..fc1365b 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h @@ -4,7 +4,6 @@ enum hyper_dmabuf_command { HYPER_DMABUF_EXPORT = 0x10, HYPER_DMABUF_NOTIFY_UNEXPORT, - HYPER_DMABUF_UNEXPORT_FINISH, HYPER_DMABUF_OPS_TO_REMOTE, HYPER_DMABUF_OPS_TO_SOURCE, }; diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c index fa2fa11..61ba4ed 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c @@ -8,6 +8,7 @@ #include "hyper_dmabuf_drv.h" #include "xen/hyper_dmabuf_xen_comm.h" #include "hyper_dmabuf_msg.h" +#include "hyper_dmabuf_imp.h" extern struct hyper_dmabuf_private hyper_dmabuf_private; @@ -114,10 +115,17 @@ int hyper_dmabuf_remote_sync(int id, int ops) 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. + /* + * 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) { + hyper_dmabuf_cleanup_sgt_info(sgt_info, false); + hyper_dmabuf_remove_exported(id); + kfree(sgt_info); + } + break; case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS: diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h index bfe80ee..1194cf2 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h @@ -18,6 +18,11 @@ * 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; @@ -76,7 +81,7 @@ struct hyper_dmabuf_sgt_info { struct attachment_list *active_attached; struct kmap_vaddr_list *va_kmapped; struct vmap_vaddr_list *va_vmapped; - + int flags; struct hyper_dmabuf_shared_pages_info shared_pages_info; int private[4]; /* device specific info (e.g. image's meta info?) */ }; @@ -92,6 +97,8 @@ struct hyper_dmabuf_imported_sgt_info { grant_ref_t gref; /* reference number of top level addressing page of shared pages */ struct sg_table *sgt; /* sgt pointer after importing buffer */ struct hyper_dmabuf_shared_pages_info shared_pages_info; + int flags; + int ref_count; int private[4]; /* device specific info (e.g. image's meta info?) */ }; -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 13/60] hyper_dmabuf: postponing cleanup of hyper_DMABUF Date: Tue, 19 Dec 2017 11:29:29 -0800 Message-ID: <1513711816-2618-13-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 A89AC6E339 for ; Tue, 19 Dec 2017 19:36:34 +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 RnJvbTogTWF0ZXVzeiBQb2xyb2xhIDxtYXRldXN6eC5wb3Ryb2xhQGludGVsLmNvbT4KCkltbWVk aWF0ZSBjbGVhbiB1cCBvZiBidWZmZXIgaXMgbm90IHBvc3NpYmxlIGlmIHRoZSBidWZmZXIgaXMK YWN0aXZlbHkgdXNlZCBieSBpbXBvcnRlci4gSW4gdGhpcyBjYXNlLCB3ZSBuZWVkIHRvIHBvc3Rw b25lCmZyZWVpbmcgaHlwZXJfRE1BQlVGIHVudGlsIHRoZSBsYXN0IGNvbnN1bWVyIHVubWFwcyBh bmQgcmVsZWFzZXMKdGhlIGJ1ZmZlciBvbiBpbXBvdGVyIFZNLiBOZXcgcmVmZXJlbmNlIGNvdW50 IGlzIGFkZGVkIGZvciB0cmFja2luZwp1c2FnZSBieSBpbXBvcnRlcnMuCgpTaWduZWQtb2ZmLWJ5 OiBEb25nd29uIEtpbSA8ZG9uZ3dvbi5raW1AaW50ZWwuY29tPgotLS0KIGRyaXZlcnMveGVuL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMgICAgICAgIHwgMzcgKysrKysrKysrKysrKyst LQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jICAgICAgfCAz NCArKysrKysrKysrKy0tLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZf bXNnLmMgICAgICAgIHwgNDkgKysrKysrKy0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaCAgICAgICAgfCAgMSAtCiAuLi4veGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMuYyAgICB8IDE0ICsrKysrLS0KIGRyaXZl cnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmggICAgIHwgIDkgKysrLQog NiBmaWxlcyBjaGFuZ2VkLCA5NSBpbnNlcnRpb25zKCspLCA0OSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2ltcC5jIGIvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pbXAuYwppbmRleCAwNmJkOGU1Li5m MjU4OTgxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X2ltcC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMK QEAgLTksNiArOSw3IEBACiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2ltcC5oIgogI2luY2x1ZGUg Inhlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uaCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfbXNn LmgiCisjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2xpc3QuaCIKIAogI2RlZmluZSBSRUZTX1BFUl9Q QUdFIChQQUdFX1NJWkUvc2l6ZW9mKGdyYW50X3JlZl90KSkKIApAQCAtMTA0LDcgKzEwNSw3IEBA IHN0cnVjdCBzZ190YWJsZSogaHlwZXJfZG1hYnVmX2NyZWF0ZV9zZ3Qoc3RydWN0IHBhZ2UgKipw YWdlcywKIAogCXJldCA9IHNnX2FsbG9jX3RhYmxlKHNndCwgbmVudHMsIEdGUF9LRVJORUwpOwog CWlmIChyZXQpIHsKLQkJc2dfZnJlZV90YWJsZShzZ3QpOworCQloeXBlcl9kbWFidWZfZnJlZV9z Z3Qoc2d0KTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCkBAIC0xMjksNiArMTMwLDcgQEAgc3RydWN0 IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfY3JlYXRlX3NndChzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAog dm9pZCBoeXBlcl9kbWFidWZfZnJlZV9zZ3Qoc3RydWN0IHNnX3RhYmxlKiBzZ3QpCiB7CiAJc2df ZnJlZV90YWJsZShzZ3QpOworCWtmcmVlKHNndCk7CiB9CiAKIC8qCkBAIC01ODMsNiArNTg1LDkg QEAgaW50IGh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKHN0cnVjdCBoeXBlcl9kbWFidWZf c2d0X2luZm8gKnNndF9pbmZvLCBpbnQgZm8KIAkJa2ZyZWUoYXR0YWNobCk7CiAJfQogCisJLyog U3RhcnQgY2xlYW51cCBvZiBidWZmZXIgaW4gcmV2ZXJzZSBvcmRlciB0byBleHBvcnRpbmcgKi8K KwloeXBlcl9kbWFidWZfY2xlYW51cF9ncmVmX3RhYmxlKHNndF9pbmZvKTsKKwogCS8qIHVubWFw IGRtYS1idWYgKi8KIAlkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoc2d0X2luZm8tPmFjdGl2ZV9h dHRhY2hlZC0+YXR0YWNoLAogCQkJCSBzZ3RfaW5mby0+YWN0aXZlX3NndHMtPnNndCwKQEAgLTU5 NCw4ICs1OTksNiBAQCBpbnQgaHlwZXJfZG1hYnVmX2NsZWFudXBfc2d0X2luZm8oc3RydWN0IGh5 cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm8sIGludCBmbwogCS8qIGNsb3NlIGNvbm5lY3Rp b24gdG8gZG1hLWJ1ZiBjb21wbGV0ZWx5ICovCiAJZG1hX2J1Zl9wdXQoc2d0X2luZm8tPmRtYV9i dWYpOwogCi0JaHlwZXJfZG1hYnVmX2NsZWFudXBfZ3JlZl90YWJsZShzZ3RfaW5mbyk7Ci0KIAlr ZnJlZShzZ3RfaW5mby0+YWN0aXZlX3NndHMpOwogCWtmcmVlKHNndF9pbmZvLT5hY3RpdmVfYXR0 YWNoZWQpOwogCWtmcmVlKHNndF9pbmZvLT52YV9rbWFwcGVkKTsKQEAgLTY5NCw2ICs2OTcsOSBA QCBzdGF0aWMgc3RydWN0IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfb3BzX21hcChzdHJ1Y3QgZG1h X2J1Zl9hdHRhY2htZW50ICphdHRhY2htZQogCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVl c3RfYW5kX3dhaXQoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCwKIAkJCQkJCUhZUEVSX0RNQUJV Rl9PUFNfTUFQKTsKIAorCWtmcmVlKHBhZ2VfaW5mby0+cGFnZXMpOworCWtmcmVlKHBhZ2VfaW5m byk7CisKIAlpZiAocmV0IDwgMCkgewogCQlwcmludGsoImh5cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6 c2VuZCBkbWFidWYgc3luYyByZXF1ZXN0IGZhaWxlZFxuIiwgX19mdW5jX18pOwogCX0KQEAgLTc0 MSwxMiArNzQ3LDM0IEBAIHN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9vcHNfcmVsZWFzZShzdHJ1 Y3QgZG1hX2J1ZiAqZG1hYnVmKQogCiAJc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9p bXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsKIAorCWlmIChzZ3RfaW5mbykgeworCQkv KiBkbWFidWYgZmQgaXMgYmVpbmcgcmVsZWFzZWQgLSBkZWNyZWFzZSByZWZjb3VudCAqLworCQlz Z3RfaW5mby0+cmVmX2NvdW50LS07CisKKwkJLyogaWYgbm8gb25lIGVsc2UgaW4gdGhhdCBkb21h aW4gaXMgdXNpbmcgdGhhdCBidWZmZXIsIHVubWFwIGl0IGZvciBub3cgKi8KKwkJaWYgKHNndF9p bmZvLT5yZWZfY291bnQgPT0gMCkgeworCQkJaHlwZXJfZG1hYnVmX2NsZWFudXBfaW1wb3J0ZWRf cGFnZXMoc2d0X2luZm8pOworCQkJaHlwZXJfZG1hYnVmX2ZyZWVfc2d0KHNndF9pbmZvLT5zZ3Qp OworCQkJc2d0X2luZm8tPnNndCA9IE5VTEw7CisJCX0KKwl9CisKIAlyZXQgPSBoeXBlcl9kbWFi dWZfc3luY19yZXF1ZXN0X2FuZF93YWl0KHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQsCiAJCQkJ CQlIWVBFUl9ETUFCVUZfT1BTX1JFTEVBU0UpOwogCiAJaWYgKHJldCA8IDApIHsKIAkJcHJpbnRr KCJoeXBlcl9kbWFidWY6OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMgcmVxdWVzdCBmYWlsZWRc biIsIF9fZnVuY19fKTsKIAl9CisKKwkvKgorCSAqIENoZWNrIGlmIGJ1ZmZlciBpcyBzdGlsbCB2 YWxpZCBhbmQgaWYgbm90IHJlbW92ZSBpdCBmcm9tIGltcG9ydGVkIGxpc3QuCisJICogVGhhdCBo YXMgdG8gYmUgZG9uZSBhZnRlciBzZW5kaW5nIHN5bmMgcmVxdWVzdAorCSAqLworCWlmIChzZ3Rf aW5mbyAmJiBzZ3RfaW5mby0+cmVmX2NvdW50ID09IDAgJiYKKwkgICAgc2d0X2luZm8tPmZsYWdz ID09IEhZUEVSX0RNQUJVRl9TR1RfSU5WQUxJRCkgeworCQloeXBlcl9kbWFidWZfcmVtb3ZlX2lt cG9ydGVkKHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpOworCQlrZnJlZShzZ3RfaW5mbyk7CisJ fQogfQogCiBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9vcHNfYmVnaW5fY3B1X2FjY2VzcyhzdHJ1 Y3QgZG1hX2J1ZiAqZG1hYnVmLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIpCkBAIC05NDQs NiArOTcyLDkgQEAgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfZmQoc3RydWN0IGh5cGVyX2RtYWJ1 Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqZGluZm8sIGludCBmbGEKIAogCWZkID0gZG1hX2J1Zl9mZChk bWFidWYsIGZsYWdzKTsKIAorCS8qIGRtYWJ1ZiBmZCBpcyBleHBvcnRlZCBmb3IgZ2l2ZW4gYnVm ZXIgLSBpbmNyZWFzZSBpdHMgcmVmIGNvdW50ICovCisJZGluZm8tPnJlZl9jb3VudCsrOworCiAJ cmV0dXJuIGZkOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlw ZXJfZG1hYnVmX2lvY3RsLmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X2lvY3RsLmMKaW5kZXggYTIyMmMxYi4uYzU3YWNhZmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYworKysgYi9kcml2ZXJzL3hlbi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKQEAgLTEzNSw2ICsxMzUsNyBAQCBzdGF0aWMg aW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlKHZvaWQgKmRhdGEpCiAJLyogVE9ETzogV2Ug bWlnaHQgbmVlZCB0byBjb25zaWRlciB1c2luZyBwb3J0IG51bWJlciBvbiBldmVudCBjaGFubmVs PyAqLwogCXNndF9pbmZvLT5oeXBlcl9kbWFidWZfcmRvbWFpbiA9IGV4cG9ydF9yZW1vdGVfYXR0 ci0+cmVtb3RlX2RvbWFpbjsKIAlzZ3RfaW5mby0+ZG1hX2J1ZiA9IGRtYV9idWY7CisJc2d0X2lu Zm8tPmZsYWdzID0gMDsKIAogCXNndF9pbmZvLT5hY3RpdmVfc2d0cyA9IGtjYWxsb2MoMSwgc2l6 ZW9mKHN0cnVjdCBzZ3RfbGlzdCksIEdGUF9LRVJORUwpOwogCXNndF9pbmZvLT5hY3RpdmVfYXR0 YWNoZWQgPSBrY2FsbG9jKDEsIHNpemVvZihzdHJ1Y3QgYXR0YWNobWVudF9saXN0KSwgR0ZQX0tF Uk5FTCk7CkBAIC0yMzMsNiArMjM0LDE1IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9y dF9mZF9pb2N0bCh2b2lkICpkYXRhKQogCWlmIChpbXBvcnRlZF9zZ3RfaW5mbyA9PSBOVUxMKSAv KiBjYW4ndCBmaW5kIHNndCBmcm9tIHRoZSB0YWJsZSAqLwogCQlyZXR1cm4gLTE7CiAKKwkvKgor CSAqIENoZWNrIGlmIGJ1ZmZlciB3YXMgbm90IHVuZXhwb3J0ZWQgYnkgZXhwb3J0ZXIuCisJICog SW4gc3VjaCBleHBvcnRlciBpcyB3YWl0aW5nIGZvciBpbXBvcnRlciB0byBmaW5pc2ggdXNpbmcg dGhhdCBidWZmZXIsCisJICogc28gZG8gbm90IGFsbG93IGV4cG9ydCBmZCBvZiBzdWNoIGJ1ZmZl ciBhbnltb3JlLgorCSAqLworCWlmIChpbXBvcnRlZF9zZ3RfaW5mby0+ZmxhZ3MgPT0gSFlQRVJf RE1BQlVGX1NHVF9JTlZBTElEKSB7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwogCXByaW50aygi JXMgRm91bmQgYnVmZmVyIGdyZWYgJWQgIG9mZiAlZCBsYXN0IGxlbiAlZCBuZW50cyAlZCBkb21h aW4gJWRcbiIsIF9fZnVuY19fLAogCQlpbXBvcnRlZF9zZ3RfaW5mby0+Z3JlZiwgaW1wb3J0ZWRf c2d0X2luZm8tPmZyc3Rfb2ZzdCwKIAkJaW1wb3J0ZWRfc2d0X2luZm8tPmxhc3RfbGVuLCBpbXBv cnRlZF9zZ3RfaW5mby0+bmVudHMsCkBAIC0yODksOSArMjk5LDcgQEAgc3RhdGljIGludCBoeXBl cl9kbWFidWZfdW5leHBvcnQodm9pZCAqZGF0YSkKIAogCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVx dWVzdChyZXEsIEhZUEVSX0RNQUJVRl9OT1RJRllfVU5FWFBPUlQsICZ1bmV4cG9ydF9hdHRyLT5o eXBlcl9kbWFidWZfaWQpOwogCi0JLyogbm93IHNlbmQgZGVzdHJveSByZXF1ZXN0IHRvIHJlbW90 ZSBkb21haW4KLQkgKiBjdXJyZW50bHkgYXNzdW1pbmcgdGhlcmUncyBvbmx5IG9uZSBpbXBvcnRl ciBleGlzdAotCSAqLworCS8qIE5vdyBzZW5kIHVuZXhwb3J0IHJlcXVlc3QgdG8gcmVtb3RlIGRv bWFpbiwgbWFya2luZyB0aGF0IGJ1ZmZlciBzaG91bGQgbm90IGJlIHVzZWQgYW55bW9yZSAqLwog CXJldCA9IGh5cGVyX2RtYWJ1Zl9zZW5kX3JlcXVlc3Qoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9y ZG9tYWluLCByZXEsIHRydWUpOwogCWlmIChyZXQgPCAwKSB7CiAJCWtmcmVlKHJlcSk7CkBAIC0z MDAsMTEgKzMwOCwyMyBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl91bmV4cG9ydCh2b2lkICpk YXRhKQogCiAJLyogZnJlZSBtc2cgKi8KIAlrZnJlZShyZXEpOwotCXVuZXhwb3J0X2F0dHItPnN0 YXR1cyA9IHJldDsKIAotCS8qIFJlc3Qgb2YgY2xlYW51cCB3aWxsIGZvbGxvdyB3aGVuIGltcG9y dGVyIHdpbGwgZnJlZSBpdCdzIGJ1ZmZlciwKLQkgKiBjdXJyZW50IGltcGxlbWVudGF0aW9uIGFz c3VtZXMgdGhhdCB0aGVyZSBpcyBvbmx5IG9uZSBpbXBvcnRlcgotICAgICAgICAgKi8KKwkvKgor CSAqIENoZWNrIGlmIGFueSBpbXBvcnRlciBpcyBzdGlsbCB1c2luZyBidWZmZXIsIGlmIG5vdCBj bGVhbiBpdCB1cCBjb21wbGV0bHksCisJICogb3RoZXJ3aXNlIG1hcmsgYnVmZmVyIGFzIHVuZXhw b3J0ZWQgYW5kIHBvc3Rwb25lIGl0cyBjbGVhbnVwIHRvIHRpbWUgd2hlbgorCSAqIGltcG9ydGVy IHdpbGwgZmluaXNoIHVzaW5nIGl0LgorCSAqLworCWlmIChsaXN0X2VtcHR5KCZzZ3RfaW5mby0+ YWN0aXZlX3NndHMtPmxpc3QpICYmCisJICAgIGxpc3RfZW1wdHkoJnNndF9pbmZvLT5hY3RpdmVf YXR0YWNoZWQtPmxpc3QpKSB7CisJCWh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKHNndF9p bmZvLCBmYWxzZSk7CisJCWh5cGVyX2RtYWJ1Zl9yZW1vdmVfZXhwb3J0ZWQodW5leHBvcnRfYXR0 ci0+aHlwZXJfZG1hYnVmX2lkKTsKKwkJa2ZyZWUoc2d0X2luZm8pOworCX0gZWxzZSB7CisJCXNn dF9pbmZvLT5mbGFncyA9IEhZUEVSX0RNQUJVRl9TR1RfVU5FWFBPUlRFRDsKKwl9CisKKwkvKiBU T0RPOiBzaG91bGQgd2UgbWFyayBoZXJlIHRoYXQgYnVmZmVyIHdhcyBkZXN0cm95ZWQgaW1taWVk ZXRhbHkgb3IgdGhhdCB3YXMgcG9zdHBvbmVkID8gKi8KKwl1bmV4cG9ydF9hdHRyLT5zdGF0dXMg PSByZXQ7CiAKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfbXNnLmMKaW5kZXggZTc1MzJiNS4uOTdiNDJhNCAxMDA2NDQKLS0tIGEvZHJpdmVy cy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYworKysgYi9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5jCkBAIC04MSwxMSArODEsMTAgQEAgdm9pZCBo eXBlcl9kbWFidWZfY3JlYXRlX3JlcXVlc3Qoc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpy ZXF1ZXN0LAogdm9pZCBjbWRfcHJvY2Vzc193b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykK IHsKIAlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICppbXBvcnRlZF9zZ3Rf aW5mbzsKLSAgICAgICAgc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm87CiAJ c3RydWN0IGNtZF9wcm9jZXNzICpwcm9jID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBjbWRf cHJvY2Vzcywgd29yayk7CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpyZXE7CiAJaW50 IGRvbWlkOwotCWludCBpLCByZXQ7CisJaW50IGk7CiAKIAlyZXEgPSBwcm9jLT5ycTsKIAlkb21p ZCA9IHByb2MtPmRvbWlkOwpAQCAtMTE4LDMxICsxMTcsMTEgQEAgdm9pZCBjbWRfcHJvY2Vzc193 b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIAkJZm9yIChpPTA7IGk8NDsgaSsrKQogCQkJ aW1wb3J0ZWRfc2d0X2luZm8tPnByaXZhdGVbaV0gPSByZXEtPm9wZXJhbmRzWzUraV07CiAKKwkJ aW1wb3J0ZWRfc2d0X2luZm8tPmZsYWdzID0gMDsKKwkJaW1wb3J0ZWRfc2d0X2luZm8tPnJlZl9j b3VudCA9IDA7CiAJCWh5cGVyX2RtYWJ1Zl9yZWdpc3Rlcl9pbXBvcnRlZChpbXBvcnRlZF9zZ3Rf aW5mbyk7CiAJCWJyZWFrOwogCi0JY2FzZSBIWVBFUl9ETUFCVUZfVU5FWFBPUlRfRklOSVNIOgot CQkvKiBkZXN0cm95IHNnX2xpc3QgZm9yIGh5cGVyX2RtYWJ1Zl9pZCBvbiBsb2NhbCBzaWRlICov Ci0JCS8qIGNvbW1hbmQgOiBETUFCVUZfREVTVFJPWV9GSU5JU0gsCi0JCSAqIG9wZXJhbmRzMCA6 IGh5cGVyX2RtYWJ1Zl9pZAotCQkgKi8KLQotCQkvKiBUT0RPOiB0aGF0IHNob3VsZCBiZSBkb25l IG9uIHdvcmtxdWV1ZSwgd2hlbiByZWNlaXZlZCBhY2sgZnJvbQotCQkgKiBhbGwgaW1wb3J0ZXJz IHRoYXQgYnVmZmVyIGlzIG5vIGxvbmdlciB1c2VkCi0JCSAqLwotCQlzZ3RfaW5mbyA9IGh5cGVy X2RtYWJ1Zl9maW5kX2V4cG9ydGVkKHJlcS0+b3BlcmFuZHNbMF0pOwotCQloeXBlcl9kbWFidWZf cmVtb3ZlX2V4cG9ydGVkKHJlcS0+b3BlcmFuZHNbMF0pOwotCQlpZiAoIXNndF9pbmZvKQotCQkJ cHJpbnRrKCJzZ3RfaW5mbyBkb2VzIG5vdCBleGlzdCBpbiB0aGUgbGlzdFxuIik7Ci0KLQkJcmV0 ID0gaHlwZXJfZG1hYnVmX2NsZWFudXBfc2d0X2luZm8oc2d0X2luZm8sIEZPUkNFRF9VTkVYUE9S VElORyk7Ci0JCWlmICghcmV0KQotCQkJa2ZyZWUoc2d0X2luZm8pOwotCQllbHNlCi0JCQlwcmlu dGsoImZhaWxlZCB0byBjbGVhbiB1cCBzZ3RfaW5mb1xuIik7Ci0KLQkJYnJlYWs7Ci0KIAljYXNl IEhZUEVSX0RNQUJVRl9PUFNfVE9fUkVNT1RFOgogCQkvKiBub3RpZnlpbmcgZG1hYnVmIG1hcC91 bm1hcCB0byBpbXBvcnRlciAocHJvYmFibHkgbm90IG5lZWRlZCkgKi8KIAkJLyogZm9yIGRtYWJ1 ZiBzeW5jaHJvbml6YXRpb24gKi8KQEAgLTE5MSwxNiArMTcwLDE4IEBAIGludCBoeXBlcl9kbWFi dWZfbXNnX3BhcnNlKGludCBkb21pZCwgc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpyZXEp CiAJCQloeXBlcl9kbWFidWZfZmluZF9pbXBvcnRlZChyZXEtPm9wZXJhbmRzWzBdKTsKIAogCQlp ZiAoaW1wb3J0ZWRfc2d0X2luZm8pIHsKLQkJCWh5cGVyX2RtYWJ1Zl9mcmVlX3NndChpbXBvcnRl ZF9zZ3RfaW5mby0+c2d0KTsKLQotCQkJaHlwZXJfZG1hYnVmX2NsZWFudXBfaW1wb3J0ZWRfcGFn ZXMoaW1wb3J0ZWRfc2d0X2luZm8pOwotCQkJaHlwZXJfZG1hYnVmX3JlbW92ZV9pbXBvcnRlZChy ZXEtPm9wZXJhbmRzWzBdKTsKLQotCQkJLyogTm90aWZ5IGV4cG9ydGVyIHRoYXQgYnVmZmVyIGlz IGZyZWVkIGFuZCBpdCBjYW4KLQkJCSAqIGNsZWFudXAgaXQKLQkJCSAqLwotCQkJcmVxLT5zdGF0 dXMgPSBIWVBFUl9ETUFCVUZfUkVRX05FRURTX0ZPTExPV19VUDsKLQkJCXJlcS0+Y29tbWFuZCA9 IEhZUEVSX0RNQUJVRl9VTkVYUE9SVF9GSU5JU0g7CisJCQkvKiBjaGVjayBpZiBidWZmZXIgaXMg c3RpbGwgbWFwcGVkIGFuZCBpbiB1c2UgKi8KKwkJCWlmIChpbXBvcnRlZF9zZ3RfaW5mby0+c2d0 KSB7CisJCQkJLyoKKwkJCQkgKiBCdWZmZXIgaXMgc3RpbGwgaW4gIHVzZSwganVzdCBtYXJrIHRo YXQgaXQgc2hvdWxkCisJCQkJICogbm90IGJlIGFsbG93ZWQgdG8gZXhwb3J0IGl0cyBmZCBhbnlt b3JlLgorCQkJCSAqLworCQkJCWltcG9ydGVkX3NndF9pbmZvLT5mbGFncyA9IEhZUEVSX0RNQUJV Rl9TR1RfSU5WQUxJRDsKKwkJCX0gZWxzZSB7CisJCQkJLyogTm8gb25lIGlzIHVzaW5nIGJ1ZmZl ciwgcmVtb3ZlIGl0IGZyb20gaW1wb3J0ZWQgbGlzdCAqLworCQkJCWh5cGVyX2RtYWJ1Zl9yZW1v dmVfaW1wb3J0ZWQocmVxLT5vcGVyYW5kc1swXSk7CisJCQkJa2ZyZWUoaW1wb3J0ZWRfc2d0X2lu Zm8pOworCQkJfQogCQl9IGVsc2UgewogCQkJcmVxLT5zdGF0dXMgPSBIWVBFUl9ETUFCVUZfUkVR X0VSUk9SOwogCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX21zZy5oIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cu aAppbmRleCAzOWExMTRhLi5mYzEzNjViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9k bWFidWYvaHlwZXJfZG1hYnVmX21zZy5oCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9o eXBlcl9kbWFidWZfbXNnLmgKQEAgLTQsNyArNCw2IEBACiBlbnVtIGh5cGVyX2RtYWJ1Zl9jb21t YW5kIHsKIAlIWVBFUl9ETUFCVUZfRVhQT1JUID0gMHgxMCwKIAlIWVBFUl9ETUFCVUZfTk9USUZZ X1VORVhQT1JULAotCUhZUEVSX0RNQUJVRl9VTkVYUE9SVF9GSU5JU0gsCiAJSFlQRVJfRE1BQlVG X09QU19UT19SRU1PVEUsCiAJSFlQRVJfRE1BQlVGX09QU19UT19TT1VSQ0UsCiB9OwpkaWZmIC0t Z2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5j IGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jCmlu ZGV4IGZhMmZhMTEuLjYxYmE0ZWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi9oeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMuYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jLmMKQEAgLTgsNiArOCw3IEBACiAjaW5jbHVkZSAi aHlwZXJfZG1hYnVmX2Rydi5oIgogI2luY2x1ZGUgInhlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0u aCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfbXNnLmgiCisjaW5jbHVkZSAiaHlwZXJfZG1hYnVm X2ltcC5oIgogCiBleHRlcm4gc3RydWN0IGh5cGVyX2RtYWJ1Zl9wcml2YXRlIGh5cGVyX2RtYWJ1 Zl9wcml2YXRlOwogCkBAIC0xMTQsMTAgKzExNSwxNyBAQCBpbnQgaHlwZXJfZG1hYnVmX3JlbW90 ZV9zeW5jKGludCBpZCwgaW50IG9wcykKIAkJYnJlYWs7CiAKIAljYXNlIEhZUEVSX0RNQUJVRl9P UFNfUkVMRUFTRToKLQkJLyogcmVtb3RlIGltcG9ydGVyIHNob3VsZG4ndCByZWxlYXNlIGRtYV9i dWYgYmVjYXVzZQotCQkgKiBleHBvcnRlciB3aWxsIGhvbGQgaGFuZGxlIHRvIHRoZSBkbWFfYnVm IGFzCi0JCSAqIGZhciBhcyBkbWFfYnVmIGlzIHNoYXJlZCB3aXRoIG90aGVyIGRvbWFpbnMuCisJ CS8qCisJCSAqIEltcG9ydGVyIGp1c3QgcmVsZWFzZWQgYnVmZmVyIGZkLCBjaGVjayBpZiB0aGVy ZSBpcyBhbnkgb3RoZXIgaW1wb3J0ZXIgc3RpbGwgdXNpbmcgaXQuCisJCSAqIElmIG5vdCBhbmQg YnVmZmVyIHdhcyB1bmV4cG9ydGVkLCBjbGVhbiB1cCBzaGFyZWQgZGF0YSBhbmQgcmVtb3ZlIHRo YXQgYnVmZmVyLgogCQkgKi8KKwkJIGlmIChsaXN0X2VtcHR5KCZzZ3RfaW5mby0+YWN0aXZlX3Nn dHMtPmxpc3QpICYmICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgCSAgICBsaXN0X2VtcHR5KCZzZ3RfaW5mby0+YWN0aXZlX2F0 dGFjaGVkLT5saXN0KSAmJgorCQkgICAgIHNndF9pbmZvLT5mbGFncyA9PSBIWVBFUl9ETUFCVUZf U0dUX1VORVhQT1JURUQpIHsKKwkJCWh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKHNndF9p bmZvLCBmYWxzZSk7CisJCQloeXBlcl9kbWFidWZfcmVtb3ZlX2V4cG9ydGVkKGlkKTsKKwkJCWtm cmVlKHNndF9pbmZvKTsKKwkJfQorCiAJCWJyZWFrOwogCiAJY2FzZSBIWVBFUl9ETUFCVUZfT1BT X0JFR0lOX0NQVV9BQ0NFU1M6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv aHlwZXJfZG1hYnVmX3N0cnVjdC5oIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2Rt YWJ1Zl9zdHJ1Y3QuaAppbmRleCBiZmU4MGVlLi4xMTk0Y2YyIDEwMDY0NAotLS0gYS9kcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3N0cnVjdC5oCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmgKQEAgLTE4LDYgKzE4LDExIEBACiAg KiBmcmFtZSBidWZmZXIpICovCiAjZGVmaW5lIE1BWF9BTExPV0VEX05VTV9QQUdFU19GT1JfR1JF Rl9OVU1fQVJSQVlTIDQKIAorZW51bSBoeXBlcl9kbWFidWZfc2d0X2ZsYWdzIHsKKyAgICAgICAg SFlQRVJfRE1BQlVGX1NHVF9JTlZBTElEID0gMHgxMCwKKyAgICAgICAgSFlQRVJfRE1BQlVGX1NH VF9VTkVYUE9SVEVELAorfTsKKwogLyogc3RhY2sgb2YgbWFwcGVkIHNndHMgKi8KIHN0cnVjdCBz Z3RfbGlzdCB7CiAJc3RydWN0IHNnX3RhYmxlICpzZ3Q7CkBAIC03Niw3ICs4MSw3IEBAIHN0cnVj dCBoeXBlcl9kbWFidWZfc2d0X2luZm8gewogCXN0cnVjdCBhdHRhY2htZW50X2xpc3QgKmFjdGl2 ZV9hdHRhY2hlZDsKIAlzdHJ1Y3Qga21hcF92YWRkcl9saXN0ICp2YV9rbWFwcGVkOwogCXN0cnVj dCB2bWFwX3ZhZGRyX2xpc3QgKnZhX3ZtYXBwZWQ7Ci0KKwlpbnQgZmxhZ3M7CiAJc3RydWN0IGh5 cGVyX2RtYWJ1Zl9zaGFyZWRfcGFnZXNfaW5mbyBzaGFyZWRfcGFnZXNfaW5mbzsKIAlpbnQgcHJp dmF0ZVs0XTsgLyogZGV2aWNlIHNwZWNpZmljIGluZm8gKGUuZy4gaW1hZ2UncyBtZXRhIGluZm8/ KSAqLwogfTsKQEAgLTkyLDYgKzk3LDggQEAgc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9z Z3RfaW5mbyB7CiAJZ3JhbnRfcmVmX3QgZ3JlZjsgLyogcmVmZXJlbmNlIG51bWJlciBvZiB0b3Ag bGV2ZWwgYWRkcmVzc2luZyBwYWdlIG9mIHNoYXJlZCBwYWdlcyAqLwogCXN0cnVjdCBzZ190YWJs ZSAqc2d0OyAvKiBzZ3QgcG9pbnRlciBhZnRlciBpbXBvcnRpbmcgYnVmZmVyICovCiAJc3RydWN0 IGh5cGVyX2RtYWJ1Zl9zaGFyZWRfcGFnZXNfaW5mbyBzaGFyZWRfcGFnZXNfaW5mbzsKKwlpbnQg ZmxhZ3M7CisJaW50IHJlZl9jb3VudDsKIAlpbnQgcHJpdmF0ZVs0XTsgLyogZGV2aWNlIHNwZWNp ZmljIGluZm8gKGUuZy4gaW1hZ2UncyBtZXRhIGluZm8/KSAqLwogfTsKIAotLSAKMi43LjQKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBt YWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3Rz LmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=