From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S966505AbeBNBvb (ORCPT ); Tue, 13 Feb 2018 20:51:31 -0500 Received: from mga02.intel.com ([134.134.136.20]:56116 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S966456AbeBNBv0 (ORCPT ); Tue, 13 Feb 2018 20:51:26 -0500 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.46,510,1511856000"; d="scan'208";a="34498954" From: Dongwon Kim To: linux-kernel@vger.kernel.org, linaro-mm-sig@lists.linaro.org, xen-devel@lists.xenproject.org Cc: dri-devel@lists.freedesktop.org, dongwon.kim@intel.com, mateuszx.potrola@intel.com, sumit.semwal@linaro.org Subject: [RFC PATCH v2 7/9] hyper_dmabuf: query ioctl for retreiving various hyper_DMABUF info Date: Tue, 13 Feb 2018 17:50:06 -0800 Message-Id: <20180214015008.9513-8-dongwon.kim@intel.com> X-Mailer: git-send-email 2.16.1 In-Reply-To: <20180214015008.9513-1-dongwon.kim@intel.com> References: <20180214015008.9513-1-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 Add a new ioctl, "IOCTL_HYPER_DMABUF_QUERY" for the userspace to retreive various information about hyper_DMABUF, currently being shared across VMs. Supported query items are as followed: enum hyper_dmabuf_query { HYPER_DMABUF_QUERY_TYPE = 0x10, HYPER_DMABUF_QUERY_EXPORTER, HYPER_DMABUF_QUERY_IMPORTER, HYPER_DMABUF_QUERY_SIZE, HYPER_DMABUF_QUERY_BUSY, HYPER_DMABUF_QUERY_UNEXPORTED, HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED, HYPER_DMABUF_QUERY_PRIV_INFO_SIZE, HYPER_DMABUF_QUERY_PRIV_INFO, }; Query IOCTL call with each query item above returns, HYPER_DMABUF_QUERY_TYPE - type - EXPORTED/IMPORTED of hyper_DMABUF from current VM's perspective. HYPER_DMABUF_QUERY_EXPORTER - ID of exporting VM HYPER_DMABUF_QUERY_IMPORTER - ID of importing VM HYPER_DMABUF_QUERY_SIZE - size of shared buffer in byte HYPER_DMABUF_QUERY_BUSY - true if hyper_DMABUF is being actively used (e.g. attached and mapped by end-consumer) HYPER_DMABUF_QUERY_UNEXPORTED - true if hyper_DMABUF has been unexported on exporting VM's side. HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED - true if hyper_DMABUF is scheduled to be unexported (still valid but will be unexported soon) HYPER_DMABUF_QUERY_PRIV_INFO_SIZE - size of private information (given by user application on exporter's side) attached to hyper_DMABUF HYPER_DMABUF_QUERY_PRIV_INFO - private information attached to hyper_DMABUF Signed-off-by: Dongwon Kim Signed-off-by: Mateusz Polrola --- drivers/dma-buf/hyper_dmabuf/Makefile | 1 + drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.c | 49 +++++- drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.c | 174 ++++++++++++++++++++++ drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.h | 36 +++++ include/uapi/linux/hyper_dmabuf.h | 32 ++++ 5 files changed, 291 insertions(+), 1 deletion(-) create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.c create mode 100644 drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.h diff --git a/drivers/dma-buf/hyper_dmabuf/Makefile b/drivers/dma-buf/hyper_dmabuf/Makefile index 702696f29215..578a669a0d3e 100644 --- a/drivers/dma-buf/hyper_dmabuf/Makefile +++ b/drivers/dma-buf/hyper_dmabuf/Makefile @@ -10,6 +10,7 @@ ifneq ($(KERNELRELEASE),) hyper_dmabuf_msg.o \ hyper_dmabuf_id.o \ hyper_dmabuf_remote_sync.o \ + hyper_dmabuf_query.o \ ifeq ($(CONFIG_HYPER_DMABUF_XEN), y) $(TARGET_MODULE)-objs += backends/xen/hyper_dmabuf_xen_comm.o \ diff --git a/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.c index 168ccf98f710..e90e59cd0568 100644 --- a/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -41,6 +41,7 @@ #include "hyper_dmabuf_msg.h" #include "hyper_dmabuf_sgl_proc.h" #include "hyper_dmabuf_ops.h" +#include "hyper_dmabuf_query.h" static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data) { @@ -543,7 +544,6 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]); - bknd_ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, false); kfree(req); @@ -682,6 +682,51 @@ int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data) return 0; } +static int hyper_dmabuf_query_ioctl(struct file *filp, void *data) +{ + struct ioctl_hyper_dmabuf_query *query_attr = + (struct ioctl_hyper_dmabuf_query *)data; + struct exported_sgt_info *exported = NULL; + struct imported_sgt_info *imported = NULL; + int ret = 0; + + if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hy_drv_priv->domid) { + /* query for exported dmabuf */ + exported = hyper_dmabuf_find_exported(query_attr->hid); + if (exported) { + ret = hyper_dmabuf_query_exported(exported, + query_attr->item, + &query_attr->info); + } else { + dev_err(hy_drv_priv->dev, + "hid {id:%d key:%d %d %d} not in exp list\n", + query_attr->hid.id, + query_attr->hid.rng_key[0], + query_attr->hid.rng_key[1], + query_attr->hid.rng_key[2]); + return -ENOENT; + } + } else { + /* query for imported dmabuf */ + imported = hyper_dmabuf_find_imported(query_attr->hid); + if (imported) { + ret = hyper_dmabuf_query_imported(imported, + query_attr->item, + &query_attr->info); + } else { + dev_err(hy_drv_priv->dev, + "hid {id:%d key:%d %d %d} not in imp list\n", + query_attr->hid.id, + query_attr->hid.rng_key[0], + query_attr->hid.rng_key[1], + query_attr->hid.rng_key[2]); + return -ENOENT; + } + } + + return ret; +} + const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = { HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_TX_CH_SETUP, hyper_dmabuf_tx_ch_setup_ioctl, 0), @@ -693,6 +738,8 @@ const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = { hyper_dmabuf_export_fd_ioctl, 0), HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_UNEXPORT, hyper_dmabuf_unexport_ioctl, 0), + HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_QUERY, + hyper_dmabuf_query_ioctl, 0), }; long hyper_dmabuf_ioctl(struct file *filp, diff --git a/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.c b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.c new file mode 100644 index 000000000000..edf92318d4cd --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.c @@ -0,0 +1,174 @@ +/* + * Copyright © 2018 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * SPDX-License-Identifier: (MIT OR GPL-2.0) + * + * Authors: + * Dongwon Kim + * Mateusz Polrola + * + */ + +#include +#include +#include "hyper_dmabuf_drv.h" +#include "hyper_dmabuf_struct.h" +#include "hyper_dmabuf_id.h" + +#define HYPER_DMABUF_SIZE(nents, first_offset, last_len) \ + ((nents)*PAGE_SIZE - (first_offset) - PAGE_SIZE + (last_len)) + +int hyper_dmabuf_query_exported(struct exported_sgt_info *exported, + int query, unsigned long *info) +{ + switch (query) { + case HYPER_DMABUF_QUERY_TYPE: + *info = EXPORTED; + break; + + /* exporting domain of this specific dmabuf*/ + case HYPER_DMABUF_QUERY_EXPORTER: + *info = HYPER_DMABUF_DOM_ID(exported->hid); + break; + + /* importing domain of this specific dmabuf */ + case HYPER_DMABUF_QUERY_IMPORTER: + *info = exported->rdomid; + break; + + /* size of dmabuf in byte */ + case HYPER_DMABUF_QUERY_SIZE: + *info = exported->dma_buf->size; + break; + + /* whether the buffer is used by importer */ + case HYPER_DMABUF_QUERY_BUSY: + *info = (exported->active > 0); + break; + + /* whether the buffer is unexported */ + case HYPER_DMABUF_QUERY_UNEXPORTED: + *info = !exported->valid; + break; + + /* whether the buffer is scheduled to be unexported */ + case HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED: + *info = !exported->unexport_sched; + break; + + /* size of private info attached to buffer */ + case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE: + *info = exported->sz_priv; + break; + + /* copy private info attached to buffer */ + case HYPER_DMABUF_QUERY_PRIV_INFO: + if (exported->sz_priv > 0) { + int n; + + n = copy_to_user((void __user *) *info, + exported->priv, + exported->sz_priv); + if (n != 0) + return -EINVAL; + } + break; + + default: + return -EINVAL; + } + + return 0; +} + + +int hyper_dmabuf_query_imported(struct imported_sgt_info *imported, + int query, unsigned long *info) +{ + switch (query) { + case HYPER_DMABUF_QUERY_TYPE: + *info = IMPORTED; + break; + + /* exporting domain of this specific dmabuf*/ + case HYPER_DMABUF_QUERY_EXPORTER: + *info = HYPER_DMABUF_DOM_ID(imported->hid); + break; + + /* importing domain of this specific dmabuf */ + case HYPER_DMABUF_QUERY_IMPORTER: + *info = hy_drv_priv->domid; + break; + + /* size of dmabuf in byte */ + case HYPER_DMABUF_QUERY_SIZE: + if (imported->dma_buf) { + /* if local dma_buf is created (if it's + * ever mapped), retrieve it directly + * from struct dma_buf * + */ + *info = imported->dma_buf->size; + } else { + /* calcuate it from given nents, frst_ofst + * and last_len + */ + *info = HYPER_DMABUF_SIZE(imported->nents, + imported->frst_ofst, + imported->last_len); + } + break; + + /* whether the buffer is used or not */ + case HYPER_DMABUF_QUERY_BUSY: + /* checks if it's used by importer */ + *info = (imported->importers > 0); + break; + + /* whether the buffer is unexported */ + case HYPER_DMABUF_QUERY_UNEXPORTED: + *info = !imported->valid; + break; + + /* size of private info attached to buffer */ + case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE: + *info = imported->sz_priv; + break; + + /* copy private info attached to buffer */ + case HYPER_DMABUF_QUERY_PRIV_INFO: + if (imported->sz_priv > 0) { + int n; + + n = copy_to_user((void __user *)*info, + imported->priv, + imported->sz_priv); + if (n != 0) + return -EINVAL; + } + break; + + default: + return -EINVAL; + } + + return 0; +} diff --git a/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.h b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.h new file mode 100644 index 000000000000..b9687db7e7d5 --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_query.h @@ -0,0 +1,36 @@ +/* + * Copyright © 2018 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * SPDX-License-Identifier: (MIT OR GPL-2.0) + * + */ + +#ifndef __HYPER_DMABUF_QUERY_H__ +#define __HYPER_DMABUF_QUERY_H__ + +int hyper_dmabuf_query_imported(struct imported_sgt_info *imported, + int query, unsigned long *info); + +int hyper_dmabuf_query_exported(struct exported_sgt_info *exported, + int query, unsigned long *info); + +#endif // __HYPER_DMABUF_QUERY_H__ diff --git a/include/uapi/linux/hyper_dmabuf.h b/include/uapi/linux/hyper_dmabuf.h index 36794a4af811..4f8e8ac0375b 100644 --- a/include/uapi/linux/hyper_dmabuf.h +++ b/include/uapi/linux/hyper_dmabuf.h @@ -88,4 +88,36 @@ struct ioctl_hyper_dmabuf_unexport { int status; }; +#define IOCTL_HYPER_DMABUF_QUERY \ +_IOC(_IOC_NONE, 'G', 5, sizeof(struct ioctl_hyper_dmabuf_query)) +struct ioctl_hyper_dmabuf_query { + /* in parameters */ + /* hyper dmabuf id to be queried */ + hyper_dmabuf_id_t hid; + /* item to be queried */ + int item; + /* OUT parameters */ + /* Value of queried item */ + unsigned long info; +}; + +/* DMABUF query */ + +enum hyper_dmabuf_query { + HYPER_DMABUF_QUERY_TYPE = 0x10, + HYPER_DMABUF_QUERY_EXPORTER, + HYPER_DMABUF_QUERY_IMPORTER, + HYPER_DMABUF_QUERY_SIZE, + HYPER_DMABUF_QUERY_BUSY, + HYPER_DMABUF_QUERY_UNEXPORTED, + HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED, + HYPER_DMABUF_QUERY_PRIV_INFO_SIZE, + HYPER_DMABUF_QUERY_PRIV_INFO, +}; + +enum hyper_dmabuf_status { + EXPORTED = 0x01, + IMPORTED, +}; + #endif //__LINUX_PUBLIC_HYPER_DMABUF_H__ -- 2.16.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH v2 7/9] hyper_dmabuf: query ioctl for retreiving various hyper_DMABUF info Date: Tue, 13 Feb 2018 17:50:06 -0800 Message-ID: <20180214015008.9513-8-dongwon.kim@intel.com> References: <20180214015008.9513-1-dongwon.kim@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 6077A6E32D for ; Wed, 14 Feb 2018 01:51:25 +0000 (UTC) In-Reply-To: <20180214015008.9513-1-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, linaro-mm-sig@lists.linaro.org, xen-devel@lists.xenproject.org Cc: dongwon.kim@intel.com, dri-devel@lists.freedesktop.org, mateuszx.potrola@intel.com List-Id: dri-devel@lists.freedesktop.org QWRkIGEgbmV3IGlvY3RsLCAiSU9DVExfSFlQRVJfRE1BQlVGX1FVRVJZIiBmb3IgdGhlIHVzZXJz cGFjZSB0bwpyZXRyZWl2ZSB2YXJpb3VzIGluZm9ybWF0aW9uIGFib3V0IGh5cGVyX0RNQUJVRiwg Y3VycmVudGx5IGJlaW5nIHNoYXJlZAphY3Jvc3MgVk1zLgoKU3VwcG9ydGVkIHF1ZXJ5IGl0ZW1z IGFyZSBhcyBmb2xsb3dlZDoKCmVudW0gaHlwZXJfZG1hYnVmX3F1ZXJ5IHsKICAgICAgICBIWVBF Ul9ETUFCVUZfUVVFUllfVFlQRSA9IDB4MTAsCiAgICAgICAgSFlQRVJfRE1BQlVGX1FVRVJZX0VY UE9SVEVSLAogICAgICAgIEhZUEVSX0RNQUJVRl9RVUVSWV9JTVBPUlRFUiwKICAgICAgICBIWVBF Ul9ETUFCVUZfUVVFUllfU0laRSwKICAgICAgICBIWVBFUl9ETUFCVUZfUVVFUllfQlVTWSwKICAg ICAgICBIWVBFUl9ETUFCVUZfUVVFUllfVU5FWFBPUlRFRCwKICAgICAgICBIWVBFUl9ETUFCVUZf UVVFUllfREVMQVlFRF9VTkVYUE9SVEVELAogICAgICAgIEhZUEVSX0RNQUJVRl9RVUVSWV9QUklW X0lORk9fU0laRSwKICAgICAgICBIWVBFUl9ETUFCVUZfUVVFUllfUFJJVl9JTkZPLAp9OwoKUXVl cnkgSU9DVEwgY2FsbCB3aXRoIGVhY2ggcXVlcnkgaXRlbSBhYm92ZSByZXR1cm5zLAoKSFlQRVJf RE1BQlVGX1FVRVJZX1RZUEUgLSB0eXBlIC0gRVhQT1JURUQvSU1QT1JURUQgb2YgaHlwZXJfRE1B QlVGIGZyb20KY3VycmVudCBWTSdzIHBlcnNwZWN0aXZlLgoKSFlQRVJfRE1BQlVGX1FVRVJZX0VY UE9SVEVSIC0gSUQgb2YgZXhwb3J0aW5nIFZNCgpIWVBFUl9ETUFCVUZfUVVFUllfSU1QT1JURVIg LSBJRCBvZiBpbXBvcnRpbmcgVk0KCkhZUEVSX0RNQUJVRl9RVUVSWV9TSVpFIC0gc2l6ZSBvZiBz aGFyZWQgYnVmZmVyIGluIGJ5dGUKCkhZUEVSX0RNQUJVRl9RVUVSWV9CVVNZIC0gdHJ1ZSBpZiBo eXBlcl9ETUFCVUYgaXMgYmVpbmcgYWN0aXZlbHkgdXNlZAooZS5nLiBhdHRhY2hlZCBhbmQgbWFw cGVkIGJ5IGVuZC1jb25zdW1lcikKCkhZUEVSX0RNQUJVRl9RVUVSWV9VTkVYUE9SVEVEIC0gdHJ1 ZSBpZiBoeXBlcl9ETUFCVUYgaGFzIGJlZW4gdW5leHBvcnRlZApvbiBleHBvcnRpbmcgVk0ncyBz aWRlLgoKSFlQRVJfRE1BQlVGX1FVRVJZX0RFTEFZRURfVU5FWFBPUlRFRCAtIHRydWUgaWYgaHlw ZXJfRE1BQlVGIGlzIHNjaGVkdWxlZAp0byBiZSB1bmV4cG9ydGVkIChzdGlsbCB2YWxpZCBidXQg d2lsbCBiZSB1bmV4cG9ydGVkIHNvb24pCgpIWVBFUl9ETUFCVUZfUVVFUllfUFJJVl9JTkZPX1NJ WkUgLSBzaXplIG9mIHByaXZhdGUgaW5mb3JtYXRpb24gKGdpdmVuIGJ5CnVzZXIgYXBwbGljYXRp b24gb24gZXhwb3J0ZXIncyBzaWRlKSBhdHRhY2hlZCB0byBoeXBlcl9ETUFCVUYKCkhZUEVSX0RN QUJVRl9RVUVSWV9QUklWX0lORk8gLSBwcml2YXRlIGluZm9ybWF0aW9uIGF0dGFjaGVkIHRvIGh5 cGVyX0RNQUJVRgoKU2lnbmVkLW9mZi1ieTogRG9uZ3dvbiBLaW0gPGRvbmd3b24ua2ltQGludGVs LmNvbT4KU2lnbmVkLW9mZi1ieTogTWF0ZXVzeiBQb2xyb2xhIDxtYXRldXN6eC5wb3Ryb2xhQGlu dGVsLmNvbT4KLS0tCiBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL01ha2VmaWxlICAgICAg ICAgICAgIHwgICAxICsKIGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X2lvY3RsLmMgfCAgNDkgKysrKystCiBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9xdWVyeS5jIHwgMTc0ICsrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZG1h LWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3F1ZXJ5LmggfCAgMzYgKysrKysKIGluY2x1 ZGUvdWFwaS9saW51eC9oeXBlcl9kbWFidWYuaCAgICAgICAgICAgICAgICAgfCAgMzIgKysrKwog NSBmaWxlcyBjaGFuZ2VkLCAyOTEgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3F1 ZXJ5LmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5 cGVyX2RtYWJ1Zl9xdWVyeS5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL2h5cGVyX2Rt YWJ1Zi9NYWtlZmlsZSBiL2RyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvTWFrZWZpbGUKaW5k ZXggNzAyNjk2ZjI5MjE1Li41NzhhNjY5YTBkM2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1 Zi9oeXBlcl9kbWFidWYvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1 Zi9NYWtlZmlsZQpAQCAtMTAsNiArMTAsNyBAQCBpZm5lcSAoJChLRVJORUxSRUxFQVNFKSwpCiAJ CQkJIGh5cGVyX2RtYWJ1Zl9tc2cubyBcCiAJCQkJIGh5cGVyX2RtYWJ1Zl9pZC5vIFwKIAkJCQkg aHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jLm8gXAorCQkJCSBoeXBlcl9kbWFidWZfcXVlcnkubyBc CiAKIGlmZXEgKCQoQ09ORklHX0hZUEVSX0RNQUJVRl9YRU4pLCB5KQogCSQoVEFSR0VUX01PRFVM RSktb2JqcyArPSBiYWNrZW5kcy94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLm8gXApkaWZmIC0t Z2l0IGEvZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYyBi L2RyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKaW5kZXgg MTY4Y2NmOThmNzEwLi5lOTBlNTljZDA1NjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKKysrIGIvZHJpdmVycy9kbWEtYnVmL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYwpAQCAtNDEsNiArNDEsNyBAQAogI2luY2x1 ZGUgImh5cGVyX2RtYWJ1Zl9tc2cuaCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfc2dsX3Byb2Mu aCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfb3BzLmgiCisjaW5jbHVkZSAiaHlwZXJfZG1hYnVm X3F1ZXJ5LmgiCiAKIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX3R4X2NoX3NldHVwX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQogewpAQCAtNTQzLDcgKzU0NCw2IEBAIHN0YXRp YyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9p ZCAqZGF0YSkKIAkJCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxKHJlcSwKIAkJCQkJCUhZUEVSX0RN QUJVRl9FWFBPUlRfRkRfRkFJTEVELAogCQkJCQkJJm9wWzBdKTsKLQogCQkJYmtuZF9vcHMtPnNl bmRfcmVxKEhZUEVSX0RNQUJVRl9ET01fSUQoaW1wb3J0ZWQtPmhpZCksCiAJCQkJCSAgIHJlcSwg ZmFsc2UpOwogCQkJa2ZyZWUocmVxKTsKQEAgLTY4Miw2ICs2ODIsNTEgQEAgaW50IGh5cGVyX2Rt YWJ1Zl91bmV4cG9ydF9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAqZGF0YSkKIAlyZXR1 cm4gMDsKIH0KIAorc3RhdGljIGludCBoeXBlcl9kbWFidWZfcXVlcnlfaW9jdGwoc3RydWN0IGZp bGUgKmZpbHAsIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9xdWVy eSAqcXVlcnlfYXR0ciA9CisJCQkoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9xdWVyeSAqKWRh dGE7CisJc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvICpleHBvcnRlZCA9IE5VTEw7CisJc3RydWN0 IGltcG9ydGVkX3NndF9pbmZvICppbXBvcnRlZCA9IE5VTEw7CisJaW50IHJldCA9IDA7CisKKwlp ZiAoSFlQRVJfRE1BQlVGX0RPTV9JRChxdWVyeV9hdHRyLT5oaWQpID09IGh5X2Rydl9wcml2LT5k b21pZCkgeworCQkvKiBxdWVyeSBmb3IgZXhwb3J0ZWQgZG1hYnVmICovCisJCWV4cG9ydGVkID0g aHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQocXVlcnlfYXR0ci0+aGlkKTsKKwkJaWYgKGV4cG9y dGVkKSB7CisJCQlyZXQgPSBoeXBlcl9kbWFidWZfcXVlcnlfZXhwb3J0ZWQoZXhwb3J0ZWQsCisJ CQkJCQkJICBxdWVyeV9hdHRyLT5pdGVtLAorCQkJCQkJCSAgJnF1ZXJ5X2F0dHItPmluZm8pOwor CQl9IGVsc2UgeworCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJCSJoaWQge2lkOiVk IGtleTolZCAlZCAlZH0gbm90IGluIGV4cCBsaXN0XG4iLAorCQkJCXF1ZXJ5X2F0dHItPmhpZC5p ZCwKKwkJCQlxdWVyeV9hdHRyLT5oaWQucm5nX2tleVswXSwKKwkJCQlxdWVyeV9hdHRyLT5oaWQu cm5nX2tleVsxXSwKKwkJCQlxdWVyeV9hdHRyLT5oaWQucm5nX2tleVsyXSk7CisJCQlyZXR1cm4g LUVOT0VOVDsKKwkJfQorCX0gZWxzZSB7CisJCS8qIHF1ZXJ5IGZvciBpbXBvcnRlZCBkbWFidWYg Ki8KKwkJaW1wb3J0ZWQgPSBoeXBlcl9kbWFidWZfZmluZF9pbXBvcnRlZChxdWVyeV9hdHRyLT5o aWQpOworCQlpZiAoaW1wb3J0ZWQpIHsKKwkJCXJldCA9IGh5cGVyX2RtYWJ1Zl9xdWVyeV9pbXBv cnRlZChpbXBvcnRlZCwKKwkJCQkJCQkgIHF1ZXJ5X2F0dHItPml0ZW0sCisJCQkJCQkJICAmcXVl cnlfYXR0ci0+aW5mbyk7CisJCX0gZWxzZSB7CisJCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYs CisJCQkJImhpZCB7aWQ6JWQga2V5OiVkICVkICVkfSBub3QgaW4gaW1wIGxpc3RcbiIsCisJCQkJ cXVlcnlfYXR0ci0+aGlkLmlkLAorCQkJCXF1ZXJ5X2F0dHItPmhpZC5ybmdfa2V5WzBdLAorCQkJ CXF1ZXJ5X2F0dHItPmhpZC5ybmdfa2V5WzFdLAorCQkJCXF1ZXJ5X2F0dHItPmhpZC5ybmdfa2V5 WzJdKTsKKwkJCXJldHVybiAtRU5PRU5UOworCQl9CisJfQorCisJcmV0dXJuIHJldDsKK30KKwog Y29uc3Qgc3RydWN0IGh5cGVyX2RtYWJ1Zl9pb2N0bF9kZXNjIGh5cGVyX2RtYWJ1Zl9pb2N0bHNb XSA9IHsKIAlIWVBFUl9ETUFCVUZfSU9DVExfREVGKElPQ1RMX0hZUEVSX0RNQUJVRl9UWF9DSF9T RVRVUCwKIAkJCSAgICAgICBoeXBlcl9kbWFidWZfdHhfY2hfc2V0dXBfaW9jdGwsIDApLApAQCAt NjkzLDYgKzczOCw4IEBAIGNvbnN0IHN0cnVjdCBoeXBlcl9kbWFidWZfaW9jdGxfZGVzYyBoeXBl cl9kbWFidWZfaW9jdGxzW10gPSB7CiAJCQkgICAgICAgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9p b2N0bCwgMCksCiAJSFlQRVJfRE1BQlVGX0lPQ1RMX0RFRihJT0NUTF9IWVBFUl9ETUFCVUZfVU5F WFBPUlQsCiAJCQkgICAgICAgaHlwZXJfZG1hYnVmX3VuZXhwb3J0X2lvY3RsLCAwKSwKKwlIWVBF Ul9ETUFCVUZfSU9DVExfREVGKElPQ1RMX0hZUEVSX0RNQUJVRl9RVUVSWSwKKwkJCSAgICAgICBo eXBlcl9kbWFidWZfcXVlcnlfaW9jdGwsIDApLAogfTsKIAogbG9uZyBoeXBlcl9kbWFidWZfaW9j dGwoc3RydWN0IGZpbGUgKmZpbHAsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9xdWVyeS5jIGIvZHJpdmVycy9kbWEtYnVmL2h5cGVyX2RtYWJ1 Zi9oeXBlcl9kbWFidWZfcXVlcnkuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLmVkZjkyMzE4ZDRjZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3F1ZXJ5LmMKQEAgLTAsMCArMSwxNzQgQEAKKy8qCisg KiBDb3B5cmlnaHQgwqkgMjAxOCBJbnRlbCBDb3Jwb3JhdGlvbgorICoKKyAqIFBlcm1pc3Npb24g aXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmlu ZyBhCisgKiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlv biBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0 aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICogdGhlIHJp Z2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1 YmxpY2Vuc2UsCisgKiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8g cGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBk byBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKgorICogVGhlIGFi b3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2UgKGluY2x1ZGlu ZyB0aGUgbmV4dAorICogcGFyYWdyYXBoKSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwgY29waWVz IG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZQorICogU29mdHdhcmUuCisgKgorICogVEhF IFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJ TkQsIEVYUFJFU1MgT1IKKyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8g VEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNIQUxMCisg KiBUSEUgQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJ TSwgREFNQUdFUyBPUiBPVEhFUgorICogTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBP RiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcKKyAqIEZST00sIE9VVCBPRiBP UiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVB TElOR1MKKyAqIElOIFRIRSBTT0ZUV0FSRS4KKyAqCisgKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogKE1JVCBPUiBHUEwtMi4wKQorICoKKyAqIEF1dGhvcnM6CisgKiAgICBEb25nd29uIEtpbSA8 ZG9uZ3dvbi5raW1AaW50ZWwuY29tPgorICogICAgTWF0ZXVzeiBQb2xyb2xhIDxtYXRldXN6eC5w b3Ryb2xhQGludGVsLmNvbT4KKyAqCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4K KyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2Rydi5o IgorI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaCIKKyNpbmNsdWRlICJoeXBlcl9kbWFi dWZfaWQuaCIKKworI2RlZmluZSBIWVBFUl9ETUFCVUZfU0laRShuZW50cywgZmlyc3Rfb2Zmc2V0 LCBsYXN0X2xlbikgXAorCSgobmVudHMpKlBBR0VfU0laRSAtIChmaXJzdF9vZmZzZXQpIC0gUEFH RV9TSVpFICsgKGxhc3RfbGVuKSkKKworaW50IGh5cGVyX2RtYWJ1Zl9xdWVyeV9leHBvcnRlZChz dHJ1Y3QgZXhwb3J0ZWRfc2d0X2luZm8gKmV4cG9ydGVkLAorCQkJCWludCBxdWVyeSwgdW5zaWdu ZWQgbG9uZyAqaW5mbykKK3sKKwlzd2l0Y2ggKHF1ZXJ5KSB7CisJY2FzZSBIWVBFUl9ETUFCVUZf UVVFUllfVFlQRToKKwkJKmluZm8gPSBFWFBPUlRFRDsKKwkJYnJlYWs7CisKKwkvKiBleHBvcnRp bmcgZG9tYWluIG9mIHRoaXMgc3BlY2lmaWMgZG1hYnVmKi8KKwljYXNlIEhZUEVSX0RNQUJVRl9R VUVSWV9FWFBPUlRFUjoKKwkJKmluZm8gPSBIWVBFUl9ETUFCVUZfRE9NX0lEKGV4cG9ydGVkLT5o aWQpOworCQlicmVhazsKKworCS8qIGltcG9ydGluZyBkb21haW4gb2YgdGhpcyBzcGVjaWZpYyBk bWFidWYgKi8KKwljYXNlIEhZUEVSX0RNQUJVRl9RVUVSWV9JTVBPUlRFUjoKKwkJKmluZm8gPSBl eHBvcnRlZC0+cmRvbWlkOworCQlicmVhazsKKworCS8qIHNpemUgb2YgZG1hYnVmIGluIGJ5dGUg Ki8KKwljYXNlIEhZUEVSX0RNQUJVRl9RVUVSWV9TSVpFOgorCQkqaW5mbyA9IGV4cG9ydGVkLT5k bWFfYnVmLT5zaXplOworCQlicmVhazsKKworCS8qIHdoZXRoZXIgdGhlIGJ1ZmZlciBpcyB1c2Vk IGJ5IGltcG9ydGVyICovCisJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfQlVTWToKKwkJKmluZm8g PSAoZXhwb3J0ZWQtPmFjdGl2ZSA+IDApOworCQlicmVhazsKKworCS8qIHdoZXRoZXIgdGhlIGJ1 ZmZlciBpcyB1bmV4cG9ydGVkICovCisJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfVU5FWFBPUlRF RDoKKwkJKmluZm8gPSAhZXhwb3J0ZWQtPnZhbGlkOworCQlicmVhazsKKworCS8qIHdoZXRoZXIg dGhlIGJ1ZmZlciBpcyBzY2hlZHVsZWQgdG8gYmUgdW5leHBvcnRlZCAqLworCWNhc2UgSFlQRVJf RE1BQlVGX1FVRVJZX0RFTEFZRURfVU5FWFBPUlRFRDoKKwkJKmluZm8gPSAhZXhwb3J0ZWQtPnVu ZXhwb3J0X3NjaGVkOworCQlicmVhazsKKworCS8qIHNpemUgb2YgcHJpdmF0ZSBpbmZvIGF0dGFj aGVkIHRvIGJ1ZmZlciAqLworCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZX1BSSVZfSU5GT19TSVpF OgorCQkqaW5mbyA9IGV4cG9ydGVkLT5zel9wcml2OworCQlicmVhazsKKworCS8qIGNvcHkgcHJp dmF0ZSBpbmZvIGF0dGFjaGVkIHRvIGJ1ZmZlciAqLworCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZ X1BSSVZfSU5GTzoKKwkJaWYgKGV4cG9ydGVkLT5zel9wcml2ID4gMCkgeworCQkJaW50IG47CisK KwkJCW4gPSBjb3B5X3RvX3VzZXIoKHZvaWQgX191c2VyICopICppbmZvLAorCQkJCQlleHBvcnRl ZC0+cHJpdiwKKwkJCQkJZXhwb3J0ZWQtPnN6X3ByaXYpOworCQkJaWYgKG4gIT0gMCkKKwkJCQly ZXR1cm4gLUVJTlZBTDsKKwkJfQorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCXJldHVybiAtRUlO VkFMOworCX0KKworCXJldHVybiAwOworfQorCisKK2ludCBoeXBlcl9kbWFidWZfcXVlcnlfaW1w b3J0ZWQoc3RydWN0IGltcG9ydGVkX3NndF9pbmZvICppbXBvcnRlZCwKKwkJCQlpbnQgcXVlcnks IHVuc2lnbmVkIGxvbmcgKmluZm8pCit7CisJc3dpdGNoIChxdWVyeSkgeworCWNhc2UgSFlQRVJf RE1BQlVGX1FVRVJZX1RZUEU6CisJCSppbmZvID0gSU1QT1JURUQ7CisJCWJyZWFrOworCisJLyog ZXhwb3J0aW5nIGRvbWFpbiBvZiB0aGlzIHNwZWNpZmljIGRtYWJ1ZiovCisJY2FzZSBIWVBFUl9E TUFCVUZfUVVFUllfRVhQT1JURVI6CisJCSppbmZvID0gSFlQRVJfRE1BQlVGX0RPTV9JRChpbXBv cnRlZC0+aGlkKTsKKwkJYnJlYWs7CisKKwkvKiBpbXBvcnRpbmcgZG9tYWluIG9mIHRoaXMgc3Bl Y2lmaWMgZG1hYnVmICovCisJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfSU1QT1JURVI6CisJCSpp bmZvID0gaHlfZHJ2X3ByaXYtPmRvbWlkOworCQlicmVhazsKKworCS8qIHNpemUgb2YgZG1hYnVm IGluIGJ5dGUgKi8KKwljYXNlIEhZUEVSX0RNQUJVRl9RVUVSWV9TSVpFOgorCQlpZiAoaW1wb3J0 ZWQtPmRtYV9idWYpIHsKKwkJCS8qIGlmIGxvY2FsIGRtYV9idWYgaXMgY3JlYXRlZCAoaWYgaXQn cworCQkJICogZXZlciBtYXBwZWQpLCByZXRyaWV2ZSBpdCBkaXJlY3RseQorCQkJICogZnJvbSBz dHJ1Y3QgZG1hX2J1ZiAqCisJCQkgKi8KKwkJCSppbmZvID0gaW1wb3J0ZWQtPmRtYV9idWYtPnNp emU7CisJCX0gZWxzZSB7CisJCQkvKiBjYWxjdWF0ZSBpdCBmcm9tIGdpdmVuIG5lbnRzLCBmcnN0 X29mc3QKKwkJCSAqIGFuZCBsYXN0X2xlbgorCQkJICovCisJCQkqaW5mbyA9IEhZUEVSX0RNQUJV Rl9TSVpFKGltcG9ydGVkLT5uZW50cywKKwkJCQkJCSAgaW1wb3J0ZWQtPmZyc3Rfb2ZzdCwKKwkJ CQkJCSAgaW1wb3J0ZWQtPmxhc3RfbGVuKTsKKwkJfQorCQlicmVhazsKKworCS8qIHdoZXRoZXIg dGhlIGJ1ZmZlciBpcyB1c2VkIG9yIG5vdCAqLworCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZX0JV U1k6CisJCS8qIGNoZWNrcyBpZiBpdCdzIHVzZWQgYnkgaW1wb3J0ZXIgKi8KKwkJKmluZm8gPSAo aW1wb3J0ZWQtPmltcG9ydGVycyA+IDApOworCQlicmVhazsKKworCS8qIHdoZXRoZXIgdGhlIGJ1 ZmZlciBpcyB1bmV4cG9ydGVkICovCisJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfVU5FWFBPUlRF RDoKKwkJKmluZm8gPSAhaW1wb3J0ZWQtPnZhbGlkOworCQlicmVhazsKKworCS8qIHNpemUgb2Yg cHJpdmF0ZSBpbmZvIGF0dGFjaGVkIHRvIGJ1ZmZlciAqLworCWNhc2UgSFlQRVJfRE1BQlVGX1FV RVJZX1BSSVZfSU5GT19TSVpFOgorCQkqaW5mbyA9IGltcG9ydGVkLT5zel9wcml2OworCQlicmVh azsKKworCS8qIGNvcHkgcHJpdmF0ZSBpbmZvIGF0dGFjaGVkIHRvIGJ1ZmZlciAqLworCWNhc2Ug SFlQRVJfRE1BQlVGX1FVRVJZX1BSSVZfSU5GTzoKKwkJaWYgKGltcG9ydGVkLT5zel9wcml2ID4g MCkgeworCQkJaW50IG47CisKKwkJCW4gPSBjb3B5X3RvX3VzZXIoKHZvaWQgX191c2VyICopKmlu Zm8sCisJCQkJCWltcG9ydGVkLT5wcml2LAorCQkJCQlpbXBvcnRlZC0+c3pfcHJpdik7CisJCQlp ZiAobiAhPSAwKQorCQkJCXJldHVybiAtRUlOVkFMOworCQl9CisJCWJyZWFrOworCisJZGVmYXVs dDoKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9k cml2ZXJzL2RtYS1idWYvaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9xdWVyeS5oIGIvZHJpdmVy cy9kbWEtYnVmL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcXVlcnkuaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmI5Njg3ZGI3ZTdkNQotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvZG1hLWJ1Zi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3F1ZXJ5LmgKQEAg LTAsMCArMSwzNiBAQAorLyoKKyAqIENvcHlyaWdodCDCqSAyMDE4IEludGVsIENvcnBvcmF0aW9u CisgKgorICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRv IGFueSBwZXJzb24gb2J0YWluaW5nIGEKKyAqIGNvcHkgb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNz b2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksCisgKiB0byBkZWFs IGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBs aW1pdGF0aW9uCisgKiB0aGUgcmlnaHRzIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVi bGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwKKyAqIGFuZC9vciBzZWxsIGNvcGllcyBvZiB0 aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZQorICogU29mdHdh cmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9uczoKKyAqCisgKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNz aW9uIG5vdGljZSAoaW5jbHVkaW5nIHRoZSBuZXh0CisgKiBwYXJhZ3JhcGgpIHNoYWxsIGJlIGlu Y2x1ZGVkIGluIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlCisgKiBT b2Z0d2FyZS4KKyAqCisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9V VCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwgSU5DTFVESU5H IEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCisg KiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiAg SU4gTk8gRVZFTlQgU0hBTEwKKyAqIFRIRSBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJF IExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCisgKiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lO RworICogRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1Ig VEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUworICogSU4gVEhFIFNPRlRXQVJFLgorICoKKyAqIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiAoTUlUIE9SIEdQTC0yLjApCisgKgorICovCisKKyNpZm5k ZWYgX19IWVBFUl9ETUFCVUZfUVVFUllfSF9fCisjZGVmaW5lIF9fSFlQRVJfRE1BQlVGX1FVRVJZ X0hfXworCitpbnQgaHlwZXJfZG1hYnVmX3F1ZXJ5X2ltcG9ydGVkKHN0cnVjdCBpbXBvcnRlZF9z Z3RfaW5mbyAqaW1wb3J0ZWQsCisJCQkJaW50IHF1ZXJ5LCB1bnNpZ25lZCBsb25nICppbmZvKTsK KworaW50IGh5cGVyX2RtYWJ1Zl9xdWVyeV9leHBvcnRlZChzdHJ1Y3QgZXhwb3J0ZWRfc2d0X2lu Zm8gKmV4cG9ydGVkLAorCQkJCWludCBxdWVyeSwgdW5zaWduZWQgbG9uZyAqaW5mbyk7CisKKyNl bmRpZiAvLyBfX0hZUEVSX0RNQUJVRl9RVUVSWV9IX18KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFw aS9saW51eC9oeXBlcl9kbWFidWYuaCBiL2luY2x1ZGUvdWFwaS9saW51eC9oeXBlcl9kbWFidWYu aAppbmRleCAzNjc5NGE0YWY4MTEuLjRmOGU4YWMwMzc1YiAxMDA2NDQKLS0tIGEvaW5jbHVkZS91 YXBpL2xpbnV4L2h5cGVyX2RtYWJ1Zi5oCisrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9oeXBlcl9k bWFidWYuaApAQCAtODgsNCArODgsMzYgQEAgc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl91bmV4 cG9ydCB7CiAJaW50IHN0YXR1czsKIH07CiAKKyNkZWZpbmUgSU9DVExfSFlQRVJfRE1BQlVGX1FV RVJZIFwKK19JT0MoX0lPQ19OT05FLCAnRycsIDUsIHNpemVvZihzdHJ1Y3QgaW9jdGxfaHlwZXJf ZG1hYnVmX3F1ZXJ5KSkKK3N0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfcXVlcnkgeworCS8qIGlu IHBhcmFtZXRlcnMgKi8KKwkvKiBoeXBlciBkbWFidWYgaWQgdG8gYmUgcXVlcmllZCAqLworCWh5 cGVyX2RtYWJ1Zl9pZF90IGhpZDsKKwkvKiBpdGVtIHRvIGJlIHF1ZXJpZWQgKi8KKwlpbnQgaXRl bTsKKwkvKiBPVVQgcGFyYW1ldGVycyAqLworCS8qIFZhbHVlIG9mIHF1ZXJpZWQgaXRlbSAqLwor CXVuc2lnbmVkIGxvbmcgaW5mbzsKK307CisKKy8qIERNQUJVRiBxdWVyeSAqLworCitlbnVtIGh5 cGVyX2RtYWJ1Zl9xdWVyeSB7CisJSFlQRVJfRE1BQlVGX1FVRVJZX1RZUEUgPSAweDEwLAorCUhZ UEVSX0RNQUJVRl9RVUVSWV9FWFBPUlRFUiwKKwlIWVBFUl9ETUFCVUZfUVVFUllfSU1QT1JURVIs CisJSFlQRVJfRE1BQlVGX1FVRVJZX1NJWkUsCisJSFlQRVJfRE1BQlVGX1FVRVJZX0JVU1ksCisJ SFlQRVJfRE1BQlVGX1FVRVJZX1VORVhQT1JURUQsCisJSFlQRVJfRE1BQlVGX1FVRVJZX0RFTEFZ RURfVU5FWFBPUlRFRCwKKwlIWVBFUl9ETUFCVUZfUVVFUllfUFJJVl9JTkZPX1NJWkUsCisJSFlQ RVJfRE1BQlVGX1FVRVJZX1BSSVZfSU5GTywKK307CisKK2VudW0gaHlwZXJfZG1hYnVmX3N0YXR1 cyB7CisJRVhQT1JURUQgPSAweDAxLAorCUlNUE9SVEVELAorfTsKKwogI2VuZGlmIC8vX19MSU5V WF9QVUJMSUNfSFlQRVJfRE1BQlVGX0hfXwotLSAKMi4xNi4xCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK