From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753423AbdLSTqV (ORCPT ); Tue, 19 Dec 2017 14:46:21 -0500 Received: from mga01.intel.com ([192.55.52.88]:17647 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753144AbdLSTgq (ORCPT ); Tue, 19 Dec 2017 14:36:46 -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="4018562" 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 25/60] hyper_dmabuf: introduced delayed unexport Date: Tue, 19 Dec 2017 11:29:41 -0800 Message-Id: <1513711816-2618-25-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 To prevent overhead when a DMA BUF needs to be exported right after it is unexported, a marginal delay is introduced in unexporting process. This adds a probation period to the unexporting process. If the same DMA_BUF is requested to be exported agagin, unexporting process is canceled right away and the buffer can be reused without any extensive re-exporting process. Additionally, "FIRST EXPORT" message is synchronously transmitted to the exporter VM (importer VM waits for the response.) to make sure the buffer is still valid (not unexported) on expoter VM's side before importer VM starts to use it. "delayed_ms" attribute is added to unexport ioctl, used for hardcoding delay from userspace. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c | 4 + drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 157 ++++++++++++++------- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 2 + drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 41 +++--- drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 2 + .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 2 + 6 files changed, 139 insertions(+), 69 deletions(-) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c index d7a35fc..a9bc354 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c @@ -341,6 +341,10 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme /* extract pages from sgt */ page_info = hyper_dmabuf_ext_pgs(sgt_info->sgt); + if (!page_info) { + return NULL; + } + /* create a new sg_table with extracted pages */ st = hyper_dmabuf_create_sgt(page_info->pages, page_info->frst_ofst, page_info->last_len, page_info->nents); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index b0f5b5b..018de8c 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -115,11 +115,24 @@ static int hyper_dmabuf_export_remote(void *data) 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) { + /* + * Check if unexport is already scheduled for that buffer, + * if so try to cancel it. If that will fail, buffer needs + * to be reexport once again. + */ + if (sgt_info->unexport_scheduled) { + if (!cancel_delayed_work_sync(&sgt_info->unexport_work)) { + dma_buf_put(dma_buf); + goto reexport; + } + sgt_info->unexport_scheduled = 0; + } dma_buf_put(dma_buf); export_remote_attr->hyper_dmabuf_id = ret; return 0; } +reexport: attachment = dma_buf_attach(dma_buf, hyper_dmabuf_private.device); if (!attachment) { dev_err(hyper_dmabuf_private.device, "Cannot get attachment\n"); @@ -133,7 +146,7 @@ static int hyper_dmabuf_export_remote(void *data) sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL); - sgt_info = kmalloc(sizeof(*sgt_info), GFP_KERNEL); + sgt_info = kcalloc(1, sizeof(*sgt_info), GFP_KERNEL); sgt_info->hyper_dmabuf_id = hyper_dmabuf_get_id(); @@ -141,7 +154,6 @@ static int hyper_dmabuf_export_remote(void *data) sgt_info->hyper_dmabuf_rdomain = export_remote_attr->remote_domain; sgt_info->dma_buf = dma_buf; sgt_info->valid = 1; - sgt_info->importer_exported = 0; sgt_info->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL); sgt_info->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL); @@ -245,8 +257,35 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) /* look for dmabuf for the id */ sgt_info = hyper_dmabuf_find_imported(export_fd_attr->hyper_dmabuf_id); - if (sgt_info == NULL) /* can't find sgt from the table */ + if (sgt_info == NULL || !sgt_info->valid) /* can't find sgt from the table */ + return -1; + + sgt_info->num_importers++; + + /* send notification for export_fd to exporter */ + operand = sgt_info->hyper_dmabuf_id; + + req = kcalloc(1, sizeof(*req), GFP_KERNEL); + hyper_dmabuf_create_request(req, HYPER_DMABUF_FIRST_EXPORT, &operand); + + ret = ops->send_req(HYPER_DMABUF_DOM_ID(operand), req, true); + + if (ret < 0) { + kfree(req); + dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n"); + sgt_info->num_importers--; + return -EINVAL; + } + kfree(req); + + if (ret == HYPER_DMABUF_REQ_ERROR) { + dev_err(hyper_dmabuf_private.device, + "Buffer invalid\n"); + sgt_info->num_importers--; return -1; + } else { + dev_dbg(hyper_dmabuf_private.device, "Can import buffer\n"); + } dev_dbg(hyper_dmabuf_private.device, "%s Found buffer gref %d off %d last len %d nents %d domain %d\n", __func__, @@ -262,86 +301,62 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) sgt_info->nents, &sgt_info->refs_info); + if (!data_pages) { + sgt_info->num_importers--; + return -EINVAL; + } + sgt_info->sgt = hyper_dmabuf_create_sgt(data_pages, sgt_info->frst_ofst, sgt_info->last_len, sgt_info->nents); } - /* send notification for export_fd to exporter */ - operand = sgt_info->hyper_dmabuf_id; - - req = kcalloc(1, sizeof(*req), GFP_KERNEL); - hyper_dmabuf_create_request(req, HYPER_DMABUF_FIRST_EXPORT, &operand); - - ret = ops->send_req(HYPER_DMABUF_DOM_ID(operand), req, false); - - if (!sgt_info->sgt || ret) { - kfree(req); - dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n"); - return -EINVAL; - } - kfree(req); - export_fd_attr->fd = hyper_dmabuf_export_fd(sgt_info, export_fd_attr->flags); if (export_fd_attr->fd < 0) { /* fail to get fd */ ret = export_fd_attr->fd; - } else { - sgt_info->num_importers++; } - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); - return ret; + dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + return 0; } /* unexport dmabuf from the database and send int req to the source domain * to unmap it. */ -static int hyper_dmabuf_unexport(void *data) +static void hyper_dmabuf_delayed_unexport(struct work_struct *work) { - struct ioctl_hyper_dmabuf_unexport *unexport_attr; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; - struct hyper_dmabuf_sgt_info *sgt_info; struct hyper_dmabuf_req *req; + int hyper_dmabuf_id; int ret; + struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; + struct hyper_dmabuf_sgt_info *sgt_info = + container_of(work, struct hyper_dmabuf_sgt_info, unexport_work.work); - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); - - if (!data) { - dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); - return -EINVAL; - } - - unexport_attr = (struct ioctl_hyper_dmabuf_unexport *)data; + if (!sgt_info) + return; - /* find dmabuf in export list */ - sgt_info = hyper_dmabuf_find_exported(unexport_attr->hyper_dmabuf_id); + hyper_dmabuf_id = sgt_info->hyper_dmabuf_id; - /* failed to find corresponding entry in export list */ - if (sgt_info == NULL) { - unexport_attr->status = -EINVAL; - return -EFAULT; - } + dev_dbg(hyper_dmabuf_private.device, + "Marking buffer %d as invalid\n", hyper_dmabuf_id); + /* no longer valid */ + sgt_info->valid = 0; req = kcalloc(1, sizeof(*req), GFP_KERNEL); - hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &unexport_attr->hyper_dmabuf_id); + hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &hyper_dmabuf_id); /* Now send unexport request to remote domain, marking that buffer should not be used anymore */ ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true); if (ret < 0) { - kfree(req); - return -EFAULT; + dev_err(hyper_dmabuf_private.device, "unexport message for buffer %d failed\n", hyper_dmabuf_id); } /* free msg */ kfree(req); - - dev_dbg(hyper_dmabuf_private.device, - "Marking buffer %d as invalid\n", unexport_attr->hyper_dmabuf_id); - /* no longer valid */ - sgt_info->valid = 0; + sgt_info->unexport_scheduled = 0; /* * Immediately clean-up if it has never been exported by importer @@ -352,16 +367,52 @@ static int hyper_dmabuf_unexport(void *data) */ if (!sgt_info->importer_exported) { dev_dbg(hyper_dmabuf_private.device, - "claning up buffer %d completly\n", unexport_attr->hyper_dmabuf_id); + "claning up buffer %d completly\n", hyper_dmabuf_id); hyper_dmabuf_cleanup_sgt_info(sgt_info, false); - hyper_dmabuf_remove_exported(unexport_attr->hyper_dmabuf_id); + hyper_dmabuf_remove_exported(hyper_dmabuf_id); kfree(sgt_info); /* register hyper_dmabuf_id to the list for reuse */ - store_reusable_id(unexport_attr->hyper_dmabuf_id); + store_reusable_id(hyper_dmabuf_id); } +} + +/* Schedules unexport of dmabuf. + */ +static int hyper_dmabuf_unexport(void *data) +{ + struct ioctl_hyper_dmabuf_unexport *unexport_attr; + struct hyper_dmabuf_sgt_info *sgt_info; dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); - return ret; + + if (!data) { + dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); + return -EINVAL; + } + + unexport_attr = (struct ioctl_hyper_dmabuf_unexport *)data; + + /* find dmabuf in export list */ + sgt_info = hyper_dmabuf_find_exported(unexport_attr->hyper_dmabuf_id); + + dev_dbg(hyper_dmabuf_private.device, "scheduling unexport of buffer %d\n", unexport_attr->hyper_dmabuf_id); + + /* failed to find corresponding entry in export list */ + if (sgt_info == NULL) { + unexport_attr->status = -EINVAL; + return -EFAULT; + } + + if (sgt_info->unexport_scheduled) + return 0; + + sgt_info->unexport_scheduled = 1; + INIT_DELAYED_WORK(&sgt_info->unexport_work, hyper_dmabuf_delayed_unexport); + schedule_delayed_work(&sgt_info->unexport_work, + msecs_to_jiffies(unexport_attr->delay_ms)); + + dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + return 0; } static int hyper_dmabuf_query(void *data) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h index e43a25f..558964c 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h @@ -90,6 +90,8 @@ struct ioctl_hyper_dmabuf_unexport { /* IN parameters */ /* hyper dmabuf id to be unexported */ int hyper_dmabuf_id; + /* delay in ms by which unexport processing will be postponed */ + int delay_ms; /* OUT parameters */ /* Status of request */ int status; diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c index c99176ac..dd4bb01 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c @@ -112,7 +112,6 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req, void cmd_process_work(struct work_struct *work) { - struct hyper_dmabuf_sgt_info *sgt_info; struct hyper_dmabuf_imported_sgt_info *imported_sgt_info; struct cmd_process *proc = container_of(work, struct cmd_process, work); struct hyper_dmabuf_req *req; @@ -154,19 +153,6 @@ void cmd_process_work(struct work_struct *work) 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) { - dev_err(hyper_dmabuf_private.device, - "critical err: requested sgt_info can't be found %d\n", req->operands[0]); - break; - } - - sgt_info->importer_exported++; - break; - case HYPER_DMABUF_OPS_TO_REMOTE: /* notifying dmabuf map/unmap to importer (probably not needed) */ /* for dmabuf synchronization */ @@ -187,6 +173,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) struct cmd_process *proc; struct hyper_dmabuf_req *temp_req; struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct hyper_dmabuf_sgt_info *exp_sgt_info; int ret; if (!req) { @@ -216,8 +203,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) if (sgt_info) { /* if anything is still using dma_buf */ - if (sgt_info->dma_buf && - dmabuf_refcount(sgt_info->dma_buf) > 0) { + if (sgt_info->num_importers) { /* * Buffer is still in use, just mark that it should * not be allowed to export its fd anymore. @@ -255,6 +241,29 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) return req->command; } + /* synchronous dma_buf_fd export */ + if (req->command == HYPER_DMABUF_FIRST_EXPORT) { + /* find a corresponding SGT for the id */ + exp_sgt_info = hyper_dmabuf_find_exported(req->operands[0]); + + if (!exp_sgt_info) { + dev_err(hyper_dmabuf_private.device, + "critical err: requested sgt_info can't be found %d\n", req->operands[0]); + req->status = HYPER_DMABUF_REQ_ERROR; + } else if (!exp_sgt_info->valid) { + dev_dbg(hyper_dmabuf_private.device, + "Buffer no longer valid - cannot export\n"); + req->status = HYPER_DMABUF_REQ_ERROR; + } else { + dev_dbg(hyper_dmabuf_private.device, + "Buffer still valid - can export\n"); + exp_sgt_info->importer_exported++; + req->status = HYPER_DMABUF_REQ_PROCESSED; + } + return req->command; + } + + dev_dbg(hyper_dmabuf_private.device, "%s: putting request to workqueue\n", __func__); temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h index 2a58218..a41fd0a 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h @@ -78,6 +78,8 @@ struct hyper_dmabuf_sgt_info { bool valid; int importer_exported; /* exported locally on importer's side */ void *refs_info; /* hypervisor-specific info for the references */ + struct delayed_work unexport_work; + bool unexport_scheduled; 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 ba6b126..a8cce26 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c @@ -551,6 +551,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) dev_err(hyper_dmabuf_private.device, "request timed-out\n"); return -EBUSY; } + + return req_pending.status; } return 0; -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 25/60] hyper_dmabuf: introduced delayed unexport Date: Tue, 19 Dec 2017 11:29:41 -0800 Message-ID: <1513711816-2618-25-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: In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-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 RnJvbTogTWF0ZXVzeiBQb2xyb2xhIDxtYXRldXN6eC5wb3Ryb2xhQGludGVsLmNvbT4KClRvIHBy ZXZlbnQgb3ZlcmhlYWQgd2hlbiBhIERNQSBCVUYgbmVlZHMgdG8gYmUgZXhwb3J0ZWQgcmlnaHQg YWZ0ZXIKaXQgaXMgdW5leHBvcnRlZCwgYSBtYXJnaW5hbCBkZWxheSBpcyBpbnRyb2R1Y2VkIGlu IHVuZXhwb3J0aW5nIHByb2Nlc3MuClRoaXMgYWRkcyBhIHByb2JhdGlvbiBwZXJpb2QgdG8gdGhl IHVuZXhwb3J0aW5nIHByb2Nlc3MuIElmIHRoZSBzYW1lCkRNQV9CVUYgaXMgcmVxdWVzdGVkIHRv IGJlIGV4cG9ydGVkIGFnYWdpbiwgdW5leHBvcnRpbmcgcHJvY2VzcyBpcwpjYW5jZWxlZCByaWdo dCBhd2F5IGFuZCB0aGUgYnVmZmVyIGNhbiBiZSByZXVzZWQgd2l0aG91dCBhbnkgZXh0ZW5zaXZl CnJlLWV4cG9ydGluZyBwcm9jZXNzLgoKQWRkaXRpb25hbGx5LCAiRklSU1QgRVhQT1JUIiBtZXNz YWdlIGlzIHN5bmNocm9ub3VzbHkgdHJhbnNtaXR0ZWQgdG8KdGhlIGV4cG9ydGVyIFZNIChpbXBv cnRlciBWTSB3YWl0cyBmb3IgdGhlIHJlc3BvbnNlLikgdG8gbWFrZSBzdXJlCnRoZSBidWZmZXIg aXMgc3RpbGwgdmFsaWQgKG5vdCB1bmV4cG9ydGVkKSBvbiBleHBvdGVyIFZNJ3Mgc2lkZSBiZWZv cmUKaW1wb3J0ZXIgVk0gc3RhcnRzIHRvIHVzZSBpdC4KCiJkZWxheWVkX21zIiBhdHRyaWJ1dGUg aXMgYWRkZWQgdG8gdW5leHBvcnQgaW9jdGwsIHVzZWQgZm9yIGhhcmRjb2RpbmcKZGVsYXkgZnJv bSB1c2Vyc3BhY2UuCgpTaWduZWQtb2ZmLWJ5OiBEb25nd29uIEtpbSA8ZG9uZ3dvbi5raW1AaW50 ZWwuY29tPgotLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMg ICAgICAgIHwgICA0ICsKIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9j dGwuYyAgICAgIHwgMTU3ICsrKysrKysrKysrKysrLS0tLS0tLQogZHJpdmVycy94ZW4vaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5oICAgICAgfCAgIDIgKwogZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYyAgICAgICAgfCAgNDEgKysrLS0tCiBkcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3N0cnVjdC5oICAgICB8ICAgMiArCiAuLi4v eGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMgICB8ICAgMiArCiA2 IGZpbGVzIGNoYW5nZWQsIDEzOSBpbnNlcnRpb25zKCspLCA2OSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2ltcC5jIGIvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pbXAuYwppbmRleCBkN2EzNWZjLi5h OWJjMzU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X2ltcC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMK QEAgLTM0MSw2ICszNDEsMTAgQEAgc3RhdGljIHN0cnVjdCBzZ190YWJsZSogaHlwZXJfZG1hYnVm X29wc19tYXAoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNobWUKIAkvKiBleHRyYWN0 IHBhZ2VzIGZyb20gc2d0ICovCiAJcGFnZV9pbmZvID0gaHlwZXJfZG1hYnVmX2V4dF9wZ3Moc2d0 X2luZm8tPnNndCk7CiAKKwlpZiAoIXBhZ2VfaW5mbykgeworCQlyZXR1cm4gTlVMTDsKKwl9CisK IAkvKiBjcmVhdGUgYSBuZXcgc2dfdGFibGUgd2l0aCBleHRyYWN0ZWQgcGFnZXMgKi8KIAlzdCA9 IGh5cGVyX2RtYWJ1Zl9jcmVhdGVfc2d0KHBhZ2VfaW5mby0+cGFnZXMsIHBhZ2VfaW5mby0+ZnJz dF9vZnN0LAogCQkJCXBhZ2VfaW5mby0+bGFzdF9sZW4sIHBhZ2VfaW5mby0+bmVudHMpOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jIGIv ZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jCmluZGV4IGIwZjVi NWIuLjAxOGRlOGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9k bWFidWZfaW9jdGwuYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X2lvY3RsLmMKQEAgLTExNSwxMSArMTE1LDI0IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4 cG9ydF9yZW1vdGUodm9pZCAqZGF0YSkKIAlyZXQgPSBoeXBlcl9kbWFidWZfZmluZF9pZF9leHBv cnRlZChkbWFfYnVmLCBleHBvcnRfcmVtb3RlX2F0dHItPnJlbW90ZV9kb21haW4pOwogCXNndF9p bmZvID0gaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQocmV0KTsKIAlpZiAocmV0ICE9IC0xICYm IHNndF9pbmZvLT52YWxpZCkgeworCQkvKgorCQkgKiBDaGVjayBpZiB1bmV4cG9ydCBpcyBhbHJl YWR5IHNjaGVkdWxlZCBmb3IgdGhhdCBidWZmZXIsCisJCSAqIGlmIHNvIHRyeSB0byBjYW5jZWwg aXQuIElmIHRoYXQgd2lsbCBmYWlsLCBidWZmZXIgbmVlZHMKKwkJICogdG8gYmUgcmVleHBvcnQg b25jZSBhZ2Fpbi4KKwkJICovCisJCWlmIChzZ3RfaW5mby0+dW5leHBvcnRfc2NoZWR1bGVkKSB7 CisJCQlpZiAoIWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmc2d0X2luZm8tPnVuZXhwb3J0X3dv cmspKSB7CisJCQkJZG1hX2J1Zl9wdXQoZG1hX2J1Zik7CisJCQkJZ290byByZWV4cG9ydDsKKwkJ CX0KKwkJCXNndF9pbmZvLT51bmV4cG9ydF9zY2hlZHVsZWQgPSAwOworCQl9CiAJCWRtYV9idWZf cHV0KGRtYV9idWYpOwogCQlleHBvcnRfcmVtb3RlX2F0dHItPmh5cGVyX2RtYWJ1Zl9pZCA9IHJl dDsKIAkJcmV0dXJuIDA7CiAJfQogCityZWV4cG9ydDoKIAlhdHRhY2htZW50ID0gZG1hX2J1Zl9h dHRhY2goZG1hX2J1ZiwgaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlKTsKIAlpZiAoIWF0dGFj aG1lbnQpIHsKIAkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJDYW5ub3Qg Z2V0IGF0dGFjaG1lbnRcbiIpOwpAQCAtMTMzLDcgKzE0Niw3IEBAIHN0YXRpYyBpbnQgaHlwZXJf ZG1hYnVmX2V4cG9ydF9yZW1vdGUodm9pZCAqZGF0YSkKIAogCXNndCA9IGRtYV9idWZfbWFwX2F0 dGFjaG1lbnQoYXR0YWNobWVudCwgRE1BX0JJRElSRUNUSU9OQUwpOwogCi0Jc2d0X2luZm8gPSBr bWFsbG9jKHNpemVvZigqc2d0X2luZm8pLCBHRlBfS0VSTkVMKTsKKwlzZ3RfaW5mbyA9IGtjYWxs b2MoMSwgc2l6ZW9mKCpzZ3RfaW5mbyksIEdGUF9LRVJORUwpOwogCiAJc2d0X2luZm8tPmh5cGVy X2RtYWJ1Zl9pZCA9IGh5cGVyX2RtYWJ1Zl9nZXRfaWQoKTsKIApAQCAtMTQxLDcgKzE1NCw2IEBA IHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGUodm9pZCAqZGF0YSkKIAlzZ3Rf aW5mby0+aHlwZXJfZG1hYnVmX3Jkb21haW4gPSBleHBvcnRfcmVtb3RlX2F0dHItPnJlbW90ZV9k b21haW47CiAJc2d0X2luZm8tPmRtYV9idWYgPSBkbWFfYnVmOwogCXNndF9pbmZvLT52YWxpZCA9 IDE7Ci0Jc2d0X2luZm8tPmltcG9ydGVyX2V4cG9ydGVkID0gMDsKIAogCXNndF9pbmZvLT5hY3Rp dmVfc2d0cyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBzZ3RfbGlzdCksIEdGUF9LRVJORUwpOwog CXNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgYXR0YWNo bWVudF9saXN0KSwgR0ZQX0tFUk5FTCk7CkBAIC0yNDUsOCArMjU3LDM1IEBAIHN0YXRpYyBpbnQg aHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bCh2b2lkICpkYXRhKQogCiAJLyogbG9vayBmb3Ig ZG1hYnVmIGZvciB0aGUgaWQgKi8KIAlzZ3RfaW5mbyA9IGh5cGVyX2RtYWJ1Zl9maW5kX2ltcG9y dGVkKGV4cG9ydF9mZF9hdHRyLT5oeXBlcl9kbWFidWZfaWQpOwotCWlmIChzZ3RfaW5mbyA9PSBO VUxMKSAvKiBjYW4ndCBmaW5kIHNndCBmcm9tIHRoZSB0YWJsZSAqLworCWlmIChzZ3RfaW5mbyA9 PSBOVUxMIHx8ICFzZ3RfaW5mby0+dmFsaWQpIC8qIGNhbid0IGZpbmQgc2d0IGZyb20gdGhlIHRh YmxlICovCisJCXJldHVybiAtMTsKKworCXNndF9pbmZvLT5udW1faW1wb3J0ZXJzKys7CisKKwkv KiBzZW5kIG5vdGlmaWNhdGlvbiBmb3IgZXhwb3J0X2ZkIHRvIGV4cG9ydGVyICovCisJb3BlcmFu ZCA9IHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQ7CisKKwlyZXEgPSBrY2FsbG9jKDEsIHNpemVv ZigqcmVxKSwgR0ZQX0tFUk5FTCk7CisJaHlwZXJfZG1hYnVmX2NyZWF0ZV9yZXF1ZXN0KHJlcSwg SFlQRVJfRE1BQlVGX0ZJUlNUX0VYUE9SVCwgJm9wZXJhbmQpOworCisJcmV0ID0gb3BzLT5zZW5k X3JlcShIWVBFUl9ETUFCVUZfRE9NX0lEKG9wZXJhbmQpLCByZXEsIHRydWUpOworCisJaWYgKHJl dCA8IDApIHsKKwkJa2ZyZWUocmVxKTsKKwkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5k ZXZpY2UsICJGYWlsZWQgdG8gY3JlYXRlIHNndCBvciBub3RpZnkgZXhwb3J0ZXJcbiIpOworCQlz Z3RfaW5mby0+bnVtX2ltcG9ydGVycy0tOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJa2ZyZWUo cmVxKTsKKworCWlmIChyZXQgPT0gSFlQRVJfRE1BQlVGX1JFUV9FUlJPUikgeworCQlkZXZfZXJy KGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJCSJCdWZmZXIgaW52YWxpZFxuIik7CisJ CXNndF9pbmZvLT5udW1faW1wb3J0ZXJzLS07CiAJCXJldHVybiAtMTsKKwl9IGVsc2UgeworCQlk ZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIkNhbiBpbXBvcnQgYnVmZmVyXG4i KTsKKwl9CiAKIAlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKIAkJICAiJXMg Rm91bmQgYnVmZmVyIGdyZWYgJWQgIG9mZiAlZCBsYXN0IGxlbiAlZCBuZW50cyAlZCBkb21haW4g JWRcbiIsIF9fZnVuY19fLApAQCAtMjYyLDg2ICszMDEsNjIgQEAgc3RhdGljIGludCBoeXBlcl9k bWFidWZfZXhwb3J0X2ZkX2lvY3RsKHZvaWQgKmRhdGEpCiAJCQkJCQkgICBzZ3RfaW5mby0+bmVu dHMsCiAJCQkJCQkgICAmc2d0X2luZm8tPnJlZnNfaW5mbyk7CiAKKwkJaWYgKCFkYXRhX3BhZ2Vz KSB7CisJCQlzZ3RfaW5mby0+bnVtX2ltcG9ydGVycy0tOworCQkJcmV0dXJuIC1FSU5WQUw7CisJ CX0KKwogCQlzZ3RfaW5mby0+c2d0ID0gaHlwZXJfZG1hYnVmX2NyZWF0ZV9zZ3QoZGF0YV9wYWdl cywgc2d0X2luZm8tPmZyc3Rfb2ZzdCwKIAkJCQkJCQlzZ3RfaW5mby0+bGFzdF9sZW4sIHNndF9p bmZvLT5uZW50cyk7CiAKIAl9CiAKLQkvKiBzZW5kIG5vdGlmaWNhdGlvbiBmb3IgZXhwb3J0X2Zk IHRvIGV4cG9ydGVyICovCi0Jb3BlcmFuZCA9IHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQ7Ci0K LQlyZXEgPSBrY2FsbG9jKDEsIHNpemVvZigqcmVxKSwgR0ZQX0tFUk5FTCk7Ci0JaHlwZXJfZG1h YnVmX2NyZWF0ZV9yZXF1ZXN0KHJlcSwgSFlQRVJfRE1BQlVGX0ZJUlNUX0VYUE9SVCwgJm9wZXJh bmQpOwotCi0JcmV0ID0gb3BzLT5zZW5kX3JlcShIWVBFUl9ETUFCVUZfRE9NX0lEKG9wZXJhbmQp LCByZXEsIGZhbHNlKTsKLQotCWlmICghc2d0X2luZm8tPnNndCB8fCByZXQpIHsKLQkJa2ZyZWUo cmVxKTsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJGYWlsZWQgdG8g Y3JlYXRlIHNndCBvciBub3RpZnkgZXhwb3J0ZXJcbiIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9 Ci0Ja2ZyZWUocmVxKTsKLQogCWV4cG9ydF9mZF9hdHRyLT5mZCA9IGh5cGVyX2RtYWJ1Zl9leHBv cnRfZmQoc2d0X2luZm8sIGV4cG9ydF9mZF9hdHRyLT5mbGFncyk7CiAKIAlpZiAoZXhwb3J0X2Zk X2F0dHItPmZkIDwgMCkgewogCQkvKiBmYWlsIHRvIGdldCBmZCAqLwogCQlyZXQgPSBleHBvcnRf ZmRfYXR0ci0+ZmQ7Ci0JfSBlbHNlIHsKLQkJc2d0X2luZm8tPm51bV9pbXBvcnRlcnMrKzsKIAl9 CiAKLQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIiVzIGVudHJ5XG4iLCBf X2Z1bmNfXyk7Ci0JcmV0dXJuIHJldDsKKwlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRl dmljZSwgIiVzIGV4aXRcbiIsIF9fZnVuY19fKTsKKwlyZXR1cm4gMDsKIH0KIAogLyogdW5leHBv cnQgZG1hYnVmIGZyb20gdGhlIGRhdGFiYXNlIGFuZCBzZW5kIGludCByZXEgdG8gdGhlIHNvdXJj ZSBkb21haW4KICAqIHRvIHVubWFwIGl0LgogICovCi1zdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl91 bmV4cG9ydCh2b2lkICpkYXRhKQorc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX2RlbGF5ZWRfdW5l eHBvcnQoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewotCXN0cnVjdCBpb2N0bF9oeXBlcl9k bWFidWZfdW5leHBvcnQgKnVuZXhwb3J0X2F0dHI7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNr ZW5kX29wcyAqb3BzID0gaHlwZXJfZG1hYnVmX3ByaXZhdGUuYmFja2VuZF9vcHM7Ci0Jc3RydWN0 IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm87CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9y ZXEgKnJlcTsKKwlpbnQgaHlwZXJfZG1hYnVmX2lkOwogCWludCByZXQ7CisJc3RydWN0IGh5cGVy X2RtYWJ1Zl9iYWNrZW5kX29wcyAqb3BzID0gaHlwZXJfZG1hYnVmX3ByaXZhdGUuYmFja2VuZF9v cHM7CisJc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm8gPQorCQljb250YWlu ZXJfb2Yod29yaywgc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbywgdW5leHBvcnRfd29yay53 b3JrKTsKIAotCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiJXMgZW50cnlc biIsIF9fZnVuY19fKTsKLQotCWlmICghZGF0YSkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9w cml2YXRlLmRldmljZSwgInVzZXIgZGF0YSBpcyBOVUxMXG4iKTsKLQkJcmV0dXJuIC1FSU5WQUw7 Ci0JfQotCi0JdW5leHBvcnRfYXR0ciA9IChzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3VuZXhw b3J0ICopZGF0YTsKKwlpZiAoIXNndF9pbmZvKQorCQlyZXR1cm47CiAKLQkvKiBmaW5kIGRtYWJ1 ZiBpbiBleHBvcnQgbGlzdCAqLwotCXNndF9pbmZvID0gaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0 ZWQodW5leHBvcnRfYXR0ci0+aHlwZXJfZG1hYnVmX2lkKTsKKwloeXBlcl9kbWFidWZfaWQgPSBz Z3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkOwogCi0JLyogZmFpbGVkIHRvIGZpbmQgY29ycmVzcG9u ZGluZyBlbnRyeSBpbiBleHBvcnQgbGlzdCAqLwotCWlmIChzZ3RfaW5mbyA9PSBOVUxMKSB7Ci0J CXVuZXhwb3J0X2F0dHItPnN0YXR1cyA9IC1FSU5WQUw7Ci0JCXJldHVybiAtRUZBVUxUOwotCX0K KwlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJIk1hcmtpbmcgYnVmZmVy ICVkIGFzIGludmFsaWRcbiIsIGh5cGVyX2RtYWJ1Zl9pZCk7CisJLyogbm8gbG9uZ2VyIHZhbGlk ICovCisJc2d0X2luZm8tPnZhbGlkID0gMDsKIAogCXJlcSA9IGtjYWxsb2MoMSwgc2l6ZW9mKCpy ZXEpLCBHRlBfS0VSTkVMKTsKIAotCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChyZXEsIEhZ UEVSX0RNQUJVRl9OT1RJRllfVU5FWFBPUlQsICZ1bmV4cG9ydF9hdHRyLT5oeXBlcl9kbWFidWZf aWQpOworCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChyZXEsIEhZUEVSX0RNQUJVRl9OT1RJ RllfVU5FWFBPUlQsICZoeXBlcl9kbWFidWZfaWQpOwogCiAJLyogTm93IHNlbmQgdW5leHBvcnQg cmVxdWVzdCB0byByZW1vdGUgZG9tYWluLCBtYXJraW5nIHRoYXQgYnVmZmVyIHNob3VsZCBub3Qg YmUgdXNlZCBhbnltb3JlICovCiAJcmV0ID0gb3BzLT5zZW5kX3JlcShzZ3RfaW5mby0+aHlwZXJf ZG1hYnVmX3Jkb21haW4sIHJlcSwgdHJ1ZSk7CiAJaWYgKHJldCA8IDApIHsKLQkJa2ZyZWUocmVx KTsKLQkJcmV0dXJuIC1FRkFVTFQ7CisJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2 aWNlLCAidW5leHBvcnQgbWVzc2FnZSBmb3IgYnVmZmVyICVkIGZhaWxlZFxuIiwgaHlwZXJfZG1h YnVmX2lkKTsKIAl9CiAKIAkvKiBmcmVlIG1zZyAqLwogCWtmcmVlKHJlcSk7Ci0KLQlkZXZfZGJn KGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJIk1hcmtpbmcgYnVmZmVyICVkIGFzIGlu dmFsaWRcbiIsIHVuZXhwb3J0X2F0dHItPmh5cGVyX2RtYWJ1Zl9pZCk7Ci0JLyogbm8gbG9uZ2Vy IHZhbGlkICovCi0Jc2d0X2luZm8tPnZhbGlkID0gMDsKKwlzZ3RfaW5mby0+dW5leHBvcnRfc2No ZWR1bGVkID0gMDsKIAogCS8qCiAJICogSW1tZWRpYXRlbHkgY2xlYW4tdXAgaWYgaXQgaGFzIG5l dmVyIGJlZW4gZXhwb3J0ZWQgYnkgaW1wb3J0ZXIKQEAgLTM1MiwxNiArMzY3LDUyIEBAIHN0YXRp YyBpbnQgaHlwZXJfZG1hYnVmX3VuZXhwb3J0KHZvaWQgKmRhdGEpCiAJICovCiAJaWYgKCFzZ3Rf aW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQpIHsKIAkJZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsCi0JCQkiY2xhbmluZyB1cCBidWZmZXIgJWQgY29tcGxldGx5XG4iLCB1bmV4cG9y dF9hdHRyLT5oeXBlcl9kbWFidWZfaWQpOworCQkJImNsYW5pbmcgdXAgYnVmZmVyICVkIGNvbXBs ZXRseVxuIiwgaHlwZXJfZG1hYnVmX2lkKTsKIAkJaHlwZXJfZG1hYnVmX2NsZWFudXBfc2d0X2lu Zm8oc2d0X2luZm8sIGZhbHNlKTsKLQkJaHlwZXJfZG1hYnVmX3JlbW92ZV9leHBvcnRlZCh1bmV4 cG9ydF9hdHRyLT5oeXBlcl9kbWFidWZfaWQpOworCQloeXBlcl9kbWFidWZfcmVtb3ZlX2V4cG9y dGVkKGh5cGVyX2RtYWJ1Zl9pZCk7CiAJCWtmcmVlKHNndF9pbmZvKTsKIAkJLyogcmVnaXN0ZXIg aHlwZXJfZG1hYnVmX2lkIHRvIHRoZSBsaXN0IGZvciByZXVzZSAqLwotCQlzdG9yZV9yZXVzYWJs ZV9pZCh1bmV4cG9ydF9hdHRyLT5oeXBlcl9kbWFidWZfaWQpOworCQlzdG9yZV9yZXVzYWJsZV9p ZChoeXBlcl9kbWFidWZfaWQpOwogCX0KK30KKworLyogU2NoZWR1bGVzIHVuZXhwb3J0IG9mIGRt YWJ1Zi4KKyAqLworc3RhdGljIGludCBoeXBlcl9kbWFidWZfdW5leHBvcnQodm9pZCAqZGF0YSkK K3sKKwlzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3VuZXhwb3J0ICp1bmV4cG9ydF9hdHRyOwor CXN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gKnNndF9pbmZvOwogCiAJZGV2X2RiZyhoeXBl cl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICIlcyBlbnRyeVxuIiwgX19mdW5jX18pOwotCXJldHVy biByZXQ7CisKKwlpZiAoIWRhdGEpIHsKKwkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5k ZXZpY2UsICJ1c2VyIGRhdGEgaXMgTlVMTFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwor CXVuZXhwb3J0X2F0dHIgPSAoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl91bmV4cG9ydCAqKWRh dGE7CisKKwkvKiBmaW5kIGRtYWJ1ZiBpbiBleHBvcnQgbGlzdCAqLworCXNndF9pbmZvID0gaHlw ZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQodW5leHBvcnRfYXR0ci0+aHlwZXJfZG1hYnVmX2lkKTsK KworCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAic2NoZWR1bGluZyB1bmV4 cG9ydCBvZiBidWZmZXIgJWRcbiIsIHVuZXhwb3J0X2F0dHItPmh5cGVyX2RtYWJ1Zl9pZCk7CisK KwkvKiBmYWlsZWQgdG8gZmluZCBjb3JyZXNwb25kaW5nIGVudHJ5IGluIGV4cG9ydCBsaXN0ICov CisJaWYgKHNndF9pbmZvID09IE5VTEwpIHsKKwkJdW5leHBvcnRfYXR0ci0+c3RhdHVzID0gLUVJ TlZBTDsKKwkJcmV0dXJuIC1FRkFVTFQ7CisJfQorCisJaWYgKHNndF9pbmZvLT51bmV4cG9ydF9z Y2hlZHVsZWQpCisJCXJldHVybiAwOworCisJc2d0X2luZm8tPnVuZXhwb3J0X3NjaGVkdWxlZCA9 IDE7CisJSU5JVF9ERUxBWUVEX1dPUksoJnNndF9pbmZvLT51bmV4cG9ydF93b3JrLCBoeXBlcl9k bWFidWZfZGVsYXllZF91bmV4cG9ydCk7CisJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZzZ3RfaW5m by0+dW5leHBvcnRfd29yaywKKwkJCSAgICAgIG1zZWNzX3RvX2ppZmZpZXModW5leHBvcnRfYXR0 ci0+ZGVsYXlfbXMpKTsKKworCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAi JXMgZXhpdFxuIiwgX19mdW5jX18pOworCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IGh5cGVy X2RtYWJ1Zl9xdWVyeSh2b2lkICpkYXRhKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5oIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5 cGVyX2RtYWJ1Zl9pb2N0bC5oCmluZGV4IGU0M2EyNWYuLjU1ODk2NGMgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuaAorKysgYi9kcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmgKQEAgLTkwLDYgKzkwLDggQEAg c3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl91bmV4cG9ydCB7CiAJLyogSU4gcGFyYW1ldGVycyAq LwogCS8qIGh5cGVyIGRtYWJ1ZiBpZCB0byBiZSB1bmV4cG9ydGVkICovCiAJaW50IGh5cGVyX2Rt YWJ1Zl9pZDsKKwkvKiBkZWxheSBpbiBtcyBieSB3aGljaCB1bmV4cG9ydCBwcm9jZXNzaW5nIHdp bGwgYmUgcG9zdHBvbmVkICovCisJaW50IGRlbGF5X21zOwogCS8qIE9VVCBwYXJhbWV0ZXJzICov CiAJLyogU3RhdHVzIG9mIHJlcXVlc3QgKi8KIAlpbnQgc3RhdHVzOwpkaWZmIC0tZ2l0IGEvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYyBiL2RyaXZlcnMveGVuL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMKaW5kZXggYzk5MTc2YWMuLmRkNGJiMDEgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMKKysr IGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYwpAQCAtMTEyLDcg KzExMiw2IEBAIHZvaWQgaHlwZXJfZG1hYnVmX2NyZWF0ZV9yZXF1ZXN0KHN0cnVjdCBoeXBlcl9k bWFidWZfcmVxICpyZXEsCiAKIHZvaWQgY21kX3Byb2Nlc3Nfd29yayhzdHJ1Y3Qgd29ya19zdHJ1 Y3QgKndvcmspCiB7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0X2luZm87CiAJ c3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWRfc2d0X2luZm87 CiAJc3RydWN0IGNtZF9wcm9jZXNzICpwcm9jID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBj bWRfcHJvY2Vzcywgd29yayk7CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcTsKQEAgLTE1 NCwxOSArMTUzLDYgQEAgdm9pZCBjbWRfcHJvY2Vzc193b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAq d29yaykKIAkJaHlwZXJfZG1hYnVmX3JlZ2lzdGVyX2ltcG9ydGVkKGltcG9ydGVkX3NndF9pbmZv KTsKIAkJYnJlYWs7CiAKLQljYXNlIEhZUEVSX0RNQUJVRl9GSVJTVF9FWFBPUlQ6Ci0JCS8qIGZp bmQgYSBjb3JyZXNwb25kaW5nIFNHVCBmb3IgdGhlIGlkICovCi0JCXNndF9pbmZvID0gaHlwZXJf ZG1hYnVmX2ZpbmRfZXhwb3J0ZWQocmVxLT5vcGVyYW5kc1swXSk7Ci0KLQkJaWYgKCFzZ3RfaW5m bykgewotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkJImNyaXRp Y2FsIGVycjogcmVxdWVzdGVkIHNndF9pbmZvIGNhbid0IGJlIGZvdW5kICVkXG4iLCByZXEtPm9w ZXJhbmRzWzBdKTsKLQkJCWJyZWFrOwotCQl9Ci0KLQkJc2d0X2luZm8tPmltcG9ydGVyX2V4cG9y dGVkKys7Ci0JCWJyZWFrOwotCiAJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX1RPX1JFTU9URToKIAkJ Lyogbm90aWZ5aW5nIGRtYWJ1ZiBtYXAvdW5tYXAgdG8gaW1wb3J0ZXIgKHByb2JhYmx5IG5vdCBu ZWVkZWQpICovCiAJCS8qIGZvciBkbWFidWYgc3luY2hyb25pemF0aW9uICovCkBAIC0xODcsNiAr MTczLDcgQEAgaW50IGh5cGVyX2RtYWJ1Zl9tc2dfcGFyc2UoaW50IGRvbWlkLCBzdHJ1Y3QgaHlw ZXJfZG1hYnVmX3JlcSAqcmVxKQogCXN0cnVjdCBjbWRfcHJvY2VzcyAqcHJvYzsKIAlzdHJ1Y3Qg aHlwZXJfZG1hYnVmX3JlcSAqdGVtcF9yZXE7CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRl ZF9zZ3RfaW5mbyAqc2d0X2luZm87CisJc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqZXhw X3NndF9pbmZvOwogCWludCByZXQ7CiAKIAlpZiAoIXJlcSkgewpAQCAtMjE2LDggKzIwMyw3IEBA IGludCBoeXBlcl9kbWFidWZfbXNnX3BhcnNlKGludCBkb21pZCwgc3RydWN0IGh5cGVyX2RtYWJ1 Zl9yZXEgKnJlcSkKIAogCQlpZiAoc2d0X2luZm8pIHsKIAkJCS8qIGlmIGFueXRoaW5nIGlzIHN0 aWxsIHVzaW5nIGRtYV9idWYgKi8KLQkJCWlmIChzZ3RfaW5mby0+ZG1hX2J1ZiAmJgotCQkJICAg IGRtYWJ1Zl9yZWZjb3VudChzZ3RfaW5mby0+ZG1hX2J1ZikgPiAwKSB7CisJCQlpZiAoc2d0X2lu Zm8tPm51bV9pbXBvcnRlcnMpIHsKIAkJCQkvKgogCQkJCSAqIEJ1ZmZlciBpcyBzdGlsbCBpbiAg dXNlLCBqdXN0IG1hcmsgdGhhdCBpdCBzaG91bGQKIAkJCQkgKiBub3QgYmUgYWxsb3dlZCB0byBl eHBvcnQgaXRzIGZkIGFueW1vcmUuCkBAIC0yNTUsNiArMjQxLDI5IEBAIGludCBoeXBlcl9kbWFi dWZfbXNnX3BhcnNlKGludCBkb21pZCwgc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcSkKIAkJ cmV0dXJuIHJlcS0+Y29tbWFuZDsKIAl9CiAKKwkvKiBzeW5jaHJvbm91cyBkbWFfYnVmX2ZkIGV4 cG9ydCAqLworCWlmIChyZXEtPmNvbW1hbmQgPT0gSFlQRVJfRE1BQlVGX0ZJUlNUX0VYUE9SVCkg eworCQkvKiBmaW5kIGEgY29ycmVzcG9uZGluZyBTR1QgZm9yIHRoZSBpZCAqLworCQlleHBfc2d0 X2luZm8gPSBoeXBlcl9kbWFidWZfZmluZF9leHBvcnRlZChyZXEtPm9wZXJhbmRzWzBdKTsKKwor CQlpZiAoIWV4cF9zZ3RfaW5mbykgeworCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5k ZXZpY2UsCisJCQkJImNyaXRpY2FsIGVycjogcmVxdWVzdGVkIHNndF9pbmZvIGNhbid0IGJlIGZv dW5kICVkXG4iLCByZXEtPm9wZXJhbmRzWzBdKTsKKwkJCXJlcS0+c3RhdHVzID0gSFlQRVJfRE1B QlVGX1JFUV9FUlJPUjsKKwkJfSBlbHNlIGlmICghZXhwX3NndF9pbmZvLT52YWxpZCkgeworCQkJ ZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCQkJIkJ1ZmZlciBubyBsb25n ZXIgdmFsaWQgLSBjYW5ub3QgZXhwb3J0XG4iKTsKKwkJCXJlcS0+c3RhdHVzID0gSFlQRVJfRE1B QlVGX1JFUV9FUlJPUjsKKwkJfSBlbHNlIHsKKwkJCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZh dGUuZGV2aWNlLAorCQkJCSJCdWZmZXIgc3RpbGwgdmFsaWQgLSBjYW4gZXhwb3J0XG4iKTsKKwkJ CWV4cF9zZ3RfaW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQrKzsKKwkJCXJlcS0+c3RhdHVzID0gSFlQ RVJfRE1BQlVGX1JFUV9QUk9DRVNTRUQ7CisJCX0KKwkJcmV0dXJuIHJlcS0+Y29tbWFuZDsKKwl9 CisKKwogCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAogCQkiJXM6IHB1dHRp bmcgcmVxdWVzdCB0byB3b3JrcXVldWVcbiIsIF9fZnVuY19fKTsKIAl0ZW1wX3JlcSA9IGttYWxs b2Moc2l6ZW9mKCp0ZW1wX3JlcSksIEdGUF9LRVJORUwpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94 ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaCBiL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmgKaW5kZXggMmE1ODIxOC4uYTQxZmQwYSAxMDA2 NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaAor KysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3N0cnVjdC5oCkBAIC03 OCw2ICs3OCw4IEBAIHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gewogCWJvb2wgdmFsaWQ7 CiAJaW50IGltcG9ydGVyX2V4cG9ydGVkOyAvKiBleHBvcnRlZCBsb2NhbGx5IG9uIGltcG9ydGVy J3Mgc2lkZSAqLwogCXZvaWQgKnJlZnNfaW5mbzsgLyogaHlwZXJ2aXNvci1zcGVjaWZpYyBpbmZv IGZvciB0aGUgcmVmZXJlbmNlcyAqLworCXN0cnVjdCBkZWxheWVkX3dvcmsgdW5leHBvcnRfd29y azsKKwlib29sIHVuZXhwb3J0X3NjaGVkdWxlZDsKIAlpbnQgcHJpdmF0ZVs0XTsgLyogZGV2aWNl IHNwZWNpZmljIGluZm8gKGUuZy4gaW1hZ2UncyBtZXRhIGluZm8/KSAqLwogfTsKIApkaWZmIC0t Z2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0u YyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMK aW5kZXggYmE2YjEyNi4uYThjY2UyNiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9k bWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5jCkBAIC01NTEsNiArNTUxLDggQEAgaW50 IGh5cGVyX2RtYWJ1Zl94ZW5fc2VuZF9yZXEoaW50IGRvbWlkLCBzdHJ1Y3QgaHlwZXJfZG1hYnVm X3JlcSAqcmVxLCBpbnQgd2FpdCkKIAkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2 aWNlLCAicmVxdWVzdCB0aW1lZC1vdXRcbiIpOwogCQkJcmV0dXJuIC1FQlVTWTsKIAkJfQorCisJ CXJldHVybiByZXFfcGVuZGluZy5zdGF0dXM7CiAJfQogCiAJcmV0dXJuIDA7Ci0tIAoyLjcuNAoK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZl bCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlz dHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw=