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=-9.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable 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 2D0EAC04AAF for ; Tue, 21 May 2019 14:47:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id EC9B0217D7 for ; Tue, 21 May 2019 14:47:54 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="fpCVJsMG" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728733AbfEUOry (ORCPT ); Tue, 21 May 2019 10:47:54 -0400 Received: from mail-ed1-f66.google.com ([209.85.208.66]:33362 "EHLO mail-ed1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728715AbfEUOrw (ORCPT ); Tue, 21 May 2019 10:47:52 -0400 Received: by mail-ed1-f66.google.com with SMTP id n17so29871244edb.0 for ; Tue, 21 May 2019 07:47:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ORiID9Ap1Ob1uAeKkaBEOgmrOkRFTz441mfPcwfeVdo=; b=fpCVJsMGbVo4GpzstOvt8j2+d91/EMWbNCdaBUHhz7PfDrfsbmYFj936b3DTgwnHL3 2uoQ8oWlpW6PBeEvByLI+hamcbjZf/Bd92NU6WxXZvOa1xc2hvdotOLIYpZEj3rogl8X NhpXPJa4dNEj21vwsB5tLPXadJz1t4Y0lktR8= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ORiID9Ap1Ob1uAeKkaBEOgmrOkRFTz441mfPcwfeVdo=; b=F3E0sGbOrg9JGe+rIUt8bQpjqRnegM3/Zeh67d89N8Mj1U0IGe5WM6yN6PsutKcLeS 8bFlT3o9ItUMI86gCNHOUPlxvG+BgM+GUwBr8gNuSx8bhUScU9aG0MYsA6XFjO9rsGJR AacxQ5V0fQeAK1DV5x6LCJmtdjjttDR4KtnQFvuO7XpaVWhTpECexJvTN7iAo8FNwbHS rQ8KlrR0CdWXv8qtDe/VDqa9wJswD4McIzlwQsqNdZykcnJH665RrxRF1EV9EYV3psx4 rFC0aaO2aD6xdgZRPGlP5HwGJWXaAIoT0pTlM1mDGGHYUAZdpqujD9ibEOgR72zIoywG 3k4Q== X-Gm-Message-State: APjAAAVnjOCDM/Ld3l3rzaKUSvFF5qv5fFxGJQZEoFXc9QE6dtUPU41O JrvfblSlXXU69kr8eMEUx7/m3w== X-Google-Smtp-Source: APXvYqxERFtQFlyIJ7giopEydDDWTX5kk1Gf0ci+hNclUSwmbRui3nZHrUHxGCfgmxEnBmWtycq59A== X-Received: by 2002:a50:896a:: with SMTP id f39mr82284940edf.293.1558450070057; Tue, 21 May 2019 07:47:50 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:569e:0:3106:d637:d723:e855]) by smtp.gmail.com with ESMTPSA id p27sm3510990ejf.65.2019.05.21.07.47.48 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 21 May 2019 07:47:48 -0700 (PDT) From: Daniel Vetter To: DRI Development Cc: Intel Graphics Development , LKML , Linux MM , Daniel Vetter , Peter Zijlstra , Ingo Molnar , Andrew Morton , Michal Hocko , David Rientjes , =?UTF-8?q?Christian=20K=C3=B6nig?= , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Masahiro Yamada , Wei Wang , Andy Shevchenko , Thomas Gleixner , Jann Horn , Feng Tang , Kees Cook , Randy Dunlap , Daniel Vetter Subject: [PATCH] kernel.h: Add non_block_start/end() Date: Tue, 21 May 2019 16:47:43 +0200 Message-Id: <20190521144743.6895-1-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190520213945.17046-2-daniel.vetter@ffwll.ch> References: <20190520213945.17046-2-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org In some special cases we must not block, but there's not a spinlock, preempt-off, irqs-off or similar critical section already that arms the might_sleep() debug checks. Add a non_block_start/end() pair to annotate these. This will be used in the oom paths of mmu-notifiers, where blocking is not allowed to make sure there's forward progress. Quoting Michal: "The notifier is called from quite a restricted context - oom_reaper - which shouldn't depend on any locks or sleepable conditionals. The code should be swift as well but we mostly do care about it to make a forward progress. Checking for sleepable context is the best thing we could come up with that would describe these demands at least partially." Peter also asked whether we want to catch spinlocks on top, but Michal said those are less of a problem because spinlocks can't have an indirect dependency upon the page allocator and hence close the loop with the oom reaper. Suggested by Michal Hocko. v2: - Improve commit message (Michal) - Also check in schedule, not just might_sleep (Peter) v3: It works better when I actually squash in the fixup I had lying around :-/ Cc: Peter Zijlstra Cc: Ingo Molnar Cc: Andrew Morton Cc: Michal Hocko Cc: David Rientjes Cc: "Christian König" Cc: Daniel Vetter Cc: "Jérôme Glisse" Cc: linux-mm@kvack.org Cc: Masahiro Yamada Cc: Wei Wang Cc: Andy Shevchenko Cc: Thomas Gleixner Cc: Jann Horn Cc: Feng Tang Cc: Kees Cook Cc: Randy Dunlap Cc: linux-kernel@vger.kernel.org Acked-by: Christian König (v1) Signed-off-by: Daniel Vetter --- include/linux/kernel.h | 10 +++++++++- include/linux/sched.h | 4 ++++ kernel/sched/core.c | 19 ++++++++++++++----- 3 files changed, 27 insertions(+), 6 deletions(-) diff --git a/include/linux/kernel.h b/include/linux/kernel.h index 74b1ee9027f5..b5f2c2ff0eab 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h @@ -214,7 +214,9 @@ extern void __cant_sleep(const char *file, int line, int preempt_offset); * might_sleep - annotation for functions that can sleep * * this macro will print a stack trace if it is executed in an atomic - * context (spinlock, irq-handler, ...). + * context (spinlock, irq-handler, ...). Additional sections where blocking is + * not allowed can be annotated with non_block_start() and non_block_end() + * pairs. * * This is a useful debugging help to be able to catch problems early and not * be bitten later when the calling function happens to sleep when it is not @@ -230,6 +232,10 @@ extern void __cant_sleep(const char *file, int line, int preempt_offset); # define cant_sleep() \ do { __cant_sleep(__FILE__, __LINE__, 0); } while (0) # define sched_annotate_sleep() (current->task_state_change = 0) +# define non_block_start() \ + do { current->non_block_count++; } while (0) +# define non_block_end() \ + do { WARN_ON(current->non_block_count-- == 0); } while (0) #else static inline void ___might_sleep(const char *file, int line, int preempt_offset) { } @@ -238,6 +244,8 @@ extern void __cant_sleep(const char *file, int line, int preempt_offset); # define might_sleep() do { might_resched(); } while (0) # define cant_sleep() do { } while (0) # define sched_annotate_sleep() do { } while (0) +# define non_block_start() do { } while (0) +# define non_block_end() do { } while (0) #endif #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0) diff --git a/include/linux/sched.h b/include/linux/sched.h index 11837410690f..7f5b293e72df 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -908,6 +908,10 @@ struct task_struct { struct mutex_waiter *blocked_on; #endif +#ifdef CONFIG_DEBUG_ATOMIC_SLEEP + int non_block_count; +#endif + #ifdef CONFIG_TRACE_IRQFLAGS unsigned int irq_events; unsigned long hardirq_enable_ip; diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 102dfcf0a29a..ed7755a28465 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -3264,13 +3264,22 @@ static noinline void __schedule_bug(struct task_struct *prev) /* * Various schedule()-time debugging checks and statistics: */ -static inline void schedule_debug(struct task_struct *prev) +static inline void schedule_debug(struct task_struct *prev, bool preempt) { #ifdef CONFIG_SCHED_STACK_END_CHECK if (task_stack_end_corrupted(prev)) panic("corrupted stack end detected inside scheduler\n"); #endif +#ifdef CONFIG_DEBUG_ATOMIC_SLEEP + if (!preempt && prev->state && prev->non_block_count) { + printk(KERN_ERR "BUG: scheduling in a non-blocking section: %s/%d/%i\n", + prev->comm, prev->pid, prev->non_block_count); + dump_stack(); + add_taint(TAINT_WARN, LOCKDEP_STILL_OK); + } +#endif + if (unlikely(in_atomic_preempt_off())) { __schedule_bug(prev); preempt_count_set(PREEMPT_DISABLED); @@ -3377,7 +3386,7 @@ static void __sched notrace __schedule(bool preempt) rq = cpu_rq(cpu); prev = rq->curr; - schedule_debug(prev); + schedule_debug(prev, preempt); if (sched_feat(HRTICK)) hrtick_clear(rq); @@ -6102,7 +6111,7 @@ void ___might_sleep(const char *file, int line, int preempt_offset) rcu_sleep_check(); if ((preempt_count_equals(preempt_offset) && !irqs_disabled() && - !is_idle_task(current)) || + !is_idle_task(current) && !current->non_block_count) || system_state == SYSTEM_BOOTING || system_state > SYSTEM_RUNNING || oops_in_progress) return; @@ -6118,8 +6127,8 @@ void ___might_sleep(const char *file, int line, int preempt_offset) "BUG: sleeping function called from invalid context at %s:%d\n", file, line); printk(KERN_ERR - "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n", - in_atomic(), irqs_disabled(), + "in_atomic(): %d, irqs_disabled(): %d, non_block: %d, pid: %d, name: %s\n", + in_atomic(), irqs_disabled(), current->non_block_count, current->pid, current->comm); if (task_stack_end_corrupted(current)) -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: [PATCH] kernel.h: Add non_block_start/end() Date: Tue, 21 May 2019 16:47:43 +0200 Message-ID: <20190521144743.6895-1-daniel.vetter@ffwll.ch> References: <20190520213945.17046-2-daniel.vetter@ffwll.ch> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190520213945.17046-2-daniel.vetter@ffwll.ch> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: DRI Development Cc: Feng Tang , Michal Hocko , Kees Cook , Masahiro Yamada , Peter Zijlstra , Daniel Vetter , Intel Graphics Development , Jann Horn , LKML , Linux MM , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Ingo Molnar , Thomas Gleixner , Randy Dunlap , David Rientjes , Wei Wang , Daniel Vetter , Andrew Morton , Andy Shevchenko , =?UTF-8?q?Christian=20K=C3=B6nig?= List-Id: dri-devel@lists.freedesktop.org SW4gc29tZSBzcGVjaWFsIGNhc2VzIHdlIG11c3Qgbm90IGJsb2NrLCBidXQgdGhlcmUncyBub3Qg YQpzcGlubG9jaywgcHJlZW1wdC1vZmYsIGlycXMtb2ZmIG9yIHNpbWlsYXIgY3JpdGljYWwgc2Vj dGlvbiBhbHJlYWR5CnRoYXQgYXJtcyB0aGUgbWlnaHRfc2xlZXAoKSBkZWJ1ZyBjaGVja3MuIEFk ZCBhIG5vbl9ibG9ja19zdGFydC9lbmQoKQpwYWlyIHRvIGFubm90YXRlIHRoZXNlLgoKVGhpcyB3 aWxsIGJlIHVzZWQgaW4gdGhlIG9vbSBwYXRocyBvZiBtbXUtbm90aWZpZXJzLCB3aGVyZSBibG9j a2luZyBpcwpub3QgYWxsb3dlZCB0byBtYWtlIHN1cmUgdGhlcmUncyBmb3J3YXJkIHByb2dyZXNz LiBRdW90aW5nIE1pY2hhbDoKCiJUaGUgbm90aWZpZXIgaXMgY2FsbGVkIGZyb20gcXVpdGUgYSBy ZXN0cmljdGVkIGNvbnRleHQgLSBvb21fcmVhcGVyIC0Kd2hpY2ggc2hvdWxkbid0IGRlcGVuZCBv biBhbnkgbG9ja3Mgb3Igc2xlZXBhYmxlIGNvbmRpdGlvbmFscy4gVGhlIGNvZGUKc2hvdWxkIGJl IHN3aWZ0IGFzIHdlbGwgYnV0IHdlIG1vc3RseSBkbyBjYXJlIGFib3V0IGl0IHRvIG1ha2UgYSBm b3J3YXJkCnByb2dyZXNzLiBDaGVja2luZyBmb3Igc2xlZXBhYmxlIGNvbnRleHQgaXMgdGhlIGJl c3QgdGhpbmcgd2UgY291bGQgY29tZQp1cCB3aXRoIHRoYXQgd291bGQgZGVzY3JpYmUgdGhlc2Ug ZGVtYW5kcyBhdCBsZWFzdCBwYXJ0aWFsbHkuIgoKUGV0ZXIgYWxzbyBhc2tlZCB3aGV0aGVyIHdl IHdhbnQgdG8gY2F0Y2ggc3BpbmxvY2tzIG9uIHRvcCwgYnV0IE1pY2hhbApzYWlkIHRob3NlIGFy ZSBsZXNzIG9mIGEgcHJvYmxlbSBiZWNhdXNlIHNwaW5sb2NrcyBjYW4ndCBoYXZlIGFuCmluZGly ZWN0IGRlcGVuZGVuY3kgdXBvbiB0aGUgcGFnZSBhbGxvY2F0b3IgYW5kIGhlbmNlIGNsb3NlIHRo ZSBsb29wCndpdGggdGhlIG9vbSByZWFwZXIuCgpTdWdnZXN0ZWQgYnkgTWljaGFsIEhvY2tvLgoK djI6Ci0gSW1wcm92ZSBjb21taXQgbWVzc2FnZSAoTWljaGFsKQotIEFsc28gY2hlY2sgaW4gc2No ZWR1bGUsIG5vdCBqdXN0IG1pZ2h0X3NsZWVwIChQZXRlcikKCnYzOiBJdCB3b3JrcyBiZXR0ZXIg d2hlbiBJIGFjdHVhbGx5IHNxdWFzaCBpbiB0aGUgZml4dXAgSSBoYWQgbHlpbmcKYXJvdW5kIDot LwoKQ2M6IFBldGVyIFppamxzdHJhIDxwZXRlcnpAaW5mcmFkZWFkLm9yZz4KQ2M6IEluZ28gTW9s bmFyIDxtaW5nb0ByZWRoYXQuY29tPgpDYzogQW5kcmV3IE1vcnRvbiA8YWtwbUBsaW51eC1mb3Vu ZGF0aW9uLm9yZz4KQ2M6IE1pY2hhbCBIb2NrbyA8bWhvY2tvQHN1c2UuY29tPgpDYzogRGF2aWQg UmllbnRqZXMgPHJpZW50amVzQGdvb2dsZS5jb20+CkNjOiAiQ2hyaXN0aWFuIEvDtm5pZyIgPGNo cmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJA ZmZ3bGwuY2g+CkNjOiAiSsOpcsO0bWUgR2xpc3NlIiA8amdsaXNzZUByZWRoYXQuY29tPgpDYzog bGludXgtbW1Aa3ZhY2sub3JnCkNjOiBNYXNhaGlybyBZYW1hZGEgPHlhbWFkYS5tYXNhaGlyb0Bz b2Npb25leHQuY29tPgpDYzogV2VpIFdhbmcgPHd2d0Bnb29nbGUuY29tPgpDYzogQW5keSBTaGV2 Y2hlbmtvIDxhbmRyaXkuc2hldmNoZW5rb0BsaW51eC5pbnRlbC5jb20+CkNjOiBUaG9tYXMgR2xl aXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KQ2M6IEphbm4gSG9ybiA8amFubmhAZ29vZ2xlLmNv bT4KQ2M6IEZlbmcgVGFuZyA8ZmVuZy50YW5nQGludGVsLmNvbT4KQ2M6IEtlZXMgQ29vayA8a2Vl c2Nvb2tAY2hyb21pdW0ub3JnPgpDYzogUmFuZHkgRHVubGFwIDxyZHVubGFwQGluZnJhZGVhZC5v cmc+CkNjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCkFja2VkLWJ5OiBDaHJpc3RpYW4g S8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+ICh2MSkKU2lnbmVkLW9mZi1ieTogRGFu aWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBpbnRlbC5jb20+Ci0tLQogaW5jbHVkZS9saW51eC9r ZXJuZWwuaCB8IDEwICsrKysrKysrKy0KIGluY2x1ZGUvbGludXgvc2NoZWQuaCAgfCAgNCArKysr CiBrZXJuZWwvc2NoZWQvY29yZS5jICAgIHwgMTkgKysrKysrKysrKysrKystLS0tLQogMyBmaWxl cyBjaGFuZ2VkLCAyNyBpbnNlcnRpb25zKCspLCA2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L2luY2x1ZGUvbGludXgva2VybmVsLmggYi9pbmNsdWRlL2xpbnV4L2tlcm5lbC5oCmluZGV4IDc0 YjFlZTkwMjdmNS4uYjVmMmMyZmYwZWFiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2tlcm5l bC5oCisrKyBiL2luY2x1ZGUvbGludXgva2VybmVsLmgKQEAgLTIxNCw3ICsyMTQsOSBAQCBleHRl cm4gdm9pZCBfX2NhbnRfc2xlZXAoY29uc3QgY2hhciAqZmlsZSwgaW50IGxpbmUsIGludCBwcmVl bXB0X29mZnNldCk7CiAgKiBtaWdodF9zbGVlcCAtIGFubm90YXRpb24gZm9yIGZ1bmN0aW9ucyB0 aGF0IGNhbiBzbGVlcAogICoKICAqIHRoaXMgbWFjcm8gd2lsbCBwcmludCBhIHN0YWNrIHRyYWNl IGlmIGl0IGlzIGV4ZWN1dGVkIGluIGFuIGF0b21pYwotICogY29udGV4dCAoc3BpbmxvY2ssIGly cS1oYW5kbGVyLCAuLi4pLgorICogY29udGV4dCAoc3BpbmxvY2ssIGlycS1oYW5kbGVyLCAuLi4p LiBBZGRpdGlvbmFsIHNlY3Rpb25zIHdoZXJlIGJsb2NraW5nIGlzCisgKiBub3QgYWxsb3dlZCBj YW4gYmUgYW5ub3RhdGVkIHdpdGggbm9uX2Jsb2NrX3N0YXJ0KCkgYW5kIG5vbl9ibG9ja19lbmQo KQorICogcGFpcnMuCiAgKgogICogVGhpcyBpcyBhIHVzZWZ1bCBkZWJ1Z2dpbmcgaGVscCB0byBi ZSBhYmxlIHRvIGNhdGNoIHByb2JsZW1zIGVhcmx5IGFuZCBub3QKICAqIGJlIGJpdHRlbiBsYXRl ciB3aGVuIHRoZSBjYWxsaW5nIGZ1bmN0aW9uIGhhcHBlbnMgdG8gc2xlZXAgd2hlbiBpdCBpcyBu b3QKQEAgLTIzMCw2ICsyMzIsMTAgQEAgZXh0ZXJuIHZvaWQgX19jYW50X3NsZWVwKGNvbnN0IGNo YXIgKmZpbGUsIGludCBsaW5lLCBpbnQgcHJlZW1wdF9vZmZzZXQpOwogIyBkZWZpbmUgY2FudF9z bGVlcCgpIFwKIAlkbyB7IF9fY2FudF9zbGVlcChfX0ZJTEVfXywgX19MSU5FX18sIDApOyB9IHdo aWxlICgwKQogIyBkZWZpbmUgc2NoZWRfYW5ub3RhdGVfc2xlZXAoKQkoY3VycmVudC0+dGFza19z dGF0ZV9jaGFuZ2UgPSAwKQorIyBkZWZpbmUgbm9uX2Jsb2NrX3N0YXJ0KCkgXAorCWRvIHsgY3Vy cmVudC0+bm9uX2Jsb2NrX2NvdW50Kys7IH0gd2hpbGUgKDApCisjIGRlZmluZSBub25fYmxvY2tf ZW5kKCkgXAorCWRvIHsgV0FSTl9PTihjdXJyZW50LT5ub25fYmxvY2tfY291bnQtLSA9PSAwKTsg fSB3aGlsZSAoMCkKICNlbHNlCiAgIHN0YXRpYyBpbmxpbmUgdm9pZCBfX19taWdodF9zbGVlcChj b25zdCBjaGFyICpmaWxlLCBpbnQgbGluZSwKIAkJCQkgICBpbnQgcHJlZW1wdF9vZmZzZXQpIHsg fQpAQCAtMjM4LDYgKzI0NCw4IEBAIGV4dGVybiB2b2lkIF9fY2FudF9zbGVlcChjb25zdCBjaGFy ICpmaWxlLCBpbnQgbGluZSwgaW50IHByZWVtcHRfb2Zmc2V0KTsKICMgZGVmaW5lIG1pZ2h0X3Ns ZWVwKCkgZG8geyBtaWdodF9yZXNjaGVkKCk7IH0gd2hpbGUgKDApCiAjIGRlZmluZSBjYW50X3Ns ZWVwKCkgZG8geyB9IHdoaWxlICgwKQogIyBkZWZpbmUgc2NoZWRfYW5ub3RhdGVfc2xlZXAoKSBk byB7IH0gd2hpbGUgKDApCisjIGRlZmluZSBub25fYmxvY2tfc3RhcnQoKSBkbyB7IH0gd2hpbGUg KDApCisjIGRlZmluZSBub25fYmxvY2tfZW5kKCkgZG8geyB9IHdoaWxlICgwKQogI2VuZGlmCiAK ICNkZWZpbmUgbWlnaHRfc2xlZXBfaWYoY29uZCkgZG8geyBpZiAoY29uZCkgbWlnaHRfc2xlZXAo KTsgfSB3aGlsZSAoMCkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc2NoZWQuaCBiL2luY2x1 ZGUvbGludXgvc2NoZWQuaAppbmRleCAxMTgzNzQxMDY5MGYuLjdmNWIyOTNlNzJkZiAxMDA2NDQK LS0tIGEvaW5jbHVkZS9saW51eC9zY2hlZC5oCisrKyBiL2luY2x1ZGUvbGludXgvc2NoZWQuaApA QCAtOTA4LDYgKzkwOCwxMCBAQCBzdHJ1Y3QgdGFza19zdHJ1Y3QgewogCXN0cnVjdCBtdXRleF93 YWl0ZXIJCSpibG9ja2VkX29uOwogI2VuZGlmCiAKKyNpZmRlZiBDT05GSUdfREVCVUdfQVRPTUlD X1NMRUVQCisJaW50CQkJCW5vbl9ibG9ja19jb3VudDsKKyNlbmRpZgorCiAjaWZkZWYgQ09ORklH X1RSQUNFX0lSUUZMQUdTCiAJdW5zaWduZWQgaW50CQkJaXJxX2V2ZW50czsKIAl1bnNpZ25lZCBs b25nCQkJaGFyZGlycV9lbmFibGVfaXA7CmRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWQvY29yZS5j IGIva2VybmVsL3NjaGVkL2NvcmUuYwppbmRleCAxMDJkZmNmMGEyOWEuLmVkNzc1NWEyODQ2NSAx MDA2NDQKLS0tIGEva2VybmVsL3NjaGVkL2NvcmUuYworKysgYi9rZXJuZWwvc2NoZWQvY29yZS5j CkBAIC0zMjY0LDEzICszMjY0LDIyIEBAIHN0YXRpYyBub2lubGluZSB2b2lkIF9fc2NoZWR1bGVf YnVnKHN0cnVjdCB0YXNrX3N0cnVjdCAqcHJldikKIC8qCiAgKiBWYXJpb3VzIHNjaGVkdWxlKCkt dGltZSBkZWJ1Z2dpbmcgY2hlY2tzIGFuZCBzdGF0aXN0aWNzOgogICovCi1zdGF0aWMgaW5saW5l IHZvaWQgc2NoZWR1bGVfZGVidWcoc3RydWN0IHRhc2tfc3RydWN0ICpwcmV2KQorc3RhdGljIGlu bGluZSB2b2lkIHNjaGVkdWxlX2RlYnVnKHN0cnVjdCB0YXNrX3N0cnVjdCAqcHJldiwgYm9vbCBw cmVlbXB0KQogewogI2lmZGVmIENPTkZJR19TQ0hFRF9TVEFDS19FTkRfQ0hFQ0sKIAlpZiAodGFz a19zdGFja19lbmRfY29ycnVwdGVkKHByZXYpKQogCQlwYW5pYygiY29ycnVwdGVkIHN0YWNrIGVu ZCBkZXRlY3RlZCBpbnNpZGUgc2NoZWR1bGVyXG4iKTsKICNlbmRpZgogCisjaWZkZWYgQ09ORklH X0RFQlVHX0FUT01JQ19TTEVFUAorCWlmICghcHJlZW1wdCAmJiBwcmV2LT5zdGF0ZSAmJiBwcmV2 LT5ub25fYmxvY2tfY291bnQpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJCVUc6IHNjaGVkdWxpbmcg aW4gYSBub24tYmxvY2tpbmcgc2VjdGlvbjogJXMvJWQvJWlcbiIsCisJCQlwcmV2LT5jb21tLCBw cmV2LT5waWQsIHByZXYtPm5vbl9ibG9ja19jb3VudCk7CisJCWR1bXBfc3RhY2soKTsKKwkJYWRk X3RhaW50KFRBSU5UX1dBUk4sIExPQ0tERVBfU1RJTExfT0spOworCX0KKyNlbmRpZgorCiAJaWYg KHVubGlrZWx5KGluX2F0b21pY19wcmVlbXB0X29mZigpKSkgewogCQlfX3NjaGVkdWxlX2J1Zyhw cmV2KTsKIAkJcHJlZW1wdF9jb3VudF9zZXQoUFJFRU1QVF9ESVNBQkxFRCk7CkBAIC0zMzc3LDcg KzMzODYsNyBAQCBzdGF0aWMgdm9pZCBfX3NjaGVkIG5vdHJhY2UgX19zY2hlZHVsZShib29sIHBy ZWVtcHQpCiAJcnEgPSBjcHVfcnEoY3B1KTsKIAlwcmV2ID0gcnEtPmN1cnI7CiAKLQlzY2hlZHVs ZV9kZWJ1ZyhwcmV2KTsKKwlzY2hlZHVsZV9kZWJ1ZyhwcmV2LCBwcmVlbXB0KTsKIAogCWlmIChz Y2hlZF9mZWF0KEhSVElDSykpCiAJCWhydGlja19jbGVhcihycSk7CkBAIC02MTAyLDcgKzYxMTEs NyBAQCB2b2lkIF9fX21pZ2h0X3NsZWVwKGNvbnN0IGNoYXIgKmZpbGUsIGludCBsaW5lLCBpbnQg cHJlZW1wdF9vZmZzZXQpCiAJcmN1X3NsZWVwX2NoZWNrKCk7CiAKIAlpZiAoKHByZWVtcHRfY291 bnRfZXF1YWxzKHByZWVtcHRfb2Zmc2V0KSAmJiAhaXJxc19kaXNhYmxlZCgpICYmCi0JICAgICAh aXNfaWRsZV90YXNrKGN1cnJlbnQpKSB8fAorCSAgICAgIWlzX2lkbGVfdGFzayhjdXJyZW50KSAm JiAhY3VycmVudC0+bm9uX2Jsb2NrX2NvdW50KSB8fAogCSAgICBzeXN0ZW1fc3RhdGUgPT0gU1lT VEVNX0JPT1RJTkcgfHwgc3lzdGVtX3N0YXRlID4gU1lTVEVNX1JVTk5JTkcgfHwKIAkgICAgb29w c19pbl9wcm9ncmVzcykKIAkJcmV0dXJuOwpAQCAtNjExOCw4ICs2MTI3LDggQEAgdm9pZCBfX19t aWdodF9zbGVlcChjb25zdCBjaGFyICpmaWxlLCBpbnQgbGluZSwgaW50IHByZWVtcHRfb2Zmc2V0 KQogCQkiQlVHOiBzbGVlcGluZyBmdW5jdGlvbiBjYWxsZWQgZnJvbSBpbnZhbGlkIGNvbnRleHQg YXQgJXM6JWRcbiIsCiAJCQlmaWxlLCBsaW5lKTsKIAlwcmludGsoS0VSTl9FUlIKLQkJImluX2F0 b21pYygpOiAlZCwgaXJxc19kaXNhYmxlZCgpOiAlZCwgcGlkOiAlZCwgbmFtZTogJXNcbiIsCi0J CQlpbl9hdG9taWMoKSwgaXJxc19kaXNhYmxlZCgpLAorCQkiaW5fYXRvbWljKCk6ICVkLCBpcnFz X2Rpc2FibGVkKCk6ICVkLCBub25fYmxvY2s6ICVkLCBwaWQ6ICVkLCBuYW1lOiAlc1xuIiwKKwkJ CWluX2F0b21pYygpLCBpcnFzX2Rpc2FibGVkKCksIGN1cnJlbnQtPm5vbl9ibG9ja19jb3VudCwK IAkJCWN1cnJlbnQtPnBpZCwgY3VycmVudC0+Y29tbSk7CiAKIAlpZiAodGFza19zdGFja19lbmRf Y29ycnVwdGVkKGN1cnJlbnQpKQotLSAKMi4yMC4xCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9pbnRlbC1nZng=