From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752289AbcF3Q04 (ORCPT ); Thu, 30 Jun 2016 12:26:56 -0400 Received: from mail-qk0-f196.google.com ([209.85.220.196]:35333 "EHLO mail-qk0-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752065AbcF3Q0y (ORCPT ); Thu, 30 Jun 2016 12:26:54 -0400 From: Gustavo Padovan To: dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org, Daniel Stone , Daniel Vetter , Rob Clark , Greg Hackmann , John Harrison , laurent.pinchart@ideasonboard.com, seanpaul@google.com, marcheu@google.com, m.chehab@samsung.com, Sumit Semwal , Maarten Lankhorst , Gustavo Padovan , Chris Wilson , =?UTF-8?q?Christian=20K=C3=B6nig?= Subject: [PATCH 2/2] dma-buf/sync_file: rework fence storage in struct file Date: Thu, 30 Jun 2016 11:09:48 -0300 Message-Id: <1467295788-6422-3-git-send-email-gustavo@padovan.org> X-Mailer: git-send-email 2.5.5 In-Reply-To: <1467295788-6422-1-git-send-email-gustavo@padovan.org> References: <1467295788-6422-1-git-send-email-gustavo@padovan.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Gustavo Padovan Create sync_file->fence to abstract the type of fence we are using for each sync_file. If only one fence is present we use a normal struct fence but if there is more fences to be added to the sync_file a fence_array is created. This change cleans up sync_file a bit. We don't need to have sync_file_cb array anymore. Instead, as we always have one fence, only one fence callback is registered per sync_file. v3: Comments from Chris Wilson and Christian König - struct sync_file lost status member in favor of fence_is_signaled() - drop use of fence_array_teardown() - use sizeof(*fence) to allocate only an array on fence pointers v2: Comments from Chris Wilson and Christian König - Not using fence_ops anymore - fence_is_array() was created to differentiate fence from fence_array - fence_array_teardown() is now exported and used under fence_is_array() - struct sync_file lost num_fences member Cc: Chris Wilson Cc: Christian König Signed-off-by: Gustavo Padovan --- drivers/dma-buf/sync_file.c | 163 ++++++++++++++++++++++------------- drivers/staging/android/sync_debug.c | 13 ++- include/linux/sync_file.h | 17 ++-- 3 files changed, 118 insertions(+), 75 deletions(-) diff --git a/drivers/dma-buf/sync_file.c b/drivers/dma-buf/sync_file.c index 9aaa608..7a5aaae 100644 --- a/drivers/dma-buf/sync_file.c +++ b/drivers/dma-buf/sync_file.c @@ -28,11 +28,11 @@ static const struct file_operations sync_file_fops; -static struct sync_file *sync_file_alloc(int size) +static struct sync_file *sync_file_alloc(void) { struct sync_file *sync_file; - sync_file = kzalloc(size, GFP_KERNEL); + sync_file = kzalloc(sizeof(*sync_file), GFP_KERNEL); if (!sync_file) return NULL; @@ -45,6 +45,8 @@ static struct sync_file *sync_file_alloc(int size) init_waitqueue_head(&sync_file->wq); + INIT_LIST_HEAD(&sync_file->cb.node); + return sync_file; err: @@ -54,14 +56,11 @@ err: static void fence_check_cb_func(struct fence *f, struct fence_cb *cb) { - struct sync_file_cb *check; struct sync_file *sync_file; - check = container_of(cb, struct sync_file_cb, cb); - sync_file = check->sync_file; + sync_file = container_of(cb, struct sync_file, cb); - if (atomic_dec_and_test(&sync_file->status)) - wake_up_all(&sync_file->wq); + wake_up_all(&sync_file->wq); } /** @@ -76,22 +75,18 @@ struct sync_file *sync_file_create(struct fence *fence) { struct sync_file *sync_file; - sync_file = sync_file_alloc(offsetof(struct sync_file, cbs[1])); + sync_file = sync_file_alloc(); if (!sync_file) return NULL; - sync_file->num_fences = 1; - atomic_set(&sync_file->status, 1); + sync_file->fence = fence; + snprintf(sync_file->name, sizeof(sync_file->name), "%s-%s%llu-%d", fence->ops->get_driver_name(fence), fence->ops->get_timeline_name(fence), fence->context, fence->seqno); - sync_file->cbs[0].fence = fence; - sync_file->cbs[0].sync_file = sync_file; - if (fence_add_callback(fence, &sync_file->cbs[0].cb, - fence_check_cb_func)) - atomic_dec(&sync_file->status); + fence_add_callback(fence, &sync_file->cb, fence_check_cb_func); return sync_file; } @@ -121,14 +116,48 @@ err: return NULL; } -static void sync_file_add_pt(struct sync_file *sync_file, int *i, - struct fence *fence) +static int sync_file_set_fence(struct sync_file *sync_file, + struct fence **fences, int num_fences) +{ + struct fence_array *array; + + /* + * The reference for the fences in the new sync_file and holded + * in add_fence() during the merge procedure, so for num_fences == 1 + * we already own a new reference to the fence. For num_fence > 1 + * we own the reference of the fence_array creation. + */ + if (num_fences == 1) { + sync_file->fence = fences[0]; + } else { + array = fence_array_create(num_fences, fences, + fence_context_alloc(1), 1, false); + if (!array) + return -ENOMEM; + + sync_file->fence = (struct fence *)array; + } + + return 0; +} + +static struct fence **get_fences(struct sync_file *sync_file, int *num_fences) +{ + if (fence_is_array(sync_file->fence)) { + struct fence_array *array = to_fence_array(sync_file->fence); + *num_fences = array->num_fences; + return array->fences; + } else { + *num_fences = 1; + return &sync_file->fence; + } +} + +static void add_fence(struct fence **fences, int *i, struct fence *fence) { - sync_file->cbs[*i].fence = fence; - sync_file->cbs[*i].sync_file = sync_file; + fences[*i] = fence; - if (!fence_add_callback(fence, &sync_file->cbs[*i].cb, - fence_check_cb_func)) { + if (!fence_is_signaled(fence)) { fence_get(fence); (*i)++; } @@ -147,16 +176,21 @@ static void sync_file_add_pt(struct sync_file *sync_file, int *i, static struct sync_file *sync_file_merge(const char *name, struct sync_file *a, struct sync_file *b) { - int num_fences = a->num_fences + b->num_fences; struct sync_file *sync_file; - int i, i_a, i_b; - unsigned long size = offsetof(struct sync_file, cbs[num_fences]); + struct fence **fences, **a_fences, **b_fences; + int i, i_a, i_b, num_fences, a_num_fences, b_num_fences; - sync_file = sync_file_alloc(size); + sync_file = sync_file_alloc(); if (!sync_file) return NULL; - atomic_set(&sync_file->status, num_fences); + a_fences = get_fences(a, &a_num_fences); + b_fences = get_fences(b, &b_num_fences); + num_fences = a_num_fences + b_num_fences; + + fences = kcalloc(num_fences, sizeof(*fences), GFP_KERNEL); + if (!fences) + goto err; /* * Assume sync_file a and b are both ordered and have no @@ -165,55 +199,66 @@ static struct sync_file *sync_file_merge(const char *name, struct sync_file *a, * If a sync_file can only be created with sync_file_merge * and sync_file_create, this is a reasonable assumption. */ - for (i = i_a = i_b = 0; i_a < a->num_fences && i_b < b->num_fences; ) { - struct fence *pt_a = a->cbs[i_a].fence; - struct fence *pt_b = b->cbs[i_b].fence; + for (i = i_a = i_b = 0; i_a < a_num_fences && i_b < b_num_fences; ) { + struct fence *pt_a = a_fences[i_a]; + struct fence *pt_b = b_fences[i_b]; if (pt_a->context < pt_b->context) { - sync_file_add_pt(sync_file, &i, pt_a); + add_fence(fences, &i, pt_a); i_a++; } else if (pt_a->context > pt_b->context) { - sync_file_add_pt(sync_file, &i, pt_b); + add_fence(fences, &i, pt_b); i_b++; } else { if (pt_a->seqno - pt_b->seqno <= INT_MAX) - sync_file_add_pt(sync_file, &i, pt_a); + add_fence(fences, &i, pt_a); else - sync_file_add_pt(sync_file, &i, pt_b); + add_fence(fences, &i, pt_b); i_a++; i_b++; } } - for (; i_a < a->num_fences; i_a++) - sync_file_add_pt(sync_file, &i, a->cbs[i_a].fence); + for (; i_a < a_num_fences; i_a++) + add_fence(fences, &i, a_fences[i_a]); + + for (; i_b < b_num_fences; i_b++) + add_fence(fences, &i, b_fences[i_b]); + + if (num_fences > i) { + fences = krealloc(fences, i * sizeof(**fences), + GFP_KERNEL); + if (!fences) + goto err; + } - for (; i_b < b->num_fences; i_b++) - sync_file_add_pt(sync_file, &i, b->cbs[i_b].fence); + if (sync_file_set_fence(sync_file, fences, i) < 0) { + kfree(fences); + goto err; + } - if (num_fences > i) - atomic_sub(num_fences - i, &sync_file->status); - sync_file->num_fences = i; + fence_add_callback(sync_file->fence, &sync_file->cb, + fence_check_cb_func); strlcpy(sync_file->name, name, sizeof(sync_file->name)); return sync_file; + +err: + fput(sync_file->file); + return NULL; + } static void sync_file_free(struct kref *kref) { struct sync_file *sync_file = container_of(kref, struct sync_file, kref); - int i; - - for (i = 0; i < sync_file->num_fences; ++i) { - fence_remove_callback(sync_file->cbs[i].fence, - &sync_file->cbs[i].cb); - fence_put(sync_file->cbs[i].fence); - } + fence_remove_callback(sync_file->fence, &sync_file->cb); + fence_put(sync_file->fence); kfree(sync_file); } @@ -232,9 +277,9 @@ static unsigned int sync_file_poll(struct file *file, poll_table *wait) poll_wait(file, &sync_file->wq, wait); - status = atomic_read(&sync_file->status); + status = fence_is_signaled(sync_file->fence); - if (!status) + if (status) return POLLIN; if (status < 0) return POLLERR; @@ -315,8 +360,9 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file, { struct sync_file_info info; struct sync_fence_info *fence_info = NULL; + struct fence **fences; __u32 size; - int ret, i; + int num_fences, ret, i; if (copy_from_user(&info, (void __user *)arg, sizeof(info))) return -EFAULT; @@ -324,6 +370,8 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file, if (info.flags || info.pad) return -EINVAL; + fences = get_fences(sync_file, &num_fences); + /* * Passing num_fences = 0 means that userspace doesn't want to * retrieve any sync_fence_info. If num_fences = 0 we skip filling @@ -333,16 +381,16 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file, if (!info.num_fences) goto no_fences; - if (info.num_fences < sync_file->num_fences) + if (info.num_fences < num_fences) return -EINVAL; - size = sync_file->num_fences * sizeof(*fence_info); + size = num_fences * sizeof(*fence_info); fence_info = kzalloc(size, GFP_KERNEL); if (!fence_info) return -ENOMEM; - for (i = 0; i < sync_file->num_fences; ++i) - sync_fill_fence_info(sync_file->cbs[i].fence, &fence_info[i]); + for (i = 0; i < num_fences; i++) + sync_fill_fence_info(fences[i], &fence_info[i]); if (copy_to_user(u64_to_user_ptr(info.sync_fence_info), fence_info, size)) { @@ -352,11 +400,8 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file, no_fences: strlcpy(info.name, sync_file->name, sizeof(info.name)); - info.status = atomic_read(&sync_file->status); - if (info.status >= 0) - info.status = !info.status; - - info.num_fences = sync_file->num_fences; + info.status = fence_is_signaled(sync_file->fence); + info.num_fences = num_fences; if (copy_to_user((void __user *)arg, &info, sizeof(info))) ret = -EFAULT; diff --git a/drivers/staging/android/sync_debug.c b/drivers/staging/android/sync_debug.c index 5f57499..0638a06 100644 --- a/drivers/staging/android/sync_debug.c +++ b/drivers/staging/android/sync_debug.c @@ -159,10 +159,15 @@ static void sync_print_sync_file(struct seq_file *s, int i; seq_printf(s, "[%p] %s: %s\n", sync_file, sync_file->name, - sync_status_str(atomic_read(&sync_file->status))); - - for (i = 0; i < sync_file->num_fences; ++i) - sync_print_fence(s, sync_file->cbs[i].fence, true); + sync_status_str(!fence_is_signaled(sync_file->fence))); + + if (fence_is_array(sync_file->fence)) { + struct fence_array *array = to_fence_array(sync_file->fence); + for (i = 0; i < array->num_fences; ++i) + sync_print_fence(s, array->fences[i], true); + } else { + sync_print_fence(s, sync_file->fence, true); + } } static int sync_debugfs_show(struct seq_file *s, void *unused) diff --git a/include/linux/sync_file.h b/include/linux/sync_file.h index c6ffe8b..2efc5ec 100644 --- a/include/linux/sync_file.h +++ b/include/linux/sync_file.h @@ -19,12 +19,7 @@ #include #include #include - -struct sync_file_cb { - struct fence_cb cb; - struct fence *fence; - struct sync_file *sync_file; -}; +#include /** * struct sync_file - sync file to export to the userspace @@ -32,10 +27,9 @@ struct sync_file_cb { * @kref: reference count on fence. * @name: name of sync_file. Useful for debugging * @sync_file_list: membership in global file list - * @num_fences: number of sync_pts in the fence * @wq: wait queue for fence signaling - * @status: 0: signaled, >0:active, <0: error - * @cbs: sync_pts callback information + * @fence: fence with the fences in the sync_file + * @cb: fence callback information */ struct sync_file { struct file *file; @@ -44,12 +38,11 @@ struct sync_file { #ifdef CONFIG_DEBUG_FS struct list_head sync_file_list; #endif - int num_fences; wait_queue_head_t wq; - atomic_t status; - struct sync_file_cb cbs[]; + struct fence *fence; + struct fence_cb cb; }; struct sync_file *sync_file_create(struct fence *fence); -- 2.5.5 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gustavo Padovan Subject: [PATCH 2/2] dma-buf/sync_file: rework fence storage in struct file Date: Thu, 30 Jun 2016 11:09:48 -0300 Message-ID: <1467295788-6422-3-git-send-email-gustavo@padovan.org> References: <1467295788-6422-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-qk0-f196.google.com (mail-qk0-f196.google.com [209.85.220.196]) by gabe.freedesktop.org (Postfix) with ESMTPS id 6C2916E8A3 for ; Thu, 30 Jun 2016 14:10:07 +0000 (UTC) Received: by mail-qk0-f196.google.com with SMTP id n132so16846017qka.0 for ; Thu, 30 Jun 2016 07:10:07 -0700 (PDT) In-Reply-To: <1467295788-6422-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: dri-devel@lists.freedesktop.org Cc: marcheu@google.com, Daniel Stone , seanpaul@google.com, =?UTF-8?q?Christian=20K=C3=B6nig?= , Daniel Vetter , linux-kernel@vger.kernel.org, laurent.pinchart@ideasonboard.com, Gustavo Padovan , John Harrison , m.chehab@samsung.com List-Id: dri-devel@lists.freedesktop.org RnJvbTogR3VzdGF2byBQYWRvdmFuIDxndXN0YXZvLnBhZG92YW5AY29sbGFib3JhLmNvLnVrPgoK Q3JlYXRlIHN5bmNfZmlsZS0+ZmVuY2UgdG8gYWJzdHJhY3QgdGhlIHR5cGUgb2YgZmVuY2Ugd2Ug YXJlIHVzaW5nIGZvcgplYWNoIHN5bmNfZmlsZS4gSWYgb25seSBvbmUgZmVuY2UgaXMgcHJlc2Vu dCB3ZSB1c2UgYSBub3JtYWwgc3RydWN0IGZlbmNlCmJ1dCBpZiB0aGVyZSBpcyBtb3JlIGZlbmNl cyB0byBiZSBhZGRlZCB0byB0aGUgc3luY19maWxlIGEgZmVuY2VfYXJyYXkKaXMgY3JlYXRlZC4K ClRoaXMgY2hhbmdlIGNsZWFucyB1cCBzeW5jX2ZpbGUgYSBiaXQuIFdlIGRvbid0IG5lZWQgdG8g aGF2ZSBzeW5jX2ZpbGVfY2IKYXJyYXkgYW55bW9yZS4gSW5zdGVhZCwgYXMgd2UgYWx3YXlzIGhh dmUgIG9uZSBmZW5jZSwgb25seSBvbmUgZmVuY2UKY2FsbGJhY2sgaXMgcmVnaXN0ZXJlZCBwZXIg c3luY19maWxlLgoKdjM6IENvbW1lbnRzIGZyb20gQ2hyaXMgV2lsc29uIGFuZCBDaHJpc3RpYW4g S8O2bmlnCgktIHN0cnVjdCBzeW5jX2ZpbGUgbG9zdCBzdGF0dXMgbWVtYmVyIGluIGZhdm9yIG9m IGZlbmNlX2lzX3NpZ25hbGVkKCkKCS0gZHJvcCB1c2Ugb2YgZmVuY2VfYXJyYXlfdGVhcmRvd24o KQoJLSB1c2Ugc2l6ZW9mKCpmZW5jZSkgdG8gYWxsb2NhdGUgb25seSBhbiBhcnJheSBvbiBmZW5j ZSBwb2ludGVycwoKdjI6IENvbW1lbnRzIGZyb20gQ2hyaXMgV2lsc29uIGFuZCBDaHJpc3RpYW4g S8O2bmlnCgktIE5vdCB1c2luZyBmZW5jZV9vcHMgYW55bW9yZQoJLSBmZW5jZV9pc19hcnJheSgp IHdhcyBjcmVhdGVkIHRvIGRpZmZlcmVudGlhdGUgZmVuY2UgZnJvbSBmZW5jZV9hcnJheQoJLSBm ZW5jZV9hcnJheV90ZWFyZG93bigpIGlzIG5vdyBleHBvcnRlZCBhbmQgdXNlZCB1bmRlciBmZW5j ZV9pc19hcnJheSgpCgktIHN0cnVjdCBzeW5jX2ZpbGUgbG9zdCBudW1fZmVuY2VzIG1lbWJlcgoK Q2M6IENocmlzIFdpbHNvbiA8Y2hyaXNAY2hyaXMtd2lsc29uLmNvLnVrPgpDYzogQ2hyaXN0aWFu IEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgpTaWduZWQtb2ZmLWJ5OiBHdXN0YXZv IFBhZG92YW4gPGd1c3Rhdm8ucGFkb3ZhbkBjb2xsYWJvcmEuY28udWs+Ci0tLQogZHJpdmVycy9k bWEtYnVmL3N5bmNfZmlsZS5jICAgICAgICAgIHwgMTYzICsrKysrKysrKysrKysrKysrKysrKyst LS0tLS0tLS0tLS0tCiBkcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jX2RlYnVnLmMgfCAgMTMg KystCiBpbmNsdWRlL2xpbnV4L3N5bmNfZmlsZS5oICAgICAgICAgICAgfCAgMTcgKystLQogMyBm aWxlcyBjaGFuZ2VkLCAxMTggaW5zZXJ0aW9ucygrKSwgNzUgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9kbWEtYnVmL3N5bmNfZmlsZS5jIGIvZHJpdmVycy9kbWEtYnVmL3N5bmNf ZmlsZS5jCmluZGV4IDlhYWE2MDguLjdhNWFhYWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1 Zi9zeW5jX2ZpbGUuYworKysgYi9kcml2ZXJzL2RtYS1idWYvc3luY19maWxlLmMKQEAgLTI4LDEx ICsyOCwxMSBAQAogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBzeW5jX2Zp bGVfZm9wczsKIAotc3RhdGljIHN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZV9hbGxvYyhpbnQg c2l6ZSkKK3N0YXRpYyBzdHJ1Y3Qgc3luY19maWxlICpzeW5jX2ZpbGVfYWxsb2Modm9pZCkKIHsK IAlzdHJ1Y3Qgc3luY19maWxlICpzeW5jX2ZpbGU7CiAKLQlzeW5jX2ZpbGUgPSBremFsbG9jKHNp emUsIEdGUF9LRVJORUwpOworCXN5bmNfZmlsZSA9IGt6YWxsb2Moc2l6ZW9mKCpzeW5jX2ZpbGUp LCBHRlBfS0VSTkVMKTsKIAlpZiAoIXN5bmNfZmlsZSkKIAkJcmV0dXJuIE5VTEw7CiAKQEAgLTQ1 LDYgKzQ1LDggQEAgc3RhdGljIHN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZV9hbGxvYyhpbnQg c2l6ZSkKIAogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnN5bmNfZmlsZS0+d3EpOwogCisJSU5JVF9M SVNUX0hFQUQoJnN5bmNfZmlsZS0+Y2Iubm9kZSk7CisKIAlyZXR1cm4gc3luY19maWxlOwogCiBl cnI6CkBAIC01NCwxNCArNTYsMTEgQEAgZXJyOgogCiBzdGF0aWMgdm9pZCBmZW5jZV9jaGVja19j Yl9mdW5jKHN0cnVjdCBmZW5jZSAqZiwgc3RydWN0IGZlbmNlX2NiICpjYikKIHsKLQlzdHJ1Y3Qg c3luY19maWxlX2NiICpjaGVjazsKIAlzdHJ1Y3Qgc3luY19maWxlICpzeW5jX2ZpbGU7CiAKLQlj aGVjayA9IGNvbnRhaW5lcl9vZihjYiwgc3RydWN0IHN5bmNfZmlsZV9jYiwgY2IpOwotCXN5bmNf ZmlsZSA9IGNoZWNrLT5zeW5jX2ZpbGU7CisJc3luY19maWxlID0gY29udGFpbmVyX29mKGNiLCBz dHJ1Y3Qgc3luY19maWxlLCBjYik7CiAKLQlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmc3luY19m aWxlLT5zdGF0dXMpKQotCQl3YWtlX3VwX2FsbCgmc3luY19maWxlLT53cSk7CisJd2FrZV91cF9h bGwoJnN5bmNfZmlsZS0+d3EpOwogfQogCiAvKioKQEAgLTc2LDIyICs3NSwxOCBAQCBzdHJ1Y3Qg c3luY19maWxlICpzeW5jX2ZpbGVfY3JlYXRlKHN0cnVjdCBmZW5jZSAqZmVuY2UpCiB7CiAJc3Ry dWN0IHN5bmNfZmlsZSAqc3luY19maWxlOwogCi0Jc3luY19maWxlID0gc3luY19maWxlX2FsbG9j KG9mZnNldG9mKHN0cnVjdCBzeW5jX2ZpbGUsIGNic1sxXSkpOworCXN5bmNfZmlsZSA9IHN5bmNf ZmlsZV9hbGxvYygpOwogCWlmICghc3luY19maWxlKQogCQlyZXR1cm4gTlVMTDsKIAotCXN5bmNf ZmlsZS0+bnVtX2ZlbmNlcyA9IDE7Ci0JYXRvbWljX3NldCgmc3luY19maWxlLT5zdGF0dXMsIDEp OworCXN5bmNfZmlsZS0+ZmVuY2UgPSBmZW5jZTsKKwogCXNucHJpbnRmKHN5bmNfZmlsZS0+bmFt ZSwgc2l6ZW9mKHN5bmNfZmlsZS0+bmFtZSksICIlcy0lcyVsbHUtJWQiLAogCQkgZmVuY2UtPm9w cy0+Z2V0X2RyaXZlcl9uYW1lKGZlbmNlKSwKIAkJIGZlbmNlLT5vcHMtPmdldF90aW1lbGluZV9u YW1lKGZlbmNlKSwgZmVuY2UtPmNvbnRleHQsCiAJCSBmZW5jZS0+c2Vxbm8pOwogCi0Jc3luY19m aWxlLT5jYnNbMF0uZmVuY2UgPSBmZW5jZTsKLQlzeW5jX2ZpbGUtPmNic1swXS5zeW5jX2ZpbGUg PSBzeW5jX2ZpbGU7Ci0JaWYgKGZlbmNlX2FkZF9jYWxsYmFjayhmZW5jZSwgJnN5bmNfZmlsZS0+ Y2JzWzBdLmNiLAotCQkJICAgICAgIGZlbmNlX2NoZWNrX2NiX2Z1bmMpKQotCQlhdG9taWNfZGVj KCZzeW5jX2ZpbGUtPnN0YXR1cyk7CisJZmVuY2VfYWRkX2NhbGxiYWNrKGZlbmNlLCAmc3luY19m aWxlLT5jYiwgZmVuY2VfY2hlY2tfY2JfZnVuYyk7CiAKIAlyZXR1cm4gc3luY19maWxlOwogfQpA QCAtMTIxLDE0ICsxMTYsNDggQEAgZXJyOgogCXJldHVybiBOVUxMOwogfQogCi1zdGF0aWMgdm9p ZCBzeW5jX2ZpbGVfYWRkX3B0KHN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZSwgaW50ICppLAot CQkJICAgICBzdHJ1Y3QgZmVuY2UgKmZlbmNlKQorc3RhdGljIGludCBzeW5jX2ZpbGVfc2V0X2Zl bmNlKHN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZSwKKwkJCSAgICAgICBzdHJ1Y3QgZmVuY2Ug KipmZW5jZXMsIGludCBudW1fZmVuY2VzKQoreworCXN0cnVjdCBmZW5jZV9hcnJheSAqYXJyYXk7 CisKKwkvKgorCSAqIFRoZSByZWZlcmVuY2UgZm9yIHRoZSBmZW5jZXMgaW4gdGhlIG5ldyBzeW5j X2ZpbGUgYW5kIGhvbGRlZAorCSAqIGluIGFkZF9mZW5jZSgpIGR1cmluZyB0aGUgbWVyZ2UgcHJv Y2VkdXJlLCBzbyBmb3IgbnVtX2ZlbmNlcyA9PSAxCisJICogd2UgYWxyZWFkeSBvd24gYSBuZXcg cmVmZXJlbmNlIHRvIHRoZSBmZW5jZS4gRm9yIG51bV9mZW5jZSA+IDEKKwkgKiB3ZSBvd24gdGhl IHJlZmVyZW5jZSBvZiB0aGUgZmVuY2VfYXJyYXkgY3JlYXRpb24uCisJICovCisJaWYgKG51bV9m ZW5jZXMgPT0gMSkgeworCQlzeW5jX2ZpbGUtPmZlbmNlID0gZmVuY2VzWzBdOworCX0gZWxzZSB7 CisJCWFycmF5ID0gZmVuY2VfYXJyYXlfY3JlYXRlKG51bV9mZW5jZXMsIGZlbmNlcywKKwkJCQkJ ICAgZmVuY2VfY29udGV4dF9hbGxvYygxKSwgMSwgZmFsc2UpOworCQlpZiAoIWFycmF5KQorCQkJ cmV0dXJuIC1FTk9NRU07CisKKwkJc3luY19maWxlLT5mZW5jZSA9IChzdHJ1Y3QgZmVuY2UgKilh cnJheTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBmZW5jZSAqKmdldF9m ZW5jZXMoc3RydWN0IHN5bmNfZmlsZSAqc3luY19maWxlLCBpbnQgKm51bV9mZW5jZXMpCit7CisJ aWYgKGZlbmNlX2lzX2FycmF5KHN5bmNfZmlsZS0+ZmVuY2UpKSB7CisJCXN0cnVjdCBmZW5jZV9h cnJheSAqYXJyYXkgPSB0b19mZW5jZV9hcnJheShzeW5jX2ZpbGUtPmZlbmNlKTsKKwkJKm51bV9m ZW5jZXMgPSBhcnJheS0+bnVtX2ZlbmNlczsKKwkJcmV0dXJuIGFycmF5LT5mZW5jZXM7CisJfSBl bHNlIHsKKwkJKm51bV9mZW5jZXMgPSAxOworCQlyZXR1cm4gJnN5bmNfZmlsZS0+ZmVuY2U7CisJ fQorfQorCitzdGF0aWMgdm9pZCBhZGRfZmVuY2Uoc3RydWN0IGZlbmNlICoqZmVuY2VzLCBpbnQg KmksIHN0cnVjdCBmZW5jZSAqZmVuY2UpCiB7Ci0Jc3luY19maWxlLT5jYnNbKmldLmZlbmNlID0g ZmVuY2U7Ci0Jc3luY19maWxlLT5jYnNbKmldLnN5bmNfZmlsZSA9IHN5bmNfZmlsZTsKKwlmZW5j ZXNbKmldID0gZmVuY2U7CiAKLQlpZiAoIWZlbmNlX2FkZF9jYWxsYmFjayhmZW5jZSwgJnN5bmNf ZmlsZS0+Y2JzWyppXS5jYiwKLQkJCQlmZW5jZV9jaGVja19jYl9mdW5jKSkgeworCWlmICghZmVu Y2VfaXNfc2lnbmFsZWQoZmVuY2UpKSB7CiAJCWZlbmNlX2dldChmZW5jZSk7CiAJCSgqaSkrKzsK IAl9CkBAIC0xNDcsMTYgKzE3NiwyMSBAQCBzdGF0aWMgdm9pZCBzeW5jX2ZpbGVfYWRkX3B0KHN0 cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZSwgaW50ICppLAogc3RhdGljIHN0cnVjdCBzeW5jX2Zp bGUgKnN5bmNfZmlsZV9tZXJnZShjb25zdCBjaGFyICpuYW1lLCBzdHJ1Y3Qgc3luY19maWxlICph LAogCQkJCQkgc3RydWN0IHN5bmNfZmlsZSAqYikKIHsKLQlpbnQgbnVtX2ZlbmNlcyA9IGEtPm51 bV9mZW5jZXMgKyBiLT5udW1fZmVuY2VzOwogCXN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZTsK LQlpbnQgaSwgaV9hLCBpX2I7Ci0JdW5zaWduZWQgbG9uZyBzaXplID0gb2Zmc2V0b2Yoc3RydWN0 IHN5bmNfZmlsZSwgY2JzW251bV9mZW5jZXNdKTsKKwlzdHJ1Y3QgZmVuY2UgKipmZW5jZXMsICoq YV9mZW5jZXMsICoqYl9mZW5jZXM7CisJaW50IGksIGlfYSwgaV9iLCBudW1fZmVuY2VzLCBhX251 bV9mZW5jZXMsIGJfbnVtX2ZlbmNlczsKIAotCXN5bmNfZmlsZSA9IHN5bmNfZmlsZV9hbGxvYyhz aXplKTsKKwlzeW5jX2ZpbGUgPSBzeW5jX2ZpbGVfYWxsb2MoKTsKIAlpZiAoIXN5bmNfZmlsZSkK IAkJcmV0dXJuIE5VTEw7CiAKLQlhdG9taWNfc2V0KCZzeW5jX2ZpbGUtPnN0YXR1cywgbnVtX2Zl bmNlcyk7CisJYV9mZW5jZXMgPSBnZXRfZmVuY2VzKGEsICZhX251bV9mZW5jZXMpOworCWJfZmVu Y2VzID0gZ2V0X2ZlbmNlcyhiLCAmYl9udW1fZmVuY2VzKTsKKwludW1fZmVuY2VzID0gYV9udW1f ZmVuY2VzICsgYl9udW1fZmVuY2VzOworCisJZmVuY2VzID0ga2NhbGxvYyhudW1fZmVuY2VzLCBz aXplb2YoKmZlbmNlcyksIEdGUF9LRVJORUwpOworCWlmICghZmVuY2VzKQorCQlnb3RvIGVycjsK IAogCS8qCiAJICogQXNzdW1lIHN5bmNfZmlsZSBhIGFuZCBiIGFyZSBib3RoIG9yZGVyZWQgYW5k IGhhdmUgbm8KQEAgLTE2NSw1NSArMTk5LDY2IEBAIHN0YXRpYyBzdHJ1Y3Qgc3luY19maWxlICpz eW5jX2ZpbGVfbWVyZ2UoY29uc3QgY2hhciAqbmFtZSwgc3RydWN0IHN5bmNfZmlsZSAqYSwKIAkg KiBJZiBhIHN5bmNfZmlsZSBjYW4gb25seSBiZSBjcmVhdGVkIHdpdGggc3luY19maWxlX21lcmdl CiAJICogYW5kIHN5bmNfZmlsZV9jcmVhdGUsIHRoaXMgaXMgYSByZWFzb25hYmxlIGFzc3VtcHRp b24uCiAJICovCi0JZm9yIChpID0gaV9hID0gaV9iID0gMDsgaV9hIDwgYS0+bnVtX2ZlbmNlcyAm JiBpX2IgPCBiLT5udW1fZmVuY2VzOyApIHsKLQkJc3RydWN0IGZlbmNlICpwdF9hID0gYS0+Y2Jz W2lfYV0uZmVuY2U7Ci0JCXN0cnVjdCBmZW5jZSAqcHRfYiA9IGItPmNic1tpX2JdLmZlbmNlOwor CWZvciAoaSA9IGlfYSA9IGlfYiA9IDA7IGlfYSA8IGFfbnVtX2ZlbmNlcyAmJiBpX2IgPCBiX251 bV9mZW5jZXM7ICkgeworCQlzdHJ1Y3QgZmVuY2UgKnB0X2EgPSBhX2ZlbmNlc1tpX2FdOworCQlz dHJ1Y3QgZmVuY2UgKnB0X2IgPSBiX2ZlbmNlc1tpX2JdOwogCiAJCWlmIChwdF9hLT5jb250ZXh0 IDwgcHRfYi0+Y29udGV4dCkgewotCQkJc3luY19maWxlX2FkZF9wdChzeW5jX2ZpbGUsICZpLCBw dF9hKTsKKwkJCWFkZF9mZW5jZShmZW5jZXMsICZpLCBwdF9hKTsKIAogCQkJaV9hKys7CiAJCX0g ZWxzZSBpZiAocHRfYS0+Y29udGV4dCA+IHB0X2ItPmNvbnRleHQpIHsKLQkJCXN5bmNfZmlsZV9h ZGRfcHQoc3luY19maWxlLCAmaSwgcHRfYik7CisJCQlhZGRfZmVuY2UoZmVuY2VzLCAmaSwgcHRf Yik7CiAKIAkJCWlfYisrOwogCQl9IGVsc2UgewogCQkJaWYgKHB0X2EtPnNlcW5vIC0gcHRfYi0+ c2Vxbm8gPD0gSU5UX01BWCkKLQkJCQlzeW5jX2ZpbGVfYWRkX3B0KHN5bmNfZmlsZSwgJmksIHB0 X2EpOworCQkJCWFkZF9mZW5jZShmZW5jZXMsICZpLCBwdF9hKTsKIAkJCWVsc2UKLQkJCQlzeW5j X2ZpbGVfYWRkX3B0KHN5bmNfZmlsZSwgJmksIHB0X2IpOworCQkJCWFkZF9mZW5jZShmZW5jZXMs ICZpLCBwdF9iKTsKIAogCQkJaV9hKys7CiAJCQlpX2IrKzsKIAkJfQogCX0KIAotCWZvciAoOyBp X2EgPCBhLT5udW1fZmVuY2VzOyBpX2ErKykKLQkJc3luY19maWxlX2FkZF9wdChzeW5jX2ZpbGUs ICZpLCBhLT5jYnNbaV9hXS5mZW5jZSk7CisJZm9yICg7IGlfYSA8IGFfbnVtX2ZlbmNlczsgaV9h KyspCisJCWFkZF9mZW5jZShmZW5jZXMsICZpLCBhX2ZlbmNlc1tpX2FdKTsKKworCWZvciAoOyBp X2IgPCBiX251bV9mZW5jZXM7IGlfYisrKQorCQlhZGRfZmVuY2UoZmVuY2VzLCAmaSwgYl9mZW5j ZXNbaV9iXSk7CisKKwlpZiAobnVtX2ZlbmNlcyA+IGkpIHsKKwkJZmVuY2VzID0ga3JlYWxsb2Mo ZmVuY2VzLCBpICogc2l6ZW9mKCoqZmVuY2VzKSwKKwkJCQkgIEdGUF9LRVJORUwpOworCQlpZiAo IWZlbmNlcykKKwkJCWdvdG8gZXJyOworCX0KIAotCWZvciAoOyBpX2IgPCBiLT5udW1fZmVuY2Vz OyBpX2IrKykKLQkJc3luY19maWxlX2FkZF9wdChzeW5jX2ZpbGUsICZpLCBiLT5jYnNbaV9iXS5m ZW5jZSk7CisJaWYgKHN5bmNfZmlsZV9zZXRfZmVuY2Uoc3luY19maWxlLCBmZW5jZXMsIGkpIDwg MCkgeworCQlrZnJlZShmZW5jZXMpOworCQlnb3RvIGVycjsKKwl9CiAKLQlpZiAobnVtX2ZlbmNl cyA+IGkpCi0JCWF0b21pY19zdWIobnVtX2ZlbmNlcyAtIGksICZzeW5jX2ZpbGUtPnN0YXR1cyk7 Ci0Jc3luY19maWxlLT5udW1fZmVuY2VzID0gaTsKKwlmZW5jZV9hZGRfY2FsbGJhY2soc3luY19m aWxlLT5mZW5jZSwgJnN5bmNfZmlsZS0+Y2IsCisJCQkgICBmZW5jZV9jaGVja19jYl9mdW5jKTsK IAogCXN0cmxjcHkoc3luY19maWxlLT5uYW1lLCBuYW1lLCBzaXplb2Yoc3luY19maWxlLT5uYW1l KSk7CiAJcmV0dXJuIHN5bmNfZmlsZTsKKworZXJyOgorCWZwdXQoc3luY19maWxlLT5maWxlKTsK KwlyZXR1cm4gTlVMTDsKKwogfQogCiBzdGF0aWMgdm9pZCBzeW5jX2ZpbGVfZnJlZShzdHJ1Y3Qg a3JlZiAqa3JlZikKIHsKIAlzdHJ1Y3Qgc3luY19maWxlICpzeW5jX2ZpbGUgPSBjb250YWluZXJf b2Yoa3JlZiwgc3RydWN0IHN5bmNfZmlsZSwKIAkJCQkJCSAgICAga3JlZik7Ci0JaW50IGk7Ci0K LQlmb3IgKGkgPSAwOyBpIDwgc3luY19maWxlLT5udW1fZmVuY2VzOyArK2kpIHsKLQkJZmVuY2Vf cmVtb3ZlX2NhbGxiYWNrKHN5bmNfZmlsZS0+Y2JzW2ldLmZlbmNlLAotCQkJCSAgICAgICZzeW5j X2ZpbGUtPmNic1tpXS5jYik7Ci0JCWZlbmNlX3B1dChzeW5jX2ZpbGUtPmNic1tpXS5mZW5jZSk7 Ci0JfQogCisJZmVuY2VfcmVtb3ZlX2NhbGxiYWNrKHN5bmNfZmlsZS0+ZmVuY2UsICZzeW5jX2Zp bGUtPmNiKTsKKwlmZW5jZV9wdXQoc3luY19maWxlLT5mZW5jZSk7CiAJa2ZyZWUoc3luY19maWxl KTsKIH0KIApAQCAtMjMyLDkgKzI3Nyw5IEBAIHN0YXRpYyB1bnNpZ25lZCBpbnQgc3luY19maWxl X3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHBvbGxfdGFibGUgKndhaXQpCiAKIAlwb2xsX3dhaXQo ZmlsZSwgJnN5bmNfZmlsZS0+d3EsIHdhaXQpOwogCi0Jc3RhdHVzID0gYXRvbWljX3JlYWQoJnN5 bmNfZmlsZS0+c3RhdHVzKTsKKwlzdGF0dXMgPSBmZW5jZV9pc19zaWduYWxlZChzeW5jX2ZpbGUt PmZlbmNlKTsKIAotCWlmICghc3RhdHVzKQorCWlmIChzdGF0dXMpCiAJCXJldHVybiBQT0xMSU47 CiAJaWYgKHN0YXR1cyA8IDApCiAJCXJldHVybiBQT0xMRVJSOwpAQCAtMzE1LDggKzM2MCw5IEBA IHN0YXRpYyBsb25nIHN5bmNfZmlsZV9pb2N0bF9mZW5jZV9pbmZvKHN0cnVjdCBzeW5jX2ZpbGUg KnN5bmNfZmlsZSwKIHsKIAlzdHJ1Y3Qgc3luY19maWxlX2luZm8gaW5mbzsKIAlzdHJ1Y3Qgc3lu Y19mZW5jZV9pbmZvICpmZW5jZV9pbmZvID0gTlVMTDsKKwlzdHJ1Y3QgZmVuY2UgKipmZW5jZXM7 CiAJX191MzIgc2l6ZTsKLQlpbnQgcmV0LCBpOworCWludCBudW1fZmVuY2VzLCByZXQsIGk7CiAK IAlpZiAoY29weV9mcm9tX3VzZXIoJmluZm8sICh2b2lkIF9fdXNlciAqKWFyZywgc2l6ZW9mKGlu Zm8pKSkKIAkJcmV0dXJuIC1FRkFVTFQ7CkBAIC0zMjQsNiArMzcwLDggQEAgc3RhdGljIGxvbmcg c3luY19maWxlX2lvY3RsX2ZlbmNlX2luZm8oc3RydWN0IHN5bmNfZmlsZSAqc3luY19maWxlLAog CWlmIChpbmZvLmZsYWdzIHx8IGluZm8ucGFkKQogCQlyZXR1cm4gLUVJTlZBTDsKIAorCWZlbmNl cyA9IGdldF9mZW5jZXMoc3luY19maWxlLCAmbnVtX2ZlbmNlcyk7CisKIAkvKgogCSAqIFBhc3Np bmcgbnVtX2ZlbmNlcyA9IDAgbWVhbnMgdGhhdCB1c2Vyc3BhY2UgZG9lc24ndCB3YW50IHRvCiAJ ICogcmV0cmlldmUgYW55IHN5bmNfZmVuY2VfaW5mby4gSWYgbnVtX2ZlbmNlcyA9IDAgd2Ugc2tp cCBmaWxsaW5nCkBAIC0zMzMsMTYgKzM4MSwxNiBAQCBzdGF0aWMgbG9uZyBzeW5jX2ZpbGVfaW9j dGxfZmVuY2VfaW5mbyhzdHJ1Y3Qgc3luY19maWxlICpzeW5jX2ZpbGUsCiAJaWYgKCFpbmZvLm51 bV9mZW5jZXMpCiAJCWdvdG8gbm9fZmVuY2VzOwogCi0JaWYgKGluZm8ubnVtX2ZlbmNlcyA8IHN5 bmNfZmlsZS0+bnVtX2ZlbmNlcykKKwlpZiAoaW5mby5udW1fZmVuY2VzIDwgbnVtX2ZlbmNlcykK IAkJcmV0dXJuIC1FSU5WQUw7CiAKLQlzaXplID0gc3luY19maWxlLT5udW1fZmVuY2VzICogc2l6 ZW9mKCpmZW5jZV9pbmZvKTsKKwlzaXplID0gbnVtX2ZlbmNlcyAqIHNpemVvZigqZmVuY2VfaW5m byk7CiAJZmVuY2VfaW5mbyA9IGt6YWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFmZW5j ZV9pbmZvKQogCQlyZXR1cm4gLUVOT01FTTsKIAotCWZvciAoaSA9IDA7IGkgPCBzeW5jX2ZpbGUt Pm51bV9mZW5jZXM7ICsraSkKLQkJc3luY19maWxsX2ZlbmNlX2luZm8oc3luY19maWxlLT5jYnNb aV0uZmVuY2UsICZmZW5jZV9pbmZvW2ldKTsKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX2ZlbmNlczsg aSsrKQorCQlzeW5jX2ZpbGxfZmVuY2VfaW5mbyhmZW5jZXNbaV0sICZmZW5jZV9pbmZvW2ldKTsK IAogCWlmIChjb3B5X3RvX3VzZXIodTY0X3RvX3VzZXJfcHRyKGluZm8uc3luY19mZW5jZV9pbmZv KSwgZmVuY2VfaW5mbywKIAkJCSBzaXplKSkgewpAQCAtMzUyLDExICs0MDAsOCBAQCBzdGF0aWMg bG9uZyBzeW5jX2ZpbGVfaW9jdGxfZmVuY2VfaW5mbyhzdHJ1Y3Qgc3luY19maWxlICpzeW5jX2Zp bGUsCiAKIG5vX2ZlbmNlczoKIAlzdHJsY3B5KGluZm8ubmFtZSwgc3luY19maWxlLT5uYW1lLCBz aXplb2YoaW5mby5uYW1lKSk7Ci0JaW5mby5zdGF0dXMgPSBhdG9taWNfcmVhZCgmc3luY19maWxl LT5zdGF0dXMpOwotCWlmIChpbmZvLnN0YXR1cyA+PSAwKQotCQlpbmZvLnN0YXR1cyA9ICFpbmZv LnN0YXR1czsKLQotCWluZm8ubnVtX2ZlbmNlcyA9IHN5bmNfZmlsZS0+bnVtX2ZlbmNlczsKKwlp bmZvLnN0YXR1cyA9IGZlbmNlX2lzX3NpZ25hbGVkKHN5bmNfZmlsZS0+ZmVuY2UpOworCWluZm8u bnVtX2ZlbmNlcyA9IG51bV9mZW5jZXM7CiAKIAlpZiAoY29weV90b191c2VyKCh2b2lkIF9fdXNl ciAqKWFyZywgJmluZm8sIHNpemVvZihpbmZvKSkpCiAJCXJldCA9IC1FRkFVTFQ7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jX2RlYnVnLmMgYi9kcml2ZXJzL3N0YWdp bmcvYW5kcm9pZC9zeW5jX2RlYnVnLmMKaW5kZXggNWY1NzQ5OS4uMDYzOGEwNiAxMDA2NDQKLS0t IGEvZHJpdmVycy9zdGFnaW5nL2FuZHJvaWQvc3luY19kZWJ1Zy5jCisrKyBiL2RyaXZlcnMvc3Rh Z2luZy9hbmRyb2lkL3N5bmNfZGVidWcuYwpAQCAtMTU5LDEwICsxNTksMTUgQEAgc3RhdGljIHZv aWQgc3luY19wcmludF9zeW5jX2ZpbGUoc3RydWN0IHNlcV9maWxlICpzLAogCWludCBpOwogCiAJ c2VxX3ByaW50ZihzLCAiWyVwXSAlczogJXNcbiIsIHN5bmNfZmlsZSwgc3luY19maWxlLT5uYW1l LAotCQkgICBzeW5jX3N0YXR1c19zdHIoYXRvbWljX3JlYWQoJnN5bmNfZmlsZS0+c3RhdHVzKSkp OwotCi0JZm9yIChpID0gMDsgaSA8IHN5bmNfZmlsZS0+bnVtX2ZlbmNlczsgKytpKQotCQlzeW5j X3ByaW50X2ZlbmNlKHMsIHN5bmNfZmlsZS0+Y2JzW2ldLmZlbmNlLCB0cnVlKTsKKwkJICAgc3lu Y19zdGF0dXNfc3RyKCFmZW5jZV9pc19zaWduYWxlZChzeW5jX2ZpbGUtPmZlbmNlKSkpOworCisJ aWYgKGZlbmNlX2lzX2FycmF5KHN5bmNfZmlsZS0+ZmVuY2UpKSB7CisJCXN0cnVjdCBmZW5jZV9h cnJheSAqYXJyYXkgPSB0b19mZW5jZV9hcnJheShzeW5jX2ZpbGUtPmZlbmNlKTsKKwkJZm9yIChp ID0gMDsgaSA8IGFycmF5LT5udW1fZmVuY2VzOyArK2kpCisJCQlzeW5jX3ByaW50X2ZlbmNlKHMs IGFycmF5LT5mZW5jZXNbaV0sIHRydWUpOworCX0gZWxzZSB7CisJCXN5bmNfcHJpbnRfZmVuY2Uo cywgc3luY19maWxlLT5mZW5jZSwgdHJ1ZSk7CisJfQogfQogCiBzdGF0aWMgaW50IHN5bmNfZGVi dWdmc19zaG93KHN0cnVjdCBzZXFfZmlsZSAqcywgdm9pZCAqdW51c2VkKQpkaWZmIC0tZ2l0IGEv aW5jbHVkZS9saW51eC9zeW5jX2ZpbGUuaCBiL2luY2x1ZGUvbGludXgvc3luY19maWxlLmgKaW5k ZXggYzZmZmU4Yi4uMmVmYzVlYyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zeW5jX2ZpbGUu aAorKysgYi9pbmNsdWRlL2xpbnV4L3N5bmNfZmlsZS5oCkBAIC0xOSwxMiArMTksNyBAQAogI2lu Y2x1ZGUgPGxpbnV4L2xpc3QuaD4KICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgogI2luY2x1 ZGUgPGxpbnV4L2ZlbmNlLmg+Ci0KLXN0cnVjdCBzeW5jX2ZpbGVfY2IgewotCXN0cnVjdCBmZW5j ZV9jYiBjYjsKLQlzdHJ1Y3QgZmVuY2UgKmZlbmNlOwotCXN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNf ZmlsZTsKLX07CisjaW5jbHVkZSA8bGludXgvZmVuY2UtYXJyYXkuaD4KIAogLyoqCiAgKiBzdHJ1 Y3Qgc3luY19maWxlIC0gc3luYyBmaWxlIHRvIGV4cG9ydCB0byB0aGUgdXNlcnNwYWNlCkBAIC0z MiwxMCArMjcsOSBAQCBzdHJ1Y3Qgc3luY19maWxlX2NiIHsKICAqIEBrcmVmOgkJcmVmZXJlbmNl IGNvdW50IG9uIGZlbmNlLgogICogQG5hbWU6CQluYW1lIG9mIHN5bmNfZmlsZS4gIFVzZWZ1bCBm b3IgZGVidWdnaW5nCiAgKiBAc3luY19maWxlX2xpc3Q6CW1lbWJlcnNoaXAgaW4gZ2xvYmFsIGZp bGUgbGlzdAotICogQG51bV9mZW5jZXM6CQludW1iZXIgb2Ygc3luY19wdHMgaW4gdGhlIGZlbmNl CiAgKiBAd3E6CQkJd2FpdCBxdWV1ZSBmb3IgZmVuY2Ugc2lnbmFsaW5nCi0gKiBAc3RhdHVzOgkJ MDogc2lnbmFsZWQsID4wOmFjdGl2ZSwgPDA6IGVycm9yCi0gKiBAY2JzOgkJc3luY19wdHMgY2Fs bGJhY2sgaW5mb3JtYXRpb24KKyAqIEBmZW5jZToJCWZlbmNlIHdpdGggdGhlIGZlbmNlcyBpbiB0 aGUgc3luY19maWxlCisgKiBAY2I6CQkJZmVuY2UgY2FsbGJhY2sgaW5mb3JtYXRpb24KICAqLwog c3RydWN0IHN5bmNfZmlsZSB7CiAJc3RydWN0IGZpbGUJCSpmaWxlOwpAQCAtNDQsMTIgKzM4LDEx IEBAIHN0cnVjdCBzeW5jX2ZpbGUgewogI2lmZGVmIENPTkZJR19ERUJVR19GUwogCXN0cnVjdCBs aXN0X2hlYWQJc3luY19maWxlX2xpc3Q7CiAjZW5kaWYKLQlpbnQgbnVtX2ZlbmNlczsKIAogCXdh aXRfcXVldWVfaGVhZF90CXdxOwotCWF0b21pY190CQlzdGF0dXM7CiAKLQlzdHJ1Y3Qgc3luY19m aWxlX2NiCWNic1tdOworCXN0cnVjdCBmZW5jZQkJKmZlbmNlOworCXN0cnVjdCBmZW5jZV9jYiBj YjsKIH07CiAKIHN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZV9jcmVhdGUoc3RydWN0IGZlbmNl ICpmZW5jZSk7Ci0tIAoyLjUuNQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVsCg==