From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753511AbdLSTi4 (ORCPT ); Tue, 19 Dec 2017 14:38:56 -0500 Received: from mga11.intel.com ([192.55.52.93]:27382 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753183AbdLSThJ (ORCPT ); Tue, 19 Dec 2017 14:37:09 -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="4018678" 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 54/60] hyper_dmabuf: 'backend_ops' reduced to 'bknd_ops' and 'ops' to 'bknd_ops' Date: Tue, 19 Dec 2017 11:30:10 -0800 Message-Id: <1513711816-2618-54-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 To make type's name compact, *_backend_ops is changed to '*_bknd_ops'. Also 'ops' is now changed to 'bknd_ops' to clarify it is a data structure with entry points of 'backend' operations. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 14 +++++------ drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 4 ++-- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 28 +++++++++++----------- drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c | 10 ++++---- drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c | 4 ++-- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c | 2 +- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h | 2 +- 7 files changed, 33 insertions(+), 31 deletions(-) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c index 387cc63..161fee7 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c @@ -276,13 +276,13 @@ static int __init hyper_dmabuf_drv_init(void) /* currently only supports XEN hypervisor */ #ifdef CONFIG_HYPER_DMABUF_XEN - hy_drv_priv->backend_ops = &xen_backend_ops; + hy_drv_priv->bknd_ops = &xen_bknd_ops; #else - hy_drv_priv->backend_ops = NULL; + hy_drv_priv->bknd_ops = NULL; printk(KERN_ERR "hyper_dmabuf drv currently supports XEN only.\n"); #endif - if (hy_drv_priv->backend_ops == NULL) { + if (hy_drv_priv->bknd_ops == NULL) { printk(KERN_ERR "Hyper_dmabuf: no backend found\n"); return -1; } @@ -301,7 +301,7 @@ static int __init hyper_dmabuf_drv_init(void) ret = hyper_dmabuf_table_init(); if (ret < 0) { dev_err(hy_drv_priv->dev, - "failed to initialize table for exported/imported entries\n"); + "fail to init table for exported/imported entries\n"); mutex_unlock(&hy_drv_priv->lock); kfree(hy_drv_priv); return ret; @@ -330,9 +330,9 @@ static int __init hyper_dmabuf_drv_init(void) hy_drv_priv->pending = 0; #endif - hy_drv_priv->domid = hy_drv_priv->backend_ops->get_vm_id(); + hy_drv_priv->domid = hy_drv_priv->bknd_ops->get_vm_id(); - ret = hy_drv_priv->backend_ops->init_comm_env(); + ret = hy_drv_priv->bknd_ops->init_comm_env(); if (ret < 0) { dev_dbg(hy_drv_priv->dev, "failed to initialize comm-env.\n"); @@ -360,7 +360,7 @@ static void hyper_dmabuf_drv_exit(void) /* hash tables for export/import entries and ring_infos */ hyper_dmabuf_table_destroy(); - hy_drv_priv->backend_ops->destroy_comm(); + hy_drv_priv->bknd_ops->destroy_comm(); /* destroy workqueue */ if (hy_drv_priv->work_queue) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h index 049c694..4a51f9e 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h @@ -48,7 +48,7 @@ struct hyper_dmabuf_private { struct list_reusable_id *id_queue; /* backend ops - hypervisor specific */ - struct hyper_dmabuf_backend_ops *backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops; /* device global lock */ /* TODO: might need a lock per resource (e.g. EXPORT LIST) */ @@ -72,7 +72,7 @@ struct list_reusable_id { struct list_head list; }; -struct hyper_dmabuf_backend_ops { +struct hyper_dmabuf_bknd_ops { /* retreiving id of current virtual machine */ int (*get_vm_id)(void); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index d11f609..d1970c8 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -44,7 +44,7 @@ static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data) { struct ioctl_hyper_dmabuf_tx_ch_setup *tx_ch_attr; - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; int ret = 0; if (!data) { @@ -53,7 +53,7 @@ static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data) } tx_ch_attr = (struct ioctl_hyper_dmabuf_tx_ch_setup *)data; - ret = ops->init_tx_ch(tx_ch_attr->remote_domain); + ret = bknd_ops->init_tx_ch(tx_ch_attr->remote_domain); return ret; } @@ -61,7 +61,7 @@ static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data) static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data) { struct ioctl_hyper_dmabuf_rx_ch_setup *rx_ch_attr; - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; int ret = 0; if (!data) { @@ -71,7 +71,7 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data) rx_ch_attr = (struct ioctl_hyper_dmabuf_rx_ch_setup *)data; - ret = ops->init_rx_ch(rx_ch_attr->source_domain); + ret = bknd_ops->init_rx_ch(rx_ch_attr->source_domain); return ret; } @@ -79,7 +79,7 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data) static int send_export_msg(struct exported_sgt_info *exported, struct pages_info *pg_info) { - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; struct hyper_dmabuf_req *req; int op[MAX_NUMBER_OF_OPERANDS] = {0}; int ret, i; @@ -94,7 +94,7 @@ static int send_export_msg(struct exported_sgt_info *exported, op[4] = pg_info->nents; op[5] = pg_info->frst_ofst; op[6] = pg_info->last_len; - op[7] = ops->share_pages(pg_info->pgs, exported->rdomid, + op[7] = bknd_ops->share_pages(pg_info->pgs, exported->rdomid, pg_info->nents, &exported->refs_info); if (op[7] < 0) { dev_err(hy_drv_priv->dev, "pages sharing failed\n"); @@ -115,7 +115,7 @@ static int send_export_msg(struct exported_sgt_info *exported, /* composing a message to the importer */ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT, &op[0]); - ret = ops->send_req(exported->rdomid, req, true); + ret = bknd_ops->send_req(exported->rdomid, req, true); kfree(req); @@ -423,7 +423,7 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) { struct ioctl_hyper_dmabuf_export_fd *export_fd_attr = (struct ioctl_hyper_dmabuf_export_fd *)data; - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; struct imported_sgt_info *imported; struct hyper_dmabuf_req *req; struct page **data_pgs; @@ -465,7 +465,7 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD, &op[0]); - ret = ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, true); + ret = bknd_ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, true); if (ret < 0) { /* in case of timeout other end eventually will receive request, @@ -473,7 +473,7 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) */ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]); - ops->send_req(op[0], req, false); + bknd_ops->send_req(op[0], req, false); kfree(req); dev_err(hy_drv_priv->dev, "Failed to create sgt or notify exporter\n"); @@ -512,7 +512,7 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1], imported->hid.rng_key[2]); - data_pgs = ops->map_shared_pages(imported->ref_handle, + data_pgs = bknd_ops->map_shared_pages(imported->ref_handle, HYPER_DMABUF_DOM_ID(imported->hid), imported->nents, &imported->refs_info); @@ -536,7 +536,7 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]); - ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, + bknd_ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, false); kfree(req); mutex_unlock(&hy_drv_priv->lock); @@ -570,7 +570,7 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) static void delayed_unexport(struct work_struct *work) { struct hyper_dmabuf_req *req; - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; struct exported_sgt_info *exported = container_of(work, struct exported_sgt_info, unexport.work); int op[4]; @@ -602,7 +602,7 @@ static void delayed_unexport(struct work_struct *work) /* Now send unexport request to remote domain, marking * that buffer should not be used anymore */ - ret = ops->send_req(exported->rdomid, req, true); + ret = bknd_ops->send_req(exported->rdomid, req, true); if (ret < 0) { dev_err(hy_drv_priv->dev, "unexport message for buffer {id:%d key:%d %d %d} failed\n", diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c index bf805b1..e85f619 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c @@ -52,7 +52,7 @@ static int dmabuf_refcount(struct dma_buf *dma_buf) static int sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops) { struct hyper_dmabuf_req *req; - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; int op[5]; int i; int ret; @@ -72,7 +72,8 @@ static int sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops) hyper_dmabuf_create_req(req, HYPER_DMABUF_OPS_TO_SOURCE, &op[0]); /* send request and wait for a response */ - ret = ops->send_req(HYPER_DMABUF_DOM_ID(hid), req, WAIT_AFTER_SYNC_REQ); + ret = bknd_ops->send_req(HYPER_DMABUF_DOM_ID(hid), req, + WAIT_AFTER_SYNC_REQ); if (ret < 0) { dev_dbg(hy_drv_priv->dev, @@ -186,7 +187,7 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment, static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf) { struct imported_sgt_info *imported; - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; int ret; int finish; @@ -201,7 +202,8 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf) imported->importers--; if (imported->importers == 0) { - ops->unmap_shared_pages(&imported->refs_info, imported->nents); + bknd_ops->unmap_shared_pages(&imported->refs_info, + imported->nents); if (imported->sgt) { sg_free_table(imported->sgt); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c index 9ad7ab9..d15eb17 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c @@ -170,7 +170,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported, struct attachment_list *attachl; struct kmap_vaddr_list *va_kmapl; struct vmap_vaddr_list *va_vmapl; - struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct hyper_dmabuf_bknd_ops *bknd_ops = hy_drv_priv->bknd_ops; if (!exported) { dev_err(hy_drv_priv->dev, "invalid hyper_dmabuf_id\n"); @@ -231,7 +231,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported, } /* Start cleanup of buffer in reverse order to exporting */ - ops->unshare_pages(&exported->refs_info, exported->nents); + bknd_ops->unshare_pages(&exported->refs_info, exported->nents); /* unmap dma-buf */ dma_buf_unmap_attachment(exported->active_attached->attach, diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c index 23965b8..1d7249d 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c @@ -30,7 +30,7 @@ #include "hyper_dmabuf_xen_comm.h" #include "hyper_dmabuf_xen_shm.h" -struct hyper_dmabuf_backend_ops xen_backend_ops = { +struct hyper_dmabuf_bknd_ops xen_bknd_ops = { .get_vm_id = xen_be_get_domid, .share_pages = xen_be_share_pages, .unshare_pages = xen_be_unshare_pages, diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h index e5bff09..a4902b7 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h @@ -26,7 +26,7 @@ #define __HYPER_DMABUF_XEN_DRV_H__ #include -extern struct hyper_dmabuf_backend_ops xen_backend_ops; +extern struct hyper_dmabuf_bknd_ops xen_bknd_ops; /* Main purpose of this structure is to keep * all references created or acquired for sharing -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 54/60] hyper_dmabuf: 'backend_ops' reduced to 'bknd_ops' and 'ops' to 'bknd_ops' Date: Tue, 19 Dec 2017 11:30:10 -0800 Message-ID: <1513711816-2618-54-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 VG8gbWFrZSB0eXBlJ3MgbmFtZSBjb21wYWN0LCAqX2JhY2tlbmRfb3BzIGlzIGNoYW5nZWQgdG8g JypfYmtuZF9vcHMnLiBBbHNvCidvcHMnIGlzIG5vdyBjaGFuZ2VkIHRvICdia25kX29wcycgdG8g Y2xhcmlmeSBpdCBpcyBhIGRhdGEgc3RydWN0dXJlIHdpdGgKZW50cnkgcG9pbnRzIG9mICdiYWNr ZW5kJyBvcGVyYXRpb25zLgoKU2lnbmVkLW9mZi1ieTogRG9uZ3dvbiBLaW0gPGRvbmd3b24ua2lt QGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Ry di5jICAgICAgICB8IDE0ICsrKysrLS0tLS0tCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlw ZXJfZG1hYnVmX2Rydi5oICAgICAgICB8ICA0ICsrLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi9oeXBlcl9kbWFidWZfaW9jdGwuYyAgICAgIHwgMjggKysrKysrKysrKystLS0tLS0tLS0tLQog ZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9vcHMuYyAgICAgICAgfCAxMCAr KysrLS0tLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zZ2xfcHJvYy5j ICAgfCAgNCArKy0tCiAuLi4veGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9k cnYuYyAgICB8ICAyICstCiAuLi4veGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hl bl9kcnYuaCAgICB8ICAyICstCiA3IGZpbGVzIGNoYW5nZWQsIDMzIGluc2VydGlvbnMoKyksIDMx IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfZHJ2LmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Ry di5jCmluZGV4IDM4N2NjNjMuLjE2MWZlZTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVm L2h5cGVyX2RtYWJ1Zl9kcnYuYwpAQCAtMjc2LDEzICsyNzYsMTMgQEAgc3RhdGljIGludCBfX2lu aXQgaHlwZXJfZG1hYnVmX2Rydl9pbml0KHZvaWQpCiAKIC8qIGN1cnJlbnRseSBvbmx5IHN1cHBv cnRzIFhFTiBoeXBlcnZpc29yICovCiAjaWZkZWYgQ09ORklHX0hZUEVSX0RNQUJVRl9YRU4KLQlo eV9kcnZfcHJpdi0+YmFja2VuZF9vcHMgPSAmeGVuX2JhY2tlbmRfb3BzOworCWh5X2Rydl9wcml2 LT5ia25kX29wcyA9ICZ4ZW5fYmtuZF9vcHM7CiAjZWxzZQotCWh5X2Rydl9wcml2LT5iYWNrZW5k X29wcyA9IE5VTEw7CisJaHlfZHJ2X3ByaXYtPmJrbmRfb3BzID0gTlVMTDsKIAlwcmludGsoS0VS Tl9FUlIgImh5cGVyX2RtYWJ1ZiBkcnYgY3VycmVudGx5IHN1cHBvcnRzIFhFTiBvbmx5LlxuIik7 CiAjZW5kaWYKIAotCWlmIChoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHMgPT0gTlVMTCkgeworCWlm IChoeV9kcnZfcHJpdi0+YmtuZF9vcHMgPT0gTlVMTCkgewogCQlwcmludGsoS0VSTl9FUlIgIkh5 cGVyX2RtYWJ1Zjogbm8gYmFja2VuZCBmb3VuZFxuIik7CiAJCXJldHVybiAtMTsKIAl9CkBAIC0z MDEsNyArMzAxLDcgQEAgc3RhdGljIGludCBfX2luaXQgaHlwZXJfZG1hYnVmX2Rydl9pbml0KHZv aWQpCiAJcmV0ID0gaHlwZXJfZG1hYnVmX3RhYmxlX2luaXQoKTsKIAlpZiAocmV0IDwgMCkgewog CQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCi0JCQkiZmFpbGVkIHRvIGluaXRpYWxpemUgdGFi bGUgZm9yIGV4cG9ydGVkL2ltcG9ydGVkIGVudHJpZXNcbiIpOworCQkJImZhaWwgdG8gaW5pdCB0 YWJsZSBmb3IgZXhwb3J0ZWQvaW1wb3J0ZWQgZW50cmllc1xuIik7CiAJCW11dGV4X3VubG9jaygm aHlfZHJ2X3ByaXYtPmxvY2spOwogCQlrZnJlZShoeV9kcnZfcHJpdik7CiAJCXJldHVybiByZXQ7 CkBAIC0zMzAsOSArMzMwLDkgQEAgc3RhdGljIGludCBfX2luaXQgaHlwZXJfZG1hYnVmX2Rydl9p bml0KHZvaWQpCiAJaHlfZHJ2X3ByaXYtPnBlbmRpbmcgPSAwOwogI2VuZGlmCiAKLQloeV9kcnZf cHJpdi0+ZG9taWQgPSBoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHMtPmdldF92bV9pZCgpOworCWh5 X2Rydl9wcml2LT5kb21pZCA9IGh5X2Rydl9wcml2LT5ia25kX29wcy0+Z2V0X3ZtX2lkKCk7CiAK LQlyZXQgPSBoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHMtPmluaXRfY29tbV9lbnYoKTsKKwlyZXQg PSBoeV9kcnZfcHJpdi0+YmtuZF9vcHMtPmluaXRfY29tbV9lbnYoKTsKIAlpZiAocmV0IDwgMCkg ewogCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiZmFpbGVkIHRvIGluaXRpYWxpemUg Y29tbS1lbnYuXG4iKTsKQEAgLTM2MCw3ICszNjAsNyBAQCBzdGF0aWMgdm9pZCBoeXBlcl9kbWFi dWZfZHJ2X2V4aXQodm9pZCkKIAkvKiBoYXNoIHRhYmxlcyBmb3IgZXhwb3J0L2ltcG9ydCBlbnRy aWVzIGFuZCByaW5nX2luZm9zICovCiAJaHlwZXJfZG1hYnVmX3RhYmxlX2Rlc3Ryb3koKTsKIAot CWh5X2Rydl9wcml2LT5iYWNrZW5kX29wcy0+ZGVzdHJveV9jb21tKCk7CisJaHlfZHJ2X3ByaXYt PmJrbmRfb3BzLT5kZXN0cm95X2NvbW0oKTsKIAogCS8qIGRlc3Ryb3kgd29ya3F1ZXVlICovCiAJ aWYgKGh5X2Rydl9wcml2LT53b3JrX3F1ZXVlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuaCBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9o eXBlcl9kbWFidWZfZHJ2LmgKaW5kZXggMDQ5YzY5NC4uNGE1MWY5ZSAxMDA2NDQKLS0tIGEvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuaAorKysgYi9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5oCkBAIC00OCw3ICs0OCw3IEBAIHN0cnVj dCBoeXBlcl9kbWFidWZfcHJpdmF0ZSB7CiAJc3RydWN0IGxpc3RfcmV1c2FibGVfaWQgKmlkX3F1 ZXVlOwogCiAJLyogYmFja2VuZCBvcHMgLSBoeXBlcnZpc29yIHNwZWNpZmljICovCi0Jc3RydWN0 IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAqYmFja2VuZF9vcHM7CisJc3RydWN0IGh5cGVyX2Rt YWJ1Zl9ia25kX29wcyAqYmtuZF9vcHM7CiAKIAkvKiBkZXZpY2UgZ2xvYmFsIGxvY2sgKi8KIAkv KiBUT0RPOiBtaWdodCBuZWVkIGEgbG9jayBwZXIgcmVzb3VyY2UgKGUuZy4gRVhQT1JUIExJU1Qp ICovCkBAIC03Miw3ICs3Miw3IEBAIHN0cnVjdCBsaXN0X3JldXNhYmxlX2lkIHsKIAlzdHJ1Y3Qg bGlzdF9oZWFkIGxpc3Q7CiB9OwogCi1zdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tlbmRfb3BzIHsK K3N0cnVjdCBoeXBlcl9kbWFidWZfYmtuZF9vcHMgewogCS8qIHJldHJlaXZpbmcgaWQgb2YgY3Vy cmVudCB2aXJ0dWFsIG1hY2hpbmUgKi8KIAlpbnQgKCpnZXRfdm1faWQpKHZvaWQpOwogCmRpZmYg LS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMgYi9k cml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKaW5kZXggZDExZjYw OS4uZDE5NzBjOCAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2Rt YWJ1Zl9pb2N0bC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZf aW9jdGwuYwpAQCAtNDQsNyArNDQsNyBAQAogc3RhdGljIGludCBoeXBlcl9kbWFidWZfdHhfY2hf c2V0dXBfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRhdGEpCiB7CiAJc3RydWN0IGlv Y3RsX2h5cGVyX2RtYWJ1Zl90eF9jaF9zZXR1cCAqdHhfY2hfYXR0cjsKLQlzdHJ1Y3QgaHlwZXJf ZG1hYnVmX2JhY2tlbmRfb3BzICpvcHMgPSBoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHM7CisJc3Ry dWN0IGh5cGVyX2RtYWJ1Zl9ia25kX29wcyAqYmtuZF9vcHMgPSBoeV9kcnZfcHJpdi0+YmtuZF9v cHM7CiAJaW50IHJldCA9IDA7CiAKIAlpZiAoIWRhdGEpIHsKQEAgLTUzLDcgKzUzLDcgQEAgc3Rh dGljIGludCBoeXBlcl9kbWFidWZfdHhfY2hfc2V0dXBfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAs IHZvaWQgKmRhdGEpCiAJfQogCXR4X2NoX2F0dHIgPSAoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1 Zl90eF9jaF9zZXR1cCAqKWRhdGE7CiAKLQlyZXQgPSBvcHMtPmluaXRfdHhfY2godHhfY2hfYXR0 ci0+cmVtb3RlX2RvbWFpbik7CisJcmV0ID0gYmtuZF9vcHMtPmluaXRfdHhfY2godHhfY2hfYXR0 ci0+cmVtb3RlX2RvbWFpbik7CiAKIAlyZXR1cm4gcmV0OwogfQpAQCAtNjEsNyArNjEsNyBAQCBz dGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl90eF9jaF9zZXR1cF9pb2N0bChzdHJ1Y3QgZmlsZSAqZmls cCwgdm9pZCAqZGF0YSkKIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX3J4X2NoX3NldHVwX2lvY3Rs KHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQogewogCXN0cnVjdCBpb2N0bF9oeXBlcl9k bWFidWZfcnhfY2hfc2V0dXAgKnJ4X2NoX2F0dHI7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNr ZW5kX29wcyAqb3BzID0gaHlfZHJ2X3ByaXYtPmJhY2tlbmRfb3BzOworCXN0cnVjdCBoeXBlcl9k bWFidWZfYmtuZF9vcHMgKmJrbmRfb3BzID0gaHlfZHJ2X3ByaXYtPmJrbmRfb3BzOwogCWludCBy ZXQgPSAwOwogCiAJaWYgKCFkYXRhKSB7CkBAIC03MSw3ICs3MSw3IEBAIHN0YXRpYyBpbnQgaHlw ZXJfZG1hYnVmX3J4X2NoX3NldHVwX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRh KQogCiAJcnhfY2hfYXR0ciA9IChzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3J4X2NoX3NldHVw ICopZGF0YTsKIAotCXJldCA9IG9wcy0+aW5pdF9yeF9jaChyeF9jaF9hdHRyLT5zb3VyY2VfZG9t YWluKTsKKwlyZXQgPSBia25kX29wcy0+aW5pdF9yeF9jaChyeF9jaF9hdHRyLT5zb3VyY2VfZG9t YWluKTsKIAogCXJldHVybiByZXQ7CiB9CkBAIC03OSw3ICs3OSw3IEBAIHN0YXRpYyBpbnQgaHlw ZXJfZG1hYnVmX3J4X2NoX3NldHVwX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRh KQogc3RhdGljIGludCBzZW5kX2V4cG9ydF9tc2coc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvICpl eHBvcnRlZCwKIAkJCSAgIHN0cnVjdCBwYWdlc19pbmZvICpwZ19pbmZvKQogewotCXN0cnVjdCBo eXBlcl9kbWFidWZfYmFja2VuZF9vcHMgKm9wcyA9IGh5X2Rydl9wcml2LT5iYWNrZW5kX29wczsK KwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JrbmRfb3BzICpia25kX29wcyA9IGh5X2Rydl9wcml2LT5i a25kX29wczsKIAlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JlcSAqcmVxOwogCWludCBvcFtNQVhfTlVN QkVSX09GX09QRVJBTkRTXSA9IHswfTsKIAlpbnQgcmV0LCBpOwpAQCAtOTQsNyArOTQsNyBAQCBz dGF0aWMgaW50IHNlbmRfZXhwb3J0X21zZyhzdHJ1Y3QgZXhwb3J0ZWRfc2d0X2luZm8gKmV4cG9y dGVkLAogCQlvcFs0XSA9IHBnX2luZm8tPm5lbnRzOwogCQlvcFs1XSA9IHBnX2luZm8tPmZyc3Rf b2ZzdDsKIAkJb3BbNl0gPSBwZ19pbmZvLT5sYXN0X2xlbjsKLQkJb3BbN10gPSBvcHMtPnNoYXJl X3BhZ2VzKHBnX2luZm8tPnBncywgZXhwb3J0ZWQtPnJkb21pZCwKKwkJb3BbN10gPSBia25kX29w cy0+c2hhcmVfcGFnZXMocGdfaW5mby0+cGdzLCBleHBvcnRlZC0+cmRvbWlkLAogCQkJCQkgcGdf aW5mby0+bmVudHMsICZleHBvcnRlZC0+cmVmc19pbmZvKTsKIAkJaWYgKG9wWzddIDwgMCkgewog CQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAicGFnZXMgc2hhcmluZyBmYWlsZWRcbiIpOwpA QCAtMTE1LDcgKzExNSw3IEBAIHN0YXRpYyBpbnQgc2VuZF9leHBvcnRfbXNnKHN0cnVjdCBleHBv cnRlZF9zZ3RfaW5mbyAqZXhwb3J0ZWQsCiAJLyogY29tcG9zaW5nIGEgbWVzc2FnZSB0byB0aGUg aW1wb3J0ZXIgKi8KIAloeXBlcl9kbWFidWZfY3JlYXRlX3JlcShyZXEsIEhZUEVSX0RNQUJVRl9F WFBPUlQsICZvcFswXSk7CiAKLQlyZXQgPSBvcHMtPnNlbmRfcmVxKGV4cG9ydGVkLT5yZG9taWQs IHJlcSwgdHJ1ZSk7CisJcmV0ID0gYmtuZF9vcHMtPnNlbmRfcmVxKGV4cG9ydGVkLT5yZG9taWQs IHJlcSwgdHJ1ZSk7CiAKIAlrZnJlZShyZXEpOwogCkBAIC00MjMsNyArNDIzLDcgQEAgc3RhdGlj IGludCBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2b2lk ICpkYXRhKQogewogCXN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfZXhwb3J0X2ZkICpleHBvcnRf ZmRfYXR0ciA9CiAJCQkoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9leHBvcnRfZmQgKilkYXRh OwotCXN0cnVjdCBoeXBlcl9kbWFidWZfYmFja2VuZF9vcHMgKm9wcyA9IGh5X2Rydl9wcml2LT5i YWNrZW5kX29wczsKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JrbmRfb3BzICpia25kX29wcyA9IGh5 X2Rydl9wcml2LT5ia25kX29wczsKIAlzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKmltcG9ydGVk OwogCXN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpyZXE7CiAJc3RydWN0IHBhZ2UgKipkYXRhX3Bn czsKQEAgLTQ2NSw3ICs0NjUsNyBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfZmRf aW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRhdGEpCiAKIAloeXBlcl9kbWFidWZfY3Jl YXRlX3JlcShyZXEsIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkQsICZvcFswXSk7CiAKLQlyZXQgPSBv cHMtPnNlbmRfcmVxKEhZUEVSX0RNQUJVRl9ET01fSUQoaW1wb3J0ZWQtPmhpZCksIHJlcSwgdHJ1 ZSk7CisJcmV0ID0gYmtuZF9vcHMtPnNlbmRfcmVxKEhZUEVSX0RNQUJVRl9ET01fSUQoaW1wb3J0 ZWQtPmhpZCksIHJlcSwgdHJ1ZSk7CiAKIAlpZiAocmV0IDwgMCkgewogCQkvKiBpbiBjYXNlIG9m IHRpbWVvdXQgb3RoZXIgZW5kIGV2ZW50dWFsbHkgd2lsbCByZWNlaXZlIHJlcXVlc3QsCkBAIC00 NzMsNyArNDczLDcgQEAgc3RhdGljIGludCBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQogCQkgKi8KIAkJaHlwZXJfZG1hYnVmX2NyZWF0 ZV9yZXEocmVxLCBIWVBFUl9ETUFCVUZfRVhQT1JUX0ZEX0ZBSUxFRCwKIAkJCQkJJm9wWzBdKTsK LQkJb3BzLT5zZW5kX3JlcShvcFswXSwgcmVxLCBmYWxzZSk7CisJCWJrbmRfb3BzLT5zZW5kX3Jl cShvcFswXSwgcmVxLCBmYWxzZSk7CiAJCWtmcmVlKHJlcSk7CiAJCWRldl9lcnIoaHlfZHJ2X3By aXYtPmRldiwKIAkJCSJGYWlsZWQgdG8gY3JlYXRlIHNndCBvciBub3RpZnkgZXhwb3J0ZXJcbiIp OwpAQCAtNTEyLDcgKzUxMiw3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9p b2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAqZGF0YSkKIAkJCWltcG9ydGVkLT5oaWQuaWQs IGltcG9ydGVkLT5oaWQucm5nX2tleVswXSwKIAkJCWltcG9ydGVkLT5oaWQucm5nX2tleVsxXSwg aW1wb3J0ZWQtPmhpZC5ybmdfa2V5WzJdKTsKIAotCQlkYXRhX3BncyA9IG9wcy0+bWFwX3NoYXJl ZF9wYWdlcyhpbXBvcnRlZC0+cmVmX2hhbmRsZSwKKwkJZGF0YV9wZ3MgPSBia25kX29wcy0+bWFw X3NoYXJlZF9wYWdlcyhpbXBvcnRlZC0+cmVmX2hhbmRsZSwKIAkJCQkJSFlQRVJfRE1BQlVGX0RP TV9JRChpbXBvcnRlZC0+aGlkKSwKIAkJCQkJaW1wb3J0ZWQtPm5lbnRzLAogCQkJCQkmaW1wb3J0 ZWQtPnJlZnNfaW5mbyk7CkBAIC01MzYsNyArNTM2LDcgQEAgc3RhdGljIGludCBoeXBlcl9kbWFi dWZfZXhwb3J0X2ZkX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQogCQkJaHlw ZXJfZG1hYnVmX2NyZWF0ZV9yZXEocmVxLAogCQkJCQkJSFlQRVJfRE1BQlVGX0VYUE9SVF9GRF9G QUlMRUQsCiAJCQkJCQkmb3BbMF0pOwotCQkJb3BzLT5zZW5kX3JlcShIWVBFUl9ETUFCVUZfRE9N X0lEKGltcG9ydGVkLT5oaWQpLCByZXEsCisJCQlia25kX29wcy0+c2VuZF9yZXEoSFlQRVJfRE1B QlVGX0RPTV9JRChpbXBvcnRlZC0+aGlkKSwgcmVxLAogCQkJCQkJCSAgZmFsc2UpOwogCQkJa2Zy ZWUocmVxKTsKIAkJCW11dGV4X3VubG9jaygmaHlfZHJ2X3ByaXYtPmxvY2spOwpAQCAtNTcwLDcg KzU3MCw3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bChzdHJ1Y3Qg ZmlsZSAqZmlscCwgdm9pZCAqZGF0YSkKIHN0YXRpYyB2b2lkIGRlbGF5ZWRfdW5leHBvcnQoc3Ry dWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpyZXE7 Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAqb3BzID0gaHlfZHJ2X3ByaXYtPmJh Y2tlbmRfb3BzOworCXN0cnVjdCBoeXBlcl9kbWFidWZfYmtuZF9vcHMgKmJrbmRfb3BzID0gaHlf ZHJ2X3ByaXYtPmJrbmRfb3BzOwogCXN0cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyAqZXhwb3J0ZWQg PQogCQljb250YWluZXJfb2Yod29yaywgc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvLCB1bmV4cG9y dC53b3JrKTsKIAlpbnQgb3BbNF07CkBAIC02MDIsNyArNjAyLDcgQEAgc3RhdGljIHZvaWQgZGVs YXllZF91bmV4cG9ydChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJLyogTm93IHNlbmQgdW5l eHBvcnQgcmVxdWVzdCB0byByZW1vdGUgZG9tYWluLCBtYXJraW5nCiAJICogdGhhdCBidWZmZXIg c2hvdWxkIG5vdCBiZSB1c2VkIGFueW1vcmUKIAkgKi8KLQlyZXQgPSBvcHMtPnNlbmRfcmVxKGV4 cG9ydGVkLT5yZG9taWQsIHJlcSwgdHJ1ZSk7CisJcmV0ID0gYmtuZF9vcHMtPnNlbmRfcmVxKGV4 cG9ydGVkLT5yZG9taWQsIHJlcSwgdHJ1ZSk7CiAJaWYgKHJldCA8IDApIHsKIAkJZGV2X2Vyciho eV9kcnZfcHJpdi0+ZGV2LAogCQkJInVuZXhwb3J0IG1lc3NhZ2UgZm9yIGJ1ZmZlciB7aWQ6JWQg a2V5OiVkICVkICVkfSBmYWlsZWRcbiIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9k bWFidWYvaHlwZXJfZG1hYnVmX29wcy5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9vcHMuYwppbmRleCBiZjgwNWIxLi5lODVmNjE5IDEwMDY0NAotLS0gYS9kcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX29wcy5jCisrKyBiL2RyaXZlcnMveGVuL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfb3BzLmMKQEAgLTUyLDcgKzUyLDcgQEAgc3RhdGljIGlu dCBkbWFidWZfcmVmY291bnQoc3RydWN0IGRtYV9idWYgKmRtYV9idWYpCiBzdGF0aWMgaW50IHN5 bmNfcmVxdWVzdChoeXBlcl9kbWFidWZfaWRfdCBoaWQsIGludCBkbWFidWZfb3BzKQogewogCXN0 cnVjdCBoeXBlcl9kbWFidWZfcmVxICpyZXE7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5k X29wcyAqb3BzID0gaHlfZHJ2X3ByaXYtPmJhY2tlbmRfb3BzOworCXN0cnVjdCBoeXBlcl9kbWFi dWZfYmtuZF9vcHMgKmJrbmRfb3BzID0gaHlfZHJ2X3ByaXYtPmJrbmRfb3BzOwogCWludCBvcFs1 XTsKIAlpbnQgaTsKIAlpbnQgcmV0OwpAQCAtNzIsNyArNzIsOCBAQCBzdGF0aWMgaW50IHN5bmNf cmVxdWVzdChoeXBlcl9kbWFidWZfaWRfdCBoaWQsIGludCBkbWFidWZfb3BzKQogCWh5cGVyX2Rt YWJ1Zl9jcmVhdGVfcmVxKHJlcSwgSFlQRVJfRE1BQlVGX09QU19UT19TT1VSQ0UsICZvcFswXSk7 CiAKIAkvKiBzZW5kIHJlcXVlc3QgYW5kIHdhaXQgZm9yIGEgcmVzcG9uc2UgKi8KLQlyZXQgPSBv cHMtPnNlbmRfcmVxKEhZUEVSX0RNQUJVRl9ET01fSUQoaGlkKSwgcmVxLCBXQUlUX0FGVEVSX1NZ TkNfUkVRKTsKKwlyZXQgPSBia25kX29wcy0+c2VuZF9yZXEoSFlQRVJfRE1BQlVGX0RPTV9JRCho aWQpLCByZXEsCisJCQkJIFdBSVRfQUZURVJfU1lOQ19SRVEpOwogCiAJaWYgKHJldCA8IDApIHsK IAkJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LApAQCAtMTg2LDcgKzE4Nyw3IEBAIHN0YXRpYyB2 b2lkIGh5cGVyX2RtYWJ1Zl9vcHNfdW5tYXAoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0 YWNobWVudCwKIHN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9vcHNfcmVsZWFzZShzdHJ1Y3QgZG1h X2J1ZiAqZG1hX2J1ZikKIHsKIAlzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKmltcG9ydGVkOwot CXN0cnVjdCBoeXBlcl9kbWFidWZfYmFja2VuZF9vcHMgKm9wcyA9IGh5X2Rydl9wcml2LT5iYWNr ZW5kX29wczsKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JrbmRfb3BzICpia25kX29wcyA9IGh5X2Ry dl9wcml2LT5ia25kX29wczsKIAlpbnQgcmV0OwogCWludCBmaW5pc2g7CiAKQEAgLTIwMSw3ICsy MDIsOCBAQCBzdGF0aWMgdm9pZCBoeXBlcl9kbWFidWZfb3BzX3JlbGVhc2Uoc3RydWN0IGRtYV9i dWYgKmRtYV9idWYpCiAJaW1wb3J0ZWQtPmltcG9ydGVycy0tOwogCiAJaWYgKGltcG9ydGVkLT5p bXBvcnRlcnMgPT0gMCkgewotCQlvcHMtPnVubWFwX3NoYXJlZF9wYWdlcygmaW1wb3J0ZWQtPnJl ZnNfaW5mbywgaW1wb3J0ZWQtPm5lbnRzKTsKKwkJYmtuZF9vcHMtPnVubWFwX3NoYXJlZF9wYWdl cygmaW1wb3J0ZWQtPnJlZnNfaW5mbywKKwkJCQkJICAgICBpbXBvcnRlZC0+bmVudHMpOwogCiAJ CWlmIChpbXBvcnRlZC0+c2d0KSB7CiAJCQlzZ19mcmVlX3RhYmxlKGltcG9ydGVkLT5zZ3QpOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zZ2xfcHJv Yy5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zZ2xfcHJvYy5jCmlu ZGV4IDlhZDdhYjkuLmQxNWViMTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi9oeXBlcl9kbWFidWZfc2dsX3Byb2MuYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv aHlwZXJfZG1hYnVmX3NnbF9wcm9jLmMKQEAgLTE3MCw3ICsxNzAsNyBAQCBpbnQgaHlwZXJfZG1h YnVmX2NsZWFudXBfc2d0X2luZm8oc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvICpleHBvcnRlZCwK IAlzdHJ1Y3QgYXR0YWNobWVudF9saXN0ICphdHRhY2hsOwogCXN0cnVjdCBrbWFwX3ZhZGRyX2xp c3QgKnZhX2ttYXBsOwogCXN0cnVjdCB2bWFwX3ZhZGRyX2xpc3QgKnZhX3ZtYXBsOwotCXN0cnVj dCBoeXBlcl9kbWFidWZfYmFja2VuZF9vcHMgKm9wcyA9IGh5X2Rydl9wcml2LT5iYWNrZW5kX29w czsKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JrbmRfb3BzICpia25kX29wcyA9IGh5X2Rydl9wcml2 LT5ia25kX29wczsKIAogCWlmICghZXhwb3J0ZWQpIHsKIAkJZGV2X2VycihoeV9kcnZfcHJpdi0+ ZGV2LCAiaW52YWxpZCBoeXBlcl9kbWFidWZfaWRcbiIpOwpAQCAtMjMxLDcgKzIzMSw3IEBAIGlu dCBoeXBlcl9kbWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzdHJ1Y3QgZXhwb3J0ZWRfc2d0X2luZm8g KmV4cG9ydGVkLAogCX0KIAogCS8qIFN0YXJ0IGNsZWFudXAgb2YgYnVmZmVyIGluIHJldmVyc2Ug b3JkZXIgdG8gZXhwb3J0aW5nICovCi0Jb3BzLT51bnNoYXJlX3BhZ2VzKCZleHBvcnRlZC0+cmVm c19pbmZvLCBleHBvcnRlZC0+bmVudHMpOworCWJrbmRfb3BzLT51bnNoYXJlX3BhZ2VzKCZleHBv cnRlZC0+cmVmc19pbmZvLCBleHBvcnRlZC0+bmVudHMpOwogCiAJLyogdW5tYXAgZG1hLWJ1ZiAq LwogCWRtYV9idWZfdW5tYXBfYXR0YWNobWVudChleHBvcnRlZC0+YWN0aXZlX2F0dGFjaGVkLT5h dHRhY2gsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2Rt YWJ1Zl94ZW5fZHJ2LmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1 Zl94ZW5fZHJ2LmMKaW5kZXggMjM5NjViOC4uMWQ3MjQ5ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy94 ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2Rydi5jCisrKyBiL2RyaXZlcnMv eGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9kcnYuYwpAQCAtMzAsNyArMzAs NyBAQAogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl94ZW5fY29tbS5oIgogI2luY2x1ZGUgImh5cGVy X2RtYWJ1Zl94ZW5fc2htLmgiCiAKLXN0cnVjdCBoeXBlcl9kbWFidWZfYmFja2VuZF9vcHMgeGVu X2JhY2tlbmRfb3BzID0geworc3RydWN0IGh5cGVyX2RtYWJ1Zl9ia25kX29wcyB4ZW5fYmtuZF9v cHMgPSB7CiAJLmdldF92bV9pZCA9IHhlbl9iZV9nZXRfZG9taWQsCiAJLnNoYXJlX3BhZ2VzID0g eGVuX2JlX3NoYXJlX3BhZ2VzLAogCS51bnNoYXJlX3BhZ2VzID0geGVuX2JlX3Vuc2hhcmVfcGFn ZXMsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1 Zl94ZW5fZHJ2LmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94 ZW5fZHJ2LmgKaW5kZXggZTViZmYwOS4uYTQ5MDJiNyAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4v aHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2Rydi5oCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9kcnYuaApAQCAtMjYsNyArMjYsNyBA QAogI2RlZmluZSBfX0hZUEVSX0RNQUJVRl9YRU5fRFJWX0hfXwogI2luY2x1ZGUgPHhlbi9pbnRl cmZhY2UvZ3JhbnRfdGFibGUuaD4KIAotZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfYmFja2Vu ZF9vcHMgeGVuX2JhY2tlbmRfb3BzOworZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfYmtuZF9v cHMgeGVuX2JrbmRfb3BzOwogCiAvKiBNYWluIHB1cnBvc2Ugb2YgdGhpcyBzdHJ1Y3R1cmUgaXMg dG8ga2VlcAogICogYWxsIHJlZmVyZW5jZXMgY3JlYXRlZCBvciBhY3F1aXJlZCBmb3Igc2hhcmlu ZwotLSAKMi43LjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9y ZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs