From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752403AbdLGKI7 (ORCPT ); Thu, 7 Dec 2017 05:08:59 -0500 Received: from mail-wm0-f67.google.com ([74.125.82.67]:44950 "EHLO mail-wm0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750981AbdLGKI5 (ORCPT ); Thu, 7 Dec 2017 05:08:57 -0500 X-Google-Smtp-Source: AGs4zMYIT6d7e10y/Oe5W6qX+TasugJvBO2WRunktSSZmEhiaWJYUjROD3+HwWmzaiQddr7GYLHkwA== From: Daniel Vetter To: LKML Cc: DRI Development , Intel Graphics Development , Daniel Vetter , Tvrtko Ursulin , Marta Lofstedt , Byungchul Park , Ingo Molnar , Peter Zijlstra , Tejun Heo , Kees Cook , Thomas Gleixner , Shaohua Li , Andrew Morton , Jens Axboe , Greg Kroah-Hartman , Jonathan Corbet , Oleg Nesterov , Daniel Vetter Subject: [PATCH] kthread: finer-grained lockdep/cross-release completion Date: Thu, 7 Dec 2017 11:08:49 +0100 Message-Id: <20171207100849.407-1-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.15.0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Since -rc1 we're hitting a bunch of lockdep splats using the new cross-release stuff around the 2 kthread completions. In all cases they are because totally independent uses of kthread are mixed up by lockdep into the same locking class, creating artificial deadlocks. Fix this by converting kthread code in the same way as e.g. alloc_workqueue already works: Use macros for the public api so we can have a callsite specific lockdep key, then pass that through the entire callchain. Due to the many entry points this is slightly tedious. Cc: Tvrtko Ursulin Cc: Marta Lofstedt Cc: Byungchul Park Cc: Ingo Molnar Cc: Peter Zijlstra Cc: Tejun Heo Cc: Kees Cook Cc: Thomas Gleixner Cc: Shaohua Li Cc: Andrew Morton Cc: Jens Axboe Cc: Daniel Vetter Cc: Greg Kroah-Hartman Cc: Jonathan Corbet Cc: Oleg Nesterov References: https://bugs.freedesktop.org/show_bug.cgi?id=103950 Signed-off-by: Daniel Vetter --- include/linux/kthread.h | 48 +++++++++++++++++++++++++++++----- kernel/kthread.c | 68 ++++++++++++++++++++++++++++++++++--------------- 2 files changed, 88 insertions(+), 28 deletions(-) diff --git a/include/linux/kthread.h b/include/linux/kthread.h index c1961761311d..7a9463f0be5c 100644 --- a/include/linux/kthread.h +++ b/include/linux/kthread.h @@ -6,10 +6,12 @@ #include #include -__printf(4, 5) -struct task_struct *kthread_create_on_node(int (*threadfn)(void *data), +__printf(6, 7) +struct task_struct *_kthread_create_on_node(int (*threadfn)(void *data), void *data, int node, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, const char namefmt[], ...); /** @@ -25,12 +27,27 @@ struct task_struct *kthread_create_on_node(int (*threadfn)(void *data), */ #define kthread_create(threadfn, data, namefmt, arg...) \ kthread_create_on_node(threadfn, data, NUMA_NO_NODE, namefmt, ##arg) +#define kthread_create_on_node(threadfn, data, node, namefmt, arg...) \ +({ \ + static struct lock_class_key __exited_key, __parked_key; \ + _kthread_create_on_node(threadfn, data, node, &__exited_key, \ + &__parked_key, namefmt, ##arg); \ +}) -struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data), +struct task_struct *_kthread_create_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, const char *namefmt); +#define kthread_create_on_cpu(threadfn, data, cpu, namefmt) \ +({ \ + static struct lock_class_key __exited_key, __parked_key; \ + _kthread_create_on_cpu(threadfn, data, cpu, &__exited_key,\ + &__parked_key, namefmt); \ +}) + /** * kthread_run - create and wake a thread. @@ -171,13 +188,30 @@ extern void __kthread_init_worker(struct kthread_worker *worker, int kthread_worker_fn(void *worker_ptr); -__printf(2, 3) +__printf(4, 5) struct kthread_worker * -kthread_create_worker(unsigned int flags, const char namefmt[], ...); +_kthread_create_worker(unsigned int flags, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, + const char namefmt[], ...); +#define kthread_create_worker(flags, namefmt...) \ +({ \ + static struct lock_class_key __exited_key, __parked_key; \ + _kthread_create_worker(flags, &__exited_key, &__parked_key, \ + ##namefmt); \ +}) -__printf(3, 4) struct kthread_worker * -kthread_create_worker_on_cpu(int cpu, unsigned int flags, +__printf(5, 6) struct kthread_worker * +_kthread_create_worker_on_cpu(int cpu, unsigned int flags, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, const char namefmt[], ...); +#define kthread_create_worker_on_cpu(cpu, flags, namefmt...) \ +({ \ + static struct lock_class_key __exited_key, __parked_key; \ + _kthread_create_worker_on_cpu(cpu, flags, &__exited_key, &__parked_key,\ + ##namefmt); \ +}) bool kthread_queue_work(struct kthread_worker *worker, struct kthread_work *work); diff --git a/kernel/kthread.c b/kernel/kthread.c index cd50e99202b0..5b73e3da0d2e 100644 --- a/kernel/kthread.c +++ b/kernel/kthread.c @@ -32,6 +32,7 @@ struct kthread_create_info int (*threadfn)(void *data); void *data; int node; + struct lock_class_key *exited_key, *parked_key; /* Result passed back to kthread_create() from kthreadd. */ struct task_struct *result; @@ -221,8 +222,15 @@ static int kthread(void *_create) } self->data = data; - init_completion(&self->exited); - init_completion(&self->parked); + lockdep_init_map_crosslock(&self->exited.map.map, + "(kthread completion)->exited", + create->exited_key, 0); + init_completion_map(&self->exited, &self->exited.map.map); + lockdep_init_map_crosslock(&self->parked.map.map, + "(kthread completion)->parked", + create->parked_key, 0); + init_completion_map(&self->parked, &self->exited.map.map); + current->vfork_done = &self->exited; /* OK, tell user we're spawned, wait for stop or wakeup */ @@ -272,9 +280,11 @@ static void create_kthread(struct kthread_create_info *create) } } -static __printf(4, 0) +static __printf(6, 0) struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data), void *data, int node, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, const char namefmt[], va_list args) { @@ -289,6 +299,8 @@ struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data), create->data = data; create->node = node; create->done = &done; + create->exited_key = exited_key; + create->parked_key = parked_key; spin_lock(&kthread_create_lock); list_add_tail(&create->list, &kthread_create_list); @@ -353,21 +365,24 @@ struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data), * * Returns a task_struct or ERR_PTR(-ENOMEM) or ERR_PTR(-EINTR). */ -struct task_struct *kthread_create_on_node(int (*threadfn)(void *data), - void *data, int node, - const char namefmt[], - ...) +struct task_struct *_kthread_create_on_node(int (*threadfn)(void *data), + void *data, int node, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, + const char namefmt[], + ...) { struct task_struct *task; va_list args; va_start(args, namefmt); - task = __kthread_create_on_node(threadfn, data, node, namefmt, args); + task = __kthread_create_on_node(threadfn, data, node, + exited_key, parked_key, namefmt, args); va_end(args); return task; } -EXPORT_SYMBOL(kthread_create_on_node); +EXPORT_SYMBOL(_kthread_create_on_node); static void __kthread_bind_mask(struct task_struct *p, const struct cpumask *mask, long state) { @@ -421,14 +436,16 @@ EXPORT_SYMBOL(kthread_bind); * Description: This helper function creates and names a kernel thread * The thread will be woken and put into park mode. */ -struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data), +struct task_struct *_kthread_create_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, const char *namefmt) { struct task_struct *p; - p = kthread_create_on_node(threadfn, data, cpu_to_node(cpu), namefmt, - cpu); + p = _kthread_create_on_node(threadfn, data, cpu_to_node(cpu), + exited_key, parked_key, namefmt, cpu); if (IS_ERR(p)) return p; kthread_bind(p, cpu); @@ -649,8 +666,10 @@ int kthread_worker_fn(void *worker_ptr) } EXPORT_SYMBOL_GPL(kthread_worker_fn); -static __printf(3, 0) struct kthread_worker * +static __printf(5, 0) struct kthread_worker * __kthread_create_worker(int cpu, unsigned int flags, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, const char namefmt[], va_list args) { struct kthread_worker *worker; @@ -666,8 +685,8 @@ __kthread_create_worker(int cpu, unsigned int flags, if (cpu >= 0) node = cpu_to_node(cpu); - task = __kthread_create_on_node(kthread_worker_fn, worker, - node, namefmt, args); + task = __kthread_create_on_node(kthread_worker_fn, worker, node, + exited_key, parked_key, namefmt, args); if (IS_ERR(task)) goto fail_task; @@ -694,18 +713,22 @@ __kthread_create_worker(int cpu, unsigned int flags, * when the worker was SIGKILLed. */ struct kthread_worker * -kthread_create_worker(unsigned int flags, const char namefmt[], ...) +_kthread_create_worker(unsigned int flags, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, + const char namefmt[], ...) { struct kthread_worker *worker; va_list args; va_start(args, namefmt); - worker = __kthread_create_worker(-1, flags, namefmt, args); + worker = __kthread_create_worker(-1, flags, exited_key, parked_key, + namefmt, args); va_end(args); return worker; } -EXPORT_SYMBOL(kthread_create_worker); +EXPORT_SYMBOL(_kthread_create_worker); /** * kthread_create_worker_on_cpu - create a kthread worker and bind it @@ -725,19 +748,22 @@ EXPORT_SYMBOL(kthread_create_worker); * when the worker was SIGKILLed. */ struct kthread_worker * -kthread_create_worker_on_cpu(int cpu, unsigned int flags, +_kthread_create_worker_on_cpu(int cpu, unsigned int flags, + struct lock_class_key *exited_key, + struct lock_class_key *parked_key, const char namefmt[], ...) { struct kthread_worker *worker; va_list args; va_start(args, namefmt); - worker = __kthread_create_worker(cpu, flags, namefmt, args); + worker = __kthread_create_worker(cpu, flags, exited_key, parked_key, + namefmt, args); va_end(args); return worker; } -EXPORT_SYMBOL(kthread_create_worker_on_cpu); +EXPORT_SYMBOL(_kthread_create_worker_on_cpu); /* * Returns true when the work could not be queued at the moment. -- 2.15.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: [PATCH] kthread: finer-grained lockdep/cross-release completion Date: Thu, 7 Dec 2017 11:08:49 +0100 Message-ID: <20171207100849.407-1-daniel.vetter@ffwll.ch> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x243.google.com (mail-wm0-x243.google.com [IPv6:2a00:1450:400c:c09::243]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5AD886E1F0 for ; Thu, 7 Dec 2017 10:08:57 +0000 (UTC) Received: by mail-wm0-x243.google.com with SMTP id f140so11799376wmd.2 for ; Thu, 07 Dec 2017 02:08:57 -0800 (PST) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: LKML Cc: Jens Axboe , Kees Cook , Tvrtko Ursulin , Peter Zijlstra , Daniel Vetter , Intel Graphics Development , Jonathan Corbet , Andrew Morton , DRI Development , Oleg Nesterov , Byungchul Park , Shaohua Li , Greg Kroah-Hartman , Tejun Heo , Daniel Vetter , Thomas Gleixner , Ingo Molnar List-Id: dri-devel@lists.freedesktop.org U2luY2UgLXJjMSB3ZSdyZSBoaXR0aW5nIGEgYnVuY2ggb2YgbG9ja2RlcCBzcGxhdHMgdXNpbmcg dGhlIG5ldwpjcm9zcy1yZWxlYXNlIHN0dWZmIGFyb3VuZCB0aGUgMiBrdGhyZWFkIGNvbXBsZXRp b25zLiBJbiBhbGwgY2FzZXMKdGhleSBhcmUgYmVjYXVzZSB0b3RhbGx5IGluZGVwZW5kZW50IHVz ZXMgb2Yga3RocmVhZCBhcmUgbWl4ZWQgdXAgYnkKbG9ja2RlcCBpbnRvIHRoZSBzYW1lIGxvY2tp bmcgY2xhc3MsIGNyZWF0aW5nIGFydGlmaWNpYWwgZGVhZGxvY2tzLgoKRml4IHRoaXMgYnkgY29u dmVydGluZyBrdGhyZWFkIGNvZGUgaW4gdGhlIHNhbWUgd2F5IGFzIGUuZy4KYWxsb2Nfd29ya3F1 ZXVlIGFscmVhZHkgd29ya3M6IFVzZSBtYWNyb3MgZm9yIHRoZSBwdWJsaWMgYXBpIHNvIHdlIGNh bgpoYXZlIGEgY2FsbHNpdGUgc3BlY2lmaWMgbG9ja2RlcCBrZXksIHRoZW4gcGFzcyB0aGF0IHRo cm91Z2ggdGhlCmVudGlyZSBjYWxsY2hhaW4uIER1ZSB0byB0aGUgbWFueSBlbnRyeSBwb2ludHMg dGhpcyBpcyBzbGlnaHRseQp0ZWRpb3VzLgoKQ2M6IFR2cnRrbyBVcnN1bGluIDx0dnJ0a28udXJz dWxpbkBpbnRlbC5jb20+CkNjOiBNYXJ0YSBMb2ZzdGVkdCA8bWFydGEubG9mc3RlZHRAaW50ZWwu Y29tPgpDYzogQnl1bmdjaHVsIFBhcmsgPGJ5dW5nY2h1bC5wYXJrQGxnZS5jb20+CkNjOiBJbmdv IE1vbG5hciA8bWluZ29Aa2VybmVsLm9yZz4KQ2M6IFBldGVyIFppamxzdHJhIDxwZXRlcnpAaW5m cmFkZWFkLm9yZz4KQ2M6IFRlanVuIEhlbyA8dGpAa2VybmVsLm9yZz4KQ2M6IEtlZXMgQ29vayA8 a2Vlc2Nvb2tAY2hyb21pdW0ub3JnPgpDYzogVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9u aXguZGU+CkNjOiBTaGFvaHVhIExpIDxzaGxpQGZiLmNvbT4KQ2M6IEFuZHJldyBNb3J0b24gPGFr cG1AbGludXgtZm91bmRhdGlvbi5vcmc+CkNjOiBKZW5zIEF4Ym9lIDxheGJvZUBrZXJuZWwuZGs+ CkNjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPgpDYzogR3JlZyBLcm9h aC1IYXJ0bWFuIDxncmVna2hAbGludXhmb3VuZGF0aW9uLm9yZz4KQ2M6IEpvbmF0aGFuIENvcmJl dCA8Y29yYmV0QGx3bi5uZXQ+CkNjOiBPbGVnIE5lc3Rlcm92IDxvbGVnQHJlZGhhdC5jb20+ClJl ZmVyZW5jZXM6IGh0dHBzOi8vYnVncy5mcmVlZGVza3RvcC5vcmcvc2hvd19idWcuY2dpP2lkPTEw Mzk1MApTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGludGVsLmNv bT4KLS0tCiBpbmNsdWRlL2xpbnV4L2t0aHJlYWQuaCB8IDQ4ICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrLS0tLS0KIGtlcm5lbC9rdGhyZWFkLmMgICAgICAgIHwgNjggKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLQogMiBmaWxlcyBjaGFuZ2VkLCA4 OCBpbnNlcnRpb25zKCspLCAyOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xp bnV4L2t0aHJlYWQuaCBiL2luY2x1ZGUvbGludXgva3RocmVhZC5oCmluZGV4IGMxOTYxNzYxMzEx ZC4uN2E5NDYzZjBiZTVjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2t0aHJlYWQuaAorKysg Yi9pbmNsdWRlL2xpbnV4L2t0aHJlYWQuaApAQCAtNiwxMCArNiwxMiBAQAogI2luY2x1ZGUgPGxp bnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvY2dyb3VwLmg+CiAKLV9fcHJpbnRmKDQsIDUp Ci1zdHJ1Y3QgdGFza19zdHJ1Y3QgKmt0aHJlYWRfY3JlYXRlX29uX25vZGUoaW50ICgqdGhyZWFk Zm4pKHZvaWQgKmRhdGEpLAorX19wcmludGYoNiwgNykKK3N0cnVjdCB0YXNrX3N0cnVjdCAqX2t0 aHJlYWRfY3JlYXRlX29uX25vZGUoaW50ICgqdGhyZWFkZm4pKHZvaWQgKmRhdGEpLAogCQkJCQkg ICB2b2lkICpkYXRhLAogCQkJCQkgICBpbnQgbm9kZSwKKwkJCQkJICAgc3RydWN0IGxvY2tfY2xh c3Nfa2V5ICpleGl0ZWRfa2V5LAorCQkJCQkgICBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgKnBhcmtl ZF9rZXksCiAJCQkJCSAgIGNvbnN0IGNoYXIgbmFtZWZtdFtdLCAuLi4pOwogCiAvKioKQEAgLTI1 LDEyICsyNywyNyBAQCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKmt0aHJlYWRfY3JlYXRlX29uX25vZGUo aW50ICgqdGhyZWFkZm4pKHZvaWQgKmRhdGEpLAogICovCiAjZGVmaW5lIGt0aHJlYWRfY3JlYXRl KHRocmVhZGZuLCBkYXRhLCBuYW1lZm10LCBhcmcuLi4pIFwKIAlrdGhyZWFkX2NyZWF0ZV9vbl9u b2RlKHRocmVhZGZuLCBkYXRhLCBOVU1BX05PX05PREUsIG5hbWVmbXQsICMjYXJnKQorI2RlZmlu ZSBrdGhyZWFkX2NyZWF0ZV9vbl9ub2RlKHRocmVhZGZuLCBkYXRhLCBub2RlLCBuYW1lZm10LCBh cmcuLi4pCVwKKyh7CQkJCQkJCQkJXAorCXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgX19l eGl0ZWRfa2V5LCBfX3BhcmtlZF9rZXk7CVwKKwlfa3RocmVhZF9jcmVhdGVfb25fbm9kZSh0aHJl YWRmbiwgZGF0YSwgbm9kZSwgJl9fZXhpdGVkX2tleSwJXAorCQkJICAgICAgICZfX3BhcmtlZF9r ZXksIG5hbWVmbXQsICMjYXJnKTsJCVwKK30pCiAKIAotc3RydWN0IHRhc2tfc3RydWN0ICprdGhy ZWFkX2NyZWF0ZV9vbl9jcHUoaW50ICgqdGhyZWFkZm4pKHZvaWQgKmRhdGEpLAorc3RydWN0IHRh c2tfc3RydWN0ICpfa3RocmVhZF9jcmVhdGVfb25fY3B1KGludCAoKnRocmVhZGZuKSh2b2lkICpk YXRhKSwKIAkJCQkJICB2b2lkICpkYXRhLAogCQkJCQkgIHVuc2lnbmVkIGludCBjcHUsCisJCQkJ CSAgc3RydWN0IGxvY2tfY2xhc3Nfa2V5ICpleGl0ZWRfa2V5LAorCQkJCQkgIHN0cnVjdCBsb2Nr X2NsYXNzX2tleSAqcGFya2VkX2tleSwKIAkJCQkJICBjb25zdCBjaGFyICpuYW1lZm10KTsKKyNk ZWZpbmUga3RocmVhZF9jcmVhdGVfb25fY3B1KHRocmVhZGZuLCBkYXRhLCBjcHUsIG5hbWVmbXQp CQlcCisoewkJCQkJCQkJCVwKKwlzdGF0aWMgc3RydWN0IGxvY2tfY2xhc3Nfa2V5IF9fZXhpdGVk X2tleSwgX19wYXJrZWRfa2V5OwlcCisJX2t0aHJlYWRfY3JlYXRlX29uX2NwdSh0aHJlYWRmbiwg ZGF0YSwgY3B1LCAmX19leGl0ZWRfa2V5LFwKKwkJCSAgICAgICAmX19wYXJrZWRfa2V5LCBuYW1l Zm10KTsJCQlcCit9KQorCiAKIC8qKgogICoga3RocmVhZF9ydW4gLSBjcmVhdGUgYW5kIHdha2Ug YSB0aHJlYWQuCkBAIC0xNzEsMTMgKzE4OCwzMCBAQCBleHRlcm4gdm9pZCBfX2t0aHJlYWRfaW5p dF93b3JrZXIoc3RydWN0IGt0aHJlYWRfd29ya2VyICp3b3JrZXIsCiAKIGludCBrdGhyZWFkX3dv cmtlcl9mbih2b2lkICp3b3JrZXJfcHRyKTsKIAotX19wcmludGYoMiwgMykKK19fcHJpbnRmKDQs IDUpCiBzdHJ1Y3Qga3RocmVhZF93b3JrZXIgKgota3RocmVhZF9jcmVhdGVfd29ya2VyKHVuc2ln bmVkIGludCBmbGFncywgY29uc3QgY2hhciBuYW1lZm10W10sIC4uLik7Citfa3RocmVhZF9jcmVh dGVfd29ya2VyKHVuc2lnbmVkIGludCBmbGFncywKKwkJICAgICAgIHN0cnVjdCBsb2NrX2NsYXNz X2tleSAqZXhpdGVkX2tleSwKKwkJICAgICAgIHN0cnVjdCBsb2NrX2NsYXNzX2tleSAqcGFya2Vk X2tleSwKKwkJICAgICAgIGNvbnN0IGNoYXIgbmFtZWZtdFtdLCAuLi4pOworI2RlZmluZSBrdGhy ZWFkX2NyZWF0ZV93b3JrZXIoZmxhZ3MsIG5hbWVmbXQuLi4pCQkJCVwKKyh7CQkJCQkJCQkJXAor CXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgX19leGl0ZWRfa2V5LCBfX3BhcmtlZF9rZXk7 CVwKKwlfa3RocmVhZF9jcmVhdGVfd29ya2VyKGZsYWdzLCAmX19leGl0ZWRfa2V5LCAmX19wYXJr ZWRfa2V5LAlcCisJCQkgICAgICAgIyNuYW1lZm10KTsJCQkJXAorfSkKIAotX19wcmludGYoMywg NCkgc3RydWN0IGt0aHJlYWRfd29ya2VyICoKLWt0aHJlYWRfY3JlYXRlX3dvcmtlcl9vbl9jcHUo aW50IGNwdSwgdW5zaWduZWQgaW50IGZsYWdzLAorX19wcmludGYoNSwgNikgc3RydWN0IGt0aHJl YWRfd29ya2VyICoKK19rdGhyZWFkX2NyZWF0ZV93b3JrZXJfb25fY3B1KGludCBjcHUsIHVuc2ln bmVkIGludCBmbGFncywKKwkJICAgICAgIHN0cnVjdCBsb2NrX2NsYXNzX2tleSAqZXhpdGVkX2tl eSwKKwkJICAgICAgIHN0cnVjdCBsb2NrX2NsYXNzX2tleSAqcGFya2VkX2tleSwKIAkJCSAgICAg Y29uc3QgY2hhciBuYW1lZm10W10sIC4uLik7CisjZGVmaW5lIGt0aHJlYWRfY3JlYXRlX3dvcmtl cl9vbl9jcHUoY3B1LCBmbGFncywgbmFtZWZtdC4uLikJXAorKHsJCQkJCQkJCQlcCisJc3RhdGlj IHN0cnVjdCBsb2NrX2NsYXNzX2tleSBfX2V4aXRlZF9rZXksIF9fcGFya2VkX2tleTsJXAorCV9r dGhyZWFkX2NyZWF0ZV93b3JrZXJfb25fY3B1KGNwdSwgZmxhZ3MsICZfX2V4aXRlZF9rZXksICZf X3BhcmtlZF9rZXksXAorCQkJICAgICAgICMjbmFtZWZtdCk7CQkJCVwKK30pCiAKIGJvb2wga3Ro cmVhZF9xdWV1ZV93b3JrKHN0cnVjdCBrdGhyZWFkX3dvcmtlciAqd29ya2VyLAogCQkJc3RydWN0 IGt0aHJlYWRfd29yayAqd29yayk7CmRpZmYgLS1naXQgYS9rZXJuZWwva3RocmVhZC5jIGIva2Vy bmVsL2t0aHJlYWQuYwppbmRleCBjZDUwZTk5MjAyYjAuLjViNzNlM2RhMGQyZSAxMDA2NDQKLS0t IGEva2VybmVsL2t0aHJlYWQuYworKysgYi9rZXJuZWwva3RocmVhZC5jCkBAIC0zMiw2ICszMiw3 IEBAIHN0cnVjdCBrdGhyZWFkX2NyZWF0ZV9pbmZvCiAJaW50ICgqdGhyZWFkZm4pKHZvaWQgKmRh dGEpOwogCXZvaWQgKmRhdGE7CiAJaW50IG5vZGU7CisJc3RydWN0IGxvY2tfY2xhc3Nfa2V5ICpl eGl0ZWRfa2V5LCAqcGFya2VkX2tleTsKIAogCS8qIFJlc3VsdCBwYXNzZWQgYmFjayB0byBrdGhy ZWFkX2NyZWF0ZSgpIGZyb20ga3RocmVhZGQuICovCiAJc3RydWN0IHRhc2tfc3RydWN0ICpyZXN1 bHQ7CkBAIC0yMjEsOCArMjIyLDE1IEBAIHN0YXRpYyBpbnQga3RocmVhZCh2b2lkICpfY3JlYXRl KQogCX0KIAogCXNlbGYtPmRhdGEgPSBkYXRhOwotCWluaXRfY29tcGxldGlvbigmc2VsZi0+ZXhp dGVkKTsKLQlpbml0X2NvbXBsZXRpb24oJnNlbGYtPnBhcmtlZCk7CisJbG9ja2RlcF9pbml0X21h cF9jcm9zc2xvY2soJnNlbGYtPmV4aXRlZC5tYXAubWFwLAorCQkJIihrdGhyZWFkIGNvbXBsZXRp b24pLT5leGl0ZWQiLAorCQkJY3JlYXRlLT5leGl0ZWRfa2V5LCAwKTsKKwlpbml0X2NvbXBsZXRp b25fbWFwKCZzZWxmLT5leGl0ZWQsICZzZWxmLT5leGl0ZWQubWFwLm1hcCk7CisJbG9ja2RlcF9p bml0X21hcF9jcm9zc2xvY2soJnNlbGYtPnBhcmtlZC5tYXAubWFwLAorCQkJIihrdGhyZWFkIGNv bXBsZXRpb24pLT5wYXJrZWQiLAorCQkJY3JlYXRlLT5wYXJrZWRfa2V5LCAwKTsKKwlpbml0X2Nv bXBsZXRpb25fbWFwKCZzZWxmLT5wYXJrZWQsICZzZWxmLT5leGl0ZWQubWFwLm1hcCk7CisKIAlj dXJyZW50LT52Zm9ya19kb25lID0gJnNlbGYtPmV4aXRlZDsKIAogCS8qIE9LLCB0ZWxsIHVzZXIg d2UncmUgc3Bhd25lZCwgd2FpdCBmb3Igc3RvcCBvciB3YWtldXAgKi8KQEAgLTI3Miw5ICsyODAs MTEgQEAgc3RhdGljIHZvaWQgY3JlYXRlX2t0aHJlYWQoc3RydWN0IGt0aHJlYWRfY3JlYXRlX2lu Zm8gKmNyZWF0ZSkKIAl9CiB9CiAKLXN0YXRpYyBfX3ByaW50Zig0LCAwKQorc3RhdGljIF9fcHJp bnRmKDYsIDApCiBzdHJ1Y3QgdGFza19zdHJ1Y3QgKl9fa3RocmVhZF9jcmVhdGVfb25fbm9kZShp bnQgKCp0aHJlYWRmbikodm9pZCAqZGF0YSksCiAJCQkJCQkgICAgdm9pZCAqZGF0YSwgaW50IG5v ZGUsCisJCQkJCQkgICAgc3RydWN0IGxvY2tfY2xhc3Nfa2V5ICpleGl0ZWRfa2V5LAorCQkJCQkJ ICAgIHN0cnVjdCBsb2NrX2NsYXNzX2tleSAqcGFya2VkX2tleSwKIAkJCQkJCSAgICBjb25zdCBj aGFyIG5hbWVmbXRbXSwKIAkJCQkJCSAgICB2YV9saXN0IGFyZ3MpCiB7CkBAIC0yODksNiArMjk5 LDggQEAgc3RydWN0IHRhc2tfc3RydWN0ICpfX2t0aHJlYWRfY3JlYXRlX29uX25vZGUoaW50ICgq dGhyZWFkZm4pKHZvaWQgKmRhdGEpLAogCWNyZWF0ZS0+ZGF0YSA9IGRhdGE7CiAJY3JlYXRlLT5u b2RlID0gbm9kZTsKIAljcmVhdGUtPmRvbmUgPSAmZG9uZTsKKwljcmVhdGUtPmV4aXRlZF9rZXkg PSBleGl0ZWRfa2V5OworCWNyZWF0ZS0+cGFya2VkX2tleSA9IHBhcmtlZF9rZXk7CiAKIAlzcGlu X2xvY2soJmt0aHJlYWRfY3JlYXRlX2xvY2spOwogCWxpc3RfYWRkX3RhaWwoJmNyZWF0ZS0+bGlz dCwgJmt0aHJlYWRfY3JlYXRlX2xpc3QpOwpAQCAtMzUzLDIxICszNjUsMjQgQEAgc3RydWN0IHRh c2tfc3RydWN0ICpfX2t0aHJlYWRfY3JlYXRlX29uX25vZGUoaW50ICgqdGhyZWFkZm4pKHZvaWQg KmRhdGEpLAogICoKICAqIFJldHVybnMgYSB0YXNrX3N0cnVjdCBvciBFUlJfUFRSKC1FTk9NRU0p IG9yIEVSUl9QVFIoLUVJTlRSKS4KICAqLwotc3RydWN0IHRhc2tfc3RydWN0ICprdGhyZWFkX2Ny ZWF0ZV9vbl9ub2RlKGludCAoKnRocmVhZGZuKSh2b2lkICpkYXRhKSwKLQkJCQkJICAgdm9pZCAq ZGF0YSwgaW50IG5vZGUsCi0JCQkJCSAgIGNvbnN0IGNoYXIgbmFtZWZtdFtdLAotCQkJCQkgICAu Li4pCitzdHJ1Y3QgdGFza19zdHJ1Y3QgKl9rdGhyZWFkX2NyZWF0ZV9vbl9ub2RlKGludCAoKnRo cmVhZGZuKSh2b2lkICpkYXRhKSwKKwkJCQkJICAgIHZvaWQgKmRhdGEsIGludCBub2RlLAorCQkJ CQkgICAgc3RydWN0IGxvY2tfY2xhc3Nfa2V5ICpleGl0ZWRfa2V5LAorCQkJCQkgICAgc3RydWN0 IGxvY2tfY2xhc3Nfa2V5ICpwYXJrZWRfa2V5LAorCQkJCQkgICAgY29uc3QgY2hhciBuYW1lZm10 W10sCisJCQkJCSAgICAuLi4pCiB7CiAJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrOwogCXZhX2xp c3QgYXJnczsKIAogCXZhX3N0YXJ0KGFyZ3MsIG5hbWVmbXQpOwotCXRhc2sgPSBfX2t0aHJlYWRf Y3JlYXRlX29uX25vZGUodGhyZWFkZm4sIGRhdGEsIG5vZGUsIG5hbWVmbXQsIGFyZ3MpOworCXRh c2sgPSBfX2t0aHJlYWRfY3JlYXRlX29uX25vZGUodGhyZWFkZm4sIGRhdGEsIG5vZGUsCisJCQkJ CWV4aXRlZF9rZXksIHBhcmtlZF9rZXksIG5hbWVmbXQsIGFyZ3MpOwogCXZhX2VuZChhcmdzKTsK IAogCXJldHVybiB0YXNrOwogfQotRVhQT1JUX1NZTUJPTChrdGhyZWFkX2NyZWF0ZV9vbl9ub2Rl KTsKK0VYUE9SVF9TWU1CT0woX2t0aHJlYWRfY3JlYXRlX29uX25vZGUpOwogCiBzdGF0aWMgdm9p ZCBfX2t0aHJlYWRfYmluZF9tYXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqcCwgY29uc3Qgc3RydWN0 IGNwdW1hc2sgKm1hc2ssIGxvbmcgc3RhdGUpCiB7CkBAIC00MjEsMTQgKzQzNiwxNiBAQCBFWFBP UlRfU1lNQk9MKGt0aHJlYWRfYmluZCk7CiAgKiBEZXNjcmlwdGlvbjogVGhpcyBoZWxwZXIgZnVu Y3Rpb24gY3JlYXRlcyBhbmQgbmFtZXMgYSBrZXJuZWwgdGhyZWFkCiAgKiBUaGUgdGhyZWFkIHdp bGwgYmUgd29rZW4gYW5kIHB1dCBpbnRvIHBhcmsgbW9kZS4KICAqLwotc3RydWN0IHRhc2tfc3Ry dWN0ICprdGhyZWFkX2NyZWF0ZV9vbl9jcHUoaW50ICgqdGhyZWFkZm4pKHZvaWQgKmRhdGEpLAor c3RydWN0IHRhc2tfc3RydWN0ICpfa3RocmVhZF9jcmVhdGVfb25fY3B1KGludCAoKnRocmVhZGZu KSh2b2lkICpkYXRhKSwKIAkJCQkJICB2b2lkICpkYXRhLCB1bnNpZ25lZCBpbnQgY3B1LAorCQkJ CQkgIHN0cnVjdCBsb2NrX2NsYXNzX2tleSAqZXhpdGVkX2tleSwKKwkJCQkJICBzdHJ1Y3QgbG9j a19jbGFzc19rZXkgKnBhcmtlZF9rZXksCiAJCQkJCSAgY29uc3QgY2hhciAqbmFtZWZtdCkKIHsK IAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnA7CiAKLQlwID0ga3RocmVhZF9jcmVhdGVfb25fbm9kZSh0 aHJlYWRmbiwgZGF0YSwgY3B1X3RvX25vZGUoY3B1KSwgbmFtZWZtdCwKLQkJCQkgICBjcHUpOwor CXAgPSBfa3RocmVhZF9jcmVhdGVfb25fbm9kZSh0aHJlYWRmbiwgZGF0YSwgY3B1X3RvX25vZGUo Y3B1KSwKKwkJCQkgICAgZXhpdGVkX2tleSwgcGFya2VkX2tleSwgbmFtZWZtdCwgY3B1KTsKIAlp ZiAoSVNfRVJSKHApKQogCQlyZXR1cm4gcDsKIAlrdGhyZWFkX2JpbmQocCwgY3B1KTsKQEAgLTY0 OSw4ICs2NjYsMTAgQEAgaW50IGt0aHJlYWRfd29ya2VyX2ZuKHZvaWQgKndvcmtlcl9wdHIpCiB9 CiBFWFBPUlRfU1lNQk9MX0dQTChrdGhyZWFkX3dvcmtlcl9mbik7CiAKLXN0YXRpYyBfX3ByaW50 ZigzLCAwKSBzdHJ1Y3Qga3RocmVhZF93b3JrZXIgKgorc3RhdGljIF9fcHJpbnRmKDUsIDApIHN0 cnVjdCBrdGhyZWFkX3dvcmtlciAqCiBfX2t0aHJlYWRfY3JlYXRlX3dvcmtlcihpbnQgY3B1LCB1 bnNpZ25lZCBpbnQgZmxhZ3MsCisJCQlzdHJ1Y3QgbG9ja19jbGFzc19rZXkgKmV4aXRlZF9rZXks CisJCQlzdHJ1Y3QgbG9ja19jbGFzc19rZXkgKnBhcmtlZF9rZXksCiAJCQljb25zdCBjaGFyIG5h bWVmbXRbXSwgdmFfbGlzdCBhcmdzKQogewogCXN0cnVjdCBrdGhyZWFkX3dvcmtlciAqd29ya2Vy OwpAQCAtNjY2LDggKzY4NSw4IEBAIF9fa3RocmVhZF9jcmVhdGVfd29ya2VyKGludCBjcHUsIHVu c2lnbmVkIGludCBmbGFncywKIAlpZiAoY3B1ID49IDApCiAJCW5vZGUgPSBjcHVfdG9fbm9kZShj cHUpOwogCi0JdGFzayA9IF9fa3RocmVhZF9jcmVhdGVfb25fbm9kZShrdGhyZWFkX3dvcmtlcl9m biwgd29ya2VyLAotCQkJCQkJbm9kZSwgbmFtZWZtdCwgYXJncyk7CisJdGFzayA9IF9fa3RocmVh ZF9jcmVhdGVfb25fbm9kZShrdGhyZWFkX3dvcmtlcl9mbiwgd29ya2VyLCBub2RlLAorCQkJCQll eGl0ZWRfa2V5LCBwYXJrZWRfa2V5LCBuYW1lZm10LCBhcmdzKTsKIAlpZiAoSVNfRVJSKHRhc2sp KQogCQlnb3RvIGZhaWxfdGFzazsKIApAQCAtNjk0LDE4ICs3MTMsMjIgQEAgX19rdGhyZWFkX2Ny ZWF0ZV93b3JrZXIoaW50IGNwdSwgdW5zaWduZWQgaW50IGZsYWdzLAogICogd2hlbiB0aGUgd29y a2VyIHdhcyBTSUdLSUxMZWQuCiAgKi8KIHN0cnVjdCBrdGhyZWFkX3dvcmtlciAqCi1rdGhyZWFk X2NyZWF0ZV93b3JrZXIodW5zaWduZWQgaW50IGZsYWdzLCBjb25zdCBjaGFyIG5hbWVmbXRbXSwg Li4uKQorX2t0aHJlYWRfY3JlYXRlX3dvcmtlcih1bnNpZ25lZCBpbnQgZmxhZ3MsCisJCSAgICAg ICBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgKmV4aXRlZF9rZXksCisJCSAgICAgICBzdHJ1Y3QgbG9j a19jbGFzc19rZXkgKnBhcmtlZF9rZXksCisJCSAgICAgICBjb25zdCBjaGFyIG5hbWVmbXRbXSwg Li4uKQogewogCXN0cnVjdCBrdGhyZWFkX3dvcmtlciAqd29ya2VyOwogCXZhX2xpc3QgYXJnczsK IAogCXZhX3N0YXJ0KGFyZ3MsIG5hbWVmbXQpOwotCXdvcmtlciA9IF9fa3RocmVhZF9jcmVhdGVf d29ya2VyKC0xLCBmbGFncywgbmFtZWZtdCwgYXJncyk7CisJd29ya2VyID0gX19rdGhyZWFkX2Ny ZWF0ZV93b3JrZXIoLTEsIGZsYWdzLCBleGl0ZWRfa2V5LCBwYXJrZWRfa2V5LAorCQkJCQkgbmFt ZWZtdCwgYXJncyk7CiAJdmFfZW5kKGFyZ3MpOwogCiAJcmV0dXJuIHdvcmtlcjsKIH0KLUVYUE9S VF9TWU1CT0woa3RocmVhZF9jcmVhdGVfd29ya2VyKTsKK0VYUE9SVF9TWU1CT0woX2t0aHJlYWRf Y3JlYXRlX3dvcmtlcik7CiAKIC8qKgogICoga3RocmVhZF9jcmVhdGVfd29ya2VyX29uX2NwdSAt IGNyZWF0ZSBhIGt0aHJlYWQgd29ya2VyIGFuZCBiaW5kIGl0CkBAIC03MjUsMTkgKzc0OCwyMiBA QCBFWFBPUlRfU1lNQk9MKGt0aHJlYWRfY3JlYXRlX3dvcmtlcik7CiAgKiB3aGVuIHRoZSB3b3Jr ZXIgd2FzIFNJR0tJTExlZC4KICAqLwogc3RydWN0IGt0aHJlYWRfd29ya2VyICoKLWt0aHJlYWRf Y3JlYXRlX3dvcmtlcl9vbl9jcHUoaW50IGNwdSwgdW5zaWduZWQgaW50IGZsYWdzLAorX2t0aHJl YWRfY3JlYXRlX3dvcmtlcl9vbl9jcHUoaW50IGNwdSwgdW5zaWduZWQgaW50IGZsYWdzLAorCQkJ ICAgICAgc3RydWN0IGxvY2tfY2xhc3Nfa2V5ICpleGl0ZWRfa2V5LAorCQkJICAgICAgc3RydWN0 IGxvY2tfY2xhc3Nfa2V5ICpwYXJrZWRfa2V5LAogCQkJICAgICBjb25zdCBjaGFyIG5hbWVmbXRb XSwgLi4uKQogewogCXN0cnVjdCBrdGhyZWFkX3dvcmtlciAqd29ya2VyOwogCXZhX2xpc3QgYXJn czsKIAogCXZhX3N0YXJ0KGFyZ3MsIG5hbWVmbXQpOwotCXdvcmtlciA9IF9fa3RocmVhZF9jcmVh dGVfd29ya2VyKGNwdSwgZmxhZ3MsIG5hbWVmbXQsIGFyZ3MpOworCXdvcmtlciA9IF9fa3RocmVh ZF9jcmVhdGVfd29ya2VyKGNwdSwgZmxhZ3MsIGV4aXRlZF9rZXksIHBhcmtlZF9rZXksCisJCQkJ CSBuYW1lZm10LCBhcmdzKTsKIAl2YV9lbmQoYXJncyk7CiAKIAlyZXR1cm4gd29ya2VyOwogfQot RVhQT1JUX1NZTUJPTChrdGhyZWFkX2NyZWF0ZV93b3JrZXJfb25fY3B1KTsKK0VYUE9SVF9TWU1C T0woX2t0aHJlYWRfY3JlYXRlX3dvcmtlcl9vbl9jcHUpOwogCiAvKgogICogUmV0dXJucyB0cnVl IHdoZW4gdGhlIHdvcmsgY291bGQgbm90IGJlIHF1ZXVlZCBhdCB0aGUgbW9tZW50LgotLSAKMi4x NS4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmkt ZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6 Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK