From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-wm1-f41.google.com (mail-wm1-f41.google.com [209.85.128.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 527963B14B5 for ; Tue, 11 Aug 2026 15:41:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.41 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786462890; cv=none; b=GTFOMh0vhjle90QtXJQMBC04ETAQuV9SZDXj2bHPSCbC8ppyavFyGZ+cTgO29B1usRNjxP4xcxlSSrMoZvJrDlEIRXXt+186W8dFBK0O8qmOyTzS65J8+GBQb1OISeW26oA1WLXj2ETF9Gsh4VNNMwtwx2T+K0l6A458eq+3LKk= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786462890; c=relaxed/simple; bh=U/CuYnW3nKlm0Ag5nbrLZwr7GqhHDz5KB3HhWHjv9Ds=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=MdB/CK/E8ZrJRpcT68xQHP2AHAg6a+6HnRTnA/s0AOM7lW/kvUYzQaPKRu2NIQ8y+4k2Gc64FuJY2KjTXaoKeCvspZZ2OTd85s+bEfXFq9cdtkb2CclYBefDjFv6j2KZ1VTTcMMDvHTSpS0w3vzUm6ivjaFlWql54dFsCugn/cE= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Vm8NEm1C; arc=none smtp.client-ip=209.85.128.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Vm8NEm1C" Received: by mail-wm1-f41.google.com with SMTP id 5b1f17b1804b1-4996f1ee4a4so18798685e9.2 for ; Tue, 11 Aug 2026 08:41:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1786462884; x=1787067684; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=TYbzUo5s72w0MgSb7UEpNxz2BTiCO8snbdn2LAQeGn8=; b=Vm8NEm1COG5PKNJg+XqqKm/jfq4oh2lEJmAcEJsO862ULQBxCoIQiJ0snHn9fl7aGu 1T1ns0jPwJsxk2Wyk2aqXJtYGZb7yNE8MuhSf3yWwB2HzCl241ovrSEh2SXSeNyuFEso 4TOXQnKSC5jDNo3Y1h0eDjVJuj/5veeJxHtYX0bIHVHBjV3eUoXFk2fL/VQWO2uUetKW yA4mNIyXjtEv+so41iZbvSGuFq5JXh7qy/tyGH/U7k1FpJo0Mc0UyfUc5WfCg2vJJBHj RfxQQu5NqdvFSWAlYYfAHdI2N8AOy9cbDihwNoCQdA/mFPMc+4pyReroxvhUVuabSuOD unhg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786462884; x=1787067684; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=TYbzUo5s72w0MgSb7UEpNxz2BTiCO8snbdn2LAQeGn8=; b=fbWs/5OoeIECilzxB1Q3Or1ZKvxpjd46HlRrKkcHRsOmes1mWkK5VRpSeSysJOR8gP YqKdVVwBG54jHeHw9k5rMpi0mKPM/NBXwwKi7e/Pns7Uc8XRouREV3TXuywUTJw3KV7L tFc5uh2zKVmxTJqLG8NnMrbWxkFaaxvnXZ5KfLDhPlnDPTpbc8JlgqWaZ9QguDXx02dz +f6kj4PdlTjB07Na+1CcZ01AxB/Ity4kXPLSmhKTFsfV+GOdgQ6wqwHi+sH/h7MsNapG 3IpJ7TqiS7Ani5+rZ2b7uDiRfaZtTYClKtJpSaii4aWSCjMwtEOUNt8KxUproPjSz9mt x2qA== X-Forwarded-Encrypted: i=1; AHgh+RrvhmF9tcNUy272VBdHUi8ybsrdHvGBAd3YQ61770U31tg+PftDLi0EEgM4tfiPhkGjCIifr86jT8hJ+I8=@vger.kernel.org X-Gm-Message-State: AOJu0YwiELwSu0e05AC9X7XoibQnFeLycDfXECPGXBNVxp5Emoh29743 TyHyssQZEpV7bRQLqyzAi06Q1rEHWn7FieUG3lPLI/LiRJiu+GNA+t0S X-Gm-Gg: AR+sD12zSIi0VM0YvdQA2NKTrWcOT1/4pznwHYlfYEJ/A2Z/mt9t3sEx/iw10OB+4Ae A/9XF/gev80L21PDasQoZmbnQ9dTT0lB3mKGqA/oluO5P/JqLTFvmDy/dwQMiMXD28AP+dm6ChN WZLPk/x5Ujl8jSn0TJajlpye9+zbSTmtHMoTtDOCoznKK9MFGgyqLxIzknCCUTHM7KBwatXeJ75 W6LUwe3C1Y22UaXyE0Q6GpcTY6E+JyIPEBL6V1tuLrpyLxN+qIKbKZ9eCsQDzvgrt6owplZgm0B 5ctwtbq6HT0Vaeh5x3B5cAHnuLFdYvIngnuIFzlhKsC6K7xVFBcp1bW061n00EeLKbdEIPqbnQW hFsrU9X6+CMn9lRFDYhEXTszRxgh5VHlPdt760Qszimt85ck4QChTwtPEPyn8bJatsKhV+clFQe WVZXDbNMl1hXo+buAyvUIxIAZgmbbmNcMO0dMCHkWCxG73V3JbH0am8TXXfjVex5p3zGxMYEAQh 2gPHv5efXLyP6eD3cU4uMalKo0d0hZ+163YQbl+dEaFUtz/2CdrC5O0SEKv6dClQDqTlYA272lo 8CVelglC1874tnOfZqyFMq8f4HAxAByhLA1FQNqjbR32+pjNPOWz3iifcTI7jYeBTIhv X-Received: by 2002:a05:600c:4fd5:b0:496:c18c:f9a3 with SMTP id 5b1f17b1804b1-4997840ab65mr67073835e9.5.1786462884404; Tue, 11 Aug 2026 08:41:24 -0700 (PDT) Received: from localhost.localdomain (dynamic-2a02-3100-a133-e401-bc8e-d36c-2d08-c5e0.310.pool.telefonica.de. [2a02:3100:a133:e401:bc8e:d36c:2d08:c5e0]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-4997aaa7aabsm1670275e9.7.2026.08.11.08.41.22 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Tue, 11 Aug 2026 08:41:23 -0700 (PDT) From: Karl Mehltretter To: Andrew Morton Cc: Karl Mehltretter , Andrey Konovalov , Alexander Potapenko , Dmitry Vyukov , Marco Elver , Bradley Morgan , Anna-Maria Behnsen , Frederic Weisbecker , Thomas Gleixner , Ingo Molnar , Peter Zijlstra , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Valentin Schneider , K Prateek Nayak , Sebastian Andrzej Siewior , Clark Williams , linux-rt-devel@lists.linux.dev, kasan-dev@googlegroups.com, linux-kernel@vger.kernel.org Subject: [PATCH v2 2/6] kcov: Add a kcov_pause guard Date: Tue, 11 Aug 2026 17:41:07 +0200 Message-Id: <20260811154111.64669-3-kmehltretter@gmail.com> X-Mailer: git-send-email 2.39.5 (Apple Git-154) In-Reply-To: <20260811154111.64669-1-kmehltretter@gmail.com> References: <20260811154111.64669-1-kmehltretter@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Interrupt-return work can run after HARDIRQ_OFFSET is dropped, when in_task() is true. KCOV then attributes instrumented callees to the interrupted task. Add a KCOV_PAUSED bit next to KCOV_IN_CTXSW and mask both in kcov_mode_enabled(). The coverage callbacks need no new check because check_kcov_mode()'s exact comparison rejects modes with KCOV_PAUSED set. The context switch suppression keeps its own bit: kcov_prepare_switch() runs on the previous task and kcov_finish_switch() on the one switched in, so its lifetime is not a pause section. Provide a kcov_pause guard backed by internal helpers that operate on current. The guard saves the previous pause state and restores it at scope exit, so sections nest. When KCOV is enabled for current, remote softirq sections save and restore the complete mode, preserving the pause state. The helpers are __always_inline, and guard users must be uninstrumented: inlining does not remove the caller's own coverage callbacks. Assisted-by: Claude:claude-fable-5 Signed-off-by: Karl Mehltretter --- Notes: v2: - add guard(kcov_pause)() backed by private current-only helpers include/linux/kcov.h | 40 +++++++++++++++++++++++++++++++++++++++- kernel/kcov.c | 2 +- 2 files changed, 40 insertions(+), 2 deletions(-) diff --git a/include/linux/kcov.h b/include/linux/kcov.h index 895b761b2db15..1b4806dab62fb 100644 --- a/include/linux/kcov.h +++ b/include/linux/kcov.h @@ -2,6 +2,8 @@ #ifndef _LINUX_KCOV_H #define _LINUX_KCOV_H +#include +#include #include #include @@ -23,7 +25,8 @@ enum kcov_mode { KCOV_MODE_TRACE_CMP = 3, }; -#define KCOV_IN_CTXSW (1 << 30) +#define KCOV_IN_CTXSW BIT(30) +#define KCOV_PAUSED BIT(29) void kcov_task_init(struct task_struct *t); void kcov_task_exit(struct task_struct *t); @@ -38,6 +41,25 @@ do { \ (t)->kcov_mode &= ~KCOV_IN_CTXSW; \ } while (0) +/* + * Pause coverage for current. Callers must be uninstrumented. + * Pass the returned state to __kcov_resume(). + */ +static __always_inline unsigned int __kcov_pause(void) +{ + unsigned int paused; + + paused = current->kcov_mode & KCOV_PAUSED; + current->kcov_mode |= KCOV_PAUSED; + return paused; +} + +static __always_inline void __kcov_resume(unsigned int paused) +{ + if (!paused) + current->kcov_mode &= ~KCOV_PAUSED; +} + /* See Documentation/dev-tools/kcov.rst for usage details. */ void kcov_remote_start(u64 handle); void kcov_remote_stop(void); @@ -93,6 +115,8 @@ void __sanitizer_cov_trace_switch(kcov_u64 val, void *cases); static inline void kcov_task_init(struct task_struct *t) {} static inline void kcov_task_exit(struct task_struct *t) {} +static inline unsigned int __kcov_pause(void) { return 0; } +static inline void __kcov_resume(unsigned int paused) {} static inline void kcov_prepare_switch(struct task_struct *t) {} static inline void kcov_finish_switch(struct task_struct *t) {} static inline void kcov_remote_start(u64 handle) {} @@ -107,4 +131,18 @@ static inline void kcov_remote_start_usb_softirq(u64 id) {} static inline void kcov_remote_stop_softirq(void) {} #endif /* CONFIG_KCOV */ + +/* + * Scope-based KCOV pause: + * + * guard(kcov_pause)(); + * + * pauses coverage for current until the end of the scope. Callers must be + * uninstrumented. + */ +DEFINE_LOCK_GUARD_0(kcov_pause, + _T->paused = __kcov_pause(), + __kcov_resume(_T->paused), + unsigned int paused) + #endif /* _LINUX_KCOV_H */ diff --git a/kernel/kcov.c b/kernel/kcov.c index b5340369e6fe3..a5c43764f21ac 100644 --- a/kernel/kcov.c +++ b/kernel/kcov.c @@ -830,7 +830,7 @@ static const struct file_operations kcov_fops = { static inline bool kcov_mode_enabled(unsigned int mode) { - return (mode & ~KCOV_IN_CTXSW) != KCOV_MODE_DISABLED; + return (mode & ~(KCOV_IN_CTXSW | KCOV_PAUSED)) != KCOV_MODE_DISABLED; } static void kcov_remote_softirq_start(struct task_struct *t) -- 2.53.0