From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755025AbcAOO47 (ORCPT ); Fri, 15 Jan 2016 09:56:59 -0500 Received: from mail-yk0-f170.google.com ([209.85.160.170]:35407 "EHLO mail-yk0-f170.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754908AbcAOO4z (ORCPT ); Fri, 15 Jan 2016 09:56:55 -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 18/29] dma-buf/fence: create default .fence_value_str() and .timeline_value_str() Date: Fri, 15 Jan 2016 12:55:28 -0200 Message-Id: <1452869739-3304-19-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 Provide simple default functions to help users retrieve the values of the fence and the timeline. Signed-off-by: Gustavo Padovan --- drivers/dma-buf/fence.c | 31 +++++++++++++++++++++++++++++++ drivers/staging/android/sw_sync.c | 18 ------------------ drivers/staging/android/sync.c | 30 ++---------------------------- drivers/staging/android/sync_debug.c | 11 +---------- include/linux/fence.h | 10 ++-------- include/trace/events/fence.h | 12 +++--------- 6 files changed, 39 insertions(+), 73 deletions(-) diff --git a/drivers/dma-buf/fence.c b/drivers/dma-buf/fence.c index 786c987..9fdeae8 100644 --- a/drivers/dma-buf/fence.c +++ b/drivers/dma-buf/fence.c @@ -620,6 +620,37 @@ void fence_default_release(struct fence *fence) } EXPORT_SYMBOL(fence_default_release); +/** + * fence_default_value_str - default .fence_value_str fence ops + * @fence: [in] the fence to get the value from + * @str: [out] the string pointer to write the value + * @size: [in] the size of the allocated string + * + * This functions returns a string containing the value of the fence. + */ +void fence_default_value_str(struct fence *fence, char *str, int size) +{ + snprintf(str, size, "%d", fence->seqno); +} +EXPORT_SYMBOL(fence_default_value_str); + +/** + * fence_default_timeline_value_str - default .timeline_value_str fence ops + * @fence: [in] the timeline child fence + * @str: [out] the string pointer to write the value + * @size: [in] the size of the allocated string + * + * This functions returns a string containing the value of the last signaled + * fence in this timeline. + */ +void fence_default_timeline_value_str(struct fence *fence, char *str, int size) +{ + struct fence_timeline *timeline = fence_parent(fence); + + snprintf(str, size, "%d", timeline->value); +} +EXPORT_SYMBOL(fence_default_timeline_value_str); + static bool fence_test_signaled_any(struct fence **fences, uint32_t count) { diff --git a/drivers/staging/android/sw_sync.c b/drivers/staging/android/sw_sync.c index bed6801..cfd7a18 100644 --- a/drivers/staging/android/sw_sync.c +++ b/drivers/staging/android/sw_sync.c @@ -51,26 +51,8 @@ static int sw_sync_fill_driver_data(struct fence *fence, return sizeof(pt->value); } -static void sw_sync_timeline_value_str(struct fence_timeline *fence_timeline, - char *str, int size) -{ - struct sw_sync_timeline *timeline = - (struct sw_sync_timeline *)fence_timeline; - snprintf(str, size, "%d", timeline->value); -} - -static void sw_sync_fence_value_str(struct fence *fence, - char *str, int size) -{ - struct sw_sync_pt *pt = (struct sw_sync_pt *)fence; - - snprintf(str, size, "%d", pt->value); -} - static struct fence_timeline_ops sw_sync_timeline_ops = { .fill_driver_data = sw_sync_fill_driver_data, - .timeline_value_str = sw_sync_timeline_value_str, - .fence_value_str = sw_sync_fence_value_str, }; struct sw_sync_timeline *sw_sync_timeline_create(const char *name) diff --git a/drivers/staging/android/sync.c b/drivers/staging/android/sync.c index 8216635..147a494 100644 --- a/drivers/staging/android/sync.c +++ b/drivers/staging/android/sync.c @@ -331,32 +331,6 @@ static int sync_fence_fill_driver_data(struct fence *fence, return parent->ops->fill_driver_data(fence, data, size); } -static void sync_fence_value_str(struct fence *fence, - char *str, int size) -{ - struct fence_timeline *parent = fence_parent(fence); - - if (!parent->ops->fence_value_str) { - if (size) - *str = 0; - return; - } - parent->ops->fence_value_str(fence, str, size); -} - -static void sync_fence_timeline_value_str(struct fence *fence, - char *str, int size) -{ - struct fence_timeline *parent = fence_parent(fence); - - if (!parent->ops->timeline_value_str) { - if (size) - *str = 0; - return; - } - parent->ops->timeline_value_str(parent, str, size); -} - static const struct fence_ops sync_fence_ops = { .get_driver_name = fence_default_get_driver_name, .get_timeline_name = fence_default_get_timeline_name, @@ -365,8 +339,8 @@ static const struct fence_ops sync_fence_ops = { .wait = fence_default_wait, .release = fence_default_release, .fill_driver_data = sync_fence_fill_driver_data, - .fence_value_str = sync_fence_value_str, - .timeline_value_str = sync_fence_timeline_value_str, + .fence_value_str = fence_default_value_str, + .timeline_value_str = fence_default_timeline_value_str, }; static void sync_fence_free(struct kref *kref) diff --git a/drivers/staging/android/sync_debug.c b/drivers/staging/android/sync_debug.c index db618ca..89b334c 100644 --- a/drivers/staging/android/sync_debug.c +++ b/drivers/staging/android/sync_debug.c @@ -133,16 +133,7 @@ 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", obj->name, obj->drv_name); - - if (obj->ops->timeline_value_str) { - char value[64]; - - obj->ops->timeline_value_str(obj, value, sizeof(value)); - seq_printf(s, ": %s", value); - } - - seq_puts(s, "\n"); + 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) { diff --git a/include/linux/fence.h b/include/linux/fence.h index e71545e..5371beb 100644 --- a/include/linux/fence.h +++ b/include/linux/fence.h @@ -40,19 +40,11 @@ struct fence_cb; * should return an error if there is not enough room * as specified by size. This information is returned * to userspace by SYNC_IOC_FENCE_INFO. - * @timeline_value_str: fill str with the value of the sync_timeline's counter * @pt_value_str: fill str with the value of the sync_pt */ struct fence_timeline_ops { /* optional */ int (*fill_driver_data)(struct fence *fence, void *data, int size); - - /* optional */ - void (*timeline_value_str)(struct fence_timeline *timeline, char *str, - int size); - - /* optional */ - void (*fence_value_str)(struct fence *fence, char *str, int size); }; /** @@ -293,6 +285,8 @@ bool fence_default_signaled(struct fence *fence); bool fence_default_enable_signaling(struct fence *fence); signed long fence_default_wait(struct fence *fence, bool intr, signed long timeout); void fence_default_release(struct fence *fence); +void fence_default_value_str(struct fence *fence, char *str, int size); +void fence_default_timeline_value_str(struct fence *fence, char *str, int size); int fence_add_callback(struct fence *fence, struct fence_cb *cb, fence_func_t func); bool fence_remove_callback(struct fence *fence, struct fence_cb *cb); diff --git a/include/trace/events/fence.h b/include/trace/events/fence.h index c4d01de..e1ca808 100644 --- a/include/trace/events/fence.h +++ b/include/trace/events/fence.h @@ -55,21 +55,15 @@ TRACE_EVENT(fence_timeline, TP_STRUCT__entry( __string(name, timeline->name) - __array(char, value, 32) + __field(unsigned int, value) ), TP_fast_assign( __assign_str(name, timeline->name); - if (timeline->ops->timeline_value_str) { - timeline->ops->timeline_value_str(timeline, - __entry->value, - sizeof(__entry->value)); - } else { - __entry->value[0] = '\0'; - } + __entry->value = timeline->value; ), - TP_printk("name=%s value=%s", __get_str(name), __entry->value) + TP_printk("name=%s value=%u", __get_str(name), __entry->value) ); DECLARE_EVENT_CLASS(fence, -- 2.5.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: [RFC 18/29] dma-buf/fence: create default .fence_value_str() and .timeline_value_str() Date: Fri, 15 Jan 2016 12:55:28 -0200 Message-ID: <1452869739-3304-19-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-f173.google.com (mail-yk0-f173.google.com [209.85.160.173]) by gabe.freedesktop.org (Postfix) with ESMTPS id BA5D57A0F7 for ; Fri, 15 Jan 2016 06:56:55 -0800 (PST) Received: by mail-yk0-f173.google.com with SMTP id a85so467190399ykb.1 for ; Fri, 15 Jan 2016 06:56:55 -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 UHJvdmlkZSBzaW1wbGUgZGVmYXVsdCBmdW5jdGlvbnMgdG8gaGVscCB1c2VycyByZXRyaWV2ZSB0 aGUgdmFsdWVzIG9mIHRoZQpmZW5jZSBhbmQgdGhlIHRpbWVsaW5lLgoKU2lnbmVkLW9mZi1ieTog R3VzdGF2byBQYWRvdmFuIDxndXN0YXZvLnBhZG92YW5AY29sbGFib3JhLmNvLnVrPgotLS0KIGRy aXZlcnMvZG1hLWJ1Zi9mZW5jZS5jICAgICAgICAgICAgICB8IDMxICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysKIGRyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N3X3N5bmMuYyAgICB8IDE4 IC0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luYy5jICAgICAg IHwgMzAgKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3N0YWdpbmcvYW5k cm9pZC9zeW5jX2RlYnVnLmMgfCAxMSArLS0tLS0tLS0tLQogaW5jbHVkZS9saW51eC9mZW5jZS5o ICAgICAgICAgICAgICAgIHwgMTAgKystLS0tLS0tLQogaW5jbHVkZS90cmFjZS9ldmVudHMvZmVu Y2UuaCAgICAgICAgIHwgMTIgKysrLS0tLS0tLS0tCiA2IGZpbGVzIGNoYW5nZWQsIDM5IGluc2Vy dGlvbnMoKyksIDczIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9m ZW5jZS5jIGIvZHJpdmVycy9kbWEtYnVmL2ZlbmNlLmMKaW5kZXggNzg2Yzk4Ny4uOWZkZWFlOCAx MDA2NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVmL2ZlbmNlLmMKKysrIGIvZHJpdmVycy9kbWEtYnVm L2ZlbmNlLmMKQEAgLTYyMCw2ICs2MjAsMzcgQEAgdm9pZCBmZW5jZV9kZWZhdWx0X3JlbGVhc2Uo c3RydWN0IGZlbmNlICpmZW5jZSkKIH0KIEVYUE9SVF9TWU1CT0woZmVuY2VfZGVmYXVsdF9yZWxl YXNlKTsKIAorLyoqCisgKiBmZW5jZV9kZWZhdWx0X3ZhbHVlX3N0ciAtIGRlZmF1bHQgLmZlbmNl X3ZhbHVlX3N0ciBmZW5jZSBvcHMKKyAqIEBmZW5jZToJW2luXQl0aGUgZmVuY2UgdG8gZ2V0IHRo ZSB2YWx1ZSBmcm9tCisgKiBAc3RyOglbb3V0XQl0aGUgc3RyaW5nIHBvaW50ZXIgdG8gd3JpdGUg dGhlIHZhbHVlCisgKiBAc2l6ZToJW2luXQl0aGUgc2l6ZSBvZiB0aGUgYWxsb2NhdGVkIHN0cmlu ZworICoKKyAqIFRoaXMgZnVuY3Rpb25zIHJldHVybnMgYSBzdHJpbmcgY29udGFpbmluZyB0aGUg dmFsdWUgb2YgdGhlIGZlbmNlLgorICovCit2b2lkIGZlbmNlX2RlZmF1bHRfdmFsdWVfc3RyKHN0 cnVjdCBmZW5jZSAqZmVuY2UsIGNoYXIgKnN0ciwgaW50IHNpemUpCit7CisJc25wcmludGYoc3Ry LCBzaXplLCAiJWQiLCBmZW5jZS0+c2Vxbm8pOworfQorRVhQT1JUX1NZTUJPTChmZW5jZV9kZWZh dWx0X3ZhbHVlX3N0cik7CisKKy8qKgorICogZmVuY2VfZGVmYXVsdF90aW1lbGluZV92YWx1ZV9z dHIgLSBkZWZhdWx0IC50aW1lbGluZV92YWx1ZV9zdHIgZmVuY2Ugb3BzCisgKiBAZmVuY2U6CVtp bl0JdGhlIHRpbWVsaW5lIGNoaWxkIGZlbmNlCisgKiBAc3RyOglbb3V0XQl0aGUgc3RyaW5nIHBv aW50ZXIgdG8gd3JpdGUgdGhlIHZhbHVlCisgKiBAc2l6ZToJW2luXQl0aGUgc2l6ZSBvZiB0aGUg YWxsb2NhdGVkIHN0cmluZworICoKKyAqIFRoaXMgZnVuY3Rpb25zIHJldHVybnMgYSBzdHJpbmcg Y29udGFpbmluZyB0aGUgdmFsdWUgb2YgdGhlIGxhc3Qgc2lnbmFsZWQKKyAqIGZlbmNlIGluIHRo aXMgdGltZWxpbmUuCisgKi8KK3ZvaWQgZmVuY2VfZGVmYXVsdF90aW1lbGluZV92YWx1ZV9zdHIo c3RydWN0IGZlbmNlICpmZW5jZSwgY2hhciAqc3RyLCBpbnQgc2l6ZSkKK3sKKwlzdHJ1Y3QgZmVu Y2VfdGltZWxpbmUgKnRpbWVsaW5lID0gZmVuY2VfcGFyZW50KGZlbmNlKTsKKworCXNucHJpbnRm KHN0ciwgc2l6ZSwgIiVkIiwgdGltZWxpbmUtPnZhbHVlKTsKK30KK0VYUE9SVF9TWU1CT0woZmVu Y2VfZGVmYXVsdF90aW1lbGluZV92YWx1ZV9zdHIpOworCiBzdGF0aWMgYm9vbAogZmVuY2VfdGVz dF9zaWduYWxlZF9hbnkoc3RydWN0IGZlbmNlICoqZmVuY2VzLCB1aW50MzJfdCBjb3VudCkKIHsK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N3X3N5bmMuYyBiL2RyaXZlcnMv c3RhZ2luZy9hbmRyb2lkL3N3X3N5bmMuYwppbmRleCBiZWQ2ODAxLi5jZmQ3YTE4IDEwMDY0NAot LS0gYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zd19zeW5jLmMKKysrIGIvZHJpdmVycy9zdGFn aW5nL2FuZHJvaWQvc3dfc3luYy5jCkBAIC01MSwyNiArNTEsOCBAQCBzdGF0aWMgaW50IHN3X3N5 bmNfZmlsbF9kcml2ZXJfZGF0YShzdHJ1Y3QgZmVuY2UgKmZlbmNlLAogCXJldHVybiBzaXplb2Yo cHQtPnZhbHVlKTsKIH0KIAotc3RhdGljIHZvaWQgc3dfc3luY190aW1lbGluZV92YWx1ZV9zdHIo c3RydWN0IGZlbmNlX3RpbWVsaW5lICpmZW5jZV90aW1lbGluZSwKLQkJCQkgICAgICAgY2hhciAq c3RyLCBpbnQgc2l6ZSkKLXsKLQlzdHJ1Y3Qgc3dfc3luY190aW1lbGluZSAqdGltZWxpbmUgPQot CQkoc3RydWN0IHN3X3N5bmNfdGltZWxpbmUgKilmZW5jZV90aW1lbGluZTsKLQlzbnByaW50Zihz dHIsIHNpemUsICIlZCIsIHRpbWVsaW5lLT52YWx1ZSk7Ci19Ci0KLXN0YXRpYyB2b2lkIHN3X3N5 bmNfZmVuY2VfdmFsdWVfc3RyKHN0cnVjdCBmZW5jZSAqZmVuY2UsCi0JCQkJIGNoYXIgKnN0ciwg aW50IHNpemUpCi17Ci0Jc3RydWN0IHN3X3N5bmNfcHQgKnB0ID0gKHN0cnVjdCBzd19zeW5jX3B0 ICopZmVuY2U7Ci0KLQlzbnByaW50ZihzdHIsIHNpemUsICIlZCIsIHB0LT52YWx1ZSk7Ci19Ci0K IHN0YXRpYyBzdHJ1Y3QgZmVuY2VfdGltZWxpbmVfb3BzIHN3X3N5bmNfdGltZWxpbmVfb3BzID0g ewogCS5maWxsX2RyaXZlcl9kYXRhID0gc3dfc3luY19maWxsX2RyaXZlcl9kYXRhLAotCS50aW1l bGluZV92YWx1ZV9zdHIgPSBzd19zeW5jX3RpbWVsaW5lX3ZhbHVlX3N0ciwKLQkuZmVuY2VfdmFs dWVfc3RyID0gc3dfc3luY19mZW5jZV92YWx1ZV9zdHIsCiB9OwogCiBzdHJ1Y3Qgc3dfc3luY190 aW1lbGluZSAqc3dfc3luY190aW1lbGluZV9jcmVhdGUoY29uc3QgY2hhciAqbmFtZSkKZGlmZiAt LWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuYyBiL2RyaXZlcnMvc3RhZ2luZy9h bmRyb2lkL3N5bmMuYwppbmRleCA4MjE2NjM1Li4xNDdhNDk0IDEwMDY0NAotLS0gYS9kcml2ZXJz L3N0YWdpbmcvYW5kcm9pZC9zeW5jLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3lu Yy5jCkBAIC0zMzEsMzIgKzMzMSw2IEBAIHN0YXRpYyBpbnQgc3luY19mZW5jZV9maWxsX2RyaXZl cl9kYXRhKHN0cnVjdCBmZW5jZSAqZmVuY2UsCiAJcmV0dXJuIHBhcmVudC0+b3BzLT5maWxsX2Ry aXZlcl9kYXRhKGZlbmNlLCBkYXRhLCBzaXplKTsKIH0KIAotc3RhdGljIHZvaWQgc3luY19mZW5j ZV92YWx1ZV9zdHIoc3RydWN0IGZlbmNlICpmZW5jZSwKLQkJCQkgICAgY2hhciAqc3RyLCBpbnQg c2l6ZSkKLXsKLQlzdHJ1Y3QgZmVuY2VfdGltZWxpbmUgKnBhcmVudCA9IGZlbmNlX3BhcmVudChm ZW5jZSk7Ci0KLQlpZiAoIXBhcmVudC0+b3BzLT5mZW5jZV92YWx1ZV9zdHIpIHsKLQkJaWYgKHNp emUpCi0JCQkqc3RyID0gMDsKLQkJcmV0dXJuOwotCX0KLQlwYXJlbnQtPm9wcy0+ZmVuY2VfdmFs dWVfc3RyKGZlbmNlLCBzdHIsIHNpemUpOwotfQotCi1zdGF0aWMgdm9pZCBzeW5jX2ZlbmNlX3Rp bWVsaW5lX3ZhbHVlX3N0cihzdHJ1Y3QgZmVuY2UgKmZlbmNlLAotCQkJCQkgICAgIGNoYXIgKnN0 ciwgaW50IHNpemUpCi17Ci0Jc3RydWN0IGZlbmNlX3RpbWVsaW5lICpwYXJlbnQgPSBmZW5jZV9w YXJlbnQoZmVuY2UpOwotCi0JaWYgKCFwYXJlbnQtPm9wcy0+dGltZWxpbmVfdmFsdWVfc3RyKSB7 Ci0JCWlmIChzaXplKQotCQkJKnN0ciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0JcGFyZW50LT5vcHMt PnRpbWVsaW5lX3ZhbHVlX3N0cihwYXJlbnQsIHN0ciwgc2l6ZSk7Ci19Ci0KIHN0YXRpYyBjb25z dCBzdHJ1Y3QgZmVuY2Vfb3BzIHN5bmNfZmVuY2Vfb3BzID0gewogCS5nZXRfZHJpdmVyX25hbWUg PSBmZW5jZV9kZWZhdWx0X2dldF9kcml2ZXJfbmFtZSwKIAkuZ2V0X3RpbWVsaW5lX25hbWUgPSBm ZW5jZV9kZWZhdWx0X2dldF90aW1lbGluZV9uYW1lLApAQCAtMzY1LDggKzMzOSw4IEBAIHN0YXRp YyBjb25zdCBzdHJ1Y3QgZmVuY2Vfb3BzIHN5bmNfZmVuY2Vfb3BzID0gewogCS53YWl0ID0gZmVu Y2VfZGVmYXVsdF93YWl0LAogCS5yZWxlYXNlID0gZmVuY2VfZGVmYXVsdF9yZWxlYXNlLAogCS5m aWxsX2RyaXZlcl9kYXRhID0gc3luY19mZW5jZV9maWxsX2RyaXZlcl9kYXRhLAotCS5mZW5jZV92 YWx1ZV9zdHIgPSBzeW5jX2ZlbmNlX3ZhbHVlX3N0ciwKLQkudGltZWxpbmVfdmFsdWVfc3RyID0g c3luY19mZW5jZV90aW1lbGluZV92YWx1ZV9zdHIsCisJLmZlbmNlX3ZhbHVlX3N0ciA9IGZlbmNl X2RlZmF1bHRfdmFsdWVfc3RyLAorCS50aW1lbGluZV92YWx1ZV9zdHIgPSBmZW5jZV9kZWZhdWx0 X3RpbWVsaW5lX3ZhbHVlX3N0ciwKIH07CiAKIHN0YXRpYyB2b2lkIHN5bmNfZmVuY2VfZnJlZShz dHJ1Y3Qga3JlZiAqa3JlZikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5 bmNfZGVidWcuYyBiL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmNfZGVidWcuYwppbmRleCBk YjYxOGNhLi44OWIzMzRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5j X2RlYnVnLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luY19kZWJ1Zy5jCkBAIC0x MzMsMTYgKzEzMyw3IEBAIHN0YXRpYyB2b2lkIHN5bmNfcHJpbnRfb2JqKHN0cnVjdCBzZXFfZmls ZSAqcywgc3RydWN0IGZlbmNlX3RpbWVsaW5lICpvYmopCiAJc3RydWN0IGxpc3RfaGVhZCAqcG9z OwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlzZXFfcHJpbnRmKHMsICIlcyAlcyIsIG9iai0+ bmFtZSwgb2JqLT5kcnZfbmFtZSk7Ci0KLQlpZiAob2JqLT5vcHMtPnRpbWVsaW5lX3ZhbHVlX3N0 cikgewotCQljaGFyIHZhbHVlWzY0XTsKLQotCQlvYmotPm9wcy0+dGltZWxpbmVfdmFsdWVfc3Ry KG9iaiwgdmFsdWUsIHNpemVvZih2YWx1ZSkpOwotCQlzZXFfcHJpbnRmKHMsICI6ICVzIiwgdmFs dWUpOwotCX0KLQotCXNlcV9wdXRzKHMsICJcbiIpOworCXNlcV9wcmludGYocywgIiVzICVzOiAl ZFxuIiwgb2JqLT5uYW1lLCBvYmotPmRydl9uYW1lLCBvYmotPnZhbHVlKTsKIAogCXNwaW5fbG9j a19pcnFzYXZlKCZvYmotPmxvY2ssIGZsYWdzKTsKIAlsaXN0X2Zvcl9lYWNoKHBvcywgJm9iai0+ Y2hpbGRfbGlzdF9oZWFkKSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2ZlbmNlLmggYi9p bmNsdWRlL2xpbnV4L2ZlbmNlLmgKaW5kZXggZTcxNTQ1ZS4uNTM3MWJlYiAxMDA2NDQKLS0tIGEv aW5jbHVkZS9saW51eC9mZW5jZS5oCisrKyBiL2luY2x1ZGUvbGludXgvZmVuY2UuaApAQCAtNDAs MTkgKzQwLDExIEBAIHN0cnVjdCBmZW5jZV9jYjsKICAqCQkJICBzaG91bGQgcmV0dXJuIGFuIGVy cm9yIGlmIHRoZXJlIGlzIG5vdCBlbm91Z2ggcm9vbQogICoJCQkgIGFzIHNwZWNpZmllZCBieSBz aXplLiAgVGhpcyBpbmZvcm1hdGlvbiBpcyByZXR1cm5lZAogICoJCQkgIHRvIHVzZXJzcGFjZSBi eSBTWU5DX0lPQ19GRU5DRV9JTkZPLgotICogQHRpbWVsaW5lX3ZhbHVlX3N0cjogZmlsbCBzdHIg d2l0aCB0aGUgdmFsdWUgb2YgdGhlIHN5bmNfdGltZWxpbmUncyBjb3VudGVyCiAgKiBAcHRfdmFs dWVfc3RyOglmaWxsIHN0ciB3aXRoIHRoZSB2YWx1ZSBvZiB0aGUgc3luY19wdAogICovCiBzdHJ1 Y3QgZmVuY2VfdGltZWxpbmVfb3BzIHsKIAkvKiBvcHRpb25hbCAqLwogCWludCAoKmZpbGxfZHJp dmVyX2RhdGEpKHN0cnVjdCBmZW5jZSAqZmVuY2UsIHZvaWQgKmRhdGEsIGludCBzaXplKTsKLQot CS8qIG9wdGlvbmFsICovCi0Jdm9pZCAoKnRpbWVsaW5lX3ZhbHVlX3N0cikoc3RydWN0IGZlbmNl X3RpbWVsaW5lICp0aW1lbGluZSwgY2hhciAqc3RyLAotCQkJCSAgIGludCBzaXplKTsKLQotCS8q IG9wdGlvbmFsICovCi0Jdm9pZCAoKmZlbmNlX3ZhbHVlX3N0cikoc3RydWN0IGZlbmNlICpmZW5j ZSwgY2hhciAqc3RyLCBpbnQgc2l6ZSk7CiB9OwogCiAvKioKQEAgLTI5Myw2ICsyODUsOCBAQCBi b29sIGZlbmNlX2RlZmF1bHRfc2lnbmFsZWQoc3RydWN0IGZlbmNlICpmZW5jZSk7CiBib29sIGZl bmNlX2RlZmF1bHRfZW5hYmxlX3NpZ25hbGluZyhzdHJ1Y3QgZmVuY2UgKmZlbmNlKTsKIHNpZ25l ZCBsb25nIGZlbmNlX2RlZmF1bHRfd2FpdChzdHJ1Y3QgZmVuY2UgKmZlbmNlLCBib29sIGludHIs IHNpZ25lZCBsb25nIHRpbWVvdXQpOwogdm9pZCBmZW5jZV9kZWZhdWx0X3JlbGVhc2Uoc3RydWN0 IGZlbmNlICpmZW5jZSk7Cit2b2lkIGZlbmNlX2RlZmF1bHRfdmFsdWVfc3RyKHN0cnVjdCBmZW5j ZSAqZmVuY2UsIGNoYXIgKnN0ciwgaW50IHNpemUpOwordm9pZCBmZW5jZV9kZWZhdWx0X3RpbWVs aW5lX3ZhbHVlX3N0cihzdHJ1Y3QgZmVuY2UgKmZlbmNlLCBjaGFyICpzdHIsIGludCBzaXplKTsK IGludCBmZW5jZV9hZGRfY2FsbGJhY2soc3RydWN0IGZlbmNlICpmZW5jZSwgc3RydWN0IGZlbmNl X2NiICpjYiwKIAkJICAgICAgIGZlbmNlX2Z1bmNfdCBmdW5jKTsKIGJvb2wgZmVuY2VfcmVtb3Zl X2NhbGxiYWNrKHN0cnVjdCBmZW5jZSAqZmVuY2UsIHN0cnVjdCBmZW5jZV9jYiAqY2IpOwpkaWZm IC0tZ2l0IGEvaW5jbHVkZS90cmFjZS9ldmVudHMvZmVuY2UuaCBiL2luY2x1ZGUvdHJhY2UvZXZl bnRzL2ZlbmNlLmgKaW5kZXggYzRkMDFkZS4uZTFjYTgwOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS90 cmFjZS9ldmVudHMvZmVuY2UuaAorKysgYi9pbmNsdWRlL3RyYWNlL2V2ZW50cy9mZW5jZS5oCkBA IC01NSwyMSArNTUsMTUgQEAgVFJBQ0VfRVZFTlQoZmVuY2VfdGltZWxpbmUsCiAKIAlUUF9TVFJV Q1RfX2VudHJ5KAogCQkJX19zdHJpbmcobmFtZSwgdGltZWxpbmUtPm5hbWUpCi0JCQlfX2FycmF5 KGNoYXIsIHZhbHVlLCAzMikKKwkJCV9fZmllbGQodW5zaWduZWQgaW50LCB2YWx1ZSkKIAkpLAog CiAJVFBfZmFzdF9hc3NpZ24oCiAJCQlfX2Fzc2lnbl9zdHIobmFtZSwgdGltZWxpbmUtPm5hbWUp OwotCQkJaWYgKHRpbWVsaW5lLT5vcHMtPnRpbWVsaW5lX3ZhbHVlX3N0cikgewotCQkJCXRpbWVs aW5lLT5vcHMtPnRpbWVsaW5lX3ZhbHVlX3N0cih0aW1lbGluZSwKLQkJCQkJCQlfX2VudHJ5LT52 YWx1ZSwKLQkJCQkJCQlzaXplb2YoX19lbnRyeS0+dmFsdWUpKTsKLQkJCX0gZWxzZSB7Ci0JCQkJ X19lbnRyeS0+dmFsdWVbMF0gPSAnXDAnOwotCQkJfQorCQkJX19lbnRyeS0+dmFsdWUgPSB0aW1l bGluZS0+dmFsdWU7CiAJKSwKIAotCVRQX3ByaW50aygibmFtZT0lcyB2YWx1ZT0lcyIsIF9fZ2V0 X3N0cihuYW1lKSwgX19lbnRyeS0+dmFsdWUpCisJVFBfcHJpbnRrKCJuYW1lPSVzIHZhbHVlPSV1 IiwgX19nZXRfc3RyKG5hbWUpLCBfX2VudHJ5LT52YWx1ZSkKICk7CiAKIERFQ0xBUkVfRVZFTlRf Q0xBU1MoZmVuY2UsCi0tIAoyLjUuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9kcmktZGV2ZWwK