From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755246AbcAOO5V (ORCPT ); Fri, 15 Jan 2016 09:57:21 -0500 Received: from mail-yk0-f171.google.com ([209.85.160.171]:33362 "EHLO mail-yk0-f171.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755141AbcAOO5R (ORCPT ); Fri, 15 Jan 2016 09:57:17 -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 24/29] dma-buf/fence: add debug to fence timeline Date: Fri, 15 Jan 2016 12:55:34 -0200 Message-Id: <1452869739-3304-25-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 Bring the debug information that belonged to sync_timeline and sync_pt back. Signed-off-by: Gustavo Padovan --- drivers/dma-buf/Makefile | 2 +- drivers/dma-buf/fence.c | 4 ++ drivers/dma-buf/fence_debug.c | 128 +++++++++++++++++++++++++++++++++++ drivers/staging/android/sync.h | 4 -- drivers/staging/android/sync_debug.c | 105 +--------------------------- include/linux/fence.h | 18 +++++ 6 files changed, 154 insertions(+), 107 deletions(-) create mode 100644 drivers/dma-buf/fence_debug.c diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index 57a675f..fb03696 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -1 +1 @@ -obj-y := dma-buf.o fence.o reservation.o seqno-fence.o +obj-y := dma-buf.o fence.o fence_debug.o reservation.o seqno-fence.o diff --git a/drivers/dma-buf/fence.c b/drivers/dma-buf/fence.c index 0a07fcb..09faf2e 100644 --- a/drivers/dma-buf/fence.c +++ b/drivers/dma-buf/fence.c @@ -84,6 +84,8 @@ struct fence_timeline *fence_timeline_create(unsigned num, int size, INIT_LIST_HEAD(&timeline->active_list_head); spin_lock_init(&timeline->lock); + fence_timeline_debug_add(timeline); + return timeline; } EXPORT_SYMBOL(fence_timeline_create); @@ -100,6 +102,8 @@ static void fence_timeline_free(struct kref *kref) struct fence_timeline *timeline = container_of(kref, struct fence_timeline, kref); + fence_timeline_debug_remove(timeline); + kfree(timeline); } diff --git a/drivers/dma-buf/fence_debug.c b/drivers/dma-buf/fence_debug.c new file mode 100644 index 0000000..c7529c6 --- /dev/null +++ b/drivers/dma-buf/fence_debug.c @@ -0,0 +1,128 @@ +/* + * drivers/dma-buf/fence_debug.c + * + * Copyright (C) 2012 Google, Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include +#include + +#ifdef CONFIG_DEBUG_FS + +static LIST_HEAD(fence_timeline_list_head); +static DEFINE_SPINLOCK(fence_timeline_list_lock); + +void fence_timeline_debug_add(struct fence_timeline *obj) +{ + unsigned long flags; + + spin_lock_irqsave(&fence_timeline_list_lock, flags); + list_add_tail(&obj->fence_timeline_list, &fence_timeline_list_head); + spin_unlock_irqrestore(&fence_timeline_list_lock, flags); +} +EXPORT_SYMBOL(fence_timeline_debug_add); + +void fence_timeline_debug_remove(struct fence_timeline *obj) +{ + unsigned long flags; + + spin_lock_irqsave(&fence_timeline_list_lock, flags); + list_del(&obj->fence_timeline_list); + spin_unlock_irqrestore(&fence_timeline_list_lock, flags); +} +EXPORT_SYMBOL(fence_timeline_debug_remove); + +const char *fence_status_str(int status) +{ + if (status == 0) + return "signaled"; + + if (status > 0) + return "active"; + + return "error"; +} +EXPORT_SYMBOL(fence_status_str); + +void fence_print(struct seq_file *s, struct fence *fence, bool show) +{ + int status = 1; + struct fence_timeline *parent = fence_parent(fence); + + if (fence_is_signaled_locked(fence)) + status = fence->status; + + seq_printf(s, " %s%sfence %s", + show ? parent->name : "", + show ? "_" : "", + fence_status_str(status)); + + if (status <= 0) { + struct timespec64 ts64 = + ktime_to_timespec64(fence->timestamp); + + seq_printf(s, "@%lld.%09ld", (s64)ts64.tv_sec, ts64.tv_nsec); + } + + if (fence->ops->timeline_value_str && + fence->ops->fence_value_str) { + char value[64]; + + fence->ops->fence_value_str(fence, value, sizeof(value)); + seq_printf(s, ": %s", value); + if (show) { + fence->ops->timeline_value_str(fence, value, + sizeof(value)); + seq_printf(s, " / %s", value); + } + } + + seq_puts(s, "\n"); +} +EXPORT_SYMBOL(fence_print); + +void fence_timeline_print(struct seq_file *s, struct fence_timeline *obj) +{ + struct list_head *pos; + unsigned long flags; + + seq_printf(s, "%s %s: %u\n", obj->name, obj->drv_name, obj->value); + + spin_lock_irqsave(&obj->lock, flags); + list_for_each(pos, &obj->child_list_head) { + struct fence *fence = + container_of(pos, struct fence, child_list); + fence_print(s, fence, false); + } + spin_unlock_irqrestore(&obj->lock, flags); +} +EXPORT_SYMBOL(fence_timeline_print); + +void fence_timeline_print_all(struct seq_file* s) +{ + unsigned long flags; + struct list_head *pos; + + spin_lock_irqsave(&fence_timeline_list_lock, flags); + list_for_each(pos, &fence_timeline_list_head) { + struct fence_timeline *obj = + container_of(pos, struct fence_timeline, + fence_timeline_list); + + fence_timeline_print(s, obj); + seq_puts(s, "\n"); + } + spin_unlock_irqrestore(&fence_timeline_list_lock, flags); +} +EXPORT_SYMBOL(fence_timeline_print_all); +#endif diff --git a/drivers/staging/android/sync.h b/drivers/staging/android/sync.h index 256315c..8e6827b 100644 --- a/drivers/staging/android/sync.h +++ b/drivers/staging/android/sync.h @@ -184,15 +184,11 @@ int sync_fence_wait(struct sync_fence *fence, long timeout); #ifdef CONFIG_DEBUG_FS -void sync_timeline_debug_add(struct fence_timeline *obj); -void sync_timeline_debug_remove(struct fence_timeline *obj); void sync_fence_debug_add(struct sync_fence *fence); void sync_fence_debug_remove(struct sync_fence *fence); void sync_dump(void); #else -# define sync_timeline_debug_add(obj) -# define sync_timeline_debug_remove(obj) # define sync_fence_debug_add(fence) # define sync_fence_debug_remove(fence) # define sync_dump() diff --git a/drivers/staging/android/sync_debug.c b/drivers/staging/android/sync_debug.c index 13d225f..8e2ca57 100644 --- a/drivers/staging/android/sync_debug.c +++ b/drivers/staging/android/sync_debug.c @@ -33,29 +33,9 @@ static struct dentry *dbgfs; -static LIST_HEAD(sync_timeline_list_head); -static DEFINE_SPINLOCK(sync_timeline_list_lock); static LIST_HEAD(sync_fence_list_head); static DEFINE_SPINLOCK(sync_fence_list_lock); -void sync_timeline_debug_add(struct fence_timeline *obj) -{ - unsigned long flags; - - spin_lock_irqsave(&sync_timeline_list_lock, flags); - list_add_tail(&obj->fence_timeline_list, &sync_timeline_list_head); - spin_unlock_irqrestore(&sync_timeline_list_lock, flags); -} - -void sync_timeline_debug_remove(struct fence_timeline *obj) -{ - unsigned long flags; - - spin_lock_irqsave(&sync_timeline_list_lock, flags); - list_del(&obj->fence_timeline_list); - spin_unlock_irqrestore(&sync_timeline_list_lock, flags); -} - void sync_fence_debug_add(struct sync_fence *sync_fence) { unsigned long flags; @@ -74,76 +54,6 @@ void sync_fence_debug_remove(struct sync_fence *sync_fence) spin_unlock_irqrestore(&sync_fence_list_lock, flags); } -static const char *sync_status_str(int status) -{ - if (status == 0) - return "signaled"; - - if (status > 0) - return "active"; - - return "error"; -} - -static void sync_print_fence(struct seq_file *s, struct fence *fence, bool show) -{ - int status = 1; - struct fence_timeline *parent = fence_parent(fence); - - if (fence_is_signaled_locked(fence)) - status = fence->status; - - seq_printf(s, " %s%sfence %s", - show ? parent->name : "", - show ? "_" : "", - sync_status_str(status)); - - if (status <= 0) { - struct timespec64 ts64 = - ktime_to_timespec64(fence->timestamp); - - seq_printf(s, "@%lld.%09ld", (s64)ts64.tv_sec, ts64.tv_nsec); - } - - if ((!fence || fence->ops->timeline_value_str) && - fence->ops->fence_value_str) { - char value[64]; - bool success; - - fence->ops->fence_value_str(fence, value, sizeof(value)); - success = strlen(value); - - if (success) - seq_printf(s, ": %s", value); - - if (success && fence) { - fence->ops->timeline_value_str(fence, value, - sizeof(value)); - - if (strlen(value)) - seq_printf(s, " / %s", value); - } - } - - seq_puts(s, "\n"); -} - -static void sync_print_obj(struct seq_file *s, struct fence_timeline *obj) -{ - struct list_head *pos; - unsigned long flags; - - seq_printf(s, "%s %s: %d\n", obj->name, obj->drv_name, obj->value); - - spin_lock_irqsave(&obj->lock, flags); - list_for_each(pos, &obj->child_list_head) { - struct fence *fence = - container_of(pos, struct fence, child_list); - sync_print_fence(s, fence, false); - } - spin_unlock_irqrestore(&obj->lock, flags); -} - static void sync_print_sync_fence(struct seq_file *s, struct sync_fence *sync_fence) { @@ -152,10 +62,10 @@ static void sync_print_sync_fence(struct seq_file *s, int i; seq_printf(s, "[%p] %s: %s\n", sync_fence, sync_fence->name, - sync_status_str(atomic_read(&sync_fence->status))); + fence_status_str(atomic_read(&sync_fence->status))); for (i = 0; i < sync_fence->num_fences; ++i) { - sync_print_fence(s, sync_fence->cbs[i].fence, true); + fence_print(s, sync_fence->cbs[i].fence, true); } spin_lock_irqsave(&sync_fence->wq.lock, flags); @@ -179,16 +89,7 @@ static int sync_debugfs_show(struct seq_file *s, void *unused) seq_puts(s, "objs:\n--------------\n"); - spin_lock_irqsave(&sync_timeline_list_lock, flags); - list_for_each(pos, &sync_timeline_list_head) { - struct fence_timeline *obj = - container_of(pos, struct fence_timeline, - fence_timeline_list); - - sync_print_obj(s, obj); - seq_puts(s, "\n"); - } - spin_unlock_irqrestore(&sync_timeline_list_lock, flags); + fence_timeline_print_all(s); seq_puts(s, "fences:\n--------------\n"); diff --git a/include/linux/fence.h b/include/linux/fence.h index adece43..32a26ab 100644 --- a/include/linux/fence.h +++ b/include/linux/fence.h @@ -407,6 +407,24 @@ static inline signed long fence_wait(struct fence *fence, bool intr) unsigned fence_context_alloc(unsigned num); +#ifdef CONFIG_DEBUG_FS + +void fence_timeline_debug_add(struct fence_timeline *obj); +void fence_timeline_debug_remove(struct fence_timeline *obj); +const char *fence_status_str(int status); +void fence_print(struct seq_file *s, struct fence *fence, bool show); +void fence_timeline_print(struct seq_file *s, struct fence_timeline *obj); +void fence_timeline_print_all(struct seq_file* s); + +#else +#define fence_timeline_debug_add(obj) +#define fence_timeline_debug_remove(obj) +#define fence_status_str(status) +#define fence_print(s, fence, show) +#define fence_timeline_print(s, obj) +#define fence_timeline_print_all(s) +#endif + #define FENCE_TRACE(f, fmt, args...) \ do { \ struct fence *__ff = (f); \ -- 2.5.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: [RFC 24/29] dma-buf/fence: add debug to fence timeline Date: Fri, 15 Jan 2016 12:55:34 -0200 Message-ID: <1452869739-3304-25-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-f169.google.com (mail-yk0-f169.google.com [209.85.160.169]) by gabe.freedesktop.org (Postfix) with ESMTPS id 25FFC7A0FC for ; Fri, 15 Jan 2016 06:57:17 -0800 (PST) Received: by mail-yk0-f169.google.com with SMTP id a85so467202781ykb.1 for ; Fri, 15 Jan 2016 06:57:17 -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 QnJpbmcgdGhlIGRlYnVnIGluZm9ybWF0aW9uIHRoYXQgYmVsb25nZWQgdG8gc3luY190aW1lbGlu ZSBhbmQgc3luY19wdApiYWNrLgoKU2lnbmVkLW9mZi1ieTogR3VzdGF2byBQYWRvdmFuIDxndXN0 YXZvLnBhZG92YW5AY29sbGFib3JhLmNvLnVrPgotLS0KIGRyaXZlcnMvZG1hLWJ1Zi9NYWtlZmls ZSAgICAgICAgICAgICB8ICAgMiArLQogZHJpdmVycy9kbWEtYnVmL2ZlbmNlLmMgICAgICAgICAg ICAgIHwgICA0ICsrCiBkcml2ZXJzL2RtYS1idWYvZmVuY2VfZGVidWcuYyAgICAgICAgfCAxMjgg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvc3RhZ2luZy9hbmRy b2lkL3N5bmMuaCAgICAgICB8ICAgNCAtLQogZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luY19k ZWJ1Zy5jIHwgMTA1ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGluY2x1ZGUvbGludXgv ZmVuY2UuaCAgICAgICAgICAgICAgICB8ICAxOCArKysrKwogNiBmaWxlcyBjaGFuZ2VkLCAxNTQg aW5zZXJ0aW9ucygrKSwgMTA3IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvZG1hLWJ1Zi9mZW5jZV9kZWJ1Zy5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL01h a2VmaWxlIGIvZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlCmluZGV4IDU3YTY3NWYuLmZiMDM2OTYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2RtYS1i dWYvTWFrZWZpbGUKQEAgLTEgKzEgQEAKLW9iai15IDo9IGRtYS1idWYubyBmZW5jZS5vIHJlc2Vy dmF0aW9uLm8gc2Vxbm8tZmVuY2Uubworb2JqLXkgOj0gZG1hLWJ1Zi5vIGZlbmNlLm8gZmVuY2Vf ZGVidWcubyByZXNlcnZhdGlvbi5vIHNlcW5vLWZlbmNlLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMv ZG1hLWJ1Zi9mZW5jZS5jIGIvZHJpdmVycy9kbWEtYnVmL2ZlbmNlLmMKaW5kZXggMGEwN2ZjYi4u MDlmYWYyZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVmL2ZlbmNlLmMKKysrIGIvZHJpdmVy cy9kbWEtYnVmL2ZlbmNlLmMKQEAgLTg0LDYgKzg0LDggQEAgc3RydWN0IGZlbmNlX3RpbWVsaW5l ICpmZW5jZV90aW1lbGluZV9jcmVhdGUodW5zaWduZWQgbnVtLCBpbnQgc2l6ZSwKIAlJTklUX0xJ U1RfSEVBRCgmdGltZWxpbmUtPmFjdGl2ZV9saXN0X2hlYWQpOwogCXNwaW5fbG9ja19pbml0KCZ0 aW1lbGluZS0+bG9jayk7CiAKKwlmZW5jZV90aW1lbGluZV9kZWJ1Z19hZGQodGltZWxpbmUpOwor CiAJcmV0dXJuIHRpbWVsaW5lOwogfQogRVhQT1JUX1NZTUJPTChmZW5jZV90aW1lbGluZV9jcmVh dGUpOwpAQCAtMTAwLDYgKzEwMiw4IEBAIHN0YXRpYyB2b2lkIGZlbmNlX3RpbWVsaW5lX2ZyZWUo c3RydWN0IGtyZWYgKmtyZWYpCiAJc3RydWN0IGZlbmNlX3RpbWVsaW5lICp0aW1lbGluZSA9CiAJ CWNvbnRhaW5lcl9vZihrcmVmLCBzdHJ1Y3QgZmVuY2VfdGltZWxpbmUsIGtyZWYpOwogCisJZmVu Y2VfdGltZWxpbmVfZGVidWdfcmVtb3ZlKHRpbWVsaW5lKTsKKwogCWtmcmVlKHRpbWVsaW5lKTsK IH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL2ZlbmNlX2RlYnVnLmMgYi9kcml2ZXJz L2RtYS1idWYvZmVuY2VfZGVidWcuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li5jNzUyOWM2Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9kbWEtYnVmL2ZlbmNlX2RlYnVn LmMKQEAgLTAsMCArMSwxMjggQEAKKy8qCisgKiBkcml2ZXJzL2RtYS1idWYvZmVuY2VfZGVidWcu YworICoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBHb29nbGUsIEluYy4KKyAqCisgKiBUaGlzIHNv ZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVi bGljCisgKiBMaWNlbnNlIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb24sIGFuZAorICogbWF5IGJlIGNvcGllZCwgZGlzdHJpYnV0ZWQsIGFuZCBt b2RpZmllZCB1bmRlciB0aG9zZSB0ZXJtcy4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoK KyAqLworCisjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51eC9mZW5j ZS5oPgorCisjaWZkZWYgQ09ORklHX0RFQlVHX0ZTCisKK3N0YXRpYyBMSVNUX0hFQUQoZmVuY2Vf dGltZWxpbmVfbGlzdF9oZWFkKTsKK3N0YXRpYyBERUZJTkVfU1BJTkxPQ0soZmVuY2VfdGltZWxp bmVfbGlzdF9sb2NrKTsKKwordm9pZCBmZW5jZV90aW1lbGluZV9kZWJ1Z19hZGQoc3RydWN0IGZl bmNlX3RpbWVsaW5lICpvYmopCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9j a19pcnFzYXZlKCZmZW5jZV90aW1lbGluZV9saXN0X2xvY2ssIGZsYWdzKTsKKwlsaXN0X2FkZF90 YWlsKCZvYmotPmZlbmNlX3RpbWVsaW5lX2xpc3QsICZmZW5jZV90aW1lbGluZV9saXN0X2hlYWQp OworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZlbmNlX3RpbWVsaW5lX2xpc3RfbG9jaywgZmxh Z3MpOworfQorRVhQT1JUX1NZTUJPTChmZW5jZV90aW1lbGluZV9kZWJ1Z19hZGQpOworCit2b2lk IGZlbmNlX3RpbWVsaW5lX2RlYnVnX3JlbW92ZShzdHJ1Y3QgZmVuY2VfdGltZWxpbmUgKm9iaikK K3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZlbmNlX3Rp bWVsaW5lX2xpc3RfbG9jaywgZmxhZ3MpOworCWxpc3RfZGVsKCZvYmotPmZlbmNlX3RpbWVsaW5l X2xpc3QpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZlbmNlX3RpbWVsaW5lX2xpc3RfbG9j aywgZmxhZ3MpOworfQorRVhQT1JUX1NZTUJPTChmZW5jZV90aW1lbGluZV9kZWJ1Z19yZW1vdmUp OworCitjb25zdCBjaGFyICpmZW5jZV9zdGF0dXNfc3RyKGludCBzdGF0dXMpCit7CisJaWYgKHN0 YXR1cyA9PSAwKQorCQlyZXR1cm4gInNpZ25hbGVkIjsKKworCWlmIChzdGF0dXMgPiAwKQorCQly ZXR1cm4gImFjdGl2ZSI7CisKKwlyZXR1cm4gImVycm9yIjsKK30KK0VYUE9SVF9TWU1CT0woZmVu Y2Vfc3RhdHVzX3N0cik7CisKK3ZvaWQgZmVuY2VfcHJpbnQoc3RydWN0IHNlcV9maWxlICpzLCBz dHJ1Y3QgZmVuY2UgKmZlbmNlLCBib29sIHNob3cpCit7CisJaW50IHN0YXR1cyA9IDE7CisJc3Ry dWN0IGZlbmNlX3RpbWVsaW5lICpwYXJlbnQgPSBmZW5jZV9wYXJlbnQoZmVuY2UpOworCisJaWYg KGZlbmNlX2lzX3NpZ25hbGVkX2xvY2tlZChmZW5jZSkpCisJCXN0YXR1cyA9IGZlbmNlLT5zdGF0 dXM7CisKKwlzZXFfcHJpbnRmKHMsICIgICVzJXNmZW5jZSAlcyIsCisJCSAgIHNob3cgPyBwYXJl bnQtPm5hbWUgOiAiIiwKKwkJICAgc2hvdyA/ICJfIiA6ICIiLAorCQkgICBmZW5jZV9zdGF0dXNf c3RyKHN0YXR1cykpOworCisJaWYgKHN0YXR1cyA8PSAwKSB7CisJCXN0cnVjdCB0aW1lc3BlYzY0 IHRzNjQgPQorCQkJa3RpbWVfdG9fdGltZXNwZWM2NChmZW5jZS0+dGltZXN0YW1wKTsKKworCQlz ZXFfcHJpbnRmKHMsICJAJWxsZC4lMDlsZCIsIChzNjQpdHM2NC50dl9zZWMsIHRzNjQudHZfbnNl Yyk7CisJfQorCisJaWYgKGZlbmNlLT5vcHMtPnRpbWVsaW5lX3ZhbHVlX3N0ciAmJgorCSAgICBm ZW5jZS0+b3BzLT5mZW5jZV92YWx1ZV9zdHIpIHsKKwkJY2hhciB2YWx1ZVs2NF07CisKKwkJZmVu Y2UtPm9wcy0+ZmVuY2VfdmFsdWVfc3RyKGZlbmNlLCB2YWx1ZSwgc2l6ZW9mKHZhbHVlKSk7CisJ CXNlcV9wcmludGYocywgIjogJXMiLCB2YWx1ZSk7CisJCWlmIChzaG93KSB7CisJCQlmZW5jZS0+ b3BzLT50aW1lbGluZV92YWx1ZV9zdHIoZmVuY2UsIHZhbHVlLAorCQkJCQkJICAgICAgIHNpemVv Zih2YWx1ZSkpOworCQkJc2VxX3ByaW50ZihzLCAiIC8gJXMiLCB2YWx1ZSk7CisJCX0KKwl9CisK KwlzZXFfcHV0cyhzLCAiXG4iKTsKK30KK0VYUE9SVF9TWU1CT0woZmVuY2VfcHJpbnQpOworCit2 b2lkIGZlbmNlX3RpbWVsaW5lX3ByaW50KHN0cnVjdCBzZXFfZmlsZSAqcywgc3RydWN0IGZlbmNl X3RpbWVsaW5lICpvYmopCit7CisJc3RydWN0IGxpc3RfaGVhZCAqcG9zOworCXVuc2lnbmVkIGxv bmcgZmxhZ3M7CisKKwlzZXFfcHJpbnRmKHMsICIlcyAlczogJXVcbiIsIG9iai0+bmFtZSwgb2Jq LT5kcnZfbmFtZSwgb2JqLT52YWx1ZSk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmb2JqLT5sb2Nr LCBmbGFncyk7CisJbGlzdF9mb3JfZWFjaChwb3MsICZvYmotPmNoaWxkX2xpc3RfaGVhZCkgewor CQlzdHJ1Y3QgZmVuY2UgKmZlbmNlID0KKwkJCWNvbnRhaW5lcl9vZihwb3MsIHN0cnVjdCBmZW5j ZSwgY2hpbGRfbGlzdCk7CisJCWZlbmNlX3ByaW50KHMsIGZlbmNlLCBmYWxzZSk7CisJfQorCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJm9iai0+bG9jaywgZmxhZ3MpOworfQorRVhQT1JUX1NZTUJP TChmZW5jZV90aW1lbGluZV9wcmludCk7CisKK3ZvaWQgZmVuY2VfdGltZWxpbmVfcHJpbnRfYWxs KHN0cnVjdCBzZXFfZmlsZSogcykKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBs aXN0X2hlYWQgKnBvczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmZW5jZV90aW1lbGluZV9saXN0 X2xvY2ssIGZsYWdzKTsKKwlsaXN0X2Zvcl9lYWNoKHBvcywgJmZlbmNlX3RpbWVsaW5lX2xpc3Rf aGVhZCkgeworCQlzdHJ1Y3QgZmVuY2VfdGltZWxpbmUgKm9iaiA9CisJCQljb250YWluZXJfb2Yo cG9zLCBzdHJ1Y3QgZmVuY2VfdGltZWxpbmUsCisJCQkJICAgICBmZW5jZV90aW1lbGluZV9saXN0 KTsKKworCQlmZW5jZV90aW1lbGluZV9wcmludChzLCBvYmopOworCQlzZXFfcHV0cyhzLCAiXG4i KTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZmVuY2VfdGltZWxpbmVfbGlzdF9sb2Nr LCBmbGFncyk7Cit9CitFWFBPUlRfU1lNQk9MKGZlbmNlX3RpbWVsaW5lX3ByaW50X2FsbCk7Cisj ZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuaCBiL2RyaXZl cnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuaAppbmRleCAyNTYzMTVjLi44ZTY4MjdiIDEwMDY0NAot LS0gYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jLmgKKysrIGIvZHJpdmVycy9zdGFnaW5n L2FuZHJvaWQvc3luYy5oCkBAIC0xODQsMTUgKzE4NCwxMSBAQCBpbnQgc3luY19mZW5jZV93YWl0 KHN0cnVjdCBzeW5jX2ZlbmNlICpmZW5jZSwgbG9uZyB0aW1lb3V0KTsKIAogI2lmZGVmIENPTkZJ R19ERUJVR19GUwogCi12b2lkIHN5bmNfdGltZWxpbmVfZGVidWdfYWRkKHN0cnVjdCBmZW5jZV90 aW1lbGluZSAqb2JqKTsKLXZvaWQgc3luY190aW1lbGluZV9kZWJ1Z19yZW1vdmUoc3RydWN0IGZl bmNlX3RpbWVsaW5lICpvYmopOwogdm9pZCBzeW5jX2ZlbmNlX2RlYnVnX2FkZChzdHJ1Y3Qgc3lu Y19mZW5jZSAqZmVuY2UpOwogdm9pZCBzeW5jX2ZlbmNlX2RlYnVnX3JlbW92ZShzdHJ1Y3Qgc3lu Y19mZW5jZSAqZmVuY2UpOwogdm9pZCBzeW5jX2R1bXAodm9pZCk7CiAKICNlbHNlCi0jIGRlZmlu ZSBzeW5jX3RpbWVsaW5lX2RlYnVnX2FkZChvYmopCi0jIGRlZmluZSBzeW5jX3RpbWVsaW5lX2Rl YnVnX3JlbW92ZShvYmopCiAjIGRlZmluZSBzeW5jX2ZlbmNlX2RlYnVnX2FkZChmZW5jZSkKICMg ZGVmaW5lIHN5bmNfZmVuY2VfZGVidWdfcmVtb3ZlKGZlbmNlKQogIyBkZWZpbmUgc3luY19kdW1w KCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmNfZGVidWcuYyBiL2Ry aXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmNfZGVidWcuYwppbmRleCAxM2QyMjVmLi44ZTJjYTU3 IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jX2RlYnVnLmMKKysrIGIv ZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luY19kZWJ1Zy5jCkBAIC0zMywyOSArMzMsOSBAQAog CiBzdGF0aWMgc3RydWN0IGRlbnRyeSAqZGJnZnM7CiAKLXN0YXRpYyBMSVNUX0hFQUQoc3luY190 aW1lbGluZV9saXN0X2hlYWQpOwotc3RhdGljIERFRklORV9TUElOTE9DSyhzeW5jX3RpbWVsaW5l X2xpc3RfbG9jayk7CiBzdGF0aWMgTElTVF9IRUFEKHN5bmNfZmVuY2VfbGlzdF9oZWFkKTsKIHN0 YXRpYyBERUZJTkVfU1BJTkxPQ0soc3luY19mZW5jZV9saXN0X2xvY2spOwogCi12b2lkIHN5bmNf dGltZWxpbmVfZGVidWdfYWRkKHN0cnVjdCBmZW5jZV90aW1lbGluZSAqb2JqKQotewotCXVuc2ln bmVkIGxvbmcgZmxhZ3M7Ci0KLQlzcGluX2xvY2tfaXJxc2F2ZSgmc3luY190aW1lbGluZV9saXN0 X2xvY2ssIGZsYWdzKTsKLQlsaXN0X2FkZF90YWlsKCZvYmotPmZlbmNlX3RpbWVsaW5lX2xpc3Qs ICZzeW5jX3RpbWVsaW5lX2xpc3RfaGVhZCk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3lu Y190aW1lbGluZV9saXN0X2xvY2ssIGZsYWdzKTsKLX0KLQotdm9pZCBzeW5jX3RpbWVsaW5lX2Rl YnVnX3JlbW92ZShzdHJ1Y3QgZmVuY2VfdGltZWxpbmUgKm9iaikKLXsKLQl1bnNpZ25lZCBsb25n IGZsYWdzOwotCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnN5bmNfdGltZWxpbmVfbGlzdF9sb2NrLCBm bGFncyk7Ci0JbGlzdF9kZWwoJm9iai0+ZmVuY2VfdGltZWxpbmVfbGlzdCk7Ci0Jc3Bpbl91bmxv Y2tfaXJxcmVzdG9yZSgmc3luY190aW1lbGluZV9saXN0X2xvY2ssIGZsYWdzKTsKLX0KLQogdm9p ZCBzeW5jX2ZlbmNlX2RlYnVnX2FkZChzdHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZSkKIHsK IAl1bnNpZ25lZCBsb25nIGZsYWdzOwpAQCAtNzQsNzYgKzU0LDYgQEAgdm9pZCBzeW5jX2ZlbmNl X2RlYnVnX3JlbW92ZShzdHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZSkKIAlzcGluX3VubG9j a19pcnFyZXN0b3JlKCZzeW5jX2ZlbmNlX2xpc3RfbG9jaywgZmxhZ3MpOwogfQogCi1zdGF0aWMg Y29uc3QgY2hhciAqc3luY19zdGF0dXNfc3RyKGludCBzdGF0dXMpCi17Ci0JaWYgKHN0YXR1cyA9 PSAwKQotCQlyZXR1cm4gInNpZ25hbGVkIjsKLQotCWlmIChzdGF0dXMgPiAwKQotCQlyZXR1cm4g ImFjdGl2ZSI7Ci0KLQlyZXR1cm4gImVycm9yIjsKLX0KLQotc3RhdGljIHZvaWQgc3luY19wcmlu dF9mZW5jZShzdHJ1Y3Qgc2VxX2ZpbGUgKnMsIHN0cnVjdCBmZW5jZSAqZmVuY2UsIGJvb2wgc2hv dykKLXsKLQlpbnQgc3RhdHVzID0gMTsKLQlzdHJ1Y3QgZmVuY2VfdGltZWxpbmUgKnBhcmVudCA9 IGZlbmNlX3BhcmVudChmZW5jZSk7Ci0KLQlpZiAoZmVuY2VfaXNfc2lnbmFsZWRfbG9ja2VkKGZl bmNlKSkKLQkJc3RhdHVzID0gZmVuY2UtPnN0YXR1czsKLQotCXNlcV9wcmludGYocywgIiAgJXMl c2ZlbmNlICVzIiwKLQkJICAgc2hvdyA/IHBhcmVudC0+bmFtZSA6ICIiLAotCQkgICBzaG93ID8g Il8iIDogIiIsCi0JCSAgIHN5bmNfc3RhdHVzX3N0cihzdGF0dXMpKTsKLQotCWlmIChzdGF0dXMg PD0gMCkgewotCQlzdHJ1Y3QgdGltZXNwZWM2NCB0czY0ID0KLQkJCWt0aW1lX3RvX3RpbWVzcGVj NjQoZmVuY2UtPnRpbWVzdGFtcCk7Ci0KLQkJc2VxX3ByaW50ZihzLCAiQCVsbGQuJTA5bGQiLCAo czY0KXRzNjQudHZfc2VjLCB0czY0LnR2X25zZWMpOwotCX0KLQotCWlmICgoIWZlbmNlIHx8IGZl bmNlLT5vcHMtPnRpbWVsaW5lX3ZhbHVlX3N0cikgJiYKLQkJZmVuY2UtPm9wcy0+ZmVuY2VfdmFs dWVfc3RyKSB7Ci0JCWNoYXIgdmFsdWVbNjRdOwotCQlib29sIHN1Y2Nlc3M7Ci0KLQkJZmVuY2Ut Pm9wcy0+ZmVuY2VfdmFsdWVfc3RyKGZlbmNlLCB2YWx1ZSwgc2l6ZW9mKHZhbHVlKSk7Ci0JCXN1 Y2Nlc3MgPSBzdHJsZW4odmFsdWUpOwotCi0JCWlmIChzdWNjZXNzKQotCQkJc2VxX3ByaW50Zihz LCAiOiAlcyIsIHZhbHVlKTsKLQotCQlpZiAoc3VjY2VzcyAmJiBmZW5jZSkgewotCQkJZmVuY2Ut Pm9wcy0+dGltZWxpbmVfdmFsdWVfc3RyKGZlbmNlLCB2YWx1ZSwKLQkJCQkJCSAgICAgICBzaXpl b2YodmFsdWUpKTsKLQotCQkJaWYgKHN0cmxlbih2YWx1ZSkpCi0JCQkJc2VxX3ByaW50ZihzLCAi IC8gJXMiLCB2YWx1ZSk7Ci0JCX0KLQl9Ci0KLQlzZXFfcHV0cyhzLCAiXG4iKTsKLX0KLQotc3Rh dGljIHZvaWQgc3luY19wcmludF9vYmooc3RydWN0IHNlcV9maWxlICpzLCBzdHJ1Y3QgZmVuY2Vf dGltZWxpbmUgKm9iaikKLXsKLQlzdHJ1Y3QgbGlzdF9oZWFkICpwb3M7Ci0JdW5zaWduZWQgbG9u ZyBmbGFnczsKLQotCXNlcV9wcmludGYocywgIiVzICVzOiAlZFxuIiwgb2JqLT5uYW1lLCBvYmot PmRydl9uYW1lLCBvYmotPnZhbHVlKTsKLQotCXNwaW5fbG9ja19pcnFzYXZlKCZvYmotPmxvY2ss IGZsYWdzKTsKLQlsaXN0X2Zvcl9lYWNoKHBvcywgJm9iai0+Y2hpbGRfbGlzdF9oZWFkKSB7Ci0J CXN0cnVjdCBmZW5jZSAqZmVuY2UgPQotCQkJY29udGFpbmVyX29mKHBvcywgc3RydWN0IGZlbmNl LCBjaGlsZF9saXN0KTsKLQkJc3luY19wcmludF9mZW5jZShzLCBmZW5jZSwgZmFsc2UpOwotCX0K LQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmotPmxvY2ssIGZsYWdzKTsKLX0KLQogc3RhdGlj IHZvaWQgc3luY19wcmludF9zeW5jX2ZlbmNlKHN0cnVjdCBzZXFfZmlsZSAqcywKIAkJCQkgIHN0 cnVjdCBzeW5jX2ZlbmNlICpzeW5jX2ZlbmNlKQogewpAQCAtMTUyLDEwICs2MiwxMCBAQCBzdGF0 aWMgdm9pZCBzeW5jX3ByaW50X3N5bmNfZmVuY2Uoc3RydWN0IHNlcV9maWxlICpzLAogCWludCBp OwogCiAJc2VxX3ByaW50ZihzLCAiWyVwXSAlczogJXNcbiIsIHN5bmNfZmVuY2UsIHN5bmNfZmVu Y2UtPm5hbWUsCi0JCSAgIHN5bmNfc3RhdHVzX3N0cihhdG9taWNfcmVhZCgmc3luY19mZW5jZS0+ c3RhdHVzKSkpOworCQkgICBmZW5jZV9zdGF0dXNfc3RyKGF0b21pY19yZWFkKCZzeW5jX2ZlbmNl LT5zdGF0dXMpKSk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgc3luY19mZW5jZS0+bnVtX2ZlbmNlczsg KytpKSB7Ci0JCXN5bmNfcHJpbnRfZmVuY2Uocywgc3luY19mZW5jZS0+Y2JzW2ldLmZlbmNlLCB0 cnVlKTsKKwkJZmVuY2VfcHJpbnQocywgc3luY19mZW5jZS0+Y2JzW2ldLmZlbmNlLCB0cnVlKTsK IAl9CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmc3luY19mZW5jZS0+d3EubG9jaywgZmxhZ3MpOwpA QCAtMTc5LDE2ICs4OSw3IEBAIHN0YXRpYyBpbnQgc3luY19kZWJ1Z2ZzX3Nob3coc3RydWN0IHNl cV9maWxlICpzLCB2b2lkICp1bnVzZWQpCiAKIAlzZXFfcHV0cyhzLCAib2Jqczpcbi0tLS0tLS0t LS0tLS0tXG4iKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZzeW5jX3RpbWVsaW5lX2xpc3RfbG9j aywgZmxhZ3MpOwotCWxpc3RfZm9yX2VhY2gocG9zLCAmc3luY190aW1lbGluZV9saXN0X2hlYWQp IHsKLQkJc3RydWN0IGZlbmNlX3RpbWVsaW5lICpvYmogPQotCQkJY29udGFpbmVyX29mKHBvcywg c3RydWN0IGZlbmNlX3RpbWVsaW5lLAotCQkJCSAgICAgZmVuY2VfdGltZWxpbmVfbGlzdCk7Ci0K LQkJc3luY19wcmludF9vYmoocywgb2JqKTsKLQkJc2VxX3B1dHMocywgIlxuIik7Ci0JfQotCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJnN5bmNfdGltZWxpbmVfbGlzdF9sb2NrLCBmbGFncyk7CisJ ZmVuY2VfdGltZWxpbmVfcHJpbnRfYWxsKHMpOwogCiAJc2VxX3B1dHMocywgImZlbmNlczpcbi0t LS0tLS0tLS0tLS0tXG4iKTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9mZW5jZS5oIGIv aW5jbHVkZS9saW51eC9mZW5jZS5oCmluZGV4IGFkZWNlNDMuLjMyYTI2YWIgMTAwNjQ0Ci0tLSBh L2luY2x1ZGUvbGludXgvZmVuY2UuaAorKysgYi9pbmNsdWRlL2xpbnV4L2ZlbmNlLmgKQEAgLTQw Nyw2ICs0MDcsMjQgQEAgc3RhdGljIGlubGluZSBzaWduZWQgbG9uZyBmZW5jZV93YWl0KHN0cnVj dCBmZW5jZSAqZmVuY2UsIGJvb2wgaW50cikKIAogdW5zaWduZWQgZmVuY2VfY29udGV4dF9hbGxv Yyh1bnNpZ25lZCBudW0pOwogCisjaWZkZWYgQ09ORklHX0RFQlVHX0ZTCisKK3ZvaWQgZmVuY2Vf dGltZWxpbmVfZGVidWdfYWRkKHN0cnVjdCBmZW5jZV90aW1lbGluZSAqb2JqKTsKK3ZvaWQgZmVu Y2VfdGltZWxpbmVfZGVidWdfcmVtb3ZlKHN0cnVjdCBmZW5jZV90aW1lbGluZSAqb2JqKTsKK2Nv bnN0IGNoYXIgKmZlbmNlX3N0YXR1c19zdHIoaW50IHN0YXR1cyk7Cit2b2lkIGZlbmNlX3ByaW50 KHN0cnVjdCBzZXFfZmlsZSAqcywgc3RydWN0IGZlbmNlICpmZW5jZSwgYm9vbCBzaG93KTsKK3Zv aWQgZmVuY2VfdGltZWxpbmVfcHJpbnQoc3RydWN0IHNlcV9maWxlICpzLCBzdHJ1Y3QgZmVuY2Vf dGltZWxpbmUgKm9iaik7Cit2b2lkIGZlbmNlX3RpbWVsaW5lX3ByaW50X2FsbChzdHJ1Y3Qgc2Vx X2ZpbGUqIHMpOworCisjZWxzZQorI2RlZmluZSBmZW5jZV90aW1lbGluZV9kZWJ1Z19hZGQob2Jq KQorI2RlZmluZSBmZW5jZV90aW1lbGluZV9kZWJ1Z19yZW1vdmUob2JqKQorI2RlZmluZSBmZW5j ZV9zdGF0dXNfc3RyKHN0YXR1cykKKyNkZWZpbmUgZmVuY2VfcHJpbnQocywgZmVuY2UsIHNob3cp CisjZGVmaW5lIGZlbmNlX3RpbWVsaW5lX3ByaW50KHMsIG9iaikKKyNkZWZpbmUgZmVuY2VfdGlt ZWxpbmVfcHJpbnRfYWxsKHMpCisjZW5kaWYKKwogI2RlZmluZSBGRU5DRV9UUkFDRShmLCBmbXQs IGFyZ3MuLi4pIFwKIAlkbyB7CQkJCQkJCQlcCiAJCXN0cnVjdCBmZW5jZSAqX19mZiA9IChmKTsJ CQkJXAotLSAKMi41LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwpodHRwOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRl dmVsCg==