From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753554AbdLSTjl (ORCPT ); Tue, 19 Dec 2017 14:39:41 -0500 Received: from mga01.intel.com ([192.55.52.88]:17651 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752881AbdLSThG (ORCPT ); Tue, 19 Dec 2017 14:37:06 -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="4018667" 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 51/60] hyper_dmabuf: missing mutex_unlock and move spinlock Date: Tue, 19 Dec 2017 11:30:07 -0800 Message-Id: <1513711816-2618-51-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 Added missing mutex_unlock to make sure mutex is unlocked before returning. Also, moved spinlock lock/unlock into hyper_dmabuf_send_event and remove checking on spinlock (with assumption caller does the spinlock in advance) to make it more straight forward. This patch includes a couple of minor modifications, changing type of function calls to static and correcting some of error code. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 38 +++++++++++++-------------- drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c | 15 +++++------ drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 8 ++++-- 3 files changed, 30 insertions(+), 31 deletions(-) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c index 023d7f4..76f57c2 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c @@ -73,7 +73,7 @@ static void hyper_dmabuf_force_free(struct exported_sgt_info *exported, } } -int hyper_dmabuf_open(struct inode *inode, struct file *filp) +static int hyper_dmabuf_open(struct inode *inode, struct file *filp) { int ret = 0; @@ -84,7 +84,7 @@ int hyper_dmabuf_open(struct inode *inode, struct file *filp) return ret; } -int hyper_dmabuf_release(struct inode *inode, struct file *filp) +static int hyper_dmabuf_release(struct inode *inode, struct file *filp) { hyper_dmabuf_foreach_exported(hyper_dmabuf_force_free, filp); @@ -93,20 +93,18 @@ int hyper_dmabuf_release(struct inode *inode, struct file *filp) #ifdef CONFIG_HYPER_DMABUF_EVENT_GEN -unsigned int hyper_dmabuf_event_poll(struct file *filp, +static unsigned int hyper_dmabuf_event_poll(struct file *filp, struct poll_table_struct *wait) { - unsigned int mask = 0; - poll_wait(filp, &hy_drv_priv->event_wait, wait); if (!list_empty(&hy_drv_priv->event_list)) - mask |= POLLIN | POLLRDNORM; + return POLLIN | POLLRDNORM; - return mask; + return 0; } -ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, +static ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, size_t count, loff_t *offset) { int ret; @@ -115,14 +113,14 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, if (!capable(CAP_DAC_OVERRIDE)) { dev_err(hy_drv_priv->dev, "Only root can read events\n"); - return -EFAULT; + return -EPERM; } /* make sure user buffer can be written */ if (!access_ok(VERIFY_WRITE, buffer, count)) { dev_err(hy_drv_priv->dev, "User buffer can't be written.\n"); - return -EFAULT; + return -EINVAL; } ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock); @@ -143,6 +141,7 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer, if (!e) { if (ret) break; + if (filp->f_flags & O_NONBLOCK) { ret = -EAGAIN; break; @@ -233,7 +232,7 @@ static struct miscdevice hyper_dmabuf_miscdev = { .fops = &hyper_dmabuf_driver_fops, }; -int register_device(void) +static int register_device(void) { int ret = 0; @@ -252,7 +251,7 @@ int register_device(void) return ret; } -void unregister_device(void) +static void unregister_device(void) { dev_info(hy_drv_priv->dev, "hyper_dmabuf: unregister_device() is called\n"); @@ -269,10 +268,8 @@ static int __init hyper_dmabuf_drv_init(void) 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; - } + if (!hy_drv_priv) + return -ENOMEM; ret = register_device(); if (ret < 0) @@ -291,7 +288,6 @@ static int __init hyper_dmabuf_drv_init(void) return -1; } - /* initializing mutexes and a spinlock */ mutex_init(&hy_drv_priv->lock); mutex_lock(&hy_drv_priv->lock); @@ -301,14 +297,14 @@ static int __init hyper_dmabuf_drv_init(void) dev_info(hy_drv_priv->dev, "initializing database for imported/exported dmabufs\n"); - /* device structure initialization */ - /* currently only does work-queue initialization */ hy_drv_priv->work_queue = create_workqueue("hyper_dmabuf_wqueue"); ret = hyper_dmabuf_table_init(); if (ret < 0) { dev_err(hy_drv_priv->dev, "failed to initialize table for exported/imported entries\n"); + mutex_unlock(&hy_drv_priv->lock); + kfree(hy_drv_priv); return ret; } @@ -317,6 +313,8 @@ static int __init hyper_dmabuf_drv_init(void) if (ret < 0) { dev_err(hy_drv_priv->dev, "failed to initialize sysfs\n"); + mutex_unlock(&hy_drv_priv->lock); + kfree(hy_drv_priv); return ret; } #endif @@ -338,7 +336,7 @@ static int __init hyper_dmabuf_drv_init(void) ret = hy_drv_priv->backend_ops->init_comm_env(); if (ret < 0) { dev_dbg(hy_drv_priv->dev, - "failed to initialize comm-env but it will re-attempt.\n"); + "failed to initialize comm-env.\n"); } else { hy_drv_priv->initialized = true; } diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c index a4945af..ae8cb43 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c @@ -37,11 +37,12 @@ #include "hyper_dmabuf_list.h" #include "hyper_dmabuf_event.h" -static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e) +static void hyper_dmabuf_send_event(struct hyper_dmabuf_event *e) { struct hyper_dmabuf_event *oldest; + unsigned long irqflags; - assert_spin_locked(&hy_drv_priv->event_lock); + spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags); /* check current number of event then if it hits the max num allowed * then remove the oldest event in the list @@ -60,6 +61,8 @@ static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e) hy_drv_priv->pending++; wake_up_interruptible(&hy_drv_priv->event_wait); + + spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags); } void hyper_dmabuf_events_release(void) @@ -89,8 +92,6 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid) struct hyper_dmabuf_event *e; struct imported_sgt_info *imported; - unsigned long irqflags; - imported = hyper_dmabuf_find_imported(hid); if (!imported) { @@ -109,11 +110,7 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid) e->event_data.data = (void *)imported->priv; e->event_data.hdr.size = imported->sz_priv; - spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags); - - hyper_dmabuf_send_event_locked(e); - - spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags); + hyper_dmabuf_send_event(e); dev_dbg(hy_drv_priv->dev, "event number = %d :", hy_drv_priv->pending); diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index f9040ed..195cede 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -441,8 +441,10 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) req = kcalloc(1, sizeof(*req), GFP_KERNEL); - if (!req) + if (!req) { + mutex_unlock(&hy_drv_priv->lock); return -ENOMEM; + } hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD, &op[0]); @@ -509,8 +511,10 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data) req = kcalloc(1, sizeof(*req), GFP_KERNEL); - if (!req) + if (!req) { + mutex_unlock(&hy_drv_priv->lock); return -ENOMEM; + } hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 51/60] hyper_dmabuf: missing mutex_unlock and move spinlock Date: Tue, 19 Dec 2017 11:30:07 -0800 Message-ID: <1513711816-2618-51-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 QWRkZWQgbWlzc2luZyBtdXRleF91bmxvY2sgdG8gbWFrZSBzdXJlIG11dGV4IGlzIHVubG9ja2Vk CmJlZm9yZSByZXR1cm5pbmcuCgpBbHNvLCBtb3ZlZCBzcGlubG9jayBsb2NrL3VubG9jayBpbnRv IGh5cGVyX2RtYWJ1Zl9zZW5kX2V2ZW50CmFuZCByZW1vdmUgY2hlY2tpbmcgb24gc3BpbmxvY2sg KHdpdGggYXNzdW1wdGlvbiBjYWxsZXIgZG9lcwp0aGUgc3BpbmxvY2sgaW4gYWR2YW5jZSkgdG8g bWFrZSBpdCBtb3JlIHN0cmFpZ2h0IGZvcndhcmQuCgpUaGlzIHBhdGNoIGluY2x1ZGVzIGEgY291 cGxlIG9mIG1pbm9yIG1vZGlmaWNhdGlvbnMsIGNoYW5naW5nIHR5cGUKb2YgZnVuY3Rpb24gY2Fs bHMgdG8gc3RhdGljIGFuZCBjb3JyZWN0aW5nIHNvbWUgb2YgZXJyb3IgY29kZS4KClNpZ25lZC1v ZmYtYnk6IERvbmd3b24gS2ltIDxkb25nd29uLmtpbUBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy94 ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9kcnYuYyAgIHwgMzggKysrKysrKysrKysrKy0t LS0tLS0tLS0tLS0tCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2V2ZW50 LmMgfCAxNSArKysrKy0tLS0tLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1 Zl9pb2N0bC5jIHwgIDggKysrKy0tCiAzIGZpbGVzIGNoYW5nZWQsIDMwIGluc2VydGlvbnMoKyks IDMxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9o eXBlcl9kbWFidWZfZHJ2LmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVm X2Rydi5jCmluZGV4IDAyM2Q3ZjQuLjc2ZjU3YzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZHJ2LmMKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL2h5cGVyX2RtYWJ1Zl9kcnYuYwpAQCAtNzMsNyArNzMsNyBAQCBzdGF0aWMgdm9pZCBoeXBl cl9kbWFidWZfZm9yY2VfZnJlZShzdHJ1Y3QgZXhwb3J0ZWRfc2d0X2luZm8gKmV4cG9ydGVkLAog CX0KIH0KIAotaW50IGh5cGVyX2RtYWJ1Zl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVj dCBmaWxlICpmaWxwKQorc3RhdGljIGludCBoeXBlcl9kbWFidWZfb3BlbihzdHJ1Y3QgaW5vZGUg Kmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkKIHsKIAlpbnQgcmV0ID0gMDsKIApAQCAtODQsNyAr ODQsNyBAQCBpbnQgaHlwZXJfZG1hYnVmX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0 IGZpbGUgKmZpbHApCiAJcmV0dXJuIHJldDsKIH0KIAotaW50IGh5cGVyX2RtYWJ1Zl9yZWxlYXNl KHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQorc3RhdGljIGludCBoeXBl cl9kbWFidWZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkK IHsKIAloeXBlcl9kbWFidWZfZm9yZWFjaF9leHBvcnRlZChoeXBlcl9kbWFidWZfZm9yY2VfZnJl ZSwgZmlscCk7CiAKQEAgLTkzLDIwICs5MywxOCBAQCBpbnQgaHlwZXJfZG1hYnVmX3JlbGVhc2Uo c3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbHApCiAKICNpZmRlZiBDT05GSUdf SFlQRVJfRE1BQlVGX0VWRU5UX0dFTgogCi11bnNpZ25lZCBpbnQgaHlwZXJfZG1hYnVmX2V2ZW50 X3BvbGwoc3RydWN0IGZpbGUgKmZpbHAsCitzdGF0aWMgdW5zaWduZWQgaW50IGh5cGVyX2RtYWJ1 Zl9ldmVudF9wb2xsKHN0cnVjdCBmaWxlICpmaWxwLAogCQkJCSAgICAgc3RydWN0IHBvbGxfdGFi bGVfc3RydWN0ICp3YWl0KQogewotCXVuc2lnbmVkIGludCBtYXNrID0gMDsKLQogCXBvbGxfd2Fp dChmaWxwLCAmaHlfZHJ2X3ByaXYtPmV2ZW50X3dhaXQsIHdhaXQpOwogCiAJaWYgKCFsaXN0X2Vt cHR5KCZoeV9kcnZfcHJpdi0+ZXZlbnRfbGlzdCkpCi0JCW1hc2sgfD0gUE9MTElOIHwgUE9MTFJE Tk9STTsKKwkJcmV0dXJuIFBPTExJTiB8IFBPTExSRE5PUk07CiAKLQlyZXR1cm4gbWFzazsKKwly ZXR1cm4gMDsKIH0KIAotc3NpemVfdCBoeXBlcl9kbWFidWZfZXZlbnRfcmVhZChzdHJ1Y3QgZmls ZSAqZmlscCwgY2hhciBfX3VzZXIgKmJ1ZmZlciwKK3N0YXRpYyBzc2l6ZV90IGh5cGVyX2RtYWJ1 Zl9ldmVudF9yZWFkKHN0cnVjdCBmaWxlICpmaWxwLCBjaGFyIF9fdXNlciAqYnVmZmVyLAogCQlz aXplX3QgY291bnQsIGxvZmZfdCAqb2Zmc2V0KQogewogCWludCByZXQ7CkBAIC0xMTUsMTQgKzEx MywxNCBAQCBzc2l6ZV90IGh5cGVyX2RtYWJ1Zl9ldmVudF9yZWFkKHN0cnVjdCBmaWxlICpmaWxw LCBjaGFyIF9fdXNlciAqYnVmZmVyLAogCWlmICghY2FwYWJsZShDQVBfREFDX09WRVJSSURFKSkg ewogCQlkZXZfZXJyKGh5X2Rydl9wcml2LT5kZXYsCiAJCQkiT25seSByb290IGNhbiByZWFkIGV2 ZW50c1xuIik7Ci0JCXJldHVybiAtRUZBVUxUOworCQlyZXR1cm4gLUVQRVJNOwogCX0KIAogCS8q IG1ha2Ugc3VyZSB1c2VyIGJ1ZmZlciBjYW4gYmUgd3JpdHRlbiAqLwogCWlmICghYWNjZXNzX29r KFZFUklGWV9XUklURSwgYnVmZmVyLCBjb3VudCkpIHsKIAkJZGV2X2VycihoeV9kcnZfcHJpdi0+ ZGV2LAogCQkJIlVzZXIgYnVmZmVyIGNhbid0IGJlIHdyaXR0ZW4uXG4iKTsKLQkJcmV0dXJuIC1F RkFVTFQ7CisJCXJldHVybiAtRUlOVkFMOwogCX0KIAogCXJldCA9IG11dGV4X2xvY2tfaW50ZXJy dXB0aWJsZSgmaHlfZHJ2X3ByaXYtPmV2ZW50X3JlYWRfbG9jayk7CkBAIC0xNDMsNiArMTQxLDcg QEAgc3NpemVfdCBoeXBlcl9kbWFidWZfZXZlbnRfcmVhZChzdHJ1Y3QgZmlsZSAqZmlscCwgY2hh ciBfX3VzZXIgKmJ1ZmZlciwKIAkJaWYgKCFlKSB7CiAJCQlpZiAocmV0KQogCQkJCWJyZWFrOwor CiAJCQlpZiAoZmlscC0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spIHsKIAkJCQlyZXQgPSAtRUFHQUlO OwogCQkJCWJyZWFrOwpAQCAtMjMzLDcgKzIzMiw3IEBAIHN0YXRpYyBzdHJ1Y3QgbWlzY2Rldmlj ZSBoeXBlcl9kbWFidWZfbWlzY2RldiA9IHsKIAkuZm9wcyA9ICZoeXBlcl9kbWFidWZfZHJpdmVy X2ZvcHMsCiB9OwogCi1pbnQgcmVnaXN0ZXJfZGV2aWNlKHZvaWQpCitzdGF0aWMgaW50IHJlZ2lz dGVyX2RldmljZSh2b2lkKQogewogCWludCByZXQgPSAwOwogCkBAIC0yNTIsNyArMjUxLDcgQEAg aW50IHJlZ2lzdGVyX2RldmljZSh2b2lkKQogCXJldHVybiByZXQ7CiB9CiAKLXZvaWQgdW5yZWdp c3Rlcl9kZXZpY2Uodm9pZCkKK3N0YXRpYyB2b2lkIHVucmVnaXN0ZXJfZGV2aWNlKHZvaWQpCiB7 CiAJZGV2X2luZm8oaHlfZHJ2X3ByaXYtPmRldiwKIAkJImh5cGVyX2RtYWJ1ZjogdW5yZWdpc3Rl cl9kZXZpY2UoKSBpcyBjYWxsZWRcbiIpOwpAQCAtMjY5LDEwICsyNjgsOCBAQCBzdGF0aWMgaW50 IF9faW5pdCBoeXBlcl9kbWFidWZfZHJ2X2luaXQodm9pZCkKIAloeV9kcnZfcHJpdiA9IGtjYWxs b2MoMSwgc2l6ZW9mKHN0cnVjdCBoeXBlcl9kbWFidWZfcHJpdmF0ZSksCiAJCQkgICAgICBHRlBf S0VSTkVMKTsKIAotCWlmICghaHlfZHJ2X3ByaXYpIHsKLQkJcHJpbnRrKEtFUk5fRVJSICJoeXBl cl9kbWFidWY6IEZhaWxlZCB0byBjcmVhdGUgZHJ2XG4iKTsKLQkJcmV0dXJuIC0xOwotCX0KKwlp ZiAoIWh5X2Rydl9wcml2KQorCQlyZXR1cm4gLUVOT01FTTsKIAogCXJldCA9IHJlZ2lzdGVyX2Rl dmljZSgpOwogCWlmIChyZXQgPCAwKQpAQCAtMjkxLDcgKzI4OCw2IEBAIHN0YXRpYyBpbnQgX19p bml0IGh5cGVyX2RtYWJ1Zl9kcnZfaW5pdCh2b2lkKQogCQlyZXR1cm4gLTE7CiAJfQogCi0JLyog aW5pdGlhbGl6aW5nIG11dGV4ZXMgYW5kIGEgc3BpbmxvY2sgKi8KIAltdXRleF9pbml0KCZoeV9k cnZfcHJpdi0+bG9jayk7CiAKIAltdXRleF9sb2NrKCZoeV9kcnZfcHJpdi0+bG9jayk7CkBAIC0z MDEsMTQgKzI5NywxNCBAQCBzdGF0aWMgaW50IF9faW5pdCBoeXBlcl9kbWFidWZfZHJ2X2luaXQo dm9pZCkKIAlkZXZfaW5mbyhoeV9kcnZfcHJpdi0+ZGV2LAogCQkgImluaXRpYWxpemluZyBkYXRh YmFzZSBmb3IgaW1wb3J0ZWQvZXhwb3J0ZWQgZG1hYnVmc1xuIik7CiAKLQkvKiBkZXZpY2Ugc3Ry dWN0dXJlIGluaXRpYWxpemF0aW9uICovCi0JLyogY3VycmVudGx5IG9ubHkgZG9lcyB3b3JrLXF1 ZXVlIGluaXRpYWxpemF0aW9uICovCiAJaHlfZHJ2X3ByaXYtPndvcmtfcXVldWUgPSBjcmVhdGVf d29ya3F1ZXVlKCJoeXBlcl9kbWFidWZfd3F1ZXVlIik7CiAKIAlyZXQgPSBoeXBlcl9kbWFidWZf dGFibGVfaW5pdCgpOwogCWlmIChyZXQgPCAwKSB7CiAJCWRldl9lcnIoaHlfZHJ2X3ByaXYtPmRl diwKIAkJCSJmYWlsZWQgdG8gaW5pdGlhbGl6ZSB0YWJsZSBmb3IgZXhwb3J0ZWQvaW1wb3J0ZWQg ZW50cmllc1xuIik7CisJCW11dGV4X3VubG9jaygmaHlfZHJ2X3ByaXYtPmxvY2spOworCQlrZnJl ZShoeV9kcnZfcHJpdik7CiAJCXJldHVybiByZXQ7CiAJfQogCkBAIC0zMTcsNiArMzEzLDggQEAg c3RhdGljIGludCBfX2luaXQgaHlwZXJfZG1hYnVmX2Rydl9pbml0KHZvaWQpCiAJaWYgKHJldCA8 IDApIHsKIAkJZGV2X2VycihoeV9kcnZfcHJpdi0+ZGV2LAogCQkJImZhaWxlZCB0byBpbml0aWFs aXplIHN5c2ZzXG4iKTsKKwkJbXV0ZXhfdW5sb2NrKCZoeV9kcnZfcHJpdi0+bG9jayk7CisJCWtm cmVlKGh5X2Rydl9wcml2KTsKIAkJcmV0dXJuIHJldDsKIAl9CiAjZW5kaWYKQEAgLTMzOCw3ICsz MzYsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBoeXBlcl9kbWFidWZfZHJ2X2luaXQodm9pZCkKIAly ZXQgPSBoeV9kcnZfcHJpdi0+YmFja2VuZF9vcHMtPmluaXRfY29tbV9lbnYoKTsKIAlpZiAocmV0 IDwgMCkgewogCQlkZXZfZGJnKGh5X2Rydl9wcml2LT5kZXYsCi0JCQkiZmFpbGVkIHRvIGluaXRp YWxpemUgY29tbS1lbnYgYnV0IGl0IHdpbGwgcmUtYXR0ZW1wdC5cbiIpOworCQkJImZhaWxlZCB0 byBpbml0aWFsaXplIGNvbW0tZW52LlxuIik7CiAJfSBlbHNlIHsKIAkJaHlfZHJ2X3ByaXYtPmlu aXRpYWxpemVkID0gdHJ1ZTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX2V2ZW50LmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJf ZG1hYnVmX2V2ZW50LmMKaW5kZXggYTQ5NDVhZi4uYWU4Y2I0MyAxMDA2NDQKLS0tIGEvZHJpdmVy cy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9ldmVudC5jCisrKyBiL2RyaXZlcnMveGVu L2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfZXZlbnQuYwpAQCAtMzcsMTEgKzM3LDEyIEBACiAj aW5jbHVkZSAiaHlwZXJfZG1hYnVmX2xpc3QuaCIKICNpbmNsdWRlICJoeXBlcl9kbWFidWZfZXZl bnQuaCIKIAotc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX3NlbmRfZXZlbnRfbG9ja2VkKHN0cnVj dCBoeXBlcl9kbWFidWZfZXZlbnQgKmUpCitzdGF0aWMgdm9pZCBoeXBlcl9kbWFidWZfc2VuZF9l dmVudChzdHJ1Y3QgaHlwZXJfZG1hYnVmX2V2ZW50ICplKQogewogCXN0cnVjdCBoeXBlcl9kbWFi dWZfZXZlbnQgKm9sZGVzdDsKKwl1bnNpZ25lZCBsb25nIGlycWZsYWdzOwogCi0JYXNzZXJ0X3Nw aW5fbG9ja2VkKCZoeV9kcnZfcHJpdi0+ZXZlbnRfbG9jayk7CisJc3Bpbl9sb2NrX2lycXNhdmUo Jmh5X2Rydl9wcml2LT5ldmVudF9sb2NrLCBpcnFmbGFncyk7CiAKIAkvKiBjaGVjayBjdXJyZW50 IG51bWJlciBvZiBldmVudCB0aGVuIGlmIGl0IGhpdHMgdGhlIG1heCBudW0gYWxsb3dlZAogCSAq IHRoZW4gcmVtb3ZlIHRoZSBvbGRlc3QgZXZlbnQgaW4gdGhlIGxpc3QKQEAgLTYwLDYgKzYxLDgg QEAgc3RhdGljIHZvaWQgaHlwZXJfZG1hYnVmX3NlbmRfZXZlbnRfbG9ja2VkKHN0cnVjdCBoeXBl cl9kbWFidWZfZXZlbnQgKmUpCiAJaHlfZHJ2X3ByaXYtPnBlbmRpbmcrKzsKIAogCXdha2VfdXBf aW50ZXJydXB0aWJsZSgmaHlfZHJ2X3ByaXYtPmV2ZW50X3dhaXQpOworCisJc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSgmaHlfZHJ2X3ByaXYtPmV2ZW50X2xvY2ssIGlycWZsYWdzKTsKIH0KIAogdm9p ZCBoeXBlcl9kbWFidWZfZXZlbnRzX3JlbGVhc2Uodm9pZCkKQEAgLTg5LDggKzkyLDYgQEAgaW50 IGh5cGVyX2RtYWJ1Zl9pbXBvcnRfZXZlbnQoaHlwZXJfZG1hYnVmX2lkX3QgaGlkKQogCXN0cnVj dCBoeXBlcl9kbWFidWZfZXZlbnQgKmU7CiAJc3RydWN0IGltcG9ydGVkX3NndF9pbmZvICppbXBv cnRlZDsKIAotCXVuc2lnbmVkIGxvbmcgaXJxZmxhZ3M7Ci0KIAlpbXBvcnRlZCA9IGh5cGVyX2Rt YWJ1Zl9maW5kX2ltcG9ydGVkKGhpZCk7CiAKIAlpZiAoIWltcG9ydGVkKSB7CkBAIC0xMDksMTEg KzExMCw3IEBAIGludCBoeXBlcl9kbWFidWZfaW1wb3J0X2V2ZW50KGh5cGVyX2RtYWJ1Zl9pZF90 IGhpZCkKIAllLT5ldmVudF9kYXRhLmRhdGEgPSAodm9pZCAqKWltcG9ydGVkLT5wcml2OwogCWUt PmV2ZW50X2RhdGEuaGRyLnNpemUgPSBpbXBvcnRlZC0+c3pfcHJpdjsKIAotCXNwaW5fbG9ja19p cnFzYXZlKCZoeV9kcnZfcHJpdi0+ZXZlbnRfbG9jaywgaXJxZmxhZ3MpOwotCi0JaHlwZXJfZG1h YnVmX3NlbmRfZXZlbnRfbG9ja2VkKGUpOwotCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaHlf ZHJ2X3ByaXYtPmV2ZW50X2xvY2ssIGlycWZsYWdzKTsKKwloeXBlcl9kbWFidWZfc2VuZF9ldmVu dChlKTsKIAogCWRldl9kYmcoaHlfZHJ2X3ByaXYtPmRldiwKIAkJImV2ZW50IG51bWJlciA9ICVk IDoiLCBoeV9kcnZfcHJpdi0+cGVuZGluZyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9oeXBl cl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMgYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYv aHlwZXJfZG1hYnVmX2lvY3RsLmMKaW5kZXggZjkwNDBlZC4uMTk1Y2VkZSAxMDA2NDQKLS0tIGEv ZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jCisrKyBiL2RyaXZl cnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYwpAQCAtNDQxLDggKzQ0MSwx MCBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfZmRfaW9jdGwoc3RydWN0IGZpbGUg KmZpbHAsIHZvaWQgKmRhdGEpCiAKIAlyZXEgPSBrY2FsbG9jKDEsIHNpemVvZigqcmVxKSwgR0ZQ X0tFUk5FTCk7CiAKLQlpZiAoIXJlcSkKKwlpZiAoIXJlcSkgeworCQltdXRleF91bmxvY2soJmh5 X2Rydl9wcml2LT5sb2NrKTsKIAkJcmV0dXJuIC1FTk9NRU07CisJfQogCiAJaHlwZXJfZG1hYnVm X2NyZWF0ZV9yZXEocmVxLCBIWVBFUl9ETUFCVUZfRVhQT1JUX0ZELCAmb3BbMF0pOwogCkBAIC01 MDksOCArNTExLDEwIEBAIHN0YXRpYyBpbnQgaHlwZXJfZG1hYnVmX2V4cG9ydF9mZF9pb2N0bChz dHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAqZGF0YSkKIAogCQkJcmVxID0ga2NhbGxvYygxLCBzaXpl b2YoKnJlcSksIEdGUF9LRVJORUwpOwogCi0JCQlpZiAoIXJlcSkKKwkJCWlmICghcmVxKSB7CisJ CQkJbXV0ZXhfdW5sb2NrKCZoeV9kcnZfcHJpdi0+bG9jayk7CiAJCQkJcmV0dXJuIC1FTk9NRU07 CisJCQl9CiAKIAkJCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVxKHJlcSwKIAkJCQkJCUhZUEVSX0RN QUJVRl9FWFBPUlRfRkRfRkFJTEVELAotLSAKMi43LjQKCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZl bEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxt YW4vbGlzdGluZm8veGVuLWRldmVs