From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753163AbdLSTu7 (ORCPT ); Tue, 19 Dec 2017 14:50:59 -0500 Received: from mga01.intel.com ([192.55.52.88]:17630 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752840AbdLSTgc (ORCPT ); Tue, 19 Dec 2017 14:36:32 -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="4018495" 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 08/60] hyper_dmabuf: automatic comm channel initialization using xenstore Date: Tue, 19 Dec 2017 11:29:24 -0800 Message-Id: <1513711816-2618-8-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 introduces use of xenstore for creating and managing communication channels between two VMs in the system. When hyper_dmabuf driver is loaded in the service VM (host OS), a new xenstore directory, "/local/domain//data/hyper_dmabuf" is created in xenstore filesystem. Whenever a new guest OS creates and initailizes its own upstream channel the service VM, new directory is created under the main directory created above as shown here: /local/domain//data/hyper_dmabuf//port /local/domain//data/hyper_dmabuf//gref This patch also adds a "xenstore watch" callback is called when a new upstream connection is made from another VM (VM-b). Upon detection, this VM (VM-a) intializes a downstream channel ,paired with detected upstream connection as shown below. VM-a (downstream) <----- (upstream) VM-a And as soon as this downstream channel is created, a new upstream channel from VM-a to VM-b is automatically created and initialized via "xenstore watch" call back on VM-b. VM-a (upstream) <----- (downstream) VM-b As a result, there will be bi-directional communication channel available between two VMs. When upstream channel is removed (e.g. unloading driver), VM on the other side is notified and "xenstore watch" callback is invoked. Via this callback, VM can remove corresponding downstream channel. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 11 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 14 -- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 30 +-- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 31 +-- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 2 - .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 226 +++++++++++++++++++-- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h | 18 +- .../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c | 22 ++ .../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h | 6 + 9 files changed, 270 insertions(+), 90 deletions(-) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c index 70b4878..5b5dae44 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c @@ -6,6 +6,7 @@ #include "hyper_dmabuf_conf.h" #include "hyper_dmabuf_list.h" #include "xen/hyper_dmabuf_xen_comm_list.h" +#include "xen/hyper_dmabuf_xen_comm.h" MODULE_LICENSE("Dual BSD/GPL"); MODULE_AUTHOR("IOTG-PED, INTEL"); @@ -43,6 +44,11 @@ static int hyper_dmabuf_drv_init(void) return -EINVAL; } + ret = hyper_dmabuf_setup_data_dir(); + if (ret < 0) { + return -EINVAL; + } + /* interrupt for comm should be registered here: */ return ret; } @@ -52,12 +58,15 @@ static void hyper_dmabuf_drv_exit(void) { /* hash tables for export/import entries and ring_infos */ hyper_dmabuf_table_destroy(); - hyper_dmabuf_ring_table_init(); + + hyper_dmabuf_cleanup_ringbufs(); + hyper_dmabuf_ring_table_destroy(); /* destroy workqueue */ if (hyper_dmabuf_private.work_queue) destroy_workqueue(hyper_dmabuf_private.work_queue); + hyper_dmabuf_destroy_data_dir(); printk( KERN_NOTICE "dma_buf-src_sink model: Exiting" ); unregister_device(); } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h index 6145d29..7511afb 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h @@ -29,8 +29,6 @@ struct ioctl_hyper_dmabuf_exporter_ring_setup { /* IN parameters */ /* Remote domain id */ uint32_t remote_domain; - grant_ref_t ring_refid; /* assigned by driver, copied to userspace after initialization */ - uint32_t port; /* assigned by driver, copied to userspace after initialization */ }; #define IOCTL_HYPER_DMABUF_IMPORTER_RING_SETUP \ @@ -39,10 +37,6 @@ struct ioctl_hyper_dmabuf_importer_ring_setup { /* IN parameters */ /* Source domain id */ uint32_t source_domain; - /* Ring shared page refid */ - grant_ref_t ring_refid; - /* Port number */ - uint32_t port; }; #define IOCTL_HYPER_DMABUF_EXPORT_REMOTE \ @@ -95,12 +89,4 @@ struct ioctl_hyper_dmabuf_query { uint32_t info; }; -#define IOCTL_HYPER_DMABUF_REMOTE_EXPORTER_RING_SETUP \ -_IOC(_IOC_NONE, 'G', 6, sizeof(struct ioctl_hyper_dmabuf_remote_exporter_ring_setup)) -struct ioctl_hyper_dmabuf_remote_exporter_ring_setup { - /* in parameters */ - uint32_t rdomain; /* id of remote domain where exporter's ring need to be setup */ - uint32_t info; -}; - #endif //__LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index e4d8316..44a153b 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -48,9 +48,7 @@ static int hyper_dmabuf_exporter_ring_setup(void *data) return 0; } - ret = hyper_dmabuf_exporter_ringbuf_init(ring_attr->remote_domain, - &ring_attr->ring_refid, - &ring_attr->port); + ret = hyper_dmabuf_exporter_ringbuf_init(ring_attr->remote_domain); return ret; } @@ -76,10 +74,7 @@ static int hyper_dmabuf_importer_ring_setup(void *data) return 0; } - /* user need to provide a port number and ref # for the page used as ring buffer */ - ret = hyper_dmabuf_importer_ringbuf_init(setup_imp_ring_attr->source_domain, - setup_imp_ring_attr->ring_refid, - setup_imp_ring_attr->port); + ret = hyper_dmabuf_importer_ringbuf_init(setup_imp_ring_attr->source_domain); return ret; } @@ -355,26 +350,6 @@ static int hyper_dmabuf_query(void *data) return ret; } -static int hyper_dmabuf_remote_exporter_ring_setup(void *data) -{ - struct ioctl_hyper_dmabuf_remote_exporter_ring_setup *remote_exporter_ring_setup; - struct hyper_dmabuf_ring_rq *req; - - remote_exporter_ring_setup = (struct ioctl_hyper_dmabuf_remote_exporter_ring_setup *)data; - - req = kcalloc(1, sizeof(*req), GFP_KERNEL); - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORTER_RING_SETUP, NULL); - - /* requesting remote domain to set-up exporter's ring */ - if(hyper_dmabuf_send_request(remote_exporter_ring_setup->rdomain, req) < 0) { - kfree(req); - return -EINVAL; - } - - kfree(req); - return 0; -} - static const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = { HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORTER_RING_SETUP, hyper_dmabuf_exporter_ring_setup, 0), HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_IMPORTER_RING_SETUP, hyper_dmabuf_importer_ring_setup, 0), @@ -382,7 +357,6 @@ static const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = { HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORT_FD, hyper_dmabuf_export_fd_ioctl, 0), HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_DESTROY, hyper_dmabuf_destroy, 0), HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_QUERY, hyper_dmabuf_query, 0), - HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_REMOTE_EXPORTER_RING_SETUP, hyper_dmabuf_remote_exporter_ring_setup, 0), }; static long hyper_dmabuf_ioctl(struct file *filp, diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c index 0166e61..8a059c8 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c @@ -70,12 +70,6 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request, request->operands[i] = operands[i]; break; - /* requesting the other side to setup another ring channel for reverse direction */ - case HYPER_DMABUF_EXPORTER_RING_SETUP: - /* command : HYPER_DMABUF_EXPORTER_RING_SETUP */ - /* no operands needed */ - break; - default: /* no command found */ return; @@ -163,13 +157,6 @@ void cmd_process_work(struct work_struct *work) */ break; - case HYPER_DMABUF_IMPORTER_RING_SETUP: - /* command: HYPER_DMABUF_IMPORTER_RING_SETUP */ - /* no operands needed */ - hyper_dmabuf_importer_ringbuf_init(domid, req->operands[0], req->operands[1]); - - break; - default: /* shouldn't get here */ /* no matched command, nothing to do.. just return error */ @@ -185,7 +172,6 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req) struct cmd_process *proc; struct hyper_dmabuf_ring_rq *temp_req; struct hyper_dmabuf_imported_sgt_info *imported_sgt_info; - int ret; if (!req) { printk("request is NULL\n"); @@ -193,28 +179,13 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req) } if ((req->command < HYPER_DMABUF_EXPORT) || - (req->command > HYPER_DMABUF_IMPORTER_RING_SETUP)) { + (req->command > HYPER_DMABUF_OPS_TO_SOURCE)) { printk("invalid command\n"); return -EINVAL; } req->status = HYPER_DMABUF_REQ_PROCESSED; - /* HYPER_DMABUF_EXPORTER_RING_SETUP requires immediate - * follow up so can't be processed in workqueue - */ - if (req->command == HYPER_DMABUF_EXPORTER_RING_SETUP) { - ret = hyper_dmabuf_exporter_ringbuf_init(domid, &req->operands[0], &req->operands[1]); - if (ret < 0) { - req->status = HYPER_DMABUF_REQ_ERROR; - } - - req->status = HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP; - req->command = HYPER_DMABUF_IMPORTER_RING_SETUP; - - return req->command; - } - /* HYPER_DMABUF_DESTROY requires immediate * follow up so can't be processed in workqueue */ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h index 44bfb70..9b25bdb 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h @@ -7,8 +7,6 @@ enum hyper_dmabuf_command { HYPER_DMABUF_DESTROY_FINISH, HYPER_DMABUF_OPS_TO_REMOTE, HYPER_DMABUF_OPS_TO_SOURCE, - HYPER_DMABUF_EXPORTER_RING_SETUP, /* requesting remote domain to set up exporter's ring */ - HYPER_DMABUF_IMPORTER_RING_SETUP, /* requesting remote domain to set up importer's ring */ }; enum hyper_dmabuf_ops { 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 05855ba1..5db58b0 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c @@ -15,6 +15,83 @@ static int export_req_id = 0; +/* Creates entry in xen store that will keep details of all exporter rings created by this domain */ +int32_t hyper_dmabuf_setup_data_dir() +{ + char buf[255]; + + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_get_domid()); + return xenbus_mkdir(XBT_NIL, buf, ""); +} + + +/* Removes entry from xenstore with exporter ring details. + * Other domains that has connected to any of exporter rings created by this domain, + * will be notified about removal of this entry and will treat that as signal to + * cleanup importer rings created for this domain + */ +int32_t hyper_dmabuf_destroy_data_dir() +{ + char buf[255]; + + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_get_domid()); + return xenbus_rm(XBT_NIL, buf, ""); +} + +/* + * Adds xenstore entries with details of exporter ring created for given remote domain. + * It requires special daemon running in dom0 to make sure that given remote domain will + * have right permissions to access that data. + */ +static int32_t hyper_dmabuf_expose_ring_details(uint32_t domid, uint32_t rdomid, uint32_t grefid, uint32_t port) +{ + char buf[255]; + int ret; + + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", domid, rdomid); + ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", grefid); + + if (ret) { + printk("Failed to write xenbus entry %s: %d\n", buf, ret); + return ret; + } + + ret = xenbus_printf(XBT_NIL, buf, "port", "%d", port); + + if (ret) { + printk("Failed to write xenbus entry %s: %d\n", buf, ret); + return ret; + } + + return 0; +} + +/* + * Queries details of ring exposed by remote domain. + */ +static int32_t hyper_dmabuf_get_ring_details(uint32_t domid, uint32_t rdomid, uint32_t *grefid, uint32_t *port) +{ + char buf[255]; + int ret; + + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", rdomid, domid); + ret = xenbus_scanf(XBT_NIL, buf, "grefid", "%d", grefid); + + if (ret <= 0) { + printk("Failed to read xenbus entry %s: %d\n", buf, ret); + return ret; + } + + ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", port); + + if (ret <= 0) { + printk("Failed to read xenbus entry %s: %d\n", buf, ret); + return ret; + } + + return (ret <= 0 ? 1 : 0); +} + int32_t hyper_dmabuf_get_domid(void) { struct xenbus_transaction xbt; @@ -40,8 +117,49 @@ int hyper_dmabuf_next_req_id_export(void) static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *dev_id); static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *dev_id); +/* + * Callback function that will be called on any change of xenbus path being watched. + * Used for detecting creation/destruction of remote domain exporter ring. + * When remote domain's exporter ring will be detected, importer ring on this domain will be created. + * When remote domain's exporter ring destruction will be detected it will celanup this domain importer ring. + * Destruction can be caused by unloading module by remote domain or it's crash/force shutdown. + */ +static void remote_domain_exporter_watch_cb(struct xenbus_watch *watch, + const char *path, const char *token) +{ + int rdom,ret; + uint32_t grefid, port; + struct hyper_dmabuf_ring_info_import *ring_info; + + /* Check which domain has changed its exporter rings */ + ret = sscanf(watch->node, "/local/domain/%d/", &rdom); + if (ret <= 0) { + return; + } + + /* Check if we have importer ring for given remote domain alrady created */ + ring_info = hyper_dmabuf_find_importer_ring(rdom); + + /* + * Try to query remote domain exporter ring details - if that will fail and we have + * importer ring that means remote domains has cleanup its exporter ring, so our + * importer ring is no longer useful. + * If querying details will succeed and we don't have importer ring, it means that + * remote domain has setup it for us and we should connect to it. + */ + ret = hyper_dmabuf_get_ring_details(hyper_dmabuf_get_domid(), rdom, &grefid, &port); + + if (ring_info && ret != 0) { + printk("Remote exporter closed, cleaninup importer\n"); + hyper_dmabuf_importer_ringbuf_cleanup(rdom); + } else if (!ring_info && ret == 0) { + printk("Registering importer\n"); + hyper_dmabuf_importer_ringbuf_init(rdom); + } +} + /* exporter needs to generated info for page sharing */ -int hyper_dmabuf_exporter_ringbuf_init(int rdomain, grant_ref_t *refid, int *port) +int hyper_dmabuf_exporter_ringbuf_init(int rdomain) { struct hyper_dmabuf_ring_info_export *ring_info; struct hyper_dmabuf_sring *sring; @@ -99,24 +217,58 @@ int hyper_dmabuf_exporter_ringbuf_init(int rdomain, grant_ref_t *refid, int *por ring_info->irq = ret; ring_info->port = alloc_unbound.port; - /* store refid and port numbers for userspace's use */ - *refid = ring_info->gref_ring; - *port = ring_info->port; - printk("%s: allocated eventchannel gref %d port: %d irq: %d\n", __func__, ring_info->gref_ring, ring_info->port, ring_info->irq); - /* register ring info */ ret = hyper_dmabuf_register_exporter_ring(ring_info); + ret = hyper_dmabuf_expose_ring_details(hyper_dmabuf_get_domid(), rdomain, + ring_info->gref_ring, ring_info->port); + + /* + * Register watch for remote domain exporter ring. + * When remote domain will setup its exporter ring, we will automatically connect our importer ring to it. + */ + ring_info->watch.callback = remote_domain_exporter_watch_cb; + ring_info->watch.node = (const char*) kmalloc(sizeof(char) * 255, GFP_KERNEL); + sprintf((char*)ring_info->watch.node, "/local/domain/%d/data/hyper_dmabuf/%d/port", rdomain, hyper_dmabuf_get_domid()); + register_xenbus_watch(&ring_info->watch); + return ret; } +/* cleans up exporter ring created for given remote domain */ +void hyper_dmabuf_exporter_ringbuf_cleanup(int rdomain) +{ + struct hyper_dmabuf_ring_info_export *ring_info; + + /* check if we at all have exporter ring for given rdomain */ + ring_info = hyper_dmabuf_find_exporter_ring(rdomain); + + if (!ring_info) { + return; + } + + hyper_dmabuf_remove_exporter_ring(rdomain); + + unregister_xenbus_watch(&ring_info->watch); + kfree(ring_info->watch.node); + + /* No need to close communication channel, will be done by this function */ + unbind_from_irqhandler(ring_info->irq, (void*) ring_info); + + /* No need to free sring page, will be freed by this function when other side will end its access */ + gnttab_end_foreign_access(ring_info->gref_ring, 0, + (unsigned long) ring_info->ring_front.sring); + + kfree(ring_info); +} + /* importer needs to know about shared page and port numbers for ring buffer and event channel */ -int hyper_dmabuf_importer_ringbuf_init(int sdomain, grant_ref_t gref, int port) +int hyper_dmabuf_importer_ringbuf_init(int sdomain) { struct hyper_dmabuf_ring_info_import *ring_info; struct hyper_dmabuf_sring *sring; @@ -124,24 +276,33 @@ int hyper_dmabuf_importer_ringbuf_init(int sdomain, grant_ref_t gref, int port) struct page *shared_ring; struct gnttab_map_grant_ref *ops; - struct gnttab_unmap_grant_ref *unmap_ops; int ret; + int importer_gref, importer_port; + + ret = hyper_dmabuf_get_ring_details(hyper_dmabuf_get_domid(), sdomain, + &importer_gref, &importer_port); + + if (ret) { + printk("Domain %d has not created exporter ring for current domain\n", sdomain); + return ret; + } ring_info = (struct hyper_dmabuf_ring_info_import *) kmalloc(sizeof(*ring_info), GFP_KERNEL); ring_info->sdomain = sdomain; - ring_info->evtchn = port; + ring_info->evtchn = importer_port; ops = (struct gnttab_map_grant_ref*)kmalloc(sizeof(*ops), GFP_KERNEL); - unmap_ops = (struct gnttab_unmap_grant_ref*)kmalloc(sizeof(*unmap_ops), GFP_KERNEL); if (gnttab_alloc_pages(1, &shared_ring)) { return -EINVAL; } gnttab_set_map_op(&ops[0], (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)), - GNTMAP_host_map, gref, sdomain); + GNTMAP_host_map, importer_gref, sdomain); + gnttab_set_unmap_op(&ring_info->unmap_op, (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)), + GNTMAP_host_map, -1); ret = gnttab_map_refs(ops, NULL, &shared_ring, 1); if (ret < 0) { @@ -152,13 +313,15 @@ int hyper_dmabuf_importer_ringbuf_init(int sdomain, grant_ref_t gref, int port) if (ops[0].status) { printk("Ring mapping failed\n"); return -EINVAL; + } else { + ring_info->unmap_op.handle = ops[0].handle; } sring = (struct hyper_dmabuf_sring*) pfn_to_kaddr(page_to_pfn(shared_ring)); BACK_RING_INIT(&ring_info->ring_back, sring, PAGE_SIZE); - ret = bind_interdomain_evtchn_to_irqhandler(sdomain, port, + ret = bind_interdomain_evtchn_to_irqhandler(sdomain, importer_port, hyper_dmabuf_back_ring_isr, 0, NULL, (void*)ring_info); if (ret < 0) { @@ -168,14 +331,51 @@ int hyper_dmabuf_importer_ringbuf_init(int sdomain, grant_ref_t gref, int port) ring_info->irq = ret; printk("%s: bound to eventchannel port: %d irq: %d\n", __func__, - port, + importer_port, ring_info->irq); ret = hyper_dmabuf_register_importer_ring(ring_info); + /* Setup communcation channel in opposite direction */ + if (!hyper_dmabuf_find_exporter_ring(sdomain)) { + ret = hyper_dmabuf_exporter_ringbuf_init(sdomain); + } + return ret; } +/* clenas up importer ring create for given source domain */ +void hyper_dmabuf_importer_ringbuf_cleanup(int sdomain) +{ + struct hyper_dmabuf_ring_info_import *ring_info; + struct page *shared_ring; + + /* check if we have importer ring created for given sdomain */ + ring_info = hyper_dmabuf_find_importer_ring(sdomain); + + if (!ring_info) + return; + + hyper_dmabuf_remove_importer_ring(sdomain); + + /* no need to close event channel, will be done by that function */ + unbind_from_irqhandler(ring_info->irq, (void*) ring_info); + + /* unmapping shared ring page */ + shared_ring = virt_to_page(ring_info->ring_back.sring); + gnttab_unmap_refs(&ring_info->unmap_op, NULL, &shared_ring, 1); + gnttab_free_pages(1, &shared_ring); + + kfree(ring_info); +} + +/* cleans up all exporter/importer rings */ +void hyper_dmabuf_cleanup_ringbufs(void) +{ + hyper_dmabuf_foreach_exporter_ring(hyper_dmabuf_exporter_ringbuf_cleanup); + hyper_dmabuf_foreach_importer_ring(hyper_dmabuf_importer_ringbuf_cleanup); +} + int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req) { struct hyper_dmabuf_front_ring *ring; diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h index 4ad0529..a4819ca 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h @@ -2,6 +2,7 @@ #define __HYPER_DMABUF_XEN_COMM_H__ #include "xen/interface/io/ring.h" +#include "xen/xenbus.h" #define MAX_NUMBER_OF_OPERANDS 9 @@ -27,6 +28,7 @@ struct hyper_dmabuf_ring_info_export { int gref_ring; int irq; int port; + struct xenbus_watch watch; }; struct hyper_dmabuf_ring_info_import { @@ -34,17 +36,29 @@ struct hyper_dmabuf_ring_info_import { int irq; int evtchn; struct hyper_dmabuf_back_ring ring_back; + struct gnttab_unmap_grant_ref unmap_op; }; int32_t hyper_dmabuf_get_domid(void); +int32_t hyper_dmabuf_setup_data_dir(void); +int32_t hyper_dmabuf_destroy_data_dir(void); int hyper_dmabuf_next_req_id_export(void); /* exporter needs to generated info for page sharing */ -int hyper_dmabuf_exporter_ringbuf_init(int rdomain, grant_ref_t *gref, int *port); +int hyper_dmabuf_exporter_ringbuf_init(int rdomain); /* importer needs to know about shared page and port numbers for ring buffer and event channel */ -int hyper_dmabuf_importer_ringbuf_init(int sdomain, grant_ref_t gref, int port); +int hyper_dmabuf_importer_ringbuf_init(int sdomain); + +/* cleans up exporter ring created for given domain */ +void hyper_dmabuf_exporter_ringbuf_cleanup(int rdomain); + +/* cleans up importer ring created for given domain */ +void hyper_dmabuf_importer_ringbuf_cleanup(int sdomain); + +/* cleans up all exporter/importer rings */ +void hyper_dmabuf_cleanup_ringbufs(void); /* send request to the remote domain */ int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req); diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c index 15c9d29..5778468 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c @@ -104,3 +104,25 @@ int hyper_dmabuf_remove_importer_ring(int domid) return -1; } + +void hyper_dmabuf_foreach_exporter_ring(void (*func)(int rdom)) +{ + struct hyper_dmabuf_exporter_ring_info *info_entry; + struct hlist_node *tmp; + int bkt; + + hash_for_each_safe(hyper_dmabuf_hash_exporter_ring, bkt, tmp, info_entry, node) { + func(info_entry->info->rdomain); + } +} + +void hyper_dmabuf_foreach_importer_ring(void (*func)(int sdom)) +{ + struct hyper_dmabuf_importer_ring_info *info_entry; + struct hlist_node *tmp; + int bkt; + + hash_for_each_safe(hyper_dmabuf_hash_importer_ring, bkt, tmp, info_entry, node) { + func(info_entry->info->sdomain); + } +} diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h index 5929f99..fd1958c 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h @@ -32,4 +32,10 @@ int hyper_dmabuf_remove_exporter_ring(int domid); int hyper_dmabuf_remove_importer_ring(int domid); +/* iterates over all exporter rings and calls provided function for each of them */ +void hyper_dmabuf_foreach_exporter_ring(void (*func)(int rdom)); + +/* iterates over all importer rings and calls provided function for each of them */ +void hyper_dmabuf_foreach_importer_ring(void (*func)(int sdom)); + #endif // __HYPER_DMABUF_XEN_COMM_LIST_H__ -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 08/60] hyper_dmabuf: automatic comm channel initialization using xenstore Date: Tue, 19 Dec 2017 11:29:24 -0800 Message-ID: <1513711816-2618-8-git-send-email-dongwon.kim@intel.com> References: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 595756E325 for ; Tue, 19 Dec 2017 19:36:30 +0000 (UTC) In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-kernel@vger.kernel.org Cc: xen-devel@lists.xenproject.org, mateuszx.potrola@intel.com, dri-devel@lists.freedesktop.org, dongwon.kim@intel.com List-Id: dri-devel@lists.freedesktop.org RnJvbTogTWF0ZXVzeiBQb2xyb2xhIDxtYXRldXN6eC5wb3Ryb2xhQGludGVsLmNvbT4KClRoaXMg aW50cm9kdWNlcyB1c2Ugb2YgeGVuc3RvcmUgZm9yIGNyZWF0aW5nIGFuZCBtYW5hZ2luZwpjb21t dW5pY2F0aW9uIGNoYW5uZWxzIGJldHdlZW4gdHdvIFZNcyBpbiB0aGUgc3lzdGVtLgoKV2hlbiBo eXBlcl9kbWFidWYgZHJpdmVyIGlzIGxvYWRlZCBpbiB0aGUgc2VydmljZSBWTSAoaG9zdCBPUyks CmEgbmV3IHhlbnN0b3JlIGRpcmVjdG9yeSwgIi9sb2NhbC9kb21haW4vPGRvbWlkPi9kYXRhL2h5 cGVyX2RtYWJ1ZiIKaXMgY3JlYXRlZCBpbiB4ZW5zdG9yZSBmaWxlc3lzdGVtLiBXaGVuZXZlciBh IG5ldyBndWVzdCBPUwpjcmVhdGVzIGFuZCBpbml0YWlsaXplcyBpdHMgb3duIHVwc3RyZWFtIGNo YW5uZWwgdGhlIHNlcnZpY2UgVk0sCm5ldyBkaXJlY3RvcnkgaXMgY3JlYXRlZCB1bmRlciB0aGUg bWFpbiBkaXJlY3RvcnkgY3JlYXRlZCBhYm92ZQphcyBzaG93biBoZXJlOgoKL2xvY2FsL2RvbWFp bi88ZG9taWQ+L2RhdGEvaHlwZXJfZG1hYnVmLzxyZW1vdGUgZG9taWQ+L3BvcnQKL2xvY2FsL2Rv bWFpbi88ZG9taWQ+L2RhdGEvaHlwZXJfZG1hYnVmLzxyZW1vdGUgZG9taWQ+L2dyZWYKClRoaXMg cGF0Y2ggYWxzbyBhZGRzIGEgInhlbnN0b3JlIHdhdGNoIiBjYWxsYmFjayBpcyBjYWxsZWQKd2hl biBhIG5ldyB1cHN0cmVhbSBjb25uZWN0aW9uIGlzIG1hZGUgZnJvbSBhbm90aGVyIFZNIChWTS1i KS4KVXBvbiBkZXRlY3Rpb24sIHRoaXMgVk0gKFZNLWEpIGludGlhbGl6ZXMgYSBkb3duc3RyZWFt IGNoYW5uZWwKLHBhaXJlZCB3aXRoIGRldGVjdGVkIHVwc3RyZWFtIGNvbm5lY3Rpb24gYXMgc2hv d24gYmVsb3cuCgpWTS1hIChkb3duc3RyZWFtKSA8LS0tLS0gKHVwc3RyZWFtKSBWTS1hCgpBbmQg YXMgc29vbiBhcyB0aGlzIGRvd25zdHJlYW0gY2hhbm5lbCBpcyBjcmVhdGVkLCBhIG5ldyB1cHN0 cmVhbQpjaGFubmVsIGZyb20gVk0tYSB0byBWTS1iIGlzIGF1dG9tYXRpY2FsbHkgY3JlYXRlZCBh bmQgaW5pdGlhbGl6ZWQKdmlhICJ4ZW5zdG9yZSB3YXRjaCIgY2FsbCBiYWNrIG9uIFZNLWIuCgpW TS1hICh1cHN0cmVhbSkgPC0tLS0tIChkb3duc3RyZWFtKSBWTS1iCgpBcyBhIHJlc3VsdCwgdGhl cmUgd2lsbCBiZSBiaS1kaXJlY3Rpb25hbCBjb21tdW5pY2F0aW9uIGNoYW5uZWwKYXZhaWxhYmxl IGJldHdlZW4gdHdvIFZNcy4KCldoZW4gdXBzdHJlYW0gY2hhbm5lbCBpcyByZW1vdmVkIChlLmcu IHVubG9hZGluZyBkcml2ZXIpLCBWTSBvbiB0aGUKb3RoZXIgc2lkZSBpcyBub3RpZmllZCBhbmQg InhlbnN0b3JlIHdhdGNoIiBjYWxsYmFjayBpcyBpbnZva2VkLgpWaWEgdGhpcyBjYWxsYmFjaywg Vk0gY2FuIHJlbW92ZSBjb3JyZXNwb25kaW5nIGRvd25zdHJlYW0gY2hhbm5lbC4KClNpZ25lZC1v ZmYtYnk6IERvbmd3b24gS2ltIDxkb25nd29uLmtpbUBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy94 ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuYyAgICAgICAgfCAgMTEgKy0KIGRyaXZl cnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmggICAgICAgIHwgIDE0IC0tCiBk cml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMgICAgICB8ICAzMCAr LS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMgICAgICAgIHwg IDMxICstLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaCAgICAg ICAgfCAgIDIgLQogLi4uL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29t bS5jICAgfCAyMjYgKysrKysrKysrKysrKysrKysrKy0tCiAuLi4veGVuL2h5cGVyX2RtYWJ1Zi94 ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmggICB8ICAxOCArLQogLi4uL2h5cGVyX2RtYWJ1Zi94 ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tX2xpc3QuYyAgfCAgMjIgKysKIC4uLi9oeXBlcl9kbWFi dWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbV9saXN0LmggIHwgICA2ICsKIDkgZmlsZXMgY2hh bmdlZCwgMjcwIGluc2VydGlvbnMoKyksIDkwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmMgYi9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5jCmluZGV4IDcwYjQ4NzguLjViNWRhZTQ0IDEw MDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5jCisr KyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmMKQEAgLTYsNiAr Niw3IEBACiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2NvbmYuaCIKICNpbmNsdWRlICJoeXBlcl9k bWFidWZfbGlzdC5oIgogI2luY2x1ZGUgInhlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW1fbGlzdC5o IgorI2luY2x1ZGUgInhlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uaCIKIAogTU9EVUxFX0xJQ0VO U0UoIkR1YWwgQlNEL0dQTCIpOwogTU9EVUxFX0FVVEhPUigiSU9URy1QRUQsIElOVEVMIik7CkBA IC00Myw2ICs0NCwxMSBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9kcnZfaW5pdCh2b2lkKQog CQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKKwlyZXQgPSBoeXBlcl9kbWFidWZfc2V0dXBfZGF0YV9k aXIoKTsKKwlpZiAocmV0IDwgMCkgeworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKIAkvKiBpbnRl cnJ1cHQgZm9yIGNvbW0gc2hvdWxkIGJlIHJlZ2lzdGVyZWQgaGVyZTogKi8KIAlyZXR1cm4gcmV0 OwogfQpAQCAtNTIsMTIgKzU4LDE1IEBAIHN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9kcnZfZXhp dCh2b2lkKQogewogCS8qIGhhc2ggdGFibGVzIGZvciBleHBvcnQvaW1wb3J0IGVudHJpZXMgYW5k IHJpbmdfaW5mb3MgKi8KIAloeXBlcl9kbWFidWZfdGFibGVfZGVzdHJveSgpOwotCWh5cGVyX2Rt YWJ1Zl9yaW5nX3RhYmxlX2luaXQoKTsKKworCWh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3JpbmdidWZz KCk7CisJaHlwZXJfZG1hYnVmX3JpbmdfdGFibGVfZGVzdHJveSgpOwogCiAJLyogZGVzdHJveSB3 b3JrcXVldWUgKi8KIAlpZiAoaHlwZXJfZG1hYnVmX3ByaXZhdGUud29ya19xdWV1ZSkKIAkJZGVz dHJveV93b3JrcXVldWUoaHlwZXJfZG1hYnVmX3ByaXZhdGUud29ya19xdWV1ZSk7CiAKKwloeXBl cl9kbWFidWZfZGVzdHJveV9kYXRhX2RpcigpOwogCXByaW50ayggS0VSTl9OT1RJQ0UgImRtYV9i dWYtc3JjX3NpbmsgbW9kZWw6IEV4aXRpbmciICk7CiAJdW5yZWdpc3Rlcl9kZXZpY2UoKTsKIH0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2Lmgg Yi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5oCmluZGV4IDYxNDVk MjkuLjc1MTFhZmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9k bWFidWZfZHJ2LmgKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9k cnYuaApAQCAtMjksOCArMjksNiBAQCBzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX2V4cG9ydGVy X3Jpbmdfc2V0dXAgewogCS8qIElOIHBhcmFtZXRlcnMgKi8KIAkvKiBSZW1vdGUgZG9tYWluIGlk ICovCiAJdWludDMyX3QgcmVtb3RlX2RvbWFpbjsKLQlncmFudF9yZWZfdCByaW5nX3JlZmlkOyAv KiBhc3NpZ25lZCBieSBkcml2ZXIsIGNvcGllZCB0byB1c2Vyc3BhY2UgYWZ0ZXIgaW5pdGlhbGl6 YXRpb24gKi8KLQl1aW50MzJfdCBwb3J0OyAvKiBhc3NpZ25lZCBieSBkcml2ZXIsIGNvcGllZCB0 byB1c2Vyc3BhY2UgYWZ0ZXIgaW5pdGlhbGl6YXRpb24gKi8KIH07CiAKICNkZWZpbmUgSU9DVExf SFlQRVJfRE1BQlVGX0lNUE9SVEVSX1JJTkdfU0VUVVAgXApAQCAtMzksMTAgKzM3LDYgQEAgc3Ry dWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9pbXBvcnRlcl9yaW5nX3NldHVwIHsKIAkvKiBJTiBwYXJh bWV0ZXJzICovCiAJLyogU291cmNlIGRvbWFpbiBpZCAqLwogCXVpbnQzMl90IHNvdXJjZV9kb21h aW47Ci0JLyogUmluZyBzaGFyZWQgcGFnZSByZWZpZCAqLwotCWdyYW50X3JlZl90IHJpbmdfcmVm aWQ7Ci0JLyogUG9ydCBudW1iZXIgKi8KLQl1aW50MzJfdCBwb3J0OwogfTsKIAogI2RlZmluZSBJ T0NUTF9IWVBFUl9ETUFCVUZfRVhQT1JUX1JFTU9URSBcCkBAIC05NSwxMiArODksNCBAQCBzdHJ1 Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3F1ZXJ5IHsKIAl1aW50MzJfdCBpbmZvOwogfTsKIAotI2Rl ZmluZSBJT0NUTF9IWVBFUl9ETUFCVUZfUkVNT1RFX0VYUE9SVEVSX1JJTkdfU0VUVVAgXAotX0lP QyhfSU9DX05PTkUsICdHJywgNiwgc2l6ZW9mKHN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfcmVt b3RlX2V4cG9ydGVyX3Jpbmdfc2V0dXApKQotc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9yZW1v dGVfZXhwb3J0ZXJfcmluZ19zZXR1cCB7Ci0JLyogaW4gcGFyYW1ldGVycyAqLwotCXVpbnQzMl90 IHJkb21haW47IC8qIGlkIG9mIHJlbW90ZSBkb21haW4gd2hlcmUgZXhwb3J0ZXIncyByaW5nIG5l ZWQgdG8gYmUgc2V0dXAgKi8KLQl1aW50MzJfdCBpbmZvOwotfTsKLQogI2VuZGlmIC8vX19MSU5V WF9QVUJMSUNfSFlQRVJfRE1BQlVGX0RSVl9IX18KZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi9oeXBlcl9kbWFidWZfaW9jdGwuYwppbmRleCBlNGQ4MzE2Li40NGExNTNiIDEwMDY0NAotLS0g YS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKKysrIGIvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jCkBAIC00OCw5ICs0OCw3 IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydGVyX3Jpbmdfc2V0dXAodm9pZCAqZGF0 YSkKIAkJcmV0dXJuIDA7CiAJfQogCi0JcmV0ID0gaHlwZXJfZG1hYnVmX2V4cG9ydGVyX3Jpbmdi dWZfaW5pdChyaW5nX2F0dHItPnJlbW90ZV9kb21haW4sCi0JCQkJCQkmcmluZ19hdHRyLT5yaW5n X3JlZmlkLAotCQkJCQkJJnJpbmdfYXR0ci0+cG9ydCk7CisJcmV0ID0gaHlwZXJfZG1hYnVmX2V4 cG9ydGVyX3JpbmdidWZfaW5pdChyaW5nX2F0dHItPnJlbW90ZV9kb21haW4pOwogCiAJcmV0dXJu IHJldDsKIH0KQEAgLTc2LDEwICs3NCw3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2ltcG9y dGVyX3Jpbmdfc2V0dXAodm9pZCAqZGF0YSkKIAkJcmV0dXJuIDA7CiAJfQogCi0JLyogdXNlciBu ZWVkIHRvIHByb3ZpZGUgYSBwb3J0IG51bWJlciBhbmQgcmVmICMgZm9yIHRoZSBwYWdlIHVzZWQg YXMgcmluZyBidWZmZXIgKi8KLQlyZXQgPSBoeXBlcl9kbWFidWZfaW1wb3J0ZXJfcmluZ2J1Zl9p bml0KHNldHVwX2ltcF9yaW5nX2F0dHItPnNvdXJjZV9kb21haW4sCi0JCQkJCQkgc2V0dXBfaW1w X3JpbmdfYXR0ci0+cmluZ19yZWZpZCwKLQkJCQkJCSBzZXR1cF9pbXBfcmluZ19hdHRyLT5wb3J0 KTsKKwlyZXQgPSBoeXBlcl9kbWFidWZfaW1wb3J0ZXJfcmluZ2J1Zl9pbml0KHNldHVwX2ltcF9y aW5nX2F0dHItPnNvdXJjZV9kb21haW4pOwogCiAJcmV0dXJuIHJldDsKIH0KQEAgLTM1NSwyNiAr MzUwLDYgQEAgc3RhdGljIGludCBoeXBlcl9kbWFidWZfcXVlcnkodm9pZCAqZGF0YSkKIAlyZXR1 cm4gcmV0OwogfQogCi1zdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9yZW1vdGVfZXhwb3J0ZXJfcmlu Z19zZXR1cCh2b2lkICpkYXRhKQotewotCXN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfcmVtb3Rl X2V4cG9ydGVyX3Jpbmdfc2V0dXAgKnJlbW90ZV9leHBvcnRlcl9yaW5nX3NldHVwOwotCXN0cnVj dCBoeXBlcl9kbWFidWZfcmluZ19ycSAqcmVxOwotCi0JcmVtb3RlX2V4cG9ydGVyX3Jpbmdfc2V0 dXAgPSAoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9yZW1vdGVfZXhwb3J0ZXJfcmluZ19zZXR1 cCAqKWRhdGE7Ci0KLQlyZXEgPSBrY2FsbG9jKDEsIHNpemVvZigqcmVxKSwgR0ZQX0tFUk5FTCk7 Ci0JaHlwZXJfZG1hYnVmX2NyZWF0ZV9yZXF1ZXN0KHJlcSwgSFlQRVJfRE1BQlVGX0VYUE9SVEVS X1JJTkdfU0VUVVAsIE5VTEwpOwotCi0JLyogcmVxdWVzdGluZyByZW1vdGUgZG9tYWluIHRvIHNl dC11cCBleHBvcnRlcidzIHJpbmcgKi8KLQlpZihoeXBlcl9kbWFidWZfc2VuZF9yZXF1ZXN0KHJl bW90ZV9leHBvcnRlcl9yaW5nX3NldHVwLT5yZG9tYWluLCByZXEpIDwgMCkgewotCQlrZnJlZShy ZXEpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlrZnJlZShyZXEpOwotCXJldHVybiAwOwot fQotCiBzdGF0aWMgY29uc3Qgc3RydWN0IGh5cGVyX2RtYWJ1Zl9pb2N0bF9kZXNjIGh5cGVyX2Rt YWJ1Zl9pb2N0bHNbXSA9IHsKIAlIWVBFUl9ETUFCVUZfSU9DVExfREVGKElPQ1RMX0hZUEVSX0RN QUJVRl9FWFBPUlRFUl9SSU5HX1NFVFVQLCBoeXBlcl9kbWFidWZfZXhwb3J0ZXJfcmluZ19zZXR1 cCwgMCksCiAJSFlQRVJfRE1BQlVGX0lPQ1RMX0RFRihJT0NUTF9IWVBFUl9ETUFCVUZfSU1QT1JU RVJfUklOR19TRVRVUCwgaHlwZXJfZG1hYnVmX2ltcG9ydGVyX3Jpbmdfc2V0dXAsIDApLApAQCAt MzgyLDcgKzM1Nyw2IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX2lvY3RsX2Rl c2MgaHlwZXJfZG1hYnVmX2lvY3Rsc1tdID0gewogCUhZUEVSX0RNQUJVRl9JT0NUTF9ERUYoSU9D VExfSFlQRVJfRE1BQlVGX0VYUE9SVF9GRCwgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bCwg MCksCiAJSFlQRVJfRE1BQlVGX0lPQ1RMX0RFRihJT0NUTF9IWVBFUl9ETUFCVUZfREVTVFJPWSwg aHlwZXJfZG1hYnVmX2Rlc3Ryb3ksIDApLAogCUhZUEVSX0RNQUJVRl9JT0NUTF9ERUYoSU9DVExf SFlQRVJfRE1BQlVGX1FVRVJZLCBoeXBlcl9kbWFidWZfcXVlcnksIDApLAotCUhZUEVSX0RNQUJV Rl9JT0NUTF9ERUYoSU9DVExfSFlQRVJfRE1BQlVGX1JFTU9URV9FWFBPUlRFUl9SSU5HX1NFVFVQ LCBoeXBlcl9kbWFidWZfcmVtb3RlX2V4cG9ydGVyX3Jpbmdfc2V0dXAsIDApLAogfTsKIAogc3Rh dGljIGxvbmcgaHlwZXJfZG1hYnVmX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLApkaWZmIC0tZ2l0 IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuYyBiL2RyaXZlcnMv eGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMKaW5kZXggMDE2NmU2MS4uOGEwNTlj OCAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cu YworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5jCkBAIC03 MCwxMiArNzAsNiBAQCB2b2lkIGh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChzdHJ1Y3QgaHlw ZXJfZG1hYnVmX3JpbmdfcnEgKnJlcXVlc3QsCiAJCQlyZXF1ZXN0LT5vcGVyYW5kc1tpXSA9IG9w ZXJhbmRzW2ldOwogCQlicmVhazsKIAotCS8qIHJlcXVlc3RpbmcgdGhlIG90aGVyIHNpZGUgdG8g c2V0dXAgYW5vdGhlciByaW5nIGNoYW5uZWwgZm9yIHJldmVyc2UgZGlyZWN0aW9uICovCi0JY2Fz ZSBIWVBFUl9ETUFCVUZfRVhQT1JURVJfUklOR19TRVRVUDoKLQkJLyogY29tbWFuZCA6IEhZUEVS X0RNQUJVRl9FWFBPUlRFUl9SSU5HX1NFVFVQICovCi0JCS8qIG5vIG9wZXJhbmRzIG5lZWRlZCAq LwotCQlicmVhazsKLQogCWRlZmF1bHQ6CiAJCS8qIG5vIGNvbW1hbmQgZm91bmQgKi8KIAkJcmV0 dXJuOwpAQCAtMTYzLDEzICsxNTcsNiBAQCB2b2lkIGNtZF9wcm9jZXNzX3dvcmsoc3RydWN0IHdv cmtfc3RydWN0ICp3b3JrKQogCQkgKi8KIAkJYnJlYWs7CiAKLQljYXNlIEhZUEVSX0RNQUJVRl9J TVBPUlRFUl9SSU5HX1NFVFVQOgotCQkvKiBjb21tYW5kOiBIWVBFUl9ETUFCVUZfSU1QT1JURVJf UklOR19TRVRVUCAqLwotCQkvKiBubyBvcGVyYW5kcyBuZWVkZWQgKi8KLQkJaHlwZXJfZG1hYnVm X2ltcG9ydGVyX3JpbmdidWZfaW5pdChkb21pZCwgcmVxLT5vcGVyYW5kc1swXSwgcmVxLT5vcGVy YW5kc1sxXSk7Ci0KLQkJYnJlYWs7Ci0KIAlkZWZhdWx0OgogCQkvKiBzaG91bGRuJ3QgZ2V0IGhl cmUgKi8KIAkJLyogbm8gbWF0Y2hlZCBjb21tYW5kLCBub3RoaW5nIHRvIGRvLi4ganVzdCByZXR1 cm4gZXJyb3IgKi8KQEAgLTE4NSw3ICsxNzIsNiBAQCBpbnQgaHlwZXJfZG1hYnVmX21zZ19wYXJz ZShpbnQgZG9taWQsIHN0cnVjdCBoeXBlcl9kbWFidWZfcmluZ19ycSAqcmVxKQogCXN0cnVjdCBj bWRfcHJvY2VzcyAqcHJvYzsKIAlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JpbmdfcnEgKnRlbXBfcmVx OwogCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKmltcG9ydGVkX3NndF9p bmZvOwotCWludCByZXQ7CiAKIAlpZiAoIXJlcSkgewogCQlwcmludGsoInJlcXVlc3QgaXMgTlVM TFxuIik7CkBAIC0xOTMsMjggKzE3OSwxMyBAQCBpbnQgaHlwZXJfZG1hYnVmX21zZ19wYXJzZShp bnQgZG9taWQsIHN0cnVjdCBoeXBlcl9kbWFidWZfcmluZ19ycSAqcmVxKQogCX0KIAogCWlmICgo cmVxLT5jb21tYW5kIDwgSFlQRVJfRE1BQlVGX0VYUE9SVCkgfHwKLQkJKHJlcS0+Y29tbWFuZCA+ IEhZUEVSX0RNQUJVRl9JTVBPUlRFUl9SSU5HX1NFVFVQKSkgeworCQkocmVxLT5jb21tYW5kID4g SFlQRVJfRE1BQlVGX09QU19UT19TT1VSQ0UpKSB7CiAJCXByaW50aygiaW52YWxpZCBjb21tYW5k XG4iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCiAJcmVxLT5zdGF0dXMgPSBIWVBFUl9ETUFC VUZfUkVRX1BST0NFU1NFRDsKIAotCS8qIEhZUEVSX0RNQUJVRl9FWFBPUlRFUl9SSU5HX1NFVFVQ IHJlcXVpcmVzIGltbWVkaWF0ZQotCSAqIGZvbGxvdyB1cCBzbyBjYW4ndCBiZSBwcm9jZXNzZWQg aW4gd29ya3F1ZXVlCi0JICovCi0JaWYgKHJlcS0+Y29tbWFuZCA9PSBIWVBFUl9ETUFCVUZfRVhQ T1JURVJfUklOR19TRVRVUCkgewotCQlyZXQgPSBoeXBlcl9kbWFidWZfZXhwb3J0ZXJfcmluZ2J1 Zl9pbml0KGRvbWlkLCAmcmVxLT5vcGVyYW5kc1swXSwgJnJlcS0+b3BlcmFuZHNbMV0pOwotCQlp ZiAocmV0IDwgMCkgewotCQkJcmVxLT5zdGF0dXMgPSBIWVBFUl9ETUFCVUZfUkVRX0VSUk9SOwot CQl9Ci0KLQkJcmVxLT5zdGF0dXMgPSBIWVBFUl9ETUFCVUZfUkVRX05FRURTX0ZPTExPV19VUDsK LQkJcmVxLT5jb21tYW5kID0gSFlQRVJfRE1BQlVGX0lNUE9SVEVSX1JJTkdfU0VUVVA7Ci0KLQkJ cmV0dXJuIHJlcS0+Y29tbWFuZDsKLQl9Ci0KIAkvKiBIWVBFUl9ETUFCVUZfREVTVFJPWSByZXF1 aXJlcyBpbW1lZGlhdGUKIAkgKiBmb2xsb3cgdXAgc28gY2FuJ3QgYmUgcHJvY2Vzc2VkIGluIHdv cmtxdWV1ZQogCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9tc2cuaCBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNn LmgKaW5kZXggNDRiZmI3MC4uOWIyNWJkYiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJf ZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaAorKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv aHlwZXJfZG1hYnVmX21zZy5oCkBAIC03LDggKzcsNiBAQCBlbnVtIGh5cGVyX2RtYWJ1Zl9jb21t YW5kIHsKIAlIWVBFUl9ETUFCVUZfREVTVFJPWV9GSU5JU0gsCiAJSFlQRVJfRE1BQlVGX09QU19U T19SRU1PVEUsCiAJSFlQRVJfRE1BQlVGX09QU19UT19TT1VSQ0UsCi0JSFlQRVJfRE1BQlVGX0VY UE9SVEVSX1JJTkdfU0VUVVAsIC8qIHJlcXVlc3RpbmcgcmVtb3RlIGRvbWFpbiB0byBzZXQgdXAg ZXhwb3J0ZXIncyByaW5nICovCi0JSFlQRVJfRE1BQlVGX0lNUE9SVEVSX1JJTkdfU0VUVVAsIC8q IHJlcXVlc3RpbmcgcmVtb3RlIGRvbWFpbiB0byBzZXQgdXAgaW1wb3J0ZXIncyByaW5nICovCiB9 OwogCiBlbnVtIGh5cGVyX2RtYWJ1Zl9vcHMgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlw ZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uYyBiL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMKaW5kZXggMDU4NTViYTEuLjVkYjU4 YjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVm X3hlbl9jb21tLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFi dWZfeGVuX2NvbW0uYwpAQCAtMTUsNiArMTUsODMgQEAKIAogc3RhdGljIGludCBleHBvcnRfcmVx X2lkID0gMDsKIAorLyogQ3JlYXRlcyBlbnRyeSBpbiB4ZW4gc3RvcmUgdGhhdCB3aWxsIGtlZXAg ZGV0YWlscyBvZiBhbGwgZXhwb3J0ZXIgcmluZ3MgY3JlYXRlZCBieSB0aGlzIGRvbWFpbiAqLwor aW50MzJfdCBoeXBlcl9kbWFidWZfc2V0dXBfZGF0YV9kaXIoKQoreworCWNoYXIgYnVmWzI1NV07 CisKKwlzcHJpbnRmKGJ1ZiwgIi9sb2NhbC9kb21haW4vJWQvZGF0YS9oeXBlcl9kbWFidWYiLCBo eXBlcl9kbWFidWZfZ2V0X2RvbWlkKCkpOworCXJldHVybiB4ZW5idXNfbWtkaXIoWEJUX05JTCwg YnVmLCAiIik7Cit9CisKKworLyogUmVtb3ZlcyBlbnRyeSBmcm9tIHhlbnN0b3JlIHdpdGggZXhw b3J0ZXIgcmluZyBkZXRhaWxzLgorICogT3RoZXIgZG9tYWlucyB0aGF0IGhhcyBjb25uZWN0ZWQg dG8gYW55IG9mIGV4cG9ydGVyIHJpbmdzIGNyZWF0ZWQgYnkgdGhpcyBkb21haW4sCisgKiB3aWxs IGJlIG5vdGlmaWVkIGFib3V0IHJlbW92YWwgb2YgdGhpcyBlbnRyeSBhbmQgd2lsbCB0cmVhdCB0 aGF0IGFzIHNpZ25hbCB0bworICogY2xlYW51cCBpbXBvcnRlciByaW5ncyBjcmVhdGVkIGZvciB0 aGlzIGRvbWFpbgorICovCitpbnQzMl90IGh5cGVyX2RtYWJ1Zl9kZXN0cm95X2RhdGFfZGlyKCkK K3sKKwljaGFyIGJ1ZlsyNTVdOworCisJc3ByaW50ZihidWYsICIvbG9jYWwvZG9tYWluLyVkL2Rh dGEvaHlwZXJfZG1hYnVmIiwgaHlwZXJfZG1hYnVmX2dldF9kb21pZCgpKTsKKwlyZXR1cm4geGVu YnVzX3JtKFhCVF9OSUwsIGJ1ZiwgIiIpOworfQorCisvKgorICogQWRkcyB4ZW5zdG9yZSBlbnRy aWVzIHdpdGggZGV0YWlscyBvZiBleHBvcnRlciByaW5nIGNyZWF0ZWQgZm9yIGdpdmVuIHJlbW90 ZSBkb21haW4uCisgKiBJdCByZXF1aXJlcyBzcGVjaWFsIGRhZW1vbiBydW5uaW5nIGluIGRvbTAg dG8gbWFrZSBzdXJlIHRoYXQgZ2l2ZW4gcmVtb3RlIGRvbWFpbiB3aWxsCisgKiBoYXZlIHJpZ2h0 IHBlcm1pc3Npb25zIHRvIGFjY2VzcyB0aGF0IGRhdGEuCisgKi8KK3N0YXRpYyBpbnQzMl90IGh5 cGVyX2RtYWJ1Zl9leHBvc2VfcmluZ19kZXRhaWxzKHVpbnQzMl90IGRvbWlkLCB1aW50MzJfdCBy ZG9taWQsIHVpbnQzMl90IGdyZWZpZCwgdWludDMyX3QgcG9ydCkKK3sKKwljaGFyIGJ1ZlsyNTVd OworCWludCByZXQ7CisKKwlzcHJpbnRmKGJ1ZiwgIi9sb2NhbC9kb21haW4vJWQvZGF0YS9oeXBl cl9kbWFidWYvJWQiLCBkb21pZCwgcmRvbWlkKTsKKwlyZXQgPSB4ZW5idXNfcHJpbnRmKFhCVF9O SUwsIGJ1ZiwgImdyZWZpZCIsICIlZCIsIGdyZWZpZCk7CisKKwlpZiAocmV0KSB7CisJCXByaW50 aygiRmFpbGVkIHRvIHdyaXRlIHhlbmJ1cyBlbnRyeSAlczogJWRcbiIsIGJ1ZiwgcmV0KTsKKwkJ cmV0dXJuIHJldDsKKwl9CisKKwlyZXQgPSB4ZW5idXNfcHJpbnRmKFhCVF9OSUwsIGJ1ZiwgInBv cnQiLCAiJWQiLCBwb3J0KTsKKworCWlmIChyZXQpIHsKKwkJcHJpbnRrKCJGYWlsZWQgdG8gd3Jp dGUgeGVuYnVzIGVudHJ5ICVzOiAlZFxuIiwgYnVmLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0K KworCXJldHVybiAwOworfQorCisvKgorICogUXVlcmllcyBkZXRhaWxzIG9mIHJpbmcgZXhwb3Nl ZCBieSByZW1vdGUgZG9tYWluLgorICovCitzdGF0aWMgaW50MzJfdCBoeXBlcl9kbWFidWZfZ2V0 X3JpbmdfZGV0YWlscyh1aW50MzJfdCBkb21pZCwgdWludDMyX3QgcmRvbWlkLCB1aW50MzJfdCAq Z3JlZmlkLCB1aW50MzJfdCAqcG9ydCkKK3sKKwljaGFyIGJ1ZlsyNTVdOworCWludCByZXQ7CisK KwlzcHJpbnRmKGJ1ZiwgIi9sb2NhbC9kb21haW4vJWQvZGF0YS9oeXBlcl9kbWFidWYvJWQiLCBy ZG9taWQsIGRvbWlkKTsKKwlyZXQgPSB4ZW5idXNfc2NhbmYoWEJUX05JTCwgYnVmLCAiZ3JlZmlk IiwgIiVkIiwgZ3JlZmlkKTsKKworCWlmIChyZXQgPD0gMCkgeworCQlwcmludGsoIkZhaWxlZCB0 byByZWFkIHhlbmJ1cyBlbnRyeSAlczogJWRcbiIsIGJ1ZiwgcmV0KTsKKwkJcmV0dXJuIHJldDsK Kwl9CisKKwlyZXQgPSB4ZW5idXNfc2NhbmYoWEJUX05JTCwgYnVmLCAicG9ydCIsICIlZCIsIHBv cnQpOworCisJaWYgKHJldCA8PSAwKSB7CisJCXByaW50aygiRmFpbGVkIHRvIHJlYWQgeGVuYnVz IGVudHJ5ICVzOiAlZFxuIiwgYnVmLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKworCXJldHVy biAocmV0IDw9IDAgPyAxIDogMCk7Cit9CisKIGludDMyX3QgaHlwZXJfZG1hYnVmX2dldF9kb21p ZCh2b2lkKQogewogCXN0cnVjdCB4ZW5idXNfdHJhbnNhY3Rpb24geGJ0OwpAQCAtNDAsOCArMTE3 LDQ5IEBAIGludCBoeXBlcl9kbWFidWZfbmV4dF9yZXFfaWRfZXhwb3J0KHZvaWQpCiBzdGF0aWMg aXJxcmV0dXJuX3QgaHlwZXJfZG1hYnVmX2Zyb250X3JpbmdfaXNyKGludCBpcnEsIHZvaWQgKmRl dl9pZCk7CiBzdGF0aWMgaXJxcmV0dXJuX3QgaHlwZXJfZG1hYnVmX2JhY2tfcmluZ19pc3IoaW50 IGlycSwgdm9pZCAqZGV2X2lkKTsKIAorLyoKKyAqIENhbGxiYWNrIGZ1bmN0aW9uIHRoYXQgd2ls bCBiZSBjYWxsZWQgb24gYW55IGNoYW5nZSBvZiB4ZW5idXMgcGF0aCBiZWluZyB3YXRjaGVkLgor ICogVXNlZCBmb3IgZGV0ZWN0aW5nIGNyZWF0aW9uL2Rlc3RydWN0aW9uIG9mIHJlbW90ZSBkb21h aW4gZXhwb3J0ZXIgcmluZy4KKyAqIFdoZW4gcmVtb3RlIGRvbWFpbidzIGV4cG9ydGVyIHJpbmcg d2lsbCBiZSBkZXRlY3RlZCwgaW1wb3J0ZXIgcmluZyBvbiB0aGlzIGRvbWFpbiB3aWxsIGJlIGNy ZWF0ZWQuCisgKiBXaGVuIHJlbW90ZSBkb21haW4ncyBleHBvcnRlciByaW5nIGRlc3RydWN0aW9u IHdpbGwgYmUgZGV0ZWN0ZWQgaXQgd2lsbCBjZWxhbnVwIHRoaXMgZG9tYWluIGltcG9ydGVyIHJp bmcuCisgKiBEZXN0cnVjdGlvbiBjYW4gYmUgY2F1c2VkIGJ5IHVubG9hZGluZyBtb2R1bGUgYnkg cmVtb3RlIGRvbWFpbiBvciBpdCdzIGNyYXNoL2ZvcmNlIHNodXRkb3duLgorICovCitzdGF0aWMg dm9pZCByZW1vdGVfZG9tYWluX2V4cG9ydGVyX3dhdGNoX2NiKHN0cnVjdCB4ZW5idXNfd2F0Y2gg KndhdGNoLAorCQkJCSAgIGNvbnN0IGNoYXIgKnBhdGgsIGNvbnN0IGNoYXIgKnRva2VuKQorewor CWludCByZG9tLHJldDsKKwl1aW50MzJfdCBncmVmaWQsIHBvcnQ7CisJc3RydWN0IGh5cGVyX2Rt YWJ1Zl9yaW5nX2luZm9faW1wb3J0ICpyaW5nX2luZm87CisKKwkvKiBDaGVjayB3aGljaCBkb21h aW4gaGFzIGNoYW5nZWQgaXRzIGV4cG9ydGVyIHJpbmdzICovCisJcmV0ID0gc3NjYW5mKHdhdGNo LT5ub2RlLCAiL2xvY2FsL2RvbWFpbi8lZC8iLCAmcmRvbSk7CisJaWYgKHJldCA8PSAwKSB7CisJ CXJldHVybjsKKwl9CisKKwkvKiBDaGVjayBpZiB3ZSBoYXZlIGltcG9ydGVyIHJpbmcgZm9yIGdp dmVuIHJlbW90ZSBkb21haW4gYWxyYWR5IGNyZWF0ZWQgKi8KKwlyaW5nX2luZm8gPSBoeXBlcl9k bWFidWZfZmluZF9pbXBvcnRlcl9yaW5nKHJkb20pOworCisJLyoKKwkgKiBUcnkgdG8gcXVlcnkg cmVtb3RlIGRvbWFpbiBleHBvcnRlciByaW5nIGRldGFpbHMgLSBpZiB0aGF0IHdpbGwgZmFpbCBh bmQgd2UgaGF2ZQorCSAqIGltcG9ydGVyIHJpbmcgdGhhdCBtZWFucyByZW1vdGUgZG9tYWlucyBo YXMgY2xlYW51cCBpdHMgZXhwb3J0ZXIgcmluZywgc28gb3VyCisJICogaW1wb3J0ZXIgcmluZyBp cyBubyBsb25nZXIgdXNlZnVsLgorCSAqIElmIHF1ZXJ5aW5nIGRldGFpbHMgd2lsbCBzdWNjZWVk IGFuZCB3ZSBkb24ndCBoYXZlIGltcG9ydGVyIHJpbmcsIGl0IG1lYW5zIHRoYXQKKwkgKiByZW1v dGUgZG9tYWluIGhhcyBzZXR1cCBpdCBmb3IgdXMgYW5kIHdlIHNob3VsZCBjb25uZWN0IHRvIGl0 LgorCSAqLworCXJldCA9IGh5cGVyX2RtYWJ1Zl9nZXRfcmluZ19kZXRhaWxzKGh5cGVyX2RtYWJ1 Zl9nZXRfZG9taWQoKSwgcmRvbSwgJmdyZWZpZCwgJnBvcnQpOworCisJaWYgKHJpbmdfaW5mbyAm JiByZXQgIT0gMCkgeworCQlwcmludGsoIlJlbW90ZSBleHBvcnRlciBjbG9zZWQsIGNsZWFuaW51 cCBpbXBvcnRlclxuIik7CisJCWh5cGVyX2RtYWJ1Zl9pbXBvcnRlcl9yaW5nYnVmX2NsZWFudXAo cmRvbSk7CisJfSBlbHNlIGlmICghcmluZ19pbmZvICYmIHJldCA9PSAwKSB7CisJCXByaW50aygi UmVnaXN0ZXJpbmcgaW1wb3J0ZXJcbiIpOworCQloeXBlcl9kbWFidWZfaW1wb3J0ZXJfcmluZ2J1 Zl9pbml0KHJkb20pOworCX0KK30KKwogLyogZXhwb3J0ZXIgbmVlZHMgdG8gZ2VuZXJhdGVkIGlu Zm8gZm9yIHBhZ2Ugc2hhcmluZyAqLwotaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRlcl9yaW5nYnVm X2luaXQoaW50IHJkb21haW4sIGdyYW50X3JlZl90ICpyZWZpZCwgaW50ICpwb3J0KQoraW50IGh5 cGVyX2RtYWJ1Zl9leHBvcnRlcl9yaW5nYnVmX2luaXQoaW50IHJkb21haW4pCiB7CiAJc3RydWN0 IGh5cGVyX2RtYWJ1Zl9yaW5nX2luZm9fZXhwb3J0ICpyaW5nX2luZm87CiAJc3RydWN0IGh5cGVy X2RtYWJ1Zl9zcmluZyAqc3Jpbmc7CkBAIC05OSwyNCArMjE3LDU4IEBAIGludCBoeXBlcl9kbWFi dWZfZXhwb3J0ZXJfcmluZ2J1Zl9pbml0KGludCByZG9tYWluLCBncmFudF9yZWZfdCAqcmVmaWQs IGludCAqcG9yCiAJcmluZ19pbmZvLT5pcnEgPSByZXQ7CiAJcmluZ19pbmZvLT5wb3J0ID0gYWxs b2NfdW5ib3VuZC5wb3J0OwogCi0JLyogc3RvcmUgcmVmaWQgYW5kIHBvcnQgbnVtYmVycyBmb3Ig dXNlcnNwYWNlJ3MgdXNlICovCi0JKnJlZmlkID0gcmluZ19pbmZvLT5ncmVmX3Jpbmc7Ci0JKnBv cnQgPSByaW5nX2luZm8tPnBvcnQ7Ci0KIAlwcmludGsoIiVzOiBhbGxvY2F0ZWQgZXZlbnRjaGFu bmVsIGdyZWYgJWQgIHBvcnQ6ICVkICBpcnE6ICVkXG4iLAogCQlfX2Z1bmNfXywKIAkJcmluZ19p bmZvLT5ncmVmX3JpbmcsCiAJCXJpbmdfaW5mby0+cG9ydCwKIAkJcmluZ19pbmZvLT5pcnEpOwog Ci0JLyogcmVnaXN0ZXIgcmluZyBpbmZvICovCiAJcmV0ID0gaHlwZXJfZG1hYnVmX3JlZ2lzdGVy X2V4cG9ydGVyX3JpbmcocmluZ19pbmZvKTsKIAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9leHBvc2Vf cmluZ19kZXRhaWxzKGh5cGVyX2RtYWJ1Zl9nZXRfZG9taWQoKSwgcmRvbWFpbiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmluZ19pbmZvLT5ncmVmX3Jp bmcsIHJpbmdfaW5mby0+cG9ydCk7CisKKwkvKgorCSAqIFJlZ2lzdGVyIHdhdGNoIGZvciByZW1v dGUgZG9tYWluIGV4cG9ydGVyIHJpbmcuCisJICogV2hlbiByZW1vdGUgZG9tYWluIHdpbGwgc2V0 dXAgaXRzIGV4cG9ydGVyIHJpbmcsIHdlIHdpbGwgYXV0b21hdGljYWxseSBjb25uZWN0IG91ciBp bXBvcnRlciByaW5nIHRvIGl0LgorCSAqLworCXJpbmdfaW5mby0+d2F0Y2guY2FsbGJhY2sgPSBy ZW1vdGVfZG9tYWluX2V4cG9ydGVyX3dhdGNoX2NiOworCXJpbmdfaW5mby0+d2F0Y2gubm9kZSA9 IChjb25zdCBjaGFyKikga21hbGxvYyhzaXplb2YoY2hhcikgKiAyNTUsIEdGUF9LRVJORUwpOwor CXNwcmludGYoKGNoYXIqKXJpbmdfaW5mby0+d2F0Y2gubm9kZSwgIi9sb2NhbC9kb21haW4vJWQv ZGF0YS9oeXBlcl9kbWFidWYvJWQvcG9ydCIsIHJkb21haW4sIGh5cGVyX2RtYWJ1Zl9nZXRfZG9t aWQoKSk7CisJcmVnaXN0ZXJfeGVuYnVzX3dhdGNoKCZyaW5nX2luZm8tPndhdGNoKTsKKwogCXJl dHVybiByZXQ7CiB9CiAKKy8qIGNsZWFucyB1cCBleHBvcnRlciByaW5nIGNyZWF0ZWQgZm9yIGdp dmVuIHJlbW90ZSBkb21haW4gKi8KK3ZvaWQgaHlwZXJfZG1hYnVmX2V4cG9ydGVyX3JpbmdidWZf Y2xlYW51cChpbnQgcmRvbWFpbikKK3sKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JpbmdfaW5mb19l eHBvcnQgKnJpbmdfaW5mbzsKKworCS8qIGNoZWNrIGlmIHdlIGF0IGFsbCBoYXZlIGV4cG9ydGVy IHJpbmcgZm9yIGdpdmVuIHJkb21haW4gKi8KKwlyaW5nX2luZm8gPSBoeXBlcl9kbWFidWZfZmlu ZF9leHBvcnRlcl9yaW5nKHJkb21haW4pOworCisJaWYgKCFyaW5nX2luZm8pIHsKKwkJcmV0dXJu OworCX0KKworCWh5cGVyX2RtYWJ1Zl9yZW1vdmVfZXhwb3J0ZXJfcmluZyhyZG9tYWluKTsKKwor CXVucmVnaXN0ZXJfeGVuYnVzX3dhdGNoKCZyaW5nX2luZm8tPndhdGNoKTsKKwlrZnJlZShyaW5n X2luZm8tPndhdGNoLm5vZGUpOworCisJLyogTm8gbmVlZCB0byBjbG9zZSBjb21tdW5pY2F0aW9u IGNoYW5uZWwsIHdpbGwgYmUgZG9uZSBieSB0aGlzIGZ1bmN0aW9uICovCisJdW5iaW5kX2Zyb21f aXJxaGFuZGxlcihyaW5nX2luZm8tPmlycSwJKHZvaWQqKSByaW5nX2luZm8pOworCisJLyogTm8g bmVlZCB0byBmcmVlIHNyaW5nIHBhZ2UsIHdpbGwgYmUgZnJlZWQgYnkgdGhpcyBmdW5jdGlvbiB3 aGVuIG90aGVyIHNpZGUgd2lsbCBlbmQgaXRzIGFjY2VzcyAqLworCWdudHRhYl9lbmRfZm9yZWln bl9hY2Nlc3MocmluZ19pbmZvLT5ncmVmX3JpbmcsIDAsCisJCQkJICAodW5zaWduZWQgbG9uZykg cmluZ19pbmZvLT5yaW5nX2Zyb250LnNyaW5nKTsKKworCWtmcmVlKHJpbmdfaW5mbyk7Cit9CisK IC8qIGltcG9ydGVyIG5lZWRzIHRvIGtub3cgYWJvdXQgc2hhcmVkIHBhZ2UgYW5kIHBvcnQgbnVt YmVycyBmb3IgcmluZyBidWZmZXIgYW5kIGV2ZW50IGNoYW5uZWwgKi8KLWludCBoeXBlcl9kbWFi dWZfaW1wb3J0ZXJfcmluZ2J1Zl9pbml0KGludCBzZG9tYWluLCBncmFudF9yZWZfdCBncmVmLCBp bnQgcG9ydCkKK2ludCBoeXBlcl9kbWFidWZfaW1wb3J0ZXJfcmluZ2J1Zl9pbml0KGludCBzZG9t YWluKQogewogCXN0cnVjdCBoeXBlcl9kbWFidWZfcmluZ19pbmZvX2ltcG9ydCAqcmluZ19pbmZv OwogCXN0cnVjdCBoeXBlcl9kbWFidWZfc3JpbmcgKnNyaW5nOwpAQCAtMTI0LDI0ICsyNzYsMzMg QEAgaW50IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlcl9yaW5nYnVmX2luaXQoaW50IHNkb21haW4sIGdy YW50X3JlZl90IGdyZWYsIGludCBwb3J0KQogCXN0cnVjdCBwYWdlICpzaGFyZWRfcmluZzsKIAog CXN0cnVjdCBnbnR0YWJfbWFwX2dyYW50X3JlZiAqb3BzOwotCXN0cnVjdCBnbnR0YWJfdW5tYXBf Z3JhbnRfcmVmICp1bm1hcF9vcHM7CiAJaW50IHJldDsKKwlpbnQgaW1wb3J0ZXJfZ3JlZiwgaW1w b3J0ZXJfcG9ydDsKKworCXJldCA9IGh5cGVyX2RtYWJ1Zl9nZXRfcmluZ19kZXRhaWxzKGh5cGVy X2RtYWJ1Zl9nZXRfZG9taWQoKSwgc2RvbWFpbiwKKwkJCQkJICAgICZpbXBvcnRlcl9ncmVmLCAm aW1wb3J0ZXJfcG9ydCk7CisKKwlpZiAocmV0KSB7CisJCXByaW50aygiRG9tYWluICVkIGhhcyBu b3QgY3JlYXRlZCBleHBvcnRlciByaW5nIGZvciBjdXJyZW50IGRvbWFpblxuIiwgc2RvbWFpbik7 CisJCXJldHVybiByZXQ7CisJfQogCiAJcmluZ19pbmZvID0gKHN0cnVjdCBoeXBlcl9kbWFidWZf cmluZ19pbmZvX2ltcG9ydCAqKQogCQkJa21hbGxvYyhzaXplb2YoKnJpbmdfaW5mbyksIEdGUF9L RVJORUwpOwogCiAJcmluZ19pbmZvLT5zZG9tYWluID0gc2RvbWFpbjsKLQlyaW5nX2luZm8tPmV2 dGNobiA9IHBvcnQ7CisJcmluZ19pbmZvLT5ldnRjaG4gPSBpbXBvcnRlcl9wb3J0OwogCiAJb3Bz ID0gKHN0cnVjdCBnbnR0YWJfbWFwX2dyYW50X3JlZiopa21hbGxvYyhzaXplb2YoKm9wcyksIEdG UF9LRVJORUwpOwotCXVubWFwX29wcyA9IChzdHJ1Y3QgZ250dGFiX3VubWFwX2dyYW50X3JlZiop a21hbGxvYyhzaXplb2YoKnVubWFwX29wcyksIEdGUF9LRVJORUwpOwogCiAJaWYgKGdudHRhYl9h bGxvY19wYWdlcygxLCAmc2hhcmVkX3JpbmcpKSB7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAog CWdudHRhYl9zZXRfbWFwX29wKCZvcHNbMF0sICh1bnNpZ25lZCBsb25nKXBmbl90b19rYWRkcihw YWdlX3RvX3BmbihzaGFyZWRfcmluZykpLAotCQkJR05UTUFQX2hvc3RfbWFwLCBncmVmLCBzZG9t YWluKTsKKwkJCUdOVE1BUF9ob3N0X21hcCwgaW1wb3J0ZXJfZ3JlZiwgc2RvbWFpbik7CisJZ250 dGFiX3NldF91bm1hcF9vcCgmcmluZ19pbmZvLT51bm1hcF9vcCwgKHVuc2lnbmVkIGxvbmcpcGZu X3RvX2thZGRyKHBhZ2VfdG9fcGZuKHNoYXJlZF9yaW5nKSksCisJCQlHTlRNQVBfaG9zdF9tYXAs IC0xKTsKIAogCXJldCA9IGdudHRhYl9tYXBfcmVmcyhvcHMsIE5VTEwsICZzaGFyZWRfcmluZywg MSk7CiAJaWYgKHJldCA8IDApIHsKQEAgLTE1MiwxMyArMzEzLDE1IEBAIGludCBoeXBlcl9kbWFi dWZfaW1wb3J0ZXJfcmluZ2J1Zl9pbml0KGludCBzZG9tYWluLCBncmFudF9yZWZfdCBncmVmLCBp bnQgcG9ydCkKIAlpZiAob3BzWzBdLnN0YXR1cykgewogCQlwcmludGsoIlJpbmcgbWFwcGluZyBm YWlsZWRcbiIpOwogCQlyZXR1cm4gLUVJTlZBTDsKKwl9IGVsc2UgeworCQlyaW5nX2luZm8tPnVu bWFwX29wLmhhbmRsZSA9IG9wc1swXS5oYW5kbGU7CiAJfQogCiAJc3JpbmcgPSAoc3RydWN0IGh5 cGVyX2RtYWJ1Zl9zcmluZyopIHBmbl90b19rYWRkcihwYWdlX3RvX3BmbihzaGFyZWRfcmluZykp OwogCiAJQkFDS19SSU5HX0lOSVQoJnJpbmdfaW5mby0+cmluZ19iYWNrLCBzcmluZywgUEFHRV9T SVpFKTsKIAotCXJldCA9IGJpbmRfaW50ZXJkb21haW5fZXZ0Y2huX3RvX2lycWhhbmRsZXIoc2Rv bWFpbiwgcG9ydCwKKwlyZXQgPSBiaW5kX2ludGVyZG9tYWluX2V2dGNobl90b19pcnFoYW5kbGVy KHNkb21haW4sIGltcG9ydGVyX3BvcnQsCiAJCQkJCQloeXBlcl9kbWFidWZfYmFja19yaW5nX2lz ciwgMCwKIAkJCQkJCU5VTEwsICh2b2lkKilyaW5nX2luZm8pOwogCWlmIChyZXQgPCAwKSB7CkBA IC0xNjgsMTQgKzMzMSw1MSBAQCBpbnQgaHlwZXJfZG1hYnVmX2ltcG9ydGVyX3JpbmdidWZfaW5p dChpbnQgc2RvbWFpbiwgZ3JhbnRfcmVmX3QgZ3JlZiwgaW50IHBvcnQpCiAJcmluZ19pbmZvLT5p cnEgPSByZXQ7CiAKIAlwcmludGsoIiVzOiBib3VuZCB0byBldmVudGNoYW5uZWwgcG9ydDogJWQg IGlycTogJWRcbiIsIF9fZnVuY19fLAotCQlwb3J0LAorCQlpbXBvcnRlcl9wb3J0LAogCQlyaW5n X2luZm8tPmlycSk7CiAKIAlyZXQgPSBoeXBlcl9kbWFidWZfcmVnaXN0ZXJfaW1wb3J0ZXJfcmlu ZyhyaW5nX2luZm8pOwogCisJLyogU2V0dXAgY29tbXVuY2F0aW9uIGNoYW5uZWwgaW4gb3Bwb3Np dGUgZGlyZWN0aW9uICovCisJaWYgKCFoeXBlcl9kbWFidWZfZmluZF9leHBvcnRlcl9yaW5nKHNk b21haW4pKSB7CisJCXJldCA9IGh5cGVyX2RtYWJ1Zl9leHBvcnRlcl9yaW5nYnVmX2luaXQoc2Rv bWFpbik7CisJfQorCiAJcmV0dXJuIHJldDsKIH0KIAorLyogY2xlbmFzIHVwIGltcG9ydGVyIHJp bmcgY3JlYXRlIGZvciBnaXZlbiBzb3VyY2UgZG9tYWluICovCit2b2lkIGh5cGVyX2RtYWJ1Zl9p bXBvcnRlcl9yaW5nYnVmX2NsZWFudXAoaW50IHNkb21haW4pCit7CisJc3RydWN0IGh5cGVyX2Rt YWJ1Zl9yaW5nX2luZm9faW1wb3J0ICpyaW5nX2luZm87CisJc3RydWN0IHBhZ2UgKnNoYXJlZF9y aW5nOworCisJLyogY2hlY2sgaWYgd2UgaGF2ZSBpbXBvcnRlciByaW5nIGNyZWF0ZWQgZm9yIGdp dmVuIHNkb21haW4gKi8KKwlyaW5nX2luZm8gPSBoeXBlcl9kbWFidWZfZmluZF9pbXBvcnRlcl9y aW5nKHNkb21haW4pOworCisJaWYgKCFyaW5nX2luZm8pCisJCXJldHVybjsKKworCWh5cGVyX2Rt YWJ1Zl9yZW1vdmVfaW1wb3J0ZXJfcmluZyhzZG9tYWluKTsKKworCS8qIG5vIG5lZWQgdG8gY2xv c2UgZXZlbnQgY2hhbm5lbCwgd2lsbCBiZSBkb25lIGJ5IHRoYXQgZnVuY3Rpb24gKi8KKwl1bmJp bmRfZnJvbV9pcnFoYW5kbGVyKHJpbmdfaW5mby0+aXJxLAkodm9pZCopIHJpbmdfaW5mbyk7CisK KwkvKiB1bm1hcHBpbmcgc2hhcmVkIHJpbmcgcGFnZSAqLworCXNoYXJlZF9yaW5nID0gdmlydF90 b19wYWdlKHJpbmdfaW5mby0+cmluZ19iYWNrLnNyaW5nKTsKKwlnbnR0YWJfdW5tYXBfcmVmcygm cmluZ19pbmZvLT51bm1hcF9vcCwgTlVMTCwgJnNoYXJlZF9yaW5nLCAxKTsKKwlnbnR0YWJfZnJl ZV9wYWdlcygxLCAmc2hhcmVkX3JpbmcpOworCisJa2ZyZWUocmluZ19pbmZvKTsKK30KKworLyog Y2xlYW5zIHVwIGFsbCBleHBvcnRlci9pbXBvcnRlciByaW5ncyAqLwordm9pZCBoeXBlcl9kbWFi dWZfY2xlYW51cF9yaW5nYnVmcyh2b2lkKQoreworCWh5cGVyX2RtYWJ1Zl9mb3JlYWNoX2V4cG9y dGVyX3JpbmcoaHlwZXJfZG1hYnVmX2V4cG9ydGVyX3JpbmdidWZfY2xlYW51cCk7CisJaHlwZXJf ZG1hYnVmX2ZvcmVhY2hfaW1wb3J0ZXJfcmluZyhoeXBlcl9kbWFidWZfaW1wb3J0ZXJfcmluZ2J1 Zl9jbGVhbnVwKTsKK30KKwogaW50IGh5cGVyX2RtYWJ1Zl9zZW5kX3JlcXVlc3QoaW50IGRvbWFp biwgc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX3JxICpyZXEpCiB7CiAJc3RydWN0IGh5cGVyX2Rt YWJ1Zl9mcm9udF9yaW5nICpyaW5nOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uaCBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmgKaW5kZXggNGFkMDUyOS4uYTQ4MTljYSAxMDA2 NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2Nv bW0uaAorKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5f Y29tbS5oCkBAIC0yLDYgKzIsNyBAQAogI2RlZmluZSBfX0hZUEVSX0RNQUJVRl9YRU5fQ09NTV9I X18KIAogI2luY2x1ZGUgInhlbi9pbnRlcmZhY2UvaW8vcmluZy5oIgorI2luY2x1ZGUgInhlbi94 ZW5idXMuaCIKIAogI2RlZmluZSBNQVhfTlVNQkVSX09GX09QRVJBTkRTIDkKIApAQCAtMjcsNiAr MjgsNyBAQCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JpbmdfaW5mb19leHBvcnQgewogICAgICAgICBp bnQgZ3JlZl9yaW5nOwogICAgICAgICBpbnQgaXJxOwogICAgICAgICBpbnQgcG9ydDsKKwlzdHJ1 Y3QgeGVuYnVzX3dhdGNoIHdhdGNoOwogfTsKIAogc3RydWN0IGh5cGVyX2RtYWJ1Zl9yaW5nX2lu Zm9faW1wb3J0IHsKQEAgLTM0LDE3ICszNiwyOSBAQCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3Jpbmdf aW5mb19pbXBvcnQgewogICAgICAgICBpbnQgaXJxOwogICAgICAgICBpbnQgZXZ0Y2huOwogICAg ICAgICBzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tfcmluZyByaW5nX2JhY2s7CisJc3RydWN0IGdu dHRhYl91bm1hcF9ncmFudF9yZWYgdW5tYXBfb3A7CiB9OwogCiBpbnQzMl90IGh5cGVyX2RtYWJ1 Zl9nZXRfZG9taWQodm9pZCk7CitpbnQzMl90IGh5cGVyX2RtYWJ1Zl9zZXR1cF9kYXRhX2Rpcih2 b2lkKTsKK2ludDMyX3QgaHlwZXJfZG1hYnVmX2Rlc3Ryb3lfZGF0YV9kaXIodm9pZCk7CiAKIGlu dCBoeXBlcl9kbWFidWZfbmV4dF9yZXFfaWRfZXhwb3J0KHZvaWQpOwogCiAvKiBleHBvcnRlciBu ZWVkcyB0byBnZW5lcmF0ZWQgaW5mbyBmb3IgcGFnZSBzaGFyaW5nICovCi1pbnQgaHlwZXJfZG1h YnVmX2V4cG9ydGVyX3JpbmdidWZfaW5pdChpbnQgcmRvbWFpbiwgZ3JhbnRfcmVmX3QgKmdyZWYs IGludCAqcG9ydCk7CitpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydGVyX3JpbmdidWZfaW5pdChpbnQg cmRvbWFpbik7CiAKIC8qIGltcG9ydGVyIG5lZWRzIHRvIGtub3cgYWJvdXQgc2hhcmVkIHBhZ2Ug YW5kIHBvcnQgbnVtYmVycyBmb3IgcmluZyBidWZmZXIgYW5kIGV2ZW50IGNoYW5uZWwgKi8KLWlu dCBoeXBlcl9kbWFidWZfaW1wb3J0ZXJfcmluZ2J1Zl9pbml0KGludCBzZG9tYWluLCBncmFudF9y ZWZfdCBncmVmLCBpbnQgcG9ydCk7CitpbnQgaHlwZXJfZG1hYnVmX2ltcG9ydGVyX3JpbmdidWZf aW5pdChpbnQgc2RvbWFpbik7CisKKy8qIGNsZWFucyB1cCBleHBvcnRlciByaW5nIGNyZWF0ZWQg Zm9yIGdpdmVuIGRvbWFpbiAqLwordm9pZCBoeXBlcl9kbWFidWZfZXhwb3J0ZXJfcmluZ2J1Zl9j bGVhbnVwKGludCByZG9tYWluKTsKKworLyogY2xlYW5zIHVwIGltcG9ydGVyIHJpbmcgY3JlYXRl ZCBmb3IgZ2l2ZW4gZG9tYWluICovCit2b2lkIGh5cGVyX2RtYWJ1Zl9pbXBvcnRlcl9yaW5nYnVm X2NsZWFudXAoaW50IHNkb21haW4pOworCisvKiBjbGVhbnMgdXAgYWxsIGV4cG9ydGVyL2ltcG9y dGVyIHJpbmdzICovCit2b2lkIGh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3JpbmdidWZzKHZvaWQpOwog CiAvKiBzZW5kIHJlcXVlc3QgdG8gdGhlIHJlbW90ZSBkb21haW4gKi8KIGludCBoeXBlcl9kbWFi dWZfc2VuZF9yZXF1ZXN0KGludCBkb21haW4sIHN0cnVjdCBoeXBlcl9kbWFidWZfcmluZ19ycSAq cmVxKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1h YnVmX3hlbl9jb21tX2xpc3QuYyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJf ZG1hYnVmX3hlbl9jb21tX2xpc3QuYwppbmRleCAxNWM5ZDI5Li41Nzc4NDY4IDEwMDY0NAotLS0g YS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbV9saXN0 LmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2Nv bW1fbGlzdC5jCkBAIC0xMDQsMyArMTA0LDI1IEBAIGludCBoeXBlcl9kbWFidWZfcmVtb3ZlX2lt cG9ydGVyX3JpbmcoaW50IGRvbWlkKQogCiAJcmV0dXJuIC0xOwogfQorCit2b2lkIGh5cGVyX2Rt YWJ1Zl9mb3JlYWNoX2V4cG9ydGVyX3Jpbmcodm9pZCAoKmZ1bmMpKGludCByZG9tKSkKK3sKKwlz dHJ1Y3QgaHlwZXJfZG1hYnVmX2V4cG9ydGVyX3JpbmdfaW5mbyAqaW5mb19lbnRyeTsKKwlzdHJ1 Y3QgaGxpc3Rfbm9kZSAqdG1wOworCWludCBia3Q7CisKKwloYXNoX2Zvcl9lYWNoX3NhZmUoaHlw ZXJfZG1hYnVmX2hhc2hfZXhwb3J0ZXJfcmluZywgYmt0LCB0bXAsIGluZm9fZW50cnksIG5vZGUp IHsKKwkJZnVuYyhpbmZvX2VudHJ5LT5pbmZvLT5yZG9tYWluKTsKKwl9Cit9CisKK3ZvaWQgaHlw ZXJfZG1hYnVmX2ZvcmVhY2hfaW1wb3J0ZXJfcmluZyh2b2lkICgqZnVuYykoaW50IHNkb20pKQor eworCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZXJfcmluZ19pbmZvICppbmZvX2VudHJ5Owor CXN0cnVjdCBobGlzdF9ub2RlICp0bXA7CisJaW50IGJrdDsKKworCWhhc2hfZm9yX2VhY2hfc2Fm ZShoeXBlcl9kbWFidWZfaGFzaF9pbXBvcnRlcl9yaW5nLCBia3QsIHRtcCwgaW5mb19lbnRyeSwg bm9kZSkgeworCQlmdW5jKGluZm9fZW50cnktPmluZm8tPnNkb21haW4pOworCX0KK30KZGlmZiAt LWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21t X2xpc3QuaCBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9j b21tX2xpc3QuaAppbmRleCA1OTI5Zjk5Li5mZDE5NThjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbV9saXN0LmgKKysrIGIvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW1fbGlzdC5oCkBA IC0zMiw0ICszMiwxMCBAQCBpbnQgaHlwZXJfZG1hYnVmX3JlbW92ZV9leHBvcnRlcl9yaW5nKGlu dCBkb21pZCk7CiAKIGludCBoeXBlcl9kbWFidWZfcmVtb3ZlX2ltcG9ydGVyX3JpbmcoaW50IGRv bWlkKTsKIAorLyogaXRlcmF0ZXMgb3ZlciBhbGwgZXhwb3J0ZXIgcmluZ3MgYW5kIGNhbGxzIHBy b3ZpZGVkIGZ1bmN0aW9uIGZvciBlYWNoIG9mIHRoZW0gKi8KK3ZvaWQgaHlwZXJfZG1hYnVmX2Zv cmVhY2hfZXhwb3J0ZXJfcmluZyh2b2lkICgqZnVuYykoaW50IHJkb20pKTsKKworLyogaXRlcmF0 ZXMgb3ZlciBhbGwgaW1wb3J0ZXIgcmluZ3MgYW5kIGNhbGxzIHByb3ZpZGVkIGZ1bmN0aW9uIGZv ciBlYWNoIG9mIHRoZW0gKi8KK3ZvaWQgaHlwZXJfZG1hYnVmX2ZvcmVhY2hfaW1wb3J0ZXJfcmlu Zyh2b2lkICgqZnVuYykoaW50IHNkb20pKTsKKwogI2VuZGlmIC8vIF9fSFlQRVJfRE1BQlVGX1hF Tl9DT01NX0xJU1RfSF9fCi0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg==