From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753611AbdLSTkZ (ORCPT ); Tue, 19 Dec 2017 14:40:25 -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 S1753275AbdLSThF (ORCPT ); Tue, 19 Dec 2017 14:37:05 -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="4018659" 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 49/60] hyper_dmabuf: general clean-up and fixes Date: Tue, 19 Dec 2017 11:30:05 -0800 Message-Id: <1513711816-2618-49-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 1. global hyper_dmabuf_private is now pointer(*hy_drv_priv) pointing to private data structure initialized when driver is initialized. This is freed when driver exits. 2. using shorter variable and type's names 3. remove unnecessary NULL checks 4. event-polling related funcs are now compiled only if CONFIG_HYPER_DMABUF_EVENT_GEN is enabled. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/Makefile | 7 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h | 25 - drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 164 +++--- drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 13 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c | 60 +-- drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c | 16 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 569 ++++++++++----------- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 2 + drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c | 88 ++-- drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h | 18 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 259 +++++----- drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 18 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c | 284 +++++----- drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h | 4 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c | 58 +-- drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h | 4 +- .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 170 +++--- drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c | 123 ++--- drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h | 10 +- drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 24 +- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 240 +++++---- .../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c | 6 +- .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c | 147 +++--- 23 files changed, 1144 insertions(+), 1165 deletions(-) delete mode 100644 drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h diff --git a/drivers/xen/hyper_dmabuf/Makefile b/drivers/xen/hyper_dmabuf/Makefile index 1cd7a81..a113bfc 100644 --- a/drivers/xen/hyper_dmabuf/Makefile +++ b/drivers/xen/hyper_dmabuf/Makefile @@ -13,9 +13,12 @@ ifneq ($(KERNELRELEASE),) hyper_dmabuf_id.o \ hyper_dmabuf_remote_sync.o \ hyper_dmabuf_query.o \ - hyper_dmabuf_event.o \ -ifeq ($(CONFIG_XEN), y) +ifeq ($(CONFIG_HYPER_DMABUF_EVENT_GEN), y) + $(TARGET_MODULE)-objs += hyper_dmabuf_event.o +endif + +ifeq ($(CONFIG_HYPER_DMABUF_XEN), y) $(TARGET_MODULE)-objs += xen/hyper_dmabuf_xen_comm.o \ xen/hyper_dmabuf_xen_comm_list.o \ xen/hyper_dmabuf_xen_shm.o \ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h deleted file mode 100644 index d5125f2..0000000 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h +++ /dev/null @@ -1,25 +0,0 @@ -/* - * 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. - * - */ - -/* configuration */ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c index 1c35a59..525ee78 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c @@ -36,7 +36,6 @@ #include #include #include "hyper_dmabuf_drv.h" -#include "hyper_dmabuf_conf.h" #include "hyper_dmabuf_ioctl.h" #include "hyper_dmabuf_msg.h" #include "hyper_dmabuf_list.h" @@ -51,13 +50,32 @@ extern struct hyper_dmabuf_backend_ops xen_backend_ops; MODULE_LICENSE("GPL and additional rights"); MODULE_AUTHOR("Intel Corporation"); -struct hyper_dmabuf_private hyper_dmabuf_private; +struct hyper_dmabuf_private *hy_drv_priv; long hyper_dmabuf_ioctl(struct file *filp, unsigned int cmd, unsigned long param); -void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info, - void *attr); +static void hyper_dmabuf_force_free(struct exported_sgt_info* exported, + void *attr) +{ + struct ioctl_hyper_dmabuf_unexport unexport_attr; + struct file *filp = (struct file*) attr; + + if (!filp || !exported) + return; + + if (exported->filp == filp) { + dev_dbg(hy_drv_priv->dev, + "Forcefully releasing buffer {id:%d key:%d %d %d}\n", + exported->hid.id, exported->hid.rng_key[0], + exported->hid.rng_key[1], exported->hid.rng_key[2]); + + unexport_attr.hid = exported->hid; + unexport_attr.delay_ms = 0; + + hyper_dmabuf_unexport_ioctl(filp, &unexport_attr); + } +} int hyper_dmabuf_open(struct inode *inode, struct file *filp) { @@ -72,18 +90,20 @@ int hyper_dmabuf_open(struct inode *inode, struct file *filp) int hyper_dmabuf_release(struct inode *inode, struct file *filp) { - hyper_dmabuf_foreach_exported(hyper_dmabuf_emergency_release, filp); + hyper_dmabuf_foreach_exported(hyper_dmabuf_force_free, filp); return 0; } +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN + unsigned int hyper_dmabuf_event_poll(struct file *filp, struct poll_table_struct *wait) { unsigned int mask = 0; - poll_wait(filp, &hyper_dmabuf_private.event_wait, wait); + poll_wait(filp, &hy_drv_priv->event_wait, wait); - if (!list_empty(&hyper_dmabuf_private.event_list)) + if (!list_empty(&hy_drv_priv->event_list)) mask |= POLLIN | POLLRDNORM; return mask; @@ -96,32 +116,32 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, /* only root can read events */ if (!capable(CAP_DAC_OVERRIDE)) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Only root can read events\n"); return -EFAULT; } /* make sure user buffer can be written */ if (!access_ok(VERIFY_WRITE, buffer, count)) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "User buffer can't be written.\n"); return -EFAULT; } - ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock); + ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock); if (ret) return ret; while (1) { struct hyper_dmabuf_event *e = NULL; - spin_lock_irq(&hyper_dmabuf_private.event_lock); - if (!list_empty(&hyper_dmabuf_private.event_list)) { - e = list_first_entry(&hyper_dmabuf_private.event_list, + spin_lock_irq(&hy_drv_priv->event_lock); + if (!list_empty(&hy_drv_priv->event_list)) { + e = list_first_entry(&hy_drv_priv->event_list, struct hyper_dmabuf_event, link); list_del(&e->link); } - spin_unlock_irq(&hyper_dmabuf_private.event_lock); + spin_unlock_irq(&hy_drv_priv->event_lock); if (!e) { if (ret) @@ -131,12 +151,12 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, break; } - mutex_unlock(&hyper_dmabuf_private.event_read_lock); - ret = wait_event_interruptible(hyper_dmabuf_private.event_wait, - !list_empty(&hyper_dmabuf_private.event_list)); + mutex_unlock(&hy_drv_priv->event_read_lock); + ret = wait_event_interruptible(hy_drv_priv->event_wait, + !list_empty(&hy_drv_priv->event_list)); if (ret == 0) - ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock); + ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock); if (ret) return ret; @@ -145,9 +165,9 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, if (length > count - ret) { put_back_event: - spin_lock_irq(&hyper_dmabuf_private.event_lock); - list_add(&e->link, &hyper_dmabuf_private.event_list); - spin_unlock_irq(&hyper_dmabuf_private.event_lock); + spin_lock_irq(&hy_drv_priv->event_lock); + list_add(&e->link, &hy_drv_priv->event_list); + spin_unlock_irq(&hy_drv_priv->event_lock); break; } @@ -170,7 +190,7 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, /* nullifying hdr of the event in user buffer */ if (copy_to_user(buffer + ret, &dummy_hdr, sizeof(dummy_hdr))) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "failed to nullify invalid hdr already in userspace\n"); } @@ -180,23 +200,30 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, } ret += e->event_data.hdr.size; - hyper_dmabuf_private.curr_num_event--; + hy_drv_priv->pending--; kfree(e); } } - mutex_unlock(&hyper_dmabuf_private.event_read_lock); + mutex_unlock(&hy_drv_priv->event_read_lock); return ret; } +#endif + static struct file_operations hyper_dmabuf_driver_fops = { .owner = THIS_MODULE, .open = hyper_dmabuf_open, .release = hyper_dmabuf_release, + +/* poll and read interfaces are needed only for event-polling */ +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN .read = hyper_dmabuf_event_read, .poll = hyper_dmabuf_event_poll, +#endif + .unlocked_ioctl = hyper_dmabuf_ioctl, }; @@ -217,17 +244,17 @@ int register_device(void) return ret; } - hyper_dmabuf_private.device = hyper_dmabuf_miscdev.this_device; + hy_drv_priv->dev = hyper_dmabuf_miscdev.this_device; /* TODO: Check if there is a different way to initialize dma mask nicely */ - dma_coerce_mask_and_coherent(hyper_dmabuf_private.device, DMA_BIT_MASK(64)); + dma_coerce_mask_and_coherent(hy_drv_priv->dev, DMA_BIT_MASK(64)); return ret; } void unregister_device(void) { - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "hyper_dmabuf: unregister_device() is called\n"); misc_deregister(&hyper_dmabuf_miscdev); @@ -239,9 +266,13 @@ static int __init hyper_dmabuf_drv_init(void) printk( KERN_NOTICE "hyper_dmabuf_starting: Initialization started\n"); - mutex_init(&hyper_dmabuf_private.lock); - mutex_init(&hyper_dmabuf_private.event_read_lock); - spin_lock_init(&hyper_dmabuf_private.event_lock); + hy_drv_priv = kcalloc(1, sizeof(struct hyper_dmabuf_private), + GFP_KERNEL); + + if (!hy_drv_priv) { + printk( KERN_ERR "hyper_dmabuf: Failed to create drv\n"); + return -1; + } ret = register_device(); if (ret < 0) { @@ -251,64 +282,72 @@ static int __init hyper_dmabuf_drv_init(void) /* currently only supports XEN hypervisor */ #ifdef CONFIG_HYPER_DMABUF_XEN - hyper_dmabuf_private.backend_ops = &xen_backend_ops; + hy_drv_priv->backend_ops = &xen_backend_ops; #else - hyper_dmabuf_private.backend_ops = NULL; + hy_drv_priv->backend_ops = NULL; printk( KERN_ERR "hyper_dmabuf drv currently supports XEN only.\n"); #endif - if (hyper_dmabuf_private.backend_ops == NULL) { + if (hy_drv_priv->backend_ops == NULL) { printk( KERN_ERR "Hyper_dmabuf: failed to be loaded - no backend found\n"); return -1; } - mutex_lock(&hyper_dmabuf_private.lock); + /* initializing mutexes and a spinlock */ + mutex_init(&hy_drv_priv->lock); + + mutex_lock(&hy_drv_priv->lock); - hyper_dmabuf_private.backend_initialized = false; + hy_drv_priv->initialized = false; - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "initializing database for imported/exported dmabufs\n"); /* device structure initialization */ /* currently only does work-queue initialization */ - hyper_dmabuf_private.work_queue = create_workqueue("hyper_dmabuf_wqueue"); + hy_drv_priv->work_queue = create_workqueue("hyper_dmabuf_wqueue"); ret = hyper_dmabuf_table_init(); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "failed to initialize table for exported/imported entries\n"); return ret; } #ifdef CONFIG_HYPER_DMABUF_SYSFS - ret = hyper_dmabuf_register_sysfs(hyper_dmabuf_private.device); + ret = hyper_dmabuf_register_sysfs(hy_drv_priv->dev); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "failed to initialize sysfs\n"); return ret; } #endif +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN + mutex_init(&hy_drv_priv->event_read_lock); + spin_lock_init(&hy_drv_priv->event_lock); + /* Initialize event queue */ - INIT_LIST_HEAD(&hyper_dmabuf_private.event_list); - init_waitqueue_head(&hyper_dmabuf_private.event_wait); + INIT_LIST_HEAD(&hy_drv_priv->event_list); + init_waitqueue_head(&hy_drv_priv->event_wait); - hyper_dmabuf_private.curr_num_event = 0; - hyper_dmabuf_private.exited = false; + /* resetting number of pending events */ + hy_drv_priv->pending = 0; +#endif - hyper_dmabuf_private.domid = hyper_dmabuf_private.backend_ops->get_vm_id(); + hy_drv_priv->domid = hy_drv_priv->backend_ops->get_vm_id(); - ret = hyper_dmabuf_private.backend_ops->init_comm_env(); + ret = hy_drv_priv->backend_ops->init_comm_env(); if (ret < 0) { - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "failed to initialize comm-env but it will re-attempt.\n"); } else { - hyper_dmabuf_private.backend_initialized = true; + hy_drv_priv->initialized = true; } - mutex_unlock(&hyper_dmabuf_private.lock); + mutex_unlock(&hy_drv_priv->lock); - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "Finishing up initialization of hyper_dmabuf drv\n"); /* interrupt for comm should be registered here: */ @@ -318,34 +357,39 @@ static int __init hyper_dmabuf_drv_init(void) static void hyper_dmabuf_drv_exit(void) { #ifdef CONFIG_HYPER_DMABUF_SYSFS - hyper_dmabuf_unregister_sysfs(hyper_dmabuf_private.device); + hyper_dmabuf_unregister_sysfs(hy_drv_priv->dev); #endif - mutex_lock(&hyper_dmabuf_private.lock); + mutex_lock(&hy_drv_priv->lock); /* hash tables for export/import entries and ring_infos */ hyper_dmabuf_table_destroy(); - hyper_dmabuf_private.backend_ops->destroy_comm(); + hy_drv_priv->backend_ops->destroy_comm(); /* destroy workqueue */ - if (hyper_dmabuf_private.work_queue) - destroy_workqueue(hyper_dmabuf_private.work_queue); + if (hy_drv_priv->work_queue) + destroy_workqueue(hy_drv_priv->work_queue); /* destroy id_queue */ - if (hyper_dmabuf_private.id_queue) + if (hy_drv_priv->id_queue) destroy_reusable_list(); - hyper_dmabuf_private.exited = true; - +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN /* clean up event queue */ hyper_dmabuf_events_release(); +#endif - mutex_unlock(&hyper_dmabuf_private.lock); + mutex_unlock(&hy_drv_priv->lock); - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "hyper_dmabuf driver: Exiting\n"); + if (hy_drv_priv) { + kfree(hy_drv_priv); + hy_drv_priv = NULL; + } + unregister_device(); } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h index a4acdd9f..2ead41b 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h @@ -36,7 +36,7 @@ struct hyper_dmabuf_event { }; struct hyper_dmabuf_private { - struct device *device; + struct device *dev; /* VM(domain) id of current VM instance */ int domid; @@ -55,7 +55,7 @@ struct hyper_dmabuf_private { struct mutex lock; /* flag that shows whether backend is initialized */ - bool backend_initialized; + bool initialized; wait_queue_head_t event_wait; struct list_head event_list; @@ -63,10 +63,8 @@ struct hyper_dmabuf_private { spinlock_t event_lock; struct mutex event_read_lock; - int curr_num_event; - - /* indicate whether the driver is unloaded */ - bool exited; + /* # of pending events */ + int pending; }; struct list_reusable_id { @@ -108,4 +106,7 @@ struct hyper_dmabuf_backend_ops { int (*send_req)(int, struct hyper_dmabuf_req *, int); }; +/* exporting global drv private info */ +extern struct hyper_dmabuf_private *hy_drv_priv; + #endif /* __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ */ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c index 3e1498c..0498cda 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c @@ -32,37 +32,33 @@ #include #include #include -#include -#include #include "hyper_dmabuf_drv.h" #include "hyper_dmabuf_struct.h" #include "hyper_dmabuf_list.h" #include "hyper_dmabuf_event.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e) { struct hyper_dmabuf_event *oldest; - assert_spin_locked(&hyper_dmabuf_private.event_lock); + assert_spin_locked(&hy_drv_priv->event_lock); /* check current number of event then if it hits the max num allowed * then remove the oldest event in the list */ - if (hyper_dmabuf_private.curr_num_event > MAX_DEPTH_EVENT_QUEUE - 1) { - oldest = list_first_entry(&hyper_dmabuf_private.event_list, + if (hy_drv_priv->pending > MAX_DEPTH_EVENT_QUEUE - 1) { + oldest = list_first_entry(&hy_drv_priv->event_list, struct hyper_dmabuf_event, link); list_del(&oldest->link); - hyper_dmabuf_private.curr_num_event--; + hy_drv_priv->pending--; kfree(oldest); } list_add_tail(&e->link, - &hyper_dmabuf_private.event_list); + &hy_drv_priv->event_list); - hyper_dmabuf_private.curr_num_event++; + hy_drv_priv->pending++; - wake_up_interruptible(&hyper_dmabuf_private.event_wait); + wake_up_interruptible(&hy_drv_priv->event_wait); } void hyper_dmabuf_events_release() @@ -70,34 +66,34 @@ void hyper_dmabuf_events_release() struct hyper_dmabuf_event *e, *et; unsigned long irqflags; - spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags); + spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags); - list_for_each_entry_safe(e, et, &hyper_dmabuf_private.event_list, + list_for_each_entry_safe(e, et, &hy_drv_priv->event_list, link) { list_del(&e->link); kfree(e); - hyper_dmabuf_private.curr_num_event--; + hy_drv_priv->pending--; } - if (hyper_dmabuf_private.curr_num_event) { - dev_err(hyper_dmabuf_private.device, + if (hy_drv_priv->pending) { + dev_err(hy_drv_priv->dev, "possible leak on event_list\n"); } - spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags); + spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags); } int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid) { struct hyper_dmabuf_event *e; - struct hyper_dmabuf_imported_sgt_info *imported_sgt_info; + struct imported_sgt_info *imported; unsigned long irqflags; - imported_sgt_info = hyper_dmabuf_find_imported(hid); + imported = hyper_dmabuf_find_imported(hid); - if (!imported_sgt_info) { - dev_err(hyper_dmabuf_private.device, + if (!imported) { + dev_err(hy_drv_priv->dev, "can't find imported_sgt_info in the list\n"); return -EINVAL; } @@ -105,29 +101,29 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid) e = kzalloc(sizeof(*e), GFP_KERNEL); if (!e) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "no space left\n"); return -ENOMEM; } e->event_data.hdr.event_type = HYPER_DMABUF_NEW_IMPORT; e->event_data.hdr.hid = hid; - e->event_data.data = (void*)imported_sgt_info->priv; - e->event_data.hdr.size = imported_sgt_info->sz_priv; + e->event_data.data = (void*)imported->priv; + e->event_data.hdr.size = imported->sz_priv; - spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags); + spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags); hyper_dmabuf_send_event_locked(e); - spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags); + spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags); - dev_dbg(hyper_dmabuf_private.device, - "event number = %d :", hyper_dmabuf_private.curr_num_event); + dev_dbg(hy_drv_priv->dev, + "event number = %d :", hy_drv_priv->pending); - dev_dbg(hyper_dmabuf_private.device, - "generating events for {%d, %d, %d, %d}\n", - imported_sgt_info->hid.id, imported_sgt_info->hid.rng_key[0], - imported_sgt_info->hid.rng_key[1], imported_sgt_info->hid.rng_key[2]); + dev_dbg(hy_drv_priv->dev, + "generating events for {%d, %d, %d, %d}\n", + imported->hid.id, imported->hid.rng_key[0], + imported->hid.rng_key[1], imported->hid.rng_key[2]); return 0; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c index cccdc19..e2466c7 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c @@ -33,17 +33,15 @@ #include "hyper_dmabuf_id.h" #include "hyper_dmabuf_msg.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - void store_reusable_hid(hyper_dmabuf_id_t hid) { - struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue; + struct list_reusable_id *reusable_head = hy_drv_priv->id_queue; struct list_reusable_id *new_reusable; new_reusable = kmalloc(sizeof(*new_reusable), GFP_KERNEL); if (!new_reusable) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return; } @@ -55,7 +53,7 @@ void store_reusable_hid(hyper_dmabuf_id_t hid) static hyper_dmabuf_id_t retrieve_reusable_hid(void) { - struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue; + struct list_reusable_id *reusable_head = hy_drv_priv->id_queue; hyper_dmabuf_id_t hid = {-1, {0,0,0}}; /* check there is reusable id */ @@ -74,7 +72,7 @@ static hyper_dmabuf_id_t retrieve_reusable_hid(void) void destroy_reusable_list(void) { - struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue; + struct list_reusable_id *reusable_head = hy_drv_priv->id_queue; struct list_reusable_id *temp_head; if (reusable_head) { @@ -103,14 +101,14 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void) reusable_head = kmalloc(sizeof(*reusable_head), GFP_KERNEL); if (!reusable_head) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return (hyper_dmabuf_id_t){-1, {0,0,0}}; } reusable_head->hid.id = -1; /* list head has an invalid count */ INIT_LIST_HEAD(&reusable_head->list); - hyper_dmabuf_private.id_queue = reusable_head; + hy_drv_priv->id_queue = reusable_head; } hid = retrieve_reusable_hid(); @@ -119,7 +117,7 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void) * and count is less than maximum allowed */ if (hid.id == -1 && count < HYPER_DMABUF_ID_MAX) { - hid.id = HYPER_DMABUF_ID_CREATE(hyper_dmabuf_private.domid, count++); + hid.id = HYPER_DMABUF_ID_CREATE(hy_drv_priv->domid, count++); } /* random data embedded in the id for security */ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index 15191c2..b328df7 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -45,16 +45,14 @@ #include "hyper_dmabuf_ops.h" #include "hyper_dmabuf_query.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data) { struct ioctl_hyper_dmabuf_tx_ch_setup *tx_ch_attr; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; int ret = 0; if (!data) { - dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); + dev_err(hy_drv_priv->dev, "user data is NULL\n"); return -EINVAL; } tx_ch_attr = (struct ioctl_hyper_dmabuf_tx_ch_setup *)data; @@ -67,11 +65,11 @@ static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data) static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data) { struct ioctl_hyper_dmabuf_rx_ch_setup *rx_ch_attr; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; int ret = 0; if (!data) { - dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); + dev_err(hy_drv_priv->dev, "user data is NULL\n"); return -EINVAL; } @@ -82,48 +80,48 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data) return ret; } -static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info, - struct hyper_dmabuf_pages_info *page_info) +static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported, + struct pages_info *pg_info) { - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; struct hyper_dmabuf_req *req; - int operands[MAX_NUMBER_OF_OPERANDS] = {0}; + int op[MAX_NUMBER_OF_OPERANDS] = {0}; int ret, i; /* now create request for importer via ring */ - operands[0] = sgt_info->hid.id; + op[0] = exported->hid.id; for (i=0; i<3; i++) - operands[i+1] = sgt_info->hid.rng_key[i]; - - if (page_info) { - operands[4] = page_info->nents; - operands[5] = page_info->frst_ofst; - operands[6] = page_info->last_len; - operands[7] = ops->share_pages (page_info->pages, sgt_info->hyper_dmabuf_rdomain, - page_info->nents, &sgt_info->refs_info); - if (operands[7] < 0) { - dev_err(hyper_dmabuf_private.device, "pages sharing failed\n"); + op[i+1] = exported->hid.rng_key[i]; + + if (pg_info) { + op[4] = pg_info->nents; + op[5] = pg_info->frst_ofst; + op[6] = pg_info->last_len; + op[7] = ops->share_pages(pg_info->pgs, exported->rdomid, + pg_info->nents, &exported->refs_info); + if (op[7] < 0) { + dev_err(hy_drv_priv->dev, "pages sharing failed\n"); return -1; } } - operands[8] = sgt_info->sz_priv; + op[8] = exported->sz_priv; /* driver/application specific private info */ - memcpy(&operands[9], sgt_info->priv, operands[8]); + memcpy(&op[9], exported->priv, op[8]); req = kcalloc(1, sizeof(*req), GFP_KERNEL); if(!req) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); + dev_err(hy_drv_priv->dev, "no more space left\n"); return -1; } /* composing a message to the importer */ - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]); + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT, &op[0]); - ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true); + ret = ops->send_req(exported->rdomid, req, true); kfree(req); @@ -132,24 +130,18 @@ static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info, static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) { - struct ioctl_hyper_dmabuf_export_remote *export_remote_attr; + struct ioctl_hyper_dmabuf_export_remote *export_remote_attr = + (struct ioctl_hyper_dmabuf_export_remote *)data; struct dma_buf *dma_buf; struct dma_buf_attachment *attachment; struct sg_table *sgt; - struct hyper_dmabuf_pages_info *page_info; - struct hyper_dmabuf_sgt_info *sgt_info; + struct pages_info *pg_info; + struct exported_sgt_info *exported; hyper_dmabuf_id_t hid; int ret = 0; - if (!data) { - dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); - return -EINVAL; - } - - export_remote_attr = (struct ioctl_hyper_dmabuf_export_remote *)data; - - if (hyper_dmabuf_private.domid == export_remote_attr->remote_domain) { - dev_err(hyper_dmabuf_private.device, + if (hy_drv_priv->domid == export_remote_attr->remote_domain) { + dev_err(hy_drv_priv->dev, "exporting to the same VM is not permitted\n"); return -EINVAL; } @@ -157,7 +149,7 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) dma_buf = dma_buf_get(export_remote_attr->dmabuf_fd); if (IS_ERR(dma_buf)) { - dev_err(hyper_dmabuf_private.device, "Cannot get dma buf\n"); + dev_err(hy_drv_priv->dev, "Cannot get dma buf\n"); return PTR_ERR(dma_buf); } @@ -165,69 +157,79 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) * to the same domain and if yes and it's valid sgt_info, * it returns hyper_dmabuf_id of pre-exported sgt_info */ - hid = hyper_dmabuf_find_hid_exported(dma_buf, export_remote_attr->remote_domain); + hid = hyper_dmabuf_find_hid_exported(dma_buf, + export_remote_attr->remote_domain); if (hid.id != -1) { - sgt_info = hyper_dmabuf_find_exported(hid); - if (sgt_info != NULL) { - if (sgt_info->valid) { + exported = hyper_dmabuf_find_exported(hid); + if (exported != NULL) { + if (exported->valid) { /* * Check if unexport is already scheduled for that buffer, * if so try to cancel it. If that will fail, buffer needs * to be reexport once again. */ - if (sgt_info->unexport_scheduled) { - if (!cancel_delayed_work_sync(&sgt_info->unexport_work)) { + if (exported->unexport_sched) { + if (!cancel_delayed_work_sync(&exported->unexport)) { dma_buf_put(dma_buf); goto reexport; } - sgt_info->unexport_scheduled = 0; + exported->unexport_sched = false; } /* if there's any change in size of private data. * we reallocate space for private data with new size */ - if (export_remote_attr->sz_priv != sgt_info->sz_priv) { - kfree(sgt_info->priv); + if (export_remote_attr->sz_priv != exported->sz_priv) { + kfree(exported->priv); /* truncating size */ if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) { - sgt_info->sz_priv = MAX_SIZE_PRIV_DATA; + exported->sz_priv = MAX_SIZE_PRIV_DATA; } else { - sgt_info->sz_priv = export_remote_attr->sz_priv; + exported->sz_priv = export_remote_attr->sz_priv; } - sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL); + exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL); - if(!sgt_info->priv) { - dev_err(hyper_dmabuf_private.device, - "Can't reallocate priv because there's no more space left\n"); - hyper_dmabuf_remove_exported(sgt_info->hid); - hyper_dmabuf_cleanup_sgt_info(sgt_info, true); - kfree(sgt_info); + if(!exported->priv) { + dev_err(hy_drv_priv->dev, + "no more space left for priv\n"); + hyper_dmabuf_remove_exported(exported->hid); + hyper_dmabuf_cleanup_sgt_info(exported, true); + kfree(exported); + dma_buf_put(dma_buf); return -ENOMEM; } } /* update private data in sgt_info with new ones */ - copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv); - - /* send an export msg for updating priv in importer */ - ret = hyper_dmabuf_send_export_msg(sgt_info, NULL); - - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, "Failed to send a new private data\n"); + ret = copy_from_user(exported->priv, export_remote_attr->priv, + exported->sz_priv); + if (ret) { + dev_err(hy_drv_priv->dev, + "Failed to load a new private data\n"); + ret = -EINVAL; + } else { + /* send an export msg for updating priv in importer */ + ret = hyper_dmabuf_send_export_msg(exported, NULL); + + if (ret < 0) { + dev_err(hy_drv_priv->dev, + "Failed to send a new private data\n"); + ret = -EBUSY; + } } dma_buf_put(dma_buf); export_remote_attr->hid = hid; - return 0; + return ret; } } } reexport: - attachment = dma_buf_attach(dma_buf, hyper_dmabuf_private.device); + attachment = dma_buf_attach(dma_buf, hy_drv_priv->dev); if (IS_ERR(attachment)) { - dev_err(hyper_dmabuf_private.device, "Cannot get attachment\n"); + dev_err(hy_drv_priv->dev, "Cannot get attachment\n"); ret = PTR_ERR(attachment); goto fail_attach; } @@ -235,154 +237,165 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL); if (IS_ERR(sgt)) { - dev_err(hyper_dmabuf_private.device, "Cannot map attachment\n"); + dev_err(hy_drv_priv->dev, "Cannot map attachment\n"); ret = PTR_ERR(sgt); goto fail_map_attachment; } - sgt_info = kcalloc(1, sizeof(*sgt_info), GFP_KERNEL); + exported = kcalloc(1, sizeof(*exported), GFP_KERNEL); - if(!sgt_info) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); + if(!exported) { + dev_err(hy_drv_priv->dev, "no more space left\n"); ret = -ENOMEM; goto fail_sgt_info_creation; } /* possible truncation */ if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) { - sgt_info->sz_priv = MAX_SIZE_PRIV_DATA; + exported->sz_priv = MAX_SIZE_PRIV_DATA; } else { - sgt_info->sz_priv = export_remote_attr->sz_priv; + exported->sz_priv = export_remote_attr->sz_priv; } /* creating buffer for private data of buffer */ - if(sgt_info->sz_priv != 0) { - sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL); + if(exported->sz_priv != 0) { + exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL); - if(!sgt_info->priv) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); + if(!exported->priv) { + dev_err(hy_drv_priv->dev, "no more space left\n"); ret = -ENOMEM; goto fail_priv_creation; } } else { - dev_err(hyper_dmabuf_private.device, "size is 0\n"); + dev_err(hy_drv_priv->dev, "size is 0\n"); } - sgt_info->hid = hyper_dmabuf_get_hid(); + exported->hid = hyper_dmabuf_get_hid(); /* no more exported dmabuf allowed */ - if(sgt_info->hid.id == -1) { - dev_err(hyper_dmabuf_private.device, + if(exported->hid.id == -1) { + dev_err(hy_drv_priv->dev, "exceeds allowed number of dmabuf to be exported\n"); ret = -ENOMEM; goto fail_sgt_info_creation; } - /* TODO: We might need to consider using port number on event channel? */ - sgt_info->hyper_dmabuf_rdomain = export_remote_attr->remote_domain; - sgt_info->dma_buf = dma_buf; - sgt_info->valid = 1; + exported->rdomid = export_remote_attr->remote_domain; + exported->dma_buf = dma_buf; + exported->valid = true; - sgt_info->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL); - if (!sgt_info->active_sgts) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); + exported->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL); + if (!exported->active_sgts) { + dev_err(hy_drv_priv->dev, "no more space left\n"); ret = -ENOMEM; goto fail_map_active_sgts; } - sgt_info->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL); - if (!sgt_info->active_attached) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); + exported->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL); + if (!exported->active_attached) { + dev_err(hy_drv_priv->dev, "no more space left\n"); ret = -ENOMEM; goto fail_map_active_attached; } - sgt_info->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL); - if (!sgt_info->va_kmapped) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); + exported->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL); + if (!exported->va_kmapped) { + dev_err(hy_drv_priv->dev, "no more space left\n"); ret = -ENOMEM; goto fail_map_va_kmapped; } - sgt_info->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL); - if (!sgt_info->va_vmapped) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); + exported->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL); + if (!exported->va_vmapped) { + dev_err(hy_drv_priv->dev, "no more space left\n"); ret = -ENOMEM; goto fail_map_va_vmapped; } - sgt_info->active_sgts->sgt = sgt; - sgt_info->active_attached->attach = attachment; - sgt_info->va_kmapped->vaddr = NULL; - sgt_info->va_vmapped->vaddr = NULL; + exported->active_sgts->sgt = sgt; + exported->active_attached->attach = attachment; + exported->va_kmapped->vaddr = NULL; + exported->va_vmapped->vaddr = NULL; /* initialize list of sgt, attachment and vaddr for dmabuf sync * via shadow dma-buf */ - INIT_LIST_HEAD(&sgt_info->active_sgts->list); - INIT_LIST_HEAD(&sgt_info->active_attached->list); - INIT_LIST_HEAD(&sgt_info->va_kmapped->list); - INIT_LIST_HEAD(&sgt_info->va_vmapped->list); + INIT_LIST_HEAD(&exported->active_sgts->list); + INIT_LIST_HEAD(&exported->active_attached->list); + INIT_LIST_HEAD(&exported->va_kmapped->list); + INIT_LIST_HEAD(&exported->va_vmapped->list); /* copy private data to sgt_info */ - copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv); + ret = copy_from_user(exported->priv, export_remote_attr->priv, + exported->sz_priv); - page_info = hyper_dmabuf_ext_pgs(sgt); - if (!page_info) { - dev_err(hyper_dmabuf_private.device, "failed to construct page_info\n"); + if (ret) { + dev_err(hy_drv_priv->dev, + "failed to load private data\n"); + ret = -EINVAL; goto fail_export; } - sgt_info->nents = page_info->nents; + pg_info = hyper_dmabuf_ext_pgs(sgt); + if (!pg_info) { + dev_err(hy_drv_priv->dev, + "failed to construct pg_info\n"); + ret = -ENOMEM; + goto fail_export; + } + + exported->nents = pg_info->nents; /* now register it to export list */ - hyper_dmabuf_register_exported(sgt_info); + hyper_dmabuf_register_exported(exported); - export_remote_attr->hid = sgt_info->hid; + export_remote_attr->hid = exported->hid; - ret = hyper_dmabuf_send_export_msg(sgt_info, page_info); + ret = hyper_dmabuf_send_export_msg(exported, pg_info); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, "failed to send out the export request\n"); + dev_err(hy_drv_priv->dev, + "failed to send out the export request\n"); goto fail_send_request; } - /* free page_info */ - kfree(page_info->pages); - kfree(page_info); + /* free pg_info */ + kfree(pg_info->pgs); + kfree(pg_info); - sgt_info->filp = filp; + exported->filp = filp; return ret; /* Clean-up if error occurs */ fail_send_request: - hyper_dmabuf_remove_exported(sgt_info->hid); + hyper_dmabuf_remove_exported(exported->hid); - /* free page_info */ - kfree(page_info->pages); - kfree(page_info); + /* free pg_info */ + kfree(pg_info->pgs); + kfree(pg_info); fail_export: - kfree(sgt_info->va_vmapped); + kfree(exported->va_vmapped); fail_map_va_vmapped: - kfree(sgt_info->va_kmapped); + kfree(exported->va_kmapped); fail_map_va_kmapped: - kfree(sgt_info->active_attached); + kfree(exported->active_attached); fail_map_active_attached: - kfree(sgt_info->active_sgts); - kfree(sgt_info->priv); + kfree(exported->active_sgts); + kfree(exported->priv); fail_priv_creation: - kfree(sgt_info); + kfree(exported); fail_map_active_sgts: fail_sgt_info_creation: - dma_buf_unmap_attachment(attachment, sgt, DMA_BIDIRECTIONAL); + dma_buf_unmap_attachment(attachment, sgt, + DMA_BIDIRECTIONAL); fail_map_attachment: dma_buf_detach(dma_buf, attachment); @@ -395,143 +408,136 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) { - struct ioctl_hyper_dmabuf_export_fd *export_fd_attr; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct ioctl_hyper_dmabuf_export_fd *export_fd_attr = + (struct ioctl_hyper_dmabuf_export_fd *)data; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct imported_sgt_info *imported; struct hyper_dmabuf_req *req; - struct page **data_pages; - int operands[4]; + struct page **data_pgs; + int op[4]; int i; int ret = 0; - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); - - if (!data) { - dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); - return -EINVAL; - } - - export_fd_attr = (struct ioctl_hyper_dmabuf_export_fd *)data; + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__); /* look for dmabuf for the id */ - sgt_info = hyper_dmabuf_find_imported(export_fd_attr->hid); + imported = hyper_dmabuf_find_imported(export_fd_attr->hid); /* can't find sgt from the table */ - if (!sgt_info) { - dev_err(hyper_dmabuf_private.device, "can't find the entry\n"); + if (!imported) { + dev_err(hy_drv_priv->dev, "can't find the entry\n"); return -ENOENT; } - mutex_lock(&hyper_dmabuf_private.lock); + mutex_lock(&hy_drv_priv->lock); - sgt_info->num_importers++; + imported->importers++; /* send notification for export_fd to exporter */ - operands[0] = sgt_info->hid.id; + op[0] = imported->hid.id; for (i=0; i<3; i++) - operands[i+1] = sgt_info->hid.rng_key[i]; + op[i+1] = imported->hid.rng_key[i]; - dev_dbg(hyper_dmabuf_private.device, "Exporting fd of buffer {id:%d key:%d %d %d}\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + dev_dbg(hy_drv_priv->dev, "Exporting fd of buffer {id:%d key:%d %d %d}\n", + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1], + imported->hid.rng_key[2]); req = kcalloc(1, sizeof(*req), GFP_KERNEL); if (!req) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD, &operands[0]); + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD, &op[0]); - ret = ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, true); + ret = ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), 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, &operands[0]); - ops->send_req(operands[0], req, false); + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]); + ops->send_req(op[0], req, false); kfree(req); - dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n"); - sgt_info->num_importers--; - mutex_unlock(&hyper_dmabuf_private.lock); + dev_err(hy_drv_priv->dev, "Failed to create sgt or notify exporter\n"); + imported->importers--; + mutex_unlock(&hy_drv_priv->lock); return ret; } kfree(req); if (ret == HYPER_DMABUF_REQ_ERROR) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Buffer invalid {id:%d key:%d %d %d}, cannot import\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1], + imported->hid.rng_key[2]); - sgt_info->num_importers--; - mutex_unlock(&hyper_dmabuf_private.lock); + imported->importers--; + mutex_unlock(&hy_drv_priv->lock); return -EINVAL; } else { - dev_dbg(hyper_dmabuf_private.device, "Can import buffer {id:%d key:%d %d %d}\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + dev_dbg(hy_drv_priv->dev, "Can import buffer {id:%d key:%d %d %d}\n", + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1], + imported->hid.rng_key[2]); ret = 0; } - dev_dbg(hyper_dmabuf_private.device, - "%s Found buffer gref %d off %d last len %d nents %d domain %d\n", __func__, - sgt_info->ref_handle, sgt_info->frst_ofst, - sgt_info->last_len, sgt_info->nents, - HYPER_DMABUF_DOM_ID(sgt_info->hid)); + dev_dbg(hy_drv_priv->dev, + "%s Found buffer gref %d off %d last len %d nents %d domain %d\n", + __func__, imported->ref_handle, imported->frst_ofst, + imported->last_len, imported->nents, HYPER_DMABUF_DOM_ID(imported->hid)); - if (!sgt_info->sgt) { - dev_dbg(hyper_dmabuf_private.device, + if (!imported->sgt) { + dev_dbg(hy_drv_priv->dev, "%s buffer {id:%d key:%d %d %d} pages not mapped yet\n", __func__, - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1], + imported->hid.rng_key[2]); - data_pages = ops->map_shared_pages(sgt_info->ref_handle, - HYPER_DMABUF_DOM_ID(sgt_info->hid), - sgt_info->nents, - &sgt_info->refs_info); + data_pgs = ops->map_shared_pages(imported->ref_handle, + HYPER_DMABUF_DOM_ID(imported->hid), + imported->nents, + &imported->refs_info); - if (!data_pages) { - dev_err(hyper_dmabuf_private.device, + if (!data_pgs) { + dev_err(hy_drv_priv->dev, "Cannot map pages of buffer {id:%d key:%d %d %d}\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1], + imported->hid.rng_key[2]); - sgt_info->num_importers--; + imported->importers--; req = kcalloc(1, sizeof(*req), GFP_KERNEL); if (!req) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No more space left\n"); return -ENOMEM; } - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operands[0]); - ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, false); + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]); + ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, false); kfree(req); - mutex_unlock(&hyper_dmabuf_private.lock); + mutex_unlock(&hy_drv_priv->lock); return -EINVAL; } - sgt_info->sgt = hyper_dmabuf_create_sgt(data_pages, sgt_info->frst_ofst, - sgt_info->last_len, sgt_info->nents); + imported->sgt = hyper_dmabuf_create_sgt(data_pgs, imported->frst_ofst, + imported->last_len, imported->nents); } - export_fd_attr->fd = hyper_dmabuf_export_fd(sgt_info, export_fd_attr->flags); + export_fd_attr->fd = hyper_dmabuf_export_fd(imported, export_fd_attr->flags); if (export_fd_attr->fd < 0) { /* fail to get fd */ ret = export_fd_attr->fd; } - mutex_unlock(&hyper_dmabuf_private.lock); + mutex_unlock(&hy_drv_priv->lock); - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__); return ret; } @@ -541,50 +547,51 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) static void hyper_dmabuf_delayed_unexport(struct work_struct *work) { struct hyper_dmabuf_req *req; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + struct exported_sgt_info *exported = + container_of(work, struct exported_sgt_info, unexport.work); + int op[4]; int i, ret; - int operands[4]; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; - struct hyper_dmabuf_sgt_info *sgt_info = - container_of(work, struct hyper_dmabuf_sgt_info, unexport_work.work); - if (!sgt_info) + if (!exported) return; - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "Marking buffer {id:%d key:%d %d %d} as invalid\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + exported->hid.id, exported->hid.rng_key[0], + exported->hid.rng_key[1], exported->hid.rng_key[2]); /* no longer valid */ - sgt_info->valid = 0; + exported->valid = false; req = kcalloc(1, sizeof(*req), GFP_KERNEL); if (!req) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return; } - operands[0] = sgt_info->hid.id; + op[0] = exported->hid.id; for (i=0; i<3; i++) - operands[i+1] = sgt_info->hid.rng_key[i]; + op[i+1] = exported->hid.rng_key[i]; - hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &operands[0]); + hyper_dmabuf_create_req(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &op[0]); - /* Now send unexport request to remote domain, marking that buffer should not be used anymore */ - ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true); + /* Now send unexport request to remote domain, marking + * that buffer should not be used anymore */ + ret = ops->send_req(exported->rdomid, req, true); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "unexport message for buffer {id:%d key:%d %d %d} failed\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + exported->hid.id, exported->hid.rng_key[0], + exported->hid.rng_key[1], exported->hid.rng_key[2]); } /* free msg */ kfree(req); - sgt_info->unexport_scheduled = 0; + exported->unexport_sched = false; /* * Immediately clean-up if it has never been exported by importer @@ -593,104 +600,94 @@ static void hyper_dmabuf_delayed_unexport(struct work_struct *work) * is called (importer does this only when there's no * no consumer of locally exported FDs) */ - if (!sgt_info->importer_exported) { - dev_dbg(hyper_dmabuf_private.device, + if (exported->active == 0) { + dev_dbg(hy_drv_priv->dev, "claning up buffer {id:%d key:%d %d %d} completly\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + exported->hid.id, exported->hid.rng_key[0], + exported->hid.rng_key[1], exported->hid.rng_key[2]); + + hyper_dmabuf_cleanup_sgt_info(exported, false); + hyper_dmabuf_remove_exported(exported->hid); - hyper_dmabuf_cleanup_sgt_info(sgt_info, false); - hyper_dmabuf_remove_exported(sgt_info->hid); /* register hyper_dmabuf_id to the list for reuse */ - store_reusable_hid(sgt_info->hid); + store_reusable_hid(exported->hid); - if (sgt_info->sz_priv > 0 && !sgt_info->priv) - kfree(sgt_info->priv); + if (exported->sz_priv > 0 && !exported->priv) + kfree(exported->priv); - kfree(sgt_info); + kfree(exported); } } -/* Schedules unexport of dmabuf. +/* Schedule unexport of dmabuf. */ -static int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data) +int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data) { - struct ioctl_hyper_dmabuf_unexport *unexport_attr; - struct hyper_dmabuf_sgt_info *sgt_info; + struct ioctl_hyper_dmabuf_unexport *unexport_attr = + (struct ioctl_hyper_dmabuf_unexport *)data; + struct exported_sgt_info *exported; - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); - - if (!data) { - dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); - return -EINVAL; - } - - unexport_attr = (struct ioctl_hyper_dmabuf_unexport *)data; + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__); /* find dmabuf in export list */ - sgt_info = hyper_dmabuf_find_exported(unexport_attr->hid); + exported = hyper_dmabuf_find_exported(unexport_attr->hid); - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "scheduling unexport of buffer {id:%d key:%d %d %d}\n", unexport_attr->hid.id, unexport_attr->hid.rng_key[0], unexport_attr->hid.rng_key[1], unexport_attr->hid.rng_key[2]); /* failed to find corresponding entry in export list */ - if (sgt_info == NULL) { + if (exported == NULL) { unexport_attr->status = -ENOENT; return -ENOENT; } - if (sgt_info->unexport_scheduled) + if (exported->unexport_sched) return 0; - sgt_info->unexport_scheduled = 1; - INIT_DELAYED_WORK(&sgt_info->unexport_work, hyper_dmabuf_delayed_unexport); - schedule_delayed_work(&sgt_info->unexport_work, + exported->unexport_sched = true; + INIT_DELAYED_WORK(&exported->unexport, + hyper_dmabuf_delayed_unexport); + schedule_delayed_work(&exported->unexport, msecs_to_jiffies(unexport_attr->delay_ms)); - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__); return 0; } static int hyper_dmabuf_query_ioctl(struct file *filp, void *data) { - struct ioctl_hyper_dmabuf_query *query_attr; - struct hyper_dmabuf_sgt_info *sgt_info = NULL; - struct hyper_dmabuf_imported_sgt_info *imported_sgt_info = NULL; + struct ioctl_hyper_dmabuf_query *query_attr = + (struct ioctl_hyper_dmabuf_query *)data; + struct exported_sgt_info *exported = NULL; + struct imported_sgt_info *imported = NULL; int ret = 0; - if (!data) { - dev_err(hyper_dmabuf_private.device, "user data is NULL\n"); - return -EINVAL; - } - - query_attr = (struct ioctl_hyper_dmabuf_query *)data; - - if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hyper_dmabuf_private.domid) { + if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hy_drv_priv->domid) { /* query for exported dmabuf */ - sgt_info = hyper_dmabuf_find_exported(query_attr->hid); - if (sgt_info) { - ret = hyper_dmabuf_query_exported(sgt_info, + exported = hyper_dmabuf_find_exported(query_attr->hid); + if (exported) { + ret = hyper_dmabuf_query_exported(exported, query_attr->item, &query_attr->info); } else { - dev_err(hyper_dmabuf_private.device, - "DMA BUF {id:%d key:%d %d %d} can't be found in the export list\n", - query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1], - query_attr->hid.rng_key[2]); + dev_err(hy_drv_priv->dev, + "DMA BUF {id:%d key:%d %d %d} not in the export list\n", + query_attr->hid.id, query_attr->hid.rng_key[0], + query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]); return -ENOENT; } } else { /* query for imported dmabuf */ - imported_sgt_info = hyper_dmabuf_find_imported(query_attr->hid); - if (imported_sgt_info) { - ret = hyper_dmabuf_query_imported(imported_sgt_info, - query_attr->item, &query_attr->info); + imported = hyper_dmabuf_find_imported(query_attr->hid); + if (imported) { + ret = hyper_dmabuf_query_imported(imported, query_attr->item, + &query_attr->info); } else { - dev_err(hyper_dmabuf_private.device, - "DMA BUF {id:%d key:%d %d %d} can't be found in the imported list\n", - query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1], - query_attr->hid.rng_key[2]); + dev_err(hy_drv_priv->dev, + "DMA BUF {id:%d key:%d %d %d} not in the imported list\n", + query_attr->hid.id, query_attr->hid.rng_key[0], + query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]); return -ENOENT; } } @@ -698,28 +695,6 @@ static int hyper_dmabuf_query_ioctl(struct file *filp, void *data) return ret; } -void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info, - void *attr) -{ - struct ioctl_hyper_dmabuf_unexport unexport_attr; - struct file *filp = (struct file*) attr; - - if (!filp || !sgt_info) - return; - - if (sgt_info->filp == filp) { - dev_dbg(hyper_dmabuf_private.device, - "Executing emergency release of buffer {id:%d key:%d %d %d}\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], - sgt_info->hid.rng_key[1], sgt_info->hid.rng_key[2]); - - unexport_attr.hid = sgt_info->hid; - unexport_attr.delay_ms = 0; - - hyper_dmabuf_unexport_ioctl(filp, &unexport_attr); - } -} - const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = { HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_TX_CH_SETUP, hyper_dmabuf_tx_ch_setup_ioctl, 0), HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_RX_CH_SETUP, hyper_dmabuf_rx_ch_setup_ioctl, 0), @@ -739,7 +714,7 @@ long hyper_dmabuf_ioctl(struct file *filp, char *kdata; if (nr > ARRAY_SIZE(hyper_dmabuf_ioctls)) { - dev_err(hyper_dmabuf_private.device, "invalid ioctl\n"); + dev_err(hy_drv_priv->dev, "invalid ioctl\n"); return -EINVAL; } @@ -748,18 +723,18 @@ long hyper_dmabuf_ioctl(struct file *filp, func = ioctl->func; if (unlikely(!func)) { - dev_err(hyper_dmabuf_private.device, "no function\n"); + dev_err(hy_drv_priv->dev, "no function\n"); return -EINVAL; } kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL); if (!kdata) { - dev_err(hyper_dmabuf_private.device, "no memory\n"); + dev_err(hy_drv_priv->dev, "no memory\n"); return -ENOMEM; } if (copy_from_user(kdata, (void __user *)param, _IOC_SIZE(cmd)) != 0) { - dev_err(hyper_dmabuf_private.device, "failed to copy from user arguments\n"); + dev_err(hy_drv_priv->dev, "failed to copy from user arguments\n"); ret = -EFAULT; goto ioctl_error; } @@ -767,7 +742,7 @@ long hyper_dmabuf_ioctl(struct file *filp, ret = func(filp, kdata); if (copy_to_user((void __user *)param, kdata, _IOC_SIZE(cmd)) != 0) { - dev_err(hyper_dmabuf_private.device, "failed to copy to user arguments\n"); + dev_err(hy_drv_priv->dev, "failed to copy to user arguments\n"); ret = -EFAULT; goto ioctl_error; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h index ebfbb84..3e9470a 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h @@ -42,4 +42,6 @@ struct hyper_dmabuf_ioctl_desc { .name = #ioctl \ } +int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data); + #endif //__HYPER_DMABUF_IOCTL_H__ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c index eaef2c1..1b3745e 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c @@ -39,24 +39,22 @@ #include "hyper_dmabuf_id.h" #include "hyper_dmabuf_event.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - DECLARE_HASHTABLE(hyper_dmabuf_hash_imported, MAX_ENTRY_IMPORTED); DECLARE_HASHTABLE(hyper_dmabuf_hash_exported, MAX_ENTRY_EXPORTED); #ifdef CONFIG_HYPER_DMABUF_SYSFS static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attribute *attr, char *buf) { - struct hyper_dmabuf_info_entry_imported *info_entry; + struct list_entry_imported *info_entry; int bkt; ssize_t count = 0; size_t total = 0; hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node) { - hyper_dmabuf_id_t hid = info_entry->info->hid; - int nents = info_entry->info->nents; - bool valid = info_entry->info->valid; - int num_importers = info_entry->info->num_importers; + hyper_dmabuf_id_t hid = info_entry->imported->hid; + int nents = info_entry->imported->nents; + bool valid = info_entry->imported->valid; + int num_importers = info_entry->imported->importers; total += nents; count += scnprintf(buf + count, PAGE_SIZE - count, "hid:{id:%d keys:%d %d %d}, nents:%d, v:%c, numi:%d\n", @@ -71,16 +69,16 @@ static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attr static ssize_t hyper_dmabuf_exported_show(struct device *drv, struct device_attribute *attr, char *buf) { - struct hyper_dmabuf_info_entry_exported *info_entry; + struct list_entry_exported *info_entry; int bkt; ssize_t count = 0; size_t total = 0; hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) { - hyper_dmabuf_id_t hid = info_entry->info->hid; - int nents = info_entry->info->nents; - bool valid = info_entry->info->valid; - int importer_exported = info_entry->info->importer_exported; + hyper_dmabuf_id_t hid = info_entry->exported->hid; + int nents = info_entry->exported->nents; + bool valid = info_entry->exported->valid; + int importer_exported = info_entry->exported->active; total += nents; count += scnprintf(buf + count, PAGE_SIZE - count, "hid:{hid:%d keys:%d %d %d}, nents:%d, v:%c, ie:%d\n", @@ -135,57 +133,57 @@ int hyper_dmabuf_table_destroy() return 0; } -int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info) +int hyper_dmabuf_register_exported(struct exported_sgt_info *exported) { - struct hyper_dmabuf_info_entry_exported *info_entry; + struct list_entry_exported *info_entry; info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL); if (!info_entry) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } - info_entry->info = info; + info_entry->exported = exported; hash_add(hyper_dmabuf_hash_exported, &info_entry->node, - info_entry->info->hid.id); + info_entry->exported->hid.id); return 0; } -int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info) +int hyper_dmabuf_register_imported(struct imported_sgt_info* imported) { - struct hyper_dmabuf_info_entry_imported *info_entry; + struct list_entry_imported *info_entry; info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL); if (!info_entry) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } - info_entry->info = info; + info_entry->imported = imported; hash_add(hyper_dmabuf_hash_imported, &info_entry->node, - info_entry->info->hid.id); + info_entry->imported->hid.id); return 0; } -struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid) +struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid) { - struct hyper_dmabuf_info_entry_exported *info_entry; + struct list_entry_exported *info_entry; int bkt; hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) /* checking hid.id first */ - if(info_entry->info->hid.id == hid.id) { + if(info_entry->exported->hid.id == hid.id) { /* then key is compared */ - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) - return info_entry->info; + if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid)) + return info_entry->exported; /* if key is unmatched, given HID is invalid, so returning NULL */ else break; @@ -197,29 +195,29 @@ struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid) /* search for pre-exported sgt and return id of it if it exist */ hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid) { - struct hyper_dmabuf_info_entry_exported *info_entry; + struct list_entry_exported *info_entry; hyper_dmabuf_id_t hid = {-1, {0, 0, 0}}; int bkt; hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) - if(info_entry->info->dma_buf == dmabuf && - info_entry->info->hyper_dmabuf_rdomain == domid) - return info_entry->info->hid; + if(info_entry->exported->dma_buf == dmabuf && + info_entry->exported->rdomid == domid) + return info_entry->exported->hid; return hid; } -struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid) +struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid) { - struct hyper_dmabuf_info_entry_imported *info_entry; + struct list_entry_imported *info_entry; int bkt; hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node) /* checking hid.id first */ - if(info_entry->info->hid.id == hid.id) { + if(info_entry->imported->hid.id == hid.id) { /* then key is compared */ - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) - return info_entry->info; + if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid)) + return info_entry->imported; /* if key is unmatched, given HID is invalid, so returning NULL */ else { break; @@ -231,14 +229,14 @@ struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_i int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid) { - struct hyper_dmabuf_info_entry_exported *info_entry; + struct list_entry_exported *info_entry; int bkt; hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) /* checking hid.id first */ - if(info_entry->info->hid.id == hid.id) { + if(info_entry->exported->hid.id == hid.id) { /* then key is compared */ - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) { + if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid)) { hash_del(&info_entry->node); kfree(info_entry); return 0; @@ -252,14 +250,14 @@ int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid) int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid) { - struct hyper_dmabuf_info_entry_imported *info_entry; + struct list_entry_imported *info_entry; int bkt; hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node) /* checking hid.id first */ - if(info_entry->info->hid.id == hid.id) { + if(info_entry->imported->hid.id == hid.id) { /* then key is compared */ - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) { + if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid)) { hash_del(&info_entry->node); kfree(info_entry); return 0; @@ -272,15 +270,15 @@ int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid) } void hyper_dmabuf_foreach_exported( - void (*func)(struct hyper_dmabuf_sgt_info *, void *attr), + void (*func)(struct exported_sgt_info *, void *attr), void *attr) { - struct hyper_dmabuf_info_entry_exported *info_entry; + struct list_entry_exported *info_entry; struct hlist_node *tmp; int bkt; hash_for_each_safe(hyper_dmabuf_hash_exported, bkt, tmp, info_entry, node) { - func(info_entry->info, attr); + func(info_entry->exported, attr); } } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h index 8f64db8..d5c17ef 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h @@ -32,13 +32,13 @@ /* number of bits to be used for imported dmabufs hash table */ #define MAX_ENTRY_IMPORTED 7 -struct hyper_dmabuf_info_entry_exported { - struct hyper_dmabuf_sgt_info *info; +struct list_entry_exported { + struct exported_sgt_info *exported; struct hlist_node node; }; -struct hyper_dmabuf_info_entry_imported { - struct hyper_dmabuf_imported_sgt_info *info; +struct list_entry_imported { + struct imported_sgt_info *imported; struct hlist_node node; }; @@ -46,23 +46,23 @@ int hyper_dmabuf_table_init(void); int hyper_dmabuf_table_destroy(void); -int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info); +int hyper_dmabuf_register_exported(struct exported_sgt_info *info); /* search for pre-exported sgt and return id of it if it exist */ hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid); -int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info); +int hyper_dmabuf_register_imported(struct imported_sgt_info* info); -struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid); +struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid); -struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid); +struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid); int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid); int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid); void hyper_dmabuf_foreach_exported( - void (*func)(struct hyper_dmabuf_sgt_info *, void *attr), + void (*func)(struct exported_sgt_info *, void *attr), void *attr); int hyper_dmabuf_register_sysfs(struct device *dev); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c index ec37c3b..907f76e 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c @@ -31,7 +31,6 @@ #include #include #include -#include #include #include "hyper_dmabuf_msg.h" #include "hyper_dmabuf_drv.h" @@ -39,58 +38,56 @@ #include "hyper_dmabuf_event.h" #include "hyper_dmabuf_list.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - struct cmd_process { struct work_struct work; struct hyper_dmabuf_req *rq; int domid; }; -void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req, - enum hyper_dmabuf_command command, int *operands) +void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req, + enum hyper_dmabuf_command cmd, int *op) { int i; - req->status = HYPER_DMABUF_REQ_NOT_RESPONDED; - req->command = command; + req->stat = HYPER_DMABUF_REQ_NOT_RESPONDED; + req->cmd = cmd; - switch(command) { + switch(cmd) { /* as exporter, commands to importer */ case HYPER_DMABUF_EXPORT: /* exporting pages for dmabuf */ /* command : HYPER_DMABUF_EXPORT, - * operands0~3 : hyper_dmabuf_id - * operands4 : number of pages to be shared - * operands5 : offset of data in the first page - * operands6 : length of data in the last page - * operands7 : top-level reference number for shared pages - * operands8 : size of private data (from operands9) - * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info) + * op0~3 : hyper_dmabuf_id + * op4 : number of pages to be shared + * op5 : offset of data in the first page + * op6 : length of data in the last page + * op7 : top-level reference number for shared pages + * op8 : size of private data (from op9) + * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info) */ - memcpy(&req->operands[0], &operands[0], 9 * sizeof(int) + operands[8]); + memcpy(&req->op[0], &op[0], 9 * sizeof(int) + op[8]); break; case HYPER_DMABUF_NOTIFY_UNEXPORT: /* destroy sg_list for hyper_dmabuf_id on remote side */ /* command : DMABUF_DESTROY, - * operands0~3 : hyper_dmabuf_id_t hid + * op0~3 : hyper_dmabuf_id_t hid */ for (i=0; i < 4; i++) - req->operands[i] = operands[i]; + req->op[i] = op[i]; break; 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~3 : hyper_dmabuf_id + * op0~3 : hyper_dmabuf_id */ for (i=0; i < 4; i++) - req->operands[i] = operands[i]; + req->op[i] = op[i]; break; case HYPER_DMABUF_OPS_TO_REMOTE: @@ -103,11 +100,11 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req, /* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping * or unmapping for synchronization with original exporter (e.g. i915) */ /* command : DMABUF_OPS_TO_SOURCE. - * operands0~3 : hyper_dmabuf_id - * operands4 : map(=1)/unmap(=2)/attach(=3)/detach(=4) + * op0~3 : hyper_dmabuf_id + * op4 : map(=1)/unmap(=2)/attach(=3)/detach(=4) */ for (i = 0; i < 5; i++) - req->operands[i] = operands[i]; + req->op[i] = op[i]; break; default: @@ -116,9 +113,9 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req, } } -void cmd_process_work(struct work_struct *work) +static void cmd_process_work(struct work_struct *work) { - struct hyper_dmabuf_imported_sgt_info *imported_sgt_info; + struct imported_sgt_info *imported; struct cmd_process *proc = container_of(work, struct cmd_process, work); struct hyper_dmabuf_req *req; int domid; @@ -127,107 +124,107 @@ void cmd_process_work(struct work_struct *work) req = proc->rq; domid = proc->domid; - switch (req->command) { + switch (req->cmd) { case HYPER_DMABUF_EXPORT: /* exporting pages for dmabuf */ /* command : HYPER_DMABUF_EXPORT, - * operands0~3 : hyper_dmabuf_id - * operands4 : number of pages to be shared - * operands5 : offset of data in the first page - * operands6 : length of data in the last page - * operands7 : top-level reference number for shared pages - * operands8 : size of private data (from operands9) - * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info) + * op0~3 : hyper_dmabuf_id + * op4 : number of pages to be shared + * op5 : offset of data in the first page + * op6 : length of data in the last page + * op7 : top-level reference number for shared pages + * op8 : size of private data (from op9) + * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info) */ /* if nents == 0, it means it is a message only for priv synchronization * for existing imported_sgt_info so not creating a new one */ - if (req->operands[4] == 0) { - hyper_dmabuf_id_t exist = {req->operands[0], - {req->operands[1], req->operands[2], - req->operands[3]}}; + if (req->op[4] == 0) { + hyper_dmabuf_id_t exist = {req->op[0], + {req->op[1], req->op[2], + req->op[3]}}; - imported_sgt_info = hyper_dmabuf_find_imported(exist); + imported = hyper_dmabuf_find_imported(exist); - if (!imported_sgt_info) { - dev_err(hyper_dmabuf_private.device, + if (!imported) { + dev_err(hy_drv_priv->dev, "Can't find imported sgt_info from IMPORT_LIST\n"); break; } /* if size of new private data is different, * we reallocate it. */ - if (imported_sgt_info->sz_priv != req->operands[8]) { - kfree(imported_sgt_info->priv); - imported_sgt_info->sz_priv = req->operands[8]; - imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL); - if (!imported_sgt_info->priv) { - dev_err(hyper_dmabuf_private.device, + if (imported->sz_priv != req->op[8]) { + kfree(imported->priv); + imported->sz_priv = req->op[8]; + imported->priv = kcalloc(1, req->op[8], GFP_KERNEL); + if (!imported->priv) { + dev_err(hy_drv_priv->dev, "Fail to allocate priv\n"); /* set it invalid */ - imported_sgt_info->valid = 0; + imported->valid = 0; break; } } /* updating priv data */ - memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]); + memcpy(imported->priv, &req->op[9], req->op[8]); #ifdef CONFIG_HYPER_DMABUF_EVENT_GEN /* generating import event */ - hyper_dmabuf_import_event(imported_sgt_info->hid); + hyper_dmabuf_import_event(imported->hid); #endif break; } - imported_sgt_info = kcalloc(1, sizeof(*imported_sgt_info), GFP_KERNEL); + imported = kcalloc(1, sizeof(*imported), GFP_KERNEL); - if (!imported_sgt_info) { - dev_err(hyper_dmabuf_private.device, + if (!imported) { + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); break; } - imported_sgt_info->sz_priv = req->operands[8]; - imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL); + imported->sz_priv = req->op[8]; + imported->priv = kcalloc(1, req->op[8], GFP_KERNEL); - if (!imported_sgt_info->priv) { - dev_err(hyper_dmabuf_private.device, + if (!imported->priv) { + dev_err(hy_drv_priv->dev, "Fail to allocate priv\n"); - kfree(imported_sgt_info); + kfree(imported); break; } - imported_sgt_info->hid.id = req->operands[0]; + imported->hid.id = req->op[0]; for (i=0; i<3; i++) - imported_sgt_info->hid.rng_key[i] = req->operands[i+1]; + imported->hid.rng_key[i] = req->op[i+1]; - imported_sgt_info->nents = req->operands[4]; - imported_sgt_info->frst_ofst = req->operands[5]; - imported_sgt_info->last_len = req->operands[6]; - imported_sgt_info->ref_handle = req->operands[7]; + imported->nents = req->op[4]; + imported->frst_ofst = req->op[5]; + imported->last_len = req->op[6]; + imported->ref_handle = req->op[7]; - dev_dbg(hyper_dmabuf_private.device, "DMABUF was exported\n"); - dev_dbg(hyper_dmabuf_private.device, "\thid{id:%d key:%d %d %d}\n", - req->operands[0], req->operands[1], req->operands[2], - req->operands[3]); - dev_dbg(hyper_dmabuf_private.device, "\tnents %d\n", req->operands[4]); - dev_dbg(hyper_dmabuf_private.device, "\tfirst offset %d\n", req->operands[5]); - dev_dbg(hyper_dmabuf_private.device, "\tlast len %d\n", req->operands[6]); - dev_dbg(hyper_dmabuf_private.device, "\tgrefid %d\n", req->operands[7]); + dev_dbg(hy_drv_priv->dev, "DMABUF was exported\n"); + dev_dbg(hy_drv_priv->dev, "\thid{id:%d key:%d %d %d}\n", + req->op[0], req->op[1], req->op[2], + req->op[3]); + dev_dbg(hy_drv_priv->dev, "\tnents %d\n", req->op[4]); + dev_dbg(hy_drv_priv->dev, "\tfirst offset %d\n", req->op[5]); + dev_dbg(hy_drv_priv->dev, "\tlast len %d\n", req->op[6]); + dev_dbg(hy_drv_priv->dev, "\tgrefid %d\n", req->op[7]); - memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]); + memcpy(imported->priv, &req->op[9], req->op[8]); - imported_sgt_info->valid = 1; - hyper_dmabuf_register_imported(imported_sgt_info); + imported->valid = true; + hyper_dmabuf_register_imported(imported); #ifdef CONFIG_HYPER_DMABUF_EVENT_GEN /* generating import event */ - hyper_dmabuf_import_event(imported_sgt_info->hid); + hyper_dmabuf_import_event(imported->hid); #endif break; @@ -251,142 +248,142 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) { struct cmd_process *proc; struct hyper_dmabuf_req *temp_req; - struct hyper_dmabuf_imported_sgt_info *sgt_info; - struct hyper_dmabuf_sgt_info *exp_sgt_info; + struct imported_sgt_info *imported; + struct exported_sgt_info *exported; hyper_dmabuf_id_t hid; int ret; if (!req) { - dev_err(hyper_dmabuf_private.device, "request is NULL\n"); + dev_err(hy_drv_priv->dev, "request is NULL\n"); return -EINVAL; } - hid.id = req->operands[0]; - hid.rng_key[0] = req->operands[1]; - hid.rng_key[1] = req->operands[2]; - hid.rng_key[2] = req->operands[3]; + hid.id = req->op[0]; + hid.rng_key[0] = req->op[1]; + hid.rng_key[1] = req->op[2]; + hid.rng_key[2] = req->op[3]; - if ((req->command < HYPER_DMABUF_EXPORT) || - (req->command > HYPER_DMABUF_OPS_TO_SOURCE)) { - dev_err(hyper_dmabuf_private.device, "invalid command\n"); + if ((req->cmd < HYPER_DMABUF_EXPORT) || + (req->cmd > HYPER_DMABUF_OPS_TO_SOURCE)) { + dev_err(hy_drv_priv->dev, "invalid command\n"); return -EINVAL; } - req->status = HYPER_DMABUF_REQ_PROCESSED; + req->stat = HYPER_DMABUF_REQ_PROCESSED; /* HYPER_DMABUF_DESTROY requires immediate * follow up so can't be processed in workqueue */ - if (req->command == HYPER_DMABUF_NOTIFY_UNEXPORT) { + if (req->cmd == HYPER_DMABUF_NOTIFY_UNEXPORT) { /* destroy sg_list for hyper_dmabuf_id on remote side */ /* command : HYPER_DMABUF_NOTIFY_UNEXPORT, - * operands0~3 : hyper_dmabuf_id + * op0~3 : hyper_dmabuf_id */ - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "%s: processing HYPER_DMABUF_NOTIFY_UNEXPORT\n", __func__); - sgt_info = hyper_dmabuf_find_imported(hid); + imported = hyper_dmabuf_find_imported(hid); - if (sgt_info) { + if (imported) { /* if anything is still using dma_buf */ - if (sgt_info->num_importers) { + if (imported->importers) { /* * Buffer is still in use, just mark that it should * not be allowed to export its fd anymore. */ - sgt_info->valid = 0; + imported->valid = false; } else { /* No one is using buffer, remove it from imported list */ hyper_dmabuf_remove_imported(hid); - kfree(sgt_info); + kfree(imported); } } else { - req->status = HYPER_DMABUF_REQ_ERROR; + req->stat = HYPER_DMABUF_REQ_ERROR; } - return req->command; + return req->cmd; } /* dma buf remote synchronization */ - if (req->command == HYPER_DMABUF_OPS_TO_SOURCE) { + if (req->cmd == HYPER_DMABUF_OPS_TO_SOURCE) { /* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping * or unmapping for synchronization with original exporter (e.g. i915) */ /* command : DMABUF_OPS_TO_SOURCE. - * operands0~3 : hyper_dmabuf_id - * operands1 : enum hyper_dmabuf_ops {....} + * op0~3 : hyper_dmabuf_id + * op1 : enum hyper_dmabuf_ops {....} */ - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "%s: HYPER_DMABUF_OPS_TO_SOURCE\n", __func__); - ret = hyper_dmabuf_remote_sync(hid, req->operands[4]); + ret = hyper_dmabuf_remote_sync(hid, req->op[4]); if (ret) - req->status = HYPER_DMABUF_REQ_ERROR; + req->stat = HYPER_DMABUF_REQ_ERROR; else - req->status = HYPER_DMABUF_REQ_PROCESSED; + req->stat = HYPER_DMABUF_REQ_PROCESSED; - return req->command; + return req->cmd; } /* synchronous dma_buf_fd export */ - if (req->command == HYPER_DMABUF_EXPORT_FD) { + if (req->cmd == HYPER_DMABUF_EXPORT_FD) { /* find a corresponding SGT for the id */ - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "Processing HYPER_DMABUF_EXPORT_FD for buffer {id:%d key:%d %d %d}\n", hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]); - exp_sgt_info = hyper_dmabuf_find_exported(hid); + exported = hyper_dmabuf_find_exported(hid); - if (!exp_sgt_info) { - dev_err(hyper_dmabuf_private.device, + if (!exported) { + dev_err(hy_drv_priv->dev, "critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n", hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]); - req->status = HYPER_DMABUF_REQ_ERROR; - } else if (!exp_sgt_info->valid) { - dev_dbg(hyper_dmabuf_private.device, + req->stat = HYPER_DMABUF_REQ_ERROR; + } else if (!exported->valid) { + dev_dbg(hy_drv_priv->dev, "Buffer no longer valid - cannot export fd for buffer {id:%d key:%d %d %d}\n", hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]); - req->status = HYPER_DMABUF_REQ_ERROR; + req->stat = HYPER_DMABUF_REQ_ERROR; } else { - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "Buffer still valid - can export fd for buffer {id:%d key:%d %d %d}\n", hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]); - exp_sgt_info->importer_exported++; - req->status = HYPER_DMABUF_REQ_PROCESSED; + exported->active++; + req->stat = HYPER_DMABUF_REQ_PROCESSED; } - return req->command; + return req->cmd; } - if (req->command == HYPER_DMABUF_EXPORT_FD_FAILED) { - dev_dbg(hyper_dmabuf_private.device, + if (req->cmd == HYPER_DMABUF_EXPORT_FD_FAILED) { + dev_dbg(hy_drv_priv->dev, "Processing HYPER_DMABUF_EXPORT_FD_FAILED for buffer {id:%d key:%d %d %d}\n", hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]); - exp_sgt_info = hyper_dmabuf_find_exported(hid); + exported = hyper_dmabuf_find_exported(hid); - if (!exp_sgt_info) { - dev_err(hyper_dmabuf_private.device, + if (!exported) { + dev_err(hy_drv_priv->dev, "critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n", hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]); - req->status = HYPER_DMABUF_REQ_ERROR; + req->stat = HYPER_DMABUF_REQ_ERROR; } else { - exp_sgt_info->importer_exported--; - req->status = HYPER_DMABUF_REQ_PROCESSED; + exported->active--; + req->stat = HYPER_DMABUF_REQ_PROCESSED; } - return req->command; + return req->cmd; } - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "%s: putting request to workqueue\n", __func__); temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL); if (!temp_req) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } @@ -396,7 +393,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) proc = kcalloc(1, sizeof(struct cmd_process), GFP_KERNEL); if (!proc) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); kfree(temp_req); return -ENOMEM; @@ -407,7 +404,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req) INIT_WORK(&(proc->work), cmd_process_work); - queue_work(hyper_dmabuf_private.work_queue, &(proc->work)); + queue_work(hy_drv_priv->work_queue, &(proc->work)); - return req->command; + return req->cmd; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h index 0f6e795..7c694ec 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h @@ -28,17 +28,17 @@ #define MAX_NUMBER_OF_OPERANDS 64 struct hyper_dmabuf_req { - unsigned int request_id; - unsigned int status; - unsigned int command; - unsigned int operands[MAX_NUMBER_OF_OPERANDS]; + unsigned int req_id; + unsigned int stat; + unsigned int cmd; + unsigned int op[MAX_NUMBER_OF_OPERANDS]; }; struct hyper_dmabuf_resp { - unsigned int response_id; - unsigned int status; - unsigned int command; - unsigned int operands[MAX_NUMBER_OF_OPERANDS]; + unsigned int resp_id; + unsigned int stat; + unsigned int cmd; + unsigned int op[MAX_NUMBER_OF_OPERANDS]; }; enum hyper_dmabuf_command { @@ -75,7 +75,7 @@ enum hyper_dmabuf_req_feedback { }; /* create a request packet with given command and operands */ -void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req, +void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req, enum hyper_dmabuf_command command, int *operands); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c index 9313c42..7e73170 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c @@ -32,8 +32,6 @@ #include #include #include -#include -#include #include "hyper_dmabuf_drv.h" #include "hyper_dmabuf_struct.h" #include "hyper_dmabuf_ops.h" @@ -45,122 +43,111 @@ #define WAIT_AFTER_SYNC_REQ 0 #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t)) -extern struct hyper_dmabuf_private hyper_dmabuf_private; - -inline int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops) +static int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops) { struct hyper_dmabuf_req *req; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; - int operands[5]; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; + int op[5]; int i; int ret; - operands[0] = hid.id; + op[0] = hid.id; for (i=0; i<3; i++) - operands[i+1] = hid.rng_key[i]; + op[i+1] = hid.rng_key[i]; - operands[4] = dmabuf_ops; + op[4] = dmabuf_ops; req = kcalloc(1, sizeof(*req), GFP_KERNEL); if (!req) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } - hyper_dmabuf_create_request(req, HYPER_DMABUF_OPS_TO_SOURCE, &operands[0]); + hyper_dmabuf_create_req(req, HYPER_DMABUF_OPS_TO_SOURCE, &op[0]); /* send request and wait for a response */ ret = ops->send_req(HYPER_DMABUF_DOM_ID(hid), req, WAIT_AFTER_SYNC_REQ); + if (ret < 0) { + dev_dbg(hy_drv_priv->dev, + "dmabuf sync request failed:%d\n", req->op[4]); + } + kfree(req); return ret; } -static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf, struct device* dev, - struct dma_buf_attachment *attach) +static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf, + struct device* dev, + struct dma_buf_attachment *attach) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!attach->dmabuf->priv) return -EINVAL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv; + imported = (struct imported_sgt_info *)attach->dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_ATTACH); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - return ret; - } - - return 0; + return ret; } -static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf, struct dma_buf_attachment *attach) +static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf, + struct dma_buf_attachment *attach) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!attach->dmabuf->priv) return; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv; + imported = (struct imported_sgt_info *)attach->dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_DETACH); - - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } } static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachment, - enum dma_data_direction dir) + enum dma_data_direction dir) { struct sg_table *st; - struct hyper_dmabuf_imported_sgt_info *sgt_info; - struct hyper_dmabuf_pages_info *page_info; + struct imported_sgt_info *imported; + struct pages_info *pg_info; int ret; if (!attachment->dmabuf->priv) return NULL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv; + imported = (struct imported_sgt_info *)attachment->dmabuf->priv; /* extract pages from sgt */ - page_info = hyper_dmabuf_ext_pgs(sgt_info->sgt); + pg_info = hyper_dmabuf_ext_pgs(imported->sgt); - if (!page_info) { + if (!pg_info) { return NULL; } /* create a new sg_table with extracted pages */ - st = hyper_dmabuf_create_sgt(page_info->pages, page_info->frst_ofst, - page_info->last_len, page_info->nents); + st = hyper_dmabuf_create_sgt(pg_info->pgs, pg_info->frst_ofst, + pg_info->last_len, pg_info->nents); if (!st) goto err_free_sg; if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir)) goto err_free_sg; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_MAP); - kfree(page_info->pages); - kfree(page_info); - - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } + kfree(pg_info->pgs); + kfree(pg_info); return st; @@ -170,8 +157,8 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme kfree(st); } - kfree(page_info->pages); - kfree(page_info); + kfree(pg_info->pgs); + kfree(pg_info); return NULL; } @@ -180,294 +167,251 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment, struct sg_table *sg, enum dma_data_direction dir) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!attachment->dmabuf->priv) return; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv; + imported = (struct imported_sgt_info *)attachment->dmabuf->priv; dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir); sg_free_table(sg); kfree(sg); - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_UNMAP); - - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } } static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; + struct imported_sgt_info *imported; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; int ret; - int final_release; + int finish; if (!dma_buf->priv) return; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dma_buf->priv; + imported = (struct imported_sgt_info *)dma_buf->priv; - if (!dmabuf_refcount(sgt_info->dma_buf)) { - sgt_info->dma_buf = NULL; + if (!dmabuf_refcount(imported->dma_buf)) { + imported->dma_buf = NULL; } - sgt_info->num_importers--; + imported->importers--; - if (sgt_info->num_importers == 0) { - ops->unmap_shared_pages(&sgt_info->refs_info, sgt_info->nents); + if (imported->importers == 0) { + ops->unmap_shared_pages(&imported->refs_info, imported->nents); - if (sgt_info->sgt) { - sg_free_table(sgt_info->sgt); - kfree(sgt_info->sgt); - sgt_info->sgt = NULL; + if (imported->sgt) { + sg_free_table(imported->sgt); + kfree(imported->sgt); + imported->sgt = NULL; } } - final_release = sgt_info && !sgt_info->valid && - !sgt_info->num_importers; + finish = imported && !imported->valid && + !imported->importers; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_RELEASE); - if (ret < 0) { - dev_warn(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } /* * Check if buffer is still valid and if not remove it from imported list. * That has to be done after sending sync request */ - if (final_release) { - hyper_dmabuf_remove_imported(sgt_info->hid); - kfree(sgt_info); + if (finish) { + hyper_dmabuf_remove_imported(imported->hid); + kfree(imported); } } static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return -EINVAL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } return ret; } static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return -EINVAL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_END_CPU_ACCESS); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } return 0; } static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return NULL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_KMAP_ATOMIC); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } return NULL; /* for now NULL.. need to return the address of mapped region */ } static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_KUNMAP_ATOMIC); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } } static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return NULL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_KMAP); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } - return NULL; /* for now NULL.. need to return the address of mapped region */ + /* for now NULL.. need to return the address of mapped region */ + return NULL; } -static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr) +static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum, + void *vaddr) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_KUNMAP); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } } static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return -EINVAL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_MMAP); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } return ret; } static void *hyper_dmabuf_ops_vmap(struct dma_buf *dmabuf) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return NULL; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_VMAP); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } return NULL; } static void hyper_dmabuf_ops_vunmap(struct dma_buf *dmabuf, void *vaddr) { - struct hyper_dmabuf_imported_sgt_info *sgt_info; + struct imported_sgt_info *imported; int ret; if (!dmabuf->priv) return; - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv; + imported = (struct imported_sgt_info *)dmabuf->priv; - ret = hyper_dmabuf_sync_request(sgt_info->hid, + ret = hyper_dmabuf_sync_request(imported->hid, HYPER_DMABUF_OPS_VUNMAP); - if (ret < 0) { - dev_err(hyper_dmabuf_private.device, - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__); - } } static const struct dma_buf_ops hyper_dmabuf_ops = { - .attach = hyper_dmabuf_ops_attach, - .detach = hyper_dmabuf_ops_detach, - .map_dma_buf = hyper_dmabuf_ops_map, - .unmap_dma_buf = hyper_dmabuf_ops_unmap, - .release = hyper_dmabuf_ops_release, - .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access, - .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access, - .map_atomic = hyper_dmabuf_ops_kmap_atomic, - .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic, - .map = hyper_dmabuf_ops_kmap, - .unmap = hyper_dmabuf_ops_kunmap, - .mmap = hyper_dmabuf_ops_mmap, - .vmap = hyper_dmabuf_ops_vmap, - .vunmap = hyper_dmabuf_ops_vunmap, + .attach = hyper_dmabuf_ops_attach, + .detach = hyper_dmabuf_ops_detach, + .map_dma_buf = hyper_dmabuf_ops_map, + .unmap_dma_buf = hyper_dmabuf_ops_unmap, + .release = hyper_dmabuf_ops_release, + .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access, + .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access, + .map_atomic = hyper_dmabuf_ops_kmap_atomic, + .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic, + .map = hyper_dmabuf_ops_kmap, + .unmap = hyper_dmabuf_ops_kunmap, + .mmap = hyper_dmabuf_ops_mmap, + .vmap = hyper_dmabuf_ops_vmap, + .vunmap = hyper_dmabuf_ops_vunmap, }; /* exporting dmabuf as fd */ -int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags) +int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags) { int fd = -1; /* call hyper_dmabuf_export_dmabuf and create * and bind a handle for it then release */ - hyper_dmabuf_export_dma_buf(dinfo); + hyper_dmabuf_export_dma_buf(imported); - if (dinfo->dma_buf) { - fd = dma_buf_fd(dinfo->dma_buf, flags); + if (imported->dma_buf) { + fd = dma_buf_fd(imported->dma_buf, flags); } return fd; } -void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo) +void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported) { DEFINE_DMA_BUF_EXPORT_INFO(exp_info); exp_info.ops = &hyper_dmabuf_ops; /* multiple of PAGE_SIZE, not considering offset */ - exp_info.size = dinfo->sgt->nents * PAGE_SIZE; - exp_info.flags = /* not sure about flag */0; - exp_info.priv = dinfo; + exp_info.size = imported->sgt->nents * PAGE_SIZE; + exp_info.flags = /* not sure about flag */ 0; + exp_info.priv = imported; - dinfo->dma_buf = dma_buf_export(&exp_info); + imported->dma_buf = dma_buf_export(&exp_info); } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h index 8c06fc6..c5505a4 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h @@ -25,8 +25,8 @@ #ifndef __HYPER_DMABUF_OPS_H__ #define __HYPER_DMABUF_OPS_H__ -int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags); +int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags); -void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo); +void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported); #endif /* __HYPER_DMABUF_IMP_H__ */ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c index 39c9dee..36e888c 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c @@ -32,16 +32,12 @@ #include "hyper_dmabuf_struct.h" #include "hyper_dmabuf_id.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - #define HYPER_DMABUF_SIZE(nents, first_offset, last_len) \ ((nents)*PAGE_SIZE - (first_offset) - PAGE_SIZE + (last_len)) -int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info, +int hyper_dmabuf_query_exported(struct exported_sgt_info *exported, int query, unsigned long* info) { - int n; - switch (query) { case HYPER_DMABUF_QUERY_TYPE: @@ -50,45 +46,46 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info, /* exporting domain of this specific dmabuf*/ case HYPER_DMABUF_QUERY_EXPORTER: - *info = HYPER_DMABUF_DOM_ID(sgt_info->hid); + *info = HYPER_DMABUF_DOM_ID(exported->hid); break; /* importing domain of this specific dmabuf */ case HYPER_DMABUF_QUERY_IMPORTER: - *info = sgt_info->hyper_dmabuf_rdomain; + *info = exported->rdomid; break; /* size of dmabuf in byte */ case HYPER_DMABUF_QUERY_SIZE: - *info = sgt_info->dma_buf->size; + *info = exported->dma_buf->size; break; /* whether the buffer is used by importer */ case HYPER_DMABUF_QUERY_BUSY: - *info = (sgt_info->importer_exported == 0) ? false : true; + *info = (exported->active > 0); break; /* whether the buffer is unexported */ case HYPER_DMABUF_QUERY_UNEXPORTED: - *info = !sgt_info->valid; + *info = !exported->valid; break; /* whether the buffer is scheduled to be unexported */ case HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED: - *info = !sgt_info->unexport_scheduled; + *info = !exported->unexport_sched; break; /* size of private info attached to buffer */ case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE: - *info = sgt_info->sz_priv; + *info = exported->sz_priv; break; /* copy private info attached to buffer */ case HYPER_DMABUF_QUERY_PRIV_INFO: - if (sgt_info->sz_priv > 0) { + if (exported->sz_priv > 0) { + int n; n = copy_to_user((void __user*) *info, - sgt_info->priv, - sgt_info->sz_priv); + exported->priv, + exported->sz_priv); if (n != 0) return -EINVAL; } @@ -102,11 +99,9 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info, } -int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info, +int hyper_dmabuf_query_imported(struct imported_sgt_info *imported, int query, unsigned long *info) { - int n; - switch (query) { case HYPER_DMABUF_QUERY_TYPE: @@ -115,50 +110,51 @@ int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_ /* exporting domain of this specific dmabuf*/ case HYPER_DMABUF_QUERY_EXPORTER: - *info = HYPER_DMABUF_DOM_ID(imported_sgt_info->hid); + *info = HYPER_DMABUF_DOM_ID(imported->hid); break; /* importing domain of this specific dmabuf */ case HYPER_DMABUF_QUERY_IMPORTER: - *info = hyper_dmabuf_private.domid; + *info = hy_drv_priv->domid; break; /* size of dmabuf in byte */ case HYPER_DMABUF_QUERY_SIZE: - if (imported_sgt_info->dma_buf) { + if (imported->dma_buf) { /* if local dma_buf is created (if it's ever mapped), * retrieve it directly from struct dma_buf * */ - *info = imported_sgt_info->dma_buf->size; + *info = imported->dma_buf->size; } else { /* calcuate it from given nents, frst_ofst and last_len */ - *info = HYPER_DMABUF_SIZE(imported_sgt_info->nents, - imported_sgt_info->frst_ofst, - imported_sgt_info->last_len); + *info = HYPER_DMABUF_SIZE(imported->nents, + imported->frst_ofst, + imported->last_len); } break; /* whether the buffer is used or not */ case HYPER_DMABUF_QUERY_BUSY: /* checks if it's used by importer */ - *info = (imported_sgt_info->num_importers > 0) ? true : false; + *info = (imported->importers > 0); break; /* whether the buffer is unexported */ case HYPER_DMABUF_QUERY_UNEXPORTED: - *info = !imported_sgt_info->valid; + *info = !imported->valid; break; /* size of private info attached to buffer */ case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE: - *info = imported_sgt_info->sz_priv; + *info = imported->sz_priv; break; /* copy private info attached to buffer */ case HYPER_DMABUF_QUERY_PRIV_INFO: - if (imported_sgt_info->sz_priv > 0) { + if (imported->sz_priv > 0) { + int n; n = copy_to_user((void __user*) *info, - imported_sgt_info->priv, - imported_sgt_info->sz_priv); + imported->priv, + imported->sz_priv); if (n != 0) return -EINVAL; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h index 7bbb322..65ae738 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h @@ -1,10 +1,10 @@ #ifndef __HYPER_DMABUF_QUERY_H__ #define __HYPER_DMABUF_QUERY_H__ -int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info, +int hyper_dmabuf_query_imported(struct imported_sgt_info *imported, int query, unsigned long *info); -int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info, +int hyper_dmabuf_query_exported(struct exported_sgt_info *exported, int query, unsigned long *info); #endif // __HYPER_DMABUF_QUERY_H__ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c index 9004406..01ec98c 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c @@ -39,8 +39,6 @@ #include "hyper_dmabuf_msg.h" #include "hyper_dmabuf_sgl_proc.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - /* Whenever importer does dma operations from remote domain, * a notification is sent to the exporter so that exporter * issues equivalent dma operation on the original dma buf @@ -58,7 +56,7 @@ extern struct hyper_dmabuf_private hyper_dmabuf_private; */ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops) { - struct hyper_dmabuf_sgt_info *sgt_info; + struct exported_sgt_info *exported; struct sgt_list *sgtl; struct attachment_list *attachl; struct kmap_vaddr_list *va_kmapl; @@ -66,10 +64,10 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops) int ret; /* find a coresponding SGT for the id */ - sgt_info = hyper_dmabuf_find_exported(hid); + exported = hyper_dmabuf_find_exported(hid); - if (!sgt_info) { - dev_err(hyper_dmabuf_private.device, + if (!exported) { + dev_err(hy_drv_priv->dev, "dmabuf remote sync::can't find exported list\n"); return -ENOENT; } @@ -79,84 +77,84 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops) attachl = kcalloc(1, sizeof(*attachl), GFP_KERNEL); if (!attachl) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_ATTACH\n"); return -ENOMEM; } - attachl->attach = dma_buf_attach(sgt_info->dma_buf, - hyper_dmabuf_private.device); + attachl->attach = dma_buf_attach(exported->dma_buf, + hy_drv_priv->dev); if (!attachl->attach) { kfree(attachl); - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_ATTACH\n"); return -ENOMEM; } - list_add(&attachl->list, &sgt_info->active_attached->list); + list_add(&attachl->list, &exported->active_attached->list); break; case HYPER_DMABUF_OPS_DETACH: - if (list_empty(&sgt_info->active_attached->list)) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_DETACH\n"); - dev_err(hyper_dmabuf_private.device, + if (list_empty(&exported->active_attached->list)) { + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_DETACH\n"); + dev_err(hy_drv_priv->dev, "no more dmabuf attachment left to be detached\n"); return -EFAULT; } - attachl = list_first_entry(&sgt_info->active_attached->list, + attachl = list_first_entry(&exported->active_attached->list, struct attachment_list, list); - dma_buf_detach(sgt_info->dma_buf, attachl->attach); + dma_buf_detach(exported->dma_buf, attachl->attach); list_del(&attachl->list); kfree(attachl); break; case HYPER_DMABUF_OPS_MAP: - if (list_empty(&sgt_info->active_attached->list)) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n"); - dev_err(hyper_dmabuf_private.device, + if (list_empty(&exported->active_attached->list)) { + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_MAP\n"); + dev_err(hy_drv_priv->dev, "no more dmabuf attachment left to be mapped\n"); return -EFAULT; } - attachl = list_first_entry(&sgt_info->active_attached->list, + attachl = list_first_entry(&exported->active_attached->list, struct attachment_list, list); sgtl = kcalloc(1, sizeof(*sgtl), GFP_KERNEL); if (!sgtl) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_MAP\n"); return -ENOMEM; } sgtl->sgt = dma_buf_map_attachment(attachl->attach, DMA_BIDIRECTIONAL); if (!sgtl->sgt) { kfree(sgtl); - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_MAP\n"); return -ENOMEM; } - list_add(&sgtl->list, &sgt_info->active_sgts->list); + list_add(&sgtl->list, &exported->active_sgts->list); break; case HYPER_DMABUF_OPS_UNMAP: - if (list_empty(&sgt_info->active_sgts->list) || - list_empty(&sgt_info->active_attached->list)) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_UNMAP\n"); - dev_err(hyper_dmabuf_private.device, + if (list_empty(&exported->active_sgts->list) || + list_empty(&exported->active_attached->list)) { + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_UNMAP\n"); + dev_err(hy_drv_priv->dev, "no more SGT or attachment left to be unmapped\n"); return -EFAULT; } - attachl = list_first_entry(&sgt_info->active_attached->list, + attachl = list_first_entry(&exported->active_attached->list, struct attachment_list, list); - sgtl = list_first_entry(&sgt_info->active_sgts->list, + sgtl = list_first_entry(&exported->active_sgts->list, struct sgt_list, list); dma_buf_unmap_attachment(attachl->attach, sgtl->sgt, @@ -166,30 +164,30 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops) break; case HYPER_DMABUF_OPS_RELEASE: - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "Buffer {id:%d key:%d %d %d} released, references left: %d\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2], sgt_info->importer_exported -1); + exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1], + exported->hid.rng_key[2], exported->active - 1); - sgt_info->importer_exported--; + exported->active--; /* If there are still importers just break, if no then continue with final cleanup */ - if (sgt_info->importer_exported) + if (exported->active) 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. */ - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "Buffer {id:%d key:%d %d %d} final released\n", - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1], - sgt_info->hid.rng_key[2]); + exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1], + exported->hid.rng_key[2]); - if (!sgt_info->valid && !sgt_info->importer_exported && - !sgt_info->unexport_scheduled) { - hyper_dmabuf_cleanup_sgt_info(sgt_info, false); + if (!exported->valid && !exported->active && + !exported->unexport_sched) { + hyper_dmabuf_cleanup_sgt_info(exported, false); hyper_dmabuf_remove_exported(hid); - kfree(sgt_info); + kfree(exported); /* store hyper_dmabuf_id in the list for reuse */ store_reusable_hid(hid); } @@ -197,19 +195,19 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops) break; case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS: - ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL); + ret = dma_buf_begin_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL); if (ret) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n"); return ret; } break; case HYPER_DMABUF_OPS_END_CPU_ACCESS: - ret = dma_buf_end_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL); + ret = dma_buf_end_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL); if (ret) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_END_CPU_ACCESS\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_END_CPU_ACCESS\n"); return ret; } break; @@ -218,49 +216,49 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops) case HYPER_DMABUF_OPS_KMAP: va_kmapl = kcalloc(1, sizeof(*va_kmapl), GFP_KERNEL); if (!va_kmapl) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n"); return -ENOMEM; } /* dummy kmapping of 1 page */ if (ops == HYPER_DMABUF_OPS_KMAP_ATOMIC) - va_kmapl->vaddr = dma_buf_kmap_atomic(sgt_info->dma_buf, 1); + va_kmapl->vaddr = dma_buf_kmap_atomic(exported->dma_buf, 1); else - va_kmapl->vaddr = dma_buf_kmap(sgt_info->dma_buf, 1); + va_kmapl->vaddr = dma_buf_kmap(exported->dma_buf, 1); if (!va_kmapl->vaddr) { kfree(va_kmapl); - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n"); return -ENOMEM; } - list_add(&va_kmapl->list, &sgt_info->va_kmapped->list); + list_add(&va_kmapl->list, &exported->va_kmapped->list); break; case HYPER_DMABUF_OPS_KUNMAP_ATOMIC: case HYPER_DMABUF_OPS_KUNMAP: - if (list_empty(&sgt_info->va_kmapped->list)) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n"); - dev_err(hyper_dmabuf_private.device, + if (list_empty(&exported->va_kmapped->list)) { + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n"); + dev_err(hy_drv_priv->dev, "no more dmabuf VA to be freed\n"); return -EFAULT; } - va_kmapl = list_first_entry(&sgt_info->va_kmapped->list, + va_kmapl = list_first_entry(&exported->va_kmapped->list, struct kmap_vaddr_list, list); if (!va_kmapl->vaddr) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n"); return PTR_ERR(va_kmapl->vaddr); } /* unmapping 1 page */ if (ops == HYPER_DMABUF_OPS_KUNMAP_ATOMIC) - dma_buf_kunmap_atomic(sgt_info->dma_buf, 1, va_kmapl->vaddr); + dma_buf_kunmap_atomic(exported->dma_buf, 1, va_kmapl->vaddr); else - dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr); + dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr); list_del(&va_kmapl->list); kfree(va_kmapl); @@ -269,48 +267,48 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops) case HYPER_DMABUF_OPS_MMAP: /* currently not supported: looking for a way to create * a dummy vma */ - dev_warn(hyper_dmabuf_private.device, - "dmabuf remote sync::sychronized mmap is not supported\n"); + dev_warn(hy_drv_priv->dev, + "remote sync::sychronized mmap is not supported\n"); break; case HYPER_DMABUF_OPS_VMAP: va_vmapl = kcalloc(1, sizeof(*va_vmapl), GFP_KERNEL); if (!va_vmapl) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_VMAP\n"); return -ENOMEM; } /* dummy vmapping */ - va_vmapl->vaddr = dma_buf_vmap(sgt_info->dma_buf); + va_vmapl->vaddr = dma_buf_vmap(exported->dma_buf); if (!va_vmapl->vaddr) { kfree(va_vmapl); - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_VMAP\n"); return -ENOMEM; } - list_add(&va_vmapl->list, &sgt_info->va_vmapped->list); + list_add(&va_vmapl->list, &exported->va_vmapped->list); break; case HYPER_DMABUF_OPS_VUNMAP: - if (list_empty(&sgt_info->va_vmapped->list)) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n"); - dev_err(hyper_dmabuf_private.device, + if (list_empty(&exported->va_vmapped->list)) { + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_VUNMAP\n"); + dev_err(hy_drv_priv->dev, "no more dmabuf VA to be freed\n"); return -EFAULT; } - va_vmapl = list_first_entry(&sgt_info->va_vmapped->list, + va_vmapl = list_first_entry(&exported->va_vmapped->list, struct vmap_vaddr_list, list); if (!va_vmapl || va_vmapl->vaddr == NULL) { - dev_err(hyper_dmabuf_private.device, - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n"); + dev_err(hy_drv_priv->dev, + "remote sync::HYPER_DMABUF_OPS_VUNMAP\n"); return -EFAULT; } - dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr); + dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr); list_del(&va_vmapl->list); kfree(va_vmapl); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c index 691a714..315c354 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c @@ -32,8 +32,6 @@ #include #include #include -#include -#include #include "hyper_dmabuf_drv.h" #include "hyper_dmabuf_struct.h" #include "hyper_dmabuf_sgl_proc.h" @@ -41,8 +39,6 @@ #include "hyper_dmabuf_msg.h" #include "hyper_dmabuf_list.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t)) int dmabuf_refcount(struct dma_buf *dma_buf) @@ -66,60 +62,68 @@ static int hyper_dmabuf_get_num_pgs(struct sg_table *sgt) sgl = sgt->sgl; length = sgl->length - PAGE_SIZE + sgl->offset; - num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE); /* round-up */ + + /* round-up */ + num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE); for (i = 1; i < sgt->nents; i++) { sgl = sg_next(sgl); - num_pages += ((sgl->length + PAGE_SIZE - 1) / PAGE_SIZE); /* round-up */ + + /* round-up */ + num_pages += ((sgl->length + PAGE_SIZE - 1) / + PAGE_SIZE); /* round-up */ } return num_pages; } /* extract pages directly from struct sg_table */ -struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt) +struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt) { - struct hyper_dmabuf_pages_info *pinfo; + struct pages_info *pg_info; int i, j, k; int length; struct scatterlist *sgl; - pinfo = kmalloc(sizeof(*pinfo), GFP_KERNEL); - if (!pinfo) + pg_info = kmalloc(sizeof(*pg_info), GFP_KERNEL); + if (!pg_info) return NULL; - pinfo->pages = kmalloc(sizeof(struct page *)*hyper_dmabuf_get_num_pgs(sgt), GFP_KERNEL); - if (!pinfo->pages) { - kfree(pinfo); + pg_info->pgs = kmalloc(sizeof(struct page *) * + hyper_dmabuf_get_num_pgs(sgt), + GFP_KERNEL); + + if (!pg_info->pgs) { + kfree(pg_info); return NULL; } sgl = sgt->sgl; - pinfo->nents = 1; - pinfo->frst_ofst = sgl->offset; - pinfo->pages[0] = sg_page(sgl); + pg_info->nents = 1; + pg_info->frst_ofst = sgl->offset; + pg_info->pgs[0] = sg_page(sgl); length = sgl->length - PAGE_SIZE + sgl->offset; i = 1; while (length > 0) { - pinfo->pages[i] = nth_page(sg_page(sgl), i); + pg_info->pgs[i] = nth_page(sg_page(sgl), i); length -= PAGE_SIZE; - pinfo->nents++; + pg_info->nents++; i++; } for (j = 1; j < sgt->nents; j++) { sgl = sg_next(sgl); - pinfo->pages[i++] = sg_page(sgl); + pg_info->pgs[i++] = sg_page(sgl); length = sgl->length - PAGE_SIZE; - pinfo->nents++; + pg_info->nents++; k = 1; while (length > 0) { - pinfo->pages[i++] = nth_page(sg_page(sgl), k++); + pg_info->pgs[i++] = nth_page(sg_page(sgl), k++); length -= PAGE_SIZE; - pinfo->nents++; + pg_info->nents++; } } @@ -127,13 +131,13 @@ struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt) * lenght at that point will be 0 or negative, * so to calculate last page size just add it to PAGE_SIZE */ - pinfo->last_len = PAGE_SIZE + length; + pg_info->last_len = PAGE_SIZE + length; - return pinfo; + return pg_info; } /* create sg_table with given pages and other parameters */ -struct sg_table* hyper_dmabuf_create_sgt(struct page **pages, +struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs, int frst_ofst, int last_len, int nents) { struct sg_table *sgt; @@ -157,31 +161,32 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pages, sgl = sgt->sgl; - sg_set_page(sgl, pages[0], PAGE_SIZE-frst_ofst, frst_ofst); + sg_set_page(sgl, pgs[0], PAGE_SIZE-frst_ofst, frst_ofst); for (i=1; i 1) /* more than one page */ { sgl = sg_next(sgl); - sg_set_page(sgl, pages[i], last_len, 0); + sg_set_page(sgl, pgs[i], last_len, 0); } return sgt; } -int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force) +int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported, + int force) { struct sgt_list *sgtl; struct attachment_list *attachl; struct kmap_vaddr_list *va_kmapl; struct vmap_vaddr_list *va_vmapl; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops; - if (!sgt_info) { - dev_err(hyper_dmabuf_private.device, "invalid hyper_dmabuf_id\n"); + if (!exported) { + dev_err(hy_drv_priv->dev, "invalid hyper_dmabuf_id\n"); return -EINVAL; } @@ -190,35 +195,37 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo * side. */ if (!force && - sgt_info->importer_exported) { - dev_warn(hyper_dmabuf_private.device, "dma-buf is used by importer\n"); + exported->active) { + dev_warn(hy_drv_priv->dev, + "dma-buf is used by importer\n"); + return -EPERM; } /* force == 1 is not recommended */ - while (!list_empty(&sgt_info->va_kmapped->list)) { - va_kmapl = list_first_entry(&sgt_info->va_kmapped->list, + while (!list_empty(&exported->va_kmapped->list)) { + va_kmapl = list_first_entry(&exported->va_kmapped->list, struct kmap_vaddr_list, list); - dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr); + dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr); list_del(&va_kmapl->list); kfree(va_kmapl); } - while (!list_empty(&sgt_info->va_vmapped->list)) { - va_vmapl = list_first_entry(&sgt_info->va_vmapped->list, + while (!list_empty(&exported->va_vmapped->list)) { + va_vmapl = list_first_entry(&exported->va_vmapped->list, struct vmap_vaddr_list, list); - dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr); + dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr); list_del(&va_vmapl->list); kfree(va_vmapl); } - while (!list_empty(&sgt_info->active_sgts->list)) { - attachl = list_first_entry(&sgt_info->active_attached->list, + while (!list_empty(&exported->active_sgts->list)) { + attachl = list_first_entry(&exported->active_attached->list, struct attachment_list, list); - sgtl = list_first_entry(&sgt_info->active_sgts->list, + sgtl = list_first_entry(&exported->active_sgts->list, struct sgt_list, list); dma_buf_unmap_attachment(attachl->attach, sgtl->sgt, @@ -227,35 +234,35 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo kfree(sgtl); } - while (!list_empty(&sgt_info->active_sgts->list)) { - attachl = list_first_entry(&sgt_info->active_attached->list, + while (!list_empty(&exported->active_sgts->list)) { + attachl = list_first_entry(&exported->active_attached->list, struct attachment_list, list); - dma_buf_detach(sgt_info->dma_buf, attachl->attach); + dma_buf_detach(exported->dma_buf, attachl->attach); list_del(&attachl->list); kfree(attachl); } /* Start cleanup of buffer in reverse order to exporting */ - ops->unshare_pages(&sgt_info->refs_info, sgt_info->nents); + ops->unshare_pages(&exported->refs_info, exported->nents); /* unmap dma-buf */ - dma_buf_unmap_attachment(sgt_info->active_attached->attach, - sgt_info->active_sgts->sgt, + dma_buf_unmap_attachment(exported->active_attached->attach, + exported->active_sgts->sgt, DMA_BIDIRECTIONAL); /* detatch dma-buf */ - dma_buf_detach(sgt_info->dma_buf, sgt_info->active_attached->attach); + dma_buf_detach(exported->dma_buf, exported->active_attached->attach); /* close connection to dma-buf completely */ - dma_buf_put(sgt_info->dma_buf); - sgt_info->dma_buf = NULL; - - kfree(sgt_info->active_sgts); - kfree(sgt_info->active_attached); - kfree(sgt_info->va_kmapped); - kfree(sgt_info->va_vmapped); - kfree(sgt_info->priv); + dma_buf_put(exported->dma_buf); + exported->dma_buf = NULL; + + kfree(exported->active_sgts); + kfree(exported->active_attached); + kfree(exported->va_kmapped); + kfree(exported->va_vmapped); + kfree(exported->priv); return 0; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h index 237ccf5..930bade 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h @@ -28,13 +28,15 @@ int dmabuf_refcount(struct dma_buf *dma_buf); /* extract pages directly from struct sg_table */ -struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt); +struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt); /* create sg_table with given pages and other parameters */ -struct sg_table* hyper_dmabuf_create_sgt(struct page **pages, - int frst_ofst, int last_len, int nents); +struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs, + int frst_ofst, int last_len, + int nents); -int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force); +int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported, + int force); void hyper_dmabuf_free_sgt(struct sg_table *sgt); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h index 6f929f2..8a612d1 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h @@ -50,24 +50,20 @@ struct vmap_vaddr_list { }; /* Exporter builds pages_info before sharing pages */ -struct hyper_dmabuf_pages_info { +struct pages_info { int frst_ofst; /* offset of data in the first page */ int last_len; /* length of data in the last page */ int nents; /* # of pages */ - struct page **pages; /* pages that contains reference numbers of shared pages*/ + struct page **pgs; /* pages that contains reference numbers of shared pages*/ }; -/* Both importer and exporter use this structure to point to sg lists - * - * Exporter stores references to sgt in a hash table +/* Exporter stores references to sgt in a hash table * Exporter keeps these references for synchronization and tracking purposes - * - * Importer use this structure exporting to other drivers in the same domain */ -struct hyper_dmabuf_sgt_info { +struct exported_sgt_info { hyper_dmabuf_id_t hid; /* unique id to reference dmabuf in remote domain */ - int hyper_dmabuf_rdomain; /* domain importing this sgt */ + int rdomid; /* domain importing this sgt */ struct dma_buf *dma_buf; /* needed to store this for freeing it later */ int nents; @@ -79,10 +75,10 @@ struct hyper_dmabuf_sgt_info { struct vmap_vaddr_list *va_vmapped; bool valid; /* set to 0 once unexported. Needed to prevent further mapping by importer */ - int importer_exported; /* exported locally on importer's side */ + int active; /* locally shared on importer's side */ void *refs_info; /* hypervisor-specific info for the references */ - struct delayed_work unexport_work; - bool unexport_scheduled; + struct delayed_work unexport; + bool unexport_sched; /* owner of buffer * TODO: that is naiive as buffer may be reused by @@ -99,7 +95,7 @@ struct hyper_dmabuf_sgt_info { /* Importer store references (before mapping) on shared pages * Importer store these references in the table and map it in * its own memory map once userspace asks for reference for the buffer */ -struct hyper_dmabuf_imported_sgt_info { +struct imported_sgt_info { hyper_dmabuf_id_t hid; /* unique id for shared dmabuf imported */ int ref_handle; /* reference number of top level addressing page of shared pages */ @@ -112,7 +108,7 @@ struct hyper_dmabuf_imported_sgt_info { void *refs_info; bool valid; - int num_importers; + int importers; size_t sz_priv; char *priv; /* device specific info (e.g. image's meta info?) */ diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c index 920ecf4..f70b4ea 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c @@ -45,8 +45,6 @@ static int export_req_id = 0; struct hyper_dmabuf_req req_pending = {0}; -extern struct hyper_dmabuf_private hyper_dmabuf_private; - extern int xenstored_ready; static void xen_get_domid_delayed(struct work_struct *unused); @@ -62,7 +60,9 @@ static int xen_comm_setup_data_dir(void) { char buf[255]; - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid); + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", + hy_drv_priv->domid); + return xenbus_mkdir(XBT_NIL, buf, ""); } @@ -76,7 +76,9 @@ static int xen_comm_destroy_data_dir(void) { char buf[255]; - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid); + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", + hy_drv_priv->domid); + return xenbus_rm(XBT_NIL, buf, ""); } @@ -91,20 +93,26 @@ static int xen_comm_expose_ring_details(int domid, int rdomid, char buf[255]; int ret; - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", domid, rdomid); + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", + domid, rdomid); + ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", gref); if (ret) { - dev_err(hyper_dmabuf_private.device, - "Failed to write xenbus entry %s: %d\n", buf, ret); + dev_err(hy_drv_priv->dev, + "Failed to write xenbus entry %s: %d\n", + buf, ret); + return ret; } ret = xenbus_printf(XBT_NIL, buf, "port", "%d", port); if (ret) { - dev_err(hyper_dmabuf_private.device, - "Failed to write xenbus entry %s: %d\n", buf, ret); + dev_err(hy_drv_priv->dev, + "Failed to write xenbus entry %s: %d\n", + buf, ret); + return ret; } @@ -114,25 +122,32 @@ static int xen_comm_expose_ring_details(int domid, int rdomid, /* * Queries details of ring exposed by remote domain. */ -static int xen_comm_get_ring_details(int domid, int rdomid, int *grefid, int *port) +static int xen_comm_get_ring_details(int domid, int rdomid, + int *grefid, int *port) { char buf[255]; int ret; - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", rdomid, domid); + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", + rdomid, domid); + ret = xenbus_scanf(XBT_NIL, buf, "grefid", "%d", grefid); if (ret <= 0) { - dev_err(hyper_dmabuf_private.device, - "Failed to read xenbus entry %s: %d\n", buf, ret); + dev_err(hy_drv_priv->dev, + "Failed to read xenbus entry %s: %d\n", + buf, ret); + return ret; } ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", port); if (ret <= 0) { - dev_err(hyper_dmabuf_private.device, - "Failed to read xenbus entry %s: %d\n", buf, ret); + dev_err(hy_drv_priv->dev, + "Failed to read xenbus entry %s: %d\n", + buf, ret); + return ret; } @@ -146,9 +161,8 @@ void xen_get_domid_delayed(struct work_struct *unused) /* scheduling another if driver is still running * and xenstore has not been initialized */ - if (hyper_dmabuf_private.exited == false && - likely(xenstored_ready == 0)) { - dev_dbg(hyper_dmabuf_private.device, + if (likely(xenstored_ready == 0)) { + dev_dbg(hy_drv_priv->dev, "Xenstore is not quite ready yet. Will retry it in 500ms\n"); schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500)); } else { @@ -163,14 +177,14 @@ void xen_get_domid_delayed(struct work_struct *unused) /* try again since -1 is an invalid id for domain * (but only if driver is still running) */ - if (hyper_dmabuf_private.exited == false && unlikely(domid == -1)) { - dev_dbg(hyper_dmabuf_private.device, + if (unlikely(domid == -1)) { + dev_dbg(hy_drv_priv->dev, "domid==-1 is invalid. Will retry it in 500ms\n"); schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500)); } else { - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "Successfully retrieved domid from Xenstore:%d\n", domid); - hyper_dmabuf_private.domid = domid; + hy_drv_priv->domid = domid; } } } @@ -232,28 +246,30 @@ static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch, return; } - /* Check if we have importer ring for given remote domain alrady created */ + /* Check if we have importer ring for given remote domain already + * created */ + ring_info = xen_comm_find_rx_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. + /* 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. + * it means that remote domain has setup it for us and we should + * connect to it. */ - - ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), rdom, - &grefid, &port); + ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), + rdom, &grefid, &port); if (ring_info && ret != 0) { - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "Remote exporter closed, cleaninup importer\n"); hyper_dmabuf_xen_cleanup_rx_rbuf(rdom); } else if (!ring_info && ret == 0) { - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "Registering importer\n"); hyper_dmabuf_xen_init_rx_rbuf(rdom); } @@ -274,7 +290,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid) ring_info = xen_comm_find_tx_ring(domid); if (ring_info) { - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "tx ring ch to domid = %d already exist\ngref = %d, port = %d\n", ring_info->rdomain, ring_info->gref_ring, ring_info->port); return 0; @@ -283,7 +299,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid) ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL); if (!ring_info) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No more spae left\n"); return -ENOMEM; } @@ -313,9 +329,9 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid) alloc_unbound.dom = DOMID_SELF; alloc_unbound.remote_dom = domid; ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, - &alloc_unbound); + &alloc_unbound); if (ret) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Cannot allocate event channel\n"); kfree(ring_info); return -EIO; @@ -327,7 +343,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid) NULL, (void*) ring_info); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Failed to setup event channel\n"); close.port = alloc_unbound.port; HYPERVISOR_event_channel_op(EVTCHNOP_close, &close); @@ -343,7 +359,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid) mutex_init(&ring_info->lock); - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "%s: allocated eventchannel gref %d port: %d irq: %d\n", __func__, ring_info->gref_ring, @@ -364,7 +380,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid) ring_info->watch.node = (const char*) kmalloc(sizeof(char) * 255, GFP_KERNEL); if (!ring_info->watch.node) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No more space left\n"); kfree(ring_info); return -ENOMEM; @@ -414,7 +430,8 @@ void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid) if (!rx_ring_info) return; - BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring, PAGE_SIZE); + BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring, + PAGE_SIZE); } /* importer needs to know about shared page and port numbers for @@ -436,25 +453,28 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid) ring_info = xen_comm_find_rx_ring(domid); if (ring_info) { - dev_info(hyper_dmabuf_private.device, - "rx ring ch from domid = %d already exist\n", ring_info->sdomain); + dev_info(hy_drv_priv->dev, + "rx ring ch from domid = %d already exist\n", + ring_info->sdomain); + return 0; } - ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), domid, &rx_gref, &rx_port); if (ret) { - dev_err(hyper_dmabuf_private.device, - "Domain %d has not created exporter ring for current domain\n", domid); + dev_err(hy_drv_priv->dev, + "Domain %d has not created exporter ring for current domain\n", + domid); + return ret; } ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL); if (!ring_info) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } @@ -465,7 +485,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid) map_ops = kmalloc(sizeof(*map_ops), GFP_KERNEL); if (!map_ops) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); ret = -ENOMEM; goto fail_no_map_ops; @@ -476,21 +496,23 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid) goto fail_others; } - gnttab_set_map_op(&map_ops[0], (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)), + gnttab_set_map_op(&map_ops[0], + (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)), GNTMAP_host_map, rx_gref, domid); - gnttab_set_unmap_op(&ring_info->unmap_op, (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)), + 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(map_ops, NULL, &shared_ring, 1); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, "Cannot map ring\n"); + dev_err(hy_drv_priv->dev, "Cannot map ring\n"); ret = -EFAULT; goto fail_others; } if (map_ops[0].status) { - dev_err(hyper_dmabuf_private.device, "Ring mapping failed\n"); + dev_err(hy_drv_priv->dev, "Ring mapping failed\n"); ret = -EFAULT; goto fail_others; } else { @@ -512,7 +534,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid) ring_info->irq = ret; - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "%s: bound to eventchannel port: %d irq: %d\n", __func__, rx_port, ring_info->irq); @@ -569,7 +591,9 @@ void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid) return; SHARED_RING_INIT(tx_ring_info->ring_front.sring); - FRONT_RING_INIT(&(tx_ring_info->ring_front), tx_ring_info->ring_front.sring, PAGE_SIZE); + FRONT_RING_INIT(&(tx_ring_info->ring_front), + tx_ring_info->ring_front.sring, + PAGE_SIZE); } #ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD @@ -587,20 +611,20 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused) char buf[128]; int i, dummy; - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "Scanning new tx channel comming from another domain\n"); /* check other domains and schedule another work if driver * is still running and backend is valid */ - if (hyper_dmabuf_private.exited == false && - hyper_dmabuf_private.backend_initialized == true) { + if (hy_drv_priv && + hy_drv_priv->initialized) { for (i = DOMID_SCAN_START; i < DOMID_SCAN_END + 1; i++) { - if (i == hyper_dmabuf_private.domid) + if (i == hy_drv_priv->domid) continue; - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", i, - hyper_dmabuf_private.domid); + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", + i, hy_drv_priv->domid); ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", &dummy); @@ -611,13 +635,14 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused) ret = hyper_dmabuf_xen_init_rx_rbuf(i); if (!ret) - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "Finishing up setting up rx channel for domain %d\n", i); } } /* check every 10 seconds */ - schedule_delayed_work(&xen_rx_ch_auto_add_work, msecs_to_jiffies(10000)); + schedule_delayed_work(&xen_rx_ch_auto_add_work, + msecs_to_jiffies(10000)); } } @@ -630,21 +655,21 @@ void xen_init_comm_env_delayed(struct work_struct *unused) /* scheduling another work if driver is still running * and xenstore hasn't been initialized or dom_id hasn't * been correctly retrieved. */ - if (hyper_dmabuf_private.exited == false && - likely(xenstored_ready == 0 || - hyper_dmabuf_private.domid == -1)) { - dev_dbg(hyper_dmabuf_private.device, - "Xenstore is not ready yet. Re-try this again in 500ms\n"); - schedule_delayed_work(&xen_init_comm_env_work, msecs_to_jiffies(500)); + if (likely(xenstored_ready == 0 || + hy_drv_priv->domid == -1)) { + dev_dbg(hy_drv_priv->dev, + "Xenstore not ready Will re-try in 500ms\n"); + schedule_delayed_work(&xen_init_comm_env_work, + msecs_to_jiffies(500)); } else { ret = xen_comm_setup_data_dir(); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Failed to create data dir in Xenstore\n"); } else { - dev_info(hyper_dmabuf_private.device, - "Successfully finished comm env initialization\n"); - hyper_dmabuf_private.backend_initialized = true; + dev_info(hy_drv_priv->dev, + "Successfully finished comm env init\n"); + hy_drv_priv->initialized = true; #ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD xen_rx_ch_add_delayed(NULL); @@ -659,20 +684,21 @@ int hyper_dmabuf_xen_init_comm_env(void) xen_comm_ring_table_init(); - if (unlikely(xenstored_ready == 0 || hyper_dmabuf_private.domid == -1)) { + if (unlikely(xenstored_ready == 0 || + hy_drv_priv->domid == -1)) { xen_init_comm_env_delayed(NULL); return -1; } ret = xen_comm_setup_data_dir(); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Failed to create data dir in Xenstore\n"); } else { - dev_info(hyper_dmabuf_private.device, + dev_info(hy_drv_priv->dev, "Successfully finished comm env initialization\n"); - hyper_dmabuf_private.backend_initialized = true; + hy_drv_priv->initialized = true; } return ret; @@ -691,7 +717,8 @@ void hyper_dmabuf_xen_destroy_comm(void) xen_comm_destroy_data_dir(); } -int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) +int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, + int wait) { struct xen_comm_front_ring *ring; struct hyper_dmabuf_req *new_req; @@ -706,22 +733,21 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) /* find a ring info for the channel */ ring_info = xen_comm_find_tx_ring(domid); if (!ring_info) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Can't find ring info for the channel\n"); return -ENOENT; } - mutex_lock(&ring_info->lock); ring = &ring_info->ring_front; do_gettimeofday(&tv_start); while (RING_FULL(ring)) { - dev_dbg(hyper_dmabuf_private.device, "RING_FULL\n"); + dev_dbg(hy_drv_priv->dev, "RING_FULL\n"); if (timeout == 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "Timeout while waiting for an entry in the ring\n"); return -EIO; } @@ -731,15 +757,17 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) timeout = 1000; + mutex_lock(&ring_info->lock); + new_req = RING_GET_REQUEST(ring, ring->req_prod_pvt); if (!new_req) { mutex_unlock(&ring_info->lock); - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "NULL REQUEST\n"); return -EIO; } - req->request_id = xen_comm_next_req_id(); + req->req_id = xen_comm_next_req_id(); /* update req_pending with current request */ memcpy(&req_pending, req, sizeof(req_pending)); @@ -756,7 +784,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) if (wait) { while (timeout--) { - if (req_pending.status != + if (req_pending.stat != HYPER_DMABUF_REQ_NOT_RESPONDED) break; usleep_range(100, 120); @@ -764,7 +792,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) if (timeout < 0) { mutex_unlock(&ring_info->lock); - dev_err(hyper_dmabuf_private.device, "request timed-out\n"); + dev_err(hy_drv_priv->dev, "request timed-out\n"); return -EBUSY; } @@ -781,10 +809,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait) } if (tv_diff.tv_sec != 0 && tv_diff.tv_usec > 16000) - dev_dbg(hyper_dmabuf_private.device, "send_req:time diff: %ld sec, %ld usec\n", + dev_dbg(hy_drv_priv->dev, "send_req:time diff: %ld sec, %ld usec\n", tv_diff.tv_sec, tv_diff.tv_usec); - - return req_pending.status; } mutex_unlock(&ring_info->lock); @@ -808,7 +834,7 @@ static irqreturn_t back_ring_isr(int irq, void *info) ring_info = (struct xen_comm_rx_ring_info *)info; ring = &ring_info->ring_back; - dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s\n", __func__); do { rc = ring->req_cons; @@ -828,13 +854,13 @@ static irqreturn_t back_ring_isr(int irq, void *info) * the requester */ memcpy(&resp, &req, sizeof(resp)); - memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt), &resp, - sizeof(resp)); + memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt), + &resp, sizeof(resp)); ring->rsp_prod_pvt++; - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "sending response to exporter for request id:%d\n", - resp.response_id); + resp.resp_id); RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify); @@ -864,7 +890,7 @@ static irqreturn_t front_ring_isr(int irq, void *info) ring_info = (struct xen_comm_tx_ring_info *)info; ring = &ring_info->ring_front; - dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s\n", __func__); do { more_to_do = 0; @@ -876,33 +902,33 @@ static irqreturn_t front_ring_isr(int irq, void *info) * in the response */ - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, "getting response from importer\n"); - if (req_pending.request_id == resp->response_id) { - req_pending.status = resp->status; + if (req_pending.req_id == resp->resp_id) { + req_pending.stat = resp->stat; } - if (resp->status == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) { + if (resp->stat == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) { /* parsing response */ ret = hyper_dmabuf_msg_parse(ring_info->rdomain, (struct hyper_dmabuf_req *)resp); if (ret < 0) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "getting error while parsing response\n"); } - } else if (resp->status == HYPER_DMABUF_REQ_PROCESSED) { + } else if (resp->stat == HYPER_DMABUF_REQ_PROCESSED) { /* for debugging dma_buf remote synchronization */ - dev_dbg(hyper_dmabuf_private.device, - "original request = 0x%x\n", resp->command); - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, + "original request = 0x%x\n", resp->cmd); + dev_dbg(hy_drv_priv->dev, "Just got HYPER_DMABUF_REQ_PROCESSED\n"); - } else if (resp->status == HYPER_DMABUF_REQ_ERROR) { + } else if (resp->stat == HYPER_DMABUF_REQ_ERROR) { /* for debugging dma_buf remote synchronization */ - dev_dbg(hyper_dmabuf_private.device, - "original request = 0x%x\n", resp->command); - dev_dbg(hyper_dmabuf_private.device, + dev_dbg(hy_drv_priv->dev, + "original request = 0x%x\n", resp->cmd); + dev_dbg(hy_drv_priv->dev, "Just got HYPER_DMABUF_REQ_ERROR\n"); } } 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 4708b49..7a8ec73 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 @@ -38,8 +38,6 @@ #include "hyper_dmabuf_xen_comm.h" #include "hyper_dmabuf_xen_comm_list.h" -extern struct hyper_dmabuf_private hyper_dmabuf_private; - DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING); DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING); @@ -56,7 +54,7 @@ int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info) info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL); if (!info_entry) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } @@ -76,7 +74,7 @@ int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info) info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL); if (!info_entry) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "No memory left to be allocated\n"); return -ENOMEM; } diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c index 908eda8..424417d 100644 --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c @@ -36,8 +36,6 @@ #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t)) -extern struct hyper_dmabuf_private hyper_dmabuf_private; - /* * Creates 2 level page directory structure for referencing shared pages. * Top level page is a single page that contains up to 1024 refids that @@ -98,7 +96,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents, sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL); if (!sh_pages_info) { - dev_err(hyper_dmabuf_private.device, "No more space left\n"); + dev_err(hy_drv_priv->dev, "No more space left\n"); return -ENOMEM; } @@ -107,10 +105,10 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents, /* share data pages in readonly mode for security */ for (i=0; idev, "No more space left in grant table\n"); /* Unshare all already shared pages for lvl2 */ while(i--) { @@ -124,10 +122,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents, /* Share 2nd level addressing pages in readonly mode*/ for (i=0; i< n_lvl2_grefs; i++) { lvl3_table[i] = gnttab_grant_foreign_access(domid, - virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ), - true); + virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ), + true); + if (lvl3_table[i] == -ENOSPC) { - dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n"); + dev_err(hy_drv_priv->dev, "No more space left in grant table\n"); /* Unshare all already shared pages for lvl3 */ while(i--) { @@ -147,11 +146,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents, /* Share lvl3_table in readonly mode*/ lvl3_gref = gnttab_grant_foreign_access(domid, - virt_to_mfn((unsigned long)lvl3_table), - true); + virt_to_mfn((unsigned long)lvl3_table), + true); if (lvl3_gref == -ENOSPC) { - dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n"); + dev_err(hy_drv_priv->dev, "No more space left in grant table\n"); /* Unshare all pages for lvl3 */ while(i--) { @@ -178,7 +177,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents, /* Store exported pages refid to be unshared later */ sh_pages_info->lvl3_gref = lvl3_gref; - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__); return lvl3_gref; err_cleanup: @@ -190,16 +189,17 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents, int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) { struct xen_shared_pages_info *sh_pages_info; - int n_lvl2_grefs = (nents/REFS_PER_PAGE + ((nents % REFS_PER_PAGE) ? 1: 0)); + int n_lvl2_grefs = (nents/REFS_PER_PAGE + + ((nents % REFS_PER_PAGE) ? 1: 0)); int i; - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__); sh_pages_info = (struct xen_shared_pages_info *)(*refs_info); if (sh_pages_info->lvl3_table == NULL || sh_pages_info->lvl2_table == NULL || sh_pages_info->lvl3_gref == -1) { - dev_warn(hyper_dmabuf_private.device, + dev_warn(hy_drv_priv->dev, "gref table for hyper_dmabuf already cleaned up\n"); return 0; } @@ -207,7 +207,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) { /* End foreign access for data pages, but do not free them */ for (i = 0; i < nents; i++) { if (gnttab_query_foreign_access(sh_pages_info->lvl2_table[i])) { - dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n"); + dev_warn(hy_drv_priv->dev, "refid not shared !!\n"); } gnttab_end_foreign_access_ref(sh_pages_info->lvl2_table[i], 0); gnttab_free_grant_reference(sh_pages_info->lvl2_table[i]); @@ -216,17 +216,17 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) { /* End foreign access for 2nd level addressing pages */ for (i = 0; i < n_lvl2_grefs; i++) { if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i])) { - dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n"); + dev_warn(hy_drv_priv->dev, "refid not shared !!\n"); } if (!gnttab_end_foreign_access_ref(sh_pages_info->lvl3_table[i], 1)) { - dev_warn(hyper_dmabuf_private.device, "refid still in use!!!\n"); + dev_warn(hy_drv_priv->dev, "refid still in use!!!\n"); } gnttab_free_grant_reference(sh_pages_info->lvl3_table[i]); } /* End foreign access for top level addressing page */ if (gnttab_query_foreign_access(sh_pages_info->lvl3_gref)) { - dev_warn(hyper_dmabuf_private.device, "gref not shared !!\n"); + dev_warn(hy_drv_priv->dev, "gref not shared !!\n"); } gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1); @@ -242,7 +242,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) { kfree(sh_pages_info); sh_pages_info = NULL; - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__); return 0; } @@ -270,27 +270,33 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n /* # of grefs in the last page of lvl2 table */ int nents_last = (nents - 1) % REFS_PER_PAGE + 1; - int n_lvl2_grefs = (nents / REFS_PER_PAGE) + ((nents_last > 0) ? 1 : 0) - + int n_lvl2_grefs = (nents / REFS_PER_PAGE) + + ((nents_last > 0) ? 1 : 0) - (nents_last == REFS_PER_PAGE); int i, j, k; - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__); sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL); *refs_info = (void *) sh_pages_info; - lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs, GFP_KERNEL); + lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs, + GFP_KERNEL); + data_pages = kcalloc(sizeof(struct page*), nents, GFP_KERNEL); - lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs, GFP_KERNEL); - lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs, GFP_KERNEL); + lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs, + GFP_KERNEL); + + lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs, + GFP_KERNEL); data_map_ops = kcalloc(sizeof(*data_map_ops), nents, GFP_KERNEL); data_unmap_ops = kcalloc(sizeof(*data_unmap_ops), nents, GFP_KERNEL); /* Map top level addressing page */ if (gnttab_alloc_pages(1, &lvl3_table_page)) { - dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n"); + dev_err(hy_drv_priv->dev, "Cannot allocate pages\n"); return NULL; } @@ -304,13 +310,16 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n GNTMAP_host_map | GNTMAP_readonly, -1); if (gnttab_map_refs(&lvl3_map_ops, NULL, &lvl3_table_page, 1)) { - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed"); + dev_err(hy_drv_priv->dev, + "HYPERVISOR map grant ref failed"); return NULL; } if (lvl3_map_ops.status) { - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed status = %d", + dev_err(hy_drv_priv->dev, + "HYPERVISOR map grant ref failed status = %d", lvl3_map_ops.status); + goto error_cleanup_lvl3; } else { lvl3_unmap_ops.handle = lvl3_map_ops.handle; @@ -318,35 +327,43 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n /* Map all second level pages */ if (gnttab_alloc_pages(n_lvl2_grefs, lvl2_table_pages)) { - dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n"); + dev_err(hy_drv_priv->dev, "Cannot allocate pages\n"); goto error_cleanup_lvl3; } for (i = 0; i < n_lvl2_grefs; i++) { lvl2_table = (grant_ref_t *)pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i])); - gnttab_set_map_op(&lvl2_map_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly, + gnttab_set_map_op(&lvl2_map_ops[i], + (unsigned long)lvl2_table, GNTMAP_host_map | + GNTMAP_readonly, lvl3_table[i], domid); - gnttab_set_unmap_op(&lvl2_unmap_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly, -1); + gnttab_set_unmap_op(&lvl2_unmap_ops[i], + (unsigned long)lvl2_table, GNTMAP_host_map | + GNTMAP_readonly, -1); } /* Unmap top level page, as it won't be needed any longer */ - if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1)) { - dev_err(hyper_dmabuf_private.device, "xen: cannot unmap top level page\n"); + if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL, + &lvl3_table_page, 1)) { + dev_err(hy_drv_priv->dev, + "xen: cannot unmap top level page\n"); return NULL; } else { /* Mark that page was unmapped */ lvl3_unmap_ops.handle = -1; } - if (gnttab_map_refs(lvl2_map_ops, NULL, lvl2_table_pages, n_lvl2_grefs)) { - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed"); + if (gnttab_map_refs(lvl2_map_ops, NULL, + lvl2_table_pages, n_lvl2_grefs)) { + dev_err(hy_drv_priv->dev, + "HYPERVISOR map grant ref failed"); return NULL; } /* Checks if pages were mapped correctly */ for (i = 0; i < n_lvl2_grefs; i++) { if (lvl2_map_ops[i].status) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "HYPERVISOR map grant ref failed status = %d", lvl2_map_ops[i].status); goto error_cleanup_lvl2; @@ -356,7 +373,8 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n } if (gnttab_alloc_pages(nents, data_pages)) { - dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n"); + dev_err(hy_drv_priv->dev, + "Cannot allocate pages\n"); goto error_cleanup_lvl2; } @@ -366,13 +384,13 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n lvl2_table = pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i])); for (j = 0; j < REFS_PER_PAGE; j++) { gnttab_set_map_op(&data_map_ops[k], - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), - GNTMAP_host_map | GNTMAP_readonly, - lvl2_table[j], domid); + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), + GNTMAP_host_map | GNTMAP_readonly, + lvl2_table[j], domid); gnttab_set_unmap_op(&data_unmap_ops[k], - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), - GNTMAP_host_map | GNTMAP_readonly, -1); + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), + GNTMAP_host_map | GNTMAP_readonly, -1); k++; } } @@ -382,25 +400,29 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n for (j = 0; j < nents_last; j++) { gnttab_set_map_op(&data_map_ops[k], - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), - GNTMAP_host_map | GNTMAP_readonly, - lvl2_table[j], domid); + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), + GNTMAP_host_map | GNTMAP_readonly, + lvl2_table[j], domid); gnttab_set_unmap_op(&data_unmap_ops[k], - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), - GNTMAP_host_map | GNTMAP_readonly, -1); + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])), + GNTMAP_host_map | GNTMAP_readonly, -1); k++; } - if (gnttab_map_refs(data_map_ops, NULL, data_pages, nents)) { - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed\n"); + if (gnttab_map_refs(data_map_ops, NULL, + data_pages, nents)) { + dev_err(hy_drv_priv->dev, + "HYPERVISOR map grant ref failed\n"); return NULL; } /* unmapping lvl2 table pages */ - if (gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages, + if (gnttab_unmap_refs(lvl2_unmap_ops, + NULL, lvl2_table_pages, n_lvl2_grefs)) { - dev_err(hyper_dmabuf_private.device, "Cannot unmap 2nd level refs\n"); + dev_err(hy_drv_priv->dev, + "Cannot unmap 2nd level refs\n"); return NULL; } else { /* Mark that pages were unmapped */ @@ -411,7 +433,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n for (i = 0; i < nents; i++) { if (data_map_ops[i].status) { - dev_err(hyper_dmabuf_private.device, + dev_err(hy_drv_priv->dev, "HYPERVISOR map grant ref failed status = %d\n", data_map_ops[i].status); goto error_cleanup_data; @@ -431,7 +453,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n kfree(lvl2_unmap_ops); kfree(data_map_ops); - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__); return data_pages; error_cleanup_data: @@ -442,13 +464,14 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n error_cleanup_lvl2: if (lvl2_unmap_ops[0].handle != -1) - gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages, - n_lvl2_grefs); + gnttab_unmap_refs(lvl2_unmap_ops, NULL, + lvl2_table_pages, n_lvl2_grefs); gnttab_free_pages(n_lvl2_grefs, lvl2_table_pages); error_cleanup_lvl3: if (lvl3_unmap_ops.handle != -1) - gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1); + gnttab_unmap_refs(&lvl3_unmap_ops, NULL, + &lvl3_table_page, 1); gnttab_free_pages(1, &lvl3_table_page); kfree(lvl2_table_pages); @@ -463,20 +486,20 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) { struct xen_shared_pages_info *sh_pages_info; - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__); sh_pages_info = (struct xen_shared_pages_info *)(*refs_info); if (sh_pages_info->unmap_ops == NULL || sh_pages_info->data_pages == NULL) { - dev_warn(hyper_dmabuf_private.device, - "Imported pages already cleaned up or buffer was not imported yet\n"); + dev_warn(hy_drv_priv->dev, + "pages already cleaned up or buffer not imported yet\n"); return 0; } if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL, sh_pages_info->data_pages, nents) ) { - dev_err(hyper_dmabuf_private.device, "Cannot unmap data pages\n"); + dev_err(hy_drv_priv->dev, "Cannot unmap data pages\n"); return -EFAULT; } @@ -489,6 +512,6 @@ int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) { kfree(sh_pages_info); sh_pages_info = NULL; - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__); + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__); return 0; } -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 49/60] hyper_dmabuf: general clean-up and fixes Date: Tue, 19 Dec 2017 11:30:05 -0800 Message-ID: <1513711816-2618-49-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 MS4gZ2xvYmFsIGh5cGVyX2RtYWJ1Zl9wcml2YXRlIGlzIG5vdyBwb2ludGVyKCpoeV9kcnZfcHJp dikKICAgcG9pbnRpbmcgdG8gcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZSBpbml0aWFsaXplZCB3aGVu IGRyaXZlcgogICBpcyBpbml0aWFsaXplZC4gVGhpcyBpcyBmcmVlZCB3aGVuIGRyaXZlciBleGl0 cy4KCjIuIHVzaW5nIHNob3J0ZXIgdmFyaWFibGUgYW5kIHR5cGUncyBuYW1lcwoKMy4gcmVtb3Zl IHVubmVjZXNzYXJ5IE5VTEwgY2hlY2tzCgo0LiBldmVudC1wb2xsaW5nIHJlbGF0ZWQgZnVuY3Mg YXJlIG5vdyBjb21waWxlZCBvbmx5IGlmCiAgIENPTkZJR19IWVBFUl9ETUFCVUZfRVZFTlRfR0VO IGlzIGVuYWJsZWQuCgpTaWduZWQtb2ZmLWJ5OiBEb25nd29uIEtpbSA8ZG9uZ3dvbi5raW1AaW50 ZWwuY29tPgotLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9NYWtlZmlsZSAgICAgICAgICAg ICAgICAgIHwgICA3ICstCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Nv bmYuaCAgICAgICB8ICAyNSAtCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X2Rydi5jICAgICAgICB8IDE2NCArKystLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBl cl9kbWFidWZfZHJ2LmggICAgICAgIHwgIDEzICstCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv aHlwZXJfZG1hYnVmX2V2ZW50LmMgICAgICB8ICA2MCArLS0KIGRyaXZlcnMveGVuL2h5cGVyX2Rt YWJ1Zi9oeXBlcl9kbWFidWZfaWQuYyAgICAgICAgIHwgIDE2ICstCiBkcml2ZXJzL3hlbi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMgICAgICB8IDU2OSArKysrKysrKysrLS0tLS0t LS0tLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuaCAgICAg IHwgICAyICsKIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5jICAg ICAgIHwgIDg4ICsrLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlz dC5oICAgICAgIHwgIDE4ICstCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X21zZy5jICAgICAgICB8IDI1OSArKysrKy0tLS0tCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv aHlwZXJfZG1hYnVmX21zZy5oICAgICAgICB8ICAxOCArLQogZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL2h5cGVyX2RtYWJ1Zl9vcHMuYyAgICAgICAgfCAyODQgKysrKystLS0tLQogZHJpdmVycy94 ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9vcHMuaCAgICAgICAgfCAgIDQgKy0KIGRyaXZl cnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcXVlcnkuYyAgICAgIHwgIDU4ICstLQog ZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9xdWVyeS5oICAgICAgfCAgIDQg Ky0KIC4uLi94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jICAgIHwg MTcwICsrKy0tLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zZ2xfcHJv Yy5jICAgfCAxMjMgKystLS0KIGRyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZf c2dsX3Byb2MuaCAgIHwgIDEwICstCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1h YnVmX3N0cnVjdC5oICAgICB8ICAyNCArLQogLi4uL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVy X2RtYWJ1Zl94ZW5fY29tbS5jICAgfCAyNDAgKysrKystLS0tCiAuLi4vaHlwZXJfZG1hYnVmL3hl bi9oeXBlcl9kbWFidWZfeGVuX2NvbW1fbGlzdC5jICB8ICAgNiArLQogLi4uL3hlbi9oeXBlcl9k bWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fc2htLmMgICAgfCAxNDcgKysrLS0tCiAyMyBmaWxl cyBjaGFuZ2VkLCAxMTQ0IGluc2VydGlvbnMoKyksIDExNjUgZGVsZXRpb25zKC0pCiBkZWxldGUg bW9kZSAxMDA2NDQgZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9jb25mLmgK CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvTWFrZWZpbGUgYi9kcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvTWFrZWZpbGUKaW5kZXggMWNkN2E4MS4uYTExM2JmYyAxMDA2NDQK LS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL01ha2VmaWxlCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9NYWtlZmlsZQpAQCAtMTMsOSArMTMsMTIgQEAgaWZuZXEgKCQoS0VSTkVM UkVMRUFTRSksKQogCQkJCSBoeXBlcl9kbWFidWZfaWQubyBcCiAJCQkJIGh5cGVyX2RtYWJ1Zl9y ZW1vdGVfc3luYy5vIFwKIAkJCQkgaHlwZXJfZG1hYnVmX3F1ZXJ5Lm8gXAotCQkJCSBoeXBlcl9k bWFidWZfZXZlbnQubyBcCiAKLWlmZXEgKCQoQ09ORklHX1hFTiksIHkpCitpZmVxICgkKENPTkZJ R19IWVBFUl9ETUFCVUZfRVZFTlRfR0VOKSwgeSkKKwkkKFRBUkdFVF9NT0RVTEUpLW9ianMgKz0g aHlwZXJfZG1hYnVmX2V2ZW50Lm8KK2VuZGlmCisKK2lmZXEgKCQoQ09ORklHX0hZUEVSX0RNQUJV Rl9YRU4pLCB5KQogCSQoVEFSR0VUX01PRFVMRSktb2JqcyArPSB4ZW4vaHlwZXJfZG1hYnVmX3hl bl9jb21tLm8gXAogCQkJCSB4ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tX2xpc3QubyBcCiAJCQkJ IHhlbi9oeXBlcl9kbWFidWZfeGVuX3NobS5vIFwKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfY29uZi5oIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVm L2h5cGVyX2RtYWJ1Zl9jb25mLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQ1MTI1 ZjIuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9j b25mLmgKKysrIC9kZXYvbnVsbApAQCAtMSwyNSArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IMKp IDIwMTcgSW50ZWwgQ29ycG9yYXRpb24KLSAqCi0gKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFu dGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYQotICogY29weSBv ZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAi U29mdHdhcmUiKSwKLSAqIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rp b24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24KLSAqIHRoZSByaWdodHMgdG8gdXNlLCBj b3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLAotICog YW5kL29yIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25z IHRvIHdob20gdGhlCi0gKiBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3Qg dG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgotICoKLSAqIFRoZSBhYm92ZSBjb3B5cmlnaHQg bm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIChpbmNsdWRpbmcgdGhlIG5leHQKLSAq IHBhcmFncmFwaCkgc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsIGNvcGllcyBvciBzdWJzdGFudGlh bCBwb3J0aW9ucyBvZiB0aGUKLSAqIFNvZnR3YXJlLgotICoKLSAqIFRIRSBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9S Ci0gKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSwKLSAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVOVCBTSEFMTAotICogVEhFIEFVVEhPUlMg T1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1Ig T1RIRVIKLSAqIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRP UlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HCi0gKiBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElP TiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTCi0gKiBJTiBU SEUgU09GVFdBUkUuCi0gKgotICovCi0KLS8qIGNvbmZpZ3VyYXRpb24gKi8KZGlmZiAtLWdpdCBh L2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmMgYi9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5jCmluZGV4IDFjMzVhNTkuLjUyNWVlNzgg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmMK KysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuYwpAQCAtMzYs NyArMzYsNiBAQAogI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KICNpbmNsdWRlIDxsaW51eC9kbWEt YnVmLmg+CiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2Rydi5oIgotI2luY2x1ZGUgImh5cGVyX2Rt YWJ1Zl9jb25mLmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2lvY3RsLmgiCiAjaW5jbHVkZSAi aHlwZXJfZG1hYnVmX21zZy5oIgogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9saXN0LmgiCkBAIC01 MSwxMyArNTAsMzIgQEAgZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfYmFja2VuZF9vcHMgeGVu X2JhY2tlbmRfb3BzOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCBhbmQgYWRkaXRpb25hbCByaWdodHMi KTsKIE1PRFVMRV9BVVRIT1IoIkludGVsIENvcnBvcmF0aW9uIik7CiAKLXN0cnVjdCBoeXBlcl9k bWFidWZfcHJpdmF0ZSBoeXBlcl9kbWFidWZfcHJpdmF0ZTsKK3N0cnVjdCBoeXBlcl9kbWFidWZf cHJpdmF0ZSAqaHlfZHJ2X3ByaXY7CiAKIGxvbmcgaHlwZXJfZG1hYnVmX2lvY3RsKHN0cnVjdCBm aWxlICpmaWxwLAogCQkJdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBwYXJhbSk7CiAK LXZvaWQgaHlwZXJfZG1hYnVmX2VtZXJnZW5jeV9yZWxlYXNlKHN0cnVjdCBoeXBlcl9kbWFidWZf c2d0X2luZm8qIHNndF9pbmZvLAotCQkJCSAgICB2b2lkICphdHRyKTsKK3N0YXRpYyB2b2lkIGh5 cGVyX2RtYWJ1Zl9mb3JjZV9mcmVlKHN0cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyogZXhwb3J0ZWQs CisJCQkgICAgICAgICAgICB2b2lkICphdHRyKQoreworCXN0cnVjdCBpb2N0bF9oeXBlcl9kbWFi dWZfdW5leHBvcnQgdW5leHBvcnRfYXR0cjsKKwlzdHJ1Y3QgZmlsZSAqZmlscCA9IChzdHJ1Y3Qg ZmlsZSopIGF0dHI7CisKKwlpZiAoIWZpbHAgfHwgIWV4cG9ydGVkKQorCQlyZXR1cm47CisKKwlp ZiAoZXhwb3J0ZWQtPmZpbHAgPT0gZmlscCkgeworCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYs CisJCQkiRm9yY2VmdWxseSByZWxlYXNpbmcgYnVmZmVyIHtpZDolZCBrZXk6JWQgJWQgJWR9XG4i LAorCQkJIGV4cG9ydGVkLT5oaWQuaWQsIGV4cG9ydGVkLT5oaWQucm5nX2tleVswXSwKKwkJCSBl eHBvcnRlZC0+aGlkLnJuZ19rZXlbMV0sIGV4cG9ydGVkLT5oaWQucm5nX2tleVsyXSk7CisKKwkJ dW5leHBvcnRfYXR0ci5oaWQgPSBleHBvcnRlZC0+aGlkOworCQl1bmV4cG9ydF9hdHRyLmRlbGF5 X21zID0gMDsKKworCQloeXBlcl9kbWFidWZfdW5leHBvcnRfaW9jdGwoZmlscCwgJnVuZXhwb3J0 X2F0dHIpOworCX0KK30KIAogaW50IGh5cGVyX2RtYWJ1Zl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5v ZGUsIHN0cnVjdCBmaWxlICpmaWxwKQogewpAQCAtNzIsMTggKzkwLDIwIEBAIGludCBoeXBlcl9k bWFidWZfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkKIAogaW50 IGh5cGVyX2RtYWJ1Zl9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpm aWxwKQogewotCWh5cGVyX2RtYWJ1Zl9mb3JlYWNoX2V4cG9ydGVkKGh5cGVyX2RtYWJ1Zl9lbWVy Z2VuY3lfcmVsZWFzZSwgZmlscCk7CisJaHlwZXJfZG1hYnVmX2ZvcmVhY2hfZXhwb3J0ZWQoaHlw ZXJfZG1hYnVmX2ZvcmNlX2ZyZWUsIGZpbHApOwogCiAJcmV0dXJuIDA7CiB9CiAKKyNpZmRlZiBD T05GSUdfSFlQRVJfRE1BQlVGX0VWRU5UX0dFTgorCiB1bnNpZ25lZCBpbnQgaHlwZXJfZG1hYnVm X2V2ZW50X3BvbGwoc3RydWN0IGZpbGUgKmZpbHAsIHN0cnVjdCBwb2xsX3RhYmxlX3N0cnVjdCAq d2FpdCkKIHsKIAl1bnNpZ25lZCBpbnQgbWFzayA9IDA7CiAKLQlwb2xsX3dhaXQoZmlscCwgJmh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmV2ZW50X3dhaXQsIHdhaXQpOworCXBvbGxfd2FpdChmaWxwLCAm aHlfZHJ2X3ByaXYtPmV2ZW50X3dhaXQsIHdhaXQpOwogCi0JaWYgKCFsaXN0X2VtcHR5KCZoeXBl cl9kbWFidWZfcHJpdmF0ZS5ldmVudF9saXN0KSkKKwlpZiAoIWxpc3RfZW1wdHkoJmh5X2Rydl9w cml2LT5ldmVudF9saXN0KSkKIAkJbWFzayB8PSBQT0xMSU4gfCBQT0xMUkROT1JNOwogCiAJcmV0 dXJuIG1hc2s7CkBAIC05NiwzMiArMTE2LDMyIEBAIHNzaXplX3QgaHlwZXJfZG1hYnVmX2V2ZW50 X3JlYWQoc3RydWN0IGZpbGUgKmZpbHAsIGNoYXIgX191c2VyICpidWZmZXIsCiAKIAkvKiBvbmx5 IHJvb3QgY2FuIHJlYWQgZXZlbnRzICovCiAJaWYgKCFjYXBhYmxlKENBUF9EQUNfT1ZFUlJJREUp KSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfZXJyKGh5 X2Rydl9wcml2LT5kZXYsCiAJCQkiT25seSByb290IGNhbiByZWFkIGV2ZW50c1xuIik7CiAJCXJl dHVybiAtRUZBVUxUOwogCX0KIAogCS8qIG1ha2Ugc3VyZSB1c2VyIGJ1ZmZlciBjYW4gYmUgd3Jp dHRlbiAqLwogCWlmICghYWNjZXNzX29rKFZFUklGWV9XUklURSwgYnVmZmVyLCBjb3VudCkpIHsK LQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2 X3ByaXYtPmRldiwKIAkJCSJVc2VyIGJ1ZmZlciBjYW4ndCBiZSB3cml0dGVuLlxuIik7CiAJCXJl dHVybiAtRUZBVUxUOwogCX0KIAotCXJldCA9IG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZXZlbnRfcmVhZF9sb2NrKTsKKwlyZXQgPSBtdXRleF9sb2NrX2lu dGVycnVwdGlibGUoJmh5X2Rydl9wcml2LT5ldmVudF9yZWFkX2xvY2spOwogCWlmIChyZXQpCiAJ CXJldHVybiByZXQ7CiAKIAl3aGlsZSAoMSkgewogCQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2V2ZW50 ICplID0gTlVMTDsKIAotCQlzcGluX2xvY2tfaXJxKCZoeXBlcl9kbWFidWZfcHJpdmF0ZS5ldmVu dF9sb2NrKTsKLQkJaWYgKCFsaXN0X2VtcHR5KCZoeXBlcl9kbWFidWZfcHJpdmF0ZS5ldmVudF9s aXN0KSkgewotCQkJZSA9IGxpc3RfZmlyc3RfZW50cnkoJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV2 ZW50X2xpc3QsCisJCXNwaW5fbG9ja19pcnEoJmh5X2Rydl9wcml2LT5ldmVudF9sb2NrKTsKKwkJ aWYgKCFsaXN0X2VtcHR5KCZoeV9kcnZfcHJpdi0+ZXZlbnRfbGlzdCkpIHsKKwkJCWUgPSBsaXN0 X2ZpcnN0X2VudHJ5KCZoeV9kcnZfcHJpdi0+ZXZlbnRfbGlzdCwKIAkJCQkJc3RydWN0IGh5cGVy X2RtYWJ1Zl9ldmVudCwgbGluayk7CiAJCQlsaXN0X2RlbCgmZS0+bGluayk7CiAJCX0KLQkJc3Bp bl91bmxvY2tfaXJxKCZoeXBlcl9kbWFidWZfcHJpdmF0ZS5ldmVudF9sb2NrKTsKKwkJc3Bpbl91 bmxvY2tfaXJxKCZoeV9kcnZfcHJpdi0+ZXZlbnRfbG9jayk7CiAKIAkJaWYgKCFlKSB7CiAJCQlp ZiAocmV0KQpAQCAtMTMxLDEyICsxNTEsMTIgQEAgc3NpemVfdCBoeXBlcl9kbWFidWZfZXZlbnRf cmVhZChzdHJ1Y3QgZmlsZSAqZmlscCwgY2hhciBfX3VzZXIgKmJ1ZmZlciwKIAkJCQlicmVhazsK IAkJCX0KIAotCQkJbXV0ZXhfdW5sb2NrKCZoeXBlcl9kbWFidWZfcHJpdmF0ZS5ldmVudF9yZWFk X2xvY2spOwotCQkJcmV0ID0gd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlKGh5cGVyX2RtYWJ1Zl9w cml2YXRlLmV2ZW50X3dhaXQsCi0JCQkJCQkgICAgICAgIWxpc3RfZW1wdHkoJmh5cGVyX2RtYWJ1 Zl9wcml2YXRlLmV2ZW50X2xpc3QpKTsKKwkJCW11dGV4X3VubG9jaygmaHlfZHJ2X3ByaXYtPmV2 ZW50X3JlYWRfbG9jayk7CisJCQlyZXQgPSB3YWl0X2V2ZW50X2ludGVycnVwdGlibGUoaHlfZHJ2 X3ByaXYtPmV2ZW50X3dhaXQsCisJCQkJCQkgICAgICAgIWxpc3RfZW1wdHkoJmh5X2Rydl9wcml2 LT5ldmVudF9saXN0KSk7CiAKIAkJCWlmIChyZXQgPT0gMCkKLQkJCQlyZXQgPSBtdXRleF9sb2Nr X2ludGVycnVwdGlibGUoJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV2ZW50X3JlYWRfbG9jayk7CisJ CQkJcmV0ID0gbXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZoeV9kcnZfcHJpdi0+ZXZlbnRfcmVh ZF9sb2NrKTsKIAogCQkJaWYgKHJldCkKIAkJCQlyZXR1cm4gcmV0OwpAQCAtMTQ1LDkgKzE2NSw5 IEBAIHNzaXplX3QgaHlwZXJfZG1hYnVmX2V2ZW50X3JlYWQoc3RydWN0IGZpbGUgKmZpbHAsIGNo YXIgX191c2VyICpidWZmZXIsCiAKIAkJCWlmIChsZW5ndGggPiBjb3VudCAtIHJldCkgewogcHV0 X2JhY2tfZXZlbnQ6Ci0JCQkJc3Bpbl9sb2NrX2lycSgmaHlwZXJfZG1hYnVmX3ByaXZhdGUuZXZl bnRfbG9jayk7Ci0JCQkJbGlzdF9hZGQoJmUtPmxpbmssICZoeXBlcl9kbWFidWZfcHJpdmF0ZS5l dmVudF9saXN0KTsKLQkJCQlzcGluX3VubG9ja19pcnEoJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV2 ZW50X2xvY2spOworCQkJCXNwaW5fbG9ja19pcnEoJmh5X2Rydl9wcml2LT5ldmVudF9sb2NrKTsK KwkJCQlsaXN0X2FkZCgmZS0+bGluaywgJmh5X2Rydl9wcml2LT5ldmVudF9saXN0KTsKKwkJCQlz cGluX3VubG9ja19pcnEoJmh5X2Rydl9wcml2LT5ldmVudF9sb2NrKTsKIAkJCQlicmVhazsKIAkJ CX0KIApAQCAtMTcwLDcgKzE5MCw3IEBAIHNzaXplX3QgaHlwZXJfZG1hYnVmX2V2ZW50X3JlYWQo c3RydWN0IGZpbGUgKmZpbHAsIGNoYXIgX191c2VyICpidWZmZXIsCiAJCQkJLyogbnVsbGlmeWlu ZyBoZHIgb2YgdGhlIGV2ZW50IGluIHVzZXIgYnVmZmVyICovCiAJCQkJaWYgKGNvcHlfdG9fdXNl cihidWZmZXIgKyByZXQsICZkdW1teV9oZHIsCiAJCQkJCQkgc2l6ZW9mKGR1bW15X2hkcikpKSB7 Ci0JCQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJCQlkZXZfZXJy KGh5X2Rydl9wcml2LT5kZXYsCiAJCQkJCQkiZmFpbGVkIHRvIG51bGxpZnkgaW52YWxpZCBoZHIg YWxyZWFkeSBpbiB1c2Vyc3BhY2VcbiIpOwogCQkJCX0KIApAQCAtMTgwLDIzICsyMDAsMzAgQEAg c3NpemVfdCBoeXBlcl9kbWFidWZfZXZlbnRfcmVhZChzdHJ1Y3QgZmlsZSAqZmlscCwgY2hhciBf X3VzZXIgKmJ1ZmZlciwKIAkJCX0KIAogCQkJcmV0ICs9IGUtPmV2ZW50X2RhdGEuaGRyLnNpemU7 Ci0JCQloeXBlcl9kbWFidWZfcHJpdmF0ZS5jdXJyX251bV9ldmVudC0tOworCQkJaHlfZHJ2X3By aXYtPnBlbmRpbmctLTsKIAkJCWtmcmVlKGUpOwogCQl9CiAJfQogCi0JbXV0ZXhfdW5sb2NrKCZo eXBlcl9kbWFidWZfcHJpdmF0ZS5ldmVudF9yZWFkX2xvY2spOworCW11dGV4X3VubG9jaygmaHlf ZHJ2X3ByaXYtPmV2ZW50X3JlYWRfbG9jayk7CiAKIAlyZXR1cm4gcmV0OwogfQogCisjZW5kaWYK Kwogc3RhdGljIHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgaHlwZXJfZG1hYnVmX2RyaXZlcl9mb3Bz ID0KIHsKIAkub3duZXIgPSBUSElTX01PRFVMRSwKIAkub3BlbiA9IGh5cGVyX2RtYWJ1Zl9vcGVu LAogCS5yZWxlYXNlID0gaHlwZXJfZG1hYnVmX3JlbGVhc2UsCisKKy8qIHBvbGwgYW5kIHJlYWQg aW50ZXJmYWNlcyBhcmUgbmVlZGVkIG9ubHkgZm9yIGV2ZW50LXBvbGxpbmcgKi8KKyNpZmRlZiBD T05GSUdfSFlQRVJfRE1BQlVGX0VWRU5UX0dFTgogCS5yZWFkID0gaHlwZXJfZG1hYnVmX2V2ZW50 X3JlYWQsCiAJLnBvbGwgPSBoeXBlcl9kbWFidWZfZXZlbnRfcG9sbCwKKyNlbmRpZgorCiAJLnVu bG9ja2VkX2lvY3RsID0gaHlwZXJfZG1hYnVmX2lvY3RsLAogfTsKIApAQCAtMjE3LDE3ICsyNDQs MTcgQEAgaW50IHJlZ2lzdGVyX2RldmljZSh2b2lkKQogCQlyZXR1cm4gcmV0OwogCX0KIAotCWh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSA9IGh5cGVyX2RtYWJ1Zl9taXNjZGV2LnRoaXNfZGV2 aWNlOworCWh5X2Rydl9wcml2LT5kZXYgPSBoeXBlcl9kbWFidWZfbWlzY2Rldi50aGlzX2Rldmlj ZTsKIAogCS8qIFRPRE86IENoZWNrIGlmIHRoZXJlIGlzIGEgZGlmZmVyZW50IHdheSB0byBpbml0 aWFsaXplIGRtYSBtYXNrIG5pY2VseSAqLwotCWRtYV9jb2VyY2VfbWFza19hbmRfY29oZXJlbnQo aHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCBETUFfQklUX01BU0soNjQpKTsKKwlkbWFfY29l cmNlX21hc2tfYW5kX2NvaGVyZW50KGh5X2Rydl9wcml2LT5kZXYsIERNQV9CSVRfTUFTSyg2NCkp OwogCiAJcmV0dXJuIHJldDsKIH0KIAogdm9pZCB1bnJlZ2lzdGVyX2RldmljZSh2b2lkKQogewot CWRldl9pbmZvKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwlkZXZfaW5mbyhoeV9kcnZf cHJpdi0+ZGV2LAogCQkiaHlwZXJfZG1hYnVmOiB1bnJlZ2lzdGVyX2RldmljZSgpIGlzIGNhbGxl ZFxuIik7CiAKIAltaXNjX2RlcmVnaXN0ZXIoJmh5cGVyX2RtYWJ1Zl9taXNjZGV2KTsKQEAgLTIz OSw5ICsyNjYsMTMgQEAgc3RhdGljIGludCBfX2luaXQgaHlwZXJfZG1hYnVmX2Rydl9pbml0KHZv aWQpCiAKIAlwcmludGsoIEtFUk5fTk9USUNFICJoeXBlcl9kbWFidWZfc3RhcnRpbmc6IEluaXRp YWxpemF0aW9uIHN0YXJ0ZWRcbiIpOwogCi0JbXV0ZXhfaW5pdCgmaHlwZXJfZG1hYnVmX3ByaXZh dGUubG9jayk7Ci0JbXV0ZXhfaW5pdCgmaHlwZXJfZG1hYnVmX3ByaXZhdGUuZXZlbnRfcmVhZF9s b2NrKTsKLQlzcGluX2xvY2tfaW5pdCgmaHlwZXJfZG1hYnVmX3ByaXZhdGUuZXZlbnRfbG9jayk7 CisJaHlfZHJ2X3ByaXYgPSBrY2FsbG9jKDEsIHNpemVvZihzdHJ1Y3QgaHlwZXJfZG1hYnVmX3By aXZhdGUpLAorCQkJICAgICAgR0ZQX0tFUk5FTCk7CisKKwlpZiAoIWh5X2Rydl9wcml2KSB7CisJ CXByaW50ayggS0VSTl9FUlIgImh5cGVyX2RtYWJ1ZjogRmFpbGVkIHRvIGNyZWF0ZSBkcnZcbiIp OworCQlyZXR1cm4gLTE7CisJfQogCiAJcmV0ID0gcmVnaXN0ZXJfZGV2aWNlKCk7CiAJaWYgKHJl dCA8IDApIHsKQEAgLTI1MSw2NCArMjgyLDcyIEBAIHN0YXRpYyBpbnQgX19pbml0IGh5cGVyX2Rt YWJ1Zl9kcnZfaW5pdCh2b2lkKQogLyogY3VycmVudGx5IG9ubHkgc3VwcG9ydHMgWEVOIGh5cGVy dmlzb3IgKi8KIAogI2lmZGVmIENPTkZJR19IWVBFUl9ETUFCVUZfWEVOCi0JaHlwZXJfZG1hYnVm X3ByaXZhdGUuYmFja2VuZF9vcHMgPSAmeGVuX2JhY2tlbmRfb3BzOworCWh5X2Rydl9wcml2LT5i YWNrZW5kX29wcyA9ICZ4ZW5fYmFja2VuZF9vcHM7CiAjZWxzZQotCWh5cGVyX2RtYWJ1Zl9wcml2 YXRlLmJhY2tlbmRfb3BzID0gTlVMTDsKKwloeV9kcnZfcHJpdi0+YmFja2VuZF9vcHMgPSBOVUxM OwogCXByaW50ayggS0VSTl9FUlIgImh5cGVyX2RtYWJ1ZiBkcnYgY3VycmVudGx5IHN1cHBvcnRz IFhFTiBvbmx5LlxuIik7CiAjZW5kaWYKIAotCWlmIChoeXBlcl9kbWFidWZfcHJpdmF0ZS5iYWNr ZW5kX29wcyA9PSBOVUxMKSB7CisJaWYgKGh5X2Rydl9wcml2LT5iYWNrZW5kX29wcyA9PSBOVUxM KSB7CiAJCXByaW50ayggS0VSTl9FUlIgIkh5cGVyX2RtYWJ1ZjogZmFpbGVkIHRvIGJlIGxvYWRl ZCAtIG5vIGJhY2tlbmQgZm91bmRcbiIpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0JbXV0ZXhfbG9j aygmaHlwZXJfZG1hYnVmX3ByaXZhdGUubG9jayk7CisJLyogaW5pdGlhbGl6aW5nIG11dGV4ZXMg YW5kIGEgc3BpbmxvY2sgKi8KKwltdXRleF9pbml0KCZoeV9kcnZfcHJpdi0+bG9jayk7CisKKwlt dXRleF9sb2NrKCZoeV9kcnZfcHJpdi0+bG9jayk7CiAKLQloeXBlcl9kbWFidWZfcHJpdmF0ZS5i YWNrZW5kX2luaXRpYWxpemVkID0gZmFsc2U7CisJaHlfZHJ2X3ByaXYtPmluaXRpYWxpemVkID0g ZmFsc2U7CiAKLQlkZXZfaW5mbyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJZGV2X2lu Zm8oaHlfZHJ2X3ByaXYtPmRldiwKIAkJICJpbml0aWFsaXppbmcgZGF0YWJhc2UgZm9yIGltcG9y dGVkL2V4cG9ydGVkIGRtYWJ1ZnNcbiIpOwogCiAJLyogZGV2aWNlIHN0cnVjdHVyZSBpbml0aWFs aXphdGlvbiAqLwogCS8qIGN1cnJlbnRseSBvbmx5IGRvZXMgd29yay1xdWV1ZSBpbml0aWFsaXph dGlvbiAqLwotCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLndvcmtfcXVldWUgPSBjcmVhdGVfd29ya3F1 ZXVlKCJoeXBlcl9kbWFidWZfd3F1ZXVlIik7CisJaHlfZHJ2X3ByaXYtPndvcmtfcXVldWUgPSBj cmVhdGVfd29ya3F1ZXVlKCJoeXBlcl9kbWFidWZfd3F1ZXVlIik7CiAKIAlyZXQgPSBoeXBlcl9k bWFidWZfdGFibGVfaW5pdCgpOwogCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1h YnVmX3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiZmFp bGVkIHRvIGluaXRpYWxpemUgdGFibGUgZm9yIGV4cG9ydGVkL2ltcG9ydGVkIGVudHJpZXNcbiIp OwogCQlyZXR1cm4gcmV0OwogCX0KIAogI2lmZGVmIENPTkZJR19IWVBFUl9ETUFCVUZfU1lTRlMK LQlyZXQgPSBoeXBlcl9kbWFidWZfcmVnaXN0ZXJfc3lzZnMoaHlwZXJfZG1hYnVmX3ByaXZhdGUu ZGV2aWNlKTsKKwlyZXQgPSBoeXBlcl9kbWFidWZfcmVnaXN0ZXJfc3lzZnMoaHlfZHJ2X3ByaXYt PmRldik7CiAJaWYgKHJldCA8IDApIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5k ZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSJmYWlsZWQgdG8gaW5pdGlh bGl6ZSBzeXNmc1xuIik7CiAJCXJldHVybiByZXQ7CiAJfQogI2VuZGlmCiAKKyNpZmRlZiBDT05G SUdfSFlQRVJfRE1BQlVGX0VWRU5UX0dFTgorCW11dGV4X2luaXQoJmh5X2Rydl9wcml2LT5ldmVu dF9yZWFkX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZoeV9kcnZfcHJpdi0+ZXZlbnRfbG9jayk7 CisKIAkvKiBJbml0aWFsaXplIGV2ZW50IHF1ZXVlICovCi0JSU5JVF9MSVNUX0hFQUQoJmh5cGVy X2RtYWJ1Zl9wcml2YXRlLmV2ZW50X2xpc3QpOwotCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmh5cGVy X2RtYWJ1Zl9wcml2YXRlLmV2ZW50X3dhaXQpOworCUlOSVRfTElTVF9IRUFEKCZoeV9kcnZfcHJp di0+ZXZlbnRfbGlzdCk7CisJaW5pdF93YWl0cXVldWVfaGVhZCgmaHlfZHJ2X3ByaXYtPmV2ZW50 X3dhaXQpOwogCi0JaHlwZXJfZG1hYnVmX3ByaXZhdGUuY3Vycl9udW1fZXZlbnQgPSAwOwotCWh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmV4aXRlZCA9IGZhbHNlOworCS8qIHJlc2V0dGluZyBudW1iZXIg b2YgcGVuZGluZyBldmVudHMgKi8KKwloeV9kcnZfcHJpdi0+cGVuZGluZyA9IDA7CisjZW5kaWYK IAotCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRvbWlkID0gaHlwZXJfZG1hYnVmX3ByaXZhdGUuYmFj a2VuZF9vcHMtPmdldF92bV9pZCgpOworCWh5X2Rydl9wcml2LT5kb21pZCA9IGh5X2Rydl9wcml2 LT5iYWNrZW5kX29wcy0+Z2V0X3ZtX2lkKCk7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZfcHJpdmF0 ZS5iYWNrZW5kX29wcy0+aW5pdF9jb21tX2VudigpOworCXJldCA9IGh5X2Rydl9wcml2LT5iYWNr ZW5kX29wcy0+aW5pdF9jb21tX2VudigpOwogCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9kYmcoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJ CQkiZmFpbGVkIHRvIGluaXRpYWxpemUgY29tbS1lbnYgYnV0IGl0IHdpbGwgcmUtYXR0ZW1wdC5c biIpOwogCX0gZWxzZSB7Ci0JCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLmJhY2tlbmRfaW5pdGlhbGl6 ZWQgPSB0cnVlOworCQloeV9kcnZfcHJpdi0+aW5pdGlhbGl6ZWQgPSB0cnVlOwogCX0KIAotCW11 dGV4X3VubG9jaygmaHlwZXJfZG1hYnVmX3ByaXZhdGUubG9jayk7CisJbXV0ZXhfdW5sb2NrKCZo eV9kcnZfcHJpdi0+bG9jayk7CiAKLQlkZXZfaW5mbyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZp Y2UsCisJZGV2X2luZm8oaHlfZHJ2X3ByaXYtPmRldiwKIAkJIkZpbmlzaGluZyB1cCBpbml0aWFs aXphdGlvbiBvZiBoeXBlcl9kbWFidWYgZHJ2XG4iKTsKIAogCS8qIGludGVycnVwdCBmb3IgY29t bSBzaG91bGQgYmUgcmVnaXN0ZXJlZCBoZXJlOiAqLwpAQCAtMzE4LDM0ICszNTcsMzkgQEAgc3Rh dGljIGludCBfX2luaXQgaHlwZXJfZG1hYnVmX2Rydl9pbml0KHZvaWQpCiBzdGF0aWMgdm9pZCBo eXBlcl9kbWFidWZfZHJ2X2V4aXQodm9pZCkKIHsKICNpZmRlZiBDT05GSUdfSFlQRVJfRE1BQlVG X1NZU0ZTCi0JaHlwZXJfZG1hYnVmX3VucmVnaXN0ZXJfc3lzZnMoaHlwZXJfZG1hYnVmX3ByaXZh dGUuZGV2aWNlKTsKKwloeXBlcl9kbWFidWZfdW5yZWdpc3Rlcl9zeXNmcyhoeV9kcnZfcHJpdi0+ ZGV2KTsKICNlbmRpZgogCi0JbXV0ZXhfbG9jaygmaHlwZXJfZG1hYnVmX3ByaXZhdGUubG9jayk7 CisJbXV0ZXhfbG9jaygmaHlfZHJ2X3ByaXYtPmxvY2spOwogCiAJLyogaGFzaCB0YWJsZXMgZm9y IGV4cG9ydC9pbXBvcnQgZW50cmllcyBhbmQgcmluZ19pbmZvcyAqLwogCWh5cGVyX2RtYWJ1Zl90 YWJsZV9kZXN0cm95KCk7CiAKLQloeXBlcl9kbWFidWZfcHJpdmF0ZS5iYWNrZW5kX29wcy0+ZGVz dHJveV9jb21tKCk7CisJaHlfZHJ2X3ByaXYtPmJhY2tlbmRfb3BzLT5kZXN0cm95X2NvbW0oKTsK IAogCS8qIGRlc3Ryb3kgd29ya3F1ZXVlICovCi0JaWYgKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLndv cmtfcXVldWUpCi0JCWRlc3Ryb3lfd29ya3F1ZXVlKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLndvcmtf cXVldWUpOworCWlmIChoeV9kcnZfcHJpdi0+d29ya19xdWV1ZSkKKwkJZGVzdHJveV93b3JrcXVl dWUoaHlfZHJ2X3ByaXYtPndvcmtfcXVldWUpOwogCiAJLyogZGVzdHJveSBpZF9xdWV1ZSAqLwot CWlmIChoeXBlcl9kbWFidWZfcHJpdmF0ZS5pZF9xdWV1ZSkKKwlpZiAoaHlfZHJ2X3ByaXYtPmlk X3F1ZXVlKQogCQlkZXN0cm95X3JldXNhYmxlX2xpc3QoKTsKIAotCWh5cGVyX2RtYWJ1Zl9wcml2 YXRlLmV4aXRlZCA9IHRydWU7Ci0KKyNpZmRlZiBDT05GSUdfSFlQRVJfRE1BQlVGX0VWRU5UX0dF TgogCS8qIGNsZWFuIHVwIGV2ZW50IHF1ZXVlICovCiAJaHlwZXJfZG1hYnVmX2V2ZW50c19yZWxl YXNlKCk7CisjZW5kaWYKIAotCW11dGV4X3VubG9jaygmaHlwZXJfZG1hYnVmX3ByaXZhdGUubG9j ayk7CisJbXV0ZXhfdW5sb2NrKCZoeV9kcnZfcHJpdi0+bG9jayk7CiAKLQlkZXZfaW5mbyhoeXBl cl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJZGV2X2luZm8oaHlfZHJ2X3ByaXYtPmRldiwKIAkJ ICJoeXBlcl9kbWFidWYgZHJpdmVyOiBFeGl0aW5nXG4iKTsKIAorCWlmIChoeV9kcnZfcHJpdikg eworCQlrZnJlZShoeV9kcnZfcHJpdik7CisJCWh5X2Rydl9wcml2ID0gTlVMTDsKKwl9CisKIAl1 bnJlZ2lzdGVyX2RldmljZSgpOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9k bWFidWYvaHlwZXJfZG1hYnVmX2Rydi5oIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9kcnYuaAppbmRleCBhNGFjZGQ5Zi4uMmVhZDQxYiAxMDA2NDQKLS0tIGEvZHJpdmVy cy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuaAorKysgYi9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2Rydi5oCkBAIC0zNiw3ICszNiw3IEBAIHN0cnVjdCBo eXBlcl9kbWFidWZfZXZlbnQgewogfTsKIAogc3RydWN0IGh5cGVyX2RtYWJ1Zl9wcml2YXRlIHsK LSAgICAgICAgc3RydWN0IGRldmljZSAqZGV2aWNlOworICAgICAgICBzdHJ1Y3QgZGV2aWNlICpk ZXY7CiAKIAkvKiBWTShkb21haW4pIGlkIG9mIGN1cnJlbnQgVk0gaW5zdGFuY2UgKi8KIAlpbnQg ZG9taWQ7CkBAIC01NSw3ICs1NSw3IEBAIHN0cnVjdCBoeXBlcl9kbWFidWZfcHJpdmF0ZSB7CiAJ c3RydWN0IG11dGV4IGxvY2s7CiAKIAkvKiBmbGFnIHRoYXQgc2hvd3Mgd2hldGhlciBiYWNrZW5k IGlzIGluaXRpYWxpemVkICovCi0JYm9vbCBiYWNrZW5kX2luaXRpYWxpemVkOworCWJvb2wgaW5p dGlhbGl6ZWQ7CiAKICAgICAgICAgd2FpdF9xdWV1ZV9oZWFkX3QgZXZlbnRfd2FpdDsKICAgICAg ICAgc3RydWN0IGxpc3RfaGVhZCBldmVudF9saXN0OwpAQCAtNjMsMTAgKzYzLDggQEAgc3RydWN0 IGh5cGVyX2RtYWJ1Zl9wcml2YXRlIHsKIAlzcGlubG9ja190IGV2ZW50X2xvY2s7CiAJc3RydWN0 IG11dGV4IGV2ZW50X3JlYWRfbG9jazsKIAotCWludCBjdXJyX251bV9ldmVudDsKLQotCS8qIGlu ZGljYXRlIHdoZXRoZXIgdGhlIGRyaXZlciBpcyB1bmxvYWRlZCAqLwotCWJvb2wgZXhpdGVkOwor CS8qICMgb2YgcGVuZGluZyBldmVudHMgKi8KKwlpbnQgcGVuZGluZzsKIH07CiAKIHN0cnVjdCBs aXN0X3JldXNhYmxlX2lkIHsKQEAgLTEwOCw0ICsxMDYsNyBAQCBzdHJ1Y3QgaHlwZXJfZG1hYnVm X2JhY2tlbmRfb3BzIHsKIAlpbnQgKCpzZW5kX3JlcSkoaW50LCBzdHJ1Y3QgaHlwZXJfZG1hYnVm X3JlcSAqLCBpbnQpOwogfTsKIAorLyogZXhwb3J0aW5nIGdsb2JhbCBkcnYgcHJpdmF0ZSBpbmZv ICovCitleHRlcm4gc3RydWN0IGh5cGVyX2RtYWJ1Zl9wcml2YXRlICpoeV9kcnZfcHJpdjsKKwog I2VuZGlmIC8qIF9fTElOVVhfUFVCTElDX0hZUEVSX0RNQUJVRl9EUlZfSF9fICovCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2V2ZW50LmMgYi9kcml2 ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2V2ZW50LmMKaW5kZXggM2UxNDk4Yy4u MDQ5OGNkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1 Zl9ldmVudC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZXZl bnQuYwpAQCAtMzIsMzcgKzMyLDMzIEBACiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1 ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KLSNpbmNsdWRl IDx4ZW4vZ3JhbnRfdGFibGUuaD4KLSNpbmNsdWRlIDxhc20veGVuL3BhZ2UuaD4KICNpbmNsdWRl ICJoeXBlcl9kbWFidWZfZHJ2LmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX3N0cnVjdC5oIgog I2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9saXN0LmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2V2 ZW50LmgiCiAKLWV4dGVybiBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3ByaXZhdGUgaHlwZXJfZG1hYnVm X3ByaXZhdGU7Ci0KIHN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9zZW5kX2V2ZW50X2xvY2tlZChz dHJ1Y3QgaHlwZXJfZG1hYnVmX2V2ZW50ICplKQogewogCXN0cnVjdCBoeXBlcl9kbWFidWZfZXZl bnQgKm9sZGVzdDsKIAotCWFzc2VydF9zcGluX2xvY2tlZCgmaHlwZXJfZG1hYnVmX3ByaXZhdGUu ZXZlbnRfbG9jayk7CisJYXNzZXJ0X3NwaW5fbG9ja2VkKCZoeV9kcnZfcHJpdi0+ZXZlbnRfbG9j ayk7CiAKIAkvKiBjaGVjayBjdXJyZW50IG51bWJlciBvZiBldmVudCB0aGVuIGlmIGl0IGhpdHMg dGhlIG1heCBudW0gYWxsb3dlZAogCSAqIHRoZW4gcmVtb3ZlIHRoZSBvbGRlc3QgZXZlbnQgaW4g dGhlIGxpc3QgKi8KLQlpZiAoaHlwZXJfZG1hYnVmX3ByaXZhdGUuY3Vycl9udW1fZXZlbnQgPiBN QVhfREVQVEhfRVZFTlRfUVVFVUUgLSAxKSB7Ci0JCW9sZGVzdCA9IGxpc3RfZmlyc3RfZW50cnko Jmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV2ZW50X2xpc3QsCisJaWYgKGh5X2Rydl9wcml2LT5wZW5k aW5nID4gTUFYX0RFUFRIX0VWRU5UX1FVRVVFIC0gMSkgeworCQlvbGRlc3QgPSBsaXN0X2ZpcnN0 X2VudHJ5KCZoeV9kcnZfcHJpdi0+ZXZlbnRfbGlzdCwKIAkJCQlzdHJ1Y3QgaHlwZXJfZG1hYnVm X2V2ZW50LCBsaW5rKTsKIAkJbGlzdF9kZWwoJm9sZGVzdC0+bGluayk7Ci0JCWh5cGVyX2RtYWJ1 Zl9wcml2YXRlLmN1cnJfbnVtX2V2ZW50LS07CisJCWh5X2Rydl9wcml2LT5wZW5kaW5nLS07CiAJ CWtmcmVlKG9sZGVzdCk7CiAJfQogCiAJbGlzdF9hZGRfdGFpbCgmZS0+bGluaywKLQkJICAgICAg Jmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV2ZW50X2xpc3QpOworCQkgICAgICAmaHlfZHJ2X3ByaXYt PmV2ZW50X2xpc3QpOwogCi0JaHlwZXJfZG1hYnVmX3ByaXZhdGUuY3Vycl9udW1fZXZlbnQrKzsK KwloeV9kcnZfcHJpdi0+cGVuZGluZysrOwogCi0Jd2FrZV91cF9pbnRlcnJ1cHRpYmxlKCZoeXBl cl9kbWFidWZfcHJpdmF0ZS5ldmVudF93YWl0KTsKKwl3YWtlX3VwX2ludGVycnVwdGlibGUoJmh5 X2Rydl9wcml2LT5ldmVudF93YWl0KTsKIH0KIAogdm9pZCBoeXBlcl9kbWFidWZfZXZlbnRzX3Jl bGVhc2UoKQpAQCAtNzAsMzQgKzY2LDM0IEBAIHZvaWQgaHlwZXJfZG1hYnVmX2V2ZW50c19yZWxl YXNlKCkKIAlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2V2ZW50ICplLCAqZXQ7CiAJdW5zaWduZWQgbG9u ZyBpcnFmbGFnczsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZoeXBlcl9kbWFidWZfcHJpdmF0ZS5l dmVudF9sb2NrLCBpcnFmbGFncyk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmh5X2Rydl9wcml2LT5l dmVudF9sb2NrLCBpcnFmbGFncyk7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoZSwgZXQs ICZoeXBlcl9kbWFidWZfcHJpdmF0ZS5ldmVudF9saXN0LAorCWxpc3RfZm9yX2VhY2hfZW50cnlf c2FmZShlLCBldCwgJmh5X2Rydl9wcml2LT5ldmVudF9saXN0LAogCQkJCSBsaW5rKSB7CiAJCWxp c3RfZGVsKCZlLT5saW5rKTsKIAkJa2ZyZWUoZSk7Ci0JCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLmN1 cnJfbnVtX2V2ZW50LS07CisJCWh5X2Rydl9wcml2LT5wZW5kaW5nLS07CiAJfQogCi0JaWYgKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmN1cnJfbnVtX2V2ZW50KSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1h YnVmX3ByaXZhdGUuZGV2aWNlLAorCWlmIChoeV9kcnZfcHJpdi0+cGVuZGluZykgeworCQlkZXZf ZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkicG9zc2libGUgbGVhayBvbiBldmVudF9saXN0XG4i KTsKIAl9CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZoeXBlcl9kbWFidWZfcHJpdmF0ZS5l dmVudF9sb2NrLCBpcnFmbGFncyk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaHlfZHJ2X3By aXYtPmV2ZW50X2xvY2ssIGlycWZsYWdzKTsKIH0KIAogaW50IGh5cGVyX2RtYWJ1Zl9pbXBvcnRf ZXZlbnQoaHlwZXJfZG1hYnVmX2lkX3QgaGlkKQogewogCXN0cnVjdCBoeXBlcl9kbWFidWZfZXZl bnQgKmU7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWRf c2d0X2luZm87CisJc3RydWN0IGltcG9ydGVkX3NndF9pbmZvICppbXBvcnRlZDsKIAogCXVuc2ln bmVkIGxvbmcgaXJxZmxhZ3M7CiAKLQlpbXBvcnRlZF9zZ3RfaW5mbyA9IGh5cGVyX2RtYWJ1Zl9m aW5kX2ltcG9ydGVkKGhpZCk7CisJaW1wb3J0ZWQgPSBoeXBlcl9kbWFidWZfZmluZF9pbXBvcnRl ZChoaWQpOwogCi0JaWYgKCFpbXBvcnRlZF9zZ3RfaW5mbykgewotCQlkZXZfZXJyKGh5cGVyX2Rt YWJ1Zl9wcml2YXRlLmRldmljZSwKKwlpZiAoIWltcG9ydGVkKSB7CisJCWRldl9lcnIoaHlfZHJ2 X3ByaXYtPmRldiwKIAkJCSJjYW4ndCBmaW5kIGltcG9ydGVkX3NndF9pbmZvIGluIHRoZSBsaXN0 XG4iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQpAQCAtMTA1LDI5ICsxMDEsMjkgQEAgaW50IGh5 cGVyX2RtYWJ1Zl9pbXBvcnRfZXZlbnQoaHlwZXJfZG1hYnVmX2lkX3QgaGlkKQogCWUgPSBremFs bG9jKHNpemVvZigqZSksIEdGUF9LRVJORUwpOwogCiAJaWYgKCFlKSB7Ci0JCWRldl9lcnIoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJ CQkibm8gc3BhY2UgbGVmdFxuIik7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KIAogCWUtPmV2ZW50 X2RhdGEuaGRyLmV2ZW50X3R5cGUgPSBIWVBFUl9ETUFCVUZfTkVXX0lNUE9SVDsKIAllLT5ldmVu dF9kYXRhLmhkci5oaWQgPSBoaWQ7Ci0JZS0+ZXZlbnRfZGF0YS5kYXRhID0gKHZvaWQqKWltcG9y dGVkX3NndF9pbmZvLT5wcml2OwotCWUtPmV2ZW50X2RhdGEuaGRyLnNpemUgPSBpbXBvcnRlZF9z Z3RfaW5mby0+c3pfcHJpdjsKKwllLT5ldmVudF9kYXRhLmRhdGEgPSAodm9pZCopaW1wb3J0ZWQt PnByaXY7CisJZS0+ZXZlbnRfZGF0YS5oZHIuc2l6ZSA9IGltcG9ydGVkLT5zel9wcml2OwogCi0J c3Bpbl9sb2NrX2lycXNhdmUoJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV2ZW50X2xvY2ssIGlycWZs YWdzKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmaHlfZHJ2X3ByaXYtPmV2ZW50X2xvY2ssIGlycWZs YWdzKTsKIAogCWh5cGVyX2RtYWJ1Zl9zZW5kX2V2ZW50X2xvY2tlZChlKTsKIAotCXNwaW5fdW5s b2NrX2lycXJlc3RvcmUoJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV2ZW50X2xvY2ssIGlycWZsYWdz KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZoeV9kcnZfcHJpdi0+ZXZlbnRfbG9jaywgaXJx ZmxhZ3MpOwogCi0JZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkiZXZl bnQgbnVtYmVyID0gJWQgOiIsIGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmN1cnJfbnVtX2V2ZW50KTsK KwlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCisJCSJldmVudCBudW1iZXIgPSAlZCA6IiwgaHlf ZHJ2X3ByaXYtPnBlbmRpbmcpOwogCi0JZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZp Y2UsCi0JCQkiZ2VuZXJhdGluZyBldmVudHMgZm9yIHslZCwgJWQsICVkLCAlZH1cbiIsCi0JCQlp bXBvcnRlZF9zZ3RfaW5mby0+aGlkLmlkLCBpbXBvcnRlZF9zZ3RfaW5mby0+aGlkLnJuZ19rZXlb MF0sCi0JCQlpbXBvcnRlZF9zZ3RfaW5mby0+aGlkLnJuZ19rZXlbMV0sIGltcG9ydGVkX3NndF9p bmZvLT5oaWQucm5nX2tleVsyXSk7CisJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LAorCQkiZ2Vu ZXJhdGluZyBldmVudHMgZm9yIHslZCwgJWQsICVkLCAlZH1cbiIsCisJCWltcG9ydGVkLT5oaWQu aWQsIGltcG9ydGVkLT5oaWQucm5nX2tleVswXSwKKwkJaW1wb3J0ZWQtPmhpZC5ybmdfa2V5WzFd LCBpbXBvcnRlZC0+aGlkLnJuZ19rZXlbMl0pOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQg YS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lkLmMgYi9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lkLmMKaW5kZXggY2NjZGMxOS4uZTI0NjZjNyAx MDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pZC5jCisr KyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaWQuYwpAQCAtMzMsMTcg KzMzLDE1IEBACiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX2lkLmgiCiAjaW5jbHVkZSAiaHlwZXJf ZG1hYnVmX21zZy5oIgogCi1leHRlcm4gc3RydWN0IGh5cGVyX2RtYWJ1Zl9wcml2YXRlIGh5cGVy X2RtYWJ1Zl9wcml2YXRlOwotCiB2b2lkIHN0b3JlX3JldXNhYmxlX2hpZChoeXBlcl9kbWFidWZf aWRfdCBoaWQpCiB7Ci0Jc3RydWN0IGxpc3RfcmV1c2FibGVfaWQgKnJldXNhYmxlX2hlYWQgPSBo eXBlcl9kbWFidWZfcHJpdmF0ZS5pZF9xdWV1ZTsKKwlzdHJ1Y3QgbGlzdF9yZXVzYWJsZV9pZCAq cmV1c2FibGVfaGVhZCA9IGh5X2Rydl9wcml2LT5pZF9xdWV1ZTsKIAlzdHJ1Y3QgbGlzdF9yZXVz YWJsZV9pZCAqbmV3X3JldXNhYmxlOwogCiAJbmV3X3JldXNhYmxlID0ga21hbGxvYyhzaXplb2Yo Km5ld19yZXVzYWJsZSksIEdGUF9LRVJORUwpOwogCiAJaWYgKCFuZXdfcmV1c2FibGUpIHsKLQkJ ZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2X3By aXYtPmRldiwKIAkJCSJObyBtZW1vcnkgbGVmdCB0byBiZSBhbGxvY2F0ZWRcbiIpOwogCQlyZXR1 cm47CiAJfQpAQCAtNTUsNyArNTMsNyBAQCB2b2lkIHN0b3JlX3JldXNhYmxlX2hpZChoeXBlcl9k bWFidWZfaWRfdCBoaWQpCiAKIHN0YXRpYyBoeXBlcl9kbWFidWZfaWRfdCByZXRyaWV2ZV9yZXVz YWJsZV9oaWQodm9pZCkKIHsKLQlzdHJ1Y3QgbGlzdF9yZXVzYWJsZV9pZCAqcmV1c2FibGVfaGVh ZCA9IGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmlkX3F1ZXVlOworCXN0cnVjdCBsaXN0X3JldXNhYmxl X2lkICpyZXVzYWJsZV9oZWFkID0gaHlfZHJ2X3ByaXYtPmlkX3F1ZXVlOwogCWh5cGVyX2RtYWJ1 Zl9pZF90IGhpZCA9IHstMSwgezAsMCwwfX07CiAKIAkvKiBjaGVjayB0aGVyZSBpcyByZXVzYWJs ZSBpZCAqLwpAQCAtNzQsNyArNzIsNyBAQCBzdGF0aWMgaHlwZXJfZG1hYnVmX2lkX3QgcmV0cmll dmVfcmV1c2FibGVfaGlkKHZvaWQpCiAKIHZvaWQgZGVzdHJveV9yZXVzYWJsZV9saXN0KHZvaWQp CiB7Ci0Jc3RydWN0IGxpc3RfcmV1c2FibGVfaWQgKnJldXNhYmxlX2hlYWQgPSBoeXBlcl9kbWFi dWZfcHJpdmF0ZS5pZF9xdWV1ZTsKKwlzdHJ1Y3QgbGlzdF9yZXVzYWJsZV9pZCAqcmV1c2FibGVf aGVhZCA9IGh5X2Rydl9wcml2LT5pZF9xdWV1ZTsKIAlzdHJ1Y3QgbGlzdF9yZXVzYWJsZV9pZCAq dGVtcF9oZWFkOwogCiAJaWYgKHJldXNhYmxlX2hlYWQpIHsKQEAgLTEwMywxNCArMTAxLDE0IEBA IGh5cGVyX2RtYWJ1Zl9pZF90IGh5cGVyX2RtYWJ1Zl9nZXRfaGlkKHZvaWQpCiAJCXJldXNhYmxl X2hlYWQgPSBrbWFsbG9jKHNpemVvZigqcmV1c2FibGVfaGVhZCksIEdGUF9LRVJORUwpOwogCiAJ CWlmICghcmV1c2FibGVfaGVhZCkgewotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5k ZXZpY2UsCisJCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkJIk5vIG1lbW9yeSBsZWZ0 IHRvIGJlIGFsbG9jYXRlZFxuIik7CiAJCQlyZXR1cm4gKGh5cGVyX2RtYWJ1Zl9pZF90KXstMSwg ezAsMCwwfX07CiAJCX0KIAogCQlyZXVzYWJsZV9oZWFkLT5oaWQuaWQgPSAtMTsgLyogbGlzdCBo ZWFkIGhhcyBhbiBpbnZhbGlkIGNvdW50ICovCiAJCUlOSVRfTElTVF9IRUFEKCZyZXVzYWJsZV9o ZWFkLT5saXN0KTsKLQkJaHlwZXJfZG1hYnVmX3ByaXZhdGUuaWRfcXVldWUgPSByZXVzYWJsZV9o ZWFkOworCQloeV9kcnZfcHJpdi0+aWRfcXVldWUgPSByZXVzYWJsZV9oZWFkOwogCX0KIAogCWhp ZCA9IHJldHJpZXZlX3JldXNhYmxlX2hpZCgpOwpAQCAtMTE5LDcgKzExNyw3IEBAIGh5cGVyX2Rt YWJ1Zl9pZF90IGh5cGVyX2RtYWJ1Zl9nZXRfaGlkKHZvaWQpCiAJICogYW5kIGNvdW50IGlzIGxl c3MgdGhhbiBtYXhpbXVtIGFsbG93ZWQKIAkgKi8KIAlpZiAoaGlkLmlkID09IC0xICYmIGNvdW50 IDwgSFlQRVJfRE1BQlVGX0lEX01BWCkgewotCQloaWQuaWQgPSBIWVBFUl9ETUFCVUZfSURfQ1JF QVRFKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRvbWlkLCBjb3VudCsrKTsKKwkJaGlkLmlkID0gSFlQ RVJfRE1BQlVGX0lEX0NSRUFURShoeV9kcnZfcHJpdi0+ZG9taWQsIGNvdW50KyspOwogCX0KIAog CS8qIHJhbmRvbSBkYXRhIGVtYmVkZGVkIGluIHRoZSBpZCBmb3Igc2VjdXJpdHkgKi8KZGlmZiAt LWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYyBiL2Ry aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYwppbmRleCAxNTE5MWMy Li5iMzI4ZGY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1h YnVmX2lvY3RsLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9p b2N0bC5jCkBAIC00NSwxNiArNDUsMTQgQEAKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfb3BzLmgi CiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX3F1ZXJ5LmgiCiAKLWV4dGVybiBzdHJ1Y3QgaHlwZXJf ZG1hYnVmX3ByaXZhdGUgaHlwZXJfZG1hYnVmX3ByaXZhdGU7Ci0KIHN0YXRpYyBpbnQgaHlwZXJf ZG1hYnVmX3R4X2NoX3NldHVwX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQog ewogCXN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfdHhfY2hfc2V0dXAgKnR4X2NoX2F0dHI7Ci0J c3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAqb3BzID0gaHlwZXJfZG1hYnVmX3ByaXZh dGUuYmFja2VuZF9vcHM7CisJc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAqb3BzID0g aHlfZHJ2X3ByaXYtPmJhY2tlbmRfb3BzOwogCWludCByZXQgPSAwOwogCiAJaWYgKCFkYXRhKSB7 Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAidXNlciBkYXRhIGlzIE5V TExcbiIpOworCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsICJ1c2VyIGRhdGEgaXMgTlVMTFxu Iik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAl0eF9jaF9hdHRyID0gKHN0cnVjdCBpb2N0bF9o eXBlcl9kbWFidWZfdHhfY2hfc2V0dXAgKilkYXRhOwpAQCAtNjcsMTEgKzY1LDExIEBAIHN0YXRp YyBpbnQgaHlwZXJfZG1hYnVmX3R4X2NoX3NldHVwX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2 b2lkICpkYXRhKQogc3RhdGljIGludCBoeXBlcl9kbWFidWZfcnhfY2hfc2V0dXBfaW9jdGwoc3Ry dWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRhdGEpCiB7CiAJc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1 Zl9yeF9jaF9zZXR1cCAqcnhfY2hfYXR0cjsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tlbmRf b3BzICpvcHMgPSBoeXBlcl9kbWFidWZfcHJpdmF0ZS5iYWNrZW5kX29wczsKKwlzdHJ1Y3QgaHlw ZXJfZG1hYnVmX2JhY2tlbmRfb3BzICpvcHMgPSBoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHM7CiAJ aW50IHJldCA9IDA7CiAKIAlpZiAoIWRhdGEpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJp dmF0ZS5kZXZpY2UsICJ1c2VyIGRhdGEgaXMgTlVMTFxuIik7CisJCWRldl9lcnIoaHlfZHJ2X3By aXYtPmRldiwgInVzZXIgZGF0YSBpcyBOVUxMXG4iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQog CkBAIC04Miw0OCArODAsNDggQEAgc3RhdGljIGludCBoeXBlcl9kbWFidWZfcnhfY2hfc2V0dXBf aW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRhdGEpCiAJcmV0dXJuIHJldDsKIH0KIAot c3RhdGljIGludCBoeXBlcl9kbWFidWZfc2VuZF9leHBvcnRfbXNnKHN0cnVjdCBoeXBlcl9kbWFi dWZfc2d0X2luZm8gKnNndF9pbmZvLAotCQkJCQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3BhZ2VzX2lu Zm8gKnBhZ2VfaW5mbykKK3N0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX3NlbmRfZXhwb3J0X21zZyhz dHJ1Y3QgZXhwb3J0ZWRfc2d0X2luZm8gKmV4cG9ydGVkLAorCQkJCQlzdHJ1Y3QgcGFnZXNfaW5m byAqcGdfaW5mbykKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tlbmRfb3BzICpvcHMgPSBo eXBlcl9kbWFidWZfcHJpdmF0ZS5iYWNrZW5kX29wczsKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2Jh Y2tlbmRfb3BzICpvcHMgPSBoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHM7CiAJc3RydWN0IGh5cGVy X2RtYWJ1Zl9yZXEgKnJlcTsKLQlpbnQgb3BlcmFuZHNbTUFYX05VTUJFUl9PRl9PUEVSQU5EU10g PSB7MH07CisJaW50IG9wW01BWF9OVU1CRVJfT0ZfT1BFUkFORFNdID0gezB9OwogCWludCByZXQs IGk7CiAKIAkvKiBub3cgY3JlYXRlIHJlcXVlc3QgZm9yIGltcG9ydGVyIHZpYSByaW5nICovCi0J b3BlcmFuZHNbMF0gPSBzZ3RfaW5mby0+aGlkLmlkOworCW9wWzBdID0gZXhwb3J0ZWQtPmhpZC5p ZDsKIAogCWZvciAoaT0wOyBpPDM7IGkrKykKLQkJb3BlcmFuZHNbaSsxXSA9IHNndF9pbmZvLT5o aWQucm5nX2tleVtpXTsKLQotCWlmIChwYWdlX2luZm8pIHsKLQkJb3BlcmFuZHNbNF0gPSBwYWdl X2luZm8tPm5lbnRzOwotCQlvcGVyYW5kc1s1XSA9IHBhZ2VfaW5mby0+ZnJzdF9vZnN0OwotCQlv cGVyYW5kc1s2XSA9IHBhZ2VfaW5mby0+bGFzdF9sZW47Ci0JCW9wZXJhbmRzWzddID0gb3BzLT5z aGFyZV9wYWdlcyAocGFnZV9pbmZvLT5wYWdlcywgc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9yZG9t YWluLAotCQkJCQkJcGFnZV9pbmZvLT5uZW50cywgJnNndF9pbmZvLT5yZWZzX2luZm8pOwotCQlp ZiAob3BlcmFuZHNbN10gPCAwKSB7Ci0JCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRl dmljZSwgInBhZ2VzIHNoYXJpbmcgZmFpbGVkXG4iKTsKKwkJb3BbaSsxXSA9IGV4cG9ydGVkLT5o aWQucm5nX2tleVtpXTsKKworCWlmIChwZ19pbmZvKSB7CisJCW9wWzRdID0gcGdfaW5mby0+bmVu dHM7CisJCW9wWzVdID0gcGdfaW5mby0+ZnJzdF9vZnN0OworCQlvcFs2XSA9IHBnX2luZm8tPmxh c3RfbGVuOworCQlvcFs3XSA9IG9wcy0+c2hhcmVfcGFnZXMocGdfaW5mby0+cGdzLCBleHBvcnRl ZC0+cmRvbWlkLAorCQkJCQkgcGdfaW5mby0+bmVudHMsICZleHBvcnRlZC0+cmVmc19pbmZvKTsK KwkJaWYgKG9wWzddIDwgMCkgeworCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAicGFnZXMg c2hhcmluZyBmYWlsZWRcbiIpOwogCQkJcmV0dXJuIC0xOwogCQl9CiAJfQogCi0Jb3BlcmFuZHNb OF0gPSBzZ3RfaW5mby0+c3pfcHJpdjsKKwlvcFs4XSA9IGV4cG9ydGVkLT5zel9wcml2OwogCiAJ LyogZHJpdmVyL2FwcGxpY2F0aW9uIHNwZWNpZmljIHByaXZhdGUgaW5mbyAqLwotCW1lbWNweSgm b3BlcmFuZHNbOV0sIHNndF9pbmZvLT5wcml2LCBvcGVyYW5kc1s4XSk7CisJbWVtY3B5KCZvcFs5 XSwgZXhwb3J0ZWQtPnByaXYsIG9wWzhdKTsKIAogCXJlcSA9IGtjYWxsb2MoMSwgc2l6ZW9mKCpy ZXEpLCBHRlBfS0VSTkVMKTsKIAogCWlmKCFyZXEpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZf cHJpdmF0ZS5kZXZpY2UsICJubyBtb3JlIHNwYWNlIGxlZnRcbiIpOworCQlkZXZfZXJyKGh5X2Ry dl9wcml2LT5kZXYsICJubyBtb3JlIHNwYWNlIGxlZnRcbiIpOwogCQlyZXR1cm4gLTE7CiAJfQog CiAJLyogY29tcG9zaW5nIGEgbWVzc2FnZSB0byB0aGUgaW1wb3J0ZXIgKi8KLQloeXBlcl9kbWFi dWZfY3JlYXRlX3JlcXVlc3QocmVxLCBIWVBFUl9ETUFCVUZfRVhQT1JULCAmb3BlcmFuZHNbMF0p OworCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxKHJlcSwgSFlQRVJfRE1BQlVGX0VYUE9SVCwgJm9w WzBdKTsKIAotCXJldCA9IG9wcy0+c2VuZF9yZXEoc2d0X2luZm8tPmh5cGVyX2RtYWJ1Zl9yZG9t YWluLCByZXEsIHRydWUpOworCXJldCA9IG9wcy0+c2VuZF9yZXEoZXhwb3J0ZWQtPnJkb21pZCwg cmVxLCB0cnVlKTsKIAogCWtmcmVlKHJlcSk7CiAKQEAgLTEzMiwyNCArMTMwLDE4IEBAIHN0YXRp YyBpbnQgaHlwZXJfZG1hYnVmX3NlbmRfZXhwb3J0X21zZyhzdHJ1Y3QgaHlwZXJfZG1hYnVmX3Nn dF9pbmZvICpzZ3RfaW5mbywKIAogc3RhdGljIGludCBoeXBlcl9kbWFidWZfZXhwb3J0X3JlbW90 ZV9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAqZGF0YSkKIHsKLQlzdHJ1Y3QgaW9jdGxf aHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGUgKmV4cG9ydF9yZW1vdGVfYXR0cjsKKwlzdHJ1Y3Qg aW9jdGxfaHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGUgKmV4cG9ydF9yZW1vdGVfYXR0ciA9CisJ CQkoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlICopZGF0YTsKIAlzdHJ1 Y3QgZG1hX2J1ZiAqZG1hX2J1ZjsKIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2ht ZW50OwogCXN0cnVjdCBzZ190YWJsZSAqc2d0OwotCXN0cnVjdCBoeXBlcl9kbWFidWZfcGFnZXNf aW5mbyAqcGFnZV9pbmZvOwotCXN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gKnNndF9pbmZv OworCXN0cnVjdCBwYWdlc19pbmZvICpwZ19pbmZvOworCXN0cnVjdCBleHBvcnRlZF9zZ3RfaW5m byAqZXhwb3J0ZWQ7CiAJaHlwZXJfZG1hYnVmX2lkX3QgaGlkOwogCWludCByZXQgPSAwOwogCi0J aWYgKCFkYXRhKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAidXNl ciBkYXRhIGlzIE5VTExcbiIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlleHBvcnRfcmVt b3RlX2F0dHIgPSAoc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlICopZGF0 YTsKLQotCWlmIChoeXBlcl9kbWFidWZfcHJpdmF0ZS5kb21pZCA9PSBleHBvcnRfcmVtb3RlX2F0 dHItPnJlbW90ZV9kb21haW4pIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZp Y2UsCisJaWYgKGh5X2Rydl9wcml2LT5kb21pZCA9PSBleHBvcnRfcmVtb3RlX2F0dHItPnJlbW90 ZV9kb21haW4pIHsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJImV4cG9ydGluZyB0 byB0aGUgc2FtZSBWTSBpcyBub3QgcGVybWl0dGVkXG4iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJ fQpAQCAtMTU3LDcgKzE0OSw3IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1v dGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRhdGEpCiAJZG1hX2J1ZiA9IGRtYV9i dWZfZ2V0KGV4cG9ydF9yZW1vdGVfYXR0ci0+ZG1hYnVmX2ZkKTsKIAogCWlmIChJU19FUlIoZG1h X2J1ZikpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICAiQ2Fubm90 IGdldCBkbWEgYnVmXG4iKTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAiQ2Fubm90IGdl dCBkbWEgYnVmXG4iKTsKIAkJcmV0dXJuIFBUUl9FUlIoZG1hX2J1Zik7CiAJfQogCkBAIC0xNjUs NjkgKzE1Nyw3OSBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlX2lvY3Rs KHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQogCSAqIHRvIHRoZSBzYW1lIGRvbWFpbiBh bmQgaWYgeWVzIGFuZCBpdCdzIHZhbGlkIHNndF9pbmZvLAogCSAqIGl0IHJldHVybnMgaHlwZXJf ZG1hYnVmX2lkIG9mIHByZS1leHBvcnRlZCBzZ3RfaW5mbwogCSAqLwotCWhpZCA9IGh5cGVyX2Rt YWJ1Zl9maW5kX2hpZF9leHBvcnRlZChkbWFfYnVmLCBleHBvcnRfcmVtb3RlX2F0dHItPnJlbW90 ZV9kb21haW4pOworCWhpZCA9IGh5cGVyX2RtYWJ1Zl9maW5kX2hpZF9leHBvcnRlZChkbWFfYnVm LAorCQkJCQkgICAgIGV4cG9ydF9yZW1vdGVfYXR0ci0+cmVtb3RlX2RvbWFpbik7CiAJaWYgKGhp ZC5pZCAhPSAtMSkgewotCQlzZ3RfaW5mbyA9IGh5cGVyX2RtYWJ1Zl9maW5kX2V4cG9ydGVkKGhp ZCk7Ci0JCWlmIChzZ3RfaW5mbyAhPSBOVUxMKSB7Ci0JCQlpZiAoc2d0X2luZm8tPnZhbGlkKSB7 CisJCWV4cG9ydGVkID0gaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQoaGlkKTsKKwkJaWYgKGV4 cG9ydGVkICE9IE5VTEwpIHsKKwkJCWlmIChleHBvcnRlZC0+dmFsaWQpIHsKIAkJCQkvKgogCQkJ CSAqIENoZWNrIGlmIHVuZXhwb3J0IGlzIGFscmVhZHkgc2NoZWR1bGVkIGZvciB0aGF0IGJ1ZmZl ciwKIAkJCQkgKiBpZiBzbyB0cnkgdG8gY2FuY2VsIGl0LiBJZiB0aGF0IHdpbGwgZmFpbCwgYnVm ZmVyIG5lZWRzCiAJCQkJICogdG8gYmUgcmVleHBvcnQgb25jZSBhZ2Fpbi4KIAkJCQkgKi8KLQkJ CQlpZiAoc2d0X2luZm8tPnVuZXhwb3J0X3NjaGVkdWxlZCkgewotCQkJCQlpZiAoIWNhbmNlbF9k ZWxheWVkX3dvcmtfc3luYygmc2d0X2luZm8tPnVuZXhwb3J0X3dvcmspKSB7CisJCQkJaWYgKGV4 cG9ydGVkLT51bmV4cG9ydF9zY2hlZCkgeworCQkJCQlpZiAoIWNhbmNlbF9kZWxheWVkX3dvcmtf c3luYygmZXhwb3J0ZWQtPnVuZXhwb3J0KSkgewogCQkJCQkJZG1hX2J1Zl9wdXQoZG1hX2J1Zik7 CiAJCQkJCQlnb3RvIHJlZXhwb3J0OwogCQkJCQl9Ci0JCQkJCXNndF9pbmZvLT51bmV4cG9ydF9z Y2hlZHVsZWQgPSAwOworCQkJCQlleHBvcnRlZC0+dW5leHBvcnRfc2NoZWQgPSBmYWxzZTsKIAkJ CQl9CiAKIAkJCQkvKiBpZiB0aGVyZSdzIGFueSBjaGFuZ2UgaW4gc2l6ZSBvZiBwcml2YXRlIGRh dGEuCiAJCQkJICogd2UgcmVhbGxvY2F0ZSBzcGFjZSBmb3IgcHJpdmF0ZSBkYXRhIHdpdGggbmV3 IHNpemUgKi8KLQkJCQlpZiAoZXhwb3J0X3JlbW90ZV9hdHRyLT5zel9wcml2ICE9IHNndF9pbmZv LT5zel9wcml2KSB7Ci0JCQkJCWtmcmVlKHNndF9pbmZvLT5wcml2KTsKKwkJCQlpZiAoZXhwb3J0 X3JlbW90ZV9hdHRyLT5zel9wcml2ICE9IGV4cG9ydGVkLT5zel9wcml2KSB7CisJCQkJCWtmcmVl KGV4cG9ydGVkLT5wcml2KTsKIAogCQkJCQkvKiB0cnVuY2F0aW5nIHNpemUgKi8KIAkJCQkJaWYg KGV4cG9ydF9yZW1vdGVfYXR0ci0+c3pfcHJpdiA+IE1BWF9TSVpFX1BSSVZfREFUQSkgewotCQkJ CQkJc2d0X2luZm8tPnN6X3ByaXYgPSBNQVhfU0laRV9QUklWX0RBVEE7CisJCQkJCQlleHBvcnRl ZC0+c3pfcHJpdiA9IE1BWF9TSVpFX1BSSVZfREFUQTsKIAkJCQkJfSBlbHNlIHsKLQkJCQkJCXNn dF9pbmZvLT5zel9wcml2ID0gZXhwb3J0X3JlbW90ZV9hdHRyLT5zel9wcml2OworCQkJCQkJZXhw b3J0ZWQtPnN6X3ByaXYgPSBleHBvcnRfcmVtb3RlX2F0dHItPnN6X3ByaXY7CiAJCQkJCX0KIAot CQkJCQlzZ3RfaW5mby0+cHJpdiA9IGtjYWxsb2MoMSwgc2d0X2luZm8tPnN6X3ByaXYsIEdGUF9L RVJORUwpOworCQkJCQlleHBvcnRlZC0+cHJpdiA9IGtjYWxsb2MoMSwgZXhwb3J0ZWQtPnN6X3By aXYsIEdGUF9LRVJORUwpOwogCi0JCQkJCWlmKCFzZ3RfaW5mby0+cHJpdikgewotCQkJCQkJZGV2 X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkJCQkJIkNhbid0IHJlYWxsb2Nh dGUgcHJpdiBiZWNhdXNlIHRoZXJlJ3Mgbm8gbW9yZSBzcGFjZSBsZWZ0XG4iKTsKLQkJCQkJCWh5 cGVyX2RtYWJ1Zl9yZW1vdmVfZXhwb3J0ZWQoc2d0X2luZm8tPmhpZCk7Ci0JCQkJCQloeXBlcl9k bWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzZ3RfaW5mbywgdHJ1ZSk7Ci0JCQkJCQlrZnJlZShzZ3Rf aW5mbyk7CisJCQkJCWlmKCFleHBvcnRlZC0+cHJpdikgeworCQkJCQkJZGV2X2VycihoeV9kcnZf cHJpdi0+ZGV2LAorCQkJCQkJCSJubyBtb3JlIHNwYWNlIGxlZnQgZm9yIHByaXZcbiIpOworCQkJ CQkJaHlwZXJfZG1hYnVmX3JlbW92ZV9leHBvcnRlZChleHBvcnRlZC0+aGlkKTsKKwkJCQkJCWh5 cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKGV4cG9ydGVkLCB0cnVlKTsKKwkJCQkJCWtmcmVl KGV4cG9ydGVkKTsKKwkJCQkJCWRtYV9idWZfcHV0KGRtYV9idWYpOwogCQkJCQkJcmV0dXJuIC1F Tk9NRU07CiAJCQkJCX0KIAkJCQl9CiAKIAkJCQkvKiB1cGRhdGUgcHJpdmF0ZSBkYXRhIGluIHNn dF9pbmZvIHdpdGggbmV3IG9uZXMgKi8KLQkJCQljb3B5X2Zyb21fdXNlcihzZ3RfaW5mby0+cHJp diwgZXhwb3J0X3JlbW90ZV9hdHRyLT5wcml2LCBzZ3RfaW5mby0+c3pfcHJpdik7Ci0KLQkJCQkv KiBzZW5kIGFuIGV4cG9ydCBtc2cgZm9yIHVwZGF0aW5nIHByaXYgaW4gaW1wb3J0ZXIgKi8KLQkJ CQlyZXQgPSBoeXBlcl9kbWFidWZfc2VuZF9leHBvcnRfbXNnKHNndF9pbmZvLCBOVUxMKTsKLQot CQkJCWlmIChyZXQgPCAwKSB7Ci0JCQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2 aWNlLCAiRmFpbGVkIHRvIHNlbmQgYSBuZXcgcHJpdmF0ZSBkYXRhXG4iKTsKKwkJCQlyZXQgPSBj b3B5X2Zyb21fdXNlcihleHBvcnRlZC0+cHJpdiwgZXhwb3J0X3JlbW90ZV9hdHRyLT5wcml2LAor CQkJCQkJICAgICBleHBvcnRlZC0+c3pfcHJpdik7CisJCQkJaWYgKHJldCkgeworCQkJCQlkZXZf ZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkJCQkiRmFpbGVkIHRvIGxvYWQgYSBuZXcgcHJpdmF0 ZSBkYXRhXG4iKTsKKwkJCQkJcmV0ID0gLUVJTlZBTDsKKwkJCQl9IGVsc2UgeworCQkJCQkvKiBz ZW5kIGFuIGV4cG9ydCBtc2cgZm9yIHVwZGF0aW5nIHByaXYgaW4gaW1wb3J0ZXIgKi8KKwkJCQkJ cmV0ID0gaHlwZXJfZG1hYnVmX3NlbmRfZXhwb3J0X21zZyhleHBvcnRlZCwgTlVMTCk7CisKKwkJ CQkJaWYgKHJldCA8IDApIHsKKwkJCQkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkJ CQkiRmFpbGVkIHRvIHNlbmQgYSBuZXcgcHJpdmF0ZSBkYXRhXG4iKTsKKwkJCQkJCXJldCA9IC1F QlVTWTsKKwkJCQkJfQogCQkJCX0KIAogCQkJCWRtYV9idWZfcHV0KGRtYV9idWYpOwogCQkJCWV4 cG9ydF9yZW1vdGVfYXR0ci0+aGlkID0gaGlkOwotCQkJCXJldHVybiAwOworCQkJCXJldHVybiBy ZXQ7CiAJCQl9CiAJCX0KIAl9CiAKIHJlZXhwb3J0OgotCWF0dGFjaG1lbnQgPSBkbWFfYnVmX2F0 dGFjaChkbWFfYnVmLCBoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UpOworCWF0dGFjaG1lbnQg PSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBoeV9kcnZfcHJpdi0+ZGV2KTsKIAlpZiAoSVNfRVJS KGF0dGFjaG1lbnQpKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAi Q2Fubm90IGdldCBhdHRhY2htZW50XG4iKTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAi Q2Fubm90IGdldCBhdHRhY2htZW50XG4iKTsKIAkJcmV0ID0gUFRSX0VSUihhdHRhY2htZW50KTsK IAkJZ290byBmYWlsX2F0dGFjaDsKIAl9CkBAIC0yMzUsMTU0ICsyMzcsMTY1IEBAIHN0YXRpYyBp bnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZv aWQgKmRhdGEpCiAJc2d0ID0gZG1hX2J1Zl9tYXBfYXR0YWNobWVudChhdHRhY2htZW50LCBETUFf QklESVJFQ1RJT05BTCk7CiAKIAlpZiAoSVNfRVJSKHNndCkpIHsKLQkJZGV2X2VycihoeXBlcl9k bWFidWZfcHJpdmF0ZS5kZXZpY2UsICJDYW5ub3QgbWFwIGF0dGFjaG1lbnRcbiIpOworCQlkZXZf ZXJyKGh5X2Rydl9wcml2LT5kZXYsICJDYW5ub3QgbWFwIGF0dGFjaG1lbnRcbiIpOwogCQlyZXQg PSBQVFJfRVJSKHNndCk7CiAJCWdvdG8gZmFpbF9tYXBfYXR0YWNobWVudDsKIAl9CiAKLQlzZ3Rf aW5mbyA9IGtjYWxsb2MoMSwgc2l6ZW9mKCpzZ3RfaW5mbyksIEdGUF9LRVJORUwpOworCWV4cG9y dGVkID0ga2NhbGxvYygxLCBzaXplb2YoKmV4cG9ydGVkKSwgR0ZQX0tFUk5FTCk7CiAKLQlpZigh c2d0X2luZm8pIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJubyBt b3JlIHNwYWNlIGxlZnRcbiIpOworCWlmKCFleHBvcnRlZCkgeworCQlkZXZfZXJyKGh5X2Rydl9w cml2LT5kZXYsICJubyBtb3JlIHNwYWNlIGxlZnRcbiIpOwogCQlyZXQgPSAtRU5PTUVNOwogCQln b3RvIGZhaWxfc2d0X2luZm9fY3JlYXRpb247CiAJfQogCiAJLyogcG9zc2libGUgdHJ1bmNhdGlv biAqLwogCWlmIChleHBvcnRfcmVtb3RlX2F0dHItPnN6X3ByaXYgPiBNQVhfU0laRV9QUklWX0RB VEEpIHsKLQkJc2d0X2luZm8tPnN6X3ByaXYgPSBNQVhfU0laRV9QUklWX0RBVEE7CisJCWV4cG9y dGVkLT5zel9wcml2ID0gTUFYX1NJWkVfUFJJVl9EQVRBOwogCX0gZWxzZSB7Ci0JCXNndF9pbmZv LT5zel9wcml2ID0gZXhwb3J0X3JlbW90ZV9hdHRyLT5zel9wcml2OworCQlleHBvcnRlZC0+c3pf cHJpdiA9IGV4cG9ydF9yZW1vdGVfYXR0ci0+c3pfcHJpdjsKIAl9CiAKIAkvKiBjcmVhdGluZyBi dWZmZXIgZm9yIHByaXZhdGUgZGF0YSBvZiBidWZmZXIgKi8KLQlpZihzZ3RfaW5mby0+c3pfcHJp diAhPSAwKSB7Ci0JCXNndF9pbmZvLT5wcml2ID0ga2NhbGxvYygxLCBzZ3RfaW5mby0+c3pfcHJp diwgR0ZQX0tFUk5FTCk7CisJaWYoZXhwb3J0ZWQtPnN6X3ByaXYgIT0gMCkgeworCQlleHBvcnRl ZC0+cHJpdiA9IGtjYWxsb2MoMSwgZXhwb3J0ZWQtPnN6X3ByaXYsIEdGUF9LRVJORUwpOwogCi0J CWlmKCFzZ3RfaW5mby0+cHJpdikgewotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5k ZXZpY2UsICJubyBtb3JlIHNwYWNlIGxlZnRcbiIpOworCQlpZighZXhwb3J0ZWQtPnByaXYpIHsK KwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgIm5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CiAJ CQlyZXQgPSAtRU5PTUVNOwogCQkJZ290byBmYWlsX3ByaXZfY3JlYXRpb247CiAJCX0KIAl9IGVs c2UgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgInNpemUgaXMgMFxu Iik7CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgInNpemUgaXMgMFxuIik7CiAJfQogCi0J c2d0X2luZm8tPmhpZCA9IGh5cGVyX2RtYWJ1Zl9nZXRfaGlkKCk7CisJZXhwb3J0ZWQtPmhpZCA9 IGh5cGVyX2RtYWJ1Zl9nZXRfaGlkKCk7CiAKIAkvKiBubyBtb3JlIGV4cG9ydGVkIGRtYWJ1ZiBh bGxvd2VkICovCi0JaWYoc2d0X2luZm8tPmhpZC5pZCA9PSAtMSkgewotCQlkZXZfZXJyKGh5cGVy X2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwlpZihleHBvcnRlZC0+aGlkLmlkID09IC0xKSB7CisJ CWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSJleGNlZWRzIGFsbG93ZWQgbnVtYmVyIG9m IGRtYWJ1ZiB0byBiZSBleHBvcnRlZFxuIik7CiAJCXJldCA9IC1FTk9NRU07CiAJCWdvdG8gZmFp bF9zZ3RfaW5mb19jcmVhdGlvbjsKIAl9CiAKLQkvKiBUT0RPOiBXZSBtaWdodCBuZWVkIHRvIGNv bnNpZGVyIHVzaW5nIHBvcnQgbnVtYmVyIG9uIGV2ZW50IGNoYW5uZWw/ICovCi0Jc2d0X2luZm8t Pmh5cGVyX2RtYWJ1Zl9yZG9tYWluID0gZXhwb3J0X3JlbW90ZV9hdHRyLT5yZW1vdGVfZG9tYWlu OwotCXNndF9pbmZvLT5kbWFfYnVmID0gZG1hX2J1ZjsKLQlzZ3RfaW5mby0+dmFsaWQgPSAxOwor CWV4cG9ydGVkLT5yZG9taWQgPSBleHBvcnRfcmVtb3RlX2F0dHItPnJlbW90ZV9kb21haW47CisJ ZXhwb3J0ZWQtPmRtYV9idWYgPSBkbWFfYnVmOworCWV4cG9ydGVkLT52YWxpZCA9IHRydWU7CiAK LQlzZ3RfaW5mby0+YWN0aXZlX3NndHMgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qgc2d0X2xpc3Qp LCBHRlBfS0VSTkVMKTsKLQlpZiAoIXNndF9pbmZvLT5hY3RpdmVfc2d0cykgewotCQlkZXZfZXJy KGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIm5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CisJ ZXhwb3J0ZWQtPmFjdGl2ZV9zZ3RzID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHNndF9saXN0KSwg R0ZQX0tFUk5FTCk7CisJaWYgKCFleHBvcnRlZC0+YWN0aXZlX3NndHMpIHsKKwkJZGV2X2Vyciho eV9kcnZfcHJpdi0+ZGV2LCAibm8gbW9yZSBzcGFjZSBsZWZ0XG4iKTsKIAkJcmV0ID0gLUVOT01F TTsKIAkJZ290byBmYWlsX21hcF9hY3RpdmVfc2d0czsKIAl9CiAKLQlzZ3RfaW5mby0+YWN0aXZl X2F0dGFjaGVkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IGF0dGFjaG1lbnRfbGlzdCksIEdGUF9L RVJORUwpOwotCWlmICghc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZCkgewotCQlkZXZfZXJyKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIm5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CisJZXhw b3J0ZWQtPmFjdGl2ZV9hdHRhY2hlZCA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBhdHRhY2htZW50 X2xpc3QpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWV4cG9ydGVkLT5hY3RpdmVfYXR0YWNoZWQpIHsK KwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAibm8gbW9yZSBzcGFjZSBsZWZ0XG4iKTsKIAkJ cmV0ID0gLUVOT01FTTsKIAkJZ290byBmYWlsX21hcF9hY3RpdmVfYXR0YWNoZWQ7CiAJfQogCi0J c2d0X2luZm8tPnZhX2ttYXBwZWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qga21hcF92YWRkcl9s aXN0KSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFzZ3RfaW5mby0+dmFfa21hcHBlZCkgewotCQlkZXZf ZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIm5vIG1vcmUgc3BhY2UgbGVmdFxuIik7 CisJZXhwb3J0ZWQtPnZhX2ttYXBwZWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qga21hcF92YWRk cl9saXN0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFleHBvcnRlZC0+dmFfa21hcHBlZCkgeworCQlk ZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsICJubyBtb3JlIHNwYWNlIGxlZnRcbiIpOwogCQlyZXQg PSAtRU5PTUVNOwogCQlnb3RvIGZhaWxfbWFwX3ZhX2ttYXBwZWQ7CiAJfQogCi0Jc2d0X2luZm8t PnZhX3ZtYXBwZWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qgdm1hcF92YWRkcl9saXN0KSwgR0ZQ X0tFUk5FTCk7Ci0JaWYgKCFzZ3RfaW5mby0+dmFfdm1hcHBlZCkgewotCQlkZXZfZXJyKGh5cGVy X2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIm5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CisJZXhwb3J0 ZWQtPnZhX3ZtYXBwZWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qgdm1hcF92YWRkcl9saXN0KSwg R0ZQX0tFUk5FTCk7CisJaWYgKCFleHBvcnRlZC0+dmFfdm1hcHBlZCkgeworCQlkZXZfZXJyKGh5 X2Rydl9wcml2LT5kZXYsICJubyBtb3JlIHNwYWNlIGxlZnRcbiIpOwogCQlyZXQgPSAtRU5PTUVN OwogCQlnb3RvIGZhaWxfbWFwX3ZhX3ZtYXBwZWQ7CiAJfQogCi0Jc2d0X2luZm8tPmFjdGl2ZV9z Z3RzLT5zZ3QgPSBzZ3Q7Ci0Jc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZC0+YXR0YWNoID0gYXR0 YWNobWVudDsKLQlzZ3RfaW5mby0+dmFfa21hcHBlZC0+dmFkZHIgPSBOVUxMOwotCXNndF9pbmZv LT52YV92bWFwcGVkLT52YWRkciA9IE5VTEw7CisJZXhwb3J0ZWQtPmFjdGl2ZV9zZ3RzLT5zZ3Qg PSBzZ3Q7CisJZXhwb3J0ZWQtPmFjdGl2ZV9hdHRhY2hlZC0+YXR0YWNoID0gYXR0YWNobWVudDsK KwlleHBvcnRlZC0+dmFfa21hcHBlZC0+dmFkZHIgPSBOVUxMOworCWV4cG9ydGVkLT52YV92bWFw cGVkLT52YWRkciA9IE5VTEw7CiAKIAkvKiBpbml0aWFsaXplIGxpc3Qgb2Ygc2d0LCBhdHRhY2ht ZW50IGFuZCB2YWRkciBmb3IgZG1hYnVmIHN5bmMKIAkgKiB2aWEgc2hhZG93IGRtYS1idWYKIAkg Ki8KLQlJTklUX0xJU1RfSEVBRCgmc2d0X2luZm8tPmFjdGl2ZV9zZ3RzLT5saXN0KTsKLQlJTklU X0xJU1RfSEVBRCgmc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZC0+bGlzdCk7Ci0JSU5JVF9MSVNU X0hFQUQoJnNndF9pbmZvLT52YV9rbWFwcGVkLT5saXN0KTsKLQlJTklUX0xJU1RfSEVBRCgmc2d0 X2luZm8tPnZhX3ZtYXBwZWQtPmxpc3QpOworCUlOSVRfTElTVF9IRUFEKCZleHBvcnRlZC0+YWN0 aXZlX3NndHMtPmxpc3QpOworCUlOSVRfTElTVF9IRUFEKCZleHBvcnRlZC0+YWN0aXZlX2F0dGFj aGVkLT5saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZXhwb3J0ZWQtPnZhX2ttYXBwZWQtPmxpc3Qp OworCUlOSVRfTElTVF9IRUFEKCZleHBvcnRlZC0+dmFfdm1hcHBlZC0+bGlzdCk7CiAKIAkvKiBj b3B5IHByaXZhdGUgZGF0YSB0byBzZ3RfaW5mbyAqLwotCWNvcHlfZnJvbV91c2VyKHNndF9pbmZv LT5wcml2LCBleHBvcnRfcmVtb3RlX2F0dHItPnByaXYsIHNndF9pbmZvLT5zel9wcml2KTsKKwly ZXQgPSBjb3B5X2Zyb21fdXNlcihleHBvcnRlZC0+cHJpdiwgZXhwb3J0X3JlbW90ZV9hdHRyLT5w cml2LAorCQkJICAgICBleHBvcnRlZC0+c3pfcHJpdik7CiAKLQlwYWdlX2luZm8gPSBoeXBlcl9k bWFidWZfZXh0X3BncyhzZ3QpOwotCWlmICghcGFnZV9pbmZvKSB7Ci0JCWRldl9lcnIoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiZmFpbGVkIHRvIGNvbnN0cnVjdCBwYWdlX2luZm9cbiIp OworCWlmIChyZXQpIHsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJImZhaWxlZCB0 byBsb2FkIHByaXZhdGUgZGF0YVxuIik7CisJCXJldCA9IC1FSU5WQUw7CiAJCWdvdG8gZmFpbF9l eHBvcnQ7CiAJfQogCi0Jc2d0X2luZm8tPm5lbnRzID0gcGFnZV9pbmZvLT5uZW50czsKKwlwZ19p bmZvID0gaHlwZXJfZG1hYnVmX2V4dF9wZ3Moc2d0KTsKKwlpZiAoIXBnX2luZm8pIHsKKwkJZGV2 X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJImZhaWxlZCB0byBjb25zdHJ1Y3QgcGdfaW5mb1xu Iik7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZmFpbF9leHBvcnQ7CisJfQorCisJZXhwb3J0 ZWQtPm5lbnRzID0gcGdfaW5mby0+bmVudHM7CiAKIAkvKiBub3cgcmVnaXN0ZXIgaXQgdG8gZXhw b3J0IGxpc3QgKi8KLQloeXBlcl9kbWFidWZfcmVnaXN0ZXJfZXhwb3J0ZWQoc2d0X2luZm8pOwor CWh5cGVyX2RtYWJ1Zl9yZWdpc3Rlcl9leHBvcnRlZChleHBvcnRlZCk7CiAKLQlleHBvcnRfcmVt b3RlX2F0dHItPmhpZCA9IHNndF9pbmZvLT5oaWQ7CisJZXhwb3J0X3JlbW90ZV9hdHRyLT5oaWQg PSBleHBvcnRlZC0+aGlkOwogCi0JcmV0ID0gaHlwZXJfZG1hYnVmX3NlbmRfZXhwb3J0X21zZyhz Z3RfaW5mbywgcGFnZV9pbmZvKTsKKwlyZXQgPSBoeXBlcl9kbWFidWZfc2VuZF9leHBvcnRfbXNn KGV4cG9ydGVkLCBwZ19pbmZvKTsKIAogCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiZmFpbGVkIHRvIHNlbmQgb3V0IHRoZSBleHBvcnQgcmVx dWVzdFxuIik7CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCSJmYWlsZWQgdG8gc2Vu ZCBvdXQgdGhlIGV4cG9ydCByZXF1ZXN0XG4iKTsKIAkJZ290byBmYWlsX3NlbmRfcmVxdWVzdDsK IAl9CiAKLQkvKiBmcmVlIHBhZ2VfaW5mbyAqLwotCWtmcmVlKHBhZ2VfaW5mby0+cGFnZXMpOwot CWtmcmVlKHBhZ2VfaW5mbyk7CisJLyogZnJlZSBwZ19pbmZvICovCisJa2ZyZWUocGdfaW5mby0+ cGdzKTsKKwlrZnJlZShwZ19pbmZvKTsKIAotCXNndF9pbmZvLT5maWxwID0gZmlscDsKKwlleHBv cnRlZC0+ZmlscCA9IGZpbHA7CiAKIAlyZXR1cm4gcmV0OwogCiAvKiBDbGVhbi11cCBpZiBlcnJv ciBvY2N1cnMgKi8KIAogZmFpbF9zZW5kX3JlcXVlc3Q6Ci0JaHlwZXJfZG1hYnVmX3JlbW92ZV9l eHBvcnRlZChzZ3RfaW5mby0+aGlkKTsKKwloeXBlcl9kbWFidWZfcmVtb3ZlX2V4cG9ydGVkKGV4 cG9ydGVkLT5oaWQpOwogCi0JLyogZnJlZSBwYWdlX2luZm8gKi8KLQlrZnJlZShwYWdlX2luZm8t PnBhZ2VzKTsKLQlrZnJlZShwYWdlX2luZm8pOworCS8qIGZyZWUgcGdfaW5mbyAqLworCWtmcmVl KHBnX2luZm8tPnBncyk7CisJa2ZyZWUocGdfaW5mbyk7CiAKIGZhaWxfZXhwb3J0OgotCWtmcmVl KHNndF9pbmZvLT52YV92bWFwcGVkKTsKKwlrZnJlZShleHBvcnRlZC0+dmFfdm1hcHBlZCk7CiAK IGZhaWxfbWFwX3ZhX3ZtYXBwZWQ6Ci0Ja2ZyZWUoc2d0X2luZm8tPnZhX2ttYXBwZWQpOworCWtm cmVlKGV4cG9ydGVkLT52YV9rbWFwcGVkKTsKIAogZmFpbF9tYXBfdmFfa21hcHBlZDoKLQlrZnJl ZShzZ3RfaW5mby0+YWN0aXZlX2F0dGFjaGVkKTsKKwlrZnJlZShleHBvcnRlZC0+YWN0aXZlX2F0 dGFjaGVkKTsKIAogZmFpbF9tYXBfYWN0aXZlX2F0dGFjaGVkOgotCWtmcmVlKHNndF9pbmZvLT5h Y3RpdmVfc2d0cyk7Ci0Ja2ZyZWUoc2d0X2luZm8tPnByaXYpOworCWtmcmVlKGV4cG9ydGVkLT5h Y3RpdmVfc2d0cyk7CisJa2ZyZWUoZXhwb3J0ZWQtPnByaXYpOwogCiBmYWlsX3ByaXZfY3JlYXRp b246Ci0Ja2ZyZWUoc2d0X2luZm8pOworCWtmcmVlKGV4cG9ydGVkKTsKIAogZmFpbF9tYXBfYWN0 aXZlX3NndHM6CiBmYWlsX3NndF9pbmZvX2NyZWF0aW9uOgotCWRtYV9idWZfdW5tYXBfYXR0YWNo bWVudChhdHRhY2htZW50LCBzZ3QsIERNQV9CSURJUkVDVElPTkFMKTsKKwlkbWFfYnVmX3VubWFw X2F0dGFjaG1lbnQoYXR0YWNobWVudCwgc2d0LAorCQkJCSBETUFfQklESVJFQ1RJT05BTCk7CiAK IGZhaWxfbWFwX2F0dGFjaG1lbnQ6CiAJZG1hX2J1Zl9kZXRhY2goZG1hX2J1ZiwgYXR0YWNobWVu dCk7CkBAIC0zOTUsMTQzICs0MDgsMTM2IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9y dF9yZW1vdGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRhdGEpCiAKIHN0YXRpYyBp bnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAq ZGF0YSkKIHsKLQlzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX2V4cG9ydF9mZCAqZXhwb3J0X2Zk X2F0dHI7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAqb3BzID0gaHlwZXJfZG1h YnVmX3ByaXZhdGUuYmFja2VuZF9vcHM7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9z Z3RfaW5mbyAqc2d0X2luZm87CisJc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9leHBvcnRfZmQg KmV4cG9ydF9mZF9hdHRyID0KKwkJCShzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX2V4cG9ydF9m ZCAqKWRhdGE7CisJc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAqb3BzID0gaHlfZHJ2 X3ByaXYtPmJhY2tlbmRfb3BzOworCXN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWQ7 CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcTsKLQlzdHJ1Y3QgcGFnZSAqKmRhdGFfcGFn ZXM7Ci0JaW50IG9wZXJhbmRzWzRdOworCXN0cnVjdCBwYWdlICoqZGF0YV9wZ3M7CisJaW50IG9w WzRdOwogCWludCBpOwogCWludCByZXQgPSAwOwogCi0JZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJp dmF0ZS5kZXZpY2UsICIlcyBlbnRyeVxuIiwgX19mdW5jX18pOwotCi0JaWYgKCFkYXRhKSB7Ci0J CWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAidXNlciBkYXRhIGlzIE5VTExc biIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlleHBvcnRfZmRfYXR0ciA9IChzdHJ1Y3Qg aW9jdGxfaHlwZXJfZG1hYnVmX2V4cG9ydF9mZCAqKWRhdGE7CisJZGV2X2RiZyhoeV9kcnZfcHJp di0+ZGV2LCAiJXMgZW50cnlcbiIsIF9fZnVuY19fKTsKIAogCS8qIGxvb2sgZm9yIGRtYWJ1ZiBm b3IgdGhlIGlkICovCi0Jc2d0X2luZm8gPSBoeXBlcl9kbWFidWZfZmluZF9pbXBvcnRlZChleHBv cnRfZmRfYXR0ci0+aGlkKTsKKwlpbXBvcnRlZCA9IGh5cGVyX2RtYWJ1Zl9maW5kX2ltcG9ydGVk KGV4cG9ydF9mZF9hdHRyLT5oaWQpOwogCiAJLyogY2FuJ3QgZmluZCBzZ3QgZnJvbSB0aGUgdGFi bGUgKi8KLQlpZiAoIXNndF9pbmZvKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUu ZGV2aWNlLCAiY2FuJ3QgZmluZCB0aGUgZW50cnlcbiIpOworCWlmICghaW1wb3J0ZWQpIHsKKwkJ ZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAiY2FuJ3QgZmluZCB0aGUgZW50cnlcbiIpOwogCQly ZXR1cm4gLUVOT0VOVDsKIAl9CiAKLQltdXRleF9sb2NrKCZoeXBlcl9kbWFidWZfcHJpdmF0ZS5s b2NrKTsKKwltdXRleF9sb2NrKCZoeV9kcnZfcHJpdi0+bG9jayk7CiAKLQlzZ3RfaW5mby0+bnVt X2ltcG9ydGVycysrOworCWltcG9ydGVkLT5pbXBvcnRlcnMrKzsKIAogCS8qIHNlbmQgbm90aWZp Y2F0aW9uIGZvciBleHBvcnRfZmQgdG8gZXhwb3J0ZXIgKi8KLQlvcGVyYW5kc1swXSA9IHNndF9p bmZvLT5oaWQuaWQ7CisJb3BbMF0gPSBpbXBvcnRlZC0+aGlkLmlkOwogCiAJZm9yIChpPTA7IGk8 MzsgaSsrKQotCQlvcGVyYW5kc1tpKzFdID0gc2d0X2luZm8tPmhpZC5ybmdfa2V5W2ldOworCQlv cFtpKzFdID0gaW1wb3J0ZWQtPmhpZC5ybmdfa2V5W2ldOwogCi0JZGV2X2RiZyhoeXBlcl9kbWFi dWZfcHJpdmF0ZS5kZXZpY2UsICJFeHBvcnRpbmcgZmQgb2YgYnVmZmVyIHtpZDolZCBrZXk6JWQg JWQgJWR9XG4iLAotCQlzZ3RfaW5mby0+aGlkLmlkLCBzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMF0s IHNndF9pbmZvLT5oaWQucm5nX2tleVsxXSwKLQkJc2d0X2luZm8tPmhpZC5ybmdfa2V5WzJdKTsK KwlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsICJFeHBvcnRpbmcgZmQgb2YgYnVmZmVyIHtpZDol ZCBrZXk6JWQgJWQgJWR9XG4iLAorCQlpbXBvcnRlZC0+aGlkLmlkLCBpbXBvcnRlZC0+aGlkLnJu Z19rZXlbMF0sIGltcG9ydGVkLT5oaWQucm5nX2tleVsxXSwKKwkJaW1wb3J0ZWQtPmhpZC5ybmdf a2V5WzJdKTsKIAogCXJlcSA9IGtjYWxsb2MoMSwgc2l6ZW9mKCpyZXEpLCBHRlBfS0VSTkVMKTsK IAogCWlmICghcmVxKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAor CQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiTm8gbWVtb3J5IGxlZnQgdG8gYmUgYWxs b2NhdGVkXG4iKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCi0JaHlwZXJfZG1hYnVmX2NyZWF0 ZV9yZXF1ZXN0KHJlcSwgSFlQRVJfRE1BQlVGX0VYUE9SVF9GRCwgJm9wZXJhbmRzWzBdKTsKKwlo eXBlcl9kbWFidWZfY3JlYXRlX3JlcShyZXEsIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkQsICZvcFsw XSk7CiAKLQlyZXQgPSBvcHMtPnNlbmRfcmVxKEhZUEVSX0RNQUJVRl9ET01fSUQoc2d0X2luZm8t PmhpZCksIHJlcSwgdHJ1ZSk7CisJcmV0ID0gb3BzLT5zZW5kX3JlcShIWVBFUl9ETUFCVUZfRE9N X0lEKGltcG9ydGVkLT5oaWQpLCByZXEsIHRydWUpOwogCiAJaWYgKHJldCA8IDApIHsKIAkJLyog aW4gY2FzZSBvZiB0aW1lb3V0IG90aGVyIGVuZCBldmVudHVhbGx5IHdpbGwgcmVjZWl2ZSByZXF1 ZXN0LCBzbyB3ZSBuZWVkIHRvIHVuZG8gaXQgKi8KLQkJaHlwZXJfZG1hYnVmX2NyZWF0ZV9yZXF1 ZXN0KHJlcSwgSFlQRVJfRE1BQlVGX0VYUE9SVF9GRF9GQUlMRUQsICZvcGVyYW5kc1swXSk7Ci0J CW9wcy0+c2VuZF9yZXEob3BlcmFuZHNbMF0sIHJlcSwgZmFsc2UpOworCQloeXBlcl9kbWFidWZf Y3JlYXRlX3JlcShyZXEsIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkRfRkFJTEVELCAmb3BbMF0pOwor CQlvcHMtPnNlbmRfcmVxKG9wWzBdLCByZXEsIGZhbHNlKTsKIAkJa2ZyZWUocmVxKTsKLQkJZGV2 X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJGYWlsZWQgdG8gY3JlYXRlIHNndCBv ciBub3RpZnkgZXhwb3J0ZXJcbiIpOwotCQlzZ3RfaW5mby0+bnVtX2ltcG9ydGVycy0tOwotCQlt dXRleF91bmxvY2soJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmxvY2spOworCQlkZXZfZXJyKGh5X2Ry dl9wcml2LT5kZXYsICJGYWlsZWQgdG8gY3JlYXRlIHNndCBvciBub3RpZnkgZXhwb3J0ZXJcbiIp OworCQlpbXBvcnRlZC0+aW1wb3J0ZXJzLS07CisJCW11dGV4X3VubG9jaygmaHlfZHJ2X3ByaXYt PmxvY2spOwogCQlyZXR1cm4gcmV0OwogCX0KIAogCWtmcmVlKHJlcSk7CiAKIAlpZiAocmV0ID09 IEhZUEVSX0RNQUJVRl9SRVFfRVJST1IpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSJCdWZmZXIgaW52YWxp ZCB7aWQ6JWQga2V5OiVkICVkICVkfSwgY2Fubm90IGltcG9ydFxuIiwKLQkJCXNndF9pbmZvLT5o aWQuaWQsIHNndF9pbmZvLT5oaWQucm5nX2tleVswXSwgc2d0X2luZm8tPmhpZC5ybmdfa2V5WzFd LAotCQkJc2d0X2luZm8tPmhpZC5ybmdfa2V5WzJdKTsKKwkJCWltcG9ydGVkLT5oaWQuaWQsIGlt cG9ydGVkLT5oaWQucm5nX2tleVswXSwgaW1wb3J0ZWQtPmhpZC5ybmdfa2V5WzFdLAorCQkJaW1w b3J0ZWQtPmhpZC5ybmdfa2V5WzJdKTsKIAotCQlzZ3RfaW5mby0+bnVtX2ltcG9ydGVycy0tOwot CQltdXRleF91bmxvY2soJmh5cGVyX2RtYWJ1Zl9wcml2YXRlLmxvY2spOworCQlpbXBvcnRlZC0+ aW1wb3J0ZXJzLS07CisJCW11dGV4X3VubG9jaygmaHlfZHJ2X3ByaXYtPmxvY2spOwogCQlyZXR1 cm4gLUVJTlZBTDsKIAl9IGVsc2UgewotCQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRl dmljZSwgIkNhbiBpbXBvcnQgYnVmZmVyIHtpZDolZCBrZXk6JWQgJWQgJWR9XG4iLAotCQkJc2d0 X2luZm8tPmhpZC5pZCwgc2d0X2luZm8tPmhpZC5ybmdfa2V5WzBdLCBzZ3RfaW5mby0+aGlkLnJu Z19rZXlbMV0sCi0JCQlzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMl0pOworCQlkZXZfZGJnKGh5X2Ry dl9wcml2LT5kZXYsICJDYW4gaW1wb3J0IGJ1ZmZlciB7aWQ6JWQga2V5OiVkICVkICVkfVxuIiwK KwkJCWltcG9ydGVkLT5oaWQuaWQsIGltcG9ydGVkLT5oaWQucm5nX2tleVswXSwgaW1wb3J0ZWQt PmhpZC5ybmdfa2V5WzFdLAorCQkJaW1wb3J0ZWQtPmhpZC5ybmdfa2V5WzJdKTsKIAogCQlyZXQg PSAwOwogCX0KIAotCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkgICIl cyBGb3VuZCBidWZmZXIgZ3JlZiAlZCAgb2ZmICVkIGxhc3QgbGVuICVkIG5lbnRzICVkIGRvbWFp biAlZFxuIiwgX19mdW5jX18sCi0JCSAgc2d0X2luZm8tPnJlZl9oYW5kbGUsIHNndF9pbmZvLT5m cnN0X29mc3QsCi0JCSAgc2d0X2luZm8tPmxhc3RfbGVuLCBzZ3RfaW5mby0+bmVudHMsCi0JCSAg SFlQRVJfRE1BQlVGX0RPTV9JRChzZ3RfaW5mby0+aGlkKSk7CisJZGV2X2RiZyhoeV9kcnZfcHJp di0+ZGV2LAorCQkgICIlcyBGb3VuZCBidWZmZXIgZ3JlZiAlZCAgb2ZmICVkIGxhc3QgbGVuICVk IG5lbnRzICVkIGRvbWFpbiAlZFxuIiwKKwkJICBfX2Z1bmNfXywgaW1wb3J0ZWQtPnJlZl9oYW5k bGUsIGltcG9ydGVkLT5mcnN0X29mc3QsCisJCSAgaW1wb3J0ZWQtPmxhc3RfbGVuLCBpbXBvcnRl ZC0+bmVudHMsIEhZUEVSX0RNQUJVRl9ET01fSUQoaW1wb3J0ZWQtPmhpZCkpOwogCi0JaWYgKCFz Z3RfaW5mby0+c2d0KSB7Ci0JCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAor CWlmICghaW1wb3J0ZWQtPnNndCkgeworCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQki JXMgYnVmZmVyIHtpZDolZCBrZXk6JWQgJWQgJWR9IHBhZ2VzIG5vdCBtYXBwZWQgeWV0XG4iLCBf X2Z1bmNfXywKLQkJCXNndF9pbmZvLT5oaWQuaWQsIHNndF9pbmZvLT5oaWQucm5nX2tleVswXSwg c2d0X2luZm8tPmhpZC5ybmdfa2V5WzFdLAotCQkJc2d0X2luZm8tPmhpZC5ybmdfa2V5WzJdKTsK KwkJCWltcG9ydGVkLT5oaWQuaWQsIGltcG9ydGVkLT5oaWQucm5nX2tleVswXSwgaW1wb3J0ZWQt PmhpZC5ybmdfa2V5WzFdLAorCQkJaW1wb3J0ZWQtPmhpZC5ybmdfa2V5WzJdKTsKIAotCQlkYXRh X3BhZ2VzID0gb3BzLT5tYXBfc2hhcmVkX3BhZ2VzKHNndF9pbmZvLT5yZWZfaGFuZGxlLAotCQkJ CQkJICAgSFlQRVJfRE1BQlVGX0RPTV9JRChzZ3RfaW5mby0+aGlkKSwKLQkJCQkJCSAgIHNndF9p bmZvLT5uZW50cywKLQkJCQkJCSAgICZzZ3RfaW5mby0+cmVmc19pbmZvKTsKKwkJZGF0YV9wZ3Mg PSBvcHMtPm1hcF9zaGFyZWRfcGFnZXMoaW1wb3J0ZWQtPnJlZl9oYW5kbGUsCisJCQkJCQkgICBI WVBFUl9ETUFCVUZfRE9NX0lEKGltcG9ydGVkLT5oaWQpLAorCQkJCQkJICAgaW1wb3J0ZWQtPm5l bnRzLAorCQkJCQkJICAgJmltcG9ydGVkLT5yZWZzX2luZm8pOwogCi0JCWlmICghZGF0YV9wYWdl cykgewotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCWlmICghZGF0 YV9wZ3MpIHsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCQkiQ2Fubm90IG1hcCBw YWdlcyBvZiBidWZmZXIge2lkOiVkIGtleTolZCAlZCAlZH1cbiIsCi0JCQkJc2d0X2luZm8tPmhp ZC5pZCwgc2d0X2luZm8tPmhpZC5ybmdfa2V5WzBdLCBzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMV0s Ci0JCQkJc2d0X2luZm8tPmhpZC5ybmdfa2V5WzJdKTsKKwkJCQlpbXBvcnRlZC0+aGlkLmlkLCBp bXBvcnRlZC0+aGlkLnJuZ19rZXlbMF0sIGltcG9ydGVkLT5oaWQucm5nX2tleVsxXSwKKwkJCQlp bXBvcnRlZC0+aGlkLnJuZ19rZXlbMl0pOwogCi0JCQlzZ3RfaW5mby0+bnVtX2ltcG9ydGVycy0t OworCQkJaW1wb3J0ZWQtPmltcG9ydGVycy0tOwogCQkJcmVxID0ga2NhbGxvYygxLCBzaXplb2Yo KnJlcSksIEdGUF9LRVJORUwpOwogCiAJCQlpZiAoIXJlcSkgewotCQkJCWRldl9lcnIoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJ CQkJIk5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CiAJCQkJcmV0dXJuIC1FTk9NRU07CiAJCQl9CiAK LQkJCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChyZXEsIEhZUEVSX0RNQUJVRl9FWFBPUlRf RkRfRkFJTEVELCAmb3BlcmFuZHNbMF0pOwotCQkJb3BzLT5zZW5kX3JlcShIWVBFUl9ETUFCVUZf RE9NX0lEKHNndF9pbmZvLT5oaWQpLCByZXEsIGZhbHNlKTsKKwkJCWh5cGVyX2RtYWJ1Zl9jcmVh dGVfcmVxKHJlcSwgSFlQRVJfRE1BQlVGX0VYUE9SVF9GRF9GQUlMRUQsICZvcFswXSk7CisJCQlv cHMtPnNlbmRfcmVxKEhZUEVSX0RNQUJVRl9ET01fSUQoaW1wb3J0ZWQtPmhpZCksIHJlcSwgZmFs c2UpOwogCQkJa2ZyZWUocmVxKTsKLQkJCW11dGV4X3VubG9jaygmaHlwZXJfZG1hYnVmX3ByaXZh dGUubG9jayk7CisJCQltdXRleF91bmxvY2soJmh5X2Rydl9wcml2LT5sb2NrKTsKIAkJCXJldHVy biAtRUlOVkFMOwogCQl9CiAKLQkJc2d0X2luZm8tPnNndCA9IGh5cGVyX2RtYWJ1Zl9jcmVhdGVf c2d0KGRhdGFfcGFnZXMsIHNndF9pbmZvLT5mcnN0X29mc3QsCi0JCQkJCQkJc2d0X2luZm8tPmxh c3RfbGVuLCBzZ3RfaW5mby0+bmVudHMpOworCQlpbXBvcnRlZC0+c2d0ID0gaHlwZXJfZG1hYnVm X2NyZWF0ZV9zZ3QoZGF0YV9wZ3MsIGltcG9ydGVkLT5mcnN0X29mc3QsCisJCQkJCQkJaW1wb3J0 ZWQtPmxhc3RfbGVuLCBpbXBvcnRlZC0+bmVudHMpOwogCiAJfQogCi0JZXhwb3J0X2ZkX2F0dHIt PmZkID0gaHlwZXJfZG1hYnVmX2V4cG9ydF9mZChzZ3RfaW5mbywgZXhwb3J0X2ZkX2F0dHItPmZs YWdzKTsKKwlleHBvcnRfZmRfYXR0ci0+ZmQgPSBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkKGltcG9y dGVkLCBleHBvcnRfZmRfYXR0ci0+ZmxhZ3MpOwogCiAJaWYgKGV4cG9ydF9mZF9hdHRyLT5mZCA8 IDApIHsKIAkJLyogZmFpbCB0byBnZXQgZmQgKi8KIAkJcmV0ID0gZXhwb3J0X2ZkX2F0dHItPmZk OwogCX0KIAotCW11dGV4X3VubG9jaygmaHlwZXJfZG1hYnVmX3ByaXZhdGUubG9jayk7CisJbXV0 ZXhfdW5sb2NrKCZoeV9kcnZfcHJpdi0+bG9jayk7CiAKLQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9w cml2YXRlLmRldmljZSwgIiVzIGV4aXRcbiIsIF9fZnVuY19fKTsKKwlkZXZfZGJnKGh5X2Rydl9w cml2LT5kZXYsICIlcyBleGl0XG4iLCBfX2Z1bmNfXyk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAt NTQxLDUwICs1NDcsNTEgQEAgc3RhdGljIGludCBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkX2lvY3Rs KHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQogc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVm X2RlbGF5ZWRfdW5leHBvcnQoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCBo eXBlcl9kbWFidWZfcmVxICpyZXE7CisJc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAq b3BzID0gaHlfZHJ2X3ByaXYtPmJhY2tlbmRfb3BzOworCXN0cnVjdCBleHBvcnRlZF9zZ3RfaW5m byAqZXhwb3J0ZWQgPQorCQljb250YWluZXJfb2Yod29yaywgc3RydWN0IGV4cG9ydGVkX3NndF9p bmZvLCB1bmV4cG9ydC53b3JrKTsKKwlpbnQgb3BbNF07CiAJaW50IGksIHJldDsKLQlpbnQgb3Bl cmFuZHNbNF07Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAqb3BzID0gaHlwZXJf ZG1hYnVmX3ByaXZhdGUuYmFja2VuZF9vcHM7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5m byAqc2d0X2luZm8gPQotCQljb250YWluZXJfb2Yod29yaywgc3RydWN0IGh5cGVyX2RtYWJ1Zl9z Z3RfaW5mbywgdW5leHBvcnRfd29yay53b3JrKTsKIAotCWlmICghc2d0X2luZm8pCisJaWYgKCFl eHBvcnRlZCkKIAkJcmV0dXJuOwogCi0JZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZp Y2UsCisJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LAogCQkiTWFya2luZyBidWZmZXIge2lkOiVk IGtleTolZCAlZCAlZH0gYXMgaW52YWxpZFxuIiwKLQkJc2d0X2luZm8tPmhpZC5pZCwgc2d0X2lu Zm8tPmhpZC5ybmdfa2V5WzBdLCBzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMV0sCi0JCXNndF9pbmZv LT5oaWQucm5nX2tleVsyXSk7CisJCWV4cG9ydGVkLT5oaWQuaWQsIGV4cG9ydGVkLT5oaWQucm5n X2tleVswXSwKKwkJZXhwb3J0ZWQtPmhpZC5ybmdfa2V5WzFdLCBleHBvcnRlZC0+aGlkLnJuZ19r ZXlbMl0pOwogCiAJLyogbm8gbG9uZ2VyIHZhbGlkICovCi0Jc2d0X2luZm8tPnZhbGlkID0gMDsK KwlleHBvcnRlZC0+dmFsaWQgPSBmYWxzZTsKIAogCXJlcSA9IGtjYWxsb2MoMSwgc2l6ZW9mKCpy ZXEpLCBHRlBfS0VSTkVMKTsKIAogCWlmICghcmVxKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVm X3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiTm8gbWVt b3J5IGxlZnQgdG8gYmUgYWxsb2NhdGVkXG4iKTsKIAkJcmV0dXJuOwogCX0KIAotCW9wZXJhbmRz WzBdID0gc2d0X2luZm8tPmhpZC5pZDsKKwlvcFswXSA9IGV4cG9ydGVkLT5oaWQuaWQ7CiAKIAlm b3IgKGk9MDsgaTwzOyBpKyspCi0JCW9wZXJhbmRzW2krMV0gPSBzZ3RfaW5mby0+aGlkLnJuZ19r ZXlbaV07CisJCW9wW2krMV0gPSBleHBvcnRlZC0+aGlkLnJuZ19rZXlbaV07CiAKLQloeXBlcl9k bWFidWZfY3JlYXRlX3JlcXVlc3QocmVxLCBIWVBFUl9ETUFCVUZfTk9USUZZX1VORVhQT1JULCAm b3BlcmFuZHNbMF0pOworCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxKHJlcSwgSFlQRVJfRE1BQlVG X05PVElGWV9VTkVYUE9SVCwgJm9wWzBdKTsKIAotCS8qIE5vdyBzZW5kIHVuZXhwb3J0IHJlcXVl c3QgdG8gcmVtb3RlIGRvbWFpbiwgbWFya2luZyB0aGF0IGJ1ZmZlciBzaG91bGQgbm90IGJlIHVz ZWQgYW55bW9yZSAqLwotCXJldCA9IG9wcy0+c2VuZF9yZXEoc2d0X2luZm8tPmh5cGVyX2RtYWJ1 Zl9yZG9tYWluLCByZXEsIHRydWUpOworCS8qIE5vdyBzZW5kIHVuZXhwb3J0IHJlcXVlc3QgdG8g cmVtb3RlIGRvbWFpbiwgbWFya2luZworCSAqIHRoYXQgYnVmZmVyIHNob3VsZCBub3QgYmUgdXNl ZCBhbnltb3JlICovCisJcmV0ID0gb3BzLT5zZW5kX3JlcShleHBvcnRlZC0+cmRvbWlkLCByZXEs IHRydWUpOwogCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUu ZGV2aWNlLAorCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkidW5leHBvcnQgbWVzc2Fn ZSBmb3IgYnVmZmVyIHtpZDolZCBrZXk6JWQgJWQgJWR9IGZhaWxlZFxuIiwKLQkJCXNndF9pbmZv LT5oaWQuaWQsIHNndF9pbmZvLT5oaWQucm5nX2tleVswXSwgc2d0X2luZm8tPmhpZC5ybmdfa2V5 WzFdLAotCQkJc2d0X2luZm8tPmhpZC5ybmdfa2V5WzJdKTsKKwkJCWV4cG9ydGVkLT5oaWQuaWQs IGV4cG9ydGVkLT5oaWQucm5nX2tleVswXSwKKwkJCWV4cG9ydGVkLT5oaWQucm5nX2tleVsxXSwg ZXhwb3J0ZWQtPmhpZC5ybmdfa2V5WzJdKTsKIAl9CiAKIAkvKiBmcmVlIG1zZyAqLwogCWtmcmVl KHJlcSk7Ci0Jc2d0X2luZm8tPnVuZXhwb3J0X3NjaGVkdWxlZCA9IDA7CisJZXhwb3J0ZWQtPnVu ZXhwb3J0X3NjaGVkID0gZmFsc2U7CiAKIAkvKgogCSAqIEltbWVkaWF0ZWx5IGNsZWFuLXVwIGlm IGl0IGhhcyBuZXZlciBiZWVuIGV4cG9ydGVkIGJ5IGltcG9ydGVyCkBAIC01OTMsMTA0ICs2MDAs OTQgQEAgc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX2RlbGF5ZWRfdW5leHBvcnQoc3RydWN0IHdv cmtfc3RydWN0ICp3b3JrKQogCSAqIGlzIGNhbGxlZCAoaW1wb3J0ZXIgZG9lcyB0aGlzIG9ubHkg d2hlbiB0aGVyZSdzIG5vCiAJICogbm8gY29uc3VtZXIgb2YgbG9jYWxseSBleHBvcnRlZCBGRHMp CiAJICovCi0JaWYgKCFzZ3RfaW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQpIHsKLQkJZGV2X2RiZyho eXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJaWYgKGV4cG9ydGVkLT5hY3RpdmUgPT0gMCkg eworCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiY2xhbmluZyB1cCBidWZmZXIge2lk OiVkIGtleTolZCAlZCAlZH0gY29tcGxldGx5XG4iLAotCQkJc2d0X2luZm8tPmhpZC5pZCwgc2d0 X2luZm8tPmhpZC5ybmdfa2V5WzBdLCBzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMV0sCi0JCQlzZ3Rf aW5mby0+aGlkLnJuZ19rZXlbMl0pOworCQkJZXhwb3J0ZWQtPmhpZC5pZCwgZXhwb3J0ZWQtPmhp ZC5ybmdfa2V5WzBdLAorCQkJZXhwb3J0ZWQtPmhpZC5ybmdfa2V5WzFdLCBleHBvcnRlZC0+aGlk LnJuZ19rZXlbMl0pOworCisJCWh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKGV4cG9ydGVk LCBmYWxzZSk7CisJCWh5cGVyX2RtYWJ1Zl9yZW1vdmVfZXhwb3J0ZWQoZXhwb3J0ZWQtPmhpZCk7 CiAKLQkJaHlwZXJfZG1hYnVmX2NsZWFudXBfc2d0X2luZm8oc2d0X2luZm8sIGZhbHNlKTsKLQkJ aHlwZXJfZG1hYnVmX3JlbW92ZV9leHBvcnRlZChzZ3RfaW5mby0+aGlkKTsKIAkJLyogcmVnaXN0 ZXIgaHlwZXJfZG1hYnVmX2lkIHRvIHRoZSBsaXN0IGZvciByZXVzZSAqLwotCQlzdG9yZV9yZXVz YWJsZV9oaWQoc2d0X2luZm8tPmhpZCk7CisJCXN0b3JlX3JldXNhYmxlX2hpZChleHBvcnRlZC0+ aGlkKTsKIAotCQlpZiAoc2d0X2luZm8tPnN6X3ByaXYgPiAwICYmICFzZ3RfaW5mby0+cHJpdikK LQkJCWtmcmVlKHNndF9pbmZvLT5wcml2KTsKKwkJaWYgKGV4cG9ydGVkLT5zel9wcml2ID4gMCAm JiAhZXhwb3J0ZWQtPnByaXYpCisJCQlrZnJlZShleHBvcnRlZC0+cHJpdik7CiAKLQkJa2ZyZWUo c2d0X2luZm8pOworCQlrZnJlZShleHBvcnRlZCk7CiAJfQogfQogCi0vKiBTY2hlZHVsZXMgdW5l eHBvcnQgb2YgZG1hYnVmLgorLyogU2NoZWR1bGUgdW5leHBvcnQgb2YgZG1hYnVmLgogICovCi1z dGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl91bmV4cG9ydF9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwg dm9pZCAqZGF0YSkKK2ludCBoeXBlcl9kbWFidWZfdW5leHBvcnRfaW9jdGwoc3RydWN0IGZpbGUg KmZpbHAsIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl91bmV4cG9y dCAqdW5leHBvcnRfYXR0cjsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvICpzZ3RfaW5m bzsKKwlzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3VuZXhwb3J0ICp1bmV4cG9ydF9hdHRyID0K KwkJCShzdHJ1Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX3VuZXhwb3J0ICopZGF0YTsKKwlzdHJ1Y3Qg ZXhwb3J0ZWRfc2d0X2luZm8gKmV4cG9ydGVkOwogCi0JZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJp dmF0ZS5kZXZpY2UsICIlcyBlbnRyeVxuIiwgX19mdW5jX18pOwotCi0JaWYgKCFkYXRhKSB7Ci0J CWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAidXNlciBkYXRhIGlzIE5VTExc biIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQl1bmV4cG9ydF9hdHRyID0gKHN0cnVjdCBp b2N0bF9oeXBlcl9kbWFidWZfdW5leHBvcnQgKilkYXRhOworCWRldl9kYmcoaHlfZHJ2X3ByaXYt PmRldiwgIiVzIGVudHJ5XG4iLCBfX2Z1bmNfXyk7CiAKIAkvKiBmaW5kIGRtYWJ1ZiBpbiBleHBv cnQgbGlzdCAqLwotCXNndF9pbmZvID0gaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQodW5leHBv cnRfYXR0ci0+aGlkKTsKKwlleHBvcnRlZCA9IGh5cGVyX2RtYWJ1Zl9maW5kX2V4cG9ydGVkKHVu ZXhwb3J0X2F0dHItPmhpZCk7CiAKLQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmlj ZSwKKwlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCSJzY2hlZHVsaW5nIHVuZXhwb3J0IG9m IGJ1ZmZlciB7aWQ6JWQga2V5OiVkICVkICVkfVxuIiwKIAkJdW5leHBvcnRfYXR0ci0+aGlkLmlk LCB1bmV4cG9ydF9hdHRyLT5oaWQucm5nX2tleVswXSwKIAkJdW5leHBvcnRfYXR0ci0+aGlkLnJu Z19rZXlbMV0sIHVuZXhwb3J0X2F0dHItPmhpZC5ybmdfa2V5WzJdKTsKIAogCS8qIGZhaWxlZCB0 byBmaW5kIGNvcnJlc3BvbmRpbmcgZW50cnkgaW4gZXhwb3J0IGxpc3QgKi8KLQlpZiAoc2d0X2lu Zm8gPT0gTlVMTCkgeworCWlmIChleHBvcnRlZCA9PSBOVUxMKSB7CiAJCXVuZXhwb3J0X2F0dHIt PnN0YXR1cyA9IC1FTk9FTlQ7CiAJCXJldHVybiAtRU5PRU5UOwogCX0KIAotCWlmIChzZ3RfaW5m by0+dW5leHBvcnRfc2NoZWR1bGVkKQorCWlmIChleHBvcnRlZC0+dW5leHBvcnRfc2NoZWQpCiAJ CXJldHVybiAwOwogCi0Jc2d0X2luZm8tPnVuZXhwb3J0X3NjaGVkdWxlZCA9IDE7Ci0JSU5JVF9E RUxBWUVEX1dPUksoJnNndF9pbmZvLT51bmV4cG9ydF93b3JrLCBoeXBlcl9kbWFidWZfZGVsYXll ZF91bmV4cG9ydCk7Ci0Jc2NoZWR1bGVfZGVsYXllZF93b3JrKCZzZ3RfaW5mby0+dW5leHBvcnRf d29yaywKKwlleHBvcnRlZC0+dW5leHBvcnRfc2NoZWQgPSB0cnVlOworCUlOSVRfREVMQVlFRF9X T1JLKCZleHBvcnRlZC0+dW5leHBvcnQsCisJCQkgIGh5cGVyX2RtYWJ1Zl9kZWxheWVkX3VuZXhw b3J0KTsKKwlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmV4cG9ydGVkLT51bmV4cG9ydCwKIAkJCSAg ICAgIG1zZWNzX3RvX2ppZmZpZXModW5leHBvcnRfYXR0ci0+ZGVsYXlfbXMpKTsKIAotCWRldl9k YmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiJXMgZXhpdFxuIiwgX19mdW5jX18pOwor CWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwgIiVzIGV4aXRcbiIsIF9fZnVuY19fKTsKIAlyZXR1 cm4gMDsKIH0KIAogc3RhdGljIGludCBoeXBlcl9kbWFidWZfcXVlcnlfaW9jdGwoc3RydWN0IGZp bGUgKmZpbHAsIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IGlvY3RsX2h5cGVyX2RtYWJ1Zl9xdWVy eSAqcXVlcnlfYXR0cjsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvICpzZ3RfaW5mbyA9 IE5VTEw7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWRf c2d0X2luZm8gPSBOVUxMOworCXN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfcXVlcnkgKnF1ZXJ5 X2F0dHIgPQorCQkJKHN0cnVjdCBpb2N0bF9oeXBlcl9kbWFidWZfcXVlcnkgKilkYXRhOworCXN0 cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyAqZXhwb3J0ZWQgPSBOVUxMOworCXN0cnVjdCBpbXBvcnRl ZF9zZ3RfaW5mbyAqaW1wb3J0ZWQgPSBOVUxMOwogCWludCByZXQgPSAwOwogCi0JaWYgKCFkYXRh KSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAidXNlciBkYXRhIGlz IE5VTExcbiIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlxdWVyeV9hdHRyID0gKHN0cnVj dCBpb2N0bF9oeXBlcl9kbWFidWZfcXVlcnkgKilkYXRhOwotCi0JaWYgKEhZUEVSX0RNQUJVRl9E T01fSUQocXVlcnlfYXR0ci0+aGlkKSA9PSBoeXBlcl9kbWFidWZfcHJpdmF0ZS5kb21pZCkgewor CWlmIChIWVBFUl9ETUFCVUZfRE9NX0lEKHF1ZXJ5X2F0dHItPmhpZCkgPT0gaHlfZHJ2X3ByaXYt PmRvbWlkKSB7CiAJCS8qIHF1ZXJ5IGZvciBleHBvcnRlZCBkbWFidWYgKi8KLQkJc2d0X2luZm8g PSBoeXBlcl9kbWFidWZfZmluZF9leHBvcnRlZChxdWVyeV9hdHRyLT5oaWQpOwotCQlpZiAoc2d0 X2luZm8pIHsKLQkJCXJldCA9IGh5cGVyX2RtYWJ1Zl9xdWVyeV9leHBvcnRlZChzZ3RfaW5mbywK KwkJZXhwb3J0ZWQgPSBoeXBlcl9kbWFidWZfZmluZF9leHBvcnRlZChxdWVyeV9hdHRyLT5oaWQp OworCQlpZiAoZXhwb3J0ZWQpIHsKKwkJCXJldCA9IGh5cGVyX2RtYWJ1Zl9xdWVyeV9leHBvcnRl ZChleHBvcnRlZCwKIAkJCQkJCQkgIHF1ZXJ5X2F0dHItPml0ZW0sICZxdWVyeV9hdHRyLT5pbmZv KTsKIAkJfSBlbHNlIHsKLQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAot CQkJCSJETUEgQlVGIHtpZDolZCBrZXk6JWQgJWQgJWR9IGNhbid0IGJlIGZvdW5kIGluIHRoZSBl eHBvcnQgbGlzdFxuIiwKLQkJCQlxdWVyeV9hdHRyLT5oaWQuaWQsIHF1ZXJ5X2F0dHItPmhpZC5y bmdfa2V5WzBdLCBxdWVyeV9hdHRyLT5oaWQucm5nX2tleVsxXSwKLQkJCQlxdWVyeV9hdHRyLT5o aWQucm5nX2tleVsyXSk7CisJCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkJIkRNQSBC VUYge2lkOiVkIGtleTolZCAlZCAlZH0gbm90IGluIHRoZSBleHBvcnQgbGlzdFxuIiwKKwkJCQlx dWVyeV9hdHRyLT5oaWQuaWQsIHF1ZXJ5X2F0dHItPmhpZC5ybmdfa2V5WzBdLAorCQkJCXF1ZXJ5 X2F0dHItPmhpZC5ybmdfa2V5WzFdLCBxdWVyeV9hdHRyLT5oaWQucm5nX2tleVsyXSk7CiAJCQly ZXR1cm4gLUVOT0VOVDsKIAkJfQogCX0gZWxzZSB7CiAJCS8qIHF1ZXJ5IGZvciBpbXBvcnRlZCBk bWFidWYgKi8KLQkJaW1wb3J0ZWRfc2d0X2luZm8gPSBoeXBlcl9kbWFidWZfZmluZF9pbXBvcnRl ZChxdWVyeV9hdHRyLT5oaWQpOwotCQlpZiAoaW1wb3J0ZWRfc2d0X2luZm8pIHsKLQkJCXJldCA9 IGh5cGVyX2RtYWJ1Zl9xdWVyeV9pbXBvcnRlZChpbXBvcnRlZF9zZ3RfaW5mbywKLQkJCQkJCQkg IHF1ZXJ5X2F0dHItPml0ZW0sICZxdWVyeV9hdHRyLT5pbmZvKTsKKwkJaW1wb3J0ZWQgPSBoeXBl cl9kbWFidWZfZmluZF9pbXBvcnRlZChxdWVyeV9hdHRyLT5oaWQpOworCQlpZiAoaW1wb3J0ZWQp IHsKKwkJCXJldCA9IGh5cGVyX2RtYWJ1Zl9xdWVyeV9pbXBvcnRlZChpbXBvcnRlZCwgcXVlcnlf YXR0ci0+aXRlbSwKKwkJCQkJCQkgICZxdWVyeV9hdHRyLT5pbmZvKTsKIAkJfSBlbHNlIHsKLQkJ CWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJCSJETUEgQlVGIHtpZDol ZCBrZXk6JWQgJWQgJWR9IGNhbid0IGJlIGZvdW5kIGluIHRoZSBpbXBvcnRlZCBsaXN0XG4iLAot CQkJCXF1ZXJ5X2F0dHItPmhpZC5pZCwgcXVlcnlfYXR0ci0+aGlkLnJuZ19rZXlbMF0sIHF1ZXJ5 X2F0dHItPmhpZC5ybmdfa2V5WzFdLAotCQkJCXF1ZXJ5X2F0dHItPmhpZC5ybmdfa2V5WzJdKTsK KwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkiRE1BIEJVRiB7aWQ6JWQga2V5OiVk ICVkICVkfSBub3QgaW4gdGhlIGltcG9ydGVkIGxpc3RcbiIsCisJCQkJcXVlcnlfYXR0ci0+aGlk LmlkLCBxdWVyeV9hdHRyLT5oaWQucm5nX2tleVswXSwKKwkJCQlxdWVyeV9hdHRyLT5oaWQucm5n X2tleVsxXSwgcXVlcnlfYXR0ci0+aGlkLnJuZ19rZXlbMl0pOwogCQkJcmV0dXJuIC1FTk9FTlQ7 CiAJCX0KIAl9CkBAIC02OTgsMjggKzY5NSw2IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX3F1 ZXJ5X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2b2lkICpkYXRhKQogCXJldHVybiByZXQ7CiB9 CiAKLXZvaWQgaHlwZXJfZG1hYnVmX2VtZXJnZW5jeV9yZWxlYXNlKHN0cnVjdCBoeXBlcl9kbWFi dWZfc2d0X2luZm8qIHNndF9pbmZvLAotCQkJCSAgICB2b2lkICphdHRyKQotewotCXN0cnVjdCBp b2N0bF9oeXBlcl9kbWFidWZfdW5leHBvcnQgdW5leHBvcnRfYXR0cjsKLQlzdHJ1Y3QgZmlsZSAq ZmlscCA9IChzdHJ1Y3QgZmlsZSopIGF0dHI7Ci0KLQlpZiAoIWZpbHAgfHwgIXNndF9pbmZvKQot CQlyZXR1cm47Ci0KLQlpZiAoc2d0X2luZm8tPmZpbHAgPT0gZmlscCkgewotCQlkZXZfZGJnKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCSJFeGVjdXRpbmcgZW1lcmdlbmN5IHJlbGVh c2Ugb2YgYnVmZmVyIHtpZDolZCBrZXk6JWQgJWQgJWR9XG4iLAotCQkJIHNndF9pbmZvLT5oaWQu aWQsIHNndF9pbmZvLT5oaWQucm5nX2tleVswXSwKLQkJCSBzZ3RfaW5mby0+aGlkLnJuZ19rZXlb MV0sIHNndF9pbmZvLT5oaWQucm5nX2tleVsyXSk7Ci0KLQkJdW5leHBvcnRfYXR0ci5oaWQgPSBz Z3RfaW5mby0+aGlkOwotCQl1bmV4cG9ydF9hdHRyLmRlbGF5X21zID0gMDsKLQotCQloeXBlcl9k bWFidWZfdW5leHBvcnRfaW9jdGwoZmlscCwgJnVuZXhwb3J0X2F0dHIpOwotCX0KLX0KLQogY29u c3Qgc3RydWN0IGh5cGVyX2RtYWJ1Zl9pb2N0bF9kZXNjIGh5cGVyX2RtYWJ1Zl9pb2N0bHNbXSA9 IHsKIAlIWVBFUl9ETUFCVUZfSU9DVExfREVGKElPQ1RMX0hZUEVSX0RNQUJVRl9UWF9DSF9TRVRV UCwgaHlwZXJfZG1hYnVmX3R4X2NoX3NldHVwX2lvY3RsLCAwKSwKIAlIWVBFUl9ETUFCVUZfSU9D VExfREVGKElPQ1RMX0hZUEVSX0RNQUJVRl9SWF9DSF9TRVRVUCwgaHlwZXJfZG1hYnVmX3J4X2No X3NldHVwX2lvY3RsLCAwKSwKQEAgLTczOSw3ICs3MTQsNyBAQCBsb25nIGh5cGVyX2RtYWJ1Zl9p b2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwKIAljaGFyICprZGF0YTsKIAogCWlmIChuciA+IEFSUkFZ X1NJWkUoaHlwZXJfZG1hYnVmX2lvY3RscykpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJp dmF0ZS5kZXZpY2UsICJpbnZhbGlkIGlvY3RsXG4iKTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ ZGV2LCAiaW52YWxpZCBpb2N0bFxuIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApAQCAtNzQ4 LDE4ICs3MjMsMTggQEAgbG9uZyBoeXBlcl9kbWFidWZfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAs CiAJZnVuYyA9IGlvY3RsLT5mdW5jOwogCiAJaWYgKHVubGlrZWx5KCFmdW5jKSkgewotCQlkZXZf ZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIm5vIGZ1bmN0aW9uXG4iKTsKKwkJZGV2 X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAibm8gZnVuY3Rpb25cbiIpOwogCQlyZXR1cm4gLUVJTlZB TDsKIAl9CiAKIAlrZGF0YSA9IGttYWxsb2MoX0lPQ19TSVpFKGNtZCksIEdGUF9LRVJORUwpOwog CWlmICgha2RhdGEpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJu byBtZW1vcnlcbiIpOworCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsICJubyBtZW1vcnlcbiIp OwogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKIAlpZiAoY29weV9mcm9tX3VzZXIoa2RhdGEsICh2 b2lkIF9fdXNlciAqKXBhcmFtLCBfSU9DX1NJWkUoY21kKSkgIT0gMCkgewotCQlkZXZfZXJyKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgImZhaWxlZCB0byBjb3B5IGZyb20gdXNlciBhcmd1 bWVudHNcbiIpOworCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsICJmYWlsZWQgdG8gY29weSBm cm9tIHVzZXIgYXJndW1lbnRzXG4iKTsKIAkJcmV0ID0gLUVGQVVMVDsKIAkJZ290byBpb2N0bF9l cnJvcjsKIAl9CkBAIC03NjcsNyArNzQyLDcgQEAgbG9uZyBoeXBlcl9kbWFidWZfaW9jdGwoc3Ry dWN0IGZpbGUgKmZpbHAsCiAJcmV0ID0gZnVuYyhmaWxwLCBrZGF0YSk7CiAKIAlpZiAoY29weV90 b191c2VyKCh2b2lkIF9fdXNlciAqKXBhcmFtLCBrZGF0YSwgX0lPQ19TSVpFKGNtZCkpICE9IDAp IHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJmYWlsZWQgdG8gY29w eSB0byB1c2VyIGFyZ3VtZW50c1xuIik7CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgImZh aWxlZCB0byBjb3B5IHRvIHVzZXIgYXJndW1lbnRzXG4iKTsKIAkJcmV0ID0gLUVGQVVMVDsKIAkJ Z290byBpb2N0bF9lcnJvcjsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX2lvY3RsLmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX2lvY3RsLmgKaW5kZXggZWJmYmI4NC4uM2U5NDcwYSAxMDA2NDQKLS0tIGEvZHJpdmVy cy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5oCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuaApAQCAtNDIsNCArNDIsNiBAQCBzdHJ1 Y3QgaHlwZXJfZG1hYnVmX2lvY3RsX2Rlc2MgewogCQkJLm5hbWUgPSAjaW9jdGwJCQlcCiAJfQog CitpbnQgaHlwZXJfZG1hYnVmX3VuZXhwb3J0X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB2b2lk ICpkYXRhKTsKKwogI2VuZGlmIC8vX19IWVBFUl9ETUFCVUZfSU9DVExfSF9fCmRpZmYgLS1naXQg YS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2xpc3QuYyBiL2RyaXZlcnMv eGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5jCmluZGV4IGVhZWYyYzEuLjFiMzc0 NWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlz dC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbGlzdC5jCkBA IC0zOSwyNCArMzksMjIgQEAKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfaWQuaCIKICNpbmNsdWRl ICJoeXBlcl9kbWFidWZfZXZlbnQuaCIKIAotZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfcHJp dmF0ZSBoeXBlcl9kbWFidWZfcHJpdmF0ZTsKLQogREVDTEFSRV9IQVNIVEFCTEUoaHlwZXJfZG1h YnVmX2hhc2hfaW1wb3J0ZWQsIE1BWF9FTlRSWV9JTVBPUlRFRCk7CiBERUNMQVJFX0hBU0hUQUJM RShoeXBlcl9kbWFidWZfaGFzaF9leHBvcnRlZCwgTUFYX0VOVFJZX0VYUE9SVEVEKTsKIAogI2lm ZGVmIENPTkZJR19IWVBFUl9ETUFCVUZfU1lTRlMKIHN0YXRpYyBzc2l6ZV90IGh5cGVyX2RtYWJ1 Zl9pbXBvcnRlZF9zaG93KHN0cnVjdCBkZXZpY2UgKmRydiwgc3RydWN0IGRldmljZV9hdHRyaWJ1 dGUgKmF0dHIsIGNoYXIgKmJ1ZikKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2luZm9fZW50cnlf aW1wb3J0ZWQgKmluZm9fZW50cnk7CisJc3RydWN0IGxpc3RfZW50cnlfaW1wb3J0ZWQgKmluZm9f ZW50cnk7CiAJaW50IGJrdDsKIAlzc2l6ZV90IGNvdW50ID0gMDsKIAlzaXplX3QgdG90YWwgPSAw OwogCiAJaGFzaF9mb3JfZWFjaChoeXBlcl9kbWFidWZfaGFzaF9pbXBvcnRlZCwgYmt0LCBpbmZv X2VudHJ5LCBub2RlKSB7Ci0JCWh5cGVyX2RtYWJ1Zl9pZF90IGhpZCA9IGluZm9fZW50cnktPmlu Zm8tPmhpZDsKLQkJaW50IG5lbnRzID0gaW5mb19lbnRyeS0+aW5mby0+bmVudHM7Ci0JCWJvb2wg dmFsaWQgPSBpbmZvX2VudHJ5LT5pbmZvLT52YWxpZDsKLQkJaW50IG51bV9pbXBvcnRlcnMgPSBp bmZvX2VudHJ5LT5pbmZvLT5udW1faW1wb3J0ZXJzOworCQloeXBlcl9kbWFidWZfaWRfdCBoaWQg PSBpbmZvX2VudHJ5LT5pbXBvcnRlZC0+aGlkOworCQlpbnQgbmVudHMgPSBpbmZvX2VudHJ5LT5p bXBvcnRlZC0+bmVudHM7CisJCWJvb2wgdmFsaWQgPSBpbmZvX2VudHJ5LT5pbXBvcnRlZC0+dmFs aWQ7CisJCWludCBudW1faW1wb3J0ZXJzID0gaW5mb19lbnRyeS0+aW1wb3J0ZWQtPmltcG9ydGVy czsKIAkJdG90YWwgKz0gbmVudHM7CiAJCWNvdW50ICs9IHNjbnByaW50ZihidWYgKyBjb3VudCwg UEFHRV9TSVpFIC0gY291bnQsCiAJCQkJICAgImhpZDp7aWQ6JWQga2V5czolZCAlZCAlZH0sIG5l bnRzOiVkLCB2OiVjLCBudW1pOiVkXG4iLApAQCAtNzEsMTYgKzY5LDE2IEBAIHN0YXRpYyBzc2l6 ZV90IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zaG93KHN0cnVjdCBkZXZpY2UgKmRydiwgc3RydWN0 IGRldmljZV9hdHRyCiAKIHN0YXRpYyBzc2l6ZV90IGh5cGVyX2RtYWJ1Zl9leHBvcnRlZF9zaG93 KHN0cnVjdCBkZXZpY2UgKmRydiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIg KmJ1ZikKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2luZm9fZW50cnlfZXhwb3J0ZWQgKmluZm9f ZW50cnk7CisJc3RydWN0IGxpc3RfZW50cnlfZXhwb3J0ZWQgKmluZm9fZW50cnk7CiAJaW50IGJr dDsKIAlzc2l6ZV90IGNvdW50ID0gMDsKIAlzaXplX3QgdG90YWwgPSAwOwogCiAJaGFzaF9mb3Jf ZWFjaChoeXBlcl9kbWFidWZfaGFzaF9leHBvcnRlZCwgYmt0LCBpbmZvX2VudHJ5LCBub2RlKSB7 Ci0JCWh5cGVyX2RtYWJ1Zl9pZF90IGhpZCA9IGluZm9fZW50cnktPmluZm8tPmhpZDsKLQkJaW50 IG5lbnRzID0gaW5mb19lbnRyeS0+aW5mby0+bmVudHM7Ci0JCWJvb2wgdmFsaWQgPSBpbmZvX2Vu dHJ5LT5pbmZvLT52YWxpZDsKLQkJaW50IGltcG9ydGVyX2V4cG9ydGVkID0gaW5mb19lbnRyeS0+ aW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQ7CisJCWh5cGVyX2RtYWJ1Zl9pZF90IGhpZCA9IGluZm9f ZW50cnktPmV4cG9ydGVkLT5oaWQ7CisJCWludCBuZW50cyA9IGluZm9fZW50cnktPmV4cG9ydGVk LT5uZW50czsKKwkJYm9vbCB2YWxpZCA9IGluZm9fZW50cnktPmV4cG9ydGVkLT52YWxpZDsKKwkJ aW50IGltcG9ydGVyX2V4cG9ydGVkID0gaW5mb19lbnRyeS0+ZXhwb3J0ZWQtPmFjdGl2ZTsKIAkJ dG90YWwgKz0gbmVudHM7CiAJCWNvdW50ICs9IHNjbnByaW50ZihidWYgKyBjb3VudCwgUEFHRV9T SVpFIC0gY291bnQsCiAJCQkJICAgImhpZDp7aGlkOiVkIGtleXM6JWQgJWQgJWR9LCBuZW50czol ZCwgdjolYywgaWU6JWRcbiIsCkBAIC0xMzUsNTcgKzEzMyw1NyBAQCBpbnQgaHlwZXJfZG1hYnVm X3RhYmxlX2Rlc3Ryb3koKQogCXJldHVybiAwOwogfQogCi1pbnQgaHlwZXJfZG1hYnVmX3JlZ2lz dGVyX2V4cG9ydGVkKHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gKmluZm8pCitpbnQgaHlw ZXJfZG1hYnVmX3JlZ2lzdGVyX2V4cG9ydGVkKHN0cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyAqZXhw b3J0ZWQpCiB7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbmZvX2VudHJ5X2V4cG9ydGVkICppbmZv X2VudHJ5OworCXN0cnVjdCBsaXN0X2VudHJ5X2V4cG9ydGVkICppbmZvX2VudHJ5OwogCiAJaW5m b19lbnRyeSA9IGttYWxsb2Moc2l6ZW9mKCppbmZvX2VudHJ5KSwgR0ZQX0tFUk5FTCk7CiAKIAlp ZiAoIWluZm9fZW50cnkpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2Us CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKICAgICAgICAgICAgICAgICAgICAgICAgICJO byBtZW1vcnkgbGVmdCB0byBiZSBhbGxvY2F0ZWRcbiIpOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9 CiAKLQlpbmZvX2VudHJ5LT5pbmZvID0gaW5mbzsKKwlpbmZvX2VudHJ5LT5leHBvcnRlZCA9IGV4 cG9ydGVkOwogCiAJaGFzaF9hZGQoaHlwZXJfZG1hYnVmX2hhc2hfZXhwb3J0ZWQsICZpbmZvX2Vu dHJ5LT5ub2RlLAotCQkgaW5mb19lbnRyeS0+aW5mby0+aGlkLmlkKTsKKwkJIGluZm9fZW50cnkt PmV4cG9ydGVkLT5oaWQuaWQpOwogCiAJcmV0dXJuIDA7CiB9CiAKLWludCBoeXBlcl9kbWFidWZf cmVnaXN0ZXJfaW1wb3J0ZWQoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyog aW5mbykKK2ludCBoeXBlcl9kbWFidWZfcmVnaXN0ZXJfaW1wb3J0ZWQoc3RydWN0IGltcG9ydGVk X3NndF9pbmZvKiBpbXBvcnRlZCkKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2luZm9fZW50cnlf aW1wb3J0ZWQgKmluZm9fZW50cnk7CisJc3RydWN0IGxpc3RfZW50cnlfaW1wb3J0ZWQgKmluZm9f ZW50cnk7CiAKIAlpbmZvX2VudHJ5ID0ga21hbGxvYyhzaXplb2YoKmluZm9fZW50cnkpLCBHRlBf S0VSTkVMKTsKIAogCWlmICghaW5mb19lbnRyeSkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9w cml2YXRlLmRldmljZSwKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogICAgICAgICAgICAg ICAgICAgICAgICAgIk5vIG1lbW9yeSBsZWZ0IHRvIGJlIGFsbG9jYXRlZFxuIik7CiAJCXJldHVy biAtRU5PTUVNOwogCX0KIAotCWluZm9fZW50cnktPmluZm8gPSBpbmZvOworCWluZm9fZW50cnkt PmltcG9ydGVkID0gaW1wb3J0ZWQ7CiAKIAloYXNoX2FkZChoeXBlcl9kbWFidWZfaGFzaF9pbXBv cnRlZCwgJmluZm9fZW50cnktPm5vZGUsCi0JCSBpbmZvX2VudHJ5LT5pbmZvLT5oaWQuaWQpOwor CQkgaW5mb19lbnRyeS0+aW1wb3J0ZWQtPmhpZC5pZCk7CiAKIAlyZXR1cm4gMDsKIH0KIAotc3Ry dWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQoaHlw ZXJfZG1hYnVmX2lkX3QgaGlkKQorc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvICpoeXBlcl9kbWFi dWZfZmluZF9leHBvcnRlZChoeXBlcl9kbWFidWZfaWRfdCBoaWQpCiB7Ci0Jc3RydWN0IGh5cGVy X2RtYWJ1Zl9pbmZvX2VudHJ5X2V4cG9ydGVkICppbmZvX2VudHJ5OworCXN0cnVjdCBsaXN0X2Vu dHJ5X2V4cG9ydGVkICppbmZvX2VudHJ5OwogCWludCBia3Q7CiAKIAloYXNoX2Zvcl9lYWNoKGh5 cGVyX2RtYWJ1Zl9oYXNoX2V4cG9ydGVkLCBia3QsIGluZm9fZW50cnksIG5vZGUpCiAJCS8qIGNo ZWNraW5nIGhpZC5pZCBmaXJzdCAqLwotCQlpZihpbmZvX2VudHJ5LT5pbmZvLT5oaWQuaWQgPT0g aGlkLmlkKSB7CisJCWlmKGluZm9fZW50cnktPmV4cG9ydGVkLT5oaWQuaWQgPT0gaGlkLmlkKSB7 CiAJCQkvKiB0aGVuIGtleSBpcyBjb21wYXJlZCAqLwotCQkJaWYoaHlwZXJfZG1hYnVmX2hpZF9r ZXljb21wKGluZm9fZW50cnktPmluZm8tPmhpZCwgaGlkKSkKLQkJCQlyZXR1cm4gaW5mb19lbnRy eS0+aW5mbzsKKwkJCWlmKGh5cGVyX2RtYWJ1Zl9oaWRfa2V5Y29tcChpbmZvX2VudHJ5LT5leHBv cnRlZC0+aGlkLCBoaWQpKQorCQkJCXJldHVybiBpbmZvX2VudHJ5LT5leHBvcnRlZDsKIAkJCS8q IGlmIGtleSBpcyB1bm1hdGNoZWQsIGdpdmVuIEhJRCBpcyBpbnZhbGlkLCBzbyByZXR1cm5pbmcg TlVMTCAqLwogCQkJZWxzZQogCQkJCWJyZWFrOwpAQCAtMTk3LDI5ICsxOTUsMjkgQEAgc3RydWN0 IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQoaHlwZXJf ZG1hYnVmX2lkX3QgaGlkKQogLyogc2VhcmNoIGZvciBwcmUtZXhwb3J0ZWQgc2d0IGFuZCByZXR1 cm4gaWQgb2YgaXQgaWYgaXQgZXhpc3QgKi8KIGh5cGVyX2RtYWJ1Zl9pZF90IGh5cGVyX2RtYWJ1 Zl9maW5kX2hpZF9leHBvcnRlZChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBpbnQgZG9taWQpCiB7 Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbmZvX2VudHJ5X2V4cG9ydGVkICppbmZvX2VudHJ5Owor CXN0cnVjdCBsaXN0X2VudHJ5X2V4cG9ydGVkICppbmZvX2VudHJ5OwogCWh5cGVyX2RtYWJ1Zl9p ZF90IGhpZCA9IHstMSwgezAsIDAsIDB9fTsKIAlpbnQgYmt0OwogCiAJaGFzaF9mb3JfZWFjaCho eXBlcl9kbWFidWZfaGFzaF9leHBvcnRlZCwgYmt0LCBpbmZvX2VudHJ5LCBub2RlKQotCQlpZihp bmZvX2VudHJ5LT5pbmZvLT5kbWFfYnVmID09IGRtYWJ1ZiAmJgotCQkgICBpbmZvX2VudHJ5LT5p bmZvLT5oeXBlcl9kbWFidWZfcmRvbWFpbiA9PSBkb21pZCkKLQkJCXJldHVybiBpbmZvX2VudHJ5 LT5pbmZvLT5oaWQ7CisJCWlmKGluZm9fZW50cnktPmV4cG9ydGVkLT5kbWFfYnVmID09IGRtYWJ1 ZiAmJgorCQkgICBpbmZvX2VudHJ5LT5leHBvcnRlZC0+cmRvbWlkID09IGRvbWlkKQorCQkJcmV0 dXJuIGluZm9fZW50cnktPmV4cG9ydGVkLT5oaWQ7CiAKIAlyZXR1cm4gaGlkOwogfQogCi1zdHJ1 Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICpoeXBlcl9kbWFidWZfZmluZF9pbXBv cnRlZChoeXBlcl9kbWFidWZfaWRfdCBoaWQpCitzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKmh5 cGVyX2RtYWJ1Zl9maW5kX2ltcG9ydGVkKGh5cGVyX2RtYWJ1Zl9pZF90IGhpZCkKIHsKLQlzdHJ1 Y3QgaHlwZXJfZG1hYnVmX2luZm9fZW50cnlfaW1wb3J0ZWQgKmluZm9fZW50cnk7CisJc3RydWN0 IGxpc3RfZW50cnlfaW1wb3J0ZWQgKmluZm9fZW50cnk7CiAJaW50IGJrdDsKIAogCWhhc2hfZm9y X2VhY2goaHlwZXJfZG1hYnVmX2hhc2hfaW1wb3J0ZWQsIGJrdCwgaW5mb19lbnRyeSwgbm9kZSkK IAkJLyogY2hlY2tpbmcgaGlkLmlkIGZpcnN0ICovCi0JCWlmKGluZm9fZW50cnktPmluZm8tPmhp ZC5pZCA9PSBoaWQuaWQpIHsKKwkJaWYoaW5mb19lbnRyeS0+aW1wb3J0ZWQtPmhpZC5pZCA9PSBo aWQuaWQpIHsKIAkJCS8qIHRoZW4ga2V5IGlzIGNvbXBhcmVkICovCi0JCQlpZihoeXBlcl9kbWFi dWZfaGlkX2tleWNvbXAoaW5mb19lbnRyeS0+aW5mby0+aGlkLCBoaWQpKQotCQkJCXJldHVybiBp bmZvX2VudHJ5LT5pbmZvOworCQkJaWYoaHlwZXJfZG1hYnVmX2hpZF9rZXljb21wKGluZm9fZW50 cnktPmltcG9ydGVkLT5oaWQsIGhpZCkpCisJCQkJcmV0dXJuIGluZm9fZW50cnktPmltcG9ydGVk OwogCQkJLyogaWYga2V5IGlzIHVubWF0Y2hlZCwgZ2l2ZW4gSElEIGlzIGludmFsaWQsIHNvIHJl dHVybmluZyBOVUxMICovCiAJCQllbHNlIHsKIAkJCQlicmVhazsKQEAgLTIzMSwxNCArMjI5LDE0 IEBAIHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKmh5cGVyX2RtYWJ1Zl9m aW5kX2ltcG9ydGVkKGh5cGVyX2RtYWJ1Zl9pCiAKIGludCBoeXBlcl9kbWFidWZfcmVtb3ZlX2V4 cG9ydGVkKGh5cGVyX2RtYWJ1Zl9pZF90IGhpZCkKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2lu Zm9fZW50cnlfZXhwb3J0ZWQgKmluZm9fZW50cnk7CisJc3RydWN0IGxpc3RfZW50cnlfZXhwb3J0 ZWQgKmluZm9fZW50cnk7CiAJaW50IGJrdDsKIAogCWhhc2hfZm9yX2VhY2goaHlwZXJfZG1hYnVm X2hhc2hfZXhwb3J0ZWQsIGJrdCwgaW5mb19lbnRyeSwgbm9kZSkKIAkJLyogY2hlY2tpbmcgaGlk LmlkIGZpcnN0ICovCi0JCWlmKGluZm9fZW50cnktPmluZm8tPmhpZC5pZCA9PSBoaWQuaWQpIHsK KwkJaWYoaW5mb19lbnRyeS0+ZXhwb3J0ZWQtPmhpZC5pZCA9PSBoaWQuaWQpIHsKIAkJCS8qIHRo ZW4ga2V5IGlzIGNvbXBhcmVkICovCi0JCQlpZihoeXBlcl9kbWFidWZfaGlkX2tleWNvbXAoaW5m b19lbnRyeS0+aW5mby0+aGlkLCBoaWQpKSB7CisJCQlpZihoeXBlcl9kbWFidWZfaGlkX2tleWNv bXAoaW5mb19lbnRyeS0+ZXhwb3J0ZWQtPmhpZCwgaGlkKSkgewogCQkJCWhhc2hfZGVsKCZpbmZv X2VudHJ5LT5ub2RlKTsKIAkJCQlrZnJlZShpbmZvX2VudHJ5KTsKIAkJCQlyZXR1cm4gMDsKQEAg LTI1MiwxNCArMjUwLDE0IEBAIGludCBoeXBlcl9kbWFidWZfcmVtb3ZlX2V4cG9ydGVkKGh5cGVy X2RtYWJ1Zl9pZF90IGhpZCkKIAogaW50IGh5cGVyX2RtYWJ1Zl9yZW1vdmVfaW1wb3J0ZWQoaHlw ZXJfZG1hYnVmX2lkX3QgaGlkKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfaW5mb19lbnRyeV9p bXBvcnRlZCAqaW5mb19lbnRyeTsKKwlzdHJ1Y3QgbGlzdF9lbnRyeV9pbXBvcnRlZCAqaW5mb19l bnRyeTsKIAlpbnQgYmt0OwogCiAJaGFzaF9mb3JfZWFjaChoeXBlcl9kbWFidWZfaGFzaF9pbXBv cnRlZCwgYmt0LCBpbmZvX2VudHJ5LCBub2RlKQogCQkvKiBjaGVja2luZyBoaWQuaWQgZmlyc3Qg Ki8KLQkJaWYoaW5mb19lbnRyeS0+aW5mby0+aGlkLmlkID09IGhpZC5pZCkgeworCQlpZihpbmZv X2VudHJ5LT5pbXBvcnRlZC0+aGlkLmlkID09IGhpZC5pZCkgewogCQkJLyogdGhlbiBrZXkgaXMg Y29tcGFyZWQgKi8KLQkJCWlmKGh5cGVyX2RtYWJ1Zl9oaWRfa2V5Y29tcChpbmZvX2VudHJ5LT5p bmZvLT5oaWQsIGhpZCkpIHsKKwkJCWlmKGh5cGVyX2RtYWJ1Zl9oaWRfa2V5Y29tcChpbmZvX2Vu dHJ5LT5pbXBvcnRlZC0+aGlkLCBoaWQpKSB7CiAJCQkJaGFzaF9kZWwoJmluZm9fZW50cnktPm5v ZGUpOwogCQkJCWtmcmVlKGluZm9fZW50cnkpOwogCQkJCXJldHVybiAwOwpAQCAtMjcyLDE1ICsy NzAsMTUgQEAgaW50IGh5cGVyX2RtYWJ1Zl9yZW1vdmVfaW1wb3J0ZWQoaHlwZXJfZG1hYnVmX2lk X3QgaGlkKQogfQogCiB2b2lkIGh5cGVyX2RtYWJ1Zl9mb3JlYWNoX2V4cG9ydGVkKAotCXZvaWQg KCpmdW5jKShzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvICosIHZvaWQgKmF0dHIpLAorCXZv aWQgKCpmdW5jKShzdHJ1Y3QgZXhwb3J0ZWRfc2d0X2luZm8gKiwgdm9pZCAqYXR0ciksCiAJdm9p ZCAqYXR0cikKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2luZm9fZW50cnlfZXhwb3J0ZWQgKmlu Zm9fZW50cnk7CisJc3RydWN0IGxpc3RfZW50cnlfZXhwb3J0ZWQgKmluZm9fZW50cnk7CiAJc3Ry dWN0IGhsaXN0X25vZGUgKnRtcDsKIAlpbnQgYmt0OwogCiAJaGFzaF9mb3JfZWFjaF9zYWZlKGh5 cGVyX2RtYWJ1Zl9oYXNoX2V4cG9ydGVkLCBia3QsIHRtcCwKIAkJCWluZm9fZW50cnksIG5vZGUp IHsKLQkJZnVuYyhpbmZvX2VudHJ5LT5pbmZvLCBhdHRyKTsKKwkJZnVuYyhpbmZvX2VudHJ5LT5l eHBvcnRlZCwgYXR0cik7CiAJfQogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL2h5cGVyX2RtYWJ1Zl9saXN0LmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX2xpc3QuaAppbmRleCA4ZjY0ZGI4Li5kNWMxN2VmIDEwMDY0NAotLS0gYS9kcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2xpc3QuaAorKysgYi9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2xpc3QuaApAQCAtMzIsMTMgKzMyLDEzIEBACiAvKiBu dW1iZXIgb2YgYml0cyB0byBiZSB1c2VkIGZvciBpbXBvcnRlZCBkbWFidWZzIGhhc2ggdGFibGUg Ki8KICNkZWZpbmUgTUFYX0VOVFJZX0lNUE9SVEVEIDcKIAotc3RydWN0IGh5cGVyX2RtYWJ1Zl9p bmZvX2VudHJ5X2V4cG9ydGVkIHsKLSAgICAgICAgc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5m byAqaW5mbzsKK3N0cnVjdCBsaXN0X2VudHJ5X2V4cG9ydGVkIHsKKyAgICAgICAgc3RydWN0IGV4 cG9ydGVkX3NndF9pbmZvICpleHBvcnRlZDsKICAgICAgICAgc3RydWN0IGhsaXN0X25vZGUgbm9k ZTsKIH07CiAKLXN0cnVjdCBoeXBlcl9kbWFidWZfaW5mb19lbnRyeV9pbXBvcnRlZCB7Ci0gICAg ICAgIHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKmluZm87CitzdHJ1Y3Qg bGlzdF9lbnRyeV9pbXBvcnRlZCB7CisgICAgICAgIHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAq aW1wb3J0ZWQ7CiAgICAgICAgIHN0cnVjdCBobGlzdF9ub2RlIG5vZGU7CiB9OwogCkBAIC00Niwy MyArNDYsMjMgQEAgaW50IGh5cGVyX2RtYWJ1Zl90YWJsZV9pbml0KHZvaWQpOwogCiBpbnQgaHlw ZXJfZG1hYnVmX3RhYmxlX2Rlc3Ryb3kodm9pZCk7CiAKLWludCBoeXBlcl9kbWFidWZfcmVnaXN0 ZXJfZXhwb3J0ZWQoc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqaW5mbyk7CitpbnQgaHlw ZXJfZG1hYnVmX3JlZ2lzdGVyX2V4cG9ydGVkKHN0cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyAqaW5m byk7CiAKIC8qIHNlYXJjaCBmb3IgcHJlLWV4cG9ydGVkIHNndCBhbmQgcmV0dXJuIGlkIG9mIGl0 IGlmIGl0IGV4aXN0ICovCiBoeXBlcl9kbWFidWZfaWRfdCBoeXBlcl9kbWFidWZfZmluZF9oaWRf ZXhwb3J0ZWQoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwgaW50IGRvbWlkKTsKIAotaW50IGh5cGVy X2RtYWJ1Zl9yZWdpc3Rlcl9pbXBvcnRlZChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3Nn dF9pbmZvKiBpbmZvKTsKK2ludCBoeXBlcl9kbWFidWZfcmVnaXN0ZXJfaW1wb3J0ZWQoc3RydWN0 IGltcG9ydGVkX3NndF9pbmZvKiBpbmZvKTsKIAotc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5m byAqaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQoaHlwZXJfZG1hYnVmX2lkX3QgaGlkKTsKK3N0 cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyAqaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQoaHlwZXJf ZG1hYnVmX2lkX3QgaGlkKTsKIAotc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5m byAqaHlwZXJfZG1hYnVmX2ZpbmRfaW1wb3J0ZWQoaHlwZXJfZG1hYnVmX2lkX3QgaGlkKTsKK3N0 cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaHlwZXJfZG1hYnVmX2ZpbmRfaW1wb3J0ZWQoaHlwZXJf ZG1hYnVmX2lkX3QgaGlkKTsKIAogaW50IGh5cGVyX2RtYWJ1Zl9yZW1vdmVfZXhwb3J0ZWQoaHlw ZXJfZG1hYnVmX2lkX3QgaGlkKTsKIAogaW50IGh5cGVyX2RtYWJ1Zl9yZW1vdmVfaW1wb3J0ZWQo aHlwZXJfZG1hYnVmX2lkX3QgaGlkKTsKIAogdm9pZCBoeXBlcl9kbWFidWZfZm9yZWFjaF9leHBv cnRlZCgKLQl2b2lkICgqZnVuYykoc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAqLCB2b2lk ICphdHRyKSwKKwl2b2lkICgqZnVuYykoc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvICosIHZvaWQg KmF0dHIpLAogCXZvaWQgKmF0dHIpOwogCiBpbnQgaHlwZXJfZG1hYnVmX3JlZ2lzdGVyX3N5c2Zz KHN0cnVjdCBkZXZpY2UgKmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX21zZy5jIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2Rt YWJ1Zl9tc2cuYwppbmRleCBlYzM3YzNiLi45MDdmNzZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hl bi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmMKQEAgLTMxLDcgKzMxLDYgQEAKICNpbmNsdWRlIDxs aW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgv ZG1hLWJ1Zi5oPgotI2luY2x1ZGUgPHhlbi9ncmFudF90YWJsZS5oPgogI2luY2x1ZGUgPGxpbnV4 L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9tc2cuaCIKICNpbmNsdWRlICJo eXBlcl9kbWFidWZfZHJ2LmgiCkBAIC0zOSw1OCArMzgsNTYgQEAKICNpbmNsdWRlICJoeXBlcl9k bWFidWZfZXZlbnQuaCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfbGlzdC5oIgogCi1leHRlcm4g c3RydWN0IGh5cGVyX2RtYWJ1Zl9wcml2YXRlIGh5cGVyX2RtYWJ1Zl9wcml2YXRlOwotCiBzdHJ1 Y3QgY21kX3Byb2Nlc3MgewogCXN0cnVjdCB3b3JrX3N0cnVjdCB3b3JrOwogCXN0cnVjdCBoeXBl cl9kbWFidWZfcmVxICpycTsKIAlpbnQgZG9taWQ7CiB9OwogCi12b2lkIGh5cGVyX2RtYWJ1Zl9j cmVhdGVfcmVxdWVzdChzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JlcSAqcmVxLAotCQkJCSBlbnVtIGh5 cGVyX2RtYWJ1Zl9jb21tYW5kIGNvbW1hbmQsIGludCAqb3BlcmFuZHMpCit2b2lkIGh5cGVyX2Rt YWJ1Zl9jcmVhdGVfcmVxKHN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpyZXEsCisJCQkgICAgIGVu dW0gaHlwZXJfZG1hYnVmX2NvbW1hbmQgY21kLCBpbnQgKm9wKQogewogCWludCBpOwogCi0JcmVx LT5zdGF0dXMgPSBIWVBFUl9ETUFCVUZfUkVRX05PVF9SRVNQT05ERUQ7Ci0JcmVxLT5jb21tYW5k ID0gY29tbWFuZDsKKwlyZXEtPnN0YXQgPSBIWVBFUl9ETUFCVUZfUkVRX05PVF9SRVNQT05ERUQ7 CisJcmVxLT5jbWQgPSBjbWQ7CiAKLQlzd2l0Y2goY29tbWFuZCkgeworCXN3aXRjaChjbWQpIHsK IAkvKiBhcyBleHBvcnRlciwgY29tbWFuZHMgdG8gaW1wb3J0ZXIgKi8KIAljYXNlIEhZUEVSX0RN QUJVRl9FWFBPUlQ6CiAJCS8qIGV4cG9ydGluZyBwYWdlcyBmb3IgZG1hYnVmICovCiAJCS8qIGNv bW1hbmQgOiBIWVBFUl9ETUFCVUZfRVhQT1JULAotCQkgKiBvcGVyYW5kczB+MyA6IGh5cGVyX2Rt YWJ1Zl9pZAotCQkgKiBvcGVyYW5kczQgOiBudW1iZXIgb2YgcGFnZXMgdG8gYmUgc2hhcmVkCi0J CSAqIG9wZXJhbmRzNSA6IG9mZnNldCBvZiBkYXRhIGluIHRoZSBmaXJzdCBwYWdlCi0JCSAqIG9w ZXJhbmRzNiA6IGxlbmd0aCBvZiBkYXRhIGluIHRoZSBsYXN0IHBhZ2UKLQkJICogb3BlcmFuZHM3 IDogdG9wLWxldmVsIHJlZmVyZW5jZSBudW1iZXIgZm9yIHNoYXJlZCBwYWdlcwotCQkgKiBvcGVy YW5kczggOiBzaXplIG9mIHByaXZhdGUgZGF0YSAoZnJvbSBvcGVyYW5kczkpCi0JCSAqIG9wZXJh bmRzOSB+IDogRHJpdmVyLXNwZWNpZmljIHByaXZhdGUgZGF0YSAoZS5nLiBncmFwaGljIGJ1ZmZl cidzIG1ldGEgaW5mbykKKwkJICogb3AwfjMgOiBoeXBlcl9kbWFidWZfaWQKKwkJICogb3A0IDog bnVtYmVyIG9mIHBhZ2VzIHRvIGJlIHNoYXJlZAorCQkgKiBvcDUgOiBvZmZzZXQgb2YgZGF0YSBp biB0aGUgZmlyc3QgcGFnZQorCQkgKiBvcDYgOiBsZW5ndGggb2YgZGF0YSBpbiB0aGUgbGFzdCBw YWdlCisJCSAqIG9wNyA6IHRvcC1sZXZlbCByZWZlcmVuY2UgbnVtYmVyIGZvciBzaGFyZWQgcGFn ZXMKKwkJICogb3A4IDogc2l6ZSBvZiBwcml2YXRlIGRhdGEgKGZyb20gb3A5KQorCQkgKiBvcDkg fiA6IERyaXZlci1zcGVjaWZpYyBwcml2YXRlIGRhdGEgKGUuZy4gZ3JhcGhpYyBidWZmZXIncyBt ZXRhIGluZm8pCiAJCSAqLwogCi0JCW1lbWNweSgmcmVxLT5vcGVyYW5kc1swXSwgJm9wZXJhbmRz WzBdLCA5ICogc2l6ZW9mKGludCkgKyBvcGVyYW5kc1s4XSk7CisJCW1lbWNweSgmcmVxLT5vcFsw XSwgJm9wWzBdLCA5ICogc2l6ZW9mKGludCkgKyBvcFs4XSk7CiAJCWJyZWFrOwogCiAJY2FzZSBI WVBFUl9ETUFCVUZfTk9USUZZX1VORVhQT1JUOgogCQkvKiBkZXN0cm95IHNnX2xpc3QgZm9yIGh5 cGVyX2RtYWJ1Zl9pZCBvbiByZW1vdGUgc2lkZSAqLwogCQkvKiBjb21tYW5kIDogRE1BQlVGX0RF U1RST1ksCi0JCSAqIG9wZXJhbmRzMH4zIDogaHlwZXJfZG1hYnVmX2lkX3QgaGlkCisJCSAqIG9w MH4zIDogaHlwZXJfZG1hYnVmX2lkX3QgaGlkCiAJCSAqLwogCiAJCWZvciAoaT0wOyBpIDwgNDsg aSsrKQotCQkJcmVxLT5vcGVyYW5kc1tpXSA9IG9wZXJhbmRzW2ldOworCQkJcmVxLT5vcFtpXSA9 IG9wW2ldOwogCQlicmVhazsKIAogCWNhc2UgSFlQRVJfRE1BQlVGX0VYUE9SVF9GRDoKIAljYXNl IEhZUEVSX0RNQUJVRl9FWFBPUlRfRkRfRkFJTEVEOgogCQkvKiBkbWFidWYgZmQgaXMgYmVpbmcg Y3JlYXRlZCBvbiBpbXBvcnRlZCBzaWRlIG9yIGltcG9ydGluZyBmYWlsZWQgKi8KIAkJLyogY29t bWFuZCA6IEhZUEVSX0RNQUJVRl9FWFBPUlRfRkQgb3IgSFlQRVJfRE1BQlVGX0VYUE9SVF9GRF9G QUlMRUQsCi0JCSAqIG9wZXJhbmRzMH4zIDogaHlwZXJfZG1hYnVmX2lkCisJCSAqIG9wMH4zIDog aHlwZXJfZG1hYnVmX2lkCiAJCSAqLwogCiAJCWZvciAoaT0wOyBpIDwgNDsgaSsrKQotCQkJcmVx LT5vcGVyYW5kc1tpXSA9IG9wZXJhbmRzW2ldOworCQkJcmVxLT5vcFtpXSA9IG9wW2ldOwogCQli cmVhazsKIAogCWNhc2UgSFlQRVJfRE1BQlVGX09QU19UT19SRU1PVEU6CkBAIC0xMDMsMTEgKzEw MCwxMSBAQCB2b2lkIGh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChzdHJ1Y3QgaHlwZXJfZG1h YnVmX3JlcSAqcmVxLAogCQkvKiBub3RpZnlpbmcgZG1hYnVmIG1hcC91bm1hcCB0byBleHBvcnRl ciwgbWFwIHdpbGwgbWFrZSB0aGUgZHJpdmVyIHRvIGRvIHNoYWRvdyBtYXBwaW5nCiAJCSogb3Ig dW5tYXBwaW5nIGZvciBzeW5jaHJvbml6YXRpb24gd2l0aCBvcmlnaW5hbCBleHBvcnRlciAoZS5n LiBpOTE1KSAqLwogCQkvKiBjb21tYW5kIDogRE1BQlVGX09QU19UT19TT1VSQ0UuCi0JCSAqIG9w ZXJhbmRzMH4zIDogaHlwZXJfZG1hYnVmX2lkCi0JCSAqIG9wZXJhbmRzNCA6IG1hcCg9MSkvdW5t YXAoPTIpL2F0dGFjaCg9MykvZGV0YWNoKD00KQorCQkgKiBvcDB+MyA6IGh5cGVyX2RtYWJ1Zl9p ZAorCQkgKiBvcDQgOiBtYXAoPTEpL3VubWFwKD0yKS9hdHRhY2goPTMpL2RldGFjaCg9NCkKIAkJ ICovCiAJCWZvciAoaSA9IDA7IGkgPCA1OyBpKyspCi0JCQlyZXEtPm9wZXJhbmRzW2ldID0gb3Bl cmFuZHNbaV07CisJCQlyZXEtPm9wW2ldID0gb3BbaV07CiAJCWJyZWFrOwogCiAJZGVmYXVsdDoK QEAgLTExNiw5ICsxMTMsOSBAQCB2b2lkIGh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxdWVzdChzdHJ1 Y3QgaHlwZXJfZG1hYnVmX3JlcSAqcmVxLAogCX0KIH0KIAotdm9pZCBjbWRfcHJvY2Vzc193b3Jr KHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKK3N0YXRpYyB2b2lkIGNtZF9wcm9jZXNzX3dvcmso c3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0 ZWRfc2d0X2luZm8gKmltcG9ydGVkX3NndF9pbmZvOworCXN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5m byAqaW1wb3J0ZWQ7CiAJc3RydWN0IGNtZF9wcm9jZXNzICpwcm9jID0gY29udGFpbmVyX29mKHdv cmssIHN0cnVjdCBjbWRfcHJvY2Vzcywgd29yayk7CiAJc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEg KnJlcTsKIAlpbnQgZG9taWQ7CkBAIC0xMjcsMTA3ICsxMjQsMTA3IEBAIHZvaWQgY21kX3Byb2Nl c3Nfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJcmVxID0gcHJvYy0+cnE7CiAJZG9t aWQgPSBwcm9jLT5kb21pZDsKIAotCXN3aXRjaCAocmVxLT5jb21tYW5kKSB7CisJc3dpdGNoIChy ZXEtPmNtZCkgewogCWNhc2UgSFlQRVJfRE1BQlVGX0VYUE9SVDoKIAkJLyogZXhwb3J0aW5nIHBh Z2VzIGZvciBkbWFidWYgKi8KIAkJLyogY29tbWFuZCA6IEhZUEVSX0RNQUJVRl9FWFBPUlQsCi0J CSAqIG9wZXJhbmRzMH4zIDogaHlwZXJfZG1hYnVmX2lkCi0JCSAqIG9wZXJhbmRzNCA6IG51bWJl ciBvZiBwYWdlcyB0byBiZSBzaGFyZWQKLQkJICogb3BlcmFuZHM1IDogb2Zmc2V0IG9mIGRhdGEg aW4gdGhlIGZpcnN0IHBhZ2UKLQkJICogb3BlcmFuZHM2IDogbGVuZ3RoIG9mIGRhdGEgaW4gdGhl IGxhc3QgcGFnZQotCQkgKiBvcGVyYW5kczcgOiB0b3AtbGV2ZWwgcmVmZXJlbmNlIG51bWJlciBm b3Igc2hhcmVkIHBhZ2VzCi0JCSAqIG9wZXJhbmRzOCA6IHNpemUgb2YgcHJpdmF0ZSBkYXRhIChm cm9tIG9wZXJhbmRzOSkKLQkJICogb3BlcmFuZHM5IH4gOiBEcml2ZXItc3BlY2lmaWMgcHJpdmF0 ZSBkYXRhIChlLmcuIGdyYXBoaWMgYnVmZmVyJ3MgbWV0YSBpbmZvKQorCQkgKiBvcDB+MyA6IGh5 cGVyX2RtYWJ1Zl9pZAorCQkgKiBvcDQgOiBudW1iZXIgb2YgcGFnZXMgdG8gYmUgc2hhcmVkCisJ CSAqIG9wNSA6IG9mZnNldCBvZiBkYXRhIGluIHRoZSBmaXJzdCBwYWdlCisJCSAqIG9wNiA6IGxl bmd0aCBvZiBkYXRhIGluIHRoZSBsYXN0IHBhZ2UKKwkJICogb3A3IDogdG9wLWxldmVsIHJlZmVy ZW5jZSBudW1iZXIgZm9yIHNoYXJlZCBwYWdlcworCQkgKiBvcDggOiBzaXplIG9mIHByaXZhdGUg ZGF0YSAoZnJvbSBvcDkpCisJCSAqIG9wOSB+IDogRHJpdmVyLXNwZWNpZmljIHByaXZhdGUgZGF0 YSAoZS5nLiBncmFwaGljIGJ1ZmZlcidzIG1ldGEgaW5mbykKIAkJICovCiAKIAkJLyogaWYgbmVu dHMgPT0gMCwgaXQgbWVhbnMgaXQgaXMgYSBtZXNzYWdlIG9ubHkgZm9yIHByaXYgc3luY2hyb25p emF0aW9uCiAJCSAqIGZvciBleGlzdGluZyBpbXBvcnRlZF9zZ3RfaW5mbyBzbyBub3QgY3JlYXRp bmcgYSBuZXcgb25lICovCi0JCWlmIChyZXEtPm9wZXJhbmRzWzRdID09IDApIHsKLQkJCWh5cGVy X2RtYWJ1Zl9pZF90IGV4aXN0ID0ge3JlcS0+b3BlcmFuZHNbMF0sCi0JCQkJCQkgICB7cmVxLT5v cGVyYW5kc1sxXSwgcmVxLT5vcGVyYW5kc1syXSwKLQkJCQkJCSAgICByZXEtPm9wZXJhbmRzWzNd fX07CisJCWlmIChyZXEtPm9wWzRdID09IDApIHsKKwkJCWh5cGVyX2RtYWJ1Zl9pZF90IGV4aXN0 ID0ge3JlcS0+b3BbMF0sCisJCQkJCQkgICB7cmVxLT5vcFsxXSwgcmVxLT5vcFsyXSwKKwkJCQkJ CSAgIHJlcS0+b3BbM119fTsKIAotCQkJaW1wb3J0ZWRfc2d0X2luZm8gPSBoeXBlcl9kbWFidWZf ZmluZF9pbXBvcnRlZChleGlzdCk7CisJCQlpbXBvcnRlZCA9IGh5cGVyX2RtYWJ1Zl9maW5kX2lt cG9ydGVkKGV4aXN0KTsKIAotCQkJaWYgKCFpbXBvcnRlZF9zZ3RfaW5mbykgewotCQkJCWRldl9l cnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJaWYgKCFpbXBvcnRlZCkgeworCQkJ CWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCQkJIkNhbid0IGZpbmQgaW1wb3J0ZWQgc2d0 X2luZm8gZnJvbSBJTVBPUlRfTElTVFxuIik7CiAJCQkJYnJlYWs7CiAJCQl9CiAKIAkJCS8qIGlm IHNpemUgb2YgbmV3IHByaXZhdGUgZGF0YSBpcyBkaWZmZXJlbnQsCiAJCQkgKiB3ZSByZWFsbG9j YXRlIGl0LiAqLwotCQkJaWYgKGltcG9ydGVkX3NndF9pbmZvLT5zel9wcml2ICE9IHJlcS0+b3Bl cmFuZHNbOF0pIHsKLQkJCQlrZnJlZShpbXBvcnRlZF9zZ3RfaW5mby0+cHJpdik7Ci0JCQkJaW1w b3J0ZWRfc2d0X2luZm8tPnN6X3ByaXYgPSByZXEtPm9wZXJhbmRzWzhdOwotCQkJCWltcG9ydGVk X3NndF9pbmZvLT5wcml2ID0ga2NhbGxvYygxLCByZXEtPm9wZXJhbmRzWzhdLCBHRlBfS0VSTkVM KTsKLQkJCQlpZiAoIWltcG9ydGVkX3NndF9pbmZvLT5wcml2KSB7Ci0JCQkJCWRldl9lcnIoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJaWYgKGltcG9ydGVkLT5zel9wcml2ICE9IHJl cS0+b3BbOF0pIHsKKwkJCQlrZnJlZShpbXBvcnRlZC0+cHJpdik7CisJCQkJaW1wb3J0ZWQtPnN6 X3ByaXYgPSByZXEtPm9wWzhdOworCQkJCWltcG9ydGVkLT5wcml2ID0ga2NhbGxvYygxLCByZXEt Pm9wWzhdLCBHRlBfS0VSTkVMKTsKKwkJCQlpZiAoIWltcG9ydGVkLT5wcml2KSB7CisJCQkJCWRl dl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCQkJCSJGYWlsIHRvIGFsbG9jYXRlIHByaXZcbiIp OwogCiAJCQkJCS8qIHNldCBpdCBpbnZhbGlkICovCi0JCQkJCWltcG9ydGVkX3NndF9pbmZvLT52 YWxpZCA9IDA7CisJCQkJCWltcG9ydGVkLT52YWxpZCA9IDA7CiAJCQkJCWJyZWFrOwogCQkJCX0K IAkJCX0KIAogCQkJLyogdXBkYXRpbmcgcHJpdiBkYXRhICovCi0JCQltZW1jcHkoaW1wb3J0ZWRf c2d0X2luZm8tPnByaXYsICZyZXEtPm9wZXJhbmRzWzldLCByZXEtPm9wZXJhbmRzWzhdKTsKKwkJ CW1lbWNweShpbXBvcnRlZC0+cHJpdiwgJnJlcS0+b3BbOV0sIHJlcS0+b3BbOF0pOwogCiAjaWZk ZWYgQ09ORklHX0hZUEVSX0RNQUJVRl9FVkVOVF9HRU4KIAkJCS8qIGdlbmVyYXRpbmcgaW1wb3J0 IGV2ZW50ICovCi0JCQloeXBlcl9kbWFidWZfaW1wb3J0X2V2ZW50KGltcG9ydGVkX3NndF9pbmZv LT5oaWQpOworCQkJaHlwZXJfZG1hYnVmX2ltcG9ydF9ldmVudChpbXBvcnRlZC0+aGlkKTsKICNl bmRpZgogCiAJCQlicmVhazsKIAkJfQogCi0JCWltcG9ydGVkX3NndF9pbmZvID0ga2NhbGxvYygx LCBzaXplb2YoKmltcG9ydGVkX3NndF9pbmZvKSwgR0ZQX0tFUk5FTCk7CisJCWltcG9ydGVkID0g a2NhbGxvYygxLCBzaXplb2YoKmltcG9ydGVkKSwgR0ZQX0tFUk5FTCk7CiAKLQkJaWYgKCFpbXBv cnRlZF9zZ3RfaW5mbykgewotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2Us CisJCWlmICghaW1wb3J0ZWQpIHsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCQki Tm8gbWVtb3J5IGxlZnQgdG8gYmUgYWxsb2NhdGVkXG4iKTsKIAkJCWJyZWFrOwogCQl9CiAKLQkJ aW1wb3J0ZWRfc2d0X2luZm8tPnN6X3ByaXYgPSByZXEtPm9wZXJhbmRzWzhdOwotCQlpbXBvcnRl ZF9zZ3RfaW5mby0+cHJpdiA9IGtjYWxsb2MoMSwgcmVxLT5vcGVyYW5kc1s4XSwgR0ZQX0tFUk5F TCk7CisJCWltcG9ydGVkLT5zel9wcml2ID0gcmVxLT5vcFs4XTsKKwkJaW1wb3J0ZWQtPnByaXYg PSBrY2FsbG9jKDEsIHJlcS0+b3BbOF0sIEdGUF9LRVJORUwpOwogCi0JCWlmICghaW1wb3J0ZWRf c2d0X2luZm8tPnByaXYpIHsKLQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNl LAorCQlpZiAoIWltcG9ydGVkLT5wcml2KSB7CisJCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYs CiAJCQkJIkZhaWwgdG8gYWxsb2NhdGUgcHJpdlxuIik7CiAKLQkJCWtmcmVlKGltcG9ydGVkX3Nn dF9pbmZvKTsKKwkJCWtmcmVlKGltcG9ydGVkKTsKIAkJCWJyZWFrOwogCQl9CiAKLQkJaW1wb3J0 ZWRfc2d0X2luZm8tPmhpZC5pZCA9IHJlcS0+b3BlcmFuZHNbMF07CisJCWltcG9ydGVkLT5oaWQu aWQgPSByZXEtPm9wWzBdOwogCiAJCWZvciAoaT0wOyBpPDM7IGkrKykKLQkJCWltcG9ydGVkX3Nn dF9pbmZvLT5oaWQucm5nX2tleVtpXSA9IHJlcS0+b3BlcmFuZHNbaSsxXTsKKwkJCWltcG9ydGVk LT5oaWQucm5nX2tleVtpXSA9IHJlcS0+b3BbaSsxXTsKIAotCQlpbXBvcnRlZF9zZ3RfaW5mby0+ bmVudHMgPSByZXEtPm9wZXJhbmRzWzRdOwotCQlpbXBvcnRlZF9zZ3RfaW5mby0+ZnJzdF9vZnN0 ID0gcmVxLT5vcGVyYW5kc1s1XTsKLQkJaW1wb3J0ZWRfc2d0X2luZm8tPmxhc3RfbGVuID0gcmVx LT5vcGVyYW5kc1s2XTsKLQkJaW1wb3J0ZWRfc2d0X2luZm8tPnJlZl9oYW5kbGUgPSByZXEtPm9w ZXJhbmRzWzddOworCQlpbXBvcnRlZC0+bmVudHMgPSByZXEtPm9wWzRdOworCQlpbXBvcnRlZC0+ ZnJzdF9vZnN0ID0gcmVxLT5vcFs1XTsKKwkJaW1wb3J0ZWQtPmxhc3RfbGVuID0gcmVxLT5vcFs2 XTsKKwkJaW1wb3J0ZWQtPnJlZl9oYW5kbGUgPSByZXEtPm9wWzddOwogCi0JCWRldl9kYmcoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiRE1BQlVGIHdhcyBleHBvcnRlZFxuIik7Ci0JCWRl dl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiXHRoaWR7aWQ6JWQga2V5OiVkICVk ICVkfVxuIiwKLQkJCXJlcS0+b3BlcmFuZHNbMF0sIHJlcS0+b3BlcmFuZHNbMV0sIHJlcS0+b3Bl cmFuZHNbMl0sCi0JCQlyZXEtPm9wZXJhbmRzWzNdKTsKLQkJZGV2X2RiZyhoeXBlcl9kbWFidWZf cHJpdmF0ZS5kZXZpY2UsICJcdG5lbnRzICVkXG4iLCByZXEtPm9wZXJhbmRzWzRdKTsKLQkJZGV2 X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJcdGZpcnN0IG9mZnNldCAlZFxuIiwg cmVxLT5vcGVyYW5kc1s1XSk7Ci0JCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNl LCAiXHRsYXN0IGxlbiAlZFxuIiwgcmVxLT5vcGVyYW5kc1s2XSk7Ci0JCWRldl9kYmcoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiXHRncmVmaWQgJWRcbiIsIHJlcS0+b3BlcmFuZHNbN10p OworCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsICJETUFCVUYgd2FzIGV4cG9ydGVkXG4iKTsK KwkJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LCAiXHRoaWR7aWQ6JWQga2V5OiVkICVkICVkfVxu IiwKKwkJCXJlcS0+b3BbMF0sIHJlcS0+b3BbMV0sIHJlcS0+b3BbMl0sCisJCQlyZXEtPm9wWzNd KTsKKwkJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LCAiXHRuZW50cyAlZFxuIiwgcmVxLT5vcFs0 XSk7CisJCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwgIlx0Zmlyc3Qgb2Zmc2V0ICVkXG4iLCBy ZXEtPm9wWzVdKTsKKwkJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LCAiXHRsYXN0IGxlbiAlZFxu IiwgcmVxLT5vcFs2XSk7CisJCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwgIlx0Z3JlZmlkICVk XG4iLCByZXEtPm9wWzddKTsKIAotCQltZW1jcHkoaW1wb3J0ZWRfc2d0X2luZm8tPnByaXYsICZy ZXEtPm9wZXJhbmRzWzldLCByZXEtPm9wZXJhbmRzWzhdKTsKKwkJbWVtY3B5KGltcG9ydGVkLT5w cml2LCAmcmVxLT5vcFs5XSwgcmVxLT5vcFs4XSk7CiAKLQkJaW1wb3J0ZWRfc2d0X2luZm8tPnZh bGlkID0gMTsKLQkJaHlwZXJfZG1hYnVmX3JlZ2lzdGVyX2ltcG9ydGVkKGltcG9ydGVkX3NndF9p bmZvKTsKKwkJaW1wb3J0ZWQtPnZhbGlkID0gdHJ1ZTsKKwkJaHlwZXJfZG1hYnVmX3JlZ2lzdGVy X2ltcG9ydGVkKGltcG9ydGVkKTsKIAogI2lmZGVmIENPTkZJR19IWVBFUl9ETUFCVUZfRVZFTlRf R0VOCiAJCS8qIGdlbmVyYXRpbmcgaW1wb3J0IGV2ZW50ICovCi0JCWh5cGVyX2RtYWJ1Zl9pbXBv cnRfZXZlbnQoaW1wb3J0ZWRfc2d0X2luZm8tPmhpZCk7CisJCWh5cGVyX2RtYWJ1Zl9pbXBvcnRf ZXZlbnQoaW1wb3J0ZWQtPmhpZCk7CiAjZW5kaWYKIAogCQlicmVhazsKQEAgLTI1MSwxNDIgKzI0 OCwxNDIgQEAgaW50IGh5cGVyX2RtYWJ1Zl9tc2dfcGFyc2UoaW50IGRvbWlkLCBzdHJ1Y3QgaHlw ZXJfZG1hYnVmX3JlcSAqcmVxKQogewogCXN0cnVjdCBjbWRfcHJvY2VzcyAqcHJvYzsKIAlzdHJ1 Y3QgaHlwZXJfZG1hYnVmX3JlcSAqdGVtcF9yZXE7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBv cnRlZF9zZ3RfaW5mbyAqc2d0X2luZm87Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9zZ3RfaW5mbyAq ZXhwX3NndF9pbmZvOworCXN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWQ7CisJc3Ry dWN0IGV4cG9ydGVkX3NndF9pbmZvICpleHBvcnRlZDsKIAloeXBlcl9kbWFidWZfaWRfdCBoaWQ7 CiAJaW50IHJldDsKIAogCWlmICghcmVxKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZh dGUuZGV2aWNlLCAicmVxdWVzdCBpcyBOVUxMXG4iKTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ ZGV2LCAicmVxdWVzdCBpcyBOVUxMXG4iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCi0JaGlk LmlkID0gcmVxLT5vcGVyYW5kc1swXTsKLQloaWQucm5nX2tleVswXSA9IHJlcS0+b3BlcmFuZHNb MV07Ci0JaGlkLnJuZ19rZXlbMV0gPSByZXEtPm9wZXJhbmRzWzJdOwotCWhpZC5ybmdfa2V5WzJd ID0gcmVxLT5vcGVyYW5kc1szXTsKKwloaWQuaWQgPSByZXEtPm9wWzBdOworCWhpZC5ybmdfa2V5 WzBdID0gcmVxLT5vcFsxXTsKKwloaWQucm5nX2tleVsxXSA9IHJlcS0+b3BbMl07CisJaGlkLnJu Z19rZXlbMl0gPSByZXEtPm9wWzNdOwogCi0JaWYgKChyZXEtPmNvbW1hbmQgPCBIWVBFUl9ETUFC VUZfRVhQT1JUKSB8fAotCQkocmVxLT5jb21tYW5kID4gSFlQRVJfRE1BQlVGX09QU19UT19TT1VS Q0UpKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiaW52YWxpZCBj b21tYW5kXG4iKTsKKwlpZiAoKHJlcS0+Y21kIDwgSFlQRVJfRE1BQlVGX0VYUE9SVCkgfHwKKwkJ KHJlcS0+Y21kID4gSFlQRVJfRE1BQlVGX09QU19UT19TT1VSQ0UpKSB7CisJCWRldl9lcnIoaHlf ZHJ2X3ByaXYtPmRldiwgImludmFsaWQgY29tbWFuZFxuIik7CiAJCXJldHVybiAtRUlOVkFMOwog CX0KIAotCXJlcS0+c3RhdHVzID0gSFlQRVJfRE1BQlVGX1JFUV9QUk9DRVNTRUQ7CisJcmVxLT5z dGF0ID0gSFlQRVJfRE1BQlVGX1JFUV9QUk9DRVNTRUQ7CiAKIAkvKiBIWVBFUl9ETUFCVUZfREVT VFJPWSByZXF1aXJlcyBpbW1lZGlhdGUKIAkgKiBmb2xsb3cgdXAgc28gY2FuJ3QgYmUgcHJvY2Vz c2VkIGluIHdvcmtxdWV1ZQogCSAqLwotCWlmIChyZXEtPmNvbW1hbmQgPT0gSFlQRVJfRE1BQlVG X05PVElGWV9VTkVYUE9SVCkgeworCWlmIChyZXEtPmNtZCA9PSBIWVBFUl9ETUFCVUZfTk9USUZZ X1VORVhQT1JUKSB7CiAJCS8qIGRlc3Ryb3kgc2dfbGlzdCBmb3IgaHlwZXJfZG1hYnVmX2lkIG9u IHJlbW90ZSBzaWRlICovCiAJCS8qIGNvbW1hbmQgOiBIWVBFUl9ETUFCVUZfTk9USUZZX1VORVhQ T1JULAotCQkgKiBvcGVyYW5kczB+MyA6IGh5cGVyX2RtYWJ1Zl9pZAorCQkgKiBvcDB+MyA6IGh5 cGVyX2RtYWJ1Zl9pZAogCQkgKi8KLQkJZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZp Y2UsCisJCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSIlczogcHJvY2Vzc2luZyBIWVBF Ul9ETUFCVUZfTk9USUZZX1VORVhQT1JUXG4iLCBfX2Z1bmNfXyk7CiAKLQkJc2d0X2luZm8gPSBo eXBlcl9kbWFidWZfZmluZF9pbXBvcnRlZChoaWQpOworCQlpbXBvcnRlZCA9IGh5cGVyX2RtYWJ1 Zl9maW5kX2ltcG9ydGVkKGhpZCk7CiAKLQkJaWYgKHNndF9pbmZvKSB7CisJCWlmIChpbXBvcnRl ZCkgewogCQkJLyogaWYgYW55dGhpbmcgaXMgc3RpbGwgdXNpbmcgZG1hX2J1ZiAqLwotCQkJaWYg KHNndF9pbmZvLT5udW1faW1wb3J0ZXJzKSB7CisJCQlpZiAoaW1wb3J0ZWQtPmltcG9ydGVycykg ewogCQkJCS8qCiAJCQkJICogQnVmZmVyIGlzIHN0aWxsIGluICB1c2UsIGp1c3QgbWFyayB0aGF0 IGl0IHNob3VsZAogCQkJCSAqIG5vdCBiZSBhbGxvd2VkIHRvIGV4cG9ydCBpdHMgZmQgYW55bW9y ZS4KIAkJCQkgKi8KLQkJCQlzZ3RfaW5mby0+dmFsaWQgPSAwOworCQkJCWltcG9ydGVkLT52YWxp ZCA9IGZhbHNlOwogCQkJfSBlbHNlIHsKIAkJCQkvKiBObyBvbmUgaXMgdXNpbmcgYnVmZmVyLCBy ZW1vdmUgaXQgZnJvbSBpbXBvcnRlZCBsaXN0ICovCiAJCQkJaHlwZXJfZG1hYnVmX3JlbW92ZV9p bXBvcnRlZChoaWQpOwotCQkJCWtmcmVlKHNndF9pbmZvKTsKKwkJCQlrZnJlZShpbXBvcnRlZCk7 CiAJCQl9CiAJCX0gZWxzZSB7Ci0JCQlyZXEtPnN0YXR1cyA9IEhZUEVSX0RNQUJVRl9SRVFfRVJS T1I7CisJCQlyZXEtPnN0YXQgPSBIWVBFUl9ETUFCVUZfUkVRX0VSUk9SOwogCQl9CiAKLQkJcmV0 dXJuIHJlcS0+Y29tbWFuZDsKKwkJcmV0dXJuIHJlcS0+Y21kOwogCX0KIAogCS8qIGRtYSBidWYg cmVtb3RlIHN5bmNocm9uaXphdGlvbiAqLwotCWlmIChyZXEtPmNvbW1hbmQgPT0gSFlQRVJfRE1B QlVGX09QU19UT19TT1VSQ0UpIHsKKwlpZiAocmVxLT5jbWQgPT0gSFlQRVJfRE1BQlVGX09QU19U T19TT1VSQ0UpIHsKIAkJLyogbm90aWZ5aW5nIGRtYWJ1ZiBtYXAvdW5tYXAgdG8gZXhwb3J0ZXIs IG1hcCB3aWxsIG1ha2UgdGhlIGRyaXZlciB0byBkbyBzaGFkb3cgbWFwcGluZwogCQkgKiBvciB1 bm1hcHBpbmcgZm9yIHN5bmNocm9uaXphdGlvbiB3aXRoIG9yaWdpbmFsIGV4cG9ydGVyIChlLmcu IGk5MTUpICovCiAKIAkJLyogY29tbWFuZCA6IERNQUJVRl9PUFNfVE9fU09VUkNFLgotCQkgKiBv cGVyYW5kczB+MyA6IGh5cGVyX2RtYWJ1Zl9pZAotCQkgKiBvcGVyYW5kczEgOiBlbnVtIGh5cGVy X2RtYWJ1Zl9vcHMgey4uLi59CisJCSAqIG9wMH4zIDogaHlwZXJfZG1hYnVmX2lkCisJCSAqIG9w MSA6IGVudW0gaHlwZXJfZG1hYnVmX29wcyB7Li4uLn0KIAkJICovCi0JCWRldl9kYmcoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQki JXM6IEhZUEVSX0RNQUJVRl9PUFNfVE9fU09VUkNFXG4iLCBfX2Z1bmNfXyk7CiAKLQkJcmV0ID0g aHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jKGhpZCwgcmVxLT5vcGVyYW5kc1s0XSk7CisJCXJldCA9 IGh5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYyhoaWQsIHJlcS0+b3BbNF0pOwogCiAJCWlmIChyZXQp Ci0JCQlyZXEtPnN0YXR1cyA9IEhZUEVSX0RNQUJVRl9SRVFfRVJST1I7CisJCQlyZXEtPnN0YXQg PSBIWVBFUl9ETUFCVUZfUkVRX0VSUk9SOwogCQllbHNlCi0JCQlyZXEtPnN0YXR1cyA9IEhZUEVS X0RNQUJVRl9SRVFfUFJPQ0VTU0VEOworCQkJcmVxLT5zdGF0ID0gSFlQRVJfRE1BQlVGX1JFUV9Q Uk9DRVNTRUQ7CiAKLQkJcmV0dXJuIHJlcS0+Y29tbWFuZDsKKwkJcmV0dXJuIHJlcS0+Y21kOwog CX0KIAogCS8qIHN5bmNocm9ub3VzIGRtYV9idWZfZmQgZXhwb3J0ICovCi0JaWYgKHJlcS0+Y29t bWFuZCA9PSBIWVBFUl9ETUFCVUZfRVhQT1JUX0ZEKSB7CisJaWYgKHJlcS0+Y21kID09IEhZUEVS X0RNQUJVRl9FWFBPUlRfRkQpIHsKIAkJLyogZmluZCBhIGNvcnJlc3BvbmRpbmcgU0dUIGZvciB0 aGUgaWQgKi8KLQkJZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCWRldl9k YmcoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSJQcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9FWFBPUlRf RkQgZm9yIGJ1ZmZlciB7aWQ6JWQga2V5OiVkICVkICVkfVxuIiwKIAkJCWhpZC5pZCwgaGlkLnJu Z19rZXlbMF0sIGhpZC5ybmdfa2V5WzFdLCBoaWQucm5nX2tleVsyXSk7CiAKLQkJZXhwX3NndF9p bmZvID0gaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0ZWQoaGlkKTsKKwkJZXhwb3J0ZWQgPSBoeXBl cl9kbWFidWZfZmluZF9leHBvcnRlZChoaWQpOwogCi0JCWlmICghZXhwX3NndF9pbmZvKSB7Ci0J CQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJaWYgKCFleHBvcnRlZCkg eworCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJCSJjcml0aWNhbCBlcnI6IHJlcXVl c3RlZCBzZ3RfaW5mbyBjYW4ndCBiZSBmb3VuZCBmb3IgYnVmZmVyIHtpZDolZCBrZXk6JWQgJWQg JWR9XG4iLAogCQkJCWhpZC5pZCwgaGlkLnJuZ19rZXlbMF0sIGhpZC5ybmdfa2V5WzFdLCBoaWQu cm5nX2tleVsyXSk7CiAKLQkJCXJlcS0+c3RhdHVzID0gSFlQRVJfRE1BQlVGX1JFUV9FUlJPUjsK LQkJfSBlbHNlIGlmICghZXhwX3NndF9pbmZvLT52YWxpZCkgewotCQkJZGV2X2RiZyhoeXBlcl9k bWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCQlyZXEtPnN0YXQgPSBIWVBFUl9ETUFCVUZfUkVRX0VS Uk9SOworCQl9IGVsc2UgaWYgKCFleHBvcnRlZC0+dmFsaWQpIHsKKwkJCWRldl9kYmcoaHlfZHJ2 X3ByaXYtPmRldiwKIAkJCQkiQnVmZmVyIG5vIGxvbmdlciB2YWxpZCAtIGNhbm5vdCBleHBvcnQg ZmQgZm9yIGJ1ZmZlciB7aWQ6JWQga2V5OiVkICVkICVkfVxuIiwKIAkJCQloaWQuaWQsIGhpZC5y bmdfa2V5WzBdLCBoaWQucm5nX2tleVsxXSwgaGlkLnJuZ19rZXlbMl0pOwogCi0JCQlyZXEtPnN0 YXR1cyA9IEhZUEVSX0RNQUJVRl9SRVFfRVJST1I7CisJCQlyZXEtPnN0YXQgPSBIWVBFUl9ETUFC VUZfUkVRX0VSUk9SOwogCQl9IGVsc2UgewotCQkJZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsCisJCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkJIkJ1ZmZlciBzdGls bCB2YWxpZCAtIGNhbiBleHBvcnQgZmQgZm9yIGJ1ZmZlciB7aWQ6JWQga2V5OiVkICVkICVkfVxu IiwKIAkJCQloaWQuaWQsIGhpZC5ybmdfa2V5WzBdLCBoaWQucm5nX2tleVsxXSwgaGlkLnJuZ19r ZXlbMl0pOwogCi0JCQlleHBfc2d0X2luZm8tPmltcG9ydGVyX2V4cG9ydGVkKys7Ci0JCQlyZXEt PnN0YXR1cyA9IEhZUEVSX0RNQUJVRl9SRVFfUFJPQ0VTU0VEOworCQkJZXhwb3J0ZWQtPmFjdGl2 ZSsrOworCQkJcmVxLT5zdGF0ID0gSFlQRVJfRE1BQlVGX1JFUV9QUk9DRVNTRUQ7CiAJCX0KLQkJ cmV0dXJuIHJlcS0+Y29tbWFuZDsKKwkJcmV0dXJuIHJlcS0+Y21kOwogCX0KIAotCWlmIChyZXEt PmNvbW1hbmQgPT0gSFlQRVJfRE1BQlVGX0VYUE9SVF9GRF9GQUlMRUQpIHsKLQkJZGV2X2RiZyho eXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJaWYgKHJlcS0+Y21kID09IEhZUEVSX0RNQUJV Rl9FWFBPUlRfRkRfRkFJTEVEKSB7CisJCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSJQ cm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9FWFBPUlRfRkRfRkFJTEVEIGZvciBidWZmZXIge2lkOiVk IGtleTolZCAlZCAlZH1cbiIsCiAJCQloaWQuaWQsIGhpZC5ybmdfa2V5WzBdLCBoaWQucm5nX2tl eVsxXSwgaGlkLnJuZ19rZXlbMl0pOwogCi0JCWV4cF9zZ3RfaW5mbyA9IGh5cGVyX2RtYWJ1Zl9m aW5kX2V4cG9ydGVkKGhpZCk7CisJCWV4cG9ydGVkID0gaHlwZXJfZG1hYnVmX2ZpbmRfZXhwb3J0 ZWQoaGlkKTsKIAotCQlpZiAoIWV4cF9zZ3RfaW5mbykgewotCQkJZGV2X2VycihoeXBlcl9kbWFi dWZfcHJpdmF0ZS5kZXZpY2UsCisJCWlmICghZXhwb3J0ZWQpIHsKKwkJCWRldl9lcnIoaHlfZHJ2 X3ByaXYtPmRldiwKIAkJCQkiY3JpdGljYWwgZXJyOiByZXF1ZXN0ZWQgc2d0X2luZm8gY2FuJ3Qg YmUgZm91bmQgZm9yIGJ1ZmZlciB7aWQ6JWQga2V5OiVkICVkICVkfVxuIiwKIAkJCQloaWQuaWQs IGhpZC5ybmdfa2V5WzBdLCBoaWQucm5nX2tleVsxXSwgaGlkLnJuZ19rZXlbMl0pOwogCi0JCQly ZXEtPnN0YXR1cyA9IEhZUEVSX0RNQUJVRl9SRVFfRVJST1I7CisJCQlyZXEtPnN0YXQgPSBIWVBF Ul9ETUFCVUZfUkVRX0VSUk9SOwogCQl9IGVsc2UgewotCQkJZXhwX3NndF9pbmZvLT5pbXBvcnRl cl9leHBvcnRlZC0tOwotCQkJcmVxLT5zdGF0dXMgPSBIWVBFUl9ETUFCVUZfUkVRX1BST0NFU1NF RDsKKwkJCWV4cG9ydGVkLT5hY3RpdmUtLTsKKwkJCXJlcS0+c3RhdCA9IEhZUEVSX0RNQUJVRl9S RVFfUFJPQ0VTU0VEOwogCQl9Ci0JCXJldHVybiByZXEtPmNvbW1hbmQ7CisJCXJldHVybiByZXEt PmNtZDsKIAl9CiAKLQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwlkZXZf ZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCSIlczogcHV0dGluZyByZXF1ZXN0IHRvIHdvcmtxdWV1 ZVxuIiwgX19mdW5jX18pOwogCXRlbXBfcmVxID0ga21hbGxvYyhzaXplb2YoKnRlbXBfcmVxKSwg R0ZQX0tFUk5FTCk7CiAKIAlpZiAoIXRlbXBfcmVxKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVm X3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiTm8gbWVt b3J5IGxlZnQgdG8gYmUgYWxsb2NhdGVkXG4iKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQpAQCAt Mzk2LDcgKzM5Myw3IEBAIGludCBoeXBlcl9kbWFidWZfbXNnX3BhcnNlKGludCBkb21pZCwgc3Ry dWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcSkKIAlwcm9jID0ga2NhbGxvYygxLCBzaXplb2Yoc3Ry dWN0IGNtZF9wcm9jZXNzKSwgR0ZQX0tFUk5FTCk7CiAKIAlpZiAoIXByb2MpIHsKLQkJZGV2X2Vy cihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRl diwKIAkJCSJObyBtZW1vcnkgbGVmdCB0byBiZSBhbGxvY2F0ZWRcbiIpOwogCQlrZnJlZSh0ZW1w X3JlcSk7CiAJCXJldHVybiAtRU5PTUVNOwpAQCAtNDA3LDcgKzQwNCw3IEBAIGludCBoeXBlcl9k bWFidWZfbXNnX3BhcnNlKGludCBkb21pZCwgc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcSkK IAogCUlOSVRfV09SSygmKHByb2MtPndvcmspLCBjbWRfcHJvY2Vzc193b3JrKTsKIAotCXF1ZXVl X3dvcmsoaHlwZXJfZG1hYnVmX3ByaXZhdGUud29ya19xdWV1ZSwgJihwcm9jLT53b3JrKSk7CisJ cXVldWVfd29yayhoeV9kcnZfcHJpdi0+d29ya19xdWV1ZSwgJihwcm9jLT53b3JrKSk7CiAKLQly ZXR1cm4gcmVxLT5jb21tYW5kOworCXJldHVybiByZXEtPmNtZDsKIH0KZGlmZiAtLWdpdCBhL2Ry aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmggYi9kcml2ZXJzL3hlbi9o eXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX21zZy5oCmluZGV4IDBmNmU3OTUuLjdjNjk0ZWMgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfbXNnLmgKKysr IGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9tc2cuaApAQCAtMjgsMTcg KzI4LDE3IEBACiAjZGVmaW5lIE1BWF9OVU1CRVJfT0ZfT1BFUkFORFMgNjQKIAogc3RydWN0IGh5 cGVyX2RtYWJ1Zl9yZXEgewotCXVuc2lnbmVkIGludCByZXF1ZXN0X2lkOwotCXVuc2lnbmVkIGlu dCBzdGF0dXM7Ci0JdW5zaWduZWQgaW50IGNvbW1hbmQ7Ci0JdW5zaWduZWQgaW50IG9wZXJhbmRz W01BWF9OVU1CRVJfT0ZfT1BFUkFORFNdOworCXVuc2lnbmVkIGludCByZXFfaWQ7CisJdW5zaWdu ZWQgaW50IHN0YXQ7CisJdW5zaWduZWQgaW50IGNtZDsKKwl1bnNpZ25lZCBpbnQgb3BbTUFYX05V TUJFUl9PRl9PUEVSQU5EU107CiB9OwogCiBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3Jlc3AgewotCXVu c2lnbmVkIGludCByZXNwb25zZV9pZDsKLQl1bnNpZ25lZCBpbnQgc3RhdHVzOwotCXVuc2lnbmVk IGludCBjb21tYW5kOwotCXVuc2lnbmVkIGludCBvcGVyYW5kc1tNQVhfTlVNQkVSX09GX09QRVJB TkRTXTsKKwl1bnNpZ25lZCBpbnQgcmVzcF9pZDsKKwl1bnNpZ25lZCBpbnQgc3RhdDsKKwl1bnNp Z25lZCBpbnQgY21kOworCXVuc2lnbmVkIGludCBvcFtNQVhfTlVNQkVSX09GX09QRVJBTkRTXTsK IH07CiAKIGVudW0gaHlwZXJfZG1hYnVmX2NvbW1hbmQgewpAQCAtNzUsNyArNzUsNyBAQCBlbnVt IGh5cGVyX2RtYWJ1Zl9yZXFfZmVlZGJhY2sgewogfTsKIAogLyogY3JlYXRlIGEgcmVxdWVzdCBw YWNrZXQgd2l0aCBnaXZlbiBjb21tYW5kIGFuZCBvcGVyYW5kcyAqLwotdm9pZCBoeXBlcl9kbWFi dWZfY3JlYXRlX3JlcXVlc3Qoc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcSwKK3ZvaWQgaHlw ZXJfZG1hYnVmX2NyZWF0ZV9yZXEoc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcSwKIAkJCQkg ZW51bSBoeXBlcl9kbWFidWZfY29tbWFuZCBjb21tYW5kLAogCQkJCSBpbnQgKm9wZXJhbmRzKTsK IApkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9vcHMu YyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfb3BzLmMKaW5kZXggOTMx M2M0Mi4uN2U3MzE3MCAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVy X2RtYWJ1Zl9vcHMuYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X29wcy5jCkBAIC0zMiw4ICszMiw2IEBACiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1 ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KLSNpbmNsdWRl IDx4ZW4vZ3JhbnRfdGFibGUuaD4KLSNpbmNsdWRlIDxhc20veGVuL3BhZ2UuaD4KICNpbmNsdWRl ICJoeXBlcl9kbWFidWZfZHJ2LmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX3N0cnVjdC5oIgog I2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9vcHMuaCIKQEAgLTQ1LDEyMiArNDMsMTExIEBACiAjZGVm aW5lIFdBSVRfQUZURVJfU1lOQ19SRVEgMAogI2RlZmluZSBSRUZTX1BFUl9QQUdFIChQQUdFX1NJ WkUvc2l6ZW9mKGdyYW50X3JlZl90KSkKIAotZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfcHJp dmF0ZSBoeXBlcl9kbWFidWZfcHJpdmF0ZTsKLQotaW5saW5lIGludCBoeXBlcl9kbWFidWZfc3lu Y19yZXF1ZXN0KGh5cGVyX2RtYWJ1Zl9pZF90IGhpZCwgaW50IGRtYWJ1Zl9vcHMpCitzdGF0aWMg aW50IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3QoaHlwZXJfZG1hYnVmX2lkX3QgaGlkLCBpbnQg ZG1hYnVmX29wcykKIHsKIAlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JlcSAqcmVxOwotCXN0cnVjdCBo eXBlcl9kbWFidWZfYmFja2VuZF9vcHMgKm9wcyA9IGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmJhY2tl bmRfb3BzOwotCWludCBvcGVyYW5kc1s1XTsKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tlbmRf b3BzICpvcHMgPSBoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHM7CisJaW50IG9wWzVdOwogCWludCBp OwogCWludCByZXQ7CiAKLQlvcGVyYW5kc1swXSA9IGhpZC5pZDsKKwlvcFswXSA9IGhpZC5pZDsK IAogCWZvciAoaT0wOyBpPDM7IGkrKykKLQkJb3BlcmFuZHNbaSsxXSA9IGhpZC5ybmdfa2V5W2ld OworCQlvcFtpKzFdID0gaGlkLnJuZ19rZXlbaV07CiAKLQlvcGVyYW5kc1s0XSA9IGRtYWJ1Zl9v cHM7CisJb3BbNF0gPSBkbWFidWZfb3BzOwogCiAJcmVxID0ga2NhbGxvYygxLCBzaXplb2YoKnJl cSksIEdGUF9LRVJORUwpOwogCiAJaWYgKCFyZXEpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZf cHJpdmF0ZS5kZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSJObyBtZW1v cnkgbGVmdCB0byBiZSBhbGxvY2F0ZWRcbiIpOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKLQlo eXBlcl9kbWFidWZfY3JlYXRlX3JlcXVlc3QocmVxLCBIWVBFUl9ETUFCVUZfT1BTX1RPX1NPVVJD RSwgJm9wZXJhbmRzWzBdKTsKKwloeXBlcl9kbWFidWZfY3JlYXRlX3JlcShyZXEsIEhZUEVSX0RN QUJVRl9PUFNfVE9fU09VUkNFLCAmb3BbMF0pOwogCiAJLyogc2VuZCByZXF1ZXN0IGFuZCB3YWl0 IGZvciBhIHJlc3BvbnNlICovCiAJcmV0ID0gb3BzLT5zZW5kX3JlcShIWVBFUl9ETUFCVUZfRE9N X0lEKGhpZCksIHJlcSwgV0FJVF9BRlRFUl9TWU5DX1JFUSk7CiAKKwlpZiAocmV0IDwgMCkgewor CQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCisJCQkiZG1hYnVmIHN5bmMgcmVxdWVzdCBmYWls ZWQ6JWRcbiIsIHJlcS0+b3BbNF0pOworCX0KKwogCWtmcmVlKHJlcSk7CiAKIAlyZXR1cm4gcmV0 OwogfQogCi1zdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9vcHNfYXR0YWNoKHN0cnVjdCBkbWFfYnVm KiBkbWFidWYsIHN0cnVjdCBkZXZpY2UqIGRldiwKLQkJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1l bnQgKmF0dGFjaCkKK3N0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX29wc19hdHRhY2goc3RydWN0IGRt YV9idWYqIGRtYWJ1ZiwKKwkJCQkgICBzdHJ1Y3QgZGV2aWNlKiBkZXYsCisJCQkJICAgc3RydWN0 IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1w b3J0ZWRfc2d0X2luZm8gKnNndF9pbmZvOworCXN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaW1w b3J0ZWQ7CiAJaW50IHJldDsKIAogCWlmICghYXR0YWNoLT5kbWFidWYtPnByaXYpCiAJCXJldHVy biAtRUlOVkFMOwogCi0Jc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9z Z3RfaW5mbyAqKWF0dGFjaC0+ZG1hYnVmLT5wcml2OworCWltcG9ydGVkID0gKHN0cnVjdCBpbXBv cnRlZF9zZ3RfaW5mbyAqKWF0dGFjaC0+ZG1hYnVmLT5wcml2OwogCi0JcmV0ID0gaHlwZXJfZG1h YnVmX3N5bmNfcmVxdWVzdChzZ3RfaW5mby0+aGlkLAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5j X3JlcXVlc3QoaW1wb3J0ZWQtPmhpZCwKIAkJCQkJSFlQRVJfRE1BQlVGX09QU19BVFRBQ0gpOwog Ci0JaWYgKHJldCA8IDApIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2Us Ci0JCQkiaHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFp bGVkXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybiByZXQ7Ci0JfQotCi0JcmV0dXJuIDA7CisJcmV0 dXJuIHJldDsKIH0KIAotc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX29wc19kZXRhY2goc3RydWN0 IGRtYV9idWYqIGRtYWJ1Ziwgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKQorc3Rh dGljIHZvaWQgaHlwZXJfZG1hYnVmX29wc19kZXRhY2goc3RydWN0IGRtYV9idWYqIGRtYWJ1ZiwK KwkJCQkgICAgc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKQogewotCXN0cnVjdCBo eXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKnNndF9pbmZvOworCXN0cnVjdCBpbXBvcnRl ZF9zZ3RfaW5mbyAqaW1wb3J0ZWQ7CiAJaW50IHJldDsKIAogCWlmICghYXR0YWNoLT5kbWFidWYt PnByaXYpCiAJCXJldHVybjsKIAotCXNndF9pbmZvID0gKHN0cnVjdCBoeXBlcl9kbWFidWZfaW1w b3J0ZWRfc2d0X2luZm8gKilhdHRhY2gtPmRtYWJ1Zi0+cHJpdjsKKwlpbXBvcnRlZCA9IChzdHJ1 Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKilhdHRhY2gtPmRtYWJ1Zi0+cHJpdjsKIAotCXJldCA9IGh5 cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3Qoc2d0X2luZm8tPmhpZCwKKwlyZXQgPSBoeXBlcl9kbWFi dWZfc3luY19yZXF1ZXN0KGltcG9ydGVkLT5oaWQsCiAJCQkJCUhZUEVSX0RNQUJVRl9PUFNfREVU QUNIKTsKLQotCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUu ZGV2aWNlLAotCQkJImh5cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6c2VuZCBkbWFidWYgc3luYyByZXF1 ZXN0IGZhaWxlZFxuIiwgX19mdW5jX18pOwotCX0KIH0KIAogc3RhdGljIHN0cnVjdCBzZ190YWJs ZSogaHlwZXJfZG1hYnVmX29wc19tYXAoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNo bWVudCwKLQkJCQkJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcikKKwkJCQkJICAgICBlbnVt IGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIpCiB7CiAJc3RydWN0IHNnX3RhYmxlICpzdDsKLQlzdHJ1 Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICpzZ3RfaW5mbzsKLQlzdHJ1Y3QgaHlw ZXJfZG1hYnVmX3BhZ2VzX2luZm8gKnBhZ2VfaW5mbzsKKwlzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2lu Zm8gKmltcG9ydGVkOworCXN0cnVjdCBwYWdlc19pbmZvICpwZ19pbmZvOwogCWludCByZXQ7CiAK IAlpZiAoIWF0dGFjaG1lbnQtPmRtYWJ1Zi0+cHJpdikKIAkJcmV0dXJuIE5VTEw7CiAKLQlzZ3Rf aW5mbyA9IChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICopYXR0YWNobWVu dC0+ZG1hYnVmLT5wcml2OworCWltcG9ydGVkID0gKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAq KWF0dGFjaG1lbnQtPmRtYWJ1Zi0+cHJpdjsKIAogCS8qIGV4dHJhY3QgcGFnZXMgZnJvbSBzZ3Qg Ki8KLQlwYWdlX2luZm8gPSBoeXBlcl9kbWFidWZfZXh0X3BncyhzZ3RfaW5mby0+c2d0KTsKKwlw Z19pbmZvID0gaHlwZXJfZG1hYnVmX2V4dF9wZ3MoaW1wb3J0ZWQtPnNndCk7CiAKLQlpZiAoIXBh Z2VfaW5mbykgeworCWlmICghcGdfaW5mbykgewogCQlyZXR1cm4gTlVMTDsKIAl9CiAKIAkvKiBj cmVhdGUgYSBuZXcgc2dfdGFibGUgd2l0aCBleHRyYWN0ZWQgcGFnZXMgKi8KLQlzdCA9IGh5cGVy X2RtYWJ1Zl9jcmVhdGVfc2d0KHBhZ2VfaW5mby0+cGFnZXMsIHBhZ2VfaW5mby0+ZnJzdF9vZnN0 LAotCQkJCXBhZ2VfaW5mby0+bGFzdF9sZW4sIHBhZ2VfaW5mby0+bmVudHMpOworCXN0ID0gaHlw ZXJfZG1hYnVmX2NyZWF0ZV9zZ3QocGdfaW5mby0+cGdzLCBwZ19pbmZvLT5mcnN0X29mc3QsCisJ CQkJICAgICBwZ19pbmZvLT5sYXN0X2xlbiwgcGdfaW5mby0+bmVudHMpOwogCWlmICghc3QpCiAJ CWdvdG8gZXJyX2ZyZWVfc2c7CiAKICAgICAgICAgaWYgKCFkbWFfbWFwX3NnKGF0dGFjaG1lbnQt PmRldiwgc3QtPnNnbCwgc3QtPm5lbnRzLCBkaXIpKQogICAgICAgICAgICAgICAgIGdvdG8gZXJy X2ZyZWVfc2c7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0KHNndF9pbmZvLT5o aWQsCisJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdChpbXBvcnRlZC0+aGlkLAogCQkJ CQlIWVBFUl9ETUFCVUZfT1BTX01BUCk7CiAKLQlrZnJlZShwYWdlX2luZm8tPnBhZ2VzKTsKLQlr ZnJlZShwYWdlX2luZm8pOwotCi0JaWYgKHJldCA8IDApIHsKLQkJZGV2X2VycihoeXBlcl9kbWFi dWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkiaHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1 ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7Ci0JfQorCWtmcmVlKHBnX2luZm8t PnBncyk7CisJa2ZyZWUocGdfaW5mbyk7CiAKIAlyZXR1cm4gc3Q7CiAKQEAgLTE3MCw4ICsxNTcs OCBAQCBzdGF0aWMgc3RydWN0IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfb3BzX21hcChzdHJ1Y3Qg ZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2htZQogCQlrZnJlZShzdCk7CiAJfQogCi0Ja2ZyZWUo cGFnZV9pbmZvLT5wYWdlcyk7Ci0Ja2ZyZWUocGFnZV9pbmZvKTsKKwlrZnJlZShwZ19pbmZvLT5w Z3MpOworCWtmcmVlKHBnX2luZm8pOwogCiAJcmV0dXJuIE5VTEw7CiB9CkBAIC0xODAsMjk0ICsx NjcsMjUxIEBAIHN0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9vcHNfdW5tYXAoc3RydWN0IGRtYV9i dWZfYXR0YWNobWVudCAqYXR0YWNobWVudCwKIAkJCQkgICBzdHJ1Y3Qgc2dfdGFibGUgKnNnLAog CQkJCSAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcikKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1h YnVmX2ltcG9ydGVkX3NndF9pbmZvICpzZ3RfaW5mbzsKKwlzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2lu Zm8gKmltcG9ydGVkOwogCWludCByZXQ7CiAKIAlpZiAoIWF0dGFjaG1lbnQtPmRtYWJ1Zi0+cHJp dikKIAkJcmV0dXJuOwogCi0Jc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRl ZF9zZ3RfaW5mbyAqKWF0dGFjaG1lbnQtPmRtYWJ1Zi0+cHJpdjsKKwlpbXBvcnRlZCA9IChzdHJ1 Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKilhdHRhY2htZW50LT5kbWFidWYtPnByaXY7CiAKIAlkbWFf dW5tYXBfc2coYXR0YWNobWVudC0+ZGV2LCBzZy0+c2dsLCBzZy0+bmVudHMsIGRpcik7CiAKIAlz Z19mcmVlX3RhYmxlKHNnKTsKIAlrZnJlZShzZyk7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZfc3lu Y19yZXF1ZXN0KHNndF9pbmZvLT5oaWQsCisJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVz dChpbXBvcnRlZC0+aGlkLAogCQkJCQlIWVBFUl9ETUFCVUZfT1BTX1VOTUFQKTsKLQotCWlmIChy ZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJImh5 cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6c2VuZCBkbWFidWYgc3luYyByZXF1ZXN0IGZhaWxlZFxuIiwg X19mdW5jX18pOwotCX0KIH0KIAogc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX29wc19yZWxlYXNl KHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0 ZWRfc2d0X2luZm8gKnNndF9pbmZvOwotCXN0cnVjdCBoeXBlcl9kbWFidWZfYmFja2VuZF9vcHMg Km9wcyA9IGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmJhY2tlbmRfb3BzOworCXN0cnVjdCBpbXBvcnRl ZF9zZ3RfaW5mbyAqaW1wb3J0ZWQ7CisJc3RydWN0IGh5cGVyX2RtYWJ1Zl9iYWNrZW5kX29wcyAq b3BzID0gaHlfZHJ2X3ByaXYtPmJhY2tlbmRfb3BzOwogCWludCByZXQ7Ci0JaW50IGZpbmFsX3Jl bGVhc2U7CisJaW50IGZpbmlzaDsKIAogCWlmICghZG1hX2J1Zi0+cHJpdikKIAkJcmV0dXJuOwog Ci0Jc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWRt YV9idWYtPnByaXY7CisJaW1wb3J0ZWQgPSAoc3RydWN0IGltcG9ydGVkX3NndF9pbmZvICopZG1h X2J1Zi0+cHJpdjsKIAotCWlmICghZG1hYnVmX3JlZmNvdW50KHNndF9pbmZvLT5kbWFfYnVmKSkg ewotCQlzZ3RfaW5mby0+ZG1hX2J1ZiA9IE5VTEw7CisJaWYgKCFkbWFidWZfcmVmY291bnQoaW1w b3J0ZWQtPmRtYV9idWYpKSB7CisJCWltcG9ydGVkLT5kbWFfYnVmID0gTlVMTDsKIAl9CiAKLQlz Z3RfaW5mby0+bnVtX2ltcG9ydGVycy0tOworCWltcG9ydGVkLT5pbXBvcnRlcnMtLTsKIAotCWlm IChzZ3RfaW5mby0+bnVtX2ltcG9ydGVycyA9PSAwKSB7Ci0JCW9wcy0+dW5tYXBfc2hhcmVkX3Bh Z2VzKCZzZ3RfaW5mby0+cmVmc19pbmZvLCBzZ3RfaW5mby0+bmVudHMpOworCWlmIChpbXBvcnRl ZC0+aW1wb3J0ZXJzID09IDApIHsKKwkJb3BzLT51bm1hcF9zaGFyZWRfcGFnZXMoJmltcG9ydGVk LT5yZWZzX2luZm8sIGltcG9ydGVkLT5uZW50cyk7CiAKLQkJaWYgKHNndF9pbmZvLT5zZ3QpIHsK LQkJCXNnX2ZyZWVfdGFibGUoc2d0X2luZm8tPnNndCk7Ci0JCQlrZnJlZShzZ3RfaW5mby0+c2d0 KTsKLQkJCXNndF9pbmZvLT5zZ3QgPSBOVUxMOworCQlpZiAoaW1wb3J0ZWQtPnNndCkgeworCQkJ c2dfZnJlZV90YWJsZShpbXBvcnRlZC0+c2d0KTsKKwkJCWtmcmVlKGltcG9ydGVkLT5zZ3QpOwor CQkJaW1wb3J0ZWQtPnNndCA9IE5VTEw7CiAJCX0KIAl9CiAKLQlmaW5hbF9yZWxlYXNlID0gc2d0 X2luZm8gJiYgIXNndF9pbmZvLT52YWxpZCAmJgotCQkgICAgICAgICFzZ3RfaW5mby0+bnVtX2lt cG9ydGVyczsKKwlmaW5pc2ggPSBpbXBvcnRlZCAmJiAhaW1wb3J0ZWQtPnZhbGlkICYmCisJCSAh aW1wb3J0ZWQtPmltcG9ydGVyczsKIAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3Qo c2d0X2luZm8tPmhpZCwKKwlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0KGltcG9ydGVk LT5oaWQsCiAJCQkJCUhZUEVSX0RNQUJVRl9PUFNfUkVMRUFTRSk7Ci0JaWYgKHJldCA8IDApIHsK LQkJZGV2X3dhcm4oaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJICJoeXBlcl9kbWFi dWY6OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMgcmVxdWVzdCBmYWlsZWRcbiIsIF9fZnVuY19f KTsKLQl9CiAKIAkvKgogCSAqIENoZWNrIGlmIGJ1ZmZlciBpcyBzdGlsbCB2YWxpZCBhbmQgaWYg bm90IHJlbW92ZSBpdCBmcm9tIGltcG9ydGVkIGxpc3QuCiAJICogVGhhdCBoYXMgdG8gYmUgZG9u ZSBhZnRlciBzZW5kaW5nIHN5bmMgcmVxdWVzdAogCSAqLwotCWlmIChmaW5hbF9yZWxlYXNlKSB7 Ci0JCWh5cGVyX2RtYWJ1Zl9yZW1vdmVfaW1wb3J0ZWQoc2d0X2luZm8tPmhpZCk7Ci0JCWtmcmVl KHNndF9pbmZvKTsKKwlpZiAoZmluaXNoKSB7CisJCWh5cGVyX2RtYWJ1Zl9yZW1vdmVfaW1wb3J0 ZWQoaW1wb3J0ZWQtPmhpZCk7CisJCWtmcmVlKGltcG9ydGVkKTsKIAl9CiB9CiAKIHN0YXRpYyBp bnQgaHlwZXJfZG1hYnVmX29wc19iZWdpbl9jcHVfYWNjZXNzKHN0cnVjdCBkbWFfYnVmICpkbWFi dWYsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcikKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVm X2ltcG9ydGVkX3NndF9pbmZvICpzZ3RfaW5mbzsKKwlzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2luZm8g KmltcG9ydGVkOwogCWludCByZXQ7CiAKIAlpZiAoIWRtYWJ1Zi0+cHJpdikKIAkJcmV0dXJuIC1F SU5WQUw7CiAKLQlzZ3RfaW5mbyA9IChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9p bmZvICopZG1hYnVmLT5wcml2OworCWltcG9ydGVkID0gKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5m byAqKWRtYWJ1Zi0+cHJpdjsKIAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3Qoc2d0 X2luZm8tPmhpZCwKKwlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0KGltcG9ydGVkLT5o aWQsCiAJCQkJCUhZUEVSX0RNQUJVRl9PUFNfQkVHSU5fQ1BVX0FDQ0VTUyk7Ci0JaWYgKHJldCA8 IDApIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkiaHlwZXJf ZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1 bmNfXyk7Ci0JfQogCiAJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBoeXBlcl9kbWFidWZf b3BzX2VuZF9jcHVfYWNjZXNzKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIGVudW0gZG1hX2RhdGFf ZGlyZWN0aW9uIGRpcikKIHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZv ICpzZ3RfaW5mbzsKKwlzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKmltcG9ydGVkOwogCWludCBy ZXQ7CiAKIAlpZiAoIWRtYWJ1Zi0+cHJpdikKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQlzZ3RfaW5m byA9IChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICopZG1hYnVmLT5wcml2 OworCWltcG9ydGVkID0gKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsK IAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3Qoc2d0X2luZm8tPmhpZCwKKwlyZXQg PSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0KGltcG9ydGVkLT5oaWQsCiAJCQkJCUhZUEVSX0RN QUJVRl9PUFNfRU5EX0NQVV9BQ0NFU1MpOwotCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJImh5cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6c2Vu ZCBkbWFidWYgc3luYyByZXF1ZXN0IGZhaWxlZFxuIiwgX19mdW5jX18pOwotCX0KIAogCXJldHVy biAwOwogfQogCiBzdGF0aWMgdm9pZCAqaHlwZXJfZG1hYnVmX29wc19rbWFwX2F0b21pYyhzdHJ1 Y3QgZG1hX2J1ZiAqZG1hYnVmLCB1bnNpZ25lZCBsb25nIHBnbnVtKQogewotCXN0cnVjdCBoeXBl cl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKnNndF9pbmZvOworCXN0cnVjdCBpbXBvcnRlZF9z Z3RfaW5mbyAqaW1wb3J0ZWQ7CiAJaW50IHJldDsKIAogCWlmICghZG1hYnVmLT5wcml2KQogCQly ZXR1cm4gTlVMTDsKIAotCXNndF9pbmZvID0gKHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRf c2d0X2luZm8gKilkbWFidWYtPnByaXY7CisJaW1wb3J0ZWQgPSAoc3RydWN0IGltcG9ydGVkX3Nn dF9pbmZvICopZG1hYnVmLT5wcml2OwogCi0JcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVz dChzZ3RfaW5mby0+aGlkLAorCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3QoaW1wb3J0 ZWQtPmhpZCwKIAkJCQkJSFlQRVJfRE1BQlVGX09QU19LTUFQX0FUT01JQyk7Ci0JaWYgKHJldCA8 IDApIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkiaHlwZXJf ZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1 bmNfXyk7Ci0JfQogCiAJcmV0dXJuIE5VTEw7IC8qIGZvciBub3cgTlVMTC4uIG5lZWQgdG8gcmV0 dXJuIHRoZSBhZGRyZXNzIG9mIG1hcHBlZCByZWdpb24gKi8KIH0KIAogc3RhdGljIHZvaWQgaHlw ZXJfZG1hYnVmX29wc19rdW5tYXBfYXRvbWljKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHVuc2ln bmVkIGxvbmcgcGdudW0sIHZvaWQgKnZhZGRyKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1w b3J0ZWRfc2d0X2luZm8gKnNndF9pbmZvOworCXN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaW1w b3J0ZWQ7CiAJaW50IHJldDsKIAogCWlmICghZG1hYnVmLT5wcml2KQogCQlyZXR1cm47CiAKLQlz Z3RfaW5mbyA9IChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICopZG1hYnVm LT5wcml2OworCWltcG9ydGVkID0gKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+ cHJpdjsKIAotCXJldCA9IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3Qoc2d0X2luZm8tPmhpZCwK KwlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0KGltcG9ydGVkLT5oaWQsCiAJCQkJCUhZ UEVSX0RNQUJVRl9PUFNfS1VOTUFQX0FUT01JQyk7Ci0JaWYgKHJldCA8IDApIHsKLQkJZGV2X2Vy cihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkiaHlwZXJfZG1hYnVmOjolcyBFcnJv cjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7Ci0JfQogfQog CiBzdGF0aWMgdm9pZCAqaHlwZXJfZG1hYnVmX29wc19rbWFwKHN0cnVjdCBkbWFfYnVmICpkbWFi dWYsIHVuc2lnbmVkIGxvbmcgcGdudW0pCiB7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRl ZF9zZ3RfaW5mbyAqc2d0X2luZm87CisJc3RydWN0IGltcG9ydGVkX3NndF9pbmZvICppbXBvcnRl ZDsKIAlpbnQgcmV0OwogCiAJaWYgKCFkbWFidWYtPnByaXYpCiAJCXJldHVybiBOVUxMOwogCi0J c2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1 Zi0+cHJpdjsKKwlpbXBvcnRlZCA9IChzdHJ1Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKilkbWFidWYt PnByaXY7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZfc3luY19yZXF1ZXN0KHNndF9pbmZvLT5oaWQs CisJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdChpbXBvcnRlZC0+aGlkLAogCQkJCQlI WVBFUl9ETUFCVUZfT1BTX0tNQVApOwotCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJImh5cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6c2VuZCBk bWFidWYgc3luYyByZXF1ZXN0IGZhaWxlZFxuIiwgX19mdW5jX18pOwotCX0KIAotCXJldHVybiBO VUxMOyAvKiBmb3Igbm93IE5VTEwuLiBuZWVkIHRvIHJldHVybiB0aGUgYWRkcmVzcyBvZiBtYXBw ZWQgcmVnaW9uICovCisJLyogZm9yIG5vdyBOVUxMLi4gbmVlZCB0byByZXR1cm4gdGhlIGFkZHJl c3Mgb2YgbWFwcGVkIHJlZ2lvbiAqLworCXJldHVybiBOVUxMOwogfQogCi1zdGF0aWMgdm9pZCBo eXBlcl9kbWFidWZfb3BzX2t1bm1hcChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCB1bnNpZ25lZCBs b25nIHBnbnVtLCB2b2lkICp2YWRkcikKK3N0YXRpYyB2b2lkIGh5cGVyX2RtYWJ1Zl9vcHNfa3Vu bWFwKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHVuc2lnbmVkIGxvbmcgcGdudW0sCisJCQkJICAg IHZvaWQgKnZhZGRyKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8g KnNndF9pbmZvOworCXN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWQ7CiAJaW50IHJl dDsKIAogCWlmICghZG1hYnVmLT5wcml2KQogCQlyZXR1cm47CiAKLQlzZ3RfaW5mbyA9IChzdHJ1 Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICopZG1hYnVmLT5wcml2OworCWltcG9y dGVkID0gKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsKIAotCXJldCA9 IGh5cGVyX2RtYWJ1Zl9zeW5jX3JlcXVlc3Qoc2d0X2luZm8tPmhpZCwKKwlyZXQgPSBoeXBlcl9k bWFidWZfc3luY19yZXF1ZXN0KGltcG9ydGVkLT5oaWQsCiAJCQkJCUhZUEVSX0RNQUJVRl9PUFNf S1VOTUFQKTsKLQlpZiAocmV0IDwgMCkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRl LmRldmljZSwKLQkJCSJoeXBlcl9kbWFidWY6OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMgcmVx dWVzdCBmYWlsZWRcbiIsIF9fZnVuY19fKTsKLQl9CiB9CiAKIHN0YXRpYyBpbnQgaHlwZXJfZG1h YnVmX29wc19tbWFwKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHN0cnVjdCB2bV9hcmVhX3N0cnVj dCAqdm1hKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKnNndF9p bmZvOworCXN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWQ7CiAJaW50IHJldDsKIAog CWlmICghZG1hYnVmLT5wcml2KQogCQlyZXR1cm4gLUVJTlZBTDsKIAotCXNndF9pbmZvID0gKHN0 cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKilkbWFidWYtPnByaXY7CisJaW1w b3J0ZWQgPSAoc3RydWN0IGltcG9ydGVkX3NndF9pbmZvICopZG1hYnVmLT5wcml2OwogCi0JcmV0 ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVxdWVzdChzZ3RfaW5mby0+aGlkLAorCXJldCA9IGh5cGVy X2RtYWJ1Zl9zeW5jX3JlcXVlc3QoaW1wb3J0ZWQtPmhpZCwKIAkJCQkJSFlQRVJfRE1BQlVGX09Q U19NTUFQKTsKLQlpZiAocmV0IDwgMCkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRl LmRldmljZSwKLQkJCSJoeXBlcl9kbWFidWY6OiVzIEVycm9yOnNlbmQgZG1hYnVmIHN5bmMgcmVx dWVzdCBmYWlsZWRcbiIsIF9fZnVuY19fKTsKLQl9CiAKIAlyZXR1cm4gcmV0OwogfQogCiBzdGF0 aWMgdm9pZCAqaHlwZXJfZG1hYnVmX29wc192bWFwKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCiB7 Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqc2d0X2luZm87CisJc3Ry dWN0IGltcG9ydGVkX3NndF9pbmZvICppbXBvcnRlZDsKIAlpbnQgcmV0OwogCiAJaWYgKCFkbWFi dWYtPnByaXYpCiAJCXJldHVybiBOVUxMOwogCi0Jc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2Rt YWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsKKwlpbXBvcnRlZCA9IChzdHJ1 Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKilkbWFidWYtPnByaXY7CiAKLQlyZXQgPSBoeXBlcl9kbWFi dWZfc3luY19yZXF1ZXN0KHNndF9pbmZvLT5oaWQsCisJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNf cmVxdWVzdChpbXBvcnRlZC0+aGlkLAogCQkJCQlIWVBFUl9ETUFCVUZfT1BTX1ZNQVApOwotCWlm IChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJ Imh5cGVyX2RtYWJ1Zjo6JXMgRXJyb3I6c2VuZCBkbWFidWYgc3luYyByZXF1ZXN0IGZhaWxlZFxu IiwgX19mdW5jX18pOwotCX0KIAogCXJldHVybiBOVUxMOwogfQogCiBzdGF0aWMgdm9pZCBoeXBl cl9kbWFidWZfb3BzX3Z1bm1hcChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCB2b2lkICp2YWRkcikK IHsKLQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICpzZ3RfaW5mbzsKKwlz dHJ1Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKmltcG9ydGVkOwogCWludCByZXQ7CiAKIAlpZiAoIWRt YWJ1Zi0+cHJpdikKIAkJcmV0dXJuOwogCi0Jc2d0X2luZm8gPSAoc3RydWN0IGh5cGVyX2RtYWJ1 Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqKWRtYWJ1Zi0+cHJpdjsKKwlpbXBvcnRlZCA9IChzdHJ1Y3Qg aW1wb3J0ZWRfc2d0X2luZm8gKilkbWFidWYtPnByaXY7CiAKLQlyZXQgPSBoeXBlcl9kbWFidWZf c3luY19yZXF1ZXN0KHNndF9pbmZvLT5oaWQsCisJcmV0ID0gaHlwZXJfZG1hYnVmX3N5bmNfcmVx dWVzdChpbXBvcnRlZC0+aGlkLAogCQkJCQlIWVBFUl9ETUFCVUZfT1BTX1ZVTk1BUCk7Ci0JaWYg KHJldCA8IDApIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQki aHlwZXJfZG1hYnVmOjolcyBFcnJvcjpzZW5kIGRtYWJ1ZiBzeW5jIHJlcXVlc3QgZmFpbGVkXG4i LCBfX2Z1bmNfXyk7Ci0JfQogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9idWZfb3BzIGh5 cGVyX2RtYWJ1Zl9vcHMgPSB7Ci0JCS5hdHRhY2ggPSBoeXBlcl9kbWFidWZfb3BzX2F0dGFjaCwK LQkJLmRldGFjaCA9IGh5cGVyX2RtYWJ1Zl9vcHNfZGV0YWNoLAotCQkubWFwX2RtYV9idWYgPSBo eXBlcl9kbWFidWZfb3BzX21hcCwKLQkJLnVubWFwX2RtYV9idWYgPSBoeXBlcl9kbWFidWZfb3Bz X3VubWFwLAotCQkucmVsZWFzZSA9IGh5cGVyX2RtYWJ1Zl9vcHNfcmVsZWFzZSwKLQkJLmJlZ2lu X2NwdV9hY2Nlc3MgPSAodm9pZCopaHlwZXJfZG1hYnVmX29wc19iZWdpbl9jcHVfYWNjZXNzLAot CQkuZW5kX2NwdV9hY2Nlc3MgPSAodm9pZCopaHlwZXJfZG1hYnVmX29wc19lbmRfY3B1X2FjY2Vz cywKLQkJLm1hcF9hdG9taWMgPSBoeXBlcl9kbWFidWZfb3BzX2ttYXBfYXRvbWljLAotCQkudW5t YXBfYXRvbWljID0gaHlwZXJfZG1hYnVmX29wc19rdW5tYXBfYXRvbWljLAotCQkubWFwID0gaHlw ZXJfZG1hYnVmX29wc19rbWFwLAotCQkudW5tYXAgPSBoeXBlcl9kbWFidWZfb3BzX2t1bm1hcCwK LQkJLm1tYXAgPSBoeXBlcl9kbWFidWZfb3BzX21tYXAsCi0JCS52bWFwID0gaHlwZXJfZG1hYnVm X29wc192bWFwLAotCQkudnVubWFwID0gaHlwZXJfZG1hYnVmX29wc192dW5tYXAsCisJLmF0dGFj aCA9IGh5cGVyX2RtYWJ1Zl9vcHNfYXR0YWNoLAorCS5kZXRhY2ggPSBoeXBlcl9kbWFidWZfb3Bz X2RldGFjaCwKKwkubWFwX2RtYV9idWYgPSBoeXBlcl9kbWFidWZfb3BzX21hcCwKKwkudW5tYXBf ZG1hX2J1ZiA9IGh5cGVyX2RtYWJ1Zl9vcHNfdW5tYXAsCisJLnJlbGVhc2UgPSBoeXBlcl9kbWFi dWZfb3BzX3JlbGVhc2UsCisJLmJlZ2luX2NwdV9hY2Nlc3MgPSAodm9pZCopaHlwZXJfZG1hYnVm X29wc19iZWdpbl9jcHVfYWNjZXNzLAorCS5lbmRfY3B1X2FjY2VzcyA9ICh2b2lkKiloeXBlcl9k bWFidWZfb3BzX2VuZF9jcHVfYWNjZXNzLAorCS5tYXBfYXRvbWljID0gaHlwZXJfZG1hYnVmX29w c19rbWFwX2F0b21pYywKKwkudW5tYXBfYXRvbWljID0gaHlwZXJfZG1hYnVmX29wc19rdW5tYXBf YXRvbWljLAorCS5tYXAgPSBoeXBlcl9kbWFidWZfb3BzX2ttYXAsCisJLnVubWFwID0gaHlwZXJf ZG1hYnVmX29wc19rdW5tYXAsCisJLm1tYXAgPSBoeXBlcl9kbWFidWZfb3BzX21tYXAsCisJLnZt YXAgPSBoeXBlcl9kbWFidWZfb3BzX3ZtYXAsCisJLnZ1bm1hcCA9IGh5cGVyX2RtYWJ1Zl9vcHNf dnVubWFwLAogfTsKIAogLyogZXhwb3J0aW5nIGRtYWJ1ZiBhcyBmZCAqLwotaW50IGh5cGVyX2Rt YWJ1Zl9leHBvcnRfZmQoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqZGlu Zm8sIGludCBmbGFncykKK2ludCBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkKHN0cnVjdCBpbXBvcnRl ZF9zZ3RfaW5mbyAqaW1wb3J0ZWQsIGludCBmbGFncykKIHsKIAlpbnQgZmQgPSAtMTsKIAogCS8q IGNhbGwgaHlwZXJfZG1hYnVmX2V4cG9ydF9kbWFidWYgYW5kIGNyZWF0ZQogCSAqIGFuZCBiaW5k IGEgaGFuZGxlIGZvciBpdCB0aGVuIHJlbGVhc2UKIAkgKi8KLQloeXBlcl9kbWFidWZfZXhwb3J0 X2RtYV9idWYoZGluZm8pOworCWh5cGVyX2RtYWJ1Zl9leHBvcnRfZG1hX2J1ZihpbXBvcnRlZCk7 CiAKLQlpZiAoZGluZm8tPmRtYV9idWYpIHsKLQkJZmQgPSBkbWFfYnVmX2ZkKGRpbmZvLT5kbWFf YnVmLCBmbGFncyk7CisJaWYgKGltcG9ydGVkLT5kbWFfYnVmKSB7CisJCWZkID0gZG1hX2J1Zl9m ZChpbXBvcnRlZC0+ZG1hX2J1ZiwgZmxhZ3MpOwogCX0KIAogCXJldHVybiBmZDsKIH0KIAotdm9p ZCBoeXBlcl9kbWFidWZfZXhwb3J0X2RtYV9idWYoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRl ZF9zZ3RfaW5mbyAqZGluZm8pCit2b2lkIGh5cGVyX2RtYWJ1Zl9leHBvcnRfZG1hX2J1ZihzdHJ1 Y3QgaW1wb3J0ZWRfc2d0X2luZm8gKmltcG9ydGVkKQogewogCURFRklORV9ETUFfQlVGX0VYUE9S VF9JTkZPKGV4cF9pbmZvKTsKIAogCWV4cF9pbmZvLm9wcyA9ICZoeXBlcl9kbWFidWZfb3BzOwog CiAJLyogbXVsdGlwbGUgb2YgUEFHRV9TSVpFLCBub3QgY29uc2lkZXJpbmcgb2Zmc2V0ICovCi0J ZXhwX2luZm8uc2l6ZSA9IGRpbmZvLT5zZ3QtPm5lbnRzICogUEFHRV9TSVpFOwotCWV4cF9pbmZv LmZsYWdzID0gLyogbm90IHN1cmUgYWJvdXQgZmxhZyAqLzA7Ci0JZXhwX2luZm8ucHJpdiA9IGRp bmZvOworCWV4cF9pbmZvLnNpemUgPSBpbXBvcnRlZC0+c2d0LT5uZW50cyAqIFBBR0VfU0laRTsK KwlleHBfaW5mby5mbGFncyA9IC8qIG5vdCBzdXJlIGFib3V0IGZsYWcgKi8gMDsKKwlleHBfaW5m by5wcml2ID0gaW1wb3J0ZWQ7CiAKLQlkaW5mby0+ZG1hX2J1ZiA9IGRtYV9idWZfZXhwb3J0KCZl eHBfaW5mbyk7CisJaW1wb3J0ZWQtPmRtYV9idWYgPSBkbWFfYnVmX2V4cG9ydCgmZXhwX2luZm8p OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9v cHMuaCBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfb3BzLmgKaW5kZXgg OGMwNmZjNi4uYzU1MDVhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5 cGVyX2RtYWJ1Zl9vcHMuaAorKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1h YnVmX29wcy5oCkBAIC0yNSw4ICsyNSw4IEBACiAjaWZuZGVmIF9fSFlQRVJfRE1BQlVGX09QU19I X18KICNkZWZpbmUgX19IWVBFUl9ETUFCVUZfT1BTX0hfXwogCi1pbnQgaHlwZXJfZG1hYnVmX2V4 cG9ydF9mZChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2ltcG9ydGVkX3NndF9pbmZvICpkaW5mbywgaW50 IGZsYWdzKTsKK2ludCBoeXBlcl9kbWFidWZfZXhwb3J0X2ZkKHN0cnVjdCBpbXBvcnRlZF9zZ3Rf aW5mbyAqaW1wb3J0ZWQsIGludCBmbGFncyk7CiAKLXZvaWQgaHlwZXJfZG1hYnVmX2V4cG9ydF9k bWFfYnVmKHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKmRpbmZvKTsKK3Zv aWQgaHlwZXJfZG1hYnVmX2V4cG9ydF9kbWFfYnVmKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAq aW1wb3J0ZWQpOwogCiAjZW5kaWYgLyogX19IWVBFUl9ETUFCVUZfSU1QX0hfXyAqLwpkaWZmIC0t Z2l0IGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9xdWVyeS5jIGIvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9xdWVyeS5jCmluZGV4IDM5YzlkZWUu LjM2ZTg4OGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFi dWZfcXVlcnkuYworKysgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3F1 ZXJ5LmMKQEAgLTMyLDE2ICszMiwxMiBAQAogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9zdHJ1Y3Qu aCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfaWQuaCIKIAotZXh0ZXJuIHN0cnVjdCBoeXBlcl9k bWFidWZfcHJpdmF0ZSBoeXBlcl9kbWFidWZfcHJpdmF0ZTsKLQogI2RlZmluZSBIWVBFUl9ETUFC VUZfU0laRShuZW50cywgZmlyc3Rfb2Zmc2V0LCBsYXN0X2xlbikgXAogCSgobmVudHMpKlBBR0Vf U0laRSAtIChmaXJzdF9vZmZzZXQpIC0gUEFHRV9TSVpFICsgKGxhc3RfbGVuKSkKIAotaW50IGh5 cGVyX2RtYWJ1Zl9xdWVyeV9leHBvcnRlZChzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvICpz Z3RfaW5mbywKK2ludCBoeXBlcl9kbWFidWZfcXVlcnlfZXhwb3J0ZWQoc3RydWN0IGV4cG9ydGVk X3NndF9pbmZvICpleHBvcnRlZCwKIAkJCQlpbnQgcXVlcnksIHVuc2lnbmVkIGxvbmcqIGluZm8p CiB7Ci0JaW50IG47Ci0KIAlzd2l0Y2ggKHF1ZXJ5KQogCXsKIAkJY2FzZSBIWVBFUl9ETUFCVUZf UVVFUllfVFlQRToKQEAgLTUwLDQ1ICs0Niw0NiBAQCBpbnQgaHlwZXJfZG1hYnVmX3F1ZXJ5X2V4 cG9ydGVkKHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gKnNndF9pbmZvLAogCiAJCS8qIGV4 cG9ydGluZyBkb21haW4gb2YgdGhpcyBzcGVjaWZpYyBkbWFidWYqLwogCQljYXNlIEhZUEVSX0RN QUJVRl9RVUVSWV9FWFBPUlRFUjoKLQkJCSppbmZvID0gSFlQRVJfRE1BQlVGX0RPTV9JRChzZ3Rf aW5mby0+aGlkKTsKKwkJCSppbmZvID0gSFlQRVJfRE1BQlVGX0RPTV9JRChleHBvcnRlZC0+aGlk KTsKIAkJCWJyZWFrOwogCiAJCS8qIGltcG9ydGluZyBkb21haW4gb2YgdGhpcyBzcGVjaWZpYyBk bWFidWYgKi8KIAkJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfSU1QT1JURVI6Ci0JCQkqaW5mbyA9 IHNndF9pbmZvLT5oeXBlcl9kbWFidWZfcmRvbWFpbjsKKwkJCSppbmZvID0gZXhwb3J0ZWQtPnJk b21pZDsKIAkJCWJyZWFrOwogCiAJCS8qIHNpemUgb2YgZG1hYnVmIGluIGJ5dGUgKi8KIAkJY2Fz ZSBIWVBFUl9ETUFCVUZfUVVFUllfU0laRToKLQkJCSppbmZvID0gc2d0X2luZm8tPmRtYV9idWYt PnNpemU7CisJCQkqaW5mbyA9IGV4cG9ydGVkLT5kbWFfYnVmLT5zaXplOwogCQkJYnJlYWs7CiAK IAkJLyogd2hldGhlciB0aGUgYnVmZmVyIGlzIHVzZWQgYnkgaW1wb3J0ZXIgKi8KIAkJY2FzZSBI WVBFUl9ETUFCVUZfUVVFUllfQlVTWToKLQkJCSppbmZvID0gKHNndF9pbmZvLT5pbXBvcnRlcl9l eHBvcnRlZCA9PSAwKSA/IGZhbHNlIDogdHJ1ZTsKKwkJCSppbmZvID0gKGV4cG9ydGVkLT5hY3Rp dmUgPiAwKTsKIAkJCWJyZWFrOwogCiAJCS8qIHdoZXRoZXIgdGhlIGJ1ZmZlciBpcyB1bmV4cG9y dGVkICovCiAJCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZX1VORVhQT1JURUQ6Ci0JCQkqaW5mbyA9 ICFzZ3RfaW5mby0+dmFsaWQ7CisJCQkqaW5mbyA9ICFleHBvcnRlZC0+dmFsaWQ7CiAJCQlicmVh azsKIAogCQkvKiB3aGV0aGVyIHRoZSBidWZmZXIgaXMgc2NoZWR1bGVkIHRvIGJlIHVuZXhwb3J0 ZWQgKi8KIAkJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfREVMQVlFRF9VTkVYUE9SVEVEOgotCQkJ KmluZm8gPSAhc2d0X2luZm8tPnVuZXhwb3J0X3NjaGVkdWxlZDsKKwkJCSppbmZvID0gIWV4cG9y dGVkLT51bmV4cG9ydF9zY2hlZDsKIAkJCWJyZWFrOwogCiAJCS8qIHNpemUgb2YgcHJpdmF0ZSBp bmZvIGF0dGFjaGVkIHRvIGJ1ZmZlciAqLwogCQljYXNlIEhZUEVSX0RNQUJVRl9RVUVSWV9QUklW X0lORk9fU0laRToKLQkJCSppbmZvID0gc2d0X2luZm8tPnN6X3ByaXY7CisJCQkqaW5mbyA9IGV4 cG9ydGVkLT5zel9wcml2OwogCQkJYnJlYWs7CiAKIAkJLyogY29weSBwcml2YXRlIGluZm8gYXR0 YWNoZWQgdG8gYnVmZmVyICovCiAJCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZX1BSSVZfSU5GTzoK LQkJCWlmIChzZ3RfaW5mby0+c3pfcHJpdiA+IDApIHsKKwkJCWlmIChleHBvcnRlZC0+c3pfcHJp diA+IDApIHsKKwkJCQlpbnQgbjsKIAkJCQluID0gY29weV90b191c2VyKCh2b2lkIF9fdXNlciop ICppbmZvLAotCQkJCQkJc2d0X2luZm8tPnByaXYsCi0JCQkJCQlzZ3RfaW5mby0+c3pfcHJpdik7 CisJCQkJCQlleHBvcnRlZC0+cHJpdiwKKwkJCQkJCWV4cG9ydGVkLT5zel9wcml2KTsKIAkJCQlp ZiAobiAhPSAwKQogCQkJCQlyZXR1cm4gLUVJTlZBTDsKIAkJCX0KQEAgLTEwMiwxMSArOTksOSBA QCBpbnQgaHlwZXJfZG1hYnVmX3F1ZXJ5X2V4cG9ydGVkKHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0 X2luZm8gKnNndF9pbmZvLAogfQogCiAKLWludCBoeXBlcl9kbWFidWZfcXVlcnlfaW1wb3J0ZWQo c3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWRfc2d0X2luZm8s CitpbnQgaHlwZXJfZG1hYnVmX3F1ZXJ5X2ltcG9ydGVkKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5m byAqaW1wb3J0ZWQsCiAJCQkJaW50IHF1ZXJ5LCB1bnNpZ25lZCBsb25nICppbmZvKQogewotCWlu dCBuOwotCiAJc3dpdGNoIChxdWVyeSkKIAl7CiAJCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZX1RZ UEU6CkBAIC0xMTUsNTAgKzExMCw1MSBAQCBpbnQgaHlwZXJfZG1hYnVmX3F1ZXJ5X2ltcG9ydGVk KHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8gKmltcG9ydGVkXwogCiAJCS8q IGV4cG9ydGluZyBkb21haW4gb2YgdGhpcyBzcGVjaWZpYyBkbWFidWYqLwogCQljYXNlIEhZUEVS X0RNQUJVRl9RVUVSWV9FWFBPUlRFUjoKLQkJCSppbmZvID0gSFlQRVJfRE1BQlVGX0RPTV9JRChp bXBvcnRlZF9zZ3RfaW5mby0+aGlkKTsKKwkJCSppbmZvID0gSFlQRVJfRE1BQlVGX0RPTV9JRChp bXBvcnRlZC0+aGlkKTsKIAkJCWJyZWFrOwogCiAJCS8qIGltcG9ydGluZyBkb21haW4gb2YgdGhp cyBzcGVjaWZpYyBkbWFidWYgKi8KIAkJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfSU1QT1JURVI6 Ci0JCQkqaW5mbyA9IGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRvbWlkOworCQkJKmluZm8gPSBoeV9k cnZfcHJpdi0+ZG9taWQ7CiAJCQlicmVhazsKIAogCQkvKiBzaXplIG9mIGRtYWJ1ZiBpbiBieXRl ICovCiAJCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZX1NJWkU6Ci0JCQlpZiAoaW1wb3J0ZWRfc2d0 X2luZm8tPmRtYV9idWYpIHsKKwkJCWlmIChpbXBvcnRlZC0+ZG1hX2J1ZikgewogCQkJCS8qIGlm IGxvY2FsIGRtYV9idWYgaXMgY3JlYXRlZCAoaWYgaXQncyBldmVyIG1hcHBlZCksCiAJCQkJICog cmV0cmlldmUgaXQgZGlyZWN0bHkgZnJvbSBzdHJ1Y3QgZG1hX2J1ZiAqCiAJCQkJICovCi0JCQkJ KmluZm8gPSBpbXBvcnRlZF9zZ3RfaW5mby0+ZG1hX2J1Zi0+c2l6ZTsKKwkJCQkqaW5mbyA9IGlt cG9ydGVkLT5kbWFfYnVmLT5zaXplOwogCQkJfSBlbHNlIHsKIAkJCQkvKiBjYWxjdWF0ZSBpdCBm cm9tIGdpdmVuIG5lbnRzLCBmcnN0X29mc3QgYW5kIGxhc3RfbGVuICovCi0JCQkJKmluZm8gPSBI WVBFUl9ETUFCVUZfU0laRShpbXBvcnRlZF9zZ3RfaW5mby0+bmVudHMsCi0JCQkJCQkJICBpbXBv cnRlZF9zZ3RfaW5mby0+ZnJzdF9vZnN0LAotCQkJCQkJCSAgaW1wb3J0ZWRfc2d0X2luZm8tPmxh c3RfbGVuKTsKKwkJCQkqaW5mbyA9IEhZUEVSX0RNQUJVRl9TSVpFKGltcG9ydGVkLT5uZW50cywK KwkJCQkJCQkgIGltcG9ydGVkLT5mcnN0X29mc3QsCisJCQkJCQkJICBpbXBvcnRlZC0+bGFzdF9s ZW4pOwogCQkJfQogCQkJYnJlYWs7CiAKIAkJLyogd2hldGhlciB0aGUgYnVmZmVyIGlzIHVzZWQg b3Igbm90ICovCiAJCWNhc2UgSFlQRVJfRE1BQlVGX1FVRVJZX0JVU1k6CiAJCQkvKiBjaGVja3Mg aWYgaXQncyB1c2VkIGJ5IGltcG9ydGVyICovCi0JCQkqaW5mbyA9IChpbXBvcnRlZF9zZ3RfaW5m by0+bnVtX2ltcG9ydGVycyA+IDApID8gdHJ1ZSA6IGZhbHNlOworCQkJKmluZm8gPSAoaW1wb3J0 ZWQtPmltcG9ydGVycyA+IDApOwogCQkJYnJlYWs7CiAKIAkJLyogd2hldGhlciB0aGUgYnVmZmVy IGlzIHVuZXhwb3J0ZWQgKi8KIAkJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfVU5FWFBPUlRFRDoK LQkJCSppbmZvID0gIWltcG9ydGVkX3NndF9pbmZvLT52YWxpZDsKKwkJCSppbmZvID0gIWltcG9y dGVkLT52YWxpZDsKIAkJCWJyZWFrOwogCQkvKiBzaXplIG9mIHByaXZhdGUgaW5mbyBhdHRhY2hl ZCB0byBidWZmZXIgKi8KIAkJY2FzZSBIWVBFUl9ETUFCVUZfUVVFUllfUFJJVl9JTkZPX1NJWkU6 Ci0JCQkqaW5mbyA9IGltcG9ydGVkX3NndF9pbmZvLT5zel9wcml2OworCQkJKmluZm8gPSBpbXBv cnRlZC0+c3pfcHJpdjsKIAkJCWJyZWFrOwogCiAJCS8qIGNvcHkgcHJpdmF0ZSBpbmZvIGF0dGFj aGVkIHRvIGJ1ZmZlciAqLwogCQljYXNlIEhZUEVSX0RNQUJVRl9RVUVSWV9QUklWX0lORk86Ci0J CQlpZiAoaW1wb3J0ZWRfc2d0X2luZm8tPnN6X3ByaXYgPiAwKSB7CisJCQlpZiAoaW1wb3J0ZWQt PnN6X3ByaXYgPiAwKSB7CisJCQkJaW50IG47CiAJCQkJbiA9IGNvcHlfdG9fdXNlcigodm9pZCBf X3VzZXIqKSAqaW5mbywKLQkJCQkJCWltcG9ydGVkX3NndF9pbmZvLT5wcml2LAotCQkJCQkJaW1w b3J0ZWRfc2d0X2luZm8tPnN6X3ByaXYpOworCQkJCQkJaW1wb3J0ZWQtPnByaXYsCisJCQkJCQlp bXBvcnRlZC0+c3pfcHJpdik7CiAJCQkJaWYgKG4gIT0gMCkKIAkJCQkJcmV0dXJuIC1FSU5WQUw7 CiAJCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X3F1ZXJ5LmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3F1ZXJ5LmgK aW5kZXggN2JiYjMyMi4uNjVhZTczOCAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL2h5cGVyX2RtYWJ1Zl9xdWVyeS5oCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9o eXBlcl9kbWFidWZfcXVlcnkuaApAQCAtMSwxMCArMSwxMCBAQAogI2lmbmRlZiBfX0hZUEVSX0RN QUJVRl9RVUVSWV9IX18KICNkZWZpbmUgX19IWVBFUl9ETUFCVUZfUVVFUllfSF9fCiAKLWludCBo eXBlcl9kbWFidWZfcXVlcnlfaW1wb3J0ZWQoc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9z Z3RfaW5mbyAqaW1wb3J0ZWRfc2d0X2luZm8sCitpbnQgaHlwZXJfZG1hYnVmX3F1ZXJ5X2ltcG9y dGVkKHN0cnVjdCBpbXBvcnRlZF9zZ3RfaW5mbyAqaW1wb3J0ZWQsCiAJCQkJaW50IHF1ZXJ5LCB1 bnNpZ25lZCBsb25nICppbmZvKTsKIAotaW50IGh5cGVyX2RtYWJ1Zl9xdWVyeV9leHBvcnRlZChz dHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvICpzZ3RfaW5mbywKK2ludCBoeXBlcl9kbWFidWZf cXVlcnlfZXhwb3J0ZWQoc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvICpleHBvcnRlZCwKIAkJCQlp bnQgcXVlcnksIHVuc2lnbmVkIGxvbmcgKmluZm8pOwogCiAjZW5kaWYgLy8gX19IWVBFUl9ETUFC VUZfUVVFUllfSF9fCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX3JlbW90ZV9zeW5jLmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1h YnVmX3JlbW90ZV9zeW5jLmMKaW5kZXggOTAwNDQwNi4uMDFlYzk4YyAxMDA2NDQKLS0tIGEvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYy5jCisrKyBiL2Ry aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMuYwpAQCAtMzks OCArMzksNiBAQAogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9tc2cuaCIKICNpbmNsdWRlICJoeXBl cl9kbWFidWZfc2dsX3Byb2MuaCIKIAotZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfcHJpdmF0 ZSBoeXBlcl9kbWFidWZfcHJpdmF0ZTsKLQogLyogV2hlbmV2ZXIgaW1wb3J0ZXIgZG9lcyBkbWEg b3BlcmF0aW9ucyBmcm9tIHJlbW90ZSBkb21haW4sCiAgKiBhIG5vdGlmaWNhdGlvbiBpcyBzZW50 IHRvIHRoZSBleHBvcnRlciBzbyB0aGF0IGV4cG9ydGVyCiAgKiBpc3N1ZXMgZXF1aXZhbGVudCBk bWEgb3BlcmF0aW9uIG9uIHRoZSBvcmlnaW5hbCBkbWEgYnVmCkBAIC01OCw3ICs1Niw3IEBAIGV4 dGVybiBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3ByaXZhdGUgaHlwZXJfZG1hYnVmX3ByaXZhdGU7CiAg Ki8KIGludCBoeXBlcl9kbWFidWZfcmVtb3RlX3N5bmMoaHlwZXJfZG1hYnVmX2lkX3QgaGlkLCBp bnQgb3BzKQogewotCXN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gKnNndF9pbmZvOworCXN0 cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyAqZXhwb3J0ZWQ7CiAJc3RydWN0IHNndF9saXN0ICpzZ3Rs OwogCXN0cnVjdCBhdHRhY2htZW50X2xpc3QgKmF0dGFjaGw7CiAJc3RydWN0IGttYXBfdmFkZHJf bGlzdCAqdmFfa21hcGw7CkBAIC02NiwxMCArNjQsMTAgQEAgaW50IGh5cGVyX2RtYWJ1Zl9yZW1v dGVfc3luYyhoeXBlcl9kbWFidWZfaWRfdCBoaWQsIGludCBvcHMpCiAJaW50IHJldDsKIAogCS8q IGZpbmQgYSBjb3Jlc3BvbmRpbmcgU0dUIGZvciB0aGUgaWQgKi8KLQlzZ3RfaW5mbyA9IGh5cGVy X2RtYWJ1Zl9maW5kX2V4cG9ydGVkKGhpZCk7CisJZXhwb3J0ZWQgPSBoeXBlcl9kbWFidWZfZmlu ZF9leHBvcnRlZChoaWQpOwogCi0JaWYgKCFzZ3RfaW5mbykgewotCQlkZXZfZXJyKGh5cGVyX2Rt YWJ1Zl9wcml2YXRlLmRldmljZSwKKwlpZiAoIWV4cG9ydGVkKSB7CisJCWRldl9lcnIoaHlfZHJ2 X3ByaXYtPmRldiwKIAkJCSJkbWFidWYgcmVtb3RlIHN5bmM6OmNhbid0IGZpbmQgZXhwb3J0ZWQg bGlzdFxuIik7CiAJCXJldHVybiAtRU5PRU5UOwogCX0KQEAgLTc5LDg0ICs3Nyw4NCBAQCBpbnQg aHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jKGh5cGVyX2RtYWJ1Zl9pZF90IGhpZCwgaW50IG9wcykK IAkJYXR0YWNobCA9IGtjYWxsb2MoMSwgc2l6ZW9mKCphdHRhY2hsKSwgR0ZQX0tFUk5FTCk7CiAK IAkJaWYgKCFhdHRhY2hsKSB7Ci0JCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmlj ZSwKLQkJCQkiZG1hYnVmIHJlbW90ZSBzeW5jOjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVS X0RNQUJVRl9PUFNfQVRUQUNIXG4iKTsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJ CQkicmVtb3RlIHN5bmM6OkhZUEVSX0RNQUJVRl9PUFNfQVRUQUNIXG4iKTsKIAkJCXJldHVybiAt RU5PTUVNOwogCQl9CiAKLQkJYXR0YWNobC0+YXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goc2d0X2lu Zm8tPmRtYV9idWYsCi0JCQkJCQkgaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlKTsKKwkJYXR0 YWNobC0+YXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goZXhwb3J0ZWQtPmRtYV9idWYsCisJCQkJCQkg aHlfZHJ2X3ByaXYtPmRldik7CiAKIAkJaWYgKCFhdHRhY2hsLT5hdHRhY2gpIHsKIAkJCWtmcmVl KGF0dGFjaGwpOwotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkJ ImRtYWJ1ZiByZW1vdGUgc3luYzo6ZXJyb3Igd2hpbGUgcHJvY2Vzc2luZyBIWVBFUl9ETUFCVUZf T1BTX0FUVEFDSFxuIik7CisJCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkJInJlbW90 ZSBzeW5jOjpIWVBFUl9ETUFCVUZfT1BTX0FUVEFDSFxuIik7CiAJCQlyZXR1cm4gLUVOT01FTTsK IAkJfQogCi0JCWxpc3RfYWRkKCZhdHRhY2hsLT5saXN0LCAmc2d0X2luZm8tPmFjdGl2ZV9hdHRh Y2hlZC0+bGlzdCk7CisJCWxpc3RfYWRkKCZhdHRhY2hsLT5saXN0LCAmZXhwb3J0ZWQtPmFjdGl2 ZV9hdHRhY2hlZC0+bGlzdCk7CiAJCWJyZWFrOwogCiAJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX0RF VEFDSDoKLQkJaWYgKGxpc3RfZW1wdHkoJnNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQtPmxpc3Qp KSB7Ci0JCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiZG1hYnVm IHJlbW90ZSBzeW5jOjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfREVU QUNIXG4iKTsKLQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlpZiAo bGlzdF9lbXB0eSgmZXhwb3J0ZWQtPmFjdGl2ZV9hdHRhY2hlZC0+bGlzdCkpIHsKKwkJCWRldl9l cnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkicmVtb3RlIHN5bmM6OkhZUEVSX0RNQUJVRl9PUFNf REVUQUNIXG4iKTsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCQkibm8gbW9yZSBk bWFidWYgYXR0YWNobWVudCBsZWZ0IHRvIGJlIGRldGFjaGVkXG4iKTsKIAkJCXJldHVybiAtRUZB VUxUOwogCQl9CiAKLQkJYXR0YWNobCA9IGxpc3RfZmlyc3RfZW50cnkoJnNndF9pbmZvLT5hY3Rp dmVfYXR0YWNoZWQtPmxpc3QsCisJCWF0dGFjaGwgPSBsaXN0X2ZpcnN0X2VudHJ5KCZleHBvcnRl ZC0+YWN0aXZlX2F0dGFjaGVkLT5saXN0LAogCQkJCQkgICBzdHJ1Y3QgYXR0YWNobWVudF9saXN0 LCBsaXN0KTsKIAotCQlkbWFfYnVmX2RldGFjaChzZ3RfaW5mby0+ZG1hX2J1ZiwgYXR0YWNobC0+ YXR0YWNoKTsKKwkJZG1hX2J1Zl9kZXRhY2goZXhwb3J0ZWQtPmRtYV9idWYsIGF0dGFjaGwtPmF0 dGFjaCk7CiAJCWxpc3RfZGVsKCZhdHRhY2hsLT5saXN0KTsKIAkJa2ZyZWUoYXR0YWNobCk7CiAJ CWJyZWFrOwogCiAJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX01BUDoKLQkJaWYgKGxpc3RfZW1wdHko JnNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQtPmxpc3QpKSB7Ci0JCQlkZXZfZXJyKGh5cGVyX2Rt YWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiZG1hYnVmIHJlbW90ZSBzeW5jOjplcnJvciB3aGls ZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfTUFQXG4iKTsKLQkJCWRldl9lcnIoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlpZiAobGlzdF9lbXB0eSgmZXhwb3J0ZWQtPmFjdGl2 ZV9hdHRhY2hlZC0+bGlzdCkpIHsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQki cmVtb3RlIHN5bmM6OkhZUEVSX0RNQUJVRl9PUFNfTUFQXG4iKTsKKwkJCWRldl9lcnIoaHlfZHJ2 X3ByaXYtPmRldiwKIAkJCQkibm8gbW9yZSBkbWFidWYgYXR0YWNobWVudCBsZWZ0IHRvIGJlIG1h cHBlZFxuIik7CiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJfQogCi0JCWF0dGFjaGwgPSBsaXN0X2Zp cnN0X2VudHJ5KCZzZ3RfaW5mby0+YWN0aXZlX2F0dGFjaGVkLT5saXN0LAorCQlhdHRhY2hsID0g bGlzdF9maXJzdF9lbnRyeSgmZXhwb3J0ZWQtPmFjdGl2ZV9hdHRhY2hlZC0+bGlzdCwKIAkJCQkJ ICAgc3RydWN0IGF0dGFjaG1lbnRfbGlzdCwgbGlzdCk7CiAKIAkJc2d0bCA9IGtjYWxsb2MoMSwg c2l6ZW9mKCpzZ3RsKSwgR0ZQX0tFUk5FTCk7CiAKIAkJaWYgKCFzZ3RsKSB7Ci0JCQlkZXZfZXJy KGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiZG1hYnVmIHJlbW90ZSBzeW5jOjpl cnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfTUFQXG4iKTsKKwkJCWRldl9l cnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkicmVtb3RlIHN5bmM6OkhZUEVSX0RNQUJVRl9PUFNf TUFQXG4iKTsKIAkJCXJldHVybiAtRU5PTUVNOwogCQl9CiAKIAkJc2d0bC0+c2d0ID0gZG1hX2J1 Zl9tYXBfYXR0YWNobWVudChhdHRhY2hsLT5hdHRhY2gsIERNQV9CSURJUkVDVElPTkFMKTsKIAkJ aWYgKCFzZ3RsLT5zZ3QpIHsKIAkJCWtmcmVlKHNndGwpOwotCQkJZGV2X2VycihoeXBlcl9kbWFi dWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkJImRtYWJ1ZiByZW1vdGUgc3luYzo6ZXJyb3Igd2hpbGUg cHJvY2Vzc2luZyBIWVBFUl9ETUFCVUZfT1BTX01BUFxuIik7CisJCQlkZXZfZXJyKGh5X2Rydl9w cml2LT5kZXYsCisJCQkJInJlbW90ZSBzeW5jOjpIWVBFUl9ETUFCVUZfT1BTX01BUFxuIik7CiAJ CQlyZXR1cm4gLUVOT01FTTsKIAkJfQotCQlsaXN0X2FkZCgmc2d0bC0+bGlzdCwgJnNndF9pbmZv LT5hY3RpdmVfc2d0cy0+bGlzdCk7CisJCWxpc3RfYWRkKCZzZ3RsLT5saXN0LCAmZXhwb3J0ZWQt PmFjdGl2ZV9zZ3RzLT5saXN0KTsKIAkJYnJlYWs7CiAKIAljYXNlIEhZUEVSX0RNQUJVRl9PUFNf VU5NQVA6Ci0JCWlmIChsaXN0X2VtcHR5KCZzZ3RfaW5mby0+YWN0aXZlX3NndHMtPmxpc3QpIHx8 Ci0JCSAgICBsaXN0X2VtcHR5KCZzZ3RfaW5mby0+YWN0aXZlX2F0dGFjaGVkLT5saXN0KSkgewot CQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkJImRtYWJ1ZiByZW1v dGUgc3luYzo6ZXJyb3Igd2hpbGUgcHJvY2Vzc2luZyBIWVBFUl9ETUFCVUZfT1BTX1VOTUFQXG4i KTsKLQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlpZiAobGlzdF9l bXB0eSgmZXhwb3J0ZWQtPmFjdGl2ZV9zZ3RzLT5saXN0KSB8fAorCQkgICAgbGlzdF9lbXB0eSgm ZXhwb3J0ZWQtPmFjdGl2ZV9hdHRhY2hlZC0+bGlzdCkpIHsKKwkJCWRldl9lcnIoaHlfZHJ2X3By aXYtPmRldiwKKwkJCQkicmVtb3RlIHN5bmM6OkhZUEVSX0RNQUJVRl9PUFNfVU5NQVBcbiIpOwor CQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJCSJubyBtb3JlIFNHVCBvciBhdHRhY2ht ZW50IGxlZnQgdG8gYmUgdW5tYXBwZWRcbiIpOwogCQkJcmV0dXJuIC1FRkFVTFQ7CiAJCX0KIAot CQlhdHRhY2hsID0gbGlzdF9maXJzdF9lbnRyeSgmc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hlZC0+ bGlzdCwKKwkJYXR0YWNobCA9IGxpc3RfZmlyc3RfZW50cnkoJmV4cG9ydGVkLT5hY3RpdmVfYXR0 YWNoZWQtPmxpc3QsCiAJCQkJCSAgIHN0cnVjdCBhdHRhY2htZW50X2xpc3QsIGxpc3QpOwotCQlz Z3RsID0gbGlzdF9maXJzdF9lbnRyeSgmc2d0X2luZm8tPmFjdGl2ZV9zZ3RzLT5saXN0LAorCQlz Z3RsID0gbGlzdF9maXJzdF9lbnRyeSgmZXhwb3J0ZWQtPmFjdGl2ZV9zZ3RzLT5saXN0LAogCQkJ CQlzdHJ1Y3Qgc2d0X2xpc3QsIGxpc3QpOwogCiAJCWRtYV9idWZfdW5tYXBfYXR0YWNobWVudChh dHRhY2hsLT5hdHRhY2gsIHNndGwtPnNndCwKQEAgLTE2NiwzMCArMTY0LDMwIEBAIGludCBoeXBl cl9kbWFidWZfcmVtb3RlX3N5bmMoaHlwZXJfZG1hYnVmX2lkX3QgaGlkLCBpbnQgb3BzKQogCQli cmVhazsKIAogCWNhc2UgSFlQRVJfRE1BQlVGX09QU19SRUxFQVNFOgotCQlkZXZfZGJnKGh5cGVy X2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LAogCQkJ IkJ1ZmZlciB7aWQ6JWQga2V5OiVkICVkICVkfSByZWxlYXNlZCwgcmVmZXJlbmNlcyBsZWZ0OiAl ZFxuIiwKLQkJCSBzZ3RfaW5mby0+aGlkLmlkLCBzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMF0sIHNn dF9pbmZvLT5oaWQucm5nX2tleVsxXSwKLQkJCSBzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMl0sIHNn dF9pbmZvLT5pbXBvcnRlcl9leHBvcnRlZCAtMSk7CisJCQkgZXhwb3J0ZWQtPmhpZC5pZCwgZXhw b3J0ZWQtPmhpZC5ybmdfa2V5WzBdLCBleHBvcnRlZC0+aGlkLnJuZ19rZXlbMV0sCisJCQkgZXhw b3J0ZWQtPmhpZC5ybmdfa2V5WzJdLCBleHBvcnRlZC0+YWN0aXZlIC0gMSk7CiAKLSAgICAgICAg ICAgICAgICBzZ3RfaW5mby0+aW1wb3J0ZXJfZXhwb3J0ZWQtLTsKKyAgICAgICAgICAgICAgICBl eHBvcnRlZC0+YWN0aXZlLS07CiAJCS8qIElmIHRoZXJlIGFyZSBzdGlsbCBpbXBvcnRlcnMganVz dCBicmVhaywgaWYgbm8gdGhlbiBjb250aW51ZSB3aXRoIGZpbmFsIGNsZWFudXAgKi8KLQkJaWYg KHNndF9pbmZvLT5pbXBvcnRlcl9leHBvcnRlZCkKKwkJaWYgKGV4cG9ydGVkLT5hY3RpdmUpCiAJ CQlicmVhazsKIAogCQkvKgogCQkgKiBJbXBvcnRlciBqdXN0IHJlbGVhc2VkIGJ1ZmZlciBmZCwg Y2hlY2sgaWYgdGhlcmUgaXMgYW55IG90aGVyIGltcG9ydGVyIHN0aWxsIHVzaW5nIGl0LgogCQkg KiBJZiBub3QgYW5kIGJ1ZmZlciB3YXMgdW5leHBvcnRlZCwgY2xlYW4gdXAgc2hhcmVkIGRhdGEg YW5kIHJlbW92ZSB0aGF0IGJ1ZmZlci4KIAkJICovCi0JCWRldl9kYmcoaHlwZXJfZG1hYnVmX3By aXZhdGUuZGV2aWNlLAorCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiQnVmZmVyIHtp ZDolZCBrZXk6JWQgJWQgJWR9IGZpbmFsIHJlbGVhc2VkXG4iLAotCQkJc2d0X2luZm8tPmhpZC5p ZCwgc2d0X2luZm8tPmhpZC5ybmdfa2V5WzBdLCBzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMV0sCi0J CQlzZ3RfaW5mby0+aGlkLnJuZ19rZXlbMl0pOworCQkJZXhwb3J0ZWQtPmhpZC5pZCwgZXhwb3J0 ZWQtPmhpZC5ybmdfa2V5WzBdLCBleHBvcnRlZC0+aGlkLnJuZ19rZXlbMV0sCisJCQlleHBvcnRl ZC0+aGlkLnJuZ19rZXlbMl0pOwogCi0JCWlmICghc2d0X2luZm8tPnZhbGlkICYmICFzZ3RfaW5m by0+aW1wb3J0ZXJfZXhwb3J0ZWQgJiYKLQkJICAgICFzZ3RfaW5mby0+dW5leHBvcnRfc2NoZWR1 bGVkKSB7Ci0JCQloeXBlcl9kbWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzZ3RfaW5mbywgZmFsc2Up OworCQlpZiAoIWV4cG9ydGVkLT52YWxpZCAmJiAhZXhwb3J0ZWQtPmFjdGl2ZSAmJgorCQkgICAg IWV4cG9ydGVkLT51bmV4cG9ydF9zY2hlZCkgeworCQkJaHlwZXJfZG1hYnVmX2NsZWFudXBfc2d0 X2luZm8oZXhwb3J0ZWQsIGZhbHNlKTsKIAkJCWh5cGVyX2RtYWJ1Zl9yZW1vdmVfZXhwb3J0ZWQo aGlkKTsKLQkJCWtmcmVlKHNndF9pbmZvKTsKKwkJCWtmcmVlKGV4cG9ydGVkKTsKIAkJCS8qIHN0 b3JlIGh5cGVyX2RtYWJ1Zl9pZCBpbiB0aGUgbGlzdCBmb3IgcmV1c2UgKi8KIAkJCXN0b3JlX3Jl dXNhYmxlX2hpZChoaWQpOwogCQl9CkBAIC0xOTcsMTkgKzE5NSwxOSBAQCBpbnQgaHlwZXJfZG1h YnVmX3JlbW90ZV9zeW5jKGh5cGVyX2RtYWJ1Zl9pZF90IGhpZCwgaW50IG9wcykKIAkJYnJlYWs7 CiAKIAljYXNlIEhZUEVSX0RNQUJVRl9PUFNfQkVHSU5fQ1BVX0FDQ0VTUzoKLQkJcmV0ID0gZG1h X2J1Zl9iZWdpbl9jcHVfYWNjZXNzKHNndF9pbmZvLT5kbWFfYnVmLCBETUFfQklESVJFQ1RJT05B TCk7CisJCXJldCA9IGRtYV9idWZfYmVnaW5fY3B1X2FjY2VzcyhleHBvcnRlZC0+ZG1hX2J1Ziwg RE1BX0JJRElSRUNUSU9OQUwpOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfZXJyKGh5cGVyX2RtYWJ1 Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiZG1hYnVmIHJlbW90ZSBzeW5jOjplcnJvciB3aGlsZSBw cm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfQkVHSU5fQ1BVX0FDQ0VTU1xuIik7CisJCQlkZXZf ZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkJInJlbW90ZSBzeW5jOjpIWVBFUl9ETUFCVUZfT1BT X0JFR0lOX0NQVV9BQ0NFU1NcbiIpOwogCQkJcmV0dXJuIHJldDsKIAkJfQogCQlicmVhazsKIAog CWNhc2UgSFlQRVJfRE1BQlVGX09QU19FTkRfQ1BVX0FDQ0VTUzoKLQkJcmV0ID0gZG1hX2J1Zl9l bmRfY3B1X2FjY2VzcyhzZ3RfaW5mby0+ZG1hX2J1ZiwgRE1BX0JJRElSRUNUSU9OQUwpOworCQly ZXQgPSBkbWFfYnVmX2VuZF9jcHVfYWNjZXNzKGV4cG9ydGVkLT5kbWFfYnVmLCBETUFfQklESVJF Q1RJT05BTCk7CiAJCWlmIChyZXQpIHsKLQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUu ZGV2aWNlLAotCQkJCSJkbWFidWYgcmVtb3RlIHN5bmM6OmVycm9yIHdoaWxlIHByb2Nlc3Npbmcg SFlQRVJfRE1BQlVGX09QU19FTkRfQ1BVX0FDQ0VTU1xuIik7CisJCQlkZXZfZXJyKGh5X2Rydl9w cml2LT5kZXYsCisJCQkJInJlbW90ZSBzeW5jOjpIWVBFUl9ETUFCVUZfT1BTX0VORF9DUFVfQUND RVNTXG4iKTsKIAkJCXJldHVybiByZXQ7CiAJCX0KIAkJYnJlYWs7CkBAIC0yMTgsNDkgKzIxNiw0 OSBAQCBpbnQgaHlwZXJfZG1hYnVmX3JlbW90ZV9zeW5jKGh5cGVyX2RtYWJ1Zl9pZF90IGhpZCwg aW50IG9wcykKIAljYXNlIEhZUEVSX0RNQUJVRl9PUFNfS01BUDoKIAkJdmFfa21hcGwgPSBrY2Fs bG9jKDEsIHNpemVvZigqdmFfa21hcGwpLCBHRlBfS0VSTkVMKTsKIAkJaWYgKCF2YV9rbWFwbCkg ewotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkJImRtYWJ1ZiBy ZW1vdGUgc3luYzo6ZXJyb3Igd2hpbGUgcHJvY2Vzc2luZyBIWVBFUl9ETUFCVUZfT1BTX0tNQVAo X0FUT01JQylcbiIpOworCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJCSJyZW1vdGUg c3luYzo6SFlQRVJfRE1BQlVGX09QU19LTUFQKF9BVE9NSUMpXG4iKTsKIAkJCXJldHVybiAtRU5P TUVNOwogCQl9CiAKIAkJLyogZHVtbXkga21hcHBpbmcgb2YgMSBwYWdlICovCiAJCWlmIChvcHMg PT0gSFlQRVJfRE1BQlVGX09QU19LTUFQX0FUT01JQykKLQkJCXZhX2ttYXBsLT52YWRkciA9IGRt YV9idWZfa21hcF9hdG9taWMoc2d0X2luZm8tPmRtYV9idWYsIDEpOworCQkJdmFfa21hcGwtPnZh ZGRyID0gZG1hX2J1Zl9rbWFwX2F0b21pYyhleHBvcnRlZC0+ZG1hX2J1ZiwgMSk7CiAJCWVsc2UK LQkJCXZhX2ttYXBsLT52YWRkciA9IGRtYV9idWZfa21hcChzZ3RfaW5mby0+ZG1hX2J1ZiwgMSk7 CisJCQl2YV9rbWFwbC0+dmFkZHIgPSBkbWFfYnVmX2ttYXAoZXhwb3J0ZWQtPmRtYV9idWYsIDEp OwogCiAJCWlmICghdmFfa21hcGwtPnZhZGRyKSB7CiAJCQlrZnJlZSh2YV9rbWFwbCk7Ci0JCQlk ZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiZG1hYnVmIHJlbW90ZSBz eW5jOjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfS01BUChfQVRPTUlD KVxuIik7CisJCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkJInJlbW90ZSBzeW5jOjpI WVBFUl9ETUFCVUZfT1BTX0tNQVAoX0FUT01JQylcbiIpOwogCQkJcmV0dXJuIC1FTk9NRU07CiAJ CX0KLQkJbGlzdF9hZGQoJnZhX2ttYXBsLT5saXN0LCAmc2d0X2luZm8tPnZhX2ttYXBwZWQtPmxp c3QpOworCQlsaXN0X2FkZCgmdmFfa21hcGwtPmxpc3QsICZleHBvcnRlZC0+dmFfa21hcHBlZC0+ bGlzdCk7CiAJCWJyZWFrOwogCiAJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX0tVTk1BUF9BVE9NSUM6 CiAJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX0tVTk1BUDoKLQkJaWYgKGxpc3RfZW1wdHkoJnNndF9p bmZvLT52YV9rbWFwcGVkLT5saXN0KSkgewotCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsCi0JCQkJImRtYWJ1ZiByZW1vdGUgc3luYzo6ZXJyb3Igd2hpbGUgcHJvY2Vzc2lu ZyBIWVBFUl9ETUFCVUZfT1BTX0tVTk1BUChfQVRPTUlDKVxuIik7Ci0JCQlkZXZfZXJyKGh5cGVy X2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJaWYgKGxpc3RfZW1wdHkoJmV4cG9ydGVkLT52YV9r bWFwcGVkLT5saXN0KSkgeworCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJCSJyZW1v dGUgc3luYzo6SFlQRVJfRE1BQlVGX09QU19LVU5NQVAoX0FUT01JQylcbiIpOworCQkJZGV2X2Vy cihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJCSJubyBtb3JlIGRtYWJ1ZiBWQSB0byBiZSBmcmVlZFxu Iik7CiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJfQogCi0JCXZhX2ttYXBsID0gbGlzdF9maXJzdF9l bnRyeSgmc2d0X2luZm8tPnZhX2ttYXBwZWQtPmxpc3QsCisJCXZhX2ttYXBsID0gbGlzdF9maXJz dF9lbnRyeSgmZXhwb3J0ZWQtPnZhX2ttYXBwZWQtPmxpc3QsCiAJCQkJCSAgICBzdHJ1Y3Qga21h cF92YWRkcl9saXN0LCBsaXN0KTsKIAkJaWYgKCF2YV9rbWFwbC0+dmFkZHIpIHsKLQkJCWRldl9l cnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJCSJkbWFidWYgcmVtb3RlIHN5bmM6 OmVycm9yIHdoaWxlIHByb2Nlc3NpbmcgSFlQRVJfRE1BQlVGX09QU19LVU5NQVAoX0FUT01JQylc biIpOworCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJCSJyZW1vdGUgc3luYzo6SFlQ RVJfRE1BQlVGX09QU19LVU5NQVAoX0FUT01JQylcbiIpOwogCQkJcmV0dXJuIFBUUl9FUlIodmFf a21hcGwtPnZhZGRyKTsKIAkJfQogCiAJCS8qIHVubWFwcGluZyAxIHBhZ2UgKi8KIAkJaWYgKG9w cyA9PSBIWVBFUl9ETUFCVUZfT1BTX0tVTk1BUF9BVE9NSUMpCi0JCQlkbWFfYnVmX2t1bm1hcF9h dG9taWMoc2d0X2luZm8tPmRtYV9idWYsIDEsIHZhX2ttYXBsLT52YWRkcik7CisJCQlkbWFfYnVm X2t1bm1hcF9hdG9taWMoZXhwb3J0ZWQtPmRtYV9idWYsIDEsIHZhX2ttYXBsLT52YWRkcik7CiAJ CWVsc2UKLQkJCWRtYV9idWZfa3VubWFwKHNndF9pbmZvLT5kbWFfYnVmLCAxLCB2YV9rbWFwbC0+ dmFkZHIpOworCQkJZG1hX2J1Zl9rdW5tYXAoZXhwb3J0ZWQtPmRtYV9idWYsIDEsIHZhX2ttYXBs LT52YWRkcik7CiAKIAkJbGlzdF9kZWwoJnZhX2ttYXBsLT5saXN0KTsKIAkJa2ZyZWUodmFfa21h cGwpOwpAQCAtMjY5LDQ4ICsyNjcsNDggQEAgaW50IGh5cGVyX2RtYWJ1Zl9yZW1vdGVfc3luYyho eXBlcl9kbWFidWZfaWRfdCBoaWQsIGludCBvcHMpCiAJY2FzZSBIWVBFUl9ETUFCVUZfT1BTX01N QVA6CiAJCS8qIGN1cnJlbnRseSBub3Qgc3VwcG9ydGVkOiBsb29raW5nIGZvciBhIHdheSB0byBj cmVhdGUKIAkJICogYSBkdW1teSB2bWEgKi8KLQkJZGV2X3dhcm4oaHlwZXJfZG1hYnVmX3ByaXZh dGUuZGV2aWNlLAotCQkJICJkbWFidWYgcmVtb3RlIHN5bmM6OnN5Y2hyb25pemVkIG1tYXAgaXMg bm90IHN1cHBvcnRlZFxuIik7CisJCWRldl93YXJuKGh5X2Rydl9wcml2LT5kZXYsCisJCQkgInJl bW90ZSBzeW5jOjpzeWNocm9uaXplZCBtbWFwIGlzIG5vdCBzdXBwb3J0ZWRcbiIpOwogCQlicmVh azsKIAogCWNhc2UgSFlQRVJfRE1BQlVGX09QU19WTUFQOgogCQl2YV92bWFwbCA9IGtjYWxsb2Mo MSwgc2l6ZW9mKCp2YV92bWFwbCksIEdGUF9LRVJORUwpOwogCiAJCWlmICghdmFfdm1hcGwpIHsK LQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJCSJkbWFidWYgcmVt b3RlIHN5bmM6OmVycm9yIHdoaWxlIHByb2Nlc3NpbmcgSFlQRVJfRE1BQlVGX09QU19WTUFQXG4i KTsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkicmVtb3RlIHN5bmM6OkhZUEVS X0RNQUJVRl9PUFNfVk1BUFxuIik7CiAJCQlyZXR1cm4gLUVOT01FTTsKIAkJfQogCiAJCS8qIGR1 bW15IHZtYXBwaW5nICovCi0JCXZhX3ZtYXBsLT52YWRkciA9IGRtYV9idWZfdm1hcChzZ3RfaW5m by0+ZG1hX2J1Zik7CisJCXZhX3ZtYXBsLT52YWRkciA9IGRtYV9idWZfdm1hcChleHBvcnRlZC0+ ZG1hX2J1Zik7CiAKIAkJaWYgKCF2YV92bWFwbC0+dmFkZHIpIHsKIAkJCWtmcmVlKHZhX3ZtYXBs KTsKLQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJCSJkbWFidWYg cmVtb3RlIHN5bmM6OmVycm9yIHdoaWxlIHByb2Nlc3NpbmcgSFlQRVJfRE1BQlVGX09QU19WTUFQ XG4iKTsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkicmVtb3RlIHN5bmM6OkhZ UEVSX0RNQUJVRl9PUFNfVk1BUFxuIik7CiAJCQlyZXR1cm4gLUVOT01FTTsKIAkJfQotCQlsaXN0 X2FkZCgmdmFfdm1hcGwtPmxpc3QsICZzZ3RfaW5mby0+dmFfdm1hcHBlZC0+bGlzdCk7CisJCWxp c3RfYWRkKCZ2YV92bWFwbC0+bGlzdCwgJmV4cG9ydGVkLT52YV92bWFwcGVkLT5saXN0KTsKIAkJ YnJlYWs7CiAKIAljYXNlIEhZUEVSX0RNQUJVRl9PUFNfVlVOTUFQOgotCQlpZiAobGlzdF9lbXB0 eSgmc2d0X2luZm8tPnZhX3ZtYXBwZWQtPmxpc3QpKSB7Ci0JCQlkZXZfZXJyKGh5cGVyX2RtYWJ1 Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiZG1hYnVmIHJlbW90ZSBzeW5jOjplcnJvciB3aGlsZSBw cm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfVlVOTUFQXG4iKTsKLQkJCWRldl9lcnIoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlpZiAobGlzdF9lbXB0eSgmZXhwb3J0ZWQtPnZhX3Zt YXBwZWQtPmxpc3QpKSB7CisJCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkJInJlbW90 ZSBzeW5jOjpIWVBFUl9ETUFCVUZfT1BTX1ZVTk1BUFxuIik7CisJCQlkZXZfZXJyKGh5X2Rydl9w cml2LT5kZXYsCiAJCQkJIm5vIG1vcmUgZG1hYnVmIFZBIHRvIGJlIGZyZWVkXG4iKTsKIAkJCXJl dHVybiAtRUZBVUxUOwogCQl9Ci0JCXZhX3ZtYXBsID0gbGlzdF9maXJzdF9lbnRyeSgmc2d0X2lu Zm8tPnZhX3ZtYXBwZWQtPmxpc3QsCisJCXZhX3ZtYXBsID0gbGlzdF9maXJzdF9lbnRyeSgmZXhw b3J0ZWQtPnZhX3ZtYXBwZWQtPmxpc3QsCiAJCQkJCXN0cnVjdCB2bWFwX3ZhZGRyX2xpc3QsIGxp c3QpOwogCQlpZiAoIXZhX3ZtYXBsIHx8IHZhX3ZtYXBsLT52YWRkciA9PSBOVUxMKSB7Ci0JCQlk ZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCQkiZG1hYnVmIHJlbW90ZSBz eW5jOjplcnJvciB3aGlsZSBwcm9jZXNzaW5nIEhZUEVSX0RNQUJVRl9PUFNfVlVOTUFQXG4iKTsK KwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkicmVtb3RlIHN5bmM6OkhZUEVSX0RN QUJVRl9PUFNfVlVOTUFQXG4iKTsKIAkJCXJldHVybiAtRUZBVUxUOwogCQl9CiAKLQkJZG1hX2J1 Zl92dW5tYXAoc2d0X2luZm8tPmRtYV9idWYsIHZhX3ZtYXBsLT52YWRkcik7CisJCWRtYV9idWZf dnVubWFwKGV4cG9ydGVkLT5kbWFfYnVmLCB2YV92bWFwbC0+dmFkZHIpOwogCiAJCWxpc3RfZGVs KCZ2YV92bWFwbC0+bGlzdCk7CiAJCWtmcmVlKHZhX3ZtYXBsKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc2dsX3Byb2MuYyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc2dsX3Byb2MuYwppbmRleCA2OTFhNzE0Li4zMTVj MzU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3Nn bF9wcm9jLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zZ2xf cHJvYy5jCkBAIC0zMiw4ICszMiw2IEBACiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1 ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KLSNpbmNsdWRl IDx4ZW4vZ3JhbnRfdGFibGUuaD4KLSNpbmNsdWRlIDxhc20veGVuL3BhZ2UuaD4KICNpbmNsdWRl ICJoeXBlcl9kbWFidWZfZHJ2LmgiCiAjaW5jbHVkZSAiaHlwZXJfZG1hYnVmX3N0cnVjdC5oIgog I2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl9zZ2xfcHJvYy5oIgpAQCAtNDEsOCArMzksNiBAQAogI2lu Y2x1ZGUgImh5cGVyX2RtYWJ1Zl9tc2cuaCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfbGlzdC5o IgogCi1leHRlcm4gc3RydWN0IGh5cGVyX2RtYWJ1Zl9wcml2YXRlIGh5cGVyX2RtYWJ1Zl9wcml2 YXRlOwotCiAjZGVmaW5lIFJFRlNfUEVSX1BBR0UgKFBBR0VfU0laRS9zaXplb2YoZ3JhbnRfcmVm X3QpKQogCiBpbnQgZG1hYnVmX3JlZmNvdW50KHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmKQpAQCAt NjYsNjAgKzYyLDY4IEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2dldF9udW1fcGdzKHN0cnVj dCBzZ190YWJsZSAqc2d0KQogCXNnbCA9IHNndC0+c2dsOwogCiAJbGVuZ3RoID0gc2dsLT5sZW5n dGggLSBQQUdFX1NJWkUgKyBzZ2wtPm9mZnNldDsKLQludW1fcGFnZXMgKz0gKChsZW5ndGggKyBQ QUdFX1NJWkUgLSAxKS9QQUdFX1NJWkUpOyAvKiByb3VuZC11cCAqLworCisJLyogcm91bmQtdXAg Ki8KKwludW1fcGFnZXMgKz0gKChsZW5ndGggKyBQQUdFX1NJWkUgLSAxKS9QQUdFX1NJWkUpOwog CiAJZm9yIChpID0gMTsgaSA8IHNndC0+bmVudHM7IGkrKykgewogCQlzZ2wgPSBzZ19uZXh0KHNn bCk7Ci0JCW51bV9wYWdlcyArPSAoKHNnbC0+bGVuZ3RoICsgUEFHRV9TSVpFIC0gMSkgLyBQQUdF X1NJWkUpOyAvKiByb3VuZC11cCAqLworCisJCS8qIHJvdW5kLXVwICovCisJCW51bV9wYWdlcyAr PSAoKHNnbC0+bGVuZ3RoICsgUEFHRV9TSVpFIC0gMSkgLworCQkJICAgICBQQUdFX1NJWkUpOyAv KiByb3VuZC11cCAqLwogCX0KIAogCXJldHVybiBudW1fcGFnZXM7CiB9CiAKIC8qIGV4dHJhY3Qg cGFnZXMgZGlyZWN0bHkgZnJvbSBzdHJ1Y3Qgc2dfdGFibGUgKi8KLXN0cnVjdCBoeXBlcl9kbWFi dWZfcGFnZXNfaW5mbyAqaHlwZXJfZG1hYnVmX2V4dF9wZ3Moc3RydWN0IHNnX3RhYmxlICpzZ3Qp CitzdHJ1Y3QgcGFnZXNfaW5mbyAqaHlwZXJfZG1hYnVmX2V4dF9wZ3Moc3RydWN0IHNnX3RhYmxl ICpzZ3QpCiB7Ci0Jc3RydWN0IGh5cGVyX2RtYWJ1Zl9wYWdlc19pbmZvICpwaW5mbzsKKwlzdHJ1 Y3QgcGFnZXNfaW5mbyAqcGdfaW5mbzsKIAlpbnQgaSwgaiwgazsKIAlpbnQgbGVuZ3RoOwogCXN0 cnVjdCBzY2F0dGVybGlzdCAqc2dsOwogCi0JcGluZm8gPSBrbWFsbG9jKHNpemVvZigqcGluZm8p LCBHRlBfS0VSTkVMKTsKLQlpZiAoIXBpbmZvKQorCXBnX2luZm8gPSBrbWFsbG9jKHNpemVvZigq cGdfaW5mbyksIEdGUF9LRVJORUwpOworCWlmICghcGdfaW5mbykKIAkJcmV0dXJuIE5VTEw7CiAK LQlwaW5mby0+cGFnZXMgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgcGFnZSAqKSpoeXBlcl9kbWFi dWZfZ2V0X251bV9wZ3Moc2d0KSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFwaW5mby0+cGFnZXMpIHsK LQkJa2ZyZWUocGluZm8pOworCXBnX2luZm8tPnBncyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBw YWdlICopICoKKwkJCSAgICAgICBoeXBlcl9kbWFidWZfZ2V0X251bV9wZ3Moc2d0KSwKKwkJCSAg ICAgICBHRlBfS0VSTkVMKTsKKworCWlmICghcGdfaW5mby0+cGdzKSB7CisJCWtmcmVlKHBnX2lu Zm8pOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAKIAlzZ2wgPSBzZ3QtPnNnbDsKIAotCXBpbmZvLT5u ZW50cyA9IDE7Ci0JcGluZm8tPmZyc3Rfb2ZzdCA9IHNnbC0+b2Zmc2V0OwotCXBpbmZvLT5wYWdl c1swXSA9IHNnX3BhZ2Uoc2dsKTsKKwlwZ19pbmZvLT5uZW50cyA9IDE7CisJcGdfaW5mby0+ZnJz dF9vZnN0ID0gc2dsLT5vZmZzZXQ7CisJcGdfaW5mby0+cGdzWzBdID0gc2dfcGFnZShzZ2wpOwog CWxlbmd0aCA9IHNnbC0+bGVuZ3RoIC0gUEFHRV9TSVpFICsgc2dsLT5vZmZzZXQ7CiAJaSA9IDE7 CiAKIAl3aGlsZSAobGVuZ3RoID4gMCkgewotCQlwaW5mby0+cGFnZXNbaV0gPSBudGhfcGFnZShz Z19wYWdlKHNnbCksIGkpOworCQlwZ19pbmZvLT5wZ3NbaV0gPSBudGhfcGFnZShzZ19wYWdlKHNn bCksIGkpOwogCQlsZW5ndGggLT0gUEFHRV9TSVpFOwotCQlwaW5mby0+bmVudHMrKzsKKwkJcGdf aW5mby0+bmVudHMrKzsKIAkJaSsrOwogCX0KIAogCWZvciAoaiA9IDE7IGogPCBzZ3QtPm5lbnRz OyBqKyspIHsKIAkJc2dsID0gc2dfbmV4dChzZ2wpOwotCQlwaW5mby0+cGFnZXNbaSsrXSA9IHNn X3BhZ2Uoc2dsKTsKKwkJcGdfaW5mby0+cGdzW2krK10gPSBzZ19wYWdlKHNnbCk7CiAJCWxlbmd0 aCA9IHNnbC0+bGVuZ3RoIC0gUEFHRV9TSVpFOwotCQlwaW5mby0+bmVudHMrKzsKKwkJcGdfaW5m by0+bmVudHMrKzsKIAkJayA9IDE7CiAKIAkJd2hpbGUgKGxlbmd0aCA+IDApIHsKLQkJCXBpbmZv LT5wYWdlc1tpKytdID0gbnRoX3BhZ2Uoc2dfcGFnZShzZ2wpLCBrKyspOworCQkJcGdfaW5mby0+ cGdzW2krK10gPSBudGhfcGFnZShzZ19wYWdlKHNnbCksIGsrKyk7CiAJCQlsZW5ndGggLT0gUEFH RV9TSVpFOwotCQkJcGluZm8tPm5lbnRzKys7CisJCQlwZ19pbmZvLT5uZW50cysrOwogCQl9CiAJ fQogCkBAIC0xMjcsMTMgKzEzMSwxMyBAQCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3BhZ2VzX2luZm8g Kmh5cGVyX2RtYWJ1Zl9leHRfcGdzKHN0cnVjdCBzZ190YWJsZSAqc2d0KQogCSAqIGxlbmdodCBh dCB0aGF0IHBvaW50IHdpbGwgYmUgMCBvciBuZWdhdGl2ZSwKIAkgKiBzbyB0byBjYWxjdWxhdGUg bGFzdCBwYWdlIHNpemUganVzdCBhZGQgaXQgdG8gUEFHRV9TSVpFCiAJICovCi0JcGluZm8tPmxh c3RfbGVuID0gUEFHRV9TSVpFICsgbGVuZ3RoOworCXBnX2luZm8tPmxhc3RfbGVuID0gUEFHRV9T SVpFICsgbGVuZ3RoOwogCi0JcmV0dXJuIHBpbmZvOworCXJldHVybiBwZ19pbmZvOwogfQogCiAv KiBjcmVhdGUgc2dfdGFibGUgd2l0aCBnaXZlbiBwYWdlcyBhbmQgb3RoZXIgcGFyYW1ldGVycyAq Lwotc3RydWN0IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfY3JlYXRlX3NndChzdHJ1Y3QgcGFnZSAq KnBhZ2VzLAorc3RydWN0IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfY3JlYXRlX3NndChzdHJ1Y3Qg cGFnZSAqKnBncywKIAkJCQkJIGludCBmcnN0X29mc3QsIGludCBsYXN0X2xlbiwgaW50IG5lbnRz KQogewogCXN0cnVjdCBzZ190YWJsZSAqc2d0OwpAQCAtMTU3LDMxICsxNjEsMzIgQEAgc3RydWN0 IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfY3JlYXRlX3NndChzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAog CiAJc2dsID0gc2d0LT5zZ2w7CiAKLQlzZ19zZXRfcGFnZShzZ2wsIHBhZ2VzWzBdLCBQQUdFX1NJ WkUtZnJzdF9vZnN0LCBmcnN0X29mc3QpOworCXNnX3NldF9wYWdlKHNnbCwgcGdzWzBdLCBQQUdF X1NJWkUtZnJzdF9vZnN0LCBmcnN0X29mc3QpOwogCiAJZm9yIChpPTE7IGk8bmVudHMtMTsgaSsr KSB7CiAJCXNnbCA9IHNnX25leHQoc2dsKTsKLQkJc2dfc2V0X3BhZ2Uoc2dsLCBwYWdlc1tpXSwg UEFHRV9TSVpFLCAwKTsKKwkJc2dfc2V0X3BhZ2Uoc2dsLCBwZ3NbaV0sIFBBR0VfU0laRSwgMCk7 CiAJfQogCiAJaWYgKG5lbnRzID4gMSkgLyogbW9yZSB0aGFuIG9uZSBwYWdlICovIHsKIAkJc2ds ID0gc2dfbmV4dChzZ2wpOwotCQlzZ19zZXRfcGFnZShzZ2wsIHBhZ2VzW2ldLCBsYXN0X2xlbiwg MCk7CisJCXNnX3NldF9wYWdlKHNnbCwgcGdzW2ldLCBsYXN0X2xlbiwgMCk7CiAJfQogCiAJcmV0 dXJuIHNndDsKIH0KIAotaW50IGh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKHN0cnVjdCBo eXBlcl9kbWFidWZfc2d0X2luZm8gKnNndF9pbmZvLCBpbnQgZm9yY2UpCitpbnQgaHlwZXJfZG1h YnVmX2NsZWFudXBfc2d0X2luZm8oc3RydWN0IGV4cG9ydGVkX3NndF9pbmZvICpleHBvcnRlZCwK KwkJCQkgIGludCBmb3JjZSkKIHsKIAlzdHJ1Y3Qgc2d0X2xpc3QgKnNndGw7CiAJc3RydWN0IGF0 dGFjaG1lbnRfbGlzdCAqYXR0YWNobDsKIAlzdHJ1Y3Qga21hcF92YWRkcl9saXN0ICp2YV9rbWFw bDsKIAlzdHJ1Y3Qgdm1hcF92YWRkcl9saXN0ICp2YV92bWFwbDsKLQlzdHJ1Y3QgaHlwZXJfZG1h YnVmX2JhY2tlbmRfb3BzICpvcHMgPSBoeXBlcl9kbWFidWZfcHJpdmF0ZS5iYWNrZW5kX29wczsK KwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tlbmRfb3BzICpvcHMgPSBoeV9kcnZfcHJpdi0+YmFj a2VuZF9vcHM7CiAKLQlpZiAoIXNndF9pbmZvKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3By aXZhdGUuZGV2aWNlLCAiaW52YWxpZCBoeXBlcl9kbWFidWZfaWRcbiIpOworCWlmICghZXhwb3J0 ZWQpIHsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAiaW52YWxpZCBoeXBlcl9kbWFidWZf aWRcbiIpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKQEAgLTE5MCwzNSArMTk1LDM3IEBAIGlu dCBoeXBlcl9kbWFidWZfY2xlYW51cF9zZ3RfaW5mbyhzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9p bmZvICpzZ3RfaW5mbywgaW50IGZvCiAJICogc2lkZS4KIAkgKi8KIAlpZiAoIWZvcmNlICYmCi0J ICAgIHNndF9pbmZvLT5pbXBvcnRlcl9leHBvcnRlZCkgewotCQlkZXZfd2FybihoeXBlcl9kbWFi dWZfcHJpdmF0ZS5kZXZpY2UsICJkbWEtYnVmIGlzIHVzZWQgYnkgaW1wb3J0ZXJcbiIpOworCSAg ICBleHBvcnRlZC0+YWN0aXZlKSB7CisJCWRldl93YXJuKGh5X2Rydl9wcml2LT5kZXYsCisJCQkg ImRtYS1idWYgaXMgdXNlZCBieSBpbXBvcnRlclxuIik7CisKIAkJcmV0dXJuIC1FUEVSTTsKIAl9 CiAKIAkvKiBmb3JjZSA9PSAxIGlzIG5vdCByZWNvbW1lbmRlZCAqLwotCXdoaWxlICghbGlzdF9l bXB0eSgmc2d0X2luZm8tPnZhX2ttYXBwZWQtPmxpc3QpKSB7Ci0JCXZhX2ttYXBsID0gbGlzdF9m aXJzdF9lbnRyeSgmc2d0X2luZm8tPnZhX2ttYXBwZWQtPmxpc3QsCisJd2hpbGUgKCFsaXN0X2Vt cHR5KCZleHBvcnRlZC0+dmFfa21hcHBlZC0+bGlzdCkpIHsKKwkJdmFfa21hcGwgPSBsaXN0X2Zp cnN0X2VudHJ5KCZleHBvcnRlZC0+dmFfa21hcHBlZC0+bGlzdCwKIAkJCQkJICAgIHN0cnVjdCBr bWFwX3ZhZGRyX2xpc3QsIGxpc3QpOwogCi0JCWRtYV9idWZfa3VubWFwKHNndF9pbmZvLT5kbWFf YnVmLCAxLCB2YV9rbWFwbC0+dmFkZHIpOworCQlkbWFfYnVmX2t1bm1hcChleHBvcnRlZC0+ZG1h X2J1ZiwgMSwgdmFfa21hcGwtPnZhZGRyKTsKIAkJbGlzdF9kZWwoJnZhX2ttYXBsLT5saXN0KTsK IAkJa2ZyZWUodmFfa21hcGwpOwogCX0KIAotCXdoaWxlICghbGlzdF9lbXB0eSgmc2d0X2luZm8t PnZhX3ZtYXBwZWQtPmxpc3QpKSB7Ci0JCXZhX3ZtYXBsID0gbGlzdF9maXJzdF9lbnRyeSgmc2d0 X2luZm8tPnZhX3ZtYXBwZWQtPmxpc3QsCisJd2hpbGUgKCFsaXN0X2VtcHR5KCZleHBvcnRlZC0+ dmFfdm1hcHBlZC0+bGlzdCkpIHsKKwkJdmFfdm1hcGwgPSBsaXN0X2ZpcnN0X2VudHJ5KCZleHBv cnRlZC0+dmFfdm1hcHBlZC0+bGlzdCwKIAkJCQkJICAgIHN0cnVjdCB2bWFwX3ZhZGRyX2xpc3Qs IGxpc3QpOwogCi0JCWRtYV9idWZfdnVubWFwKHNndF9pbmZvLT5kbWFfYnVmLCB2YV92bWFwbC0+ dmFkZHIpOworCQlkbWFfYnVmX3Z1bm1hcChleHBvcnRlZC0+ZG1hX2J1ZiwgdmFfdm1hcGwtPnZh ZGRyKTsKIAkJbGlzdF9kZWwoJnZhX3ZtYXBsLT5saXN0KTsKIAkJa2ZyZWUodmFfdm1hcGwpOwog CX0KIAotCXdoaWxlICghbGlzdF9lbXB0eSgmc2d0X2luZm8tPmFjdGl2ZV9zZ3RzLT5saXN0KSkg ewotCQlhdHRhY2hsID0gbGlzdF9maXJzdF9lbnRyeSgmc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hl ZC0+bGlzdCwKKwl3aGlsZSAoIWxpc3RfZW1wdHkoJmV4cG9ydGVkLT5hY3RpdmVfc2d0cy0+bGlz dCkpIHsKKwkJYXR0YWNobCA9IGxpc3RfZmlyc3RfZW50cnkoJmV4cG9ydGVkLT5hY3RpdmVfYXR0 YWNoZWQtPmxpc3QsCiAJCQkJCSAgIHN0cnVjdCBhdHRhY2htZW50X2xpc3QsIGxpc3QpOwogCi0J CXNndGwgPSBsaXN0X2ZpcnN0X2VudHJ5KCZzZ3RfaW5mby0+YWN0aXZlX3NndHMtPmxpc3QsCisJ CXNndGwgPSBsaXN0X2ZpcnN0X2VudHJ5KCZleHBvcnRlZC0+YWN0aXZlX3NndHMtPmxpc3QsCiAJ CQkJCXN0cnVjdCBzZ3RfbGlzdCwgbGlzdCk7CiAKIAkJZG1hX2J1Zl91bm1hcF9hdHRhY2htZW50 KGF0dGFjaGwtPmF0dGFjaCwgc2d0bC0+c2d0LApAQCAtMjI3LDM1ICsyMzQsMzUgQEAgaW50IGh5 cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8g KnNndF9pbmZvLCBpbnQgZm8KIAkJa2ZyZWUoc2d0bCk7CiAJfQogCi0Jd2hpbGUgKCFsaXN0X2Vt cHR5KCZzZ3RfaW5mby0+YWN0aXZlX3NndHMtPmxpc3QpKSB7Ci0JCWF0dGFjaGwgPSBsaXN0X2Zp cnN0X2VudHJ5KCZzZ3RfaW5mby0+YWN0aXZlX2F0dGFjaGVkLT5saXN0LAorCXdoaWxlICghbGlz dF9lbXB0eSgmZXhwb3J0ZWQtPmFjdGl2ZV9zZ3RzLT5saXN0KSkgeworCQlhdHRhY2hsID0gbGlz dF9maXJzdF9lbnRyeSgmZXhwb3J0ZWQtPmFjdGl2ZV9hdHRhY2hlZC0+bGlzdCwKIAkJCQkJICAg c3RydWN0IGF0dGFjaG1lbnRfbGlzdCwgbGlzdCk7CiAKLQkJZG1hX2J1Zl9kZXRhY2goc2d0X2lu Zm8tPmRtYV9idWYsIGF0dGFjaGwtPmF0dGFjaCk7CisJCWRtYV9idWZfZGV0YWNoKGV4cG9ydGVk LT5kbWFfYnVmLCBhdHRhY2hsLT5hdHRhY2gpOwogCQlsaXN0X2RlbCgmYXR0YWNobC0+bGlzdCk7 CiAJCWtmcmVlKGF0dGFjaGwpOwogCX0KIAogCS8qIFN0YXJ0IGNsZWFudXAgb2YgYnVmZmVyIGlu IHJldmVyc2Ugb3JkZXIgdG8gZXhwb3J0aW5nICovCi0Jb3BzLT51bnNoYXJlX3BhZ2VzKCZzZ3Rf aW5mby0+cmVmc19pbmZvLCBzZ3RfaW5mby0+bmVudHMpOworCW9wcy0+dW5zaGFyZV9wYWdlcygm ZXhwb3J0ZWQtPnJlZnNfaW5mbywgZXhwb3J0ZWQtPm5lbnRzKTsKIAogCS8qIHVubWFwIGRtYS1i dWYgKi8KLQlkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoc2d0X2luZm8tPmFjdGl2ZV9hdHRhY2hl ZC0+YXR0YWNoLAotCQkJCSBzZ3RfaW5mby0+YWN0aXZlX3NndHMtPnNndCwKKwlkbWFfYnVmX3Vu bWFwX2F0dGFjaG1lbnQoZXhwb3J0ZWQtPmFjdGl2ZV9hdHRhY2hlZC0+YXR0YWNoLAorCQkJCSBl eHBvcnRlZC0+YWN0aXZlX3NndHMtPnNndCwKIAkJCQkgRE1BX0JJRElSRUNUSU9OQUwpOwogCiAJ LyogZGV0YXRjaCBkbWEtYnVmICovCi0JZG1hX2J1Zl9kZXRhY2goc2d0X2luZm8tPmRtYV9idWYs IHNndF9pbmZvLT5hY3RpdmVfYXR0YWNoZWQtPmF0dGFjaCk7CisJZG1hX2J1Zl9kZXRhY2goZXhw b3J0ZWQtPmRtYV9idWYsIGV4cG9ydGVkLT5hY3RpdmVfYXR0YWNoZWQtPmF0dGFjaCk7CiAKIAkv KiBjbG9zZSBjb25uZWN0aW9uIHRvIGRtYS1idWYgY29tcGxldGVseSAqLwotCWRtYV9idWZfcHV0 KHNndF9pbmZvLT5kbWFfYnVmKTsKLQlzZ3RfaW5mby0+ZG1hX2J1ZiA9IE5VTEw7Ci0KLQlrZnJl ZShzZ3RfaW5mby0+YWN0aXZlX3NndHMpOwotCWtmcmVlKHNndF9pbmZvLT5hY3RpdmVfYXR0YWNo ZWQpOwotCWtmcmVlKHNndF9pbmZvLT52YV9rbWFwcGVkKTsKLQlrZnJlZShzZ3RfaW5mby0+dmFf dm1hcHBlZCk7Ci0Ja2ZyZWUoc2d0X2luZm8tPnByaXYpOworCWRtYV9idWZfcHV0KGV4cG9ydGVk LT5kbWFfYnVmKTsKKwlleHBvcnRlZC0+ZG1hX2J1ZiA9IE5VTEw7CisKKwlrZnJlZShleHBvcnRl ZC0+YWN0aXZlX3NndHMpOworCWtmcmVlKGV4cG9ydGVkLT5hY3RpdmVfYXR0YWNoZWQpOworCWtm cmVlKGV4cG9ydGVkLT52YV9rbWFwcGVkKTsKKwlrZnJlZShleHBvcnRlZC0+dmFfdm1hcHBlZCk7 CisJa2ZyZWUoZXhwb3J0ZWQtPnByaXYpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9k cml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3NnbF9wcm9jLmggYi9kcml2ZXJz L3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3NnbF9wcm9jLmgKaW5kZXggMjM3Y2NmNS4u OTMwYmFkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1 Zl9zZ2xfcHJvYy5oCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZf c2dsX3Byb2MuaApAQCAtMjgsMTMgKzI4LDE1IEBACiBpbnQgZG1hYnVmX3JlZmNvdW50KHN0cnVj dCBkbWFfYnVmICpkbWFfYnVmKTsKIAogLyogZXh0cmFjdCBwYWdlcyBkaXJlY3RseSBmcm9tIHN0 cnVjdCBzZ190YWJsZSAqLwotc3RydWN0IGh5cGVyX2RtYWJ1Zl9wYWdlc19pbmZvICpoeXBlcl9k bWFidWZfZXh0X3BncyhzdHJ1Y3Qgc2dfdGFibGUgKnNndCk7CitzdHJ1Y3QgcGFnZXNfaW5mbyAq aHlwZXJfZG1hYnVmX2V4dF9wZ3Moc3RydWN0IHNnX3RhYmxlICpzZ3QpOwogCiAvKiBjcmVhdGUg c2dfdGFibGUgd2l0aCBnaXZlbiBwYWdlcyBhbmQgb3RoZXIgcGFyYW1ldGVycyAqLwotc3RydWN0 IHNnX3RhYmxlKiBoeXBlcl9kbWFidWZfY3JlYXRlX3NndChzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgZnJzdF9vZnN0LCBpbnQgbGFzdF9s ZW4sIGludCBuZW50cyk7CitzdHJ1Y3Qgc2dfdGFibGUqIGh5cGVyX2RtYWJ1Zl9jcmVhdGVfc2d0 KHN0cnVjdCBwYWdlICoqcGdzLAorCQkJCQkgaW50IGZyc3Rfb2ZzdCwgaW50IGxhc3RfbGVuLAor CQkJCQkgaW50IG5lbnRzKTsKIAotaW50IGh5cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKHN0 cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gKnNndF9pbmZvLCBpbnQgZm9yY2UpOworaW50IGh5 cGVyX2RtYWJ1Zl9jbGVhbnVwX3NndF9pbmZvKHN0cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyAqZXhw b3J0ZWQsCisJCQkJICBpbnQgZm9yY2UpOwogCiB2b2lkIGh5cGVyX2RtYWJ1Zl9mcmVlX3NndChz dHJ1Y3Qgc2dfdGFibGUgKnNndCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2Rt YWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlw ZXJfZG1hYnVmX3N0cnVjdC5oCmluZGV4IDZmOTI5ZjIuLjhhNjEyZDEgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmgKKysrIGIvZHJpdmVy cy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaApAQCAtNTAsMjQgKzUwLDIw IEBAIHN0cnVjdCB2bWFwX3ZhZGRyX2xpc3QgewogfTsKIAogLyogRXhwb3J0ZXIgYnVpbGRzIHBh Z2VzX2luZm8gYmVmb3JlIHNoYXJpbmcgcGFnZXMgKi8KLXN0cnVjdCBoeXBlcl9kbWFidWZfcGFn ZXNfaW5mbyB7CitzdHJ1Y3QgcGFnZXNfaW5mbyB7CiAgICAgICAgIGludCBmcnN0X29mc3Q7IC8q IG9mZnNldCBvZiBkYXRhIGluIHRoZSBmaXJzdCBwYWdlICovCiAgICAgICAgIGludCBsYXN0X2xl bjsgLyogbGVuZ3RoIG9mIGRhdGEgaW4gdGhlIGxhc3QgcGFnZSAqLwogICAgICAgICBpbnQgbmVu dHM7IC8qICMgb2YgcGFnZXMgKi8KLSAgICAgICAgc3RydWN0IHBhZ2UgKipwYWdlczsgLyogcGFn ZXMgdGhhdCBjb250YWlucyByZWZlcmVuY2UgbnVtYmVycyBvZiBzaGFyZWQgcGFnZXMqLworICAg ICAgICBzdHJ1Y3QgcGFnZSAqKnBnczsgLyogcGFnZXMgdGhhdCBjb250YWlucyByZWZlcmVuY2Ug bnVtYmVycyBvZiBzaGFyZWQgcGFnZXMqLwogfTsKIAogCi0vKiBCb3RoIGltcG9ydGVyIGFuZCBl eHBvcnRlciB1c2UgdGhpcyBzdHJ1Y3R1cmUgdG8gcG9pbnQgdG8gc2cgbGlzdHMKLSAqCi0gKiBF eHBvcnRlciBzdG9yZXMgcmVmZXJlbmNlcyB0byBzZ3QgaW4gYSBoYXNoIHRhYmxlCisvKiBFeHBv cnRlciBzdG9yZXMgcmVmZXJlbmNlcyB0byBzZ3QgaW4gYSBoYXNoIHRhYmxlCiAgKiBFeHBvcnRl ciBrZWVwcyB0aGVzZSByZWZlcmVuY2VzIGZvciBzeW5jaHJvbml6YXRpb24gYW5kIHRyYWNraW5n IHB1cnBvc2VzCi0gKgotICogSW1wb3J0ZXIgdXNlIHRoaXMgc3RydWN0dXJlIGV4cG9ydGluZyB0 byBvdGhlciBkcml2ZXJzIGluIHRoZSBzYW1lIGRvbWFpbgogICovCi1zdHJ1Y3QgaHlwZXJfZG1h YnVmX3NndF9pbmZvIHsKK3N0cnVjdCBleHBvcnRlZF9zZ3RfaW5mbyB7CiAgICAgICAgIGh5cGVy X2RtYWJ1Zl9pZF90IGhpZDsgLyogdW5pcXVlIGlkIHRvIHJlZmVyZW5jZSBkbWFidWYgaW4gcmVt b3RlIGRvbWFpbiAqLwotCWludCBoeXBlcl9kbWFidWZfcmRvbWFpbjsgLyogZG9tYWluIGltcG9y dGluZyB0aGlzIHNndCAqLworCWludCByZG9taWQ7IC8qIGRvbWFpbiBpbXBvcnRpbmcgdGhpcyBz Z3QgKi8KIAogCXN0cnVjdCBkbWFfYnVmICpkbWFfYnVmOyAvKiBuZWVkZWQgdG8gc3RvcmUgdGhp cyBmb3IgZnJlZWluZyBpdCBsYXRlciAqLwogCWludCBuZW50czsKQEAgLTc5LDEwICs3NSwxMCBA QCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvIHsKIAlzdHJ1Y3Qgdm1hcF92YWRkcl9saXN0 ICp2YV92bWFwcGVkOwogCiAJYm9vbCB2YWxpZDsgLyogc2V0IHRvIDAgb25jZSB1bmV4cG9ydGVk LiBOZWVkZWQgdG8gcHJldmVudCBmdXJ0aGVyIG1hcHBpbmcgYnkgaW1wb3J0ZXIgKi8KLQlpbnQg aW1wb3J0ZXJfZXhwb3J0ZWQ7IC8qIGV4cG9ydGVkIGxvY2FsbHkgb24gaW1wb3J0ZXIncyBzaWRl ICovCisJaW50IGFjdGl2ZTsgLyogbG9jYWxseSBzaGFyZWQgb24gaW1wb3J0ZXIncyBzaWRlICov CiAJdm9pZCAqcmVmc19pbmZvOyAvKiBoeXBlcnZpc29yLXNwZWNpZmljIGluZm8gZm9yIHRoZSBy ZWZlcmVuY2VzICovCi0Jc3RydWN0IGRlbGF5ZWRfd29yayB1bmV4cG9ydF93b3JrOwotCWJvb2wg dW5leHBvcnRfc2NoZWR1bGVkOworCXN0cnVjdCBkZWxheWVkX3dvcmsgdW5leHBvcnQ7CisJYm9v bCB1bmV4cG9ydF9zY2hlZDsKIAogCS8qIG93bmVyIG9mIGJ1ZmZlcgogCSAqIFRPRE86IHRoYXQg aXMgbmFpaXZlIGFzIGJ1ZmZlciBtYXkgYmUgcmV1c2VkIGJ5CkBAIC05OSw3ICs5NSw3IEBAIHN0 cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gewogLyogSW1wb3J0ZXIgc3RvcmUgcmVmZXJlbmNl cyAoYmVmb3JlIG1hcHBpbmcpIG9uIHNoYXJlZCBwYWdlcwogICogSW1wb3J0ZXIgc3RvcmUgdGhl c2UgcmVmZXJlbmNlcyBpbiB0aGUgdGFibGUgYW5kIG1hcCBpdCBpbgogICogaXRzIG93biBtZW1v cnkgbWFwIG9uY2UgdXNlcnNwYWNlIGFza3MgZm9yIHJlZmVyZW5jZSBmb3IgdGhlIGJ1ZmZlciAq Lwotc3RydWN0IGh5cGVyX2RtYWJ1Zl9pbXBvcnRlZF9zZ3RfaW5mbyB7CitzdHJ1Y3QgaW1wb3J0 ZWRfc2d0X2luZm8gewogCWh5cGVyX2RtYWJ1Zl9pZF90IGhpZDsgLyogdW5pcXVlIGlkIGZvciBz aGFyZWQgZG1hYnVmIGltcG9ydGVkICovCiAKIAlpbnQgcmVmX2hhbmRsZTsgLyogcmVmZXJlbmNl IG51bWJlciBvZiB0b3AgbGV2ZWwgYWRkcmVzc2luZyBwYWdlIG9mIHNoYXJlZCBwYWdlcyAqLwpA QCAtMTEyLDcgKzEwOCw3IEBAIHN0cnVjdCBoeXBlcl9kbWFidWZfaW1wb3J0ZWRfc2d0X2luZm8g ewogCiAJdm9pZCAqcmVmc19pbmZvOwogCWJvb2wgdmFsaWQ7Ci0JaW50IG51bV9pbXBvcnRlcnM7 CisJaW50IGltcG9ydGVyczsKIAogCXNpemVfdCBzel9wcml2OwogCWNoYXIgKnByaXY7IC8qIGRl dmljZSBzcGVjaWZpYyBpbmZvIChlLmcuIGltYWdlJ3MgbWV0YSBpbmZvPykgKi8KZGlmZiAtLWdp dCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMg Yi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbS5jCmlu ZGV4IDkyMGVjZjQuLmY3MGI0ZWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9jb21tLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL3hlbi9oeXBlcl9kbWFidWZfeGVuX2NvbW0uYwpAQCAtNDUsOCArNDUsNiBAQCBzdGF0aWMg aW50IGV4cG9ydF9yZXFfaWQgPSAwOwogCiBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JlcSByZXFfcGVu ZGluZyA9IHswfTsKIAotZXh0ZXJuIHN0cnVjdCBoeXBlcl9kbWFidWZfcHJpdmF0ZSBoeXBlcl9k bWFidWZfcHJpdmF0ZTsKLQogZXh0ZXJuIGludCB4ZW5zdG9yZWRfcmVhZHk7CiAKIHN0YXRpYyB2 b2lkIHhlbl9nZXRfZG9taWRfZGVsYXllZChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKnVudXNlZCk7CkBA IC02Miw3ICs2MCw5IEBAIHN0YXRpYyBpbnQgeGVuX2NvbW1fc2V0dXBfZGF0YV9kaXIodm9pZCkK IHsKIAljaGFyIGJ1ZlsyNTVdOwogCi0Jc3ByaW50ZihidWYsICIvbG9jYWwvZG9tYWluLyVkL2Rh dGEvaHlwZXJfZG1hYnVmIiwgaHlwZXJfZG1hYnVmX3ByaXZhdGUuZG9taWQpOworCXNwcmludGYo YnVmLCAiL2xvY2FsL2RvbWFpbi8lZC9kYXRhL2h5cGVyX2RtYWJ1ZiIsCisJCWh5X2Rydl9wcml2 LT5kb21pZCk7CisKIAlyZXR1cm4geGVuYnVzX21rZGlyKFhCVF9OSUwsIGJ1ZiwgIiIpOwogfQog CkBAIC03Niw3ICs3Niw5IEBAIHN0YXRpYyBpbnQgeGVuX2NvbW1fZGVzdHJveV9kYXRhX2Rpcih2 b2lkKQogewogCWNoYXIgYnVmWzI1NV07CiAKLQlzcHJpbnRmKGJ1ZiwgIi9sb2NhbC9kb21haW4v JWQvZGF0YS9oeXBlcl9kbWFidWYiLCBoeXBlcl9kbWFidWZfcHJpdmF0ZS5kb21pZCk7CisJc3By aW50ZihidWYsICIvbG9jYWwvZG9tYWluLyVkL2RhdGEvaHlwZXJfZG1hYnVmIiwKKwkJaHlfZHJ2 X3ByaXYtPmRvbWlkKTsKKwogCXJldHVybiB4ZW5idXNfcm0oWEJUX05JTCwgYnVmLCAiIik7CiB9 CiAKQEAgLTkxLDIwICs5MywyNiBAQCBzdGF0aWMgaW50IHhlbl9jb21tX2V4cG9zZV9yaW5nX2Rl dGFpbHMoaW50IGRvbWlkLCBpbnQgcmRvbWlkLAogCWNoYXIgYnVmWzI1NV07CiAJaW50IHJldDsK IAotCXNwcmludGYoYnVmLCAiL2xvY2FsL2RvbWFpbi8lZC9kYXRhL2h5cGVyX2RtYWJ1Zi8lZCIs IGRvbWlkLCByZG9taWQpOworCXNwcmludGYoYnVmLCAiL2xvY2FsL2RvbWFpbi8lZC9kYXRhL2h5 cGVyX2RtYWJ1Zi8lZCIsCisJCWRvbWlkLCByZG9taWQpOworCiAJcmV0ID0geGVuYnVzX3ByaW50 ZihYQlRfTklMLCBidWYsICJncmVmaWQiLCAiJWQiLCBncmVmKTsKIAogCWlmIChyZXQpIHsKLQkJ ZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkiRmFpbGVkIHRvIHdyaXRl IHhlbmJ1cyBlbnRyeSAlczogJWRcbiIsIGJ1ZiwgcmV0KTsKKwkJZGV2X2VycihoeV9kcnZfcHJp di0+ZGV2LAorCQkJIkZhaWxlZCB0byB3cml0ZSB4ZW5idXMgZW50cnkgJXM6ICVkXG4iLAorCQkJ YnVmLCByZXQpOworCiAJCXJldHVybiByZXQ7CiAJfQogCiAJcmV0ID0geGVuYnVzX3ByaW50ZihY QlRfTklMLCBidWYsICJwb3J0IiwgIiVkIiwgcG9ydCk7CiAKIAlpZiAocmV0KSB7Ci0JCWRldl9l cnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJIkZhaWxlZCB0byB3cml0ZSB4ZW5i dXMgZW50cnkgJXM6ICVkXG4iLCBidWYsIHJldCk7CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRl diwKKwkJCSJGYWlsZWQgdG8gd3JpdGUgeGVuYnVzIGVudHJ5ICVzOiAlZFxuIiwKKwkJCWJ1Ziwg cmV0KTsKKwogCQlyZXR1cm4gcmV0OwogCX0KIApAQCAtMTE0LDI1ICsxMjIsMzIgQEAgc3RhdGlj IGludCB4ZW5fY29tbV9leHBvc2VfcmluZ19kZXRhaWxzKGludCBkb21pZCwgaW50IHJkb21pZCwK IC8qCiAgKiBRdWVyaWVzIGRldGFpbHMgb2YgcmluZyBleHBvc2VkIGJ5IHJlbW90ZSBkb21haW4u CiAgKi8KLXN0YXRpYyBpbnQgeGVuX2NvbW1fZ2V0X3JpbmdfZGV0YWlscyhpbnQgZG9taWQsIGlu dCByZG9taWQsIGludCAqZ3JlZmlkLCBpbnQgKnBvcnQpCitzdGF0aWMgaW50IHhlbl9jb21tX2dl dF9yaW5nX2RldGFpbHMoaW50IGRvbWlkLCBpbnQgcmRvbWlkLAorCQkJCSAgICAgaW50ICpncmVm aWQsIGludCAqcG9ydCkKIHsKIAljaGFyIGJ1ZlsyNTVdOwogCWludCByZXQ7CiAKLQlzcHJpbnRm KGJ1ZiwgIi9sb2NhbC9kb21haW4vJWQvZGF0YS9oeXBlcl9kbWFidWYvJWQiLCByZG9taWQsIGRv bWlkKTsKKwlzcHJpbnRmKGJ1ZiwgIi9sb2NhbC9kb21haW4vJWQvZGF0YS9oeXBlcl9kbWFidWYv JWQiLAorCQlyZG9taWQsIGRvbWlkKTsKKwogCXJldCA9IHhlbmJ1c19zY2FuZihYQlRfTklMLCBi dWYsICJncmVmaWQiLCAiJWQiLCBncmVmaWQpOwogCiAJaWYgKHJldCA8PSAwKSB7Ci0JCWRldl9l cnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJIkZhaWxlZCB0byByZWFkIHhlbmJ1 cyBlbnRyeSAlczogJWRcbiIsIGJ1ZiwgcmV0KTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2 LAorCQkJIkZhaWxlZCB0byByZWFkIHhlbmJ1cyBlbnRyeSAlczogJWRcbiIsCisJCQlidWYsIHJl dCk7CisKIAkJcmV0dXJuIHJldDsKIAl9CiAKIAlyZXQgPSB4ZW5idXNfc2NhbmYoWEJUX05JTCwg YnVmLCAicG9ydCIsICIlZCIsIHBvcnQpOwogCiAJaWYgKHJldCA8PSAwKSB7Ci0JCWRldl9lcnIo aHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJIkZhaWxlZCB0byByZWFkIHhlbmJ1cyBl bnRyeSAlczogJWRcbiIsIGJ1ZiwgcmV0KTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAor CQkJIkZhaWxlZCB0byByZWFkIHhlbmJ1cyBlbnRyeSAlczogJWRcbiIsCisJCQlidWYsIHJldCk7 CisKIAkJcmV0dXJuIHJldDsKIAl9CiAKQEAgLTE0Niw5ICsxNjEsOCBAQCB2b2lkIHhlbl9nZXRf ZG9taWRfZGVsYXllZChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKnVudXNlZCkKIAogCS8qIHNjaGVkdWxp bmcgYW5vdGhlciBpZiBkcml2ZXIgaXMgc3RpbGwgcnVubmluZwogCSAqIGFuZCB4ZW5zdG9yZSBo YXMgbm90IGJlZW4gaW5pdGlhbGl6ZWQgKi8KLQlpZiAoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZXhp dGVkID09IGZhbHNlICYmCi0JICAgIGxpa2VseSh4ZW5zdG9yZWRfcmVhZHkgPT0gMCkpIHsKLQkJ ZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJaWYgKGxpa2VseSh4ZW5zdG9y ZWRfcmVhZHkgPT0gMCkpIHsKKwkJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LAogCQkJIlhlbnN0 b3JlIGlzIG5vdCBxdWl0ZSByZWFkeSB5ZXQuIFdpbGwgcmV0cnkgaXQgaW4gNTAwbXNcbiIpOwog CQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmdldF92bV9pZF93b3JrLCBtc2Vjc190b19qaWZmaWVz KDUwMCkpOwogCX0gZWxzZSB7CkBAIC0xNjMsMTQgKzE3NywxNCBAQCB2b2lkIHhlbl9nZXRfZG9t aWRfZGVsYXllZChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKnVudXNlZCkKIAogCQkvKiB0cnkgYWdhaW4g c2luY2UgLTEgaXMgYW4gaW52YWxpZCBpZCBmb3IgZG9tYWluCiAJCSAqIChidXQgb25seSBpZiBk cml2ZXIgaXMgc3RpbGwgcnVubmluZykgKi8KLQkJaWYgKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV4 aXRlZCA9PSBmYWxzZSAmJiB1bmxpa2VseShkb21pZCA9PSAtMSkpIHsKLQkJCWRldl9kYmcoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlpZiAodW5saWtlbHkoZG9taWQgPT0gLTEpKSB7 CisJCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkJImRvbWlkPT0tMSBpcyBpbnZhbGlk LiBXaWxsIHJldHJ5IGl0IGluIDUwMG1zXG4iKTsKIAkJCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygm Z2V0X3ZtX2lkX3dvcmssIG1zZWNzX3RvX2ppZmZpZXMoNTAwKSk7CiAJCX0gZWxzZSB7Ci0JCQlk ZXZfaW5mbyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCQlkZXZfaW5mbyhoeV9kcnZf cHJpdi0+ZGV2LAogCQkJCSJTdWNjZXNzZnVsbHkgcmV0cmlldmVkIGRvbWlkIGZyb20gWGVuc3Rv cmU6JWRcbiIsIGRvbWlkKTsKLQkJCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRvbWlkID0gZG9taWQ7 CisJCQloeV9kcnZfcHJpdi0+ZG9taWQgPSBkb21pZDsKIAkJfQogCX0KIH0KQEAgLTIzMiwyOCAr MjQ2LDMwIEBAIHN0YXRpYyB2b2lkIHJlbW90ZV9kb21fZXhwb3J0ZXJfd2F0Y2hfY2Ioc3RydWN0 IHhlbmJ1c193YXRjaCAqd2F0Y2gsCiAJCXJldHVybjsKIAl9CiAKLQkvKiBDaGVjayBpZiB3ZSBo YXZlIGltcG9ydGVyIHJpbmcgZm9yIGdpdmVuIHJlbW90ZSBkb21haW4gYWxyYWR5IGNyZWF0ZWQg Ki8KKwkvKiBDaGVjayBpZiB3ZSBoYXZlIGltcG9ydGVyIHJpbmcgZm9yIGdpdmVuIHJlbW90ZSBk b21haW4gYWxyZWFkeQorCSAqIGNyZWF0ZWQgKi8KKwogCXJpbmdfaW5mbyA9IHhlbl9jb21tX2Zp bmRfcnhfcmluZyhyZG9tKTsKIAotCS8qIFRyeSB0byBxdWVyeSByZW1vdGUgZG9tYWluIGV4cG9y dGVyIHJpbmcgZGV0YWlscyAtIGlmIHRoYXQgd2lsbAotCSAqIGZhaWwgYW5kIHdlIGhhdmUgaW1w b3J0ZXIgcmluZyB0aGF0IG1lYW5zIHJlbW90ZSBkb21haW5zIGhhcyBjbGVhbnVwCi0JICogaXRz IGV4cG9ydGVyIHJpbmcsIHNvIG91ciBpbXBvcnRlciByaW5nIGlzIG5vIGxvbmdlciB1c2VmdWwu CisJLyogVHJ5IHRvIHF1ZXJ5IHJlbW90ZSBkb21haW4gZXhwb3J0ZXIgcmluZyBkZXRhaWxzIC0g aWYKKwkgKiB0aGF0IHdpbGwgZmFpbCBhbmQgd2UgaGF2ZSBpbXBvcnRlciByaW5nIHRoYXQgbWVh bnMgcmVtb3RlCisJICogZG9tYWlucyBoYXMgY2xlYW51cCBpdHMgZXhwb3J0ZXIgcmluZywgc28g b3VyIGltcG9ydGVyIHJpbmcKKwkgKiBpcyBubyBsb25nZXIgdXNlZnVsLgogCSAqCiAJICogSWYg cXVlcnlpbmcgZGV0YWlscyB3aWxsIHN1Y2NlZWQgYW5kIHdlIGRvbid0IGhhdmUgaW1wb3J0ZXIg cmluZywKLQkgKiBpdCBtZWFucyB0aGF0IHJlbW90ZSBkb21haW4gaGFzIHNldHVwIGl0IGZvciB1 cyBhbmQgd2Ugc2hvdWxkIGNvbm5lY3QKLQkgKiB0byBpdC4KKwkgKiBpdCBtZWFucyB0aGF0IHJl bW90ZSBkb21haW4gaGFzIHNldHVwIGl0IGZvciB1cyBhbmQgd2Ugc2hvdWxkCisJICogY29ubmVj dCB0byBpdC4KIAkgKi8KIAotCi0JcmV0ID0geGVuX2NvbW1fZ2V0X3JpbmdfZGV0YWlscyhoeXBl cl9kbWFidWZfeGVuX2dldF9kb21pZCgpLCByZG9tLAotCQkJCQkmZ3JlZmlkLCAmcG9ydCk7CisJ cmV0ID0geGVuX2NvbW1fZ2V0X3JpbmdfZGV0YWlscyhoeXBlcl9kbWFidWZfeGVuX2dldF9kb21p ZCgpLAorCQkJCQlyZG9tLCAmZ3JlZmlkLCAmcG9ydCk7CiAKIAlpZiAocmluZ19pbmZvICYmIHJl dCAhPSAwKSB7Ci0JCWRldl9pbmZvKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJZGV2 X2luZm8oaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSAiUmVtb3RlIGV4cG9ydGVyIGNsb3NlZCwgY2xl YW5pbnVwIGltcG9ydGVyXG4iKTsKIAkJaHlwZXJfZG1hYnVmX3hlbl9jbGVhbnVwX3J4X3JidWYo cmRvbSk7CiAJfSBlbHNlIGlmICghcmluZ19pbmZvICYmIHJldCA9PSAwKSB7Ci0JCWRldl9pbmZv KGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJZGV2X2luZm8oaHlfZHJ2X3ByaXYtPmRl diwKIAkJCSAiUmVnaXN0ZXJpbmcgaW1wb3J0ZXJcbiIpOwogCQloeXBlcl9kbWFidWZfeGVuX2lu aXRfcnhfcmJ1ZihyZG9tKTsKIAl9CkBAIC0yNzQsNyArMjkwLDcgQEAgaW50IGh5cGVyX2RtYWJ1 Zl94ZW5faW5pdF90eF9yYnVmKGludCBkb21pZCkKIAlyaW5nX2luZm8gPSB4ZW5fY29tbV9maW5k X3R4X3JpbmcoZG9taWQpOwogCiAJaWYgKHJpbmdfaW5mbykgewotCQlkZXZfaW5mbyhoeXBlcl9k bWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCWRldl9pbmZvKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkg InR4IHJpbmcgY2ggdG8gZG9taWQgPSAlZCBhbHJlYWR5IGV4aXN0XG5ncmVmID0gJWQsIHBvcnQg PSAlZFxuIiwKIAkJcmluZ19pbmZvLT5yZG9tYWluLCByaW5nX2luZm8tPmdyZWZfcmluZywgcmlu Z19pbmZvLT5wb3J0KTsKIAkJcmV0dXJuIDA7CkBAIC0yODMsNyArMjk5LDcgQEAgaW50IGh5cGVy X2RtYWJ1Zl94ZW5faW5pdF90eF9yYnVmKGludCBkb21pZCkKIAlyaW5nX2luZm8gPSBrbWFsbG9j KHNpemVvZigqcmluZ19pbmZvKSwgR0ZQX0tFUk5FTCk7CiAKIAlpZiAoIXJpbmdfaW5mbykgewot CQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJZGV2X2VycihoeV9kcnZf cHJpdi0+ZGV2LAogCQkJIk5vIG1vcmUgc3BhZSBsZWZ0XG4iKTsKIAkJcmV0dXJuIC1FTk9NRU07 CiAJfQpAQCAtMzEzLDkgKzMyOSw5IEBAIGludCBoeXBlcl9kbWFidWZfeGVuX2luaXRfdHhfcmJ1 ZihpbnQgZG9taWQpCiAJYWxsb2NfdW5ib3VuZC5kb20gPSBET01JRF9TRUxGOwogCWFsbG9jX3Vu Ym91bmQucmVtb3RlX2RvbSA9IGRvbWlkOwogCXJldCA9IEhZUEVSVklTT1JfZXZlbnRfY2hhbm5l bF9vcChFVlRDSE5PUF9hbGxvY191bmJvdW5kLAotCQkJCQkmYWxsb2NfdW5ib3VuZCk7CisJCQkJ CSAgJmFsbG9jX3VuYm91bmQpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZf cHJpdmF0ZS5kZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCSJDYW5ub3Qg YWxsb2NhdGUgZXZlbnQgY2hhbm5lbFxuIik7CiAJCWtmcmVlKHJpbmdfaW5mbyk7CiAJCXJldHVy biAtRUlPOwpAQCAtMzI3LDcgKzM0Myw3IEBAIGludCBoeXBlcl9kbWFidWZfeGVuX2luaXRfdHhf cmJ1ZihpbnQgZG9taWQpCiAJCQkJCU5VTEwsICh2b2lkKikgcmluZ19pbmZvKTsKIAogCWlmIChy ZXQgPCAwKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlkZXZf ZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiRmFpbGVkIHRvIHNldHVwIGV2ZW50IGNoYW5uZWxc biIpOwogCQljbG9zZS5wb3J0ID0gYWxsb2NfdW5ib3VuZC5wb3J0OwogCQlIWVBFUlZJU09SX2V2 ZW50X2NoYW5uZWxfb3AoRVZUQ0hOT1BfY2xvc2UsICZjbG9zZSk7CkBAIC0zNDMsNyArMzU5LDcg QEAgaW50IGh5cGVyX2RtYWJ1Zl94ZW5faW5pdF90eF9yYnVmKGludCBkb21pZCkKIAogCW11dGV4 X2luaXQoJnJpbmdfaW5mby0+bG9jayk7CiAKLQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRl LmRldmljZSwKKwlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCSIlczogYWxsb2NhdGVkIGV2 ZW50Y2hhbm5lbCBncmVmICVkICBwb3J0OiAlZCAgaXJxOiAlZFxuIiwKIAkJX19mdW5jX18sCiAJ CXJpbmdfaW5mby0+Z3JlZl9yaW5nLApAQCAtMzY0LDcgKzM4MCw3IEBAIGludCBoeXBlcl9kbWFi dWZfeGVuX2luaXRfdHhfcmJ1ZihpbnQgZG9taWQpCiAJcmluZ19pbmZvLT53YXRjaC5ub2RlID0g KGNvbnN0IGNoYXIqKSBrbWFsbG9jKHNpemVvZihjaGFyKSAqIDI1NSwgR0ZQX0tFUk5FTCk7CiAK IAlpZiAoIXJpbmdfaW5mby0+d2F0Y2gubm9kZSkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9w cml2YXRlLmRldmljZSwKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJIk5vIG1vcmUg c3BhY2UgbGVmdFxuIik7CiAJCWtmcmVlKHJpbmdfaW5mbyk7CiAJCXJldHVybiAtRU5PTUVNOwpA QCAtNDE0LDcgKzQzMCw4IEBAIHZvaWQgaHlwZXJfZG1hYnVmX3hlbl9jbGVhbnVwX3R4X3JidWYo aW50IGRvbWlkKQogCWlmICghcnhfcmluZ19pbmZvKQogCQlyZXR1cm47CiAKLQlCQUNLX1JJTkdf SU5JVCgmKHJ4X3JpbmdfaW5mby0+cmluZ19iYWNrKSwgcnhfcmluZ19pbmZvLT5yaW5nX2JhY2su c3JpbmcsIFBBR0VfU0laRSk7CisJQkFDS19SSU5HX0lOSVQoJihyeF9yaW5nX2luZm8tPnJpbmdf YmFjayksIHJ4X3JpbmdfaW5mby0+cmluZ19iYWNrLnNyaW5nLAorCQkgICAgICAgUEFHRV9TSVpF KTsKIH0KIAogLyogaW1wb3J0ZXIgbmVlZHMgdG8ga25vdyBhYm91dCBzaGFyZWQgcGFnZSBhbmQg cG9ydCBudW1iZXJzIGZvcgpAQCAtNDM2LDI1ICs0NTMsMjggQEAgaW50IGh5cGVyX2RtYWJ1Zl94 ZW5faW5pdF9yeF9yYnVmKGludCBkb21pZCkKIAlyaW5nX2luZm8gPSB4ZW5fY29tbV9maW5kX3J4 X3JpbmcoZG9taWQpOwogCiAJaWYgKHJpbmdfaW5mbykgewotCQlkZXZfaW5mbyhoeXBlcl9kbWFi dWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkgInJ4IHJpbmcgY2ggZnJvbSBkb21pZCA9ICVkIGFscmVh ZHkgZXhpc3RcbiIsIHJpbmdfaW5mby0+c2RvbWFpbik7CisJCWRldl9pbmZvKGh5X2Rydl9wcml2 LT5kZXYsCisJCQkgInJ4IHJpbmcgY2ggZnJvbSBkb21pZCA9ICVkIGFscmVhZHkgZXhpc3RcbiIs CisJCQkgcmluZ19pbmZvLT5zZG9tYWluKTsKKwogCQlyZXR1cm4gMDsKIAl9CiAKLQogCXJldCA9 IHhlbl9jb21tX2dldF9yaW5nX2RldGFpbHMoaHlwZXJfZG1hYnVmX3hlbl9nZXRfZG9taWQoKSwg ZG9taWQsCiAJCQkJCSZyeF9ncmVmLCAmcnhfcG9ydCk7CiAKIAlpZiAocmV0KSB7Ci0JCWRldl9l cnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJIkRvbWFpbiAlZCBoYXMgbm90IGNy ZWF0ZWQgZXhwb3J0ZXIgcmluZyBmb3IgY3VycmVudCBkb21haW5cbiIsIGRvbWlkKTsKKwkJZGV2 X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJIkRvbWFpbiAlZCBoYXMgbm90IGNyZWF0ZWQgZXhw b3J0ZXIgcmluZyBmb3IgY3VycmVudCBkb21haW5cbiIsCisJCQlkb21pZCk7CisKIAkJcmV0dXJu IHJldDsKIAl9CiAKIAlyaW5nX2luZm8gPSBrbWFsbG9jKHNpemVvZigqcmluZ19pbmZvKSwgR0ZQ X0tFUk5FTCk7CiAKIAlpZiAoIXJpbmdfaW5mbykgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9w cml2YXRlLmRldmljZSwKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJIk5vIG1lbW9y eSBsZWZ0IHRvIGJlIGFsbG9jYXRlZFxuIik7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KQEAgLTQ2 NSw3ICs0ODUsNyBAQCBpbnQgaHlwZXJfZG1hYnVmX3hlbl9pbml0X3J4X3JidWYoaW50IGRvbWlk KQogCW1hcF9vcHMgPSBrbWFsbG9jKHNpemVvZigqbWFwX29wcyksIEdGUF9LRVJORUwpOwogCiAJ aWYgKCFtYXBfb3BzKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAor CQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiTm8gbWVtb3J5IGxlZnQgdG8gYmUgYWxs b2NhdGVkXG4iKTsKIAkJcmV0ID0gLUVOT01FTTsKIAkJZ290byBmYWlsX25vX21hcF9vcHM7CkBA IC00NzYsMjEgKzQ5NiwyMyBAQCBpbnQgaHlwZXJfZG1hYnVmX3hlbl9pbml0X3J4X3JidWYoaW50 IGRvbWlkKQogCQlnb3RvIGZhaWxfb3RoZXJzOwogCX0KIAotCWdudHRhYl9zZXRfbWFwX29wKCZt YXBfb3BzWzBdLCAodW5zaWduZWQgbG9uZylwZm5fdG9fa2FkZHIocGFnZV90b19wZm4oc2hhcmVk X3JpbmcpKSwKKwlnbnR0YWJfc2V0X21hcF9vcCgmbWFwX29wc1swXSwKKwkJCSAgKHVuc2lnbmVk IGxvbmcpcGZuX3RvX2thZGRyKHBhZ2VfdG9fcGZuKHNoYXJlZF9yaW5nKSksCiAJCQkgIEdOVE1B UF9ob3N0X21hcCwgcnhfZ3JlZiwgZG9taWQpOwogCi0JZ250dGFiX3NldF91bm1hcF9vcCgmcmlu Z19pbmZvLT51bm1hcF9vcCwgKHVuc2lnbmVkIGxvbmcpcGZuX3RvX2thZGRyKHBhZ2VfdG9fcGZu KHNoYXJlZF9yaW5nKSksCisJZ250dGFiX3NldF91bm1hcF9vcCgmcmluZ19pbmZvLT51bm1hcF9v cCwKKwkJCSAgICAodW5zaWduZWQgbG9uZylwZm5fdG9fa2FkZHIocGFnZV90b19wZm4oc2hhcmVk X3JpbmcpKSwKIAkJCSAgICBHTlRNQVBfaG9zdF9tYXAsIC0xKTsKIAogCXJldCA9IGdudHRhYl9t YXBfcmVmcyhtYXBfb3BzLCBOVUxMLCAmc2hhcmVkX3JpbmcsIDEpOwogCWlmIChyZXQgPCAwKSB7 Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiQ2Fubm90IG1hcCByaW5n XG4iKTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAiQ2Fubm90IG1hcCByaW5nXG4iKTsK IAkJcmV0ID0gLUVGQVVMVDsKIAkJZ290byBmYWlsX290aGVyczsKIAl9CiAKIAlpZiAobWFwX29w c1swXS5zdGF0dXMpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJS aW5nIG1hcHBpbmcgZmFpbGVkXG4iKTsKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LCAiUmlu ZyBtYXBwaW5nIGZhaWxlZFxuIik7CiAJCXJldCA9IC1FRkFVTFQ7CiAJCWdvdG8gZmFpbF9vdGhl cnM7CiAJfSBlbHNlIHsKQEAgLTUxMiw3ICs1MzQsNyBAQCBpbnQgaHlwZXJfZG1hYnVmX3hlbl9p bml0X3J4X3JidWYoaW50IGRvbWlkKQogCiAJcmluZ19pbmZvLT5pcnEgPSByZXQ7CiAKLQlkZXZf ZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwlkZXZfZGJnKGh5X2Rydl9wcml2LT5k ZXYsCiAJCSIlczogYm91bmQgdG8gZXZlbnRjaGFubmVsIHBvcnQ6ICVkICBpcnE6ICVkXG4iLCBf X2Z1bmNfXywKIAkJcnhfcG9ydCwKIAkJcmluZ19pbmZvLT5pcnEpOwpAQCAtNTY5LDcgKzU5MSw5 IEBAIHZvaWQgaHlwZXJfZG1hYnVmX3hlbl9jbGVhbnVwX3J4X3JidWYoaW50IGRvbWlkKQogCQly ZXR1cm47CiAKIAlTSEFSRURfUklOR19JTklUKHR4X3JpbmdfaW5mby0+cmluZ19mcm9udC5zcmlu Zyk7Ci0JRlJPTlRfUklOR19JTklUKCYodHhfcmluZ19pbmZvLT5yaW5nX2Zyb250KSwgdHhfcmlu Z19pbmZvLT5yaW5nX2Zyb250LnNyaW5nLCBQQUdFX1NJWkUpOworCUZST05UX1JJTkdfSU5JVCgm KHR4X3JpbmdfaW5mby0+cmluZ19mcm9udCksCisJCQl0eF9yaW5nX2luZm8tPnJpbmdfZnJvbnQu c3JpbmcsCisJCQlQQUdFX1NJWkUpOwogfQogCiAjaWZkZWYgQ09ORklHX0hZUEVSX0RNQUJVRl9Y RU5fQVVUT19SWF9DSF9BREQKQEAgLTU4NywyMCArNjExLDIwIEBAIHN0YXRpYyB2b2lkIHhlbl9y eF9jaF9hZGRfZGVsYXllZChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKnVudXNlZCkKIAljaGFyIGJ1Zlsx MjhdOwogCWludCBpLCBkdW1teTsKIAotCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2 aWNlLAorCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwKIAkJIlNjYW5uaW5nIG5ldyB0eCBjaGFu bmVsIGNvbW1pbmcgZnJvbSBhbm90aGVyIGRvbWFpblxuIik7CiAKIAkvKiBjaGVjayBvdGhlciBk b21haW5zIGFuZCBzY2hlZHVsZSBhbm90aGVyIHdvcmsgaWYgZHJpdmVyCiAJICogaXMgc3RpbGwg cnVubmluZyBhbmQgYmFja2VuZCBpcyB2YWxpZAogCSAqLwotCWlmIChoeXBlcl9kbWFidWZfcHJp dmF0ZS5leGl0ZWQgPT0gZmFsc2UgJiYKLQkgICAgaHlwZXJfZG1hYnVmX3ByaXZhdGUuYmFja2Vu ZF9pbml0aWFsaXplZCA9PSB0cnVlKSB7CisJaWYgKGh5X2Rydl9wcml2ICYmCisJICAgIGh5X2Ry dl9wcml2LT5pbml0aWFsaXplZCkgewogCQlmb3IgKGkgPSBET01JRF9TQ0FOX1NUQVJUOyBpIDwg RE9NSURfU0NBTl9FTkQgKyAxOyBpKyspIHsKLQkJCWlmIChpID09IGh5cGVyX2RtYWJ1Zl9wcml2 YXRlLmRvbWlkKQorCQkJaWYgKGkgPT0gaHlfZHJ2X3ByaXYtPmRvbWlkKQogCQkJCWNvbnRpbnVl OwogCi0JCQlzcHJpbnRmKGJ1ZiwgIi9sb2NhbC9kb21haW4vJWQvZGF0YS9oeXBlcl9kbWFidWYv JWQiLCBpLAotCQkJCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRvbWlkKTsKKwkJCXNwcmludGYoYnVm LCAiL2xvY2FsL2RvbWFpbi8lZC9kYXRhL2h5cGVyX2RtYWJ1Zi8lZCIsCisJCQkJaSwgaHlfZHJ2 X3ByaXYtPmRvbWlkKTsKIAogCQkJcmV0ID0geGVuYnVzX3NjYW5mKFhCVF9OSUwsIGJ1ZiwgInBv cnQiLCAiJWQiLCAmZHVtbXkpOwogCkBAIC02MTEsMTMgKzYzNSwxNCBAQCBzdGF0aWMgdm9pZCB4 ZW5fcnhfY2hfYWRkX2RlbGF5ZWQoc3RydWN0IHdvcmtfc3RydWN0ICp1bnVzZWQpCiAJCQkJcmV0 ID0gaHlwZXJfZG1hYnVmX3hlbl9pbml0X3J4X3JidWYoaSk7CiAKIAkJCQlpZiAoIXJldCkKLQkJ CQkJZGV2X2luZm8oaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJCQlkZXZfaW5mbyho eV9kcnZfcHJpdi0+ZGV2LAogCQkJCQkJICJGaW5pc2hpbmcgdXAgc2V0dGluZyB1cCByeCBjaGFu bmVsIGZvciBkb21haW4gJWRcbiIsIGkpOwogCQkJfQogCQl9CiAKIAkJLyogY2hlY2sgZXZlcnkg MTAgc2Vjb25kcyAqLwotCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnhlbl9yeF9jaF9hdXRvX2Fk ZF93b3JrLCBtc2Vjc190b19qaWZmaWVzKDEwMDAwKSk7CisJCXNjaGVkdWxlX2RlbGF5ZWRfd29y aygmeGVuX3J4X2NoX2F1dG9fYWRkX3dvcmssCisJCQkJICAgICAgbXNlY3NfdG9famlmZmllcygx MDAwMCkpOwogCX0KIH0KIApAQCAtNjMwLDIxICs2NTUsMjEgQEAgdm9pZCB4ZW5faW5pdF9jb21t X2Vudl9kZWxheWVkKHN0cnVjdCB3b3JrX3N0cnVjdCAqdW51c2VkKQogCS8qIHNjaGVkdWxpbmcg YW5vdGhlciB3b3JrIGlmIGRyaXZlciBpcyBzdGlsbCBydW5uaW5nCiAJICogYW5kIHhlbnN0b3Jl IGhhc24ndCBiZWVuIGluaXRpYWxpemVkIG9yIGRvbV9pZCBoYXNuJ3QKIAkgKiBiZWVuIGNvcnJl Y3RseSByZXRyaWV2ZWQuICovCi0JaWYgKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmV4aXRlZCA9PSBm YWxzZSAmJgotCSAgICBsaWtlbHkoeGVuc3RvcmVkX3JlYWR5ID09IDAgfHwKLQkgICAgaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZG9taWQgPT0gLTEpKSB7Ci0JCWRldl9kYmcoaHlwZXJfZG1hYnVmX3By aXZhdGUuZGV2aWNlLAotCQkJIlhlbnN0b3JlIGlzIG5vdCByZWFkeSB5ZXQuIFJlLXRyeSB0aGlz IGFnYWluIGluIDUwMG1zXG4iKTsKLQkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZ4ZW5faW5pdF9j b21tX2Vudl93b3JrLCBtc2Vjc190b19qaWZmaWVzKDUwMCkpOworCWlmIChsaWtlbHkoeGVuc3Rv cmVkX3JlYWR5ID09IDAgfHwKKwkgICAgaHlfZHJ2X3ByaXYtPmRvbWlkID09IC0xKSkgeworCQlk ZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCisJCQkiWGVuc3RvcmUgbm90IHJlYWR5IFdpbGwgcmUt dHJ5IGluIDUwMG1zXG4iKTsKKwkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZ4ZW5faW5pdF9jb21t X2Vudl93b3JrLAorCQkJCSAgICAgIG1zZWNzX3RvX2ppZmZpZXMoNTAwKSk7CiAJfSBlbHNlIHsK IAkJcmV0ID0geGVuX2NvbW1fc2V0dXBfZGF0YV9kaXIoKTsKIAkJaWYgKHJldCA8IDApIHsKLQkJ CWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJZGV2X2VycihoeV9kcnZf cHJpdi0+ZGV2LAogCQkJCSJGYWlsZWQgdG8gY3JlYXRlIGRhdGEgZGlyIGluIFhlbnN0b3JlXG4i KTsKIAkJfSBlbHNlIHsKLQkJCWRldl9pbmZvKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwK LQkJCQkiU3VjY2Vzc2Z1bGx5IGZpbmlzaGVkIGNvbW0gZW52IGluaXRpYWxpemF0aW9uXG4iKTsK LQkJCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLmJhY2tlbmRfaW5pdGlhbGl6ZWQgPSB0cnVlOworCQkJ ZGV2X2luZm8oaHlfZHJ2X3ByaXYtPmRldiwKKwkJCQkiU3VjY2Vzc2Z1bGx5IGZpbmlzaGVkIGNv bW0gZW52IGluaXRcbiIpOworCQkJaHlfZHJ2X3ByaXYtPmluaXRpYWxpemVkID0gdHJ1ZTsKIAog I2lmZGVmIENPTkZJR19IWVBFUl9ETUFCVUZfWEVOX0FVVE9fUlhfQ0hfQURECiAJCQl4ZW5fcnhf Y2hfYWRkX2RlbGF5ZWQoTlVMTCk7CkBAIC02NTksMjAgKzY4NCwyMSBAQCBpbnQgaHlwZXJfZG1h YnVmX3hlbl9pbml0X2NvbW1fZW52KHZvaWQpCiAKIAl4ZW5fY29tbV9yaW5nX3RhYmxlX2luaXQo KTsKIAotCWlmICh1bmxpa2VseSh4ZW5zdG9yZWRfcmVhZHkgPT0gMCB8fCBoeXBlcl9kbWFidWZf cHJpdmF0ZS5kb21pZCA9PSAtMSkpIHsKKwlpZiAodW5saWtlbHkoeGVuc3RvcmVkX3JlYWR5ID09 IDAgfHwKKwkgICAgaHlfZHJ2X3ByaXYtPmRvbWlkID09IC0xKSkgewogCQl4ZW5faW5pdF9jb21t X2Vudl9kZWxheWVkKE5VTEwpOwogCQlyZXR1cm4gLTE7CiAJfQogCiAJcmV0ID0geGVuX2NvbW1f c2V0dXBfZGF0YV9kaXIoKTsKIAlpZiAocmV0IDwgMCkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1 Zl9wcml2YXRlLmRldmljZSwKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJIkZhaWxl ZCB0byBjcmVhdGUgZGF0YSBkaXIgaW4gWGVuc3RvcmVcbiIpOwogCX0gZWxzZSB7Ci0JCWRldl9p bmZvKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJZGV2X2luZm8oaHlfZHJ2X3ByaXYt PmRldiwKIAkJCSJTdWNjZXNzZnVsbHkgZmluaXNoZWQgY29tbSBlbnYgaW5pdGlhbGl6YXRpb25c biIpOwogCi0JCWh5cGVyX2RtYWJ1Zl9wcml2YXRlLmJhY2tlbmRfaW5pdGlhbGl6ZWQgPSB0cnVl OworCQloeV9kcnZfcHJpdi0+aW5pdGlhbGl6ZWQgPSB0cnVlOwogCX0KIAogCXJldHVybiByZXQ7 CkBAIC02OTEsNyArNzE3LDggQEAgdm9pZCBoeXBlcl9kbWFidWZfeGVuX2Rlc3Ryb3lfY29tbSh2 b2lkKQogCXhlbl9jb21tX2Rlc3Ryb3lfZGF0YV9kaXIoKTsKIH0KIAotaW50IGh5cGVyX2RtYWJ1 Zl94ZW5fc2VuZF9yZXEoaW50IGRvbWlkLCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JlcSAqcmVxLCBp bnQgd2FpdCkKK2ludCBoeXBlcl9kbWFidWZfeGVuX3NlbmRfcmVxKGludCBkb21pZCwgc3RydWN0 IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcSwKKwkJCSAgICAgIGludCB3YWl0KQogewogCXN0cnVjdCB4 ZW5fY29tbV9mcm9udF9yaW5nICpyaW5nOwogCXN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpuZXdf cmVxOwpAQCAtNzA2LDIyICs3MzMsMjEgQEAgaW50IGh5cGVyX2RtYWJ1Zl94ZW5fc2VuZF9yZXEo aW50IGRvbWlkLCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JlcSAqcmVxLCBpbnQgd2FpdCkKIAkvKiBm aW5kIGEgcmluZyBpbmZvIGZvciB0aGUgY2hhbm5lbCAqLwogCXJpbmdfaW5mbyA9IHhlbl9jb21t X2ZpbmRfdHhfcmluZyhkb21pZCk7CiAJaWYgKCFyaW5nX2luZm8pIHsKLQkJZGV2X2VycihoeXBl cl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKIAkJ CSJDYW4ndCBmaW5kIHJpbmcgaW5mbyBmb3IgdGhlIGNoYW5uZWxcbiIpOwogCQlyZXR1cm4gLUVO T0VOVDsKIAl9CiAKLQltdXRleF9sb2NrKCZyaW5nX2luZm8tPmxvY2spOwogCiAJcmluZyA9ICZy aW5nX2luZm8tPnJpbmdfZnJvbnQ7CiAKIAlkb19nZXR0aW1lb2ZkYXkoJnR2X3N0YXJ0KTsKIAog CXdoaWxlIChSSU5HX0ZVTEwocmluZykpIHsKLQkJZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsICJSSU5HX0ZVTExcbiIpOworCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsICJS SU5HX0ZVTExcbiIpOwogCiAJCWlmICh0aW1lb3V0ID09IDApIHsKLQkJCWRldl9lcnIoaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJ CSJUaW1lb3V0IHdoaWxlIHdhaXRpbmcgZm9yIGFuIGVudHJ5IGluIHRoZSByaW5nXG4iKTsKIAkJ CXJldHVybiAtRUlPOwogCQl9CkBAIC03MzEsMTUgKzc1NywxNyBAQCBpbnQgaHlwZXJfZG1hYnVm X3hlbl9zZW5kX3JlcShpbnQgZG9taWQsIHN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpyZXEsIGlu dCB3YWl0KQogCiAJdGltZW91dCA9IDEwMDA7CiAKKwltdXRleF9sb2NrKCZyaW5nX2luZm8tPmxv Y2spOworCiAJbmV3X3JlcSA9IFJJTkdfR0VUX1JFUVVFU1QocmluZywgcmluZy0+cmVxX3Byb2Rf cHZ0KTsKIAlpZiAoIW5ld19yZXEpIHsKIAkJbXV0ZXhfdW5sb2NrKCZyaW5nX2luZm8tPmxvY2sp OwotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJZGV2X2VycihoeV9k cnZfcHJpdi0+ZGV2LAogCQkJIk5VTEwgUkVRVUVTVFxuIik7CiAJCXJldHVybiAtRUlPOwogCX0K IAotCXJlcS0+cmVxdWVzdF9pZCA9IHhlbl9jb21tX25leHRfcmVxX2lkKCk7CisJcmVxLT5yZXFf aWQgPSB4ZW5fY29tbV9uZXh0X3JlcV9pZCgpOwogCiAJLyogdXBkYXRlIHJlcV9wZW5kaW5nIHdp dGggY3VycmVudCByZXF1ZXN0ICovCiAJbWVtY3B5KCZyZXFfcGVuZGluZywgcmVxLCBzaXplb2Yo cmVxX3BlbmRpbmcpKTsKQEAgLTc1Niw3ICs3ODQsNyBAQCBpbnQgaHlwZXJfZG1hYnVmX3hlbl9z ZW5kX3JlcShpbnQgZG9taWQsIHN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpyZXEsIGludCB3YWl0 KQogCiAJaWYgKHdhaXQpIHsKIAkJd2hpbGUgKHRpbWVvdXQtLSkgewotCQkJaWYgKHJlcV9wZW5k aW5nLnN0YXR1cyAhPQorCQkJaWYgKHJlcV9wZW5kaW5nLnN0YXQgIT0KIAkJCSAgICBIWVBFUl9E TUFCVUZfUkVRX05PVF9SRVNQT05ERUQpCiAJCQkJYnJlYWs7CiAJCQl1c2xlZXBfcmFuZ2UoMTAw LCAxMjApOwpAQCAtNzY0LDcgKzc5Miw3IEBAIGludCBoeXBlcl9kbWFidWZfeGVuX3NlbmRfcmVx KGludCBkb21pZCwgc3RydWN0IGh5cGVyX2RtYWJ1Zl9yZXEgKnJlcSwgaW50IHdhaXQpCiAKIAkJ aWYgKHRpbWVvdXQgPCAwKSB7CiAJCQltdXRleF91bmxvY2soJnJpbmdfaW5mby0+bG9jayk7Ci0J CQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgInJlcXVlc3QgdGltZWQtb3V0 XG4iKTsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgInJlcXVlc3QgdGltZWQtb3V0XG4i KTsKIAkJCXJldHVybiAtRUJVU1k7CiAJCX0KIApAQCAtNzgxLDEwICs4MDksOCBAQCBpbnQgaHlw ZXJfZG1hYnVmX3hlbl9zZW5kX3JlcShpbnQgZG9taWQsIHN0cnVjdCBoeXBlcl9kbWFidWZfcmVx ICpyZXEsIGludCB3YWl0KQogCQl9CiAKIAkJaWYgKHR2X2RpZmYudHZfc2VjICE9IDAgJiYgdHZf ZGlmZi50dl91c2VjID4gMTYwMDApCi0JCQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRl dmljZSwgInNlbmRfcmVxOnRpbWUgZGlmZjogJWxkIHNlYywgJWxkIHVzZWNcbiIsCisJCQlkZXZf ZGJnKGh5X2Rydl9wcml2LT5kZXYsICJzZW5kX3JlcTp0aW1lIGRpZmY6ICVsZCBzZWMsICVsZCB1 c2VjXG4iLAogCQkJCXR2X2RpZmYudHZfc2VjLCB0dl9kaWZmLnR2X3VzZWMpOwotCi0JCXJldHVy biByZXFfcGVuZGluZy5zdGF0dXM7CiAJfQogCiAJbXV0ZXhfdW5sb2NrKCZyaW5nX2luZm8tPmxv Y2spOwpAQCAtODA4LDcgKzgzNCw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBiYWNrX3JpbmdfaXNy KGludCBpcnEsIHZvaWQgKmluZm8pCiAJcmluZ19pbmZvID0gKHN0cnVjdCB4ZW5fY29tbV9yeF9y aW5nX2luZm8gKilpbmZvOwogCXJpbmcgPSAmcmluZ19pbmZvLT5yaW5nX2JhY2s7CiAKLQlkZXZf ZGJnKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIiVzXG4iLCBfX2Z1bmNfXyk7CisJZGV2 X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LCAiJXNcbiIsIF9fZnVuY19fKTsKIAogCWRvIHsKIAkJcmMg PSByaW5nLT5yZXFfY29uczsKQEAgLTgyOCwxMyArODU0LDEzIEBAIHN0YXRpYyBpcnFyZXR1cm5f dCBiYWNrX3JpbmdfaXNyKGludCBpcnEsIHZvaWQgKmluZm8pCiAJCQkJICogdGhlIHJlcXVlc3Rl cgogCQkJCSAqLwogCQkJCW1lbWNweSgmcmVzcCwgJnJlcSwgc2l6ZW9mKHJlc3ApKTsKLQkJCQlt ZW1jcHkoUklOR19HRVRfUkVTUE9OU0UocmluZywgcmluZy0+cnNwX3Byb2RfcHZ0KSwgJnJlc3As Ci0JCQkJCQkJc2l6ZW9mKHJlc3ApKTsKKwkJCQltZW1jcHkoUklOR19HRVRfUkVTUE9OU0Uocmlu ZywgcmluZy0+cnNwX3Byb2RfcHZ0KSwKKwkJCQkJCQkgJnJlc3AsIHNpemVvZihyZXNwKSk7CiAJ CQkJcmluZy0+cnNwX3Byb2RfcHZ0Kys7CiAKLQkJCQlkZXZfZGJnKGh5cGVyX2RtYWJ1Zl9wcml2 YXRlLmRldmljZSwKKwkJCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkJCSJzZW5kaW5n IHJlc3BvbnNlIHRvIGV4cG9ydGVyIGZvciByZXF1ZXN0IGlkOiVkXG4iLAotCQkJCQlyZXNwLnJl c3BvbnNlX2lkKTsKKwkJCQkJcmVzcC5yZXNwX2lkKTsKIAogCQkJCVJJTkdfUFVTSF9SRVNQT05T RVNfQU5EX0NIRUNLX05PVElGWShyaW5nLCBub3RpZnkpOwogCkBAIC04NjQsNyArODkwLDcgQEAg c3RhdGljIGlycXJldHVybl90IGZyb250X3JpbmdfaXNyKGludCBpcnEsIHZvaWQgKmluZm8pCiAJ cmluZ19pbmZvID0gKHN0cnVjdCB4ZW5fY29tbV90eF9yaW5nX2luZm8gKilpbmZvOwogCXJpbmcg PSAmcmluZ19pbmZvLT5yaW5nX2Zyb250OwogCi0JZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsICIlc1xuIiwgX19mdW5jX18pOworCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwg IiVzXG4iLCBfX2Z1bmNfXyk7CiAKIAlkbyB7CiAJCW1vcmVfdG9fZG8gPSAwOwpAQCAtODc2LDMz ICs5MDIsMzMgQEAgc3RhdGljIGlycXJldHVybl90IGZyb250X3JpbmdfaXNyKGludCBpcnEsIHZv aWQgKmluZm8pCiAJCQkgKiBpbiB0aGUgcmVzcG9uc2UKIAkJCSAqLwogCi0JCQlkZXZfZGJnKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwK IAkJCQkiZ2V0dGluZyByZXNwb25zZSBmcm9tIGltcG9ydGVyXG4iKTsKIAotCQkJaWYgKHJlcV9w ZW5kaW5nLnJlcXVlc3RfaWQgPT0gcmVzcC0+cmVzcG9uc2VfaWQpIHsKLQkJCQlyZXFfcGVuZGlu Zy5zdGF0dXMgPSByZXNwLT5zdGF0dXM7CisJCQlpZiAocmVxX3BlbmRpbmcucmVxX2lkID09IHJl c3AtPnJlc3BfaWQpIHsKKwkJCQlyZXFfcGVuZGluZy5zdGF0ID0gcmVzcC0+c3RhdDsKIAkJCX0K IAotCQkJaWYgKHJlc3AtPnN0YXR1cyA9PSBIWVBFUl9ETUFCVUZfUkVRX05FRURTX0ZPTExPV19V UCkgeworCQkJaWYgKHJlc3AtPnN0YXQgPT0gSFlQRVJfRE1BQlVGX1JFUV9ORUVEU19GT0xMT1df VVApIHsKIAkJCQkvKiBwYXJzaW5nIHJlc3BvbnNlICovCiAJCQkJcmV0ID0gaHlwZXJfZG1hYnVm X21zZ19wYXJzZShyaW5nX2luZm8tPnJkb21haW4sCiAJCQkJCQkJKHN0cnVjdCBoeXBlcl9kbWFi dWZfcmVxICopcmVzcCk7CiAKIAkJCQlpZiAocmV0IDwgMCkgewotCQkJCQlkZXZfZXJyKGh5cGVy X2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJCQkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAog CQkJCQkJImdldHRpbmcgZXJyb3Igd2hpbGUgcGFyc2luZyByZXNwb25zZVxuIik7CiAJCQkJfQot CQkJfSBlbHNlIGlmIChyZXNwLT5zdGF0dXMgPT0gSFlQRVJfRE1BQlVGX1JFUV9QUk9DRVNTRUQp IHsKKwkJCX0gZWxzZSBpZiAocmVzcC0+c3RhdCA9PSBIWVBFUl9ETUFCVUZfUkVRX1BST0NFU1NF RCkgewogCQkJCS8qIGZvciBkZWJ1Z2dpbmcgZG1hX2J1ZiByZW1vdGUgc3luY2hyb25pemF0aW9u ICovCi0JCQkJZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCi0JCQkJCSJvcmln aW5hbCByZXF1ZXN0ID0gMHgleFxuIiwgcmVzcC0+Y29tbWFuZCk7Ci0JCQkJZGV2X2RiZyhoeXBl cl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsCisJCQkJZGV2X2RiZyhoeV9kcnZfcHJpdi0+ZGV2LAor CQkJCQkib3JpZ2luYWwgcmVxdWVzdCA9IDB4JXhcbiIsIHJlc3AtPmNtZCk7CisJCQkJZGV2X2Ri ZyhoeV9kcnZfcHJpdi0+ZGV2LAogCQkJCQkiSnVzdCBnb3QgSFlQRVJfRE1BQlVGX1JFUV9QUk9D RVNTRURcbiIpOwotCQkJfSBlbHNlIGlmIChyZXNwLT5zdGF0dXMgPT0gSFlQRVJfRE1BQlVGX1JF UV9FUlJPUikgeworCQkJfSBlbHNlIGlmIChyZXNwLT5zdGF0ID09IEhZUEVSX0RNQUJVRl9SRVFf RVJST1IpIHsKIAkJCQkvKiBmb3IgZGVidWdnaW5nIGRtYV9idWYgcmVtb3RlIHN5bmNocm9uaXph dGlvbiAqLwotCQkJCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAotCQkJCQki b3JpZ2luYWwgcmVxdWVzdCA9IDB4JXhcbiIsIHJlc3AtPmNvbW1hbmQpOwotCQkJCWRldl9kYmco aHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRl diwKKwkJCQkJIm9yaWdpbmFsIHJlcXVlc3QgPSAweCV4XG4iLCByZXNwLT5jbWQpOworCQkJCWRl dl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwKIAkJCQkJIkp1c3QgZ290IEhZUEVSX0RNQUJVRl9SRVFf RVJST1JcbiIpOwogCQkJfQogCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbV9saXN0LmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9k bWFidWYveGVuL2h5cGVyX2RtYWJ1Zl94ZW5fY29tbV9saXN0LmMKaW5kZXggNDcwOGI0OS4uN2E4 ZWM3MyAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL3hlbi9oeXBlcl9kbWFi dWZfeGVuX2NvbW1fbGlzdC5jCisrKyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlw ZXJfZG1hYnVmX3hlbl9jb21tX2xpc3QuYwpAQCAtMzgsOCArMzgsNiBAQAogI2luY2x1ZGUgImh5 cGVyX2RtYWJ1Zl94ZW5fY29tbS5oIgogI2luY2x1ZGUgImh5cGVyX2RtYWJ1Zl94ZW5fY29tbV9s aXN0LmgiCiAKLWV4dGVybiBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3ByaXZhdGUgaHlwZXJfZG1hYnVm X3ByaXZhdGU7Ci0KIERFQ0xBUkVfSEFTSFRBQkxFKHhlbl9jb21tX3R4X3JpbmdfaGFzaCwgTUFY X0VOVFJZX1RYX1JJTkcpOwogREVDTEFSRV9IQVNIVEFCTEUoeGVuX2NvbW1fcnhfcmluZ19oYXNo LCBNQVhfRU5UUllfUlhfUklORyk7CiAKQEAgLTU2LDcgKzU0LDcgQEAgaW50IHhlbl9jb21tX2Fk ZF90eF9yaW5nKHN0cnVjdCB4ZW5fY29tbV90eF9yaW5nX2luZm8gKnJpbmdfaW5mbykKIAlpbmZv X2VudHJ5ID0ga21hbGxvYyhzaXplb2YoKmluZm9fZW50cnkpLCBHRlBfS0VSTkVMKTsKIAogCWlm ICghaW5mb19lbnRyeSkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwK KwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJIk5vIG1lbW9yeSBsZWZ0IHRvIGJlIGFs bG9jYXRlZFxuIik7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KQEAgLTc2LDcgKzc0LDcgQEAgaW50 IHhlbl9jb21tX2FkZF9yeF9yaW5nKHN0cnVjdCB4ZW5fY29tbV9yeF9yaW5nX2luZm8gKnJpbmdf aW5mbykKIAlpbmZvX2VudHJ5ID0ga21hbGxvYyhzaXplb2YoKmluZm9fZW50cnkpLCBHRlBfS0VS TkVMKTsKIAogCWlmICghaW5mb19lbnRyeSkgewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2 YXRlLmRldmljZSwKKwkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJIk5vIG1lbW9yeSBs ZWZ0IHRvIGJlIGFsbG9jYXRlZFxuIik7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KZGlmZiAtLWdp dCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9zaG0uYyBi L2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi94ZW4vaHlwZXJfZG1hYnVmX3hlbl9zaG0uYwppbmRl eCA5MDhlZGE4Li40MjQ0MTdkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv eGVuL2h5cGVyX2RtYWJ1Zl94ZW5fc2htLmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVm L3hlbi9oeXBlcl9kbWFidWZfeGVuX3NobS5jCkBAIC0zNiw4ICszNiw2IEBACiAKICNkZWZpbmUg UkVGU19QRVJfUEFHRSAoUEFHRV9TSVpFL3NpemVvZihncmFudF9yZWZfdCkpCiAKLWV4dGVybiBz dHJ1Y3QgaHlwZXJfZG1hYnVmX3ByaXZhdGUgaHlwZXJfZG1hYnVmX3ByaXZhdGU7Ci0KIC8qCiAg KiBDcmVhdGVzIDIgbGV2ZWwgcGFnZSBkaXJlY3Rvcnkgc3RydWN0dXJlIGZvciByZWZlcmVuY2lu ZyBzaGFyZWQgcGFnZXMuCiAgKiBUb3AgbGV2ZWwgcGFnZSBpcyBhIHNpbmdsZSBwYWdlIHRoYXQg Y29udGFpbnMgdXAgdG8gMTAyNCByZWZpZHMgdGhhdApAQCAtOTgsNyArOTYsNyBAQCBpbnQgaHlw ZXJfZG1hYnVmX3hlbl9zaGFyZV9wYWdlcyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCBpbnQgZG9taWQs IGludCBuZW50cywKIAlzaF9wYWdlc19pbmZvID0ga21hbGxvYyhzaXplb2YoKnNoX3BhZ2VzX2lu Zm8pLCBHRlBfS0VSTkVMKTsKIAogCWlmICghc2hfcGFnZXNfaW5mbykgewotCQlkZXZfZXJyKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIk5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CisJCWRl dl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgIk5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CiAJCXJldHVy biAtRU5PTUVNOwogCX0KIApAQCAtMTA3LDEwICsxMDUsMTAgQEAgaW50IGh5cGVyX2RtYWJ1Zl94 ZW5fc2hhcmVfcGFnZXMoc3RydWN0IHBhZ2UgKipwYWdlcywgaW50IGRvbWlkLCBpbnQgbmVudHMs CiAJLyogc2hhcmUgZGF0YSBwYWdlcyBpbiByZWFkb25seSBtb2RlIGZvciBzZWN1cml0eSAqLwog CWZvciAoaT0wOyBpPG5lbnRzOyBpKyspIHsKIAkJbHZsMl90YWJsZVtpXSA9IGdudHRhYl9ncmFu dF9mb3JlaWduX2FjY2Vzcyhkb21pZCwKLQkJCQkJCQkgICAgcGZuX3RvX21mbihwYWdlX3RvX3Bm bihwYWdlc1tpXSkpLAotCQkJCQkJCSAgICB0cnVlIC8qIHJlYWQtb25seSBmcm9tIHJlbW90ZSBk b21haW4gKi8pOworCQkJCQlwZm5fdG9fbWZuKHBhZ2VfdG9fcGZuKHBhZ2VzW2ldKSksCisJCQkJ CXRydWUgLyogcmVhZC1vbmx5IGZyb20gcmVtb3RlIGRvbWFpbiAqLyk7CiAJCWlmIChsdmwyX3Rh YmxlW2ldID09IC1FTk9TUEMpIHsKLQkJCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2 aWNlLCAiTm8gbW9yZSBzcGFjZSBsZWZ0IGluIGdyYW50IHRhYmxlXG4iKTsKKwkJCWRldl9lcnIo aHlfZHJ2X3ByaXYtPmRldiwgIk5vIG1vcmUgc3BhY2UgbGVmdCBpbiBncmFudCB0YWJsZVxuIik7 CiAKIAkJCS8qIFVuc2hhcmUgYWxsIGFscmVhZHkgc2hhcmVkIHBhZ2VzIGZvciBsdmwyICovCiAJ CQl3aGlsZShpLS0pIHsKQEAgLTEyNCwxMCArMTIyLDExIEBAIGludCBoeXBlcl9kbWFidWZfeGVu X3NoYXJlX3BhZ2VzKHN0cnVjdCBwYWdlICoqcGFnZXMsIGludCBkb21pZCwgaW50IG5lbnRzLAog CS8qIFNoYXJlIDJuZCBsZXZlbCBhZGRyZXNzaW5nIHBhZ2VzIGluIHJlYWRvbmx5IG1vZGUqLwog CWZvciAoaT0wOyBpPCBuX2x2bDJfZ3JlZnM7IGkrKykgewogCQlsdmwzX3RhYmxlW2ldID0gZ250 dGFiX2dyYW50X2ZvcmVpZ25fYWNjZXNzKGRvbWlkLAotCQkJCQkJCSAgICB2aXJ0X3RvX21mbigo dW5zaWduZWQgbG9uZylsdmwyX3RhYmxlK2kqUEFHRV9TSVpFICksCi0JCQkJCQkJICAgIHRydWUp OworCQkJCQl2aXJ0X3RvX21mbigodW5zaWduZWQgbG9uZylsdmwyX3RhYmxlK2kqUEFHRV9TSVpF ICksCisJCQkJCXRydWUpOworCiAJCWlmIChsdmwzX3RhYmxlW2ldID09IC1FTk9TUEMpIHsKLQkJ CWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiTm8gbW9yZSBzcGFjZSBsZWZ0 IGluIGdyYW50IHRhYmxlXG4iKTsKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgIk5vIG1v cmUgc3BhY2UgbGVmdCBpbiBncmFudCB0YWJsZVxuIik7CiAKIAkJCS8qIFVuc2hhcmUgYWxsIGFs cmVhZHkgc2hhcmVkIHBhZ2VzIGZvciBsdmwzICovCiAJCQl3aGlsZShpLS0pIHsKQEAgLTE0Nywx MSArMTQ2LDExIEBAIGludCBoeXBlcl9kbWFidWZfeGVuX3NoYXJlX3BhZ2VzKHN0cnVjdCBwYWdl ICoqcGFnZXMsIGludCBkb21pZCwgaW50IG5lbnRzLAogCiAJLyogU2hhcmUgbHZsM190YWJsZSBp biByZWFkb25seSBtb2RlKi8KIAlsdmwzX2dyZWYgPSBnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nl c3MoZG9taWQsCi0JCQkJCQl2aXJ0X3RvX21mbigodW5zaWduZWQgbG9uZylsdmwzX3RhYmxlKSwK LQkJCQkJCXRydWUpOworCQkJdmlydF90b19tZm4oKHVuc2lnbmVkIGxvbmcpbHZsM190YWJsZSks CisJCQl0cnVlKTsKIAogCWlmIChsdmwzX2dyZWYgPT0gLUVOT1NQQykgewotCQlkZXZfZXJyKGh5 cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIk5vIG1vcmUgc3BhY2UgbGVmdCBpbiBncmFudCB0 YWJsZVxuIik7CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgIk5vIG1vcmUgc3BhY2UgbGVm dCBpbiBncmFudCB0YWJsZVxuIik7CiAKIAkJLyogVW5zaGFyZSBhbGwgcGFnZXMgZm9yIGx2bDMg Ki8KIAkJd2hpbGUoaS0tKSB7CkBAIC0xNzgsNyArMTc3LDcgQEAgaW50IGh5cGVyX2RtYWJ1Zl94 ZW5fc2hhcmVfcGFnZXMoc3RydWN0IHBhZ2UgKipwYWdlcywgaW50IGRvbWlkLCBpbnQgbmVudHMs CiAJLyogU3RvcmUgZXhwb3J0ZWQgcGFnZXMgcmVmaWQgdG8gYmUgdW5zaGFyZWQgbGF0ZXIgKi8K IAlzaF9wYWdlc19pbmZvLT5sdmwzX2dyZWYgPSBsdmwzX2dyZWY7CiAKLQlkZXZfZGJnKGh5cGVy X2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIiVzIGV4aXRcbiIsIF9fZnVuY19fKTsKKwlkZXZfZGJn KGh5X2Rydl9wcml2LT5kZXYsICIlcyBleGl0XG4iLCBfX2Z1bmNfXyk7CiAJcmV0dXJuIGx2bDNf Z3JlZjsKIAogZXJyX2NsZWFudXA6CkBAIC0xOTAsMTYgKzE4OSwxNyBAQCBpbnQgaHlwZXJfZG1h YnVmX3hlbl9zaGFyZV9wYWdlcyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCBpbnQgZG9taWQsIGludCBu ZW50cywKIAogaW50IGh5cGVyX2RtYWJ1Zl94ZW5fdW5zaGFyZV9wYWdlcyh2b2lkICoqcmVmc19p bmZvLCBpbnQgbmVudHMpIHsKIAlzdHJ1Y3QgeGVuX3NoYXJlZF9wYWdlc19pbmZvICpzaF9wYWdl c19pbmZvOwotCWludCBuX2x2bDJfZ3JlZnMgPSAobmVudHMvUkVGU19QRVJfUEFHRSArICgobmVu dHMgJSBSRUZTX1BFUl9QQUdFKSA/IDE6IDApKTsKKwlpbnQgbl9sdmwyX2dyZWZzID0gKG5lbnRz L1JFRlNfUEVSX1BBR0UgKworCQkJICAgICgobmVudHMgJSBSRUZTX1BFUl9QQUdFKSA/IDE6IDAp KTsKIAlpbnQgaTsKIAotCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiJXMg ZW50cnlcbiIsIF9fZnVuY19fKTsKKwlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsICIlcyBlbnRy eVxuIiwgX19mdW5jX18pOwogCXNoX3BhZ2VzX2luZm8gPSAoc3RydWN0IHhlbl9zaGFyZWRfcGFn ZXNfaW5mbyAqKSgqcmVmc19pbmZvKTsKIAogCWlmIChzaF9wYWdlc19pbmZvLT5sdmwzX3RhYmxl ID09IE5VTEwgfHwKIAkgICAgc2hfcGFnZXNfaW5mby0+bHZsMl90YWJsZSA9PSAgTlVMTCB8fAog CSAgICBzaF9wYWdlc19pbmZvLT5sdmwzX2dyZWYgPT0gLTEpIHsKLQkJZGV2X3dhcm4oaHlwZXJf ZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQlkZXZfd2FybihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJ ICJncmVmIHRhYmxlIGZvciBoeXBlcl9kbWFidWYgYWxyZWFkeSBjbGVhbmVkIHVwXG4iKTsKIAkJ cmV0dXJuIDA7CiAJfQpAQCAtMjA3LDcgKzIwNyw3IEBAIGludCBoeXBlcl9kbWFidWZfeGVuX3Vu c2hhcmVfcGFnZXModm9pZCAqKnJlZnNfaW5mbywgaW50IG5lbnRzKSB7CiAJLyogRW5kIGZvcmVp Z24gYWNjZXNzIGZvciBkYXRhIHBhZ2VzLCBidXQgZG8gbm90IGZyZWUgdGhlbSAqLwogCWZvciAo aSA9IDA7IGkgPCBuZW50czsgaSsrKSB7CiAJCWlmIChnbnR0YWJfcXVlcnlfZm9yZWlnbl9hY2Nl c3Moc2hfcGFnZXNfaW5mby0+bHZsMl90YWJsZVtpXSkpIHsKLQkJCWRldl93YXJuKGh5cGVyX2Rt YWJ1Zl9wcml2YXRlLmRldmljZSwgInJlZmlkIG5vdCBzaGFyZWQgISFcbiIpOworCQkJZGV2X3dh cm4oaHlfZHJ2X3ByaXYtPmRldiwgInJlZmlkIG5vdCBzaGFyZWQgISFcbiIpOwogCQl9CiAJCWdu dHRhYl9lbmRfZm9yZWlnbl9hY2Nlc3NfcmVmKHNoX3BhZ2VzX2luZm8tPmx2bDJfdGFibGVbaV0s IDApOwogCQlnbnR0YWJfZnJlZV9ncmFudF9yZWZlcmVuY2Uoc2hfcGFnZXNfaW5mby0+bHZsMl90 YWJsZVtpXSk7CkBAIC0yMTYsMTcgKzIxNiwxNyBAQCBpbnQgaHlwZXJfZG1hYnVmX3hlbl91bnNo YXJlX3BhZ2VzKHZvaWQgKipyZWZzX2luZm8sIGludCBuZW50cykgewogCS8qIEVuZCBmb3JlaWdu IGFjY2VzcyBmb3IgMm5kIGxldmVsIGFkZHJlc3NpbmcgcGFnZXMgKi8KIAlmb3IgKGkgPSAwOyBp IDwgbl9sdmwyX2dyZWZzOyBpKyspIHsKIAkJaWYgKGdudHRhYl9xdWVyeV9mb3JlaWduX2FjY2Vz cyhzaF9wYWdlc19pbmZvLT5sdmwzX3RhYmxlW2ldKSkgewotCQkJZGV2X3dhcm4oaHlwZXJfZG1h YnVmX3ByaXZhdGUuZGV2aWNlLCAicmVmaWQgbm90IHNoYXJlZCAhIVxuIik7CisJCQlkZXZfd2Fy bihoeV9kcnZfcHJpdi0+ZGV2LCAicmVmaWQgbm90IHNoYXJlZCAhIVxuIik7CiAJCX0KIAkJaWYg KCFnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNzX3JlZihzaF9wYWdlc19pbmZvLT5sdmwzX3RhYmxl W2ldLCAxKSkgewotCQkJZGV2X3dhcm4oaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAicmVm aWQgc3RpbGwgaW4gdXNlISEhXG4iKTsKKwkJCWRldl93YXJuKGh5X2Rydl9wcml2LT5kZXYsICJy ZWZpZCBzdGlsbCBpbiB1c2UhISFcbiIpOwogCQl9CiAJCWdudHRhYl9mcmVlX2dyYW50X3JlZmVy ZW5jZShzaF9wYWdlc19pbmZvLT5sdmwzX3RhYmxlW2ldKTsKIAl9CiAKIAkvKiBFbmQgZm9yZWln biBhY2Nlc3MgZm9yIHRvcCBsZXZlbCBhZGRyZXNzaW5nIHBhZ2UgKi8KIAlpZiAoZ250dGFiX3F1 ZXJ5X2ZvcmVpZ25fYWNjZXNzKHNoX3BhZ2VzX2luZm8tPmx2bDNfZ3JlZikpIHsKLQkJZGV2X3dh cm4oaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiZ3JlZiBub3Qgc2hhcmVkICEhXG4iKTsK KwkJZGV2X3dhcm4oaHlfZHJ2X3ByaXYtPmRldiwgImdyZWYgbm90IHNoYXJlZCAhIVxuIik7CiAJ fQogCiAJZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19yZWYoc2hfcGFnZXNfaW5mby0+bHZsM19n cmVmLCAxKTsKQEAgLTI0Miw3ICsyNDIsNyBAQCBpbnQgaHlwZXJfZG1hYnVmX3hlbl91bnNoYXJl X3BhZ2VzKHZvaWQgKipyZWZzX2luZm8sIGludCBuZW50cykgewogCWtmcmVlKHNoX3BhZ2VzX2lu Zm8pOwogCXNoX3BhZ2VzX2luZm8gPSBOVUxMOwogCi0JZGV2X2RiZyhoeXBlcl9kbWFidWZfcHJp dmF0ZS5kZXZpY2UsICIlcyBleGl0XG4iLCBfX2Z1bmNfXyk7CisJZGV2X2RiZyhoeV9kcnZfcHJp di0+ZGV2LCAiJXMgZXhpdFxuIiwgX19mdW5jX18pOwogCXJldHVybiAwOwogfQogCkBAIC0yNzAs MjcgKzI3MCwzMyBAQCBzdHJ1Y3QgcGFnZSAqKiBoeXBlcl9kbWFidWZfeGVuX21hcF9zaGFyZWRf cGFnZXMoaW50IGx2bDNfZ3JlZiwgaW50IGRvbWlkLCBpbnQgbgogCiAJLyogIyBvZiBncmVmcyBp biB0aGUgbGFzdCBwYWdlIG9mIGx2bDIgdGFibGUgKi8KIAlpbnQgbmVudHNfbGFzdCA9IChuZW50 cyAtIDEpICUgUkVGU19QRVJfUEFHRSArIDE7Ci0JaW50IG5fbHZsMl9ncmVmcyA9IChuZW50cyAv IFJFRlNfUEVSX1BBR0UpICsgKChuZW50c19sYXN0ID4gMCkgPyAxIDogMCkgLQorCWludCBuX2x2 bDJfZ3JlZnMgPSAobmVudHMgLyBSRUZTX1BFUl9QQUdFKSArCisJCQkgICAoKG5lbnRzX2xhc3Qg PiAwKSA/IDEgOiAwKSAtCiAJCQkgICAobmVudHNfbGFzdCA9PSBSRUZTX1BFUl9QQUdFKTsKIAlp bnQgaSwgaiwgazsKIAotCWRldl9kYmcoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiJXMg ZW50cnlcbiIsIF9fZnVuY19fKTsKKwlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsICIlcyBlbnRy eVxuIiwgX19mdW5jX18pOwogCiAJc2hfcGFnZXNfaW5mbyA9IGttYWxsb2Moc2l6ZW9mKCpzaF9w YWdlc19pbmZvKSwgR0ZQX0tFUk5FTCk7CiAJKnJlZnNfaW5mbyA9ICh2b2lkICopIHNoX3BhZ2Vz X2luZm87CiAKLQlsdmwyX3RhYmxlX3BhZ2VzID0ga2NhbGxvYyhzaXplb2Yoc3RydWN0IHBhZ2Uq KSwgbl9sdmwyX2dyZWZzLCBHRlBfS0VSTkVMKTsKKwlsdmwyX3RhYmxlX3BhZ2VzID0ga2NhbGxv YyhzaXplb2Yoc3RydWN0IHBhZ2UqKSwgbl9sdmwyX2dyZWZzLAorCQkJCSAgIEdGUF9LRVJORUwp OworCiAJZGF0YV9wYWdlcyA9IGtjYWxsb2Moc2l6ZW9mKHN0cnVjdCBwYWdlKiksIG5lbnRzLCBH RlBfS0VSTkVMKTsKIAotCWx2bDJfbWFwX29wcyA9IGtjYWxsb2Moc2l6ZW9mKCpsdmwyX21hcF9v cHMpLCBuX2x2bDJfZ3JlZnMsIEdGUF9LRVJORUwpOwotCWx2bDJfdW5tYXBfb3BzID0ga2NhbGxv YyhzaXplb2YoKmx2bDJfdW5tYXBfb3BzKSwgbl9sdmwyX2dyZWZzLCBHRlBfS0VSTkVMKTsKKwls dmwyX21hcF9vcHMgPSBrY2FsbG9jKHNpemVvZigqbHZsMl9tYXBfb3BzKSwgbl9sdmwyX2dyZWZz LAorCQkJICAgICAgIEdGUF9LRVJORUwpOworCisJbHZsMl91bm1hcF9vcHMgPSBrY2FsbG9jKHNp emVvZigqbHZsMl91bm1hcF9vcHMpLCBuX2x2bDJfZ3JlZnMsCisJCQkJIEdGUF9LRVJORUwpOwog CiAJZGF0YV9tYXBfb3BzID0ga2NhbGxvYyhzaXplb2YoKmRhdGFfbWFwX29wcyksIG5lbnRzLCBH RlBfS0VSTkVMKTsKIAlkYXRhX3VubWFwX29wcyA9IGtjYWxsb2Moc2l6ZW9mKCpkYXRhX3VubWFw X29wcyksIG5lbnRzLCBHRlBfS0VSTkVMKTsKIAogCS8qIE1hcCB0b3AgbGV2ZWwgYWRkcmVzc2lu ZyBwYWdlICovCiAJaWYgKGdudHRhYl9hbGxvY19wYWdlcygxLCAmbHZsM190YWJsZV9wYWdlKSkg ewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgIkNhbm5vdCBhbGxvY2F0 ZSBwYWdlc1xuIik7CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwgIkNhbm5vdCBhbGxvY2F0 ZSBwYWdlc1xuIik7CiAJCXJldHVybiBOVUxMOwogCX0KIApAQCAtMzA0LDEzICszMTAsMTYgQEAg c3RydWN0IHBhZ2UgKiogaHlwZXJfZG1hYnVmX3hlbl9tYXBfc2hhcmVkX3BhZ2VzKGludCBsdmwz X2dyZWYsIGludCBkb21pZCwgaW50IG4KIAkJCSAgICBHTlRNQVBfaG9zdF9tYXAgfCBHTlRNQVBf cmVhZG9ubHksIC0xKTsKIAogCWlmIChnbnR0YWJfbWFwX3JlZnMoJmx2bDNfbWFwX29wcywgTlVM TCwgJmx2bDNfdGFibGVfcGFnZSwgMSkpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsICJIWVBFUlZJU09SIG1hcCBncmFudCByZWYgZmFpbGVkIik7CisJCWRldl9lcnIo aHlfZHJ2X3ByaXYtPmRldiwKKwkJCSJIWVBFUlZJU09SIG1hcCBncmFudCByZWYgZmFpbGVkIik7 CiAJCXJldHVybiBOVUxMOwogCX0KIAogCWlmIChsdmwzX21hcF9vcHMuc3RhdHVzKSB7Ci0JCWRl dl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiSFlQRVJWSVNPUiBtYXAgZ3JhbnQg cmVmIGZhaWxlZCBzdGF0dXMgPSAlZCIsCisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJ CSJIWVBFUlZJU09SIG1hcCBncmFudCByZWYgZmFpbGVkIHN0YXR1cyA9ICVkIiwKIAkJCWx2bDNf bWFwX29wcy5zdGF0dXMpOworCiAJCWdvdG8gZXJyb3JfY2xlYW51cF9sdmwzOwogCX0gZWxzZSB7 CiAJCWx2bDNfdW5tYXBfb3BzLmhhbmRsZSA9IGx2bDNfbWFwX29wcy5oYW5kbGU7CkBAIC0zMTgs MzUgKzMyNyw0MyBAQCBzdHJ1Y3QgcGFnZSAqKiBoeXBlcl9kbWFidWZfeGVuX21hcF9zaGFyZWRf cGFnZXMoaW50IGx2bDNfZ3JlZiwgaW50IGRvbWlkLCBpbnQgbgogCiAJLyogTWFwIGFsbCBzZWNv bmQgbGV2ZWwgcGFnZXMgKi8KIAlpZiAoZ250dGFiX2FsbG9jX3BhZ2VzKG5fbHZsMl9ncmVmcywg bHZsMl90YWJsZV9wYWdlcykpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZp Y2UsICJDYW5ub3QgYWxsb2NhdGUgcGFnZXNcbiIpOworCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5k ZXYsICJDYW5ub3QgYWxsb2NhdGUgcGFnZXNcbiIpOwogCQlnb3RvIGVycm9yX2NsZWFudXBfbHZs MzsKIAl9CiAKIAlmb3IgKGkgPSAwOyBpIDwgbl9sdmwyX2dyZWZzOyBpKyspIHsKIAkJbHZsMl90 YWJsZSA9IChncmFudF9yZWZfdCAqKXBmbl90b19rYWRkcihwYWdlX3RvX3BmbihsdmwyX3RhYmxl X3BhZ2VzW2ldKSk7Ci0JCWdudHRhYl9zZXRfbWFwX29wKCZsdmwyX21hcF9vcHNbaV0sICh1bnNp Z25lZCBsb25nKWx2bDJfdGFibGUsIEdOVE1BUF9ob3N0X21hcCB8IEdOVE1BUF9yZWFkb25seSwK KwkJZ250dGFiX3NldF9tYXBfb3AoJmx2bDJfbWFwX29wc1tpXSwKKwkJCQkgICh1bnNpZ25lZCBs b25nKWx2bDJfdGFibGUsIEdOVE1BUF9ob3N0X21hcCB8CisJCQkJICBHTlRNQVBfcmVhZG9ubHks CiAJCQkJICBsdmwzX3RhYmxlW2ldLCBkb21pZCk7Ci0JCWdudHRhYl9zZXRfdW5tYXBfb3AoJmx2 bDJfdW5tYXBfb3BzW2ldLCAodW5zaWduZWQgbG9uZylsdmwyX3RhYmxlLCBHTlRNQVBfaG9zdF9t YXAgfCBHTlRNQVBfcmVhZG9ubHksIC0xKTsKKwkJZ250dGFiX3NldF91bm1hcF9vcCgmbHZsMl91 bm1hcF9vcHNbaV0sCisJCQkJICAgICh1bnNpZ25lZCBsb25nKWx2bDJfdGFibGUsIEdOVE1BUF9o b3N0X21hcCB8CisJCQkJICAgIEdOVE1BUF9yZWFkb25seSwgLTEpOwogCX0KIAogCS8qIFVubWFw IHRvcCBsZXZlbCBwYWdlLCBhcyBpdCB3b24ndCBiZSBuZWVkZWQgYW55IGxvbmdlciAqLwotCWlm IChnbnR0YWJfdW5tYXBfcmVmcygmbHZsM191bm1hcF9vcHMsIE5VTEwsICZsdmwzX3RhYmxlX3Bh Z2UsIDEpKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAieGVuOiBj YW5ub3QgdW5tYXAgdG9wIGxldmVsIHBhZ2VcbiIpOworCWlmIChnbnR0YWJfdW5tYXBfcmVmcygm bHZsM191bm1hcF9vcHMsIE5VTEwsCisJCQkgICAgICAmbHZsM190YWJsZV9wYWdlLCAxKSkgewor CQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkieGVuOiBjYW5ub3QgdW5tYXAgdG9wIGxl dmVsIHBhZ2VcbiIpOwogCQlyZXR1cm4gTlVMTDsKIAl9IGVsc2UgewogCQkvKiBNYXJrIHRoYXQg cGFnZSB3YXMgdW5tYXBwZWQgKi8KIAkJbHZsM191bm1hcF9vcHMuaGFuZGxlID0gLTE7CiAJfQog Ci0JaWYgKGdudHRhYl9tYXBfcmVmcyhsdmwyX21hcF9vcHMsIE5VTEwsIGx2bDJfdGFibGVfcGFn ZXMsIG5fbHZsMl9ncmVmcykpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZp Y2UsICJIWVBFUlZJU09SIG1hcCBncmFudCByZWYgZmFpbGVkIik7CisJaWYgKGdudHRhYl9tYXBf cmVmcyhsdmwyX21hcF9vcHMsIE5VTEwsCisJCQkgICAgbHZsMl90YWJsZV9wYWdlcywgbl9sdmwy X2dyZWZzKSkgeworCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCisJCQkiSFlQRVJWSVNPUiBt YXAgZ3JhbnQgcmVmIGZhaWxlZCIpOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAKIAkvKiBDaGVja3Mg aWYgcGFnZXMgd2VyZSBtYXBwZWQgY29ycmVjdGx5ICovCiAJZm9yIChpID0gMDsgaSA8IG5fbHZs Ml9ncmVmczsgaSsrKSB7CiAJCWlmIChsdmwyX21hcF9vcHNbaV0uc3RhdHVzKSB7Ci0JCQlkZXZf ZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwKKwkJCWRldl9lcnIoaHlfZHJ2X3ByaXYt PmRldiwKIAkJCQkiSFlQRVJWSVNPUiBtYXAgZ3JhbnQgcmVmIGZhaWxlZCBzdGF0dXMgPSAlZCIs CiAJCQkJbHZsMl9tYXBfb3BzW2ldLnN0YXR1cyk7CiAJCQlnb3RvIGVycm9yX2NsZWFudXBfbHZs MjsKQEAgLTM1Niw3ICszNzMsOCBAQCBzdHJ1Y3QgcGFnZSAqKiBoeXBlcl9kbWFidWZfeGVuX21h cF9zaGFyZWRfcGFnZXMoaW50IGx2bDNfZ3JlZiwgaW50IGRvbWlkLCBpbnQgbgogCX0KIAogCWlm IChnbnR0YWJfYWxsb2NfcGFnZXMobmVudHMsIGRhdGFfcGFnZXMpKSB7Ci0JCWRldl9lcnIoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiQ2Fubm90IGFsbG9jYXRlIHBhZ2VzXG4iKTsKKwkJ ZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAorCQkJIkNhbm5vdCBhbGxvY2F0ZSBwYWdlc1xuIik7 CiAJCWdvdG8gZXJyb3JfY2xlYW51cF9sdmwyOwogCX0KIApAQCAtMzY2LDEzICszODQsMTMgQEAg c3RydWN0IHBhZ2UgKiogaHlwZXJfZG1hYnVmX3hlbl9tYXBfc2hhcmVkX3BhZ2VzKGludCBsdmwz X2dyZWYsIGludCBkb21pZCwgaW50IG4KIAkJbHZsMl90YWJsZSA9IHBmbl90b19rYWRkcihwYWdl X3RvX3BmbihsdmwyX3RhYmxlX3BhZ2VzW2ldKSk7CiAJCWZvciAoaiA9IDA7IGogPCBSRUZTX1BF Ul9QQUdFOyBqKyspIHsKIAkJCWdudHRhYl9zZXRfbWFwX29wKCZkYXRhX21hcF9vcHNba10sCi0J CQkJCSAgKHVuc2lnbmVkIGxvbmcpcGZuX3RvX2thZGRyKHBhZ2VfdG9fcGZuKGRhdGFfcGFnZXNb a10pKSwKLQkJCQkJICBHTlRNQVBfaG9zdF9tYXAgfCBHTlRNQVBfcmVhZG9ubHksCi0JCQkJCSAg bHZsMl90YWJsZVtqXSwgZG9taWQpOworCQkJCSh1bnNpZ25lZCBsb25nKXBmbl90b19rYWRkcihw YWdlX3RvX3BmbihkYXRhX3BhZ2VzW2tdKSksCisJCQkJR05UTUFQX2hvc3RfbWFwIHwgR05UTUFQ X3JlYWRvbmx5LAorCQkJCWx2bDJfdGFibGVbal0sIGRvbWlkKTsKIAogCQkJZ250dGFiX3NldF91 bm1hcF9vcCgmZGF0YV91bm1hcF9vcHNba10sCi0JCQkJCSAgICAodW5zaWduZWQgbG9uZylwZm5f dG9fa2FkZHIocGFnZV90b19wZm4oZGF0YV9wYWdlc1trXSkpLAotCQkJCQkgICAgR05UTUFQX2hv c3RfbWFwIHwgR05UTUFQX3JlYWRvbmx5LCAtMSk7CisJCQkJKHVuc2lnbmVkIGxvbmcpcGZuX3Rv X2thZGRyKHBhZ2VfdG9fcGZuKGRhdGFfcGFnZXNba10pKSwKKwkJCQlHTlRNQVBfaG9zdF9tYXAg fCBHTlRNQVBfcmVhZG9ubHksIC0xKTsKIAkJCWsrKzsKIAkJfQogCX0KQEAgLTM4MiwyNSArNDAw LDI5IEBAIHN0cnVjdCBwYWdlICoqIGh5cGVyX2RtYWJ1Zl94ZW5fbWFwX3NoYXJlZF9wYWdlcyhp bnQgbHZsM19ncmVmLCBpbnQgZG9taWQsIGludCBuCiAKIAlmb3IgKGogPSAwOyBqIDwgbmVudHNf bGFzdDsgaisrKSB7CiAJCWdudHRhYl9zZXRfbWFwX29wKCZkYXRhX21hcF9vcHNba10sCi0JCQkJ ICAodW5zaWduZWQgbG9uZylwZm5fdG9fa2FkZHIocGFnZV90b19wZm4oZGF0YV9wYWdlc1trXSkp LAotCQkJCSAgR05UTUFQX2hvc3RfbWFwIHwgR05UTUFQX3JlYWRvbmx5LAotCQkJCSAgbHZsMl90 YWJsZVtqXSwgZG9taWQpOworCQkJKHVuc2lnbmVkIGxvbmcpcGZuX3RvX2thZGRyKHBhZ2VfdG9f cGZuKGRhdGFfcGFnZXNba10pKSwKKwkJCUdOVE1BUF9ob3N0X21hcCB8IEdOVE1BUF9yZWFkb25s eSwKKwkJCWx2bDJfdGFibGVbal0sIGRvbWlkKTsKIAogCQlnbnR0YWJfc2V0X3VubWFwX29wKCZk YXRhX3VubWFwX29wc1trXSwKLQkJCQkgICAgKHVuc2lnbmVkIGxvbmcpcGZuX3RvX2thZGRyKHBh Z2VfdG9fcGZuKGRhdGFfcGFnZXNba10pKSwKLQkJCQkgICAgR05UTUFQX2hvc3RfbWFwIHwgR05U TUFQX3JlYWRvbmx5LCAtMSk7CisJCQkodW5zaWduZWQgbG9uZylwZm5fdG9fa2FkZHIocGFnZV90 b19wZm4oZGF0YV9wYWdlc1trXSkpLAorCQkJR05UTUFQX2hvc3RfbWFwIHwgR05UTUFQX3JlYWRv bmx5LCAtMSk7CiAJCWsrKzsKIAl9CiAKLQlpZiAoZ250dGFiX21hcF9yZWZzKGRhdGFfbWFwX29w cywgTlVMTCwgZGF0YV9wYWdlcywgbmVudHMpKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3By aXZhdGUuZGV2aWNlLCAiSFlQRVJWSVNPUiBtYXAgZ3JhbnQgcmVmIGZhaWxlZFxuIik7CisJaWYg KGdudHRhYl9tYXBfcmVmcyhkYXRhX21hcF9vcHMsIE5VTEwsCisJCQkgICAgZGF0YV9wYWdlcywg bmVudHMpKSB7CisJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRldiwKKwkJCSJIWVBFUlZJU09SIG1h cCBncmFudCByZWYgZmFpbGVkXG4iKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQogCiAJLyogdW5tYXBw aW5nIGx2bDIgdGFibGUgcGFnZXMgKi8KLQlpZiAoZ250dGFiX3VubWFwX3JlZnMobHZsMl91bm1h cF9vcHMsIE5VTEwsIGx2bDJfdGFibGVfcGFnZXMsCisJaWYgKGdudHRhYl91bm1hcF9yZWZzKGx2 bDJfdW5tYXBfb3BzLAorCQkJICAgICAgTlVMTCwgbHZsMl90YWJsZV9wYWdlcywKIAkJCSAgICAg IG5fbHZsMl9ncmVmcykpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2Us ICJDYW5ub3QgdW5tYXAgMm5kIGxldmVsIHJlZnNcbiIpOworCQlkZXZfZXJyKGh5X2Rydl9wcml2 LT5kZXYsCisJCQkiQ2Fubm90IHVubWFwIDJuZCBsZXZlbCByZWZzXG4iKTsKIAkJcmV0dXJuIE5V TEw7CiAJfSBlbHNlIHsKIAkJLyogTWFyayB0aGF0IHBhZ2VzIHdlcmUgdW5tYXBwZWQgKi8KQEAg LTQxMSw3ICs0MzMsNyBAQCBzdHJ1Y3QgcGFnZSAqKiBoeXBlcl9kbWFidWZfeGVuX21hcF9zaGFy ZWRfcGFnZXMoaW50IGx2bDNfZ3JlZiwgaW50IGRvbWlkLCBpbnQgbgogCiAJZm9yIChpID0gMDsg aSA8IG5lbnRzOyBpKyspIHsKIAkJaWYgKGRhdGFfbWFwX29wc1tpXS5zdGF0dXMpIHsKLQkJCWRl dl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLAorCQkJZGV2X2VycihoeV9kcnZfcHJp di0+ZGV2LAogCQkJCSJIWVBFUlZJU09SIG1hcCBncmFudCByZWYgZmFpbGVkIHN0YXR1cyA9ICVk XG4iLAogCQkJCWRhdGFfbWFwX29wc1tpXS5zdGF0dXMpOwogCQkJZ290byBlcnJvcl9jbGVhbnVw X2RhdGE7CkBAIC00MzEsNyArNDUzLDcgQEAgc3RydWN0IHBhZ2UgKiogaHlwZXJfZG1hYnVmX3hl bl9tYXBfc2hhcmVkX3BhZ2VzKGludCBsdmwzX2dyZWYsIGludCBkb21pZCwgaW50IG4KIAlrZnJl ZShsdmwyX3VubWFwX29wcyk7CiAJa2ZyZWUoZGF0YV9tYXBfb3BzKTsKIAotCWRldl9kYmcoaHlw ZXJfZG1hYnVmX3ByaXZhdGUuZGV2aWNlLCAiJXMgZXhpdFxuIiwgX19mdW5jX18pOworCWRldl9k YmcoaHlfZHJ2X3ByaXYtPmRldiwgIiVzIGV4aXRcbiIsIF9fZnVuY19fKTsKIAlyZXR1cm4gZGF0 YV9wYWdlczsKIAogZXJyb3JfY2xlYW51cF9kYXRhOgpAQCAtNDQyLDEzICs0NjQsMTQgQEAgc3Ry dWN0IHBhZ2UgKiogaHlwZXJfZG1hYnVmX3hlbl9tYXBfc2hhcmVkX3BhZ2VzKGludCBsdmwzX2dy ZWYsIGludCBkb21pZCwgaW50IG4KIAogZXJyb3JfY2xlYW51cF9sdmwyOgogCWlmIChsdmwyX3Vu bWFwX29wc1swXS5oYW5kbGUgIT0gLTEpCi0JCWdudHRhYl91bm1hcF9yZWZzKGx2bDJfdW5tYXBf b3BzLCBOVUxMLCBsdmwyX3RhYmxlX3BhZ2VzLAotCQkJCSAgbl9sdmwyX2dyZWZzKTsKKwkJZ250 dGFiX3VubWFwX3JlZnMobHZsMl91bm1hcF9vcHMsIE5VTEwsCisJCQkJICBsdmwyX3RhYmxlX3Bh Z2VzLCBuX2x2bDJfZ3JlZnMpOwogCWdudHRhYl9mcmVlX3BhZ2VzKG5fbHZsMl9ncmVmcywgbHZs Ml90YWJsZV9wYWdlcyk7CiAKIGVycm9yX2NsZWFudXBfbHZsMzoKIAlpZiAobHZsM191bm1hcF9v cHMuaGFuZGxlICE9IC0xKQotCQlnbnR0YWJfdW5tYXBfcmVmcygmbHZsM191bm1hcF9vcHMsIE5V TEwsICZsdmwzX3RhYmxlX3BhZ2UsIDEpOworCQlnbnR0YWJfdW5tYXBfcmVmcygmbHZsM191bm1h cF9vcHMsIE5VTEwsCisJCQkJICAmbHZsM190YWJsZV9wYWdlLCAxKTsKIAlnbnR0YWJfZnJlZV9w YWdlcygxLCAmbHZsM190YWJsZV9wYWdlKTsKIAogCWtmcmVlKGx2bDJfdGFibGVfcGFnZXMpOwpA QCAtNDYzLDIwICs0ODYsMjAgQEAgc3RydWN0IHBhZ2UgKiogaHlwZXJfZG1hYnVmX3hlbl9tYXBf c2hhcmVkX3BhZ2VzKGludCBsdmwzX2dyZWYsIGludCBkb21pZCwgaW50IG4KIGludCBoeXBlcl9k bWFidWZfeGVuX3VubWFwX3NoYXJlZF9wYWdlcyh2b2lkICoqcmVmc19pbmZvLCBpbnQgbmVudHMp IHsKIAlzdHJ1Y3QgeGVuX3NoYXJlZF9wYWdlc19pbmZvICpzaF9wYWdlc19pbmZvOwogCi0JZGV2 X2RiZyhoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICIlcyBlbnRyeVxuIiwgX19mdW5jX18p OworCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwgIiVzIGVudHJ5XG4iLCBfX2Z1bmNfXyk7CiAK IAlzaF9wYWdlc19pbmZvID0gKHN0cnVjdCB4ZW5fc2hhcmVkX3BhZ2VzX2luZm8gKikoKnJlZnNf aW5mbyk7CiAKIAlpZiAoc2hfcGFnZXNfaW5mby0+dW5tYXBfb3BzID09IE5VTEwgfHwKIAkgICAg c2hfcGFnZXNfaW5mby0+ZGF0YV9wYWdlcyA9PSBOVUxMKSB7Ci0JCWRldl93YXJuKGh5cGVyX2Rt YWJ1Zl9wcml2YXRlLmRldmljZSwKLQkJCSAiSW1wb3J0ZWQgcGFnZXMgYWxyZWFkeSBjbGVhbmVk IHVwIG9yIGJ1ZmZlciB3YXMgbm90IGltcG9ydGVkIHlldFxuIik7CisJCWRldl93YXJuKGh5X2Ry dl9wcml2LT5kZXYsCisJCQkgInBhZ2VzIGFscmVhZHkgY2xlYW5lZCB1cCBvciBidWZmZXIgbm90 IGltcG9ydGVkIHlldFxuIik7CiAJCXJldHVybiAwOwogCX0KIAogCWlmIChnbnR0YWJfdW5tYXBf cmVmcyhzaF9wYWdlc19pbmZvLT51bm1hcF9vcHMsIE5VTEwsCiAJCQkgICAgICBzaF9wYWdlc19p bmZvLT5kYXRhX3BhZ2VzLCBuZW50cykgKSB7Ci0JCWRldl9lcnIoaHlwZXJfZG1hYnVmX3ByaXZh dGUuZGV2aWNlLCAiQ2Fubm90IHVubWFwIGRhdGEgcGFnZXNcbiIpOworCQlkZXZfZXJyKGh5X2Ry dl9wcml2LT5kZXYsICJDYW5ub3QgdW5tYXAgZGF0YSBwYWdlc1xuIik7CiAJCXJldHVybiAtRUZB VUxUOwogCX0KIApAQCAtNDg5LDYgKzUxMiw2IEBAIGludCBoeXBlcl9kbWFidWZfeGVuX3VubWFw X3NoYXJlZF9wYWdlcyh2b2lkICoqcmVmc19pbmZvLCBpbnQgbmVudHMpIHsKIAlrZnJlZShzaF9w YWdlc19pbmZvKTsKIAlzaF9wYWdlc19pbmZvID0gTlVMTDsKIAotCWRldl9kYmcoaHlwZXJfZG1h YnVmX3ByaXZhdGUuZGV2aWNlLCAiJXMgZXhpdFxuIiwgX19mdW5jX18pOworCWRldl9kYmcoaHlf ZHJ2X3ByaXYtPmRldiwgIiVzIGV4aXRcbiIsIF9fZnVuY19fKTsKIAlyZXR1cm4gMDsKIH0KLS0g CjIuNy40CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K WGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0 cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA==