From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [RFC v4 01/12] kthread: Add kthread_queue_flush_work() Date: Fri, 8 May 2020 16:46:51 -0400 Message-ID: <20200508204751.155488-2-lyude@redhat.com> References: <20200508204751.155488-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Return-path: In-Reply-To: <20200508204751.155488-1-lyude@redhat.com> Sender: linux-kernel-owner@vger.kernel.org To: nouveau@lists.freedesktop.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Cc: Daniel Vetter , Tejun Heo , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Andrew Morton , Suren Baghdasaryan , Petr Mladek , Greg Kroah-Hartman , "Steven Rostedt (VMware)" , Thomas Gleixner , Ben Dooks , Liang Chen List-Id: nouveau.vger.kernel.org Currently, it's only possible to flush on a kthread_work in contexts where it's possible to block. This can be kind of painful though when trying to implement new types of delayed work which use kthread_work, since it means we'd need to drop any spinlocks for new delayed work implementations before we can actually call kthread_flush_work(). In the time between dropping locks and calling kthread_flush_work(), the work might have already executed once and have gotten re-queued by the time we're ready. This would mean that once the user finally executes kthread_flush_work(), we'd accidentally wait for someone else's queued work instead of our own. For DRM vblank works it's preferable that we just return immediately during such races, instead of blocking on the re-queue. Additionally, we also want to be able to use kthread_flush_work structs in our own contexts so that we can block until a vblank work's target vblank has passed, _and_ said work has executed once since. And finally, we also want to be able to finish flushing on a work early if it's been cancelled at any point (e.g. before or after it's actually been queued on the kthread_worker). So, let's make all of these things possible by exposing struct kthread_flush_work, and then splitting kthread_flush_work() into two functions: kthread_queue_flush_work(); which handles possibly queuing up the kthread_flush_work on the work's respective kthread_worker, and kthread_flush_work(); which performs a simple synchronous flush just like before. We also add a DEFINE_KTHREAD_FLUSH_WORK() macro, which simply initializes a kthread_flush_work struct inline (I can't see anyone needing to use a kthread_flush_work that gets used outside of the scope of a single function, and that seems like it would be a bit overkill anyway). Cc: Daniel Vetter Cc: Tejun Heo Cc: Ville Syrjälä Cc: dri-devel@lists.freedesktop.org Cc: nouveau@lists.freedesktop.org Signed-off-by: Lyude Paul --- include/linux/kthread.h | 16 ++++++++ kernel/kthread.c | 87 ++++++++++++++++++++++++++--------------- 2 files changed, 71 insertions(+), 32 deletions(-) diff --git a/include/linux/kthread.h b/include/linux/kthread.h index 8bbcaad7ef0f..0006540ce7f9 100644 --- a/include/linux/kthread.h +++ b/include/linux/kthread.h @@ -105,6 +105,11 @@ struct kthread_delayed_work { struct timer_list timer; }; +struct kthread_flush_work { + struct kthread_work work; + struct completion done; +}; + #define KTHREAD_WORKER_INIT(worker) { \ .lock = __RAW_SPIN_LOCK_UNLOCKED((worker).lock), \ .work_list = LIST_HEAD_INIT((worker).work_list), \ @@ -122,6 +127,11 @@ struct kthread_delayed_work { TIMER_IRQSAFE), \ } +#define KTHREAD_FLUSH_WORK_INIT(fwork) { \ + KTHREAD_WORK_INIT((fwork).work, __kthread_flush_work_fn), \ + COMPLETION_INITIALIZER_ONSTACK((fwork).done), \ + } + #define DEFINE_KTHREAD_WORKER(worker) \ struct kthread_worker worker = KTHREAD_WORKER_INIT(worker) @@ -132,6 +142,9 @@ struct kthread_delayed_work { struct kthread_delayed_work dwork = \ KTHREAD_DELAYED_WORK_INIT(dwork, fn) +#define DEFINE_KTHREAD_FLUSH_WORK(fwork) \ + struct kthread_flush_work fwork = KTHREAD_FLUSH_WORK_INIT(fwork); + /* * kthread_worker.lock needs its own lockdep class key when defined on * stack with lockdep enabled. Use the following macros in such cases. @@ -190,6 +203,9 @@ bool kthread_mod_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay); +bool kthread_queue_flush_work(struct kthread_work *work, + struct kthread_flush_work *fwork); +void __kthread_flush_work_fn(struct kthread_work *work); void kthread_flush_work(struct kthread_work *work); void kthread_flush_worker(struct kthread_worker *worker); diff --git a/kernel/kthread.c b/kernel/kthread.c index bfbfa481be3a..c1f8ec9d5836 100644 --- a/kernel/kthread.c +++ b/kernel/kthread.c @@ -943,52 +943,78 @@ bool kthread_queue_delayed_work(struct kthread_worker *worker, } EXPORT_SYMBOL_GPL(kthread_queue_delayed_work); -struct kthread_flush_work { - struct kthread_work work; - struct completion done; -}; - -static void kthread_flush_work_fn(struct kthread_work *work) -{ - struct kthread_flush_work *fwork = - container_of(work, struct kthread_flush_work, work); - complete(&fwork->done); -} - /** - * kthread_flush_work - flush a kthread_work - * @work: work to flush + * kthread_queue_flush_work - try queuing a kthread_flush_work after a + * queued kthread_work to synchronize with later. + * @work: The &kthread_work to synchronize with later + * @fwork: The &kthread_flush_work to queue + * + * When working with &kthread_work structs in contexts where sleeping isn't + * possible it may be desirable to synchronize with a &kthread_work that's + * currently queued, but only after we've entered a context where it's safe to + * sleep again, and while making sure we don't block on any later re-queues of + * the work. + * + * If @work is queued or executing when kthread_queue_flush_work() is called, + * @fwork will be scheduled for execution immediately after @work. The caller + * can then later synchronize on @fwork.done, which will complete once @work + * has executed once or been cancelled since kthread_queue_flush_work() was + * called. + * + * Returns: %true% if @fwork was queued,and the caller needs to call + * wait_for_completion() on @fwork.done to finish synchronizing, %false% + * otherwise. * - * If @work is queued or executing, wait for it to finish execution. */ -void kthread_flush_work(struct kthread_work *work) +bool kthread_queue_flush_work(struct kthread_work *work, + struct kthread_flush_work *fwork) { - struct kthread_flush_work fwork = { - KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn), - COMPLETION_INITIALIZER_ONSTACK(fwork.done), - }; struct kthread_worker *worker; - bool noop = false; + unsigned long flags; + bool queued = true; worker = work->worker; if (!worker) - return; + return false; - raw_spin_lock_irq(&worker->lock); + raw_spin_lock_irqsave(&worker->lock, flags); /* Work must not be used with >1 worker, see kthread_queue_work(). */ WARN_ON_ONCE(work->worker != worker); if (!list_empty(&work->node)) - kthread_insert_work(worker, &fwork.work, work->node.next); + kthread_insert_work(worker, &fwork->work, work->node.next); else if (worker->current_work == work) - kthread_insert_work(worker, &fwork.work, + kthread_insert_work(worker, &fwork->work, worker->work_list.next); else - noop = true; + queued = false; - raw_spin_unlock_irq(&worker->lock); + raw_spin_unlock_irqrestore(&worker->lock, flags); + return queued; +} +EXPORT_SYMBOL_GPL(kthread_queue_flush_work); + +void __kthread_flush_work_fn(struct kthread_work *work) +{ + struct kthread_flush_work *fwork = + container_of(work, struct kthread_flush_work, work); + complete(&fwork->done); +} +EXPORT_SYMBOL_GPL(__kthread_flush_work_fn); + +/** + * kthread_flush_work - flush a kthread_work + * @work: work to flush + * + * If @work is queued or executing, wait for it to finish execution. + */ +void kthread_flush_work(struct kthread_work *work) +{ + bool queued; + DEFINE_KTHREAD_FLUSH_WORK(fwork); - if (!noop) + queued = kthread_queue_flush_work(work, &fwork); + if (queued) wait_for_completion(&fwork.done); } EXPORT_SYMBOL_GPL(kthread_flush_work); @@ -1170,10 +1196,7 @@ EXPORT_SYMBOL_GPL(kthread_cancel_delayed_work_sync); */ void kthread_flush_worker(struct kthread_worker *worker) { - struct kthread_flush_work fwork = { - KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn), - COMPLETION_INITIALIZER_ONSTACK(fwork.done), - }; + DEFINE_KTHREAD_FLUSH_WORK(fwork); kthread_queue_work(worker, &fwork.work); wait_for_completion(&fwork.done); -- 2.25.4 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.5 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E2506C47255 for ; Fri, 8 May 2020 20:48:40 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id B3F192070B for ; Fri, 8 May 2020 20:48:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="ccD4DIUW" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B3F192070B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 2DBEF6E290; Fri, 8 May 2020 20:48:40 +0000 (UTC) Received: from us-smtp-delivery-1.mimecast.com (us-smtp-2.mimecast.com [205.139.110.61]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3C8B86EB64 for ; Fri, 8 May 2020 20:48:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1588970918; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=y3ztGSvpGSNklTeWYiWdNFt5RlfGyDcXrVhuIPQxxoU=; b=ccD4DIUWt1eUZNnR25gkQUvmHPHnKdMXfoDoF5KgO2P3SgMP7NJW075e9x5bnMI+DyQJw/ YOb4/dp3QIH9X0LFtZwJ0T7sJ86P4Jena82sG++78hBIIH2o8WRtFk6oN1gNBHECkbh5/L 7VXSqz+1A8f1FbAj3LnJS+d+B1gDAwI= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-154-1imByPr6OTqACWsgByTREQ-1; Fri, 08 May 2020 16:48:33 -0400 X-MC-Unique: 1imByPr6OTqACWsgByTREQ-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 34EAF835B49; Fri, 8 May 2020 20:48:31 +0000 (UTC) Received: from Ruby.redhat.com (ovpn-118-29.rdu2.redhat.com [10.10.118.29]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1054A5D9CA; Fri, 8 May 2020 20:48:26 +0000 (UTC) From: Lyude Paul To: nouveau@lists.freedesktop.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [RFC v4 01/12] kthread: Add kthread_queue_flush_work() Date: Fri, 8 May 2020 16:46:51 -0400 Message-Id: <20200508204751.155488-2-lyude@redhat.com> In-Reply-To: <20200508204751.155488-1-lyude@redhat.com> References: <20200508204751.155488-1-lyude@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Petr Mladek , Greg Kroah-Hartman , "Steven Rostedt \(VMware\)" , Ben Dooks , Liang Chen , Tejun Heo , Andrew Morton , Suren Baghdasaryan , Thomas Gleixner Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Q3VycmVudGx5LCBpdCdzIG9ubHkgcG9zc2libGUgdG8gZmx1c2ggb24gYSBrdGhyZWFkX3dvcmsg aW4gY29udGV4dHMKd2hlcmUgaXQncyBwb3NzaWJsZSB0byBibG9jay4gVGhpcyBjYW4gYmUga2lu ZCBvZiBwYWluZnVsIHRob3VnaCB3aGVuCnRyeWluZyB0byBpbXBsZW1lbnQgbmV3IHR5cGVzIG9m IGRlbGF5ZWQgd29yayB3aGljaCB1c2Uga3RocmVhZF93b3JrLApzaW5jZSBpdCBtZWFucyB3ZSdk IG5lZWQgdG8gZHJvcCBhbnkgc3BpbmxvY2tzIGZvciBuZXcgZGVsYXllZCB3b3JrCmltcGxlbWVu dGF0aW9ucyBiZWZvcmUgd2UgY2FuIGFjdHVhbGx5IGNhbGwga3RocmVhZF9mbHVzaF93b3JrKCku CgpJbiB0aGUgdGltZSBiZXR3ZWVuIGRyb3BwaW5nIGxvY2tzIGFuZCBjYWxsaW5nIGt0aHJlYWRf Zmx1c2hfd29yaygpLCB0aGUKd29yayBtaWdodCBoYXZlIGFscmVhZHkgZXhlY3V0ZWQgb25jZSBh bmQgaGF2ZSBnb3R0ZW4gcmUtcXVldWVkIGJ5IHRoZQp0aW1lIHdlJ3JlIHJlYWR5LiBUaGlzIHdv dWxkIG1lYW4gdGhhdCBvbmNlIHRoZSB1c2VyIGZpbmFsbHkgZXhlY3V0ZXMKa3RocmVhZF9mbHVz aF93b3JrKCksIHdlJ2QgYWNjaWRlbnRhbGx5IHdhaXQgZm9yIHNvbWVvbmUgZWxzZSdzIHF1ZXVl ZAp3b3JrIGluc3RlYWQgb2Ygb3VyIG93bi4KCkZvciBEUk0gdmJsYW5rIHdvcmtzIGl0J3MgcHJl ZmVyYWJsZSB0aGF0IHdlIGp1c3QgcmV0dXJuIGltbWVkaWF0ZWx5CmR1cmluZyBzdWNoIHJhY2Vz LCBpbnN0ZWFkIG9mIGJsb2NraW5nIG9uIHRoZSByZS1xdWV1ZS4gQWRkaXRpb25hbGx5LCB3ZQph bHNvIHdhbnQgdG8gYmUgYWJsZSB0byB1c2Uga3RocmVhZF9mbHVzaF93b3JrIHN0cnVjdHMgaW4g b3VyIG93bgpjb250ZXh0cyBzbyB0aGF0IHdlIGNhbiBibG9jayB1bnRpbCBhIHZibGFuayB3b3Jr J3MgdGFyZ2V0IHZibGFuayBoYXMKcGFzc2VkLCBfYW5kXyBzYWlkIHdvcmsgaGFzIGV4ZWN1dGVk IG9uY2Ugc2luY2UuIEFuZCBmaW5hbGx5LCB3ZSBhbHNvCndhbnQgdG8gYmUgYWJsZSB0byBmaW5p c2ggZmx1c2hpbmcgb24gYSB3b3JrIGVhcmx5IGlmIGl0J3MgYmVlbgpjYW5jZWxsZWQgYXQgYW55 IHBvaW50IChlLmcuIGJlZm9yZSBvciBhZnRlciBpdCdzIGFjdHVhbGx5IGJlZW4gcXVldWVkCm9u IHRoZSBrdGhyZWFkX3dvcmtlcikuCgpTbywgbGV0J3MgbWFrZSBhbGwgb2YgdGhlc2UgdGhpbmdz IHBvc3NpYmxlIGJ5IGV4cG9zaW5nIHN0cnVjdAprdGhyZWFkX2ZsdXNoX3dvcmssIGFuZCB0aGVu IHNwbGl0dGluZyBrdGhyZWFkX2ZsdXNoX3dvcmsoKSBpbnRvIHR3bwpmdW5jdGlvbnM6IGt0aHJl YWRfcXVldWVfZmx1c2hfd29yaygpOyB3aGljaCBoYW5kbGVzIHBvc3NpYmx5IHF1ZXVpbmcgdXAK dGhlIGt0aHJlYWRfZmx1c2hfd29yayBvbiB0aGUgd29yaydzIHJlc3BlY3RpdmUga3RocmVhZF93 b3JrZXIsIGFuZAprdGhyZWFkX2ZsdXNoX3dvcmsoKTsgd2hpY2ggcGVyZm9ybXMgYSBzaW1wbGUg c3luY2hyb25vdXMgZmx1c2gganVzdApsaWtlIGJlZm9yZS4gV2UgYWxzbyBhZGQgYSBERUZJTkVf S1RIUkVBRF9GTFVTSF9XT1JLKCkgbWFjcm8sIHdoaWNoCnNpbXBseSBpbml0aWFsaXplcyBhIGt0 aHJlYWRfZmx1c2hfd29yayBzdHJ1Y3QgaW5saW5lIChJIGNhbid0IHNlZQphbnlvbmUgbmVlZGlu ZyB0byB1c2UgYSBrdGhyZWFkX2ZsdXNoX3dvcmsgdGhhdCBnZXRzIHVzZWQgb3V0c2lkZSBvZiB0 aGUKc2NvcGUgb2YgYSBzaW5nbGUgZnVuY3Rpb24sIGFuZCB0aGF0IHNlZW1zIGxpa2UgaXQgd291 bGQgYmUgYSBiaXQKb3ZlcmtpbGwgYW55d2F5KS4KCkNjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWxA ZmZ3bGwuY2g+CkNjOiBUZWp1biBIZW8gPHRqQGtlcm5lbC5vcmc+CkNjOiBWaWxsZSBTeXJqw6Rs w6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgpDYzogZHJpLWRldmVsQGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpDYzogbm91dmVhdUBsaXN0cy5mcmVlZGVza3RvcC5vcmcKU2lnbmVkLW9m Zi1ieTogTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4KLS0tCiBpbmNsdWRlL2xpbnV4L2t0 aHJlYWQuaCB8IDE2ICsrKysrKysrCiBrZXJuZWwva3RocmVhZC5jICAgICAgICB8IDg3ICsrKysr KysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDcx IGluc2VydGlvbnMoKyksIDMyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu dXgva3RocmVhZC5oIGIvaW5jbHVkZS9saW51eC9rdGhyZWFkLmgKaW5kZXggOGJiY2FhZDdlZjBm Li4wMDA2NTQwY2U3ZjkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgva3RocmVhZC5oCisrKyBi L2luY2x1ZGUvbGludXgva3RocmVhZC5oCkBAIC0xMDUsNiArMTA1LDExIEBAIHN0cnVjdCBrdGhy ZWFkX2RlbGF5ZWRfd29yayB7CiAJc3RydWN0IHRpbWVyX2xpc3QgdGltZXI7CiB9OwogCitzdHJ1 Y3Qga3RocmVhZF9mbHVzaF93b3JrIHsKKwlzdHJ1Y3Qga3RocmVhZF93b3JrCXdvcms7CisJc3Ry dWN0IGNvbXBsZXRpb24JZG9uZTsKK307CisKICNkZWZpbmUgS1RIUkVBRF9XT1JLRVJfSU5JVCh3 b3JrZXIpCXsJCQkJXAogCS5sb2NrID0gX19SQVdfU1BJTl9MT0NLX1VOTE9DS0VEKCh3b3JrZXIp LmxvY2spLAkJXAogCS53b3JrX2xpc3QgPSBMSVNUX0hFQURfSU5JVCgod29ya2VyKS53b3JrX2xp c3QpLAkJXApAQCAtMTIyLDYgKzEyNywxMSBAQCBzdHJ1Y3Qga3RocmVhZF9kZWxheWVkX3dvcmsg ewogCQkJCSAgICAgVElNRVJfSVJRU0FGRSksCQkJXAogCX0KIAorI2RlZmluZSBLVEhSRUFEX0ZM VVNIX1dPUktfSU5JVChmd29yaykgeyBcCisJS1RIUkVBRF9XT1JLX0lOSVQoKGZ3b3JrKS53b3Jr LCBfX2t0aHJlYWRfZmx1c2hfd29ya19mbiksIFwKKwlDT01QTEVUSU9OX0lOSVRJQUxJWkVSX09O U1RBQ0soKGZ3b3JrKS5kb25lKSwgXAorCX0KKwogI2RlZmluZSBERUZJTkVfS1RIUkVBRF9XT1JL RVIod29ya2VyKQkJCQkJXAogCXN0cnVjdCBrdGhyZWFkX3dvcmtlciB3b3JrZXIgPSBLVEhSRUFE X1dPUktFUl9JTklUKHdvcmtlcikKIApAQCAtMTMyLDYgKzE0Miw5IEBAIHN0cnVjdCBrdGhyZWFk X2RlbGF5ZWRfd29yayB7CiAJc3RydWN0IGt0aHJlYWRfZGVsYXllZF93b3JrIGR3b3JrID0JCQkJ XAogCQlLVEhSRUFEX0RFTEFZRURfV09SS19JTklUKGR3b3JrLCBmbikKIAorI2RlZmluZSBERUZJ TkVfS1RIUkVBRF9GTFVTSF9XT1JLKGZ3b3JrKSBcCisJc3RydWN0IGt0aHJlYWRfZmx1c2hfd29y ayBmd29yayA9IEtUSFJFQURfRkxVU0hfV09SS19JTklUKGZ3b3JrKTsKKwogLyoKICAqIGt0aHJl YWRfd29ya2VyLmxvY2sgbmVlZHMgaXRzIG93biBsb2NrZGVwIGNsYXNzIGtleSB3aGVuIGRlZmlu ZWQgb24KICAqIHN0YWNrIHdpdGggbG9ja2RlcCBlbmFibGVkLiAgVXNlIHRoZSBmb2xsb3dpbmcg bWFjcm9zIGluIHN1Y2ggY2FzZXMuCkBAIC0xOTAsNiArMjAzLDkgQEAgYm9vbCBrdGhyZWFkX21v ZF9kZWxheWVkX3dvcmsoc3RydWN0IGt0aHJlYWRfd29ya2VyICp3b3JrZXIsCiAJCQkgICAgICBz dHJ1Y3Qga3RocmVhZF9kZWxheWVkX3dvcmsgKmR3b3JrLAogCQkJICAgICAgdW5zaWduZWQgbG9u ZyBkZWxheSk7CiAKK2Jvb2wga3RocmVhZF9xdWV1ZV9mbHVzaF93b3JrKHN0cnVjdCBrdGhyZWFk X3dvcmsgKndvcmssCisJCQkgICAgICBzdHJ1Y3Qga3RocmVhZF9mbHVzaF93b3JrICpmd29yayk7 Cit2b2lkIF9fa3RocmVhZF9mbHVzaF93b3JrX2ZuKHN0cnVjdCBrdGhyZWFkX3dvcmsgKndvcmsp Owogdm9pZCBrdGhyZWFkX2ZsdXNoX3dvcmsoc3RydWN0IGt0aHJlYWRfd29yayAqd29yayk7CiB2 b2lkIGt0aHJlYWRfZmx1c2hfd29ya2VyKHN0cnVjdCBrdGhyZWFkX3dvcmtlciAqd29ya2VyKTsK IApkaWZmIC0tZ2l0IGEva2VybmVsL2t0aHJlYWQuYyBiL2tlcm5lbC9rdGhyZWFkLmMKaW5kZXgg YmZiZmE0ODFiZTNhLi5jMWY4ZWM5ZDU4MzYgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9rdGhyZWFkLmMK KysrIGIva2VybmVsL2t0aHJlYWQuYwpAQCAtOTQzLDUyICs5NDMsNzggQEAgYm9vbCBrdGhyZWFk X3F1ZXVlX2RlbGF5ZWRfd29yayhzdHJ1Y3Qga3RocmVhZF93b3JrZXIgKndvcmtlciwKIH0KIEVY UE9SVF9TWU1CT0xfR1BMKGt0aHJlYWRfcXVldWVfZGVsYXllZF93b3JrKTsKIAotc3RydWN0IGt0 aHJlYWRfZmx1c2hfd29yayB7Ci0Jc3RydWN0IGt0aHJlYWRfd29yawl3b3JrOwotCXN0cnVjdCBj b21wbGV0aW9uCWRvbmU7Ci19OwotCi1zdGF0aWMgdm9pZCBrdGhyZWFkX2ZsdXNoX3dvcmtfZm4o c3RydWN0IGt0aHJlYWRfd29yayAqd29yaykKLXsKLQlzdHJ1Y3Qga3RocmVhZF9mbHVzaF93b3Jr ICpmd29yayA9Ci0JCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3Qga3RocmVhZF9mbHVzaF93b3Jr LCB3b3JrKTsKLQljb21wbGV0ZSgmZndvcmstPmRvbmUpOwotfQotCiAvKioKLSAqIGt0aHJlYWRf Zmx1c2hfd29yayAtIGZsdXNoIGEga3RocmVhZF93b3JrCi0gKiBAd29yazogd29yayB0byBmbHVz aAorICoga3RocmVhZF9xdWV1ZV9mbHVzaF93b3JrIC0gdHJ5IHF1ZXVpbmcgYSBrdGhyZWFkX2Zs dXNoX3dvcmsgYWZ0ZXIgYQorICogcXVldWVkIGt0aHJlYWRfd29yayB0byBzeW5jaHJvbml6ZSB3 aXRoIGxhdGVyLgorICogQHdvcms6IFRoZSAma3RocmVhZF93b3JrIHRvIHN5bmNocm9uaXplIHdp dGggbGF0ZXIKKyAqIEBmd29yazogVGhlICZrdGhyZWFkX2ZsdXNoX3dvcmsgdG8gcXVldWUKKyAq CisgKiBXaGVuIHdvcmtpbmcgd2l0aCAma3RocmVhZF93b3JrIHN0cnVjdHMgaW4gY29udGV4dHMg d2hlcmUgc2xlZXBpbmcgaXNuJ3QKKyAqIHBvc3NpYmxlIGl0IG1heSBiZSBkZXNpcmFibGUgdG8g c3luY2hyb25pemUgd2l0aCBhICZrdGhyZWFkX3dvcmsgdGhhdCdzCisgKiBjdXJyZW50bHkgcXVl dWVkLCBidXQgb25seSBhZnRlciB3ZSd2ZSBlbnRlcmVkIGEgY29udGV4dCB3aGVyZSBpdCdzIHNh ZmUgdG8KKyAqIHNsZWVwIGFnYWluLCBhbmQgd2hpbGUgbWFraW5nIHN1cmUgd2UgZG9uJ3QgYmxv Y2sgb24gYW55IGxhdGVyIHJlLXF1ZXVlcyBvZgorICogdGhlIHdvcmsuCisgKgorICogSWYgQHdv cmsgaXMgcXVldWVkIG9yIGV4ZWN1dGluZyB3aGVuIGt0aHJlYWRfcXVldWVfZmx1c2hfd29yaygp IGlzIGNhbGxlZCwKKyAqIEBmd29yayB3aWxsIGJlIHNjaGVkdWxlZCBmb3IgZXhlY3V0aW9uIGlt bWVkaWF0ZWx5IGFmdGVyIEB3b3JrLiBUaGUgY2FsbGVyCisgKiBjYW4gdGhlbiBsYXRlciBzeW5j aHJvbml6ZSBvbiBAZndvcmsuZG9uZSwgd2hpY2ggd2lsbCBjb21wbGV0ZSBvbmNlIEB3b3JrCisg KiBoYXMgZXhlY3V0ZWQgb25jZSBvciBiZWVuIGNhbmNlbGxlZCBzaW5jZSBrdGhyZWFkX3F1ZXVl X2ZsdXNoX3dvcmsoKSB3YXMKKyAqIGNhbGxlZC4KKyAqCisgKiBSZXR1cm5zOiAldHJ1ZSUgaWYg QGZ3b3JrIHdhcyBxdWV1ZWQsYW5kIHRoZSBjYWxsZXIgbmVlZHMgdG8gY2FsbAorICogd2FpdF9m b3JfY29tcGxldGlvbigpIG9uIEBmd29yay5kb25lIHRvIGZpbmlzaCBzeW5jaHJvbml6aW5nLCAl ZmFsc2UlCisgKiBvdGhlcndpc2UuCiAgKgotICogSWYgQHdvcmsgaXMgcXVldWVkIG9yIGV4ZWN1 dGluZywgd2FpdCBmb3IgaXQgdG8gZmluaXNoIGV4ZWN1dGlvbi4KICAqLwotdm9pZCBrdGhyZWFk X2ZsdXNoX3dvcmsoc3RydWN0IGt0aHJlYWRfd29yayAqd29yaykKK2Jvb2wga3RocmVhZF9xdWV1 ZV9mbHVzaF93b3JrKHN0cnVjdCBrdGhyZWFkX3dvcmsgKndvcmssCisJCQkgICAgICBzdHJ1Y3Qg a3RocmVhZF9mbHVzaF93b3JrICpmd29yaykKIHsKLQlzdHJ1Y3Qga3RocmVhZF9mbHVzaF93b3Jr IGZ3b3JrID0gewotCQlLVEhSRUFEX1dPUktfSU5JVChmd29yay53b3JrLCBrdGhyZWFkX2ZsdXNo X3dvcmtfZm4pLAotCQlDT01QTEVUSU9OX0lOSVRJQUxJWkVSX09OU1RBQ0soZndvcmsuZG9uZSks Ci0JfTsKIAlzdHJ1Y3Qga3RocmVhZF93b3JrZXIgKndvcmtlcjsKLQlib29sIG5vb3AgPSBmYWxz ZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWJvb2wgcXVldWVkID0gdHJ1ZTsKIAogCXdvcmtl ciA9IHdvcmstPndvcmtlcjsKIAlpZiAoIXdvcmtlcikKLQkJcmV0dXJuOworCQlyZXR1cm4gZmFs c2U7CiAKLQlyYXdfc3Bpbl9sb2NrX2lycSgmd29ya2VyLT5sb2NrKTsKKwlyYXdfc3Bpbl9sb2Nr X2lycXNhdmUoJndvcmtlci0+bG9jaywgZmxhZ3MpOwogCS8qIFdvcmsgbXVzdCBub3QgYmUgdXNl ZCB3aXRoID4xIHdvcmtlciwgc2VlIGt0aHJlYWRfcXVldWVfd29yaygpLiAqLwogCVdBUk5fT05f T05DRSh3b3JrLT53b3JrZXIgIT0gd29ya2VyKTsKIAogCWlmICghbGlzdF9lbXB0eSgmd29yay0+ bm9kZSkpCi0JCWt0aHJlYWRfaW5zZXJ0X3dvcmsod29ya2VyLCAmZndvcmsud29yaywgd29yay0+ bm9kZS5uZXh0KTsKKwkJa3RocmVhZF9pbnNlcnRfd29yayh3b3JrZXIsICZmd29yay0+d29yaywg d29yay0+bm9kZS5uZXh0KTsKIAllbHNlIGlmICh3b3JrZXItPmN1cnJlbnRfd29yayA9PSB3b3Jr KQotCQlrdGhyZWFkX2luc2VydF93b3JrKHdvcmtlciwgJmZ3b3JrLndvcmssCisJCWt0aHJlYWRf aW5zZXJ0X3dvcmsod29ya2VyLCAmZndvcmstPndvcmssCiAJCQkJICAgIHdvcmtlci0+d29ya19s aXN0Lm5leHQpOwogCWVsc2UKLQkJbm9vcCA9IHRydWU7CisJCXF1ZXVlZCA9IGZhbHNlOwogCi0J cmF3X3NwaW5fdW5sb2NrX2lycSgmd29ya2VyLT5sb2NrKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmd29ya2VyLT5sb2NrLCBmbGFncyk7CisJcmV0dXJuIHF1ZXVlZDsKK30KK0VYUE9S VF9TWU1CT0xfR1BMKGt0aHJlYWRfcXVldWVfZmx1c2hfd29yayk7CisKK3ZvaWQgX19rdGhyZWFk X2ZsdXNoX3dvcmtfZm4oc3RydWN0IGt0aHJlYWRfd29yayAqd29yaykKK3sKKwlzdHJ1Y3Qga3Ro cmVhZF9mbHVzaF93b3JrICpmd29yayA9CisJCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3Qga3Ro cmVhZF9mbHVzaF93b3JrLCB3b3JrKTsKKwljb21wbGV0ZSgmZndvcmstPmRvbmUpOworfQorRVhQ T1JUX1NZTUJPTF9HUEwoX19rdGhyZWFkX2ZsdXNoX3dvcmtfZm4pOworCisvKioKKyAqIGt0aHJl YWRfZmx1c2hfd29yayAtIGZsdXNoIGEga3RocmVhZF93b3JrCisgKiBAd29yazogd29yayB0byBm bHVzaAorICoKKyAqIElmIEB3b3JrIGlzIHF1ZXVlZCBvciBleGVjdXRpbmcsIHdhaXQgZm9yIGl0 IHRvIGZpbmlzaCBleGVjdXRpb24uCisgKi8KK3ZvaWQga3RocmVhZF9mbHVzaF93b3JrKHN0cnVj dCBrdGhyZWFkX3dvcmsgKndvcmspCit7CisJYm9vbCBxdWV1ZWQ7CisJREVGSU5FX0tUSFJFQURf RkxVU0hfV09SSyhmd29yayk7CiAKLQlpZiAoIW5vb3ApCisJcXVldWVkID0ga3RocmVhZF9xdWV1 ZV9mbHVzaF93b3JrKHdvcmssICZmd29yayk7CisJaWYgKHF1ZXVlZCkKIAkJd2FpdF9mb3JfY29t cGxldGlvbigmZndvcmsuZG9uZSk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChrdGhyZWFkX2ZsdXNo X3dvcmspOwpAQCAtMTE3MCwxMCArMTE5Niw3IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGt0aHJlYWRf Y2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKTsKICAqLwogdm9pZCBrdGhyZWFkX2ZsdXNoX3dvcmtl cihzdHJ1Y3Qga3RocmVhZF93b3JrZXIgKndvcmtlcikKIHsKLQlzdHJ1Y3Qga3RocmVhZF9mbHVz aF93b3JrIGZ3b3JrID0gewotCQlLVEhSRUFEX1dPUktfSU5JVChmd29yay53b3JrLCBrdGhyZWFk X2ZsdXNoX3dvcmtfZm4pLAotCQlDT01QTEVUSU9OX0lOSVRJQUxJWkVSX09OU1RBQ0soZndvcmsu ZG9uZSksCi0JfTsKKwlERUZJTkVfS1RIUkVBRF9GTFVTSF9XT1JLKGZ3b3JrKTsKIAogCWt0aHJl YWRfcXVldWVfd29yayh3b3JrZXIsICZmd29yay53b3JrKTsKIAl3YWl0X2Zvcl9jb21wbGV0aW9u KCZmd29yay5kb25lKTsKLS0gCjIuMjUuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg==