From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754666AbcAOO4W (ORCPT ); Fri, 15 Jan 2016 09:56:22 -0500 Received: from mail-yk0-f175.google.com ([209.85.160.175]:33452 "EHLO mail-yk0-f175.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751781AbcAOO4T (ORCPT ); Fri, 15 Jan 2016 09:56:19 -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 09/29] staging/android: rename struct sync_fence's variables to 'sync_fence' Date: Fri, 15 Jan 2016 12:55:19 -0200 Message-Id: <1452869739-3304-10-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 To avoid confusion with struct fence vars that are most of the time called 'fence' as well we should rename all struct sync_fence's to sync_fence. Signed-off-by: Gustavo Padovan --- drivers/staging/android/sync.c | 192 ++++++++++++++++++----------------- drivers/staging/android/sync.h | 2 +- drivers/staging/android/sync_debug.c | 39 +++---- 3 files changed, 120 insertions(+), 113 deletions(-) diff --git a/drivers/staging/android/sync.c b/drivers/staging/android/sync.c index 273aa4b..c47b68d 100644 --- a/drivers/staging/android/sync.c +++ b/drivers/staging/android/sync.c @@ -149,61 +149,62 @@ EXPORT_SYMBOL(sync_pt_free); static struct sync_fence *sync_fence_alloc(int size, const char *name) { - struct sync_fence *fence; + struct sync_fence *sync_fence; - fence = kzalloc(size, GFP_KERNEL); - if (!fence) + sync_fence = kzalloc(size, GFP_KERNEL); + if (!sync_fence) return NULL; - fence->file = anon_inode_getfile("sync_fence", &sync_fence_fops, - fence, 0); - if (IS_ERR(fence->file)) + sync_fence->file = anon_inode_getfile("sync_fence", &sync_fence_fops, + sync_fence, 0); + if (IS_ERR(sync_fence->file)) goto err; - kref_init(&fence->kref); - strlcpy(fence->name, name, sizeof(fence->name)); + kref_init(&sync_fence->kref); + strlcpy(sync_fence->name, name, sizeof(sync_fence->name)); - init_waitqueue_head(&fence->wq); + init_waitqueue_head(&sync_fence->wq); - return fence; + return sync_fence; err: - kfree(fence); + kfree(sync_fence); return NULL; } static void fence_check_cb_func(struct fence *f, struct fence_cb *cb) { struct sync_fence_cb *check; - struct sync_fence *fence; + struct sync_fence *sync_fence; check = container_of(cb, struct sync_fence_cb, cb); - fence = check->fence; + sync_fence = check->sync_fence; - if (atomic_dec_and_test(&fence->status)) - wake_up_all(&fence->wq); + if (atomic_dec_and_test(&sync_fence->status)) + wake_up_all(&sync_fence->wq); } /* TODO: implement a create which takes more that one sync_pt */ struct sync_fence *sync_fence_create_dma(const char *name, struct fence *pt) { - struct sync_fence *fence; + struct sync_fence *sync_fence; - fence = sync_fence_alloc(offsetof(struct sync_fence, cbs[1]), name); - if (!fence) + sync_fence = sync_fence_alloc(offsetof(struct sync_fence, cbs[1]), + name); + if (!sync_fence) return NULL; - fence->num_fences = 1; - atomic_set(&fence->status, 1); + sync_fence->num_fences = 1; + atomic_set(&sync_fence->status, 1); - fence->cbs[0].sync_pt = pt; - fence->cbs[0].fence = fence; - if (fence_add_callback(pt, &fence->cbs[0].cb, fence_check_cb_func)) - atomic_dec(&fence->status); + sync_fence->cbs[0].sync_pt = pt; + sync_fence->cbs[0].sync_fence = sync_fence; + if (fence_add_callback(pt, &sync_fence->cbs[0].cb, fence_check_cb_func)) + atomic_dec(&sync_fence->status); - sync_fence_debug_add(fence); + sync_fence_debug_add(sync_fence); - return fence; + return sync_fence; } EXPORT_SYMBOL(sync_fence_create_dma); @@ -231,25 +232,26 @@ err: } EXPORT_SYMBOL(sync_fence_fdget); -void sync_fence_put(struct sync_fence *fence) +void sync_fence_put(struct sync_fence *sync_fence) { - fput(fence->file); + fput(sync_fence->file); } EXPORT_SYMBOL(sync_fence_put); -void sync_fence_install(struct sync_fence *fence, int fd) +void sync_fence_install(struct sync_fence *sync_fence, int fd) { - fd_install(fd, fence->file); + fd_install(fd, sync_fence->file); } EXPORT_SYMBOL(sync_fence_install); -static void sync_fence_add_pt(struct sync_fence *fence, +static void sync_fence_add_pt(struct sync_fence *sync_fence, int *i, struct fence *pt) { - fence->cbs[*i].sync_pt = pt; - fence->cbs[*i].fence = fence; + sync_fence->cbs[*i].sync_pt = pt; + sync_fence->cbs[*i].sync_fence = sync_fence; - if (!fence_add_callback(pt, &fence->cbs[*i].cb, fence_check_cb_func)) { + if (!fence_add_callback(pt, &sync_fence->cbs[*i].cb, + fence_check_cb_func)) { fence_get(pt); (*i)++; } @@ -259,15 +261,15 @@ struct sync_fence *sync_fence_merge(const char *name, struct sync_fence *a, struct sync_fence *b) { int num_fences = a->num_fences + b->num_fences; - struct sync_fence *fence; + struct sync_fence *sync_fence; int i, i_a, i_b; unsigned long size = offsetof(struct sync_fence, cbs[num_fences]); - fence = sync_fence_alloc(size, name); - if (!fence) + sync_fence = sync_fence_alloc(size, name); + if (!sync_fence) return NULL; - atomic_set(&fence->status, num_fences); + atomic_set(&sync_fence->status, num_fences); /* * Assume sync_fence a and b are both ordered and have no @@ -281,18 +283,18 @@ struct sync_fence *sync_fence_merge(const char *name, struct fence *pt_b = b->cbs[i_b].sync_pt; if (pt_a->context < pt_b->context) { - sync_fence_add_pt(fence, &i, pt_a); + sync_fence_add_pt(sync_fence, &i, pt_a); i_a++; } else if (pt_a->context > pt_b->context) { - sync_fence_add_pt(fence, &i, pt_b); + sync_fence_add_pt(sync_fence, &i, pt_b); i_b++; } else { if (pt_a->seqno - pt_b->seqno <= INT_MAX) - sync_fence_add_pt(fence, &i, pt_a); + sync_fence_add_pt(sync_fence, &i, pt_a); else - sync_fence_add_pt(fence, &i, pt_b); + sync_fence_add_pt(sync_fence, &i, pt_b); i_a++; i_b++; @@ -300,17 +302,17 @@ struct sync_fence *sync_fence_merge(const char *name, } for (; i_a < a->num_fences; i_a++) - sync_fence_add_pt(fence, &i, a->cbs[i_a].sync_pt); + sync_fence_add_pt(sync_fence, &i, a->cbs[i_a].sync_pt); for (; i_b < b->num_fences; i_b++) - sync_fence_add_pt(fence, &i, b->cbs[i_b].sync_pt); + sync_fence_add_pt(sync_fence, &i, b->cbs[i_b].sync_pt); if (num_fences > i) - atomic_sub(num_fences - i, &fence->status); - fence->num_fences = i; + atomic_sub(num_fences - i, &sync_fence->status); + sync_fence->num_fences = i; - sync_fence_debug_add(fence); - return fence; + sync_fence_debug_add(sync_fence); + return sync_fence; } EXPORT_SYMBOL(sync_fence_merge); @@ -326,10 +328,10 @@ int sync_fence_wake_up_wq(wait_queue_t *curr, unsigned mode, return 1; } -int sync_fence_wait_async(struct sync_fence *fence, +int sync_fence_wait_async(struct sync_fence *sync_fence, struct sync_fence_waiter *waiter) { - int err = atomic_read(&fence->status); + int err = atomic_read(&sync_fence->status); unsigned long flags; if (err < 0) @@ -339,13 +341,13 @@ int sync_fence_wait_async(struct sync_fence *fence, return 1; init_waitqueue_func_entry(&waiter->work, sync_fence_wake_up_wq); - waiter->work.private = fence; + waiter->work.private = sync_fence; - spin_lock_irqsave(&fence->wq.lock, flags); - err = atomic_read(&fence->status); + spin_lock_irqsave(&sync_fence->wq.lock, flags); + err = atomic_read(&sync_fence->status); if (err > 0) - __add_wait_queue_tail(&fence->wq, &waiter->work); - spin_unlock_irqrestore(&fence->wq.lock, flags); + __add_wait_queue_tail(&sync_fence->wq, &waiter->work); + spin_unlock_irqrestore(&sync_fence->wq.lock, flags); if (err < 0) return err; @@ -354,23 +356,23 @@ int sync_fence_wait_async(struct sync_fence *fence, } EXPORT_SYMBOL(sync_fence_wait_async); -int sync_fence_cancel_async(struct sync_fence *fence, +int sync_fence_cancel_async(struct sync_fence *sync_fence, struct sync_fence_waiter *waiter) { unsigned long flags; int ret = 0; - spin_lock_irqsave(&fence->wq.lock, flags); + spin_lock_irqsave(&sync_fence->wq.lock, flags); if (!list_empty(&waiter->work.task_list)) list_del_init(&waiter->work.task_list); else ret = -ENOENT; - spin_unlock_irqrestore(&fence->wq.lock, flags); + spin_unlock_irqrestore(&sync_fence->wq.lock, flags); return ret; } EXPORT_SYMBOL(sync_fence_cancel_async); -int sync_fence_wait(struct sync_fence *fence, long timeout) +int sync_fence_wait(struct sync_fence *sync_fence, long timeout) { long ret; int i; @@ -380,28 +382,28 @@ int sync_fence_wait(struct sync_fence *fence, long timeout) else timeout = msecs_to_jiffies(timeout); - trace_sync_wait(fence, 1); - for (i = 0; i < fence->num_fences; ++i) - trace_sync_pt(fence->cbs[i].sync_pt); - ret = wait_event_interruptible_timeout(fence->wq, - atomic_read(&fence->status) <= 0, + trace_sync_wait(sync_fence, 1); + for (i = 0; i < sync_fence->num_fences; ++i) + trace_sync_pt(sync_fence->cbs[i].sync_pt); + ret = wait_event_interruptible_timeout(sync_fence->wq, + atomic_read(&sync_fence->status) <= 0, timeout); - trace_sync_wait(fence, 0); + trace_sync_wait(sync_fence, 0); if (ret < 0) { return ret; } else if (ret == 0) { if (timeout) { - pr_info("fence timeout on [%p] after %dms\n", fence, - jiffies_to_msecs(timeout)); + pr_info("sync_fence timeout on [%p] after %dms\n", + sync_fence, jiffies_to_msecs(timeout)); sync_dump(); } return -ETIME; } - ret = atomic_read(&fence->status); + ret = atomic_read(&sync_fence->status); if (ret) { - pr_info("fence error %ld on [%p]\n", ret, fence); + pr_info("sync_fence error %ld on [%p]\n", ret, sync_fence); sync_dump(); } return ret; @@ -518,35 +520,37 @@ static const struct fence_ops sync_fence_ops = { static void sync_fence_free(struct kref *kref) { - struct sync_fence *fence = container_of(kref, struct sync_fence, kref); + struct sync_fence *sync_fence = container_of(kref, struct sync_fence, + kref); int i; - for (i = 0; i < fence->num_fences; ++i) { - fence_remove_callback(fence->cbs[i].sync_pt, &fence->cbs[i].cb); - fence_put(fence->cbs[i].sync_pt); + for (i = 0; i < sync_fence->num_fences; ++i) { + fence_remove_callback(sync_fence->cbs[i].sync_pt, + &sync_fence->cbs[i].cb); + fence_put(sync_fence->cbs[i].sync_pt); } - kfree(fence); + kfree(sync_fence); } static int sync_fence_file_release(struct inode *inode, struct file *file) { - struct sync_fence *fence = file->private_data; + struct sync_fence *sync_fence = file->private_data; - sync_fence_debug_remove(fence); + sync_fence_debug_remove(sync_fence); - kref_put(&fence->kref, sync_fence_free); + kref_put(&sync_fence->kref, sync_fence_free); return 0; } static unsigned int sync_fence_poll(struct file *file, poll_table *wait) { - struct sync_fence *fence = file->private_data; + struct sync_fence *sync_fence = file->private_data; int status; - poll_wait(file, &fence->wq, wait); + poll_wait(file, &sync_fence->wq, wait); - status = atomic_read(&fence->status); + status = atomic_read(&sync_fence->status); if (!status) return POLLIN; @@ -555,17 +559,19 @@ static unsigned int sync_fence_poll(struct file *file, poll_table *wait) return 0; } -static long sync_fence_ioctl_wait(struct sync_fence *fence, unsigned long arg) +static long sync_fence_ioctl_wait(struct sync_fence *sync_fence, + unsigned long arg) { __s32 value; if (copy_from_user(&value, (void __user *)arg, sizeof(value))) return -EFAULT; - return sync_fence_wait(fence, value); + return sync_fence_wait(sync_fence, value); } -static long sync_fence_ioctl_merge(struct sync_fence *fence, unsigned long arg) +static long sync_fence_ioctl_merge(struct sync_fence *sync_fence, + unsigned long arg) { int fd = get_unused_fd_flags(O_CLOEXEC); int err; @@ -587,7 +593,7 @@ static long sync_fence_ioctl_merge(struct sync_fence *fence, unsigned long arg) } data.name[sizeof(data.name) - 1] = '\0'; - fence3 = sync_fence_merge(data.name, fence, fence2); + fence3 = sync_fence_merge(data.name, sync_fence, fence2); if (!fence3) { err = -ENOMEM; goto err_put_fence2; @@ -646,7 +652,7 @@ static int sync_fill_pt_info(struct fence *fence, void *data, int size) return info->len; } -static long sync_fence_ioctl_fence_info(struct sync_fence *fence, +static long sync_fence_ioctl_fence_info(struct sync_fence *sync_fence, unsigned long arg) { struct sync_fence_info_data *data; @@ -667,15 +673,15 @@ static long sync_fence_ioctl_fence_info(struct sync_fence *fence, if (!data) return -ENOMEM; - strlcpy(data->name, fence->name, sizeof(data->name)); - data->status = atomic_read(&fence->status); + strlcpy(data->name, sync_fence->name, sizeof(data->name)); + data->status = atomic_read(&sync_fence->status); if (data->status >= 0) data->status = !data->status; len = sizeof(struct sync_fence_info_data); - for (i = 0; i < fence->num_fences; ++i) { - struct fence *pt = fence->cbs[i].sync_pt; + for (i = 0; i < sync_fence->num_fences; ++i) { + struct fence *pt = sync_fence->cbs[i].sync_pt; ret = sync_fill_pt_info(pt, (u8 *)data + len, size - len); @@ -701,17 +707,17 @@ out: static long sync_fence_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct sync_fence *fence = file->private_data; + struct sync_fence *sync_fence = file->private_data; switch (cmd) { case SYNC_IOC_WAIT: - return sync_fence_ioctl_wait(fence, arg); + return sync_fence_ioctl_wait(sync_fence, arg); case SYNC_IOC_MERGE: - return sync_fence_ioctl_merge(fence, arg); + return sync_fence_ioctl_merge(sync_fence, arg); case SYNC_IOC_FENCE_INFO: - return sync_fence_ioctl_fence_info(fence, arg); + return sync_fence_ioctl_fence_info(sync_fence, arg); default: return -ENOTTY; diff --git a/drivers/staging/android/sync.h b/drivers/staging/android/sync.h index ad45659..0fed642 100644 --- a/drivers/staging/android/sync.h +++ b/drivers/staging/android/sync.h @@ -111,7 +111,7 @@ static inline struct sync_timeline *sync_pt_parent(struct sync_pt *pt) struct sync_fence_cb { struct fence_cb cb; struct fence *sync_pt; - struct sync_fence *fence; + struct sync_fence *sync_fence; }; /** diff --git a/drivers/staging/android/sync_debug.c b/drivers/staging/android/sync_debug.c index 0a2df3f..cfa92d2 100644 --- a/drivers/staging/android/sync_debug.c +++ b/drivers/staging/android/sync_debug.c @@ -56,21 +56,21 @@ void sync_timeline_debug_remove(struct sync_timeline *obj) spin_unlock_irqrestore(&sync_timeline_list_lock, flags); } -void sync_fence_debug_add(struct sync_fence *fence) +void sync_fence_debug_add(struct sync_fence *sync_fence) { unsigned long flags; spin_lock_irqsave(&sync_fence_list_lock, flags); - list_add_tail(&fence->sync_fence_list, &sync_fence_list_head); + list_add_tail(&sync_fence->sync_fence_list, &sync_fence_list_head); spin_unlock_irqrestore(&sync_fence_list_lock, flags); } -void sync_fence_debug_remove(struct sync_fence *fence) +void sync_fence_debug_remove(struct sync_fence *sync_fence) { unsigned long flags; spin_lock_irqsave(&sync_fence_list_lock, flags); - list_del(&fence->sync_fence_list); + list_del(&sync_fence->sync_fence_list); spin_unlock_irqrestore(&sync_fence_list_lock, flags); } @@ -152,21 +152,22 @@ static void sync_print_obj(struct seq_file *s, struct sync_timeline *obj) spin_unlock_irqrestore(&obj->child_list_lock, flags); } -static void sync_print_fence(struct seq_file *s, struct sync_fence *fence) +static void sync_print_sync_fence(struct seq_file *s, + struct sync_fence *sync_fence) { wait_queue_t *pos; unsigned long flags; int i; - seq_printf(s, "[%p] %s: %s\n", fence, fence->name, - sync_status_str(atomic_read(&fence->status))); + seq_printf(s, "[%p] %s: %s\n", sync_fence, sync_fence->name, + sync_status_str(atomic_read(&sync_fence->status))); - for (i = 0; i < fence->num_fences; ++i) { - sync_print_pt(s, fence->cbs[i].sync_pt, true); + for (i = 0; i < sync_fence->num_fences; ++i) { + sync_print_pt(s, sync_fence->cbs[i].sync_pt, true); } - spin_lock_irqsave(&fence->wq.lock, flags); - list_for_each_entry(pos, &fence->wq.task_list, task_list) { + spin_lock_irqsave(&sync_fence->wq.lock, flags); + list_for_each_entry(pos, &sync_fence->wq.task_list, task_list) { struct sync_fence_waiter *waiter; if (pos->func != &sync_fence_wake_up_wq) @@ -176,7 +177,7 @@ static void sync_print_fence(struct seq_file *s, struct sync_fence *fence) seq_printf(s, "waiter %pF\n", waiter->callback); } - spin_unlock_irqrestore(&fence->wq.lock, flags); + spin_unlock_irqrestore(&sync_fence->wq.lock, flags); } static int sync_debugfs_show(struct seq_file *s, void *unused) @@ -201,10 +202,10 @@ static int sync_debugfs_show(struct seq_file *s, void *unused) spin_lock_irqsave(&sync_fence_list_lock, flags); list_for_each(pos, &sync_fence_list_head) { - struct sync_fence *fence = + struct sync_fence *sync_fence = container_of(pos, struct sync_fence, sync_fence_list); - sync_print_fence(s, fence); + sync_print_sync_fence(s, sync_fence); seq_puts(s, "\n"); } spin_unlock_irqrestore(&sync_fence_list_lock, flags); @@ -260,7 +261,7 @@ static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, int fd = get_unused_fd_flags(O_CLOEXEC); int err; struct sync_pt *pt; - struct sync_fence *fence; + struct sync_fence *sync_fence; struct sw_sync_create_fence_data data; if (fd < 0) @@ -278,8 +279,8 @@ static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, } data.name[sizeof(data.name) - 1] = '\0'; - fence = sync_fence_create(data.name, pt); - if (!fence) { + sync_fence = sync_fence_create(data.name, pt); + if (!sync_fence) { sync_pt_free(pt); err = -ENOMEM; goto err; @@ -287,12 +288,12 @@ static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj, data.fence = fd; if (copy_to_user((void __user *)arg, &data, sizeof(data))) { - sync_fence_put(fence); + sync_fence_put(sync_fence); err = -EFAULT; goto err; } - sync_fence_install(fence, fd); + sync_fence_install(sync_fence, fd); return 0; -- 2.5.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: [RFC 09/29] staging/android: rename struct sync_fence's variables to 'sync_fence' Date: Fri, 15 Jan 2016 12:55:19 -0200 Message-ID: <1452869739-3304-10-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-f179.google.com (mail-yk0-f179.google.com [209.85.160.179]) by gabe.freedesktop.org (Postfix) with ESMTPS id 772217A0E8 for ; Fri, 15 Jan 2016 06:56:18 -0800 (PST) Received: by mail-yk0-f179.google.com with SMTP id x67so546600422ykd.2 for ; Fri, 15 Jan 2016 06:56:18 -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 VG8gYXZvaWQgY29uZnVzaW9uIHdpdGggc3RydWN0IGZlbmNlIHZhcnMgdGhhdCBhcmUgbW9zdCBv ZiB0aGUgdGltZSBjYWxsZWQKJ2ZlbmNlJyBhcyB3ZWxsIHdlIHNob3VsZCByZW5hbWUgYWxsIHN0 cnVjdCBzeW5jX2ZlbmNlJ3MgdG8gc3luY19mZW5jZS4KClNpZ25lZC1vZmYtYnk6IEd1c3Rhdm8g UGFkb3ZhbiA8Z3VzdGF2by5wYWRvdmFuQGNvbGxhYm9yYS5jby51az4KLS0tCiBkcml2ZXJzL3N0 YWdpbmcvYW5kcm9pZC9zeW5jLmMgICAgICAgfCAxOTIgKysrKysrKysrKysrKysrKysrLS0tLS0t LS0tLS0tLS0tLS0KIGRyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuaCAgICAgICB8ICAgMiAr LQogZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luY19kZWJ1Zy5jIHwgIDM5ICsrKy0tLS0KIDMg ZmlsZXMgY2hhbmdlZCwgMTIwIGluc2VydGlvbnMoKyksIDExMyBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jLmMgYi9kcml2ZXJzL3N0YWdpbmcv YW5kcm9pZC9zeW5jLmMKaW5kZXggMjczYWE0Yi4uYzQ3YjY4ZCAxMDA2NDQKLS0tIGEvZHJpdmVy cy9zdGFnaW5nL2FuZHJvaWQvc3luYy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5 bmMuYwpAQCAtMTQ5LDYxICsxNDksNjIgQEAgRVhQT1JUX1NZTUJPTChzeW5jX3B0X2ZyZWUpOwog CiBzdGF0aWMgc3RydWN0IHN5bmNfZmVuY2UgKnN5bmNfZmVuY2VfYWxsb2MoaW50IHNpemUsIGNv bnN0IGNoYXIgKm5hbWUpCiB7Ci0Jc3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlOworCXN0cnVjdCBz eW5jX2ZlbmNlICpzeW5jX2ZlbmNlOwogCi0JZmVuY2UgPSBremFsbG9jKHNpemUsIEdGUF9LRVJO RUwpOwotCWlmICghZmVuY2UpCisJc3luY19mZW5jZSA9IGt6YWxsb2Moc2l6ZSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFzeW5jX2ZlbmNlKQogCQlyZXR1cm4gTlVMTDsKIAotCWZlbmNlLT5maWxlID0g YW5vbl9pbm9kZV9nZXRmaWxlKCJzeW5jX2ZlbmNlIiwgJnN5bmNfZmVuY2VfZm9wcywKLQkJCQkJ IGZlbmNlLCAwKTsKLQlpZiAoSVNfRVJSKGZlbmNlLT5maWxlKSkKKwlzeW5jX2ZlbmNlLT5maWxl ID0gYW5vbl9pbm9kZV9nZXRmaWxlKCJzeW5jX2ZlbmNlIiwgJnN5bmNfZmVuY2VfZm9wcywKKwkJ CQkJICAgICAgc3luY19mZW5jZSwgMCk7CisJaWYgKElTX0VSUihzeW5jX2ZlbmNlLT5maWxlKSkK IAkJZ290byBlcnI7CiAKLQlrcmVmX2luaXQoJmZlbmNlLT5rcmVmKTsKLQlzdHJsY3B5KGZlbmNl LT5uYW1lLCBuYW1lLCBzaXplb2YoZmVuY2UtPm5hbWUpKTsKKwlrcmVmX2luaXQoJnN5bmNfZmVu Y2UtPmtyZWYpOworCXN0cmxjcHkoc3luY19mZW5jZS0+bmFtZSwgbmFtZSwgc2l6ZW9mKHN5bmNf ZmVuY2UtPm5hbWUpKTsKIAotCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmZlbmNlLT53cSk7CisJaW5p dF93YWl0cXVldWVfaGVhZCgmc3luY19mZW5jZS0+d3EpOwogCi0JcmV0dXJuIGZlbmNlOworCXJl dHVybiBzeW5jX2ZlbmNlOwogCiBlcnI6Ci0Ja2ZyZWUoZmVuY2UpOworCWtmcmVlKHN5bmNfZmVu Y2UpOwogCXJldHVybiBOVUxMOwogfQogCiBzdGF0aWMgdm9pZCBmZW5jZV9jaGVja19jYl9mdW5j KHN0cnVjdCBmZW5jZSAqZiwgc3RydWN0IGZlbmNlX2NiICpjYikKIHsKIAlzdHJ1Y3Qgc3luY19m ZW5jZV9jYiAqY2hlY2s7Ci0Jc3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlOworCXN0cnVjdCBzeW5j X2ZlbmNlICpzeW5jX2ZlbmNlOwogCiAJY2hlY2sgPSBjb250YWluZXJfb2YoY2IsIHN0cnVjdCBz eW5jX2ZlbmNlX2NiLCBjYik7Ci0JZmVuY2UgPSBjaGVjay0+ZmVuY2U7CisJc3luY19mZW5jZSA9 IGNoZWNrLT5zeW5jX2ZlbmNlOwogCi0JaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmZlbmNlLT5z dGF0dXMpKQotCQl3YWtlX3VwX2FsbCgmZmVuY2UtPndxKTsKKwlpZiAoYXRvbWljX2RlY19hbmRf dGVzdCgmc3luY19mZW5jZS0+c3RhdHVzKSkKKwkJd2FrZV91cF9hbGwoJnN5bmNfZmVuY2UtPndx KTsKIH0KIAogLyogVE9ETzogaW1wbGVtZW50IGEgY3JlYXRlIHdoaWNoIHRha2VzIG1vcmUgdGhh dCBvbmUgc3luY19wdCAqLwogc3RydWN0IHN5bmNfZmVuY2UgKnN5bmNfZmVuY2VfY3JlYXRlX2Rt YShjb25zdCBjaGFyICpuYW1lLCBzdHJ1Y3QgZmVuY2UgKnB0KQogewotCXN0cnVjdCBzeW5jX2Zl bmNlICpmZW5jZTsKKwlzdHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZTsKIAotCWZlbmNlID0g c3luY19mZW5jZV9hbGxvYyhvZmZzZXRvZihzdHJ1Y3Qgc3luY19mZW5jZSwgY2JzWzFdKSwgbmFt ZSk7Ci0JaWYgKCFmZW5jZSkKKwlzeW5jX2ZlbmNlID0gc3luY19mZW5jZV9hbGxvYyhvZmZzZXRv ZihzdHJ1Y3Qgc3luY19mZW5jZSwgY2JzWzFdKSwKKwkJCQkgICAgICBuYW1lKTsKKwlpZiAoIXN5 bmNfZmVuY2UpCiAJCXJldHVybiBOVUxMOwogCi0JZmVuY2UtPm51bV9mZW5jZXMgPSAxOwotCWF0 b21pY19zZXQoJmZlbmNlLT5zdGF0dXMsIDEpOworCXN5bmNfZmVuY2UtPm51bV9mZW5jZXMgPSAx OworCWF0b21pY19zZXQoJnN5bmNfZmVuY2UtPnN0YXR1cywgMSk7CiAKLQlmZW5jZS0+Y2JzWzBd LnN5bmNfcHQgPSBwdDsKLQlmZW5jZS0+Y2JzWzBdLmZlbmNlID0gZmVuY2U7Ci0JaWYgKGZlbmNl X2FkZF9jYWxsYmFjayhwdCwgJmZlbmNlLT5jYnNbMF0uY2IsIGZlbmNlX2NoZWNrX2NiX2Z1bmMp KQotCQlhdG9taWNfZGVjKCZmZW5jZS0+c3RhdHVzKTsKKwlzeW5jX2ZlbmNlLT5jYnNbMF0uc3lu Y19wdCA9IHB0OworCXN5bmNfZmVuY2UtPmNic1swXS5zeW5jX2ZlbmNlID0gc3luY19mZW5jZTsK KwlpZiAoZmVuY2VfYWRkX2NhbGxiYWNrKHB0LCAmc3luY19mZW5jZS0+Y2JzWzBdLmNiLCBmZW5j ZV9jaGVja19jYl9mdW5jKSkKKwkJYXRvbWljX2RlYygmc3luY19mZW5jZS0+c3RhdHVzKTsKIAot CXN5bmNfZmVuY2VfZGVidWdfYWRkKGZlbmNlKTsKKwlzeW5jX2ZlbmNlX2RlYnVnX2FkZChzeW5j X2ZlbmNlKTsKIAotCXJldHVybiBmZW5jZTsKKwlyZXR1cm4gc3luY19mZW5jZTsKIH0KIEVYUE9S VF9TWU1CT0woc3luY19mZW5jZV9jcmVhdGVfZG1hKTsKIApAQCAtMjMxLDI1ICsyMzIsMjYgQEAg ZXJyOgogfQogRVhQT1JUX1NZTUJPTChzeW5jX2ZlbmNlX2ZkZ2V0KTsKIAotdm9pZCBzeW5jX2Zl bmNlX3B1dChzdHJ1Y3Qgc3luY19mZW5jZSAqZmVuY2UpCit2b2lkIHN5bmNfZmVuY2VfcHV0KHN0 cnVjdCBzeW5jX2ZlbmNlICpzeW5jX2ZlbmNlKQogewotCWZwdXQoZmVuY2UtPmZpbGUpOworCWZw dXQoc3luY19mZW5jZS0+ZmlsZSk7CiB9CiBFWFBPUlRfU1lNQk9MKHN5bmNfZmVuY2VfcHV0KTsK IAotdm9pZCBzeW5jX2ZlbmNlX2luc3RhbGwoc3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlLCBpbnQg ZmQpCit2b2lkIHN5bmNfZmVuY2VfaW5zdGFsbChzdHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5j ZSwgaW50IGZkKQogewotCWZkX2luc3RhbGwoZmQsIGZlbmNlLT5maWxlKTsKKwlmZF9pbnN0YWxs KGZkLCBzeW5jX2ZlbmNlLT5maWxlKTsKIH0KIEVYUE9SVF9TWU1CT0woc3luY19mZW5jZV9pbnN0 YWxsKTsKIAotc3RhdGljIHZvaWQgc3luY19mZW5jZV9hZGRfcHQoc3RydWN0IHN5bmNfZmVuY2Ug KmZlbmNlLAorc3RhdGljIHZvaWQgc3luY19mZW5jZV9hZGRfcHQoc3RydWN0IHN5bmNfZmVuY2Ug KnN5bmNfZmVuY2UsCiAJCQkgICAgICBpbnQgKmksIHN0cnVjdCBmZW5jZSAqcHQpCiB7Ci0JZmVu Y2UtPmNic1sqaV0uc3luY19wdCA9IHB0OwotCWZlbmNlLT5jYnNbKmldLmZlbmNlID0gZmVuY2U7 CisJc3luY19mZW5jZS0+Y2JzWyppXS5zeW5jX3B0ID0gcHQ7CisJc3luY19mZW5jZS0+Y2JzWypp XS5zeW5jX2ZlbmNlID0gc3luY19mZW5jZTsKIAotCWlmICghZmVuY2VfYWRkX2NhbGxiYWNrKHB0 LCAmZmVuY2UtPmNic1sqaV0uY2IsIGZlbmNlX2NoZWNrX2NiX2Z1bmMpKSB7CisJaWYgKCFmZW5j ZV9hZGRfY2FsbGJhY2socHQsICZzeW5jX2ZlbmNlLT5jYnNbKmldLmNiLAorCQkJCWZlbmNlX2No ZWNrX2NiX2Z1bmMpKSB7CiAJCWZlbmNlX2dldChwdCk7CiAJCSgqaSkrKzsKIAl9CkBAIC0yNTks MTUgKzI2MSwxNSBAQCBzdHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZV9tZXJnZShjb25zdCBj aGFyICpuYW1lLAogCQkJCSAgICBzdHJ1Y3Qgc3luY19mZW5jZSAqYSwgc3RydWN0IHN5bmNfZmVu Y2UgKmIpCiB7CiAJaW50IG51bV9mZW5jZXMgPSBhLT5udW1fZmVuY2VzICsgYi0+bnVtX2ZlbmNl czsKLQlzdHJ1Y3Qgc3luY19mZW5jZSAqZmVuY2U7CisJc3RydWN0IHN5bmNfZmVuY2UgKnN5bmNf ZmVuY2U7CiAJaW50IGksIGlfYSwgaV9iOwogCXVuc2lnbmVkIGxvbmcgc2l6ZSA9IG9mZnNldG9m KHN0cnVjdCBzeW5jX2ZlbmNlLCBjYnNbbnVtX2ZlbmNlc10pOwogCi0JZmVuY2UgPSBzeW5jX2Zl bmNlX2FsbG9jKHNpemUsIG5hbWUpOwotCWlmICghZmVuY2UpCisJc3luY19mZW5jZSA9IHN5bmNf ZmVuY2VfYWxsb2Moc2l6ZSwgbmFtZSk7CisJaWYgKCFzeW5jX2ZlbmNlKQogCQlyZXR1cm4gTlVM TDsKIAotCWF0b21pY19zZXQoJmZlbmNlLT5zdGF0dXMsIG51bV9mZW5jZXMpOworCWF0b21pY19z ZXQoJnN5bmNfZmVuY2UtPnN0YXR1cywgbnVtX2ZlbmNlcyk7CiAKIAkvKgogCSAqIEFzc3VtZSBz eW5jX2ZlbmNlIGEgYW5kIGIgYXJlIGJvdGggb3JkZXJlZCBhbmQgaGF2ZSBubwpAQCAtMjgxLDE4 ICsyODMsMTggQEAgc3RydWN0IHN5bmNfZmVuY2UgKnN5bmNfZmVuY2VfbWVyZ2UoY29uc3QgY2hh ciAqbmFtZSwKIAkJc3RydWN0IGZlbmNlICpwdF9iID0gYi0+Y2JzW2lfYl0uc3luY19wdDsKIAog CQlpZiAocHRfYS0+Y29udGV4dCA8IHB0X2ItPmNvbnRleHQpIHsKLQkJCXN5bmNfZmVuY2VfYWRk X3B0KGZlbmNlLCAmaSwgcHRfYSk7CisJCQlzeW5jX2ZlbmNlX2FkZF9wdChzeW5jX2ZlbmNlLCAm aSwgcHRfYSk7CiAKIAkJCWlfYSsrOwogCQl9IGVsc2UgaWYgKHB0X2EtPmNvbnRleHQgPiBwdF9i LT5jb250ZXh0KSB7Ci0JCQlzeW5jX2ZlbmNlX2FkZF9wdChmZW5jZSwgJmksIHB0X2IpOworCQkJ c3luY19mZW5jZV9hZGRfcHQoc3luY19mZW5jZSwgJmksIHB0X2IpOwogCiAJCQlpX2IrKzsKIAkJ fSBlbHNlIHsKIAkJCWlmIChwdF9hLT5zZXFubyAtIHB0X2ItPnNlcW5vIDw9IElOVF9NQVgpCi0J CQkJc3luY19mZW5jZV9hZGRfcHQoZmVuY2UsICZpLCBwdF9hKTsKKwkJCQlzeW5jX2ZlbmNlX2Fk ZF9wdChzeW5jX2ZlbmNlLCAmaSwgcHRfYSk7CiAJCQllbHNlCi0JCQkJc3luY19mZW5jZV9hZGRf cHQoZmVuY2UsICZpLCBwdF9iKTsKKwkJCQlzeW5jX2ZlbmNlX2FkZF9wdChzeW5jX2ZlbmNlLCAm aSwgcHRfYik7CiAKIAkJCWlfYSsrOwogCQkJaV9iKys7CkBAIC0zMDAsMTcgKzMwMiwxNyBAQCBz dHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZV9tZXJnZShjb25zdCBjaGFyICpuYW1lLAogCX0K IAogCWZvciAoOyBpX2EgPCBhLT5udW1fZmVuY2VzOyBpX2ErKykKLQkJc3luY19mZW5jZV9hZGRf cHQoZmVuY2UsICZpLCBhLT5jYnNbaV9hXS5zeW5jX3B0KTsKKwkJc3luY19mZW5jZV9hZGRfcHQo c3luY19mZW5jZSwgJmksIGEtPmNic1tpX2FdLnN5bmNfcHQpOwogCiAJZm9yICg7IGlfYiA8IGIt Pm51bV9mZW5jZXM7IGlfYisrKQotCQlzeW5jX2ZlbmNlX2FkZF9wdChmZW5jZSwgJmksIGItPmNi c1tpX2JdLnN5bmNfcHQpOworCQlzeW5jX2ZlbmNlX2FkZF9wdChzeW5jX2ZlbmNlLCAmaSwgYi0+ Y2JzW2lfYl0uc3luY19wdCk7CiAKIAlpZiAobnVtX2ZlbmNlcyA+IGkpCi0JCWF0b21pY19zdWIo bnVtX2ZlbmNlcyAtIGksICZmZW5jZS0+c3RhdHVzKTsKLQlmZW5jZS0+bnVtX2ZlbmNlcyA9IGk7 CisJCWF0b21pY19zdWIobnVtX2ZlbmNlcyAtIGksICZzeW5jX2ZlbmNlLT5zdGF0dXMpOworCXN5 bmNfZmVuY2UtPm51bV9mZW5jZXMgPSBpOwogCi0Jc3luY19mZW5jZV9kZWJ1Z19hZGQoZmVuY2Up OwotCXJldHVybiBmZW5jZTsKKwlzeW5jX2ZlbmNlX2RlYnVnX2FkZChzeW5jX2ZlbmNlKTsKKwly ZXR1cm4gc3luY19mZW5jZTsKIH0KIEVYUE9SVF9TWU1CT0woc3luY19mZW5jZV9tZXJnZSk7CiAK QEAgLTMyNiwxMCArMzI4LDEwIEBAIGludCBzeW5jX2ZlbmNlX3dha2VfdXBfd3Eod2FpdF9xdWV1 ZV90ICpjdXJyLCB1bnNpZ25lZCBtb2RlLAogCXJldHVybiAxOwogfQogCi1pbnQgc3luY19mZW5j ZV93YWl0X2FzeW5jKHN0cnVjdCBzeW5jX2ZlbmNlICpmZW5jZSwKK2ludCBzeW5jX2ZlbmNlX3dh aXRfYXN5bmMoc3RydWN0IHN5bmNfZmVuY2UgKnN5bmNfZmVuY2UsCiAJCQkgIHN0cnVjdCBzeW5j X2ZlbmNlX3dhaXRlciAqd2FpdGVyKQogewotCWludCBlcnIgPSBhdG9taWNfcmVhZCgmZmVuY2Ut PnN0YXR1cyk7CisJaW50IGVyciA9IGF0b21pY19yZWFkKCZzeW5jX2ZlbmNlLT5zdGF0dXMpOwog CXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlpZiAoZXJyIDwgMCkKQEAgLTMzOSwxMyArMzQxLDEz IEBAIGludCBzeW5jX2ZlbmNlX3dhaXRfYXN5bmMoc3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlLAog CQlyZXR1cm4gMTsKIAogCWluaXRfd2FpdHF1ZXVlX2Z1bmNfZW50cnkoJndhaXRlci0+d29yaywg c3luY19mZW5jZV93YWtlX3VwX3dxKTsKLQl3YWl0ZXItPndvcmsucHJpdmF0ZSA9IGZlbmNlOwor CXdhaXRlci0+d29yay5wcml2YXRlID0gc3luY19mZW5jZTsKIAotCXNwaW5fbG9ja19pcnFzYXZl KCZmZW5jZS0+d3EubG9jaywgZmxhZ3MpOwotCWVyciA9IGF0b21pY19yZWFkKCZmZW5jZS0+c3Rh dHVzKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmc3luY19mZW5jZS0+d3EubG9jaywgZmxhZ3MpOwor CWVyciA9IGF0b21pY19yZWFkKCZzeW5jX2ZlbmNlLT5zdGF0dXMpOwogCWlmIChlcnIgPiAwKQot CQlfX2FkZF93YWl0X3F1ZXVlX3RhaWwoJmZlbmNlLT53cSwgJndhaXRlci0+d29yayk7Ci0Jc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmZmVuY2UtPndxLmxvY2ssIGZsYWdzKTsKKwkJX19hZGRfd2Fp dF9xdWV1ZV90YWlsKCZzeW5jX2ZlbmNlLT53cSwgJndhaXRlci0+d29yayk7CisJc3Bpbl91bmxv Y2tfaXJxcmVzdG9yZSgmc3luY19mZW5jZS0+d3EubG9jaywgZmxhZ3MpOwogCiAJaWYgKGVyciA8 IDApCiAJCXJldHVybiBlcnI7CkBAIC0zNTQsMjMgKzM1NiwyMyBAQCBpbnQgc3luY19mZW5jZV93 YWl0X2FzeW5jKHN0cnVjdCBzeW5jX2ZlbmNlICpmZW5jZSwKIH0KIEVYUE9SVF9TWU1CT0woc3lu Y19mZW5jZV93YWl0X2FzeW5jKTsKIAotaW50IHN5bmNfZmVuY2VfY2FuY2VsX2FzeW5jKHN0cnVj dCBzeW5jX2ZlbmNlICpmZW5jZSwKK2ludCBzeW5jX2ZlbmNlX2NhbmNlbF9hc3luYyhzdHJ1Y3Qg c3luY19mZW5jZSAqc3luY19mZW5jZSwKIAkJCSAgICBzdHJ1Y3Qgc3luY19mZW5jZV93YWl0ZXIg KndhaXRlcikKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXQgPSAwOwogCi0Jc3Bp bl9sb2NrX2lycXNhdmUoJmZlbmNlLT53cS5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycXNh dmUoJnN5bmNfZmVuY2UtPndxLmxvY2ssIGZsYWdzKTsKIAlpZiAoIWxpc3RfZW1wdHkoJndhaXRl ci0+d29yay50YXNrX2xpc3QpKQogCQlsaXN0X2RlbF9pbml0KCZ3YWl0ZXItPndvcmsudGFza19s aXN0KTsKIAllbHNlCiAJCXJldCA9IC1FTk9FTlQ7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgm ZmVuY2UtPndxLmxvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzeW5jX2Zl bmNlLT53cS5sb2NrLCBmbGFncyk7CiAJcmV0dXJuIHJldDsKIH0KIEVYUE9SVF9TWU1CT0woc3lu Y19mZW5jZV9jYW5jZWxfYXN5bmMpOwogCi1pbnQgc3luY19mZW5jZV93YWl0KHN0cnVjdCBzeW5j X2ZlbmNlICpmZW5jZSwgbG9uZyB0aW1lb3V0KQoraW50IHN5bmNfZmVuY2Vfd2FpdChzdHJ1Y3Qg c3luY19mZW5jZSAqc3luY19mZW5jZSwgbG9uZyB0aW1lb3V0KQogewogCWxvbmcgcmV0OwogCWlu dCBpOwpAQCAtMzgwLDI4ICszODIsMjggQEAgaW50IHN5bmNfZmVuY2Vfd2FpdChzdHJ1Y3Qgc3lu Y19mZW5jZSAqZmVuY2UsIGxvbmcgdGltZW91dCkKIAllbHNlCiAJCXRpbWVvdXQgPSBtc2Vjc190 b19qaWZmaWVzKHRpbWVvdXQpOwogCi0JdHJhY2Vfc3luY193YWl0KGZlbmNlLCAxKTsKLQlmb3Ig KGkgPSAwOyBpIDwgZmVuY2UtPm51bV9mZW5jZXM7ICsraSkKLQkJdHJhY2Vfc3luY19wdChmZW5j ZS0+Y2JzW2ldLnN5bmNfcHQpOwotCXJldCA9IHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZV90aW1l b3V0KGZlbmNlLT53cSwKLQkJCQkJICAgICAgIGF0b21pY19yZWFkKCZmZW5jZS0+c3RhdHVzKSA8 PSAwLAorCXRyYWNlX3N5bmNfd2FpdChzeW5jX2ZlbmNlLCAxKTsKKwlmb3IgKGkgPSAwOyBpIDwg c3luY19mZW5jZS0+bnVtX2ZlbmNlczsgKytpKQorCQl0cmFjZV9zeW5jX3B0KHN5bmNfZmVuY2Ut PmNic1tpXS5zeW5jX3B0KTsKKwlyZXQgPSB3YWl0X2V2ZW50X2ludGVycnVwdGlibGVfdGltZW91 dChzeW5jX2ZlbmNlLT53cSwKKwkJCQkJICAgICAgIGF0b21pY19yZWFkKCZzeW5jX2ZlbmNlLT5z dGF0dXMpIDw9IDAsCiAJCQkJCSAgICAgICB0aW1lb3V0KTsKLQl0cmFjZV9zeW5jX3dhaXQoZmVu Y2UsIDApOworCXRyYWNlX3N5bmNfd2FpdChzeW5jX2ZlbmNlLCAwKTsKIAogCWlmIChyZXQgPCAw KSB7CiAJCXJldHVybiByZXQ7CiAJfSBlbHNlIGlmIChyZXQgPT0gMCkgewogCQlpZiAodGltZW91 dCkgewotCQkJcHJfaW5mbygiZmVuY2UgdGltZW91dCBvbiBbJXBdIGFmdGVyICVkbXNcbiIsIGZl bmNlLAotCQkJCWppZmZpZXNfdG9fbXNlY3ModGltZW91dCkpOworCQkJcHJfaW5mbygic3luY19m ZW5jZSB0aW1lb3V0IG9uIFslcF0gYWZ0ZXIgJWRtc1xuIiwKKwkJCQlzeW5jX2ZlbmNlLCBqaWZm aWVzX3RvX21zZWNzKHRpbWVvdXQpKTsKIAkJCXN5bmNfZHVtcCgpOwogCQl9CiAJCXJldHVybiAt RVRJTUU7CiAJfQogCi0JcmV0ID0gYXRvbWljX3JlYWQoJmZlbmNlLT5zdGF0dXMpOworCXJldCA9 IGF0b21pY19yZWFkKCZzeW5jX2ZlbmNlLT5zdGF0dXMpOwogCWlmIChyZXQpIHsKLQkJcHJfaW5m bygiZmVuY2UgZXJyb3IgJWxkIG9uIFslcF1cbiIsIHJldCwgZmVuY2UpOworCQlwcl9pbmZvKCJz eW5jX2ZlbmNlIGVycm9yICVsZCBvbiBbJXBdXG4iLCByZXQsIHN5bmNfZmVuY2UpOwogCQlzeW5j X2R1bXAoKTsKIAl9CiAJcmV0dXJuIHJldDsKQEAgLTUxOCwzNSArNTIwLDM3IEBAIHN0YXRpYyBj b25zdCBzdHJ1Y3QgZmVuY2Vfb3BzIHN5bmNfZmVuY2Vfb3BzID0gewogCiBzdGF0aWMgdm9pZCBz eW5jX2ZlbmNlX2ZyZWUoc3RydWN0IGtyZWYgKmtyZWYpCiB7Ci0Jc3RydWN0IHN5bmNfZmVuY2Ug KmZlbmNlID0gY29udGFpbmVyX29mKGtyZWYsIHN0cnVjdCBzeW5jX2ZlbmNlLCBrcmVmKTsKKwlz dHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZSA9IGNvbnRhaW5lcl9vZihrcmVmLCBzdHJ1Y3Qg c3luY19mZW5jZSwKKwkJCQkJCSAgICAga3JlZik7CiAJaW50IGk7CiAKLQlmb3IgKGkgPSAwOyBp IDwgZmVuY2UtPm51bV9mZW5jZXM7ICsraSkgewotCQlmZW5jZV9yZW1vdmVfY2FsbGJhY2soZmVu Y2UtPmNic1tpXS5zeW5jX3B0LCAmZmVuY2UtPmNic1tpXS5jYik7Ci0JCWZlbmNlX3B1dChmZW5j ZS0+Y2JzW2ldLnN5bmNfcHQpOworCWZvciAoaSA9IDA7IGkgPCBzeW5jX2ZlbmNlLT5udW1fZmVu Y2VzOyArK2kpIHsKKwkJZmVuY2VfcmVtb3ZlX2NhbGxiYWNrKHN5bmNfZmVuY2UtPmNic1tpXS5z eW5jX3B0LAorCQkJCSAgICAgICZzeW5jX2ZlbmNlLT5jYnNbaV0uY2IpOworCQlmZW5jZV9wdXQo c3luY19mZW5jZS0+Y2JzW2ldLnN5bmNfcHQpOwogCX0KIAotCWtmcmVlKGZlbmNlKTsKKwlrZnJl ZShzeW5jX2ZlbmNlKTsKIH0KIAogc3RhdGljIGludCBzeW5jX2ZlbmNlX2ZpbGVfcmVsZWFzZShz dHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKIHsKLQlzdHJ1Y3Qgc3luY19m ZW5jZSAqZmVuY2UgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJc3RydWN0IHN5bmNfZmVuY2UgKnN5 bmNfZmVuY2UgPSBmaWxlLT5wcml2YXRlX2RhdGE7CiAKLQlzeW5jX2ZlbmNlX2RlYnVnX3JlbW92 ZShmZW5jZSk7CisJc3luY19mZW5jZV9kZWJ1Z19yZW1vdmUoc3luY19mZW5jZSk7CiAKLQlrcmVm X3B1dCgmZmVuY2UtPmtyZWYsIHN5bmNfZmVuY2VfZnJlZSk7CisJa3JlZl9wdXQoJnN5bmNfZmVu Y2UtPmtyZWYsIHN5bmNfZmVuY2VfZnJlZSk7CiAJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyB1bnNp Z25lZCBpbnQgc3luY19mZW5jZV9wb2xsKHN0cnVjdCBmaWxlICpmaWxlLCBwb2xsX3RhYmxlICp3 YWl0KQogewotCXN0cnVjdCBzeW5jX2ZlbmNlICpmZW5jZSA9IGZpbGUtPnByaXZhdGVfZGF0YTsK KwlzdHJ1Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZSA9IGZpbGUtPnByaXZhdGVfZGF0YTsKIAlp bnQgc3RhdHVzOwogCi0JcG9sbF93YWl0KGZpbGUsICZmZW5jZS0+d3EsIHdhaXQpOworCXBvbGxf d2FpdChmaWxlLCAmc3luY19mZW5jZS0+d3EsIHdhaXQpOwogCi0Jc3RhdHVzID0gYXRvbWljX3Jl YWQoJmZlbmNlLT5zdGF0dXMpOworCXN0YXR1cyA9IGF0b21pY19yZWFkKCZzeW5jX2ZlbmNlLT5z dGF0dXMpOwogCiAJaWYgKCFzdGF0dXMpCiAJCXJldHVybiBQT0xMSU47CkBAIC01NTUsMTcgKzU1 OSwxOSBAQCBzdGF0aWMgdW5zaWduZWQgaW50IHN5bmNfZmVuY2VfcG9sbChzdHJ1Y3QgZmlsZSAq ZmlsZSwgcG9sbF90YWJsZSAqd2FpdCkKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGxvbmcgc3lu Y19mZW5jZV9pb2N0bF93YWl0KHN0cnVjdCBzeW5jX2ZlbmNlICpmZW5jZSwgdW5zaWduZWQgbG9u ZyBhcmcpCitzdGF0aWMgbG9uZyBzeW5jX2ZlbmNlX2lvY3RsX3dhaXQoc3RydWN0IHN5bmNfZmVu Y2UgKnN5bmNfZmVuY2UsCisJCQkJICB1bnNpZ25lZCBsb25nIGFyZykKIHsKIAlfX3MzMiB2YWx1 ZTsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmdmFsdWUsICh2b2lkIF9fdXNlciAqKWFyZywgc2l6 ZW9mKHZhbHVlKSkpCiAJCXJldHVybiAtRUZBVUxUOwogCi0JcmV0dXJuIHN5bmNfZmVuY2Vfd2Fp dChmZW5jZSwgdmFsdWUpOworCXJldHVybiBzeW5jX2ZlbmNlX3dhaXQoc3luY19mZW5jZSwgdmFs dWUpOwogfQogCi1zdGF0aWMgbG9uZyBzeW5jX2ZlbmNlX2lvY3RsX21lcmdlKHN0cnVjdCBzeW5j X2ZlbmNlICpmZW5jZSwgdW5zaWduZWQgbG9uZyBhcmcpCitzdGF0aWMgbG9uZyBzeW5jX2ZlbmNl X2lvY3RsX21lcmdlKHN0cnVjdCBzeW5jX2ZlbmNlICpzeW5jX2ZlbmNlLAorCQkJCSAgIHVuc2ln bmVkIGxvbmcgYXJnKQogewogCWludCBmZCA9IGdldF91bnVzZWRfZmRfZmxhZ3MoT19DTE9FWEVD KTsKIAlpbnQgZXJyOwpAQCAtNTg3LDcgKzU5Myw3IEBAIHN0YXRpYyBsb25nIHN5bmNfZmVuY2Vf aW9jdGxfbWVyZ2Uoc3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlLCB1bnNpZ25lZCBsb25nIGFyZykK IAl9CiAKIAlkYXRhLm5hbWVbc2l6ZW9mKGRhdGEubmFtZSkgLSAxXSA9ICdcMCc7Ci0JZmVuY2Uz ID0gc3luY19mZW5jZV9tZXJnZShkYXRhLm5hbWUsIGZlbmNlLCBmZW5jZTIpOworCWZlbmNlMyA9 IHN5bmNfZmVuY2VfbWVyZ2UoZGF0YS5uYW1lLCBzeW5jX2ZlbmNlLCBmZW5jZTIpOwogCWlmICgh ZmVuY2UzKSB7CiAJCWVyciA9IC1FTk9NRU07CiAJCWdvdG8gZXJyX3B1dF9mZW5jZTI7CkBAIC02 NDYsNyArNjUyLDcgQEAgc3RhdGljIGludCBzeW5jX2ZpbGxfcHRfaW5mbyhzdHJ1Y3QgZmVuY2Ug KmZlbmNlLCB2b2lkICpkYXRhLCBpbnQgc2l6ZSkKIAlyZXR1cm4gaW5mby0+bGVuOwogfQogCi1z dGF0aWMgbG9uZyBzeW5jX2ZlbmNlX2lvY3RsX2ZlbmNlX2luZm8oc3RydWN0IHN5bmNfZmVuY2Ug KmZlbmNlLAorc3RhdGljIGxvbmcgc3luY19mZW5jZV9pb2N0bF9mZW5jZV9pbmZvKHN0cnVjdCBz eW5jX2ZlbmNlICpzeW5jX2ZlbmNlLAogCQkJCQl1bnNpZ25lZCBsb25nIGFyZykKIHsKIAlzdHJ1 Y3Qgc3luY19mZW5jZV9pbmZvX2RhdGEgKmRhdGE7CkBAIC02NjcsMTUgKzY3MywxNSBAQCBzdGF0 aWMgbG9uZyBzeW5jX2ZlbmNlX2lvY3RsX2ZlbmNlX2luZm8oc3RydWN0IHN5bmNfZmVuY2UgKmZl bmNlLAogCWlmICghZGF0YSkKIAkJcmV0dXJuIC1FTk9NRU07CiAKLQlzdHJsY3B5KGRhdGEtPm5h bWUsIGZlbmNlLT5uYW1lLCBzaXplb2YoZGF0YS0+bmFtZSkpOwotCWRhdGEtPnN0YXR1cyA9IGF0 b21pY19yZWFkKCZmZW5jZS0+c3RhdHVzKTsKKwlzdHJsY3B5KGRhdGEtPm5hbWUsIHN5bmNfZmVu Y2UtPm5hbWUsIHNpemVvZihkYXRhLT5uYW1lKSk7CisJZGF0YS0+c3RhdHVzID0gYXRvbWljX3Jl YWQoJnN5bmNfZmVuY2UtPnN0YXR1cyk7CiAJaWYgKGRhdGEtPnN0YXR1cyA+PSAwKQogCQlkYXRh LT5zdGF0dXMgPSAhZGF0YS0+c3RhdHVzOwogCiAJbGVuID0gc2l6ZW9mKHN0cnVjdCBzeW5jX2Zl bmNlX2luZm9fZGF0YSk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgZmVuY2UtPm51bV9mZW5jZXM7ICsr aSkgewotCQlzdHJ1Y3QgZmVuY2UgKnB0ID0gZmVuY2UtPmNic1tpXS5zeW5jX3B0OworCWZvciAo aSA9IDA7IGkgPCBzeW5jX2ZlbmNlLT5udW1fZmVuY2VzOyArK2kpIHsKKwkJc3RydWN0IGZlbmNl ICpwdCA9IHN5bmNfZmVuY2UtPmNic1tpXS5zeW5jX3B0OwogCiAJCXJldCA9IHN5bmNfZmlsbF9w dF9pbmZvKHB0LCAodTggKilkYXRhICsgbGVuLCBzaXplIC0gbGVuKTsKIApAQCAtNzAxLDE3ICs3 MDcsMTcgQEAgb3V0Ogogc3RhdGljIGxvbmcgc3luY19mZW5jZV9pb2N0bChzdHJ1Y3QgZmlsZSAq ZmlsZSwgdW5zaWduZWQgaW50IGNtZCwKIAkJCSAgICAgdW5zaWduZWQgbG9uZyBhcmcpCiB7Ci0J c3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCXN0cnVjdCBz eW5jX2ZlbmNlICpzeW5jX2ZlbmNlID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwogCiAJc3dpdGNoIChj bWQpIHsKIAljYXNlIFNZTkNfSU9DX1dBSVQ6Ci0JCXJldHVybiBzeW5jX2ZlbmNlX2lvY3RsX3dh aXQoZmVuY2UsIGFyZyk7CisJCXJldHVybiBzeW5jX2ZlbmNlX2lvY3RsX3dhaXQoc3luY19mZW5j ZSwgYXJnKTsKIAogCWNhc2UgU1lOQ19JT0NfTUVSR0U6Ci0JCXJldHVybiBzeW5jX2ZlbmNlX2lv Y3RsX21lcmdlKGZlbmNlLCBhcmcpOworCQlyZXR1cm4gc3luY19mZW5jZV9pb2N0bF9tZXJnZShz eW5jX2ZlbmNlLCBhcmcpOwogCiAJY2FzZSBTWU5DX0lPQ19GRU5DRV9JTkZPOgotCQlyZXR1cm4g c3luY19mZW5jZV9pb2N0bF9mZW5jZV9pbmZvKGZlbmNlLCBhcmcpOworCQlyZXR1cm4gc3luY19m ZW5jZV9pb2N0bF9mZW5jZV9pbmZvKHN5bmNfZmVuY2UsIGFyZyk7CiAKIAlkZWZhdWx0OgogCQly ZXR1cm4gLUVOT1RUWTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMu aCBiL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuaAppbmRleCBhZDQ1NjU5Li4wZmVkNjQy IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jLmgKKysrIGIvZHJpdmVy cy9zdGFnaW5nL2FuZHJvaWQvc3luYy5oCkBAIC0xMTEsNyArMTExLDcgQEAgc3RhdGljIGlubGlu ZSBzdHJ1Y3Qgc3luY190aW1lbGluZSAqc3luY19wdF9wYXJlbnQoc3RydWN0IHN5bmNfcHQgKnB0 KQogc3RydWN0IHN5bmNfZmVuY2VfY2IgewogCXN0cnVjdCBmZW5jZV9jYiBjYjsKIAlzdHJ1Y3Qg ZmVuY2UgKnN5bmNfcHQ7Ci0Jc3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlOworCXN0cnVjdCBzeW5j X2ZlbmNlICpzeW5jX2ZlbmNlOwogfTsKIAogLyoqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdp bmcvYW5kcm9pZC9zeW5jX2RlYnVnLmMgYi9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jX2Rl YnVnLmMKaW5kZXggMGEyZGYzZi4uY2ZhOTJkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5n L2FuZHJvaWQvc3luY19kZWJ1Zy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmNf ZGVidWcuYwpAQCAtNTYsMjEgKzU2LDIxIEBAIHZvaWQgc3luY190aW1lbGluZV9kZWJ1Z19yZW1v dmUoc3RydWN0IHN5bmNfdGltZWxpbmUgKm9iaikKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZz eW5jX3RpbWVsaW5lX2xpc3RfbG9jaywgZmxhZ3MpOwogfQogCi12b2lkIHN5bmNfZmVuY2VfZGVi dWdfYWRkKHN0cnVjdCBzeW5jX2ZlbmNlICpmZW5jZSkKK3ZvaWQgc3luY19mZW5jZV9kZWJ1Z19h ZGQoc3RydWN0IHN5bmNfZmVuY2UgKnN5bmNfZmVuY2UpCiB7CiAJdW5zaWduZWQgbG9uZyBmbGFn czsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZzeW5jX2ZlbmNlX2xpc3RfbG9jaywgZmxhZ3MpOwot CWxpc3RfYWRkX3RhaWwoJmZlbmNlLT5zeW5jX2ZlbmNlX2xpc3QsICZzeW5jX2ZlbmNlX2xpc3Rf aGVhZCk7CisJbGlzdF9hZGRfdGFpbCgmc3luY19mZW5jZS0+c3luY19mZW5jZV9saXN0LCAmc3lu Y19mZW5jZV9saXN0X2hlYWQpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN5bmNfZmVuY2Vf bGlzdF9sb2NrLCBmbGFncyk7CiB9CiAKLXZvaWQgc3luY19mZW5jZV9kZWJ1Z19yZW1vdmUoc3Ry dWN0IHN5bmNfZmVuY2UgKmZlbmNlKQordm9pZCBzeW5jX2ZlbmNlX2RlYnVnX3JlbW92ZShzdHJ1 Y3Qgc3luY19mZW5jZSAqc3luY19mZW5jZSkKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJ c3Bpbl9sb2NrX2lycXNhdmUoJnN5bmNfZmVuY2VfbGlzdF9sb2NrLCBmbGFncyk7Ci0JbGlzdF9k ZWwoJmZlbmNlLT5zeW5jX2ZlbmNlX2xpc3QpOworCWxpc3RfZGVsKCZzeW5jX2ZlbmNlLT5zeW5j X2ZlbmNlX2xpc3QpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN5bmNfZmVuY2VfbGlzdF9s b2NrLCBmbGFncyk7CiB9CiAKQEAgLTE1MiwyMSArMTUyLDIyIEBAIHN0YXRpYyB2b2lkIHN5bmNf cHJpbnRfb2JqKHN0cnVjdCBzZXFfZmlsZSAqcywgc3RydWN0IHN5bmNfdGltZWxpbmUgKm9iaikK IAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmotPmNoaWxkX2xpc3RfbG9jaywgZmxhZ3MpOwog fQogCi1zdGF0aWMgdm9pZCBzeW5jX3ByaW50X2ZlbmNlKHN0cnVjdCBzZXFfZmlsZSAqcywgc3Ry dWN0IHN5bmNfZmVuY2UgKmZlbmNlKQorc3RhdGljIHZvaWQgc3luY19wcmludF9zeW5jX2ZlbmNl KHN0cnVjdCBzZXFfZmlsZSAqcywKKwkJCQkgIHN0cnVjdCBzeW5jX2ZlbmNlICpzeW5jX2ZlbmNl KQogewogCXdhaXRfcXVldWVfdCAqcG9zOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IGk7 CiAKLQlzZXFfcHJpbnRmKHMsICJbJXBdICVzOiAlc1xuIiwgZmVuY2UsIGZlbmNlLT5uYW1lLAot CQkgICBzeW5jX3N0YXR1c19zdHIoYXRvbWljX3JlYWQoJmZlbmNlLT5zdGF0dXMpKSk7CisJc2Vx X3ByaW50ZihzLCAiWyVwXSAlczogJXNcbiIsIHN5bmNfZmVuY2UsIHN5bmNfZmVuY2UtPm5hbWUs CisJCSAgIHN5bmNfc3RhdHVzX3N0cihhdG9taWNfcmVhZCgmc3luY19mZW5jZS0+c3RhdHVzKSkp OwogCi0JZm9yIChpID0gMDsgaSA8IGZlbmNlLT5udW1fZmVuY2VzOyArK2kpIHsKLQkJc3luY19w cmludF9wdChzLCBmZW5jZS0+Y2JzW2ldLnN5bmNfcHQsIHRydWUpOworCWZvciAoaSA9IDA7IGkg PCBzeW5jX2ZlbmNlLT5udW1fZmVuY2VzOyArK2kpIHsKKwkJc3luY19wcmludF9wdChzLCBzeW5j X2ZlbmNlLT5jYnNbaV0uc3luY19wdCwgdHJ1ZSk7CiAJfQogCi0Jc3Bpbl9sb2NrX2lycXNhdmUo JmZlbmNlLT53cS5sb2NrLCBmbGFncyk7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeShwb3MsICZmZW5j ZS0+d3EudGFza19saXN0LCB0YXNrX2xpc3QpIHsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmc3luY19m ZW5jZS0+d3EubG9jaywgZmxhZ3MpOworCWxpc3RfZm9yX2VhY2hfZW50cnkocG9zLCAmc3luY19m ZW5jZS0+d3EudGFza19saXN0LCB0YXNrX2xpc3QpIHsKIAkJc3RydWN0IHN5bmNfZmVuY2Vfd2Fp dGVyICp3YWl0ZXI7CiAKIAkJaWYgKHBvcy0+ZnVuYyAhPSAmc3luY19mZW5jZV93YWtlX3VwX3dx KQpAQCAtMTc2LDcgKzE3Nyw3IEBAIHN0YXRpYyB2b2lkIHN5bmNfcHJpbnRfZmVuY2Uoc3RydWN0 IHNlcV9maWxlICpzLCBzdHJ1Y3Qgc3luY19mZW5jZSAqZmVuY2UpCiAKIAkJc2VxX3ByaW50Zihz LCAid2FpdGVyICVwRlxuIiwgd2FpdGVyLT5jYWxsYmFjayk7CiAJfQotCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJmZlbmNlLT53cS5sb2NrLCBmbGFncyk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9y ZSgmc3luY19mZW5jZS0+d3EubG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgaW50IHN5bmNfZGVi dWdmc19zaG93KHN0cnVjdCBzZXFfZmlsZSAqcywgdm9pZCAqdW51c2VkKQpAQCAtMjAxLDEwICsy MDIsMTAgQEAgc3RhdGljIGludCBzeW5jX2RlYnVnZnNfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnMs IHZvaWQgKnVudXNlZCkKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZzeW5jX2ZlbmNlX2xpc3RfbG9j aywgZmxhZ3MpOwogCWxpc3RfZm9yX2VhY2gocG9zLCAmc3luY19mZW5jZV9saXN0X2hlYWQpIHsK LQkJc3RydWN0IHN5bmNfZmVuY2UgKmZlbmNlID0KKwkJc3RydWN0IHN5bmNfZmVuY2UgKnN5bmNf ZmVuY2UgPQogCQkJY29udGFpbmVyX29mKHBvcywgc3RydWN0IHN5bmNfZmVuY2UsIHN5bmNfZmVu Y2VfbGlzdCk7CiAKLQkJc3luY19wcmludF9mZW5jZShzLCBmZW5jZSk7CisJCXN5bmNfcHJpbnRf c3luY19mZW5jZShzLCBzeW5jX2ZlbmNlKTsKIAkJc2VxX3B1dHMocywgIlxuIik7CiAJfQogCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJnN5bmNfZmVuY2VfbGlzdF9sb2NrLCBmbGFncyk7CkBAIC0y NjAsNyArMjYxLDcgQEAgc3RhdGljIGxvbmcgc3dfc3luY19pb2N0bF9jcmVhdGVfZmVuY2Uoc3Ry dWN0IHN3X3N5bmNfdGltZWxpbmUgKm9iaiwKIAlpbnQgZmQgPSBnZXRfdW51c2VkX2ZkX2ZsYWdz KE9fQ0xPRVhFQyk7CiAJaW50IGVycjsKIAlzdHJ1Y3Qgc3luY19wdCAqcHQ7Ci0Jc3RydWN0IHN5 bmNfZmVuY2UgKmZlbmNlOworCXN0cnVjdCBzeW5jX2ZlbmNlICpzeW5jX2ZlbmNlOwogCXN0cnVj dCBzd19zeW5jX2NyZWF0ZV9mZW5jZV9kYXRhIGRhdGE7CiAKIAlpZiAoZmQgPCAwKQpAQCAtMjc4 LDggKzI3OSw4IEBAIHN0YXRpYyBsb25nIHN3X3N5bmNfaW9jdGxfY3JlYXRlX2ZlbmNlKHN0cnVj dCBzd19zeW5jX3RpbWVsaW5lICpvYmosCiAJfQogCiAJZGF0YS5uYW1lW3NpemVvZihkYXRhLm5h bWUpIC0gMV0gPSAnXDAnOwotCWZlbmNlID0gc3luY19mZW5jZV9jcmVhdGUoZGF0YS5uYW1lLCBw dCk7Ci0JaWYgKCFmZW5jZSkgeworCXN5bmNfZmVuY2UgPSBzeW5jX2ZlbmNlX2NyZWF0ZShkYXRh Lm5hbWUsIHB0KTsKKwlpZiAoIXN5bmNfZmVuY2UpIHsKIAkJc3luY19wdF9mcmVlKHB0KTsKIAkJ ZXJyID0gLUVOT01FTTsKIAkJZ290byBlcnI7CkBAIC0yODcsMTIgKzI4OCwxMiBAQCBzdGF0aWMg bG9uZyBzd19zeW5jX2lvY3RsX2NyZWF0ZV9mZW5jZShzdHJ1Y3Qgc3dfc3luY190aW1lbGluZSAq b2JqLAogCiAJZGF0YS5mZW5jZSA9IGZkOwogCWlmIChjb3B5X3RvX3VzZXIoKHZvaWQgX191c2Vy ICopYXJnLCAmZGF0YSwgc2l6ZW9mKGRhdGEpKSkgewotCQlzeW5jX2ZlbmNlX3B1dChmZW5jZSk7 CisJCXN5bmNfZmVuY2VfcHV0KHN5bmNfZmVuY2UpOwogCQllcnIgPSAtRUZBVUxUOwogCQlnb3Rv IGVycjsKIAl9CiAKLQlzeW5jX2ZlbmNlX2luc3RhbGwoZmVuY2UsIGZkKTsKKwlzeW5jX2ZlbmNl X2luc3RhbGwoc3luY19mZW5jZSwgZmQpOwogCiAJcmV0dXJuIDA7CiAKLS0gCjIuNS4wCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFp bGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cDovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=