From patchwork Fri Mar 10 23:43:33 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: andrey.konovalov@linux.dev X-Patchwork-Id: 13170464 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id B3825C74A5B for ; Fri, 10 Mar 2023 23:43:46 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 4D79D6B0080; Fri, 10 Mar 2023 18:43:44 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 41CD76B0082; Fri, 10 Mar 2023 18:43:44 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 1CA8D6B0083; Fri, 10 Mar 2023 18:43:44 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id E40BA6B0080 for ; Fri, 10 Mar 2023 18:43:43 -0500 (EST) Received: from smtpin30.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id BC3221204DF for ; Fri, 10 Mar 2023 23:43:43 +0000 (UTC) X-FDA: 80554618326.30.CFB916E Received: from out-41.mta1.migadu.com (out-41.mta1.migadu.com [95.215.58.41]) by imf03.hostedemail.com (Postfix) with ESMTP id 1188820004 for ; Fri, 10 Mar 2023 23:43:41 +0000 (UTC) Authentication-Results: imf03.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=qTe147Js; dmarc=pass (policy=none) header.from=linux.dev; spf=pass (imf03.hostedemail.com: domain of andrey.konovalov@linux.dev designates 95.215.58.41 as permitted sender) smtp.mailfrom=andrey.konovalov@linux.dev ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1678491822; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=SSBGLO0ZKcc5jSLq3xLNP5yCcA0qlKOn3pEju7Cd7ZE=; b=Pf7+rApRHEO2V7PzgDxF6Nfi6vIyrZhmH0F/X1rPTD1PHSNZnMjGOwLCMskb90V5l9NbiV vdNKV9aAAG8+yHq5dUumn20I5mHEWscUaVXgulbVIWVWuFmTnL33I6sCen1tXE0/I4b9AB rUWeB4c85mZIT3M1fTeNFQ7TFNbP7pA= ARC-Authentication-Results: i=1; imf03.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=qTe147Js; dmarc=pass (policy=none) header.from=linux.dev; spf=pass (imf03.hostedemail.com: domain of andrey.konovalov@linux.dev designates 95.215.58.41 as permitted sender) smtp.mailfrom=andrey.konovalov@linux.dev ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1678491822; a=rsa-sha256; cv=none; b=PgJesF1QS7wVOrSiHEgr4+WuoA3T0gmJT63dcODvHqfpxC7J/Ev/6uaQv6zsCqIHMsE3pE WyXjrcWbTeBrTTKfLIq8TYsa5k+Rzt9+dXO+hL6hJYP7T33fhPMValReDGnRZam+m8vRtV fDu4fEpqYayJ69fJZzm3RDDpB/NUrLQ= X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1678491820; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=SSBGLO0ZKcc5jSLq3xLNP5yCcA0qlKOn3pEju7Cd7ZE=; b=qTe147JsgTpvXQaz1MuzU6p4Le749GRL4+l6KHdDbxbjugDg757OBizgyv1xrZAf+akgys RT3+ihmsWdEcXCAxS5P4ef6oW0T5jdXhD7ui2fhRdioeaK9Oq8mjlqZo1/ClrUvMp+81Ke O1zfZHyyRBdAWHtNAfEhKB9LtxT8WoM= From: andrey.konovalov@linux.dev To: Marco Elver , Catalin Marinas Cc: Andrey Konovalov , Alexander Potapenko , Dmitry Vyukov , Andrey Ryabinin , kasan-dev@googlegroups.com, Vincenzo Frascino , Will Deacon , linux-arm-kernel@lists.infradead.org, Peter Collingbourne , Evgenii Stepanov , Andrew Morton , linux-mm@kvack.org, Weizhao Ouyang , linux-kernel@vger.kernel.org, Andrey Konovalov Subject: [PATCH 5/5] kasan: suppress recursive reports for HW_TAGS Date: Sat, 11 Mar 2023 00:43:33 +0100 Message-Id: <59f433e00f7fa985e8bf9f7caf78574db16b67ab.1678491668.git.andreyknvl@google.com> In-Reply-To: References: MIME-Version: 1.0 X-Migadu-Flow: FLOW_OUT X-Rspam-User: X-Rspamd-Server: rspam02 X-Rspamd-Queue-Id: 1188820004 X-Stat-Signature: jaxiojsx19hxez145mbsyfrifc45uqhc X-HE-Tag: 1678491821-197805 X-HE-Meta: U2FsdGVkX18a+Z/0uuBBlynyz/LqTTLdaUxFTdesELihOQdrppjY8uoslhc45Lb0P+pdr2MqbSmWW1au/nyL7r9O5gD4MRhfoY9bmfB8fKFUbyNHi45L6L2pHrqNLhKAEyaKdsgc87RbAx0oAS2AwZ3IBb2gIVYPbXi4ExKUmw/BYkleJZrEt9UuTVo/uAnVYKzjQF8DVzr5oHhCEQ3T4nIu/pSAK1qE0J8WHKXKKMX8FL04E9mxZCsbZwCuApMru4NYW/olhERUAOcaCvG5LGDNr9iLXC4mh/Sl//jx0W6SLE5l0Igm2Q+0rB/5cDkECpldZY8Ctro+Xs98D5OHlqNvjHWtSOWiBsYd402pQpVBvT9CIE6KWQ29LxLqhj/uWF5gcKwPhO77Fr/Gf3IrSSlNrbpZqWhgqmGPwHaGatQphZwulgaptmf+863Uup6zzTvZKat7hKcXL/JYVgAy8PEhgcYInuEqIIf3rK1XSyUFi+XvalBr65Bcw84akfAWrp0xPPyc4rkRY/tGn8r9y/1STXaqAVY0SukBa4YSHtOJYC3e0ojsztJAQ75evWILYv5yW6ogOnHY9hBe6U4CEeWXivlDKMYboDKH/BnH3Dy7sgdFSyW/e+MOzMMYUCsJP3quJprGjfyAgCu90NnwrSGKZTA2u0qG0uQH0Neo6CiS5W3NilhaedG1dbv9/+heFjRFvLcl8dFvyFYwT1U7HmLxNOfffljQh3QWSUu/clRfK7uwXo+flcF35gKYr2dqr4qgD5CuyPAULOAb4OON1eNvGC8ZKv5OpaBt87nLpjSQbd1QHLQkVkESJOTqMGPoFDM89MVaM1mA0MZTzbiJV/8l7EaD3HBlRH9HqzBYOkMapbScyxpdThwc7M4pSCPHGfbfNJtkVKyF6B3HCkDWP5xvWPq1jhKpSMeolXAdWFhRdITT6BMevAsnTYKUKpE4lyKscfqp7GRFh1cCqsx SjMbTBsv d/vwjuIPWViqmmzPxGYWtozbLHfRdUbl9w1zxVFWjr7GTaAmHD5/3zoq5C46fqW+f9+KhPckwUWLCFF6CaQAKqYdqCgJlKPHipDCXiT65sJ6NrvhnnzZ2BbAUtfzK/QjU1Q/6NnMGmKmGAmrHPxG4IPVYP9moOfnOWUHEoZRjahPATfiIgNszYh+I2UUDwuE1mRIO8Jtl3IFSZnQhTVRGHojpwjEj0iSkUMQEOC8E/mx8n/O6+7Q6WjB/34/gP9EwuawktqGMYfG70m3Pdj9iApUaaAA7veS4OZKwPeLEAPjIgok= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: From: Andrey Konovalov KASAN suppresses reports for bad accesses done by the KASAN reporting code. The reporting code might access poisoned memory for reporting purposes. Software KASAN modes do this by suppressing reports during reporting via current->kasan_depth, the same way they suppress reports during accesses to poisoned slab metadata. Hardware Tag-Based KASAN does not use current->kasan_depth, and instead resets pointer tags for accesses to poisoned memory done by the reporting code. Despite that, a recursive report can still happen: 1. On hardware with faulty MTE support. This was observed by Weizhao Ouyang on a faulty hardware that caused memory tags to randomly change from time to time. 2. Theoretically, due to a previous MTE-undetected memory corruption. A recursive report can happen via: 1. Accessing a pointer with a non-reset tag in the reporting code, e.g. slab->slab_cache, which is what Weizhao Ouyang observed. 2. Theoretically, via external non-annotated routines, e.g. stackdepot. To resolve this issue, resetting tags for all of the pointers in the reporting code and all the used external routines would be impractical. Instead, disable tag checking done by the CPU for the duration of KASAN reporting for Hardware Tag-Based KASAN. Without this fix, Hardware Tag-Based KASAN reporting code might deadlock. Fixes: 2e903b914797 ("kasan, arm64: implement HW_TAGS runtime") Reported-by: Weizhao Ouyang Signed-off-by: Andrey Konovalov --- Considering that 1. the bug this patch fixes was only observed on faulty MTE hardware, and 2. the patch depends on the other patches in this series, I don't think it's worth backporting it into stable. --- mm/kasan/report.c | 59 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 48 insertions(+), 11 deletions(-) diff --git a/mm/kasan/report.c b/mm/kasan/report.c index 89078f912827..77a88d85c0a7 100644 --- a/mm/kasan/report.c +++ b/mm/kasan/report.c @@ -72,10 +72,18 @@ static int __init kasan_set_multi_shot(char *str) __setup("kasan_multi_shot", kasan_set_multi_shot); /* - * Used to suppress reports within kasan_disable/enable_current() critical - * sections, which are used for marking accesses to slab metadata. + * This function is used to check whether KASAN reports are suppressed for + * software KASAN modes via kasan_disable/enable_current() critical sections. + * + * This is done to avoid: + * 1. False-positive reports when accessing slab metadata, + * 2. Deadlocking when poisoned memory is accessed by the reporting code. + * + * Hardware Tag-Based KASAN instead relies on: + * For #1: Resetting tags via kasan_reset_tag(). + * For #2: Supression of tag checks via CPU, see report_suppress_start/end(). */ -static bool report_suppressed(void) +static bool report_suppressed_sw(void) { #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS) if (current->kasan_depth) @@ -84,6 +92,30 @@ static bool report_suppressed(void) return false; } +static void report_suppress_start(void) +{ +#ifdef CONFIG_KASAN_HW_TAGS + /* + * Disable migration for the duration of printing a KASAN report, as + * hw_suppress_tag_checks_start() disables checks on the current CPU. + */ + migrate_disable(); + hw_suppress_tag_checks_start(); +#else + kasan_disable_current(); +#endif +} + +static void report_suppress_stop(void) +{ +#ifdef CONFIG_KASAN_HW_TAGS + hw_suppress_tag_checks_stop(); + migrate_enable(); +#else + kasan_enable_current(); +#endif +} + /* * Used to avoid reporting more than one KASAN bug unless kasan_multi_shot * is enabled. Note that KASAN tests effectively enable kasan_multi_shot @@ -174,7 +206,7 @@ static void start_report(unsigned long *flags, bool sync) /* Do not allow LOCKDEP mangling KASAN reports. */ lockdep_off(); /* Make sure we don't end up in loop. */ - kasan_disable_current(); + report_suppress_start(); spin_lock_irqsave(&report_lock, *flags); pr_err("==================================================================\n"); } @@ -192,7 +224,7 @@ static void end_report(unsigned long *flags, void *addr) panic("kasan.fault=panic set ...\n"); add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE); lockdep_on(); - kasan_enable_current(); + report_suppress_stop(); } static void print_error_description(struct kasan_report_info *info) @@ -480,9 +512,13 @@ void kasan_report_invalid_free(void *ptr, unsigned long ip, enum kasan_report_ty struct kasan_report_info info; /* - * Do not check report_suppressed(), as an invalid-free cannot be - * caused by accessing slab metadata and thus should not be - * suppressed by kasan_disable/enable_current() critical sections. + * Do not check report_suppressed_sw(), as an invalid-free cannot be + * caused by accessing poisoned memory and thus should not be suppressed + * by kasan_disable/enable_current() critical sections. + * + * Note that for Hardware Tag-Based KASAN, kasan_report_invalid_free() + * is triggered by explicit tag checks and not by the ones performed by + * the CPU. Thus, reporting invalid-free is not suppressed as well. */ if (unlikely(!report_enabled())) return; @@ -517,7 +553,7 @@ bool kasan_report(unsigned long addr, size_t size, bool is_write, unsigned long irq_flags; struct kasan_report_info info; - if (unlikely(report_suppressed()) || unlikely(!report_enabled())) { + if (unlikely(report_suppressed_sw()) || unlikely(!report_enabled())) { ret = false; goto out; } @@ -549,8 +585,9 @@ void kasan_report_async(void) unsigned long flags; /* - * Do not check report_suppressed(), as kasan_disable/enable_current() - * critical sections do not affect Hardware Tag-Based KASAN. + * Do not check report_suppressed_sw(), as + * kasan_disable/enable_current() critical sections do not affect + * Hardware Tag-Based KASAN. */ if (unlikely(!report_enabled())) return;