From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754618AbcAOO4P (ORCPT ); Fri, 15 Jan 2016 09:56:15 -0500 Received: from mail-yk0-f180.google.com ([209.85.160.180]:33331 "EHLO mail-yk0-f180.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754560AbcAOO4K (ORCPT ); Fri, 15 Jan 2016 09:56:10 -0500 From: Gustavo Padovan To: Greg Kroah-Hartman Cc: linux-kernel@vger.kernel.org, devel@driverdev.osuosl.org, dri-devel@lists.freedesktop.org, daniels@collabora.com, =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Riley Andrews , Daniel Vetter , Rob Clark , Greg Hackmann , John Harrison , Maarten Lankhorst , Gustavo Padovan Subject: [RFC 07/29] staging/android: move sw_sync file to debugfs file Date: Fri, 15 Jan 2016 12:55:17 -0200 Message-Id: <1452869739-3304-8-git-send-email-gustavo@padovan.org> X-Mailer: git-send-email 2.5.0 In-Reply-To: <1452869739-3304-1-git-send-email-gustavo@padovan.org> References: <1452869739-3304-1-git-send-email-gustavo@padovan.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Gustavo Padovan This remove CONFIG_SW_SYNC_USER and instead compile the sw_sync file into debugpfs under /sync/sw_sync. Signed-off-by: Gustavo Padovan --- drivers/staging/android/Kconfig | 9 --- drivers/staging/android/sw_sync.c | 129 ----------------------------------- drivers/staging/android/sync_debug.c | 118 +++++++++++++++++++++++++++++++- 3 files changed, 117 insertions(+), 139 deletions(-) diff --git a/drivers/staging/android/Kconfig b/drivers/staging/android/Kconfig index 42b1512..bd90d20 100644 --- a/drivers/staging/android/Kconfig +++ b/drivers/staging/android/Kconfig @@ -57,15 +57,6 @@ config SW_SYNC synchronization. Useful when there is no hardware primitive backing the synchronization. -config SW_SYNC_USER - bool "Userspace API for SW_SYNC" - default n - depends on SW_SYNC - ---help--- - Provides a user space API to the sw sync object. - *WARNING* improper use of this can result in deadlocking kernel - drivers from userspace. - source "drivers/staging/android/ion/Kconfig" endif # if ANDROID diff --git a/drivers/staging/android/sw_sync.c b/drivers/staging/android/sw_sync.c index 566dcdc..f491dbc 100644 --- a/drivers/staging/android/sw_sync.c +++ b/drivers/staging/android/sw_sync.c @@ -102,132 +102,3 @@ void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc) sync_timeline_signal(&obj->obj); } EXPORT_SYMBOL(sw_sync_timeline_inc); - -#ifdef CONFIG_SW_SYNC_USER -/* *WARNING* - * - * improper use of this can result in deadlocking kernel drivers from userspace. - */ - -/* opening sw_sync create a new sync obj */ -static int sw_sync_open(struct inode *inode, struct file *file) -{ - struct sw_sync_timeline *obj; - char task_comm[TASK_COMM_LEN]; - - get_task_comm(task_comm, current); - - obj = sw_sync_timeline_create(task_comm); - if (!obj) - return -ENOMEM; - - file->private_data = obj; - - return 0; -} - -static int sw_sync_release(struct inode *inode, struct file *file) -{ - struct sw_sync_timeline *obj = file->private_data; - - sync_timeline_destroy(&obj->obj); - return 0; -} - -static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, - unsigned long arg) -{ - int fd = get_unused_fd_flags(O_CLOEXEC); - int err; - struct sync_pt *pt; - struct sync_fence *fence; - struct sw_sync_create_fence_data data; - - if (fd < 0) - return fd; - - if (copy_from_user(&data, (void __user *)arg, sizeof(data))) { - err = -EFAULT; - goto err; - } - - pt = sw_sync_pt_create(obj, data.value); - if (!pt) { - err = -ENOMEM; - goto err; - } - - data.name[sizeof(data.name) - 1] = '\0'; - fence = sync_fence_create(data.name, pt); - if (!fence) { - sync_pt_free(pt); - err = -ENOMEM; - goto err; - } - - data.fence = fd; - if (copy_to_user((void __user *)arg, &data, sizeof(data))) { - sync_fence_put(fence); - err = -EFAULT; - goto err; - } - - sync_fence_install(fence, fd); - - return 0; - -err: - put_unused_fd(fd); - return err; -} - -static long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg) -{ - u32 value; - - if (copy_from_user(&value, (void __user *)arg, sizeof(value))) - return -EFAULT; - - sw_sync_timeline_inc(obj, value); - - return 0; -} - -static long sw_sync_ioctl(struct file *file, unsigned int cmd, - unsigned long arg) -{ - struct sw_sync_timeline *obj = file->private_data; - - switch (cmd) { - case SW_SYNC_IOC_CREATE_FENCE: - return sw_sync_ioctl_create_fence(obj, arg); - - case SW_SYNC_IOC_INC: - return sw_sync_ioctl_inc(obj, arg); - - default: - return -ENOTTY; - } -} - -static const struct file_operations sw_sync_fops = { - .owner = THIS_MODULE, - .open = sw_sync_open, - .release = sw_sync_release, - .unlocked_ioctl = sw_sync_ioctl, - .compat_ioctl = sw_sync_ioctl, -}; - -static struct miscdevice sw_sync_dev = { - .minor = MISC_DYNAMIC_MINOR, - .name = "sw_sync", - .fops = &sw_sync_fops, -}; - -static int __init sw_sync_device_init(void) -{ - return misc_register(&sw_sync_dev); -} -device_initcall(sw_sync_device_init); - -#endif /* CONFIG_SW_SYNC_USER */ diff --git a/drivers/staging/android/sync_debug.c b/drivers/staging/android/sync_debug.c index 86d683b..0a2df3f 100644 --- a/drivers/staging/android/sync_debug.c +++ b/drivers/staging/android/sync_debug.c @@ -27,7 +27,7 @@ #include #include #include -#include "sync.h" +#include "sw_sync.h" #ifdef CONFIG_DEBUG_FS @@ -223,11 +223,127 @@ static const struct file_operations sync_info_debugfs_fops = { .release = single_release, }; +/* + * *WARNING* + * + * improper use of this can result in deadlocking kernel drivers from userspace. + */ + +/* opening sw_sync create a new sync obj */ +static int sw_sync_debugfs_open(struct inode *inode, struct file *file) +{ + struct sw_sync_timeline *obj; + char task_comm[TASK_COMM_LEN]; + + get_task_comm(task_comm, current); + + obj = sw_sync_timeline_create(task_comm); + if (!obj) + return -ENOMEM; + + file->private_data = obj; + + return 0; +} + +static int sw_sync_debugfs_release(struct inode *inode, struct file *file) +{ + struct sw_sync_timeline *obj = file->private_data; + + sync_timeline_destroy(&obj->obj); + return 0; +} + +static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, + unsigned long arg) +{ + int fd = get_unused_fd_flags(O_CLOEXEC); + int err; + struct sync_pt *pt; + struct sync_fence *fence; + struct sw_sync_create_fence_data data; + + if (fd < 0) + return fd; + + if (copy_from_user(&data, (void __user *)arg, sizeof(data))) { + err = -EFAULT; + goto err; + } + + pt = sw_sync_pt_create(obj, data.value); + if (!pt) { + err = -ENOMEM; + goto err; + } + + data.name[sizeof(data.name) - 1] = '\0'; + fence = sync_fence_create(data.name, pt); + if (!fence) { + sync_pt_free(pt); + err = -ENOMEM; + goto err; + } + + data.fence = fd; + if (copy_to_user((void __user *)arg, &data, sizeof(data))) { + sync_fence_put(fence); + err = -EFAULT; + goto err; + } + + sync_fence_install(fence, fd); + + return 0; + +err: + put_unused_fd(fd); + return err; +} + +static long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg) +{ + u32 value; + + if (copy_from_user(&value, (void __user *)arg, sizeof(value))) + return -EFAULT; + + sw_sync_timeline_inc(obj, value); + + return 0; +} + +static long sw_sync_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + struct sw_sync_timeline *obj = file->private_data; + + switch (cmd) { + case SW_SYNC_IOC_CREATE_FENCE: + return sw_sync_ioctl_create_fence(obj, arg); + + case SW_SYNC_IOC_INC: + return sw_sync_ioctl_inc(obj, arg); + + default: + return -ENOTTY; + } +} + +static const struct file_operations sw_sync_debugfs_fops = { + .open = sw_sync_debugfs_open, + .release = sw_sync_debugfs_release, + .unlocked_ioctl = sw_sync_ioctl, + .compat_ioctl = sw_sync_ioctl, +}; + static __init int sync_debugfs_init(void) { dbgfs = debugfs_create_dir("sync", NULL); debugfs_create_file("info", 0444, dbgfs, NULL, &sync_info_debugfs_fops); + debugfs_create_file("sw_sync", 0644, dbgfs, NULL, + &sw_sync_debugfs_fops); return 0; } -- 2.5.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: [RFC 07/29] staging/android: move sw_sync file to debugfs file Date: Fri, 15 Jan 2016 12:55:17 -0200 Message-ID: <1452869739-3304-8-git-send-email-gustavo@padovan.org> References: <1452869739-3304-1-git-send-email-gustavo@padovan.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-yk0-f175.google.com (mail-yk0-f175.google.com [209.85.160.175]) by gabe.freedesktop.org (Postfix) with ESMTPS id AFA857A0E7 for ; Fri, 15 Jan 2016 06:56:10 -0800 (PST) Received: by mail-yk0-f175.google.com with SMTP id a85so467165564ykb.1 for ; Fri, 15 Jan 2016 06:56:10 -0800 (PST) In-Reply-To: <1452869739-3304-1-git-send-email-gustavo@padovan.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Greg Kroah-Hartman Cc: devel@driverdev.osuosl.org, daniels@collabora.com, Daniel Vetter , Riley Andrews , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Maarten Lankhorst , Gustavo Padovan , John Harrison List-Id: dri-devel@lists.freedesktop.org RnJvbTogR3VzdGF2byBQYWRvdmFuIDxndXN0YXZvLnBhZG92YW5AY29sbGFib3JhLmNvLnVrPgoK VGhpcyByZW1vdmUgQ09ORklHX1NXX1NZTkNfVVNFUiBhbmQgaW5zdGVhZCBjb21waWxlIHRoZSBz d19zeW5jIGZpbGUgaW50bwpkZWJ1Z3BmcyB1bmRlciA8ZGVidWdmcz4vc3luYy9zd19zeW5jLgoK U2lnbmVkLW9mZi1ieTogR3VzdGF2byBQYWRvdmFuIDxndXN0YXZvLnBhZG92YW5AY29sbGFib3Jh LmNvLnVrPgotLS0KIGRyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL0tjb25maWcgICAgICB8ICAgOSAt LS0KIGRyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N3X3N5bmMuYyAgICB8IDEyOSAtLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luY19k ZWJ1Zy5jIHwgMTE4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiAzIGZpbGVzIGNo YW5nZWQsIDExNyBpbnNlcnRpb25zKCspLCAxMzkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvS2NvbmZpZyBiL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lk L0tjb25maWcKaW5kZXggNDJiMTUxMi4uYmQ5MGQyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFn aW5nL2FuZHJvaWQvS2NvbmZpZworKysgYi9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9LY29uZmln CkBAIC01NywxNSArNTcsNiBAQCBjb25maWcgU1dfU1lOQwogCSAgc3luY2hyb25pemF0aW9uLiAg VXNlZnVsIHdoZW4gdGhlcmUgaXMgbm8gaGFyZHdhcmUgcHJpbWl0aXZlIGJhY2tpbmcKIAkgIHRo ZSBzeW5jaHJvbml6YXRpb24uCiAKLWNvbmZpZyBTV19TWU5DX1VTRVIKLQlib29sICJVc2Vyc3Bh Y2UgQVBJIGZvciBTV19TWU5DIgotCWRlZmF1bHQgbgotCWRlcGVuZHMgb24gU1dfU1lOQwotCS0t LWhlbHAtLS0KLQkgIFByb3ZpZGVzIGEgdXNlciBzcGFjZSBBUEkgdG8gdGhlIHN3IHN5bmMgb2Jq ZWN0LgotCSAgKldBUk5JTkcqIGltcHJvcGVyIHVzZSBvZiB0aGlzIGNhbiByZXN1bHQgaW4gZGVh ZGxvY2tpbmcga2VybmVsCi0JICBkcml2ZXJzIGZyb20gdXNlcnNwYWNlLgotCiBzb3VyY2UgImRy aXZlcnMvc3RhZ2luZy9hbmRyb2lkL2lvbi9LY29uZmlnIgogCiBlbmRpZiAjIGlmIEFORFJPSUQK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N3X3N5bmMuYyBiL2RyaXZlcnMv c3RhZ2luZy9hbmRyb2lkL3N3X3N5bmMuYwppbmRleCA1NjZkY2RjLi5mNDkxZGJjIDEwMDY0NAot LS0gYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zd19zeW5jLmMKKysrIGIvZHJpdmVycy9zdGFn aW5nL2FuZHJvaWQvc3dfc3luYy5jCkBAIC0xMDIsMTMyICsxMDIsMyBAQCB2b2lkIHN3X3N5bmNf dGltZWxpbmVfaW5jKHN0cnVjdCBzd19zeW5jX3RpbWVsaW5lICpvYmosIHUzMiBpbmMpCiAJc3lu Y190aW1lbGluZV9zaWduYWwoJm9iai0+b2JqKTsKIH0KIEVYUE9SVF9TWU1CT0woc3dfc3luY190 aW1lbGluZV9pbmMpOwotCi0jaWZkZWYgQ09ORklHX1NXX1NZTkNfVVNFUgotLyogKldBUk5JTkcq Ci0gKgotICogaW1wcm9wZXIgdXNlIG9mIHRoaXMgY2FuIHJlc3VsdCBpbiBkZWFkbG9ja2luZyBr ZXJuZWwgZHJpdmVycyBmcm9tIHVzZXJzcGFjZS4KLSAqLwotCi0vKiBvcGVuaW5nIHN3X3N5bmMg Y3JlYXRlIGEgbmV3IHN5bmMgb2JqICovCi1zdGF0aWMgaW50IHN3X3N5bmNfb3BlbihzdHJ1Y3Qg aW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKLXsKLQlzdHJ1Y3Qgc3dfc3luY190aW1l bGluZSAqb2JqOwotCWNoYXIgdGFza19jb21tW1RBU0tfQ09NTV9MRU5dOwotCi0JZ2V0X3Rhc2tf Y29tbSh0YXNrX2NvbW0sIGN1cnJlbnQpOwotCi0Jb2JqID0gc3dfc3luY190aW1lbGluZV9jcmVh dGUodGFza19jb21tKTsKLQlpZiAoIW9iaikKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlmaWxlLT5w cml2YXRlX2RhdGEgPSBvYmo7Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCBzd19zeW5j X3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCi17Ci0Jc3Ry dWN0IHN3X3N5bmNfdGltZWxpbmUgKm9iaiA9IGZpbGUtPnByaXZhdGVfZGF0YTsKLQotCXN5bmNf dGltZWxpbmVfZGVzdHJveSgmb2JqLT5vYmopOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgbG9u ZyBzd19zeW5jX2lvY3RsX2NyZWF0ZV9mZW5jZShzdHJ1Y3Qgc3dfc3luY190aW1lbGluZSAqb2Jq LAotCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIGFyZykKLXsKLQlpbnQgZmQgPSBnZXRfdW51c2Vk X2ZkX2ZsYWdzKE9fQ0xPRVhFQyk7Ci0JaW50IGVycjsKLQlzdHJ1Y3Qgc3luY19wdCAqcHQ7Ci0J c3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlOwotCXN0cnVjdCBzd19zeW5jX2NyZWF0ZV9mZW5jZV9k YXRhIGRhdGE7Ci0KLQlpZiAoZmQgPCAwKQotCQlyZXR1cm4gZmQ7Ci0KLQlpZiAoY29weV9mcm9t X3VzZXIoJmRhdGEsICh2b2lkIF9fdXNlciAqKWFyZywgc2l6ZW9mKGRhdGEpKSkgewotCQllcnIg PSAtRUZBVUxUOwotCQlnb3RvIGVycjsKLQl9Ci0KLQlwdCA9IHN3X3N5bmNfcHRfY3JlYXRlKG9i aiwgZGF0YS52YWx1ZSk7Ci0JaWYgKCFwdCkgewotCQllcnIgPSAtRU5PTUVNOwotCQlnb3RvIGVy cjsKLQl9Ci0KLQlkYXRhLm5hbWVbc2l6ZW9mKGRhdGEubmFtZSkgLSAxXSA9ICdcMCc7Ci0JZmVu Y2UgPSBzeW5jX2ZlbmNlX2NyZWF0ZShkYXRhLm5hbWUsIHB0KTsKLQlpZiAoIWZlbmNlKSB7Ci0J CXN5bmNfcHRfZnJlZShwdCk7Ci0JCWVyciA9IC1FTk9NRU07Ci0JCWdvdG8gZXJyOwotCX0KLQot CWRhdGEuZmVuY2UgPSBmZDsKLQlpZiAoY29weV90b191c2VyKCh2b2lkIF9fdXNlciAqKWFyZywg JmRhdGEsIHNpemVvZihkYXRhKSkpIHsKLQkJc3luY19mZW5jZV9wdXQoZmVuY2UpOwotCQllcnIg PSAtRUZBVUxUOwotCQlnb3RvIGVycjsKLQl9Ci0KLQlzeW5jX2ZlbmNlX2luc3RhbGwoZmVuY2Us IGZkKTsKLQotCXJldHVybiAwOwotCi1lcnI6Ci0JcHV0X3VudXNlZF9mZChmZCk7Ci0JcmV0dXJu IGVycjsKLX0KLQotc3RhdGljIGxvbmcgc3dfc3luY19pb2N0bF9pbmMoc3RydWN0IHN3X3N5bmNf dGltZWxpbmUgKm9iaiwgdW5zaWduZWQgbG9uZyBhcmcpCi17Ci0JdTMyIHZhbHVlOwotCi0JaWYg KGNvcHlfZnJvbV91c2VyKCZ2YWx1ZSwgKHZvaWQgX191c2VyICopYXJnLCBzaXplb2YodmFsdWUp KSkKLQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQlzd19zeW5jX3RpbWVsaW5lX2luYyhvYmosIHZhbHVl KTsKLQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgbG9uZyBzd19zeW5jX2lvY3RsKHN0cnVjdCBm aWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAotCQkJICB1bnNpZ25lZCBsb25nIGFyZykKLXsK LQlzdHJ1Y3Qgc3dfc3luY190aW1lbGluZSAqb2JqID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwotCi0J c3dpdGNoIChjbWQpIHsKLQljYXNlIFNXX1NZTkNfSU9DX0NSRUFURV9GRU5DRToKLQkJcmV0dXJu IHN3X3N5bmNfaW9jdGxfY3JlYXRlX2ZlbmNlKG9iaiwgYXJnKTsKLQotCWNhc2UgU1dfU1lOQ19J T0NfSU5DOgotCQlyZXR1cm4gc3dfc3luY19pb2N0bF9pbmMob2JqLCBhcmcpOwotCi0JZGVmYXVs dDoKLQkJcmV0dXJuIC1FTk9UVFk7Ci0JfQotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVf b3BlcmF0aW9ucyBzd19zeW5jX2ZvcHMgPSB7Ci0JLm93bmVyID0gVEhJU19NT0RVTEUsCi0JLm9w ZW4gPSBzd19zeW5jX29wZW4sCi0JLnJlbGVhc2UgPSBzd19zeW5jX3JlbGVhc2UsCi0JLnVubG9j a2VkX2lvY3RsID0gc3dfc3luY19pb2N0bCwKLQkuY29tcGF0X2lvY3RsID0gc3dfc3luY19pb2N0 bCwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgbWlzY2RldmljZSBzd19zeW5jX2RldiA9IHsKLQkubWlu b3IJPSBNSVNDX0RZTkFNSUNfTUlOT1IsCi0JLm5hbWUJPSAic3dfc3luYyIsCi0JLmZvcHMJPSAm c3dfc3luY19mb3BzLAotfTsKLQotc3RhdGljIGludCBfX2luaXQgc3dfc3luY19kZXZpY2VfaW5p dCh2b2lkKQotewotCXJldHVybiBtaXNjX3JlZ2lzdGVyKCZzd19zeW5jX2Rldik7Ci19Ci1kZXZp Y2VfaW5pdGNhbGwoc3dfc3luY19kZXZpY2VfaW5pdCk7Ci0KLSNlbmRpZiAvKiBDT05GSUdfU1df U1lOQ19VU0VSICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jX2Rl YnVnLmMgYi9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jX2RlYnVnLmMKaW5kZXggODZkNjgz Yi4uMGEyZGYzZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luY19kZWJ1 Zy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmNfZGVidWcuYwpAQCAtMjcsNyAr MjcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KICNpbmNsdWRlIDxsaW51eC9hbm9u X2lub2Rlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3RpbWU2NC5oPgotI2luY2x1ZGUgInN5bmMuaCIK KyNpbmNsdWRlICJzd19zeW5jLmgiCiAKICNpZmRlZiBDT05GSUdfREVCVUdfRlMKIApAQCAtMjIz LDExICsyMjMsMTI3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHN5bmNf aW5mb19kZWJ1Z2ZzX2ZvcHMgPSB7CiAJLnJlbGVhc2UgICAgICAgID0gc2luZ2xlX3JlbGVhc2Us CiB9OwogCisvKgorICogKldBUk5JTkcqCisgKgorICogaW1wcm9wZXIgdXNlIG9mIHRoaXMgY2Fu IHJlc3VsdCBpbiBkZWFkbG9ja2luZyBrZXJuZWwgZHJpdmVycyBmcm9tIHVzZXJzcGFjZS4KKyAq LworCisvKiBvcGVuaW5nIHN3X3N5bmMgY3JlYXRlIGEgbmV3IHN5bmMgb2JqICovCitzdGF0aWMg aW50IHN3X3N5bmNfZGVidWdmc19vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxl ICpmaWxlKQoreworCXN0cnVjdCBzd19zeW5jX3RpbWVsaW5lICpvYmo7CisJY2hhciB0YXNrX2Nv bW1bVEFTS19DT01NX0xFTl07CisKKwlnZXRfdGFza19jb21tKHRhc2tfY29tbSwgY3VycmVudCk7 CisKKwlvYmogPSBzd19zeW5jX3RpbWVsaW5lX2NyZWF0ZSh0YXNrX2NvbW0pOworCWlmICghb2Jq KQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZpbGUtPnByaXZhdGVfZGF0YSA9IG9iajsKKworCXJl dHVybiAwOworfQorCitzdGF0aWMgaW50IHN3X3N5bmNfZGVidWdmc19yZWxlYXNlKHN0cnVjdCBp bm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXN0cnVjdCBzd19zeW5jX3RpbWVs aW5lICpvYmogPSBmaWxlLT5wcml2YXRlX2RhdGE7CisKKwlzeW5jX3RpbWVsaW5lX2Rlc3Ryb3ko Jm9iai0+b2JqKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGxvbmcgc3dfc3luY19pb2N0bF9j cmVhdGVfZmVuY2Uoc3RydWN0IHN3X3N5bmNfdGltZWxpbmUgKm9iaiwKKwkJCQkgICAgICAgdW5z aWduZWQgbG9uZyBhcmcpCit7CisJaW50IGZkID0gZ2V0X3VudXNlZF9mZF9mbGFncyhPX0NMT0VY RUMpOworCWludCBlcnI7CisJc3RydWN0IHN5bmNfcHQgKnB0OworCXN0cnVjdCBzeW5jX2ZlbmNl ICpmZW5jZTsKKwlzdHJ1Y3Qgc3dfc3luY19jcmVhdGVfZmVuY2VfZGF0YSBkYXRhOworCisJaWYg KGZkIDwgMCkKKwkJcmV0dXJuIGZkOworCisJaWYgKGNvcHlfZnJvbV91c2VyKCZkYXRhLCAodm9p ZCBfX3VzZXIgKilhcmcsIHNpemVvZihkYXRhKSkpIHsKKwkJZXJyID0gLUVGQVVMVDsKKwkJZ290 byBlcnI7CisJfQorCisJcHQgPSBzd19zeW5jX3B0X2NyZWF0ZShvYmosIGRhdGEudmFsdWUpOwor CWlmICghcHQpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBlcnI7CisJfQorCisJZGF0YS5u YW1lW3NpemVvZihkYXRhLm5hbWUpIC0gMV0gPSAnXDAnOworCWZlbmNlID0gc3luY19mZW5jZV9j cmVhdGUoZGF0YS5uYW1lLCBwdCk7CisJaWYgKCFmZW5jZSkgeworCQlzeW5jX3B0X2ZyZWUocHQp OworCQllcnIgPSAtRU5PTUVNOworCQlnb3RvIGVycjsKKwl9CisKKwlkYXRhLmZlbmNlID0gZmQ7 CisJaWYgKGNvcHlfdG9fdXNlcigodm9pZCBfX3VzZXIgKilhcmcsICZkYXRhLCBzaXplb2YoZGF0 YSkpKSB7CisJCXN5bmNfZmVuY2VfcHV0KGZlbmNlKTsKKwkJZXJyID0gLUVGQVVMVDsKKwkJZ290 byBlcnI7CisJfQorCisJc3luY19mZW5jZV9pbnN0YWxsKGZlbmNlLCBmZCk7CisKKwlyZXR1cm4g MDsKKworZXJyOgorCXB1dF91bnVzZWRfZmQoZmQpOworCXJldHVybiBlcnI7Cit9CisKK3N0YXRp YyBsb25nIHN3X3N5bmNfaW9jdGxfaW5jKHN0cnVjdCBzd19zeW5jX3RpbWVsaW5lICpvYmosIHVu c2lnbmVkIGxvbmcgYXJnKQoreworCXUzMiB2YWx1ZTsKKworCWlmIChjb3B5X2Zyb21fdXNlcigm dmFsdWUsICh2b2lkIF9fdXNlciAqKWFyZywgc2l6ZW9mKHZhbHVlKSkpCisJCXJldHVybiAtRUZB VUxUOworCisJc3dfc3luY190aW1lbGluZV9pbmMob2JqLCB2YWx1ZSk7CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIGxvbmcgc3dfc3luY19pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWdu ZWQgaW50IGNtZCwKKwkJCSAgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3RydWN0IHN3X3N5bmNf dGltZWxpbmUgKm9iaiA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKworCXN3aXRjaCAoY21kKSB7CisJ Y2FzZSBTV19TWU5DX0lPQ19DUkVBVEVfRkVOQ0U6CisJCXJldHVybiBzd19zeW5jX2lvY3RsX2Ny ZWF0ZV9mZW5jZShvYmosIGFyZyk7CisKKwljYXNlIFNXX1NZTkNfSU9DX0lOQzoKKwkJcmV0dXJu IHN3X3N5bmNfaW9jdGxfaW5jKG9iaiwgYXJnKTsKKworCWRlZmF1bHQ6CisJCXJldHVybiAtRU5P VFRZOworCX0KK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgc3dfc3lu Y19kZWJ1Z2ZzX2ZvcHMgPSB7CisJLm9wZW4gICAgICAgICAgID0gc3dfc3luY19kZWJ1Z2ZzX29w ZW4sCisJLnJlbGVhc2UgICAgICAgID0gc3dfc3luY19kZWJ1Z2ZzX3JlbGVhc2UsCisJLnVubG9j a2VkX2lvY3RsID0gc3dfc3luY19pb2N0bCwKKwkuY29tcGF0X2lvY3RsID0gc3dfc3luY19pb2N0 bCwKK307CisKIHN0YXRpYyBfX2luaXQgaW50IHN5bmNfZGVidWdmc19pbml0KHZvaWQpCiB7CiAJ ZGJnZnMgPSBkZWJ1Z2ZzX2NyZWF0ZV9kaXIoInN5bmMiLCBOVUxMKTsKIAogCWRlYnVnZnNfY3Jl YXRlX2ZpbGUoImluZm8iLCAwNDQ0LCBkYmdmcywgTlVMTCwgJnN5bmNfaW5mb19kZWJ1Z2ZzX2Zv cHMpOworCWRlYnVnZnNfY3JlYXRlX2ZpbGUoInN3X3N5bmMiLCAwNjQ0LCBkYmdmcywgTlVMTCwK KwkJCSAgICAmc3dfc3luY19kZWJ1Z2ZzX2ZvcHMpOwogCiAJcmV0dXJuIDA7CiB9Ci0tIAoyLjUu MAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRl dmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHA6Ly9s aXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK