From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753298AbdLSThG (ORCPT ); Tue, 19 Dec 2017 14:37:06 -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 S1753174AbdLSTgt (ORCPT ); Tue, 19 Dec 2017 14:36:49 -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="4018573" 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 28/60] hyper_dmabuf: address several synchronization issues Date: Tue, 19 Dec 2017 11:29:44 -0800 Message-Id: <1513711816-2618-28-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 This patch addresses several synchronization issues while sharing DMA_BUF with another VM. 1. Set WAIT_AFTER_SYNC_REQ to false by default to prevent possible performance degradation when waing for the response for every syncrhonization request to exporter VM. 2. Removed HYPER_DMABUF_OPS_RELEASE_FINAL message - now exporter can automatically detect when there are no more consumers of DMA_BUF so importer VM doesn't have to send out this message. 3. Renamed HYPER_DMABUF_FIRST_EXPORT into HYPER_DMABUF_EXPORT_FD 4. Introduced HYPER_DMABUF_EXPORT_FD_FAILED message to undo HYPER_DMABUF_FIRST_EXPORT in case of any failure while executing hyper_dmabuf_export_fd_ioctl 5. Waiting until other VM processes all pending requests when ring buffers are all full. 6. Create hyper_dmabuf.h with definitions of driver interface under include/uapi/xen/ Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c | 21 ++--- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 17 +++- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 74 +---------------- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 30 +++++-- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 4 +- .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 24 ++++-- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 5 +- include/uapi/xen/hyper_dmabuf.h | 96 ++++++++++++++++++++++ 8 files changed, 163 insertions(+), 108 deletions(-) create mode 100644 include/uapi/xen/hyper_dmabuf.h diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c index a0b3946..5a034ffb 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c @@ -187,10 +187,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo * side. */ if (!force && - (!list_empty(&sgt_info->va_kmapped->list) || - !list_empty(&sgt_info->va_vmapped->list) || - !list_empty(&sgt_info->active_sgts->list) || - !list_empty(&sgt_info->active_attached->list))) { + sgt_info->importer_exported) { dev_warn(hyper_dmabuf_private.device, "dma-buf is used by importer\n"); return -EPERM; } @@ -259,7 +256,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo return 0; } -#define WAIT_AFTER_SYNC_REQ 1 +#define WAIT_AFTER_SYNC_REQ 0 inline int hyper_dmabuf_sync_request(int id, int dmabuf_ops) { @@ -431,17 +428,11 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf) final_release = sgt_info && !sgt_info->valid && !sgt_info->num_importers; - if (final_release) { - ret = hyper_dmabuf_sync_request(sgt_info->hyper_dmabuf_id, - HYPER_DMABUF_OPS_RELEASE_FINAL); - } else { - ret = hyper_dmabuf_sync_request(sgt_info->hyper_dmabuf_id, - HYPER_DMABUF_OPS_RELEASE); - } - + ret = hyper_dmabuf_sync_request(sgt_info->hyper_dmabuf_id, + HYPER_DMABUF_OPS_RELEASE); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); + dev_warn(hyper_dmabuf_private.device, + "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); } /* diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index 19ca725..58b115a 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -35,6 +35,7 @@ #include #include #include +#include #include "hyper_dmabuf_struct.h" #include "hyper_dmabuf_ioctl.h" #include "hyper_dmabuf_list.h" @@ -282,12 +283,17 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) /* send notification for export_fd to exporter */ operand = sgt_info->hyper_dmabuf_id; + dev_dbg(hyper_dmabuf_private.device, "Exporting fd of buffer %d\n", operand); + req = kcalloc(1, sizeof(*req), GFP_KERNEL); - hyper_dmabuf_create_request(req, HYPER_DMABUF_FIRST_EXPORT, &operand); + hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD, &operand); ret = ops->send_req(HYPER_DMABUF_DOM_ID(operand), req, true); if (ret < 0) { + /* in case of timeout other end eventually will receive request, so we need to undo it */ + hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operand); + ops->send_req(HYPER_DMABUF_DOM_ID(operand), req, false); kfree(req); dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n"); sgt_info->num_importers--; @@ -298,12 +304,12 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) if (ret == HYPER_DMABUF_REQ_ERROR) { dev_err(hyper_dmabuf_private.device, - "Buffer invalid\n"); + "Buffer invalid %d, cannot import\n", operand); sgt_info->num_importers--; mutex_unlock(&hyper_dmabuf_private.lock); return -EINVAL; } else { - dev_dbg(hyper_dmabuf_private.device, "Can import buffer\n"); + dev_dbg(hyper_dmabuf_private.device, "Can import buffer %d\n", operand); ret = 0; } @@ -322,7 +328,12 @@ static int hyper_dmabuf_export_fd_ioctl(void *data) &sgt_info->refs_info); if (!data_pages) { + dev_err(hyper_dmabuf_private.device, "Cannot map pages of buffer %d\n", operand); sgt_info->num_importers--; + req = kcalloc(1, sizeof(*req), GFP_KERNEL); + hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operand); + ops->send_req(HYPER_DMABUF_DOM_ID(operand), req, false); + kfree(req); mutex_unlock(&hyper_dmabuf_private.lock); return -EINVAL; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h index 558964c..8355e30 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h @@ -22,8 +22,8 @@ * */ -#ifndef __LINUX_PUBLIC_HYPER_DMABUF_IOCTL_H__ -#define __LINUX_PUBLIC_HYPER_DMABUF_IOCTL_H__ +#ifndef __HYPER_DMABUF_IOCTL_H__ +#define __HYPER_DMABUF_IOCTL_H__ typedef int (*hyper_dmabuf_ioctl_t)(void *data); @@ -42,72 +42,4 @@ struct hyper_dmabuf_ioctl_desc { .name = #ioctl \ } -#define IOCTL_HYPER_DMABUF_TX_CH_SETUP \ -_IOC(_IOC_NONE, 'G', 0, sizeof(struct ioctl_hyper_dmabuf_tx_ch_setup)) -struct ioctl_hyper_dmabuf_tx_ch_setup { - /* IN parameters */ - /* Remote domain id */ - int remote_domain; -}; - -#define IOCTL_HYPER_DMABUF_RX_CH_SETUP \ -_IOC(_IOC_NONE, 'G', 1, sizeof(struct ioctl_hyper_dmabuf_rx_ch_setup)) -struct ioctl_hyper_dmabuf_rx_ch_setup { - /* IN parameters */ - /* Source domain id */ - int source_domain; -}; - -#define IOCTL_HYPER_DMABUF_EXPORT_REMOTE \ -_IOC(_IOC_NONE, 'G', 2, sizeof(struct ioctl_hyper_dmabuf_export_remote)) -struct ioctl_hyper_dmabuf_export_remote { - /* IN parameters */ - /* DMA buf fd to be exported */ - int dmabuf_fd; - /* Domain id to which buffer should be exported */ - int remote_domain; - /* exported dma buf id */ - int hyper_dmabuf_id; - int private[4]; -}; - -#define IOCTL_HYPER_DMABUF_EXPORT_FD \ -_IOC(_IOC_NONE, 'G', 3, sizeof(struct ioctl_hyper_dmabuf_export_fd)) -struct ioctl_hyper_dmabuf_export_fd { - /* IN parameters */ - /* hyper dmabuf id to be imported */ - int hyper_dmabuf_id; - /* flags */ - int flags; - /* OUT parameters */ - /* exported dma buf fd */ - int fd; -}; - -#define IOCTL_HYPER_DMABUF_UNEXPORT \ -_IOC(_IOC_NONE, 'G', 4, sizeof(struct ioctl_hyper_dmabuf_unexport)) -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; -}; - -#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 */ - int hyper_dmabuf_id; - /* item to be queried */ - int item; - /* OUT parameters */ - /* Value of queried item */ - int info; -}; - -#endif //__LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ +#endif //__HYPER_DMABUF_IOCTL_H__ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c index 6e24442..3111cdc 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c @@ -79,9 +79,10 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req, req->operands[0] = operands[0]; break; - case HYPER_DMABUF_FIRST_EXPORT: - /* dmabuf fd is being created on imported side for first time */ - /* command : HYPER_DMABUF_FIRST_EXPORT, + case HYPER_DMABUF_EXPORT_FD: + case HYPER_DMABUF_EXPORT_FD_FAILED: + /* dmabuf fd is being created on imported side or importing failed */ + /* command : HYPER_DMABUF_EXPORT_FD or HYPER_DMABUF_EXPORT_FD_FAILED, * operands0 : hyper_dmabuf_id */ req->operands[0] = operands[0]; @@ -244,8 +245,10 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) } /* synchronous dma_buf_fd export */ - if (req->command == HYPER_DMABUF_FIRST_EXPORT) { + if (req->command == HYPER_DMABUF_EXPORT_FD) { /* find a corresponding SGT for the id */ + dev_dbg(hyper_dmabuf_private.device, + "Processing HYPER_DMABUF_EXPORT_FD %d\n", req->operands[0]); exp_sgt_info = hyper_dmabuf_find_exported(req->operands[0]); if (!exp_sgt_info) { @@ -254,17 +257,32 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) 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"); + "Buffer no longer valid - cannot export fd %d\n", req->operands[0]); req->status = HYPER_DMABUF_REQ_ERROR; } else { dev_dbg(hyper_dmabuf_private.device, - "Buffer still valid - can export\n"); + "Buffer still valid - can export fd%d\n", req->operands[0]); exp_sgt_info->importer_exported++; req->status = HYPER_DMABUF_REQ_PROCESSED; } return req->command; } + if (req->command == HYPER_DMABUF_EXPORT_FD_FAILED) { + dev_dbg(hyper_dmabuf_private.device, + "Processing HYPER_DMABUF_EXPORT_FD_FAILED %d\n", req->operands[0]); + 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 { + 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__); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h index 8b3c857..50ce617 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h @@ -43,7 +43,8 @@ struct hyper_dmabuf_resp { enum hyper_dmabuf_command { HYPER_DMABUF_EXPORT = 0x10, - HYPER_DMABUF_FIRST_EXPORT, + HYPER_DMABUF_EXPORT_FD, + HYPER_DMABUF_EXPORT_FD_FAILED, HYPER_DMABUF_NOTIFY_UNEXPORT, HYPER_DMABUF_OPS_TO_REMOTE, HYPER_DMABUF_OPS_TO_SOURCE, @@ -55,7 +56,6 @@ enum hyper_dmabuf_ops { HYPER_DMABUF_OPS_MAP, HYPER_DMABUF_OPS_UNMAP, HYPER_DMABUF_OPS_RELEASE, - HYPER_DMABUF_OPS_RELEASE_FINAL, HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS, HYPER_DMABUF_OPS_END_CPU_ACCESS, HYPER_DMABUF_OPS_KMAP_ATOMIC, diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c index a74e800..0eded61 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c @@ -152,13 +152,25 @@ int hyper_dmabuf_remote_sync(int id, int ops) kfree(sgtl); break; - case HYPER_DMABUF_OPS_RELEASE_FINAL: + case HYPER_DMABUF_OPS_RELEASE: + dev_dbg(hyper_dmabuf_private.device, + "Buffer %d released, references left: %d\n", + sgt_info->hyper_dmabuf_id, + sgt_info->importer_exported -1); + sgt_info->importer_exported--; + /* If there are still importers just break, if no then continue with final cleanup */ + if (sgt_info->importer_exported) + break; + /* * Importer just released buffer fd, check if there is any other importer still using it. * If not and buffer was unexported, clean up shared data and remove that buffer. */ - if (list_empty(&sgt_info->active_attached->list) && - !sgt_info->valid) { + dev_dbg(hyper_dmabuf_private.device, + "Buffer %d final released\n", sgt_info->hyper_dmabuf_id); + + if (!sgt_info->valid && !sgt_info->importer_exported && + !sgt_info->unexport_scheduled) { hyper_dmabuf_cleanup_sgt_info(sgt_info, false); hyper_dmabuf_remove_exported(id); kfree(sgt_info); @@ -168,12 +180,6 @@ int hyper_dmabuf_remote_sync(int id, int ops) break; - case HYPER_DMABUF_OPS_RELEASE: - /* place holder */ - sgt_info->importer_exported--; - - break; - case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS: ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL); if (ret) { diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c index 2cc35e3..ce9862a 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c @@ -519,8 +519,9 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) ring = &ring_info->ring_front; - if (RING_FULL(ring)) - return -EBUSY; + while (RING_FULL(ring)) { + usleep_range(100, 120); + } new_req = RING_GET_REQUEST(ring, ring->req_prod_pvt); if (!new_req) { diff --git a/include/uapi/xen/hyper_dmabuf.h b/include/uapi/xen/hyper_dmabuf.h new file mode 100644 index 0000000..2eff3a8e --- /dev/null +++ b/include/uapi/xen/hyper_dmabuf.h @@ -0,0 +1,96 @@ +/* + * Copyright © 2017 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. + * + */ + +#ifndef __LINUX_PUBLIC_HYPER_DMABUF_H__ +#define __LINUX_PUBLIC_HYPER_DMABUF_H__ + +#define IOCTL_HYPER_DMABUF_TX_CH_SETUP \ +_IOC(_IOC_NONE, 'G', 0, sizeof(struct ioctl_hyper_dmabuf_tx_ch_setup)) +struct ioctl_hyper_dmabuf_tx_ch_setup { + /* IN parameters */ + /* Remote domain id */ + int remote_domain; +}; + +#define IOCTL_HYPER_DMABUF_RX_CH_SETUP \ +_IOC(_IOC_NONE, 'G', 1, sizeof(struct ioctl_hyper_dmabuf_rx_ch_setup)) +struct ioctl_hyper_dmabuf_rx_ch_setup { + /* IN parameters */ + /* Source domain id */ + int source_domain; +}; + +#define IOCTL_HYPER_DMABUF_EXPORT_REMOTE \ +_IOC(_IOC_NONE, 'G', 2, sizeof(struct ioctl_hyper_dmabuf_export_remote)) +struct ioctl_hyper_dmabuf_export_remote { + /* IN parameters */ + /* DMA buf fd to be exported */ + int dmabuf_fd; + /* Domain id to which buffer should be exported */ + int remote_domain; + /* exported dma buf id */ + int hyper_dmabuf_id; + int private[4]; +}; + +#define IOCTL_HYPER_DMABUF_EXPORT_FD \ +_IOC(_IOC_NONE, 'G', 3, sizeof(struct ioctl_hyper_dmabuf_export_fd)) +struct ioctl_hyper_dmabuf_export_fd { + /* IN parameters */ + /* hyper dmabuf id to be imported */ + int hyper_dmabuf_id; + /* flags */ + int flags; + /* OUT parameters */ + /* exported dma buf fd */ + int fd; +}; + +#define IOCTL_HYPER_DMABUF_UNEXPORT \ +_IOC(_IOC_NONE, 'G', 4, sizeof(struct ioctl_hyper_dmabuf_unexport)) +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; +}; + +#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 */ + int hyper_dmabuf_id; + /* item to be queried */ + int item; + /* OUT parameters */ + /* Value of queried item */ + int info; +}; + +#endif //__LINUX_PUBLIC_HYPER_DMABUF_H__ -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 28/60] hyper_dmabuf: address several synchronization issues Date: Tue, 19 Dec 2017 11:29:44 -0800 Message-ID: <1513711816-2618-28-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 RnJvbTogTWF0ZXVzeiBQb2xyb2xhIDxtYXRldXN6eC5wb3Ryb2xhQGludGVsLmNvbT4KClRoaXMg cGF0Y2ggYWRkcmVzc2VzIHNldmVyYWwgc3luY2hyb25pemF0aW9uIGlzc3VlcyB3aGlsZSBzaGFy aW5nCkRNQV9CVUYgd2l0aCBhbm90aGVyIFZNLgoKMS4gU2V0IFdBSVRfQUZURVJfU1lOQ19SRVEg dG8gZmFsc2UgYnkgZGVmYXVsdCB0byBwcmV2ZW50IHBvc3NpYmxlCiAgIHBlcmZvcm1hbmNlIGRl Z3JhZGF0aW9uIHdoZW4gd2FpbmcgZm9yIHRoZSByZXNwb25zZSBmb3IgZXZlcnkKICAgc3luY3Jo b25pemF0aW9uIHJlcXVlc3QgdG8gZXhwb3J0ZXIgVk0uCgoyLiBSZW1vdmVkIEhZUEVSX0RNQUJV Rl9PUFNfUkVMRUFTRV9GSU5BTCBtZXNzYWdlIC0gbm93IGV4cG9ydGVyIGNhbgogICBhdXRvbWF0 aWNhbGx5IGRldGVjdCB3aGVuIHRoZXJlIGFyZSBubyBtb3JlIGNvbnN1bWVycyBvZiBETUFfQlVG CiAgIHNvIGltcG9ydGVyIFZNIGRvZXNuJ3QgaGF2ZSB0byBzZW5kIG91dCB0aGlzIG1lc3NhZ2Uu CgozLiBSZW5hbWVkIEhZUEVSX0RNQUJVRl9GSVJTVF9FWFBPUlQgaW50byBIWVBFUl9ETUFCVUZf RVhQT1JUX0ZECgo0LiBJbnRyb2R1Y2VkIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkRfRkFJTEVEIG1l c3NhZ2UgdG8gdW5kbwogICBIWVBFUl9ETUFCVUZfRklSU1RfRVhQT1JUIGluIGNhc2Ugb2YgYW55 IGZhaWx1cmUgd2hpbGUgZXhlY3V0aW5nCiAgIGh5cGVyX2RtYWJ1Zl9leHBvcnRfZmRfaW9jdGwK CjUuIFdhaXRpbmcgdW50aWwgb3RoZXIgVk0gcHJvY2Vzc2VzIGFsbCBwZW5kaW5nIHJlcXVlc3Rz IHdoZW4gcmluZwogICBidWZmZXJzIGFyZSBhbGwgZnVsbC4KCjYuIENyZWF0ZSBoeXBlcl9kbWFi dWYuaCB3aXRoIGRlZmluaXRpb25zIG9mIGRyaXZlciBpbnRlcmZhY2UgdW5kZXIKICAgaW5jbHVk ZS91YXBpL3hlbi8KClNpZ25lZC1vZmYtYnk6IERvbmd3b24gS2ltIDxkb25nd29uLmtpbUBpbnRl bC5jb20+Ci0tLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pbXAuYyAg ICAgICAgfCAyMSArKy0tLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9p b2N0bC5jICAgICAgfCAxNyArKystCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1h YnVmX2lvY3RsLmggICAgICB8IDc0ICstLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3hlbi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5jICAgICAgICB8IDMwICsrKysrLS0KIGRyaXZlcnMv eGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmggICAgICAgIHwgIDQgKy0KIC4uLi94 ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jICAgIHwgMjQgKysrKy0t CiAuLi4veGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMgICB8ICA1 ICstCiBpbmNsdWRlL3VhcGkveGVuL2h5cGVyX2RtYWJ1Zi5oICAgICAgICAgICAgICAgICAgICB8 IDk2ICsrKysrKysrKysrKysrKysrKysrKysKIDggZmlsZXMgY2hhbmdlZCwgMTYzIGluc2VydGlv bnMoKyksIDEwOCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL3VhcGkv eGVuL2h5cGVyX2RtYWJ1Zi5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVm L2h5cGVyX2RtYWJ1Zl9pbXAuYyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFi dWZfaW1wLmMKaW5kZXggYTBiMzk0Ni4uNWEwMzRmZmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW1wLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pbXAuYwpAQCAtMTg3LDEwICsxODcsNyBAQCBpbnQgaHlwZXJf ZG1hYnVmX2NsZWFudXBfc2d0X2luZm8oc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqc2d0 X2luZm8sIGludCBmbwogCSAqIHNpZGUuCiAJICovCiAJaWYgKCFmb3JjZSAmJgotCSAgICAoIWxp c3RfZW1wdHkoJnNndF9pbmZvLT52YV9rbWFwcGVkLT5saXN0KSB8fAotCSAgICAhbGlzdF9lbXB0 eSgmc2d0X2luZm8tPnZhX3ZtYXBwZWQtPmxpc3QpIHx8Ci0JICAgICFsaXN0X2VtcHR5KCZzZ3Rf aW5mby0+YWN0aXZlX3NndHMtPmxpc3QpIHx8Ci0JICAgICFsaXN0X2VtcHR5KCZzZ3RfaW5mby0+ YWN0aXZlX2F0dGFjaGVkLT5saXN0KSkpIHsKKwkgICAgc2d0X2luZm8tPmltcG9ydGVyX2V4cG9y dGVkKSB7CiAJCWRldl93YXJuKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgImRtYS1idWYg aXMgdXNlZCBieSBpbXBvcnRlclxuIik7CiAJCXJldHVybiAtRVBFUk07CiAJfQpAQCAtMjU5LDcg KzI1Niw3IEBAIGludCBoeXBlcl9kbWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzdHJ1Y3QgaHlwZXJf ZG1hYnVmX3NndF9pbmZvICpzZ3RfaW5mbywgaW50IGZvCiAJcmV0dXJuIDA7CiB9CiAKLSNkZWZp bmUgV0FJVF9BRlRFUl9TWU5DX1JFUSAxCisjZGVmaW5lIFdBSVRfQUZURVJfU1lOQ19SRVEgMAog CiBpbmxpbmUgaW50IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3QoaW50IGlkLCBpbnQgZG1hYnVm X29wcykKIHsKQEAgLTQzMSwxNyArNDI4LDExIEBAIHN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9v cHNfcmVsZWFzZShzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZikKIAlmaW5hbF9yZWxlYXNlID0gc2d0 X2luZm8gJiYgIXNndF9pbmZvLT52YWxpZCAmJgogCQkgICAgICAgICFzZ3RfaW5mby0+bnVtX2lt cG9ydGVyczsKIAotCWlmIChmaW5hbF9yZWxlYXNlKSB7Ci0JCXJldCA9IGh5cGVyX2RtYWJ1Zl9z eW5jX3JlcXVlc3Qoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZCwKLQkJCQkJCUhZUEVSX0RNQUJV Rl9PUFNfUkVMRUFTRV9GSU5BTCk7Ci0JfSBlbHNlIHsKLQkJcmV0ID0gaHlwZXJfZG1hYnVmX3N5 bmNfcmVxdWVzdChzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX2lkLAotCQkJCQkJSFlQRVJfRE1BQlVG X09QU19SRUxFQVNFKTsKLQl9Ci0KKwlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0KHNn dF9pbmZvLT5oeXBlcl9kbWFidWZfaWQsCisJCQkJCUhZUEVSX0RNQUJVRl9PUFNfUkVMRUFTRSk7 CiAJaWYgKHJldCA8IDApIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2Us Ci0JCQkiaHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFp bGVkXG4iLCBfX2Z1bmNfXyk7CisJCWRldl93YXJuKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmlj ZSwKKwkJCSAiaHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3Qg ZmFpbGVkXG4iLCBfX2Z1bmNfXyk7CiAJfQogCiAJLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYyBiL2RyaXZlcnMveGVuL2h5cGVyX2Rt YWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYwppbmRleCAxOWNhNzI1Li41OGIxMTVhIDEwMDY0NAot LS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKKysrIGIv ZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jCkBAIC0zNSw2ICsz NSw3IEBACiAjaW5jbHVkZSA8bGludXgvZG1hLWJ1Zi5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5 Lmg+CiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUgPHhlbi9oeXBlcl9kbWFidWYu aD4KICNpbmNsdWRlICJoeXBlcl9kbWFidWZfc3RydWN0LmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1h YnVmX2lvY3RsLmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2xpc3QuaCIKQEAgLTI4MiwxMiAr MjgzLDE3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bCh2b2lkICpk YXRhKQogCS8qIHNlbmQgbm90aWZpY2F0aW9uIGZvciBleHBvcnRfZmQgdG8gZXhwb3J0ZXIgKi8K IAlvcGVyYW5kID0gc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9pZDsKIAorCWRldl9kYmcoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiRXhwb3J0aW5nIGZkIG9mIGJ1ZmZlciAlZFxuIiwgb3Bl cmFuZCk7CisKIAlyZXEgPSBrY2FsbG9jKDEsIHNpemVvZigqcmVxKSwgR0ZQX0tFUk5FTCk7Ci0J aHlwZXJfZG1hYnVmX2NyZWF0ZV9yZXF1ZXN0KHJlcSwgSFlQRVJfRE1BQlVGX0ZJUlNUX0VYUE9S VCwgJm9wZXJhbmQpOworCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChyZXEsIEhZUEVSX0RN QUJVRl9FWFBPUlRfRkQsICZvcGVyYW5kKTsKIAogCXJldCA9IG9wcy0+c2VuZF9yZXEoSFlQRVJf RE1BQlVGX0RPTV9JRChvcGVyYW5kKSwgcmVxLCB0cnVlKTsKIAogCWlmIChyZXQgPCAwKSB7CisJ CS8qIGluIGNhc2Ugb2YgdGltZW91dCBvdGhlciBlbmQgZXZlbnR1YWxseSB3aWxsIHJlY2VpdmUg cmVxdWVzdCwgc28gd2UgbmVlZCB0byB1bmRvIGl0ICovCisJCWh5cGVyX2RtYWJ1Zl9jcmVhdGVf cmVxdWVzdChyZXEsIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkRfRkFJTEVELCAmb3BlcmFuZCk7CisJ CW9wcy0+c2VuZF9yZXEoSFlQRVJfRE1BQlVGX0RPTV9JRChvcGVyYW5kKSwgcmVxLCBmYWxzZSk7 CiAJCWtmcmVlKHJlcSk7CiAJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAi RmFpbGVkIHRvIGNyZWF0ZSBzZ3Qgb3Igbm90aWZ5IGV4cG9ydGVyXG4iKTsKIAkJc2d0X2luZm8t Pm51bV9pbXBvcnRlcnMtLTsKQEAgLTI5OCwxMiArMzA0LDEyIEBAIHN0YXRpYyBpbnQgaHlwZXJf ZG1hYnVmX2V4cG9ydF9mZF9pb2N0bCh2b2lkICpkYXRhKQogCiAJaWYgKHJldCA9PSBIWVBFUl9E TUFCVUZfUkVRX0VSUk9SKSB7CiAJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNl LAotCQkJIkJ1ZmZlciBpbnZhbGlkXG4iKTsKKwkJCSJCdWZmZXIgaW52YWxpZCAlZCwgY2Fubm90 IGltcG9ydFxuIiwgb3BlcmFuZCk7CiAJCXNndF9pbmZvLT5udW1faW1wb3J0ZXJzLS07CiAJCW11 dGV4X3VubG9jaygmaHlwZXJfZG1hYnVmX3ByaXZhdGUubG9jayk7CiAJCXJldHVybiAtRUlOVkFM OwogCX0gZWxzZSB7Ci0JCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiQ2Fu IGltcG9ydCBidWZmZXJcbiIpOworCQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmlj ZSwgIkNhbiBpbXBvcnQgYnVmZmVyICVkXG4iLCBvcGVyYW5kKTsKIAkJcmV0ID0gMDsKIAl9CiAK QEAgLTMyMiw3ICszMjgsMTIgQEAgc3RhdGljIGludCBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkX2lv Y3RsKHZvaWQgKmRhdGEpCiAJCQkJCQkgICAmc2d0X2luZm8tPnJlZnNfaW5mbyk7CiAKIAkJaWYg KCFkYXRhX3BhZ2VzKSB7CisJCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwg IkNhbm5vdCBtYXAgcGFnZXMgb2YgYnVmZmVyICVkXG4iLCBvcGVyYW5kKTsKIAkJCXNndF9pbmZv LT5udW1faW1wb3J0ZXJzLS07CisJCQlyZXEgPSBrY2FsbG9jKDEsIHNpemVvZigqcmVxKSwgR0ZQ X0tFUk5FTCk7CisJCQloeXBlcl9kbWFidWZfY3JlYXRlX3JlcXVlc3QocmVxLCBIWVBFUl9ETUFC VUZfRVhQT1JUX0ZEX0ZBSUxFRCwgJm9wZXJhbmQpOworCQkJb3BzLT5zZW5kX3JlcShIWVBFUl9E TUFCVUZfRE9NX0lEKG9wZXJhbmQpLCByZXEsIGZhbHNlKTsKKwkJCWtmcmVlKHJlcSk7CiAJCQlt dXRleF91bmxvY2soJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmxvY2spOwogCQkJcmV0dXJuIC1FSU5W QUw7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFi dWZfaW9jdGwuaCBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwu aAppbmRleCA1NTg5NjRjLi44MzU1ZTMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9k bWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmgKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVm L2h5cGVyX2RtYWJ1Zl9pb2N0bC5oCkBAIC0yMiw4ICsyMiw4IEBACiAgKgogICovCiAKLSNpZm5k ZWYgX19MSU5VWF9QVUJMSUNfSFlQRVJfRE1BQlVGX0lPQ1RMX0hfXwotI2RlZmluZSBfX0xJTlVY X1BVQkxJQ19IWVBFUl9ETUFCVUZfSU9DVExfSF9fCisjaWZuZGVmIF9fSFlQRVJfRE1BQlVGX0lP Q1RMX0hfXworI2RlZmluZSBfX0hZUEVSX0RNQUJVRl9JT0NUTF9IX18KIAogdHlwZWRlZiBpbnQg KCpoeXBlcl9kbWFidWZfaW9jdGxfdCkodm9pZCAqZGF0YSk7CiAKQEAgLTQyLDcyICs0Miw0IEBA IHN0cnVjdCBoeXBlcl9kbWFidWZfaW9jdGxfZGVzYyB7CiAJCQkubmFtZSA9ICNpb2N0bAkJCVwK IAl9CiAKLSNkZWZpbmUgSU9DVExfSFlQRVJfRE1BQlVGX1RYX0NIX1NFVFVQIFwKLV9JT0MoX0lP Q19OT05FLCAnRycsIDAsIHNpemVvZihzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3R4X2NoX3Nl dHVwKSkKLXN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfdHhfY2hfc2V0dXAgewotCS8qIElOIHBh cmFtZXRlcnMgKi8KLQkvKiBSZW1vdGUgZG9tYWluIGlkICovCi0JaW50IHJlbW90ZV9kb21haW47 Ci19OwotCi0jZGVmaW5lIElPQ1RMX0hZUEVSX0RNQUJVRl9SWF9DSF9TRVRVUCBcCi1fSU9DKF9J T0NfTk9ORSwgJ0cnLCAxLCBzaXplb2Yoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9yeF9jaF9z ZXR1cCkpCi1zdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3J4X2NoX3NldHVwIHsKLQkvKiBJTiBw YXJhbWV0ZXJzICovCi0JLyogU291cmNlIGRvbWFpbiBpZCAqLwotCWludCBzb3VyY2VfZG9tYWlu OwotfTsKLQotI2RlZmluZSBJT0NUTF9IWVBFUl9ETUFCVUZfRVhQT1JUX1JFTU9URSBcCi1fSU9D KF9JT0NfTk9ORSwgJ0cnLCAyLCBzaXplb2Yoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9leHBv cnRfcmVtb3RlKSkKLXN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfZXhwb3J0X3JlbW90ZSB7Ci0J LyogSU4gcGFyYW1ldGVycyAqLwotCS8qIERNQSBidWYgZmQgdG8gYmUgZXhwb3J0ZWQgKi8KLQlp bnQgZG1hYnVmX2ZkOwotCS8qIERvbWFpbiBpZCB0byB3aGljaCBidWZmZXIgc2hvdWxkIGJlIGV4 cG9ydGVkICovCi0JaW50IHJlbW90ZV9kb21haW47Ci0JLyogZXhwb3J0ZWQgZG1hIGJ1ZiBpZCAq LwotCWludCBoeXBlcl9kbWFidWZfaWQ7Ci0JaW50IHByaXZhdGVbNF07Ci19OwotCi0jZGVmaW5l IElPQ1RMX0hZUEVSX0RNQUJVRl9FWFBPUlRfRkQgXAotX0lPQyhfSU9DX05PTkUsICdHJywgMywg c2l6ZW9mKHN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfZXhwb3J0X2ZkKSkKLXN0cnVjdCBpb2N0 bF9oeXBlcl9kbWFidWZfZXhwb3J0X2ZkIHsKLQkvKiBJTiBwYXJhbWV0ZXJzICovCi0JLyogaHlw ZXIgZG1hYnVmIGlkIHRvIGJlIGltcG9ydGVkICovCi0JaW50IGh5cGVyX2RtYWJ1Zl9pZDsKLQkv KiBmbGFncyAqLwotCWludCBmbGFnczsKLQkvKiBPVVQgcGFyYW1ldGVycyAqLwotCS8qIGV4cG9y dGVkIGRtYSBidWYgZmQgKi8KLQlpbnQgZmQ7Ci19OwotCi0jZGVmaW5lIElPQ1RMX0hZUEVSX0RN QUJVRl9VTkVYUE9SVCBcCi1fSU9DKF9JT0NfTk9ORSwgJ0cnLCA0LCBzaXplb2Yoc3RydWN0IGlv Y3RsX2h5cGVyX2RtYWJ1Zl91bmV4cG9ydCkpCi1zdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3Vu ZXhwb3J0IHsKLQkvKiBJTiBwYXJhbWV0ZXJzICovCi0JLyogaHlwZXIgZG1hYnVmIGlkIHRvIGJl IHVuZXhwb3J0ZWQgKi8KLQlpbnQgaHlwZXJfZG1hYnVmX2lkOwotCS8qIGRlbGF5IGluIG1zIGJ5 IHdoaWNoIHVuZXhwb3J0IHByb2Nlc3Npbmcgd2lsbCBiZSBwb3N0cG9uZWQgKi8KLQlpbnQgZGVs YXlfbXM7Ci0JLyogT1VUIHBhcmFtZXRlcnMgKi8KLQkvKiBTdGF0dXMgb2YgcmVxdWVzdCAqLwot CWludCBzdGF0dXM7Ci19OwotCi0jZGVmaW5lIElPQ1RMX0hZUEVSX0RNQUJVRl9RVUVSWSBcCi1f SU9DKF9JT0NfTk9ORSwgJ0cnLCA1LCBzaXplb2Yoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9x dWVyeSkpCi1zdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3F1ZXJ5IHsKLQkvKiBpbiBwYXJhbWV0 ZXJzICovCi0JLyogaHlwZXIgZG1hYnVmIGlkIHRvIGJlIHF1ZXJpZWQgKi8KLQlpbnQgaHlwZXJf ZG1hYnVmX2lkOwotCS8qIGl0ZW0gdG8gYmUgcXVlcmllZCAqLwotCWludCBpdGVtOwotCS8qIE9V VCBwYXJhbWV0ZXJzICovCi0JLyogVmFsdWUgb2YgcXVlcmllZCBpdGVtICovCi0JaW50IGluZm87 Ci19OwotCi0jZW5kaWYgLy9fX0xJTlVYX1BVQkxJQ19IWVBFUl9ETUFCVUZfRFJWX0hfXworI2Vu ZGlmIC8vX19IWVBFUl9ETUFCVUZfSU9DVExfSF9fCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVm L2h5cGVyX2RtYWJ1Zl9tc2cuYwppbmRleCA2ZTI0NDQyLi4zMTExY2RjIDEwMDY0NAotLS0gYS9k cml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5jCisrKyBiL2RyaXZlcnMv eGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMKQEAgLTc5LDkgKzc5LDEwIEBAIHZv aWQgaHlwZXJfZG1hYnVmX2NyZWF0ZV9yZXF1ZXN0KHN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpy ZXEsCiAJCXJlcS0+b3BlcmFuZHNbMF0gPSBvcGVyYW5kc1swXTsKIAkJYnJlYWs7CiAKLQljYXNl IEhZUEVSX0RNQUJVRl9GSVJTVF9FWFBPUlQ6Ci0JCS8qIGRtYWJ1ZiBmZCBpcyBiZWluZyBjcmVh dGVkIG9uIGltcG9ydGVkIHNpZGUgZm9yIGZpcnN0IHRpbWUgKi8KLQkJLyogY29tbWFuZCA6IEhZ UEVSX0RNQUJVRl9GSVJTVF9FWFBPUlQsCisJY2FzZSBIWVBFUl9ETUFCVUZfRVhQT1JUX0ZEOgor CWNhc2UgSFlQRVJfRE1BQlVGX0VYUE9SVF9GRF9GQUlMRUQ6CisJCS8qIGRtYWJ1ZiBmZCBpcyBi ZWluZyBjcmVhdGVkIG9uIGltcG9ydGVkIHNpZGUgb3IgaW1wb3J0aW5nIGZhaWxlZCAqLworCQkv KiBjb21tYW5kIDogSFlQRVJfRE1BQlVGX0VYUE9SVF9GRCBvciBIWVBFUl9ETUFCVUZfRVhQT1JU X0ZEX0ZBSUxFRCwKIAkJICogb3BlcmFuZHMwIDogaHlwZXJfZG1hYnVmX2lkCiAJCSAqLwogCQly ZXEtPm9wZXJhbmRzWzBdID0gb3BlcmFuZHNbMF07CkBAIC0yNDQsOCArMjQ1LDEwIEBAIGludCBo eXBlcl9kbWFidWZfbXNnX3BhcnNlKGludCBkb21pZCwgc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEg KnJlcSkKIAl9CiAKIAkvKiBzeW5jaHJvbm91cyBkbWFfYnVmX2ZkIGV4cG9ydCAqLwotCWlmIChy ZXEtPmNvbW1hbmQgPT0gSFlQRVJfRE1BQlVGX0ZJUlNUX0VYUE9SVCkgeworCWlmIChyZXEtPmNv bW1hbmQgPT0gSFlQRVJfRE1BQlVGX0VYUE9SVF9GRCkgewogCQkvKiBmaW5kIGEgY29ycmVzcG9u ZGluZyBTR1QgZm9yIHRoZSBpZCAqLworCQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRl dmljZSwKKwkJCSJQcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkQgJWRcbiIsIHJlcS0+ b3BlcmFuZHNbMF0pOwogCQlleHBfc2d0X2luZm8gPSBoeXBlcl9kbWFidWZfZmluZF9leHBvcnRl ZChyZXEtPm9wZXJhbmRzWzBdKTsKIAogCQlpZiAoIWV4cF9zZ3RfaW5mbykgewpAQCAtMjU0LDE3 ICsyNTcsMzIgQEAgaW50IGh5cGVyX2RtYWJ1Zl9tc2dfcGFyc2UoaW50IGRvbWlkLCBzdHJ1Y3Qg aHlwZXJfZG1hYnVmX3JlcSAqcmVxKQogCQkJcmVxLT5zdGF0dXMgPSBIWVBFUl9ETUFCVUZfUkVR X0VSUk9SOwogCQl9IGVsc2UgaWYgKCFleHBfc2d0X2luZm8tPnZhbGlkKSB7CiAJCQlkZXZfZGJn KGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiQnVmZmVyIG5vIGxvbmdlciB2YWxp ZCAtIGNhbm5vdCBleHBvcnRcbiIpOworCQkJCSJCdWZmZXIgbm8gbG9uZ2VyIHZhbGlkIC0gY2Fu bm90IGV4cG9ydCBmZCAlZFxuIiwgcmVxLT5vcGVyYW5kc1swXSk7CiAJCQlyZXEtPnN0YXR1cyA9 IEhZUEVSX0RNQUJVRl9SRVFfRVJST1I7CiAJCX0gZWxzZSB7CiAJCQlkZXZfZGJnKGh5cGVyX2Rt YWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiQnVmZmVyIHN0aWxsIHZhbGlkIC0gY2FuIGV4cG9y dFxuIik7CisJCQkJIkJ1ZmZlciBzdGlsbCB2YWxpZCAtIGNhbiBleHBvcnQgZmQlZFxuIiwgcmVx LT5vcGVyYW5kc1swXSk7CiAJCQlleHBfc2d0X2luZm8tPmltcG9ydGVyX2V4cG9ydGVkKys7CiAJ CQlyZXEtPnN0YXR1cyA9IEhZUEVSX0RNQUJVRl9SRVFfUFJPQ0VTU0VEOwogCQl9CiAJCXJldHVy biByZXEtPmNvbW1hbmQ7CiAJfQogCisJaWYgKHJlcS0+Y29tbWFuZCA9PSBIWVBFUl9ETUFCVUZf RVhQT1JUX0ZEX0ZBSUxFRCkgeworCQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmlj ZSwKKwkJCSJQcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkRfRkFJTEVEICVkXG4iLCBy ZXEtPm9wZXJhbmRzWzBdKTsKKwkJZXhwX3NndF9pbmZvID0gaHlwZXJfZG1hYnVmX2ZpbmRfZXhw b3J0ZWQocmVxLT5vcGVyYW5kc1swXSk7CisKKwkJaWYgKCFleHBfc2d0X2luZm8pIHsKKwkJCWRl dl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJCSJjcml0aWNhbCBlcnI6IHJl cXVlc3RlZCBzZ3RfaW5mbyBjYW4ndCBiZSBmb3VuZCAlZFxuIiwgcmVxLT5vcGVyYW5kc1swXSk7 CisJCQlyZXEtPnN0YXR1cyA9IEhZUEVSX0RNQUJVRl9SRVFfRVJST1I7CisJCX0gZWxzZSB7CisJ CQlleHBfc2d0X2luZm8tPmltcG9ydGVyX2V4cG9ydGVkLS07CisJCQlyZXEtPnN0YXR1cyA9IEhZ UEVSX0RNQUJVRl9SRVFfUFJPQ0VTU0VEOworCQl9CisJCXJldHVybiByZXEtPmNvbW1hbmQ7CisJ fQogCiAJZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCiAJCSIlczogcHV0dGlu ZyByZXF1ZXN0IHRvIHdvcmtxdWV1ZVxuIiwgX19mdW5jX18pOwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaCBiL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmgKaW5kZXggOGIzYzg1Ny4uNTBjZTYxNyAxMDA2NDQK LS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaAorKysgYi9k cml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5oCkBAIC00Myw3ICs0Myw4 IEBAIHN0cnVjdCBoeXBlcl9kbWFidWZfcmVzcCB7CiAKIGVudW0gaHlwZXJfZG1hYnVmX2NvbW1h bmQgewogCUhZUEVSX0RNQUJVRl9FWFBPUlQgPSAweDEwLAotCUhZUEVSX0RNQUJVRl9GSVJTVF9F WFBPUlQsCisJSFlQRVJfRE1BQlVGX0VYUE9SVF9GRCwKKwlIWVBFUl9ETUFCVUZfRVhQT1JUX0ZE X0ZBSUxFRCwKIAlIWVBFUl9ETUFCVUZfTk9USUZZX1VORVhQT1JULAogCUhZUEVSX0RNQUJVRl9P UFNfVE9fUkVNT1RFLAogCUhZUEVSX0RNQUJVRl9PUFNfVE9fU09VUkNFLApAQCAtNTUsNyArNTYs NiBAQCBlbnVtIGh5cGVyX2RtYWJ1Zl9vcHMgewogCUhZUEVSX0RNQUJVRl9PUFNfTUFQLAogCUhZ UEVSX0RNQUJVRl9PUFNfVU5NQVAsCiAJSFlQRVJfRE1BQlVGX09QU19SRUxFQVNFLAotCUhZUEVS X0RNQUJVRl9PUFNfUkVMRUFTRV9GSU5BTCwKIAlIWVBFUl9ETUFCVUZfT1BTX0JFR0lOX0NQVV9B Q0NFU1MsCiAJSFlQRVJfRE1BQlVGX09QU19FTkRfQ1BVX0FDQ0VTUywKIAlIWVBFUl9ETUFCVUZf T1BTX0tNQVBfQVRPTUlDLApkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5 cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9yZW1vdGVfc3luYy5jCmluZGV4IGE3NGU4MDAuLjBlZGVkNjEgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMuYworKysg Yi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jLmMKQEAg LTE1MiwxMyArMTUyLDI1IEBAIGludCBoeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMoaW50IGlkLCBp bnQgb3BzKQogCQlrZnJlZShzZ3RsKTsKIAkJYnJlYWs7CiAKLQljYXNlIEhZUEVSX0RNQUJVRl9P UFNfUkVMRUFTRV9GSU5BTDoKKwljYXNlIEhZUEVSX0RNQUJVRl9PUFNfUkVMRUFTRToKKwkJZGV2 X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCQkiQnVmZmVyICVkIHJlbGVhc2Vk LCByZWZlcmVuY2VzIGxlZnQ6ICVkXG4iLAorCQkJIHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQs CisJCQkgc2d0X2luZm8tPmltcG9ydGVyX2V4cG9ydGVkIC0xKTsKKyAgICAgICAgICAgICAgICBz Z3RfaW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQtLTsKKwkJLyogSWYgdGhlcmUgYXJlIHN0aWxsIGlt cG9ydGVycyBqdXN0IGJyZWFrLCBpZiBubyB0aGVuIGNvbnRpbnVlIHdpdGggZmluYWwgY2xlYW51 cCAqLworCQlpZiAoc2d0X2luZm8tPmltcG9ydGVyX2V4cG9ydGVkKQorCQkJYnJlYWs7CisKIAkJ LyoKIAkJICogSW1wb3J0ZXIganVzdCByZWxlYXNlZCBidWZmZXIgZmQsIGNoZWNrIGlmIHRoZXJl IGlzIGFueSBvdGhlciBpbXBvcnRlciBzdGlsbCB1c2luZyBpdC4KIAkJICogSWYgbm90IGFuZCBi dWZmZXIgd2FzIHVuZXhwb3J0ZWQsIGNsZWFuIHVwIHNoYXJlZCBkYXRhIGFuZCByZW1vdmUgdGhh dCBidWZmZXIuCiAJCSAqLwotCQkgaWYgKGxpc3RfZW1wdHkoJnNndF9pbmZvLT5hY3RpdmVfYXR0 YWNoZWQtPmxpc3QpICYmCi0JCSAgICAgIXNndF9pbmZvLT52YWxpZCkgeworCQlkZXZfZGJnKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJCSJCdWZmZXIgJWQgZmluYWwgcmVsZWFzZWRc biIsIHNndF9pbmZvLT5oeXBlcl9kbWFidWZfaWQpOworCisJCWlmICghc2d0X2luZm8tPnZhbGlk ICYmICFzZ3RfaW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQgJiYKKwkJICAgICFzZ3RfaW5mby0+dW5l eHBvcnRfc2NoZWR1bGVkKSB7CiAJCQloeXBlcl9kbWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzZ3Rf aW5mbywgZmFsc2UpOwogCQkJaHlwZXJfZG1hYnVmX3JlbW92ZV9leHBvcnRlZChpZCk7CiAJCQlr ZnJlZShzZ3RfaW5mbyk7CkBAIC0xNjgsMTIgKzE4MCw2IEBAIGludCBoeXBlcl9kbWFidWZfcmVt b3RlX3N5bmMoaW50IGlkLCBpbnQgb3BzKQogCiAJCWJyZWFrOwogCi0JY2FzZSBIWVBFUl9ETUFC VUZfT1BTX1JFTEVBU0U6Ci0JCS8qIHBsYWNlIGhvbGRlciAqLwotICAgICAgICAgICAgICAgIHNn dF9pbmZvLT5pbXBvcnRlcl9leHBvcnRlZC0tOwotCi0JCWJyZWFrOwotCiAJY2FzZSBIWVBFUl9E TUFCVUZfT1BTX0JFR0lOX0NQVV9BQ0NFU1M6CiAJCXJldCA9IGRtYV9idWZfYmVnaW5fY3B1X2Fj Y2VzcyhzZ3RfaW5mby0+ZG1hX2J1ZiwgRE1BX0JJRElSRUNUSU9OQUwpOwogCQlpZiAocmV0KSB7 CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94 ZW5fY29tbS5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVu X2NvbW0uYwppbmRleCAyY2MzNWUzLi5jZTk4NjJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5jCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMKQEAgLTUxOSw4ICs1MTks OSBAQCBpbnQgaHlwZXJfZG1hYnVmX3hlbl9zZW5kX3JlcShpbnQgZG9taWQsIHN0cnVjdCBoeXBl cl9kbWFidWZfcmVxICpyZXEsIGludCB3YWl0KQogCiAJcmluZyA9ICZyaW5nX2luZm8tPnJpbmdf ZnJvbnQ7CiAKLQlpZiAoUklOR19GVUxMKHJpbmcpKQotCQlyZXR1cm4gLUVCVVNZOworCXdoaWxl IChSSU5HX0ZVTEwocmluZykpIHsKKwkJdXNsZWVwX3JhbmdlKDEwMCwgMTIwKTsKKwl9CiAKIAlu ZXdfcmVxID0gUklOR19HRVRfUkVRVUVTVChyaW5nLCByaW5nLT5yZXFfcHJvZF9wdnQpOwogCWlm ICghbmV3X3JlcSkgewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL3hlbi9oeXBlcl9kbWFidWYu aCBiL2luY2x1ZGUvdWFwaS94ZW4vaHlwZXJfZG1hYnVmLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uMmVmZjNhOGUKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3VhcGkv eGVuL2h5cGVyX2RtYWJ1Zi5oCkBAIC0wLDAgKzEsOTYgQEAKKy8qCisgKiBDb3B5cmlnaHQgwqkg MjAxNyBJbnRlbCBDb3Jwb3JhdGlvbgorICoKKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50 ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCisgKiBjb3B5IG9m IHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJT b2Z0d2FyZSIpLAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlv biwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICogdGhlIHJpZ2h0cyB0byB1c2UsIGNv cHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCisgKiBh bmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMg dG8gd2hvbSB0aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0 byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKgorICogVGhlIGFib3ZlIGNvcHlyaWdodCBu b3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2UgKGluY2x1ZGluZyB0aGUgbmV4dAorICog cGFyYWdyYXBoKSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFs IHBvcnRpb25zIG9mIHRoZQorICogU29mdHdhcmUuCisgKgorICogVEhFIFNPRlRXQVJFIElTIFBS T1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IK KyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Ug QU5EIE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNIQUxMCisgKiBUSEUgQVVUSE9SUyBP UiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBP VEhFUgorICogTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9S VCBPUiBPVEhFUldJU0UsIEFSSVNJTkcKKyAqIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9O IFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MKKyAqIElOIFRI RSBTT0ZUV0FSRS4KKyAqCisgKi8KKworI2lmbmRlZiBfX0xJTlVYX1BVQkxJQ19IWVBFUl9ETUFC VUZfSF9fCisjZGVmaW5lIF9fTElOVVhfUFVCTElDX0hZUEVSX0RNQUJVRl9IX18KKworI2RlZmlu ZSBJT0NUTF9IWVBFUl9ETUFCVUZfVFhfQ0hfU0VUVVAgXAorX0lPQyhfSU9DX05PTkUsICdHJywg MCwgc2l6ZW9mKHN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfdHhfY2hfc2V0dXApKQorc3RydWN0 IGlvY3RsX2h5cGVyX2RtYWJ1Zl90eF9jaF9zZXR1cCB7CisJLyogSU4gcGFyYW1ldGVycyAqLwor CS8qIFJlbW90ZSBkb21haW4gaWQgKi8KKwlpbnQgcmVtb3RlX2RvbWFpbjsKK307CisKKyNkZWZp bmUgSU9DVExfSFlQRVJfRE1BQlVGX1JYX0NIX1NFVFVQIFwKK19JT0MoX0lPQ19OT05FLCAnRycs IDEsIHNpemVvZihzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3J4X2NoX3NldHVwKSkKK3N0cnVj dCBpb2N0bF9oeXBlcl9kbWFidWZfcnhfY2hfc2V0dXAgeworCS8qIElOIHBhcmFtZXRlcnMgKi8K KwkvKiBTb3VyY2UgZG9tYWluIGlkICovCisJaW50IHNvdXJjZV9kb21haW47Cit9OworCisjZGVm aW5lIElPQ1RMX0hZUEVSX0RNQUJVRl9FWFBPUlRfUkVNT1RFIFwKK19JT0MoX0lPQ19OT05FLCAn RycsIDIsIHNpemVvZihzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGUpKQor c3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlIHsKKwkvKiBJTiBwYXJhbWV0 ZXJzICovCisJLyogRE1BIGJ1ZiBmZCB0byBiZSBleHBvcnRlZCAqLworCWludCBkbWFidWZfZmQ7 CisJLyogRG9tYWluIGlkIHRvIHdoaWNoIGJ1ZmZlciBzaG91bGQgYmUgZXhwb3J0ZWQgKi8KKwlp bnQgcmVtb3RlX2RvbWFpbjsKKwkvKiBleHBvcnRlZCBkbWEgYnVmIGlkICovCisJaW50IGh5cGVy X2RtYWJ1Zl9pZDsKKwlpbnQgcHJpdmF0ZVs0XTsKK307CisKKyNkZWZpbmUgSU9DVExfSFlQRVJf RE1BQlVGX0VYUE9SVF9GRCBcCitfSU9DKF9JT0NfTk9ORSwgJ0cnLCAzLCBzaXplb2Yoc3RydWN0 IGlvY3RsX2h5cGVyX2RtYWJ1Zl9leHBvcnRfZmQpKQorc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1 Zl9leHBvcnRfZmQgeworCS8qIElOIHBhcmFtZXRlcnMgKi8KKwkvKiBoeXBlciBkbWFidWYgaWQg dG8gYmUgaW1wb3J0ZWQgKi8KKwlpbnQgaHlwZXJfZG1hYnVmX2lkOworCS8qIGZsYWdzICovCisJ aW50IGZsYWdzOworCS8qIE9VVCBwYXJhbWV0ZXJzICovCisJLyogZXhwb3J0ZWQgZG1hIGJ1ZiBm ZCAqLworCWludCBmZDsKK307CisKKyNkZWZpbmUgSU9DVExfSFlQRVJfRE1BQlVGX1VORVhQT1JU IFwKK19JT0MoX0lPQ19OT05FLCAnRycsIDQsIHNpemVvZihzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1h YnVmX3VuZXhwb3J0KSkKK3N0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfdW5leHBvcnQgeworCS8q IElOIHBhcmFtZXRlcnMgKi8KKwkvKiBoeXBlciBkbWFidWYgaWQgdG8gYmUgdW5leHBvcnRlZCAq LworCWludCBoeXBlcl9kbWFidWZfaWQ7CisJLyogZGVsYXkgaW4gbXMgYnkgd2hpY2ggdW5leHBv cnQgcHJvY2Vzc2luZyB3aWxsIGJlIHBvc3Rwb25lZCAqLworCWludCBkZWxheV9tczsKKwkvKiBP VVQgcGFyYW1ldGVycyAqLworCS8qIFN0YXR1cyBvZiByZXF1ZXN0ICovCisJaW50IHN0YXR1czsK K307CisKKyNkZWZpbmUgSU9DVExfSFlQRVJfRE1BQlVGX1FVRVJZIFwKK19JT0MoX0lPQ19OT05F LCAnRycsIDUsIHNpemVvZihzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3F1ZXJ5KSkKK3N0cnVj dCBpb2N0bF9oeXBlcl9kbWFidWZfcXVlcnkgeworCS8qIGluIHBhcmFtZXRlcnMgKi8KKwkvKiBo eXBlciBkbWFidWYgaWQgdG8gYmUgcXVlcmllZCAqLworCWludCBoeXBlcl9kbWFidWZfaWQ7CisJ LyogaXRlbSB0byBiZSBxdWVyaWVkICovCisJaW50IGl0ZW07CisJLyogT1VUIHBhcmFtZXRlcnMg Ki8KKwkvKiBWYWx1ZSBvZiBxdWVyaWVkIGl0ZW0gKi8KKwlpbnQgaW5mbzsKK307CisKKyNlbmRp ZiAvL19fTElOVVhfUFVCTElDX0hZUEVSX0RNQUJVRl9IX18KLS0gCjIuNy40CgoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcg bGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9q ZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA==