From nobody Sun Feb 8 03:57:23 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9D65D7EF05 for ; Wed, 27 Mar 2024 11:29:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711538968; cv=none; b=ImVd0/J5zJZVn7riRSzCH4sLfENHXqZBvsEkItbDbn33ckWbB6Bont7LAbbLJ8KG/GB3sB0I1CxcvgKFdW1vlnI5YUMp7SHG4ZeazPIOEzJWxGnQSDjFw05DHZqttPXB4la78YtGrlpO0lpfEy6Jagzo5bBvlrzKEbw6/FYl5rw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711538968; c=relaxed/simple; bh=zJC6Fi8RX7Q1mj0rbuAMokMhkfYSUJeFUVHxXu4xS6c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=aXc0cJoXWhjtaim6v1Uyw3MgS/ik7mNR6hEz6HYTG5a62VX0tLsxkRg5YEgb/HVw/peX+qEYP7ngtzbQkwyqXwuXF3VW77NlM0FuVFdCLYNXVWQBWr9DMNwojwFLWXbAVgIPZIe7s4RxKShpbuqXe4qPL7zAZM+q8Wq0YLgs8YI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=OnsabbbZ; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="OnsabbbZ" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1711538965; 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=5vtIGiW/761u5u6dWFg63bmfLkJ5QZDUbW7u7igykf0=; b=OnsabbbZSzBMIZqJeDE8HBGCfc+32Ms45RVKw/Y5tAbsGsXFE1tpMsGkspEZ1wZ9sFrfRr FJBIlp3x8tr3kKcBKCNLk3UosN8NLgo7fbMdivsq2LUbq7yBlhdfSh+rjKyletT+l/NXC5 gwPqk2BIDfQ4EIx4HX8VROrC4IF7bfM= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-480-hNKDEi75O4qDXJZ6ctwhsA-1; Wed, 27 Mar 2024 07:29:20 -0400 X-MC-Unique: hNKDEi75O4qDXJZ6ctwhsA-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 87129800264; Wed, 27 Mar 2024 11:29:19 +0000 (UTC) Received: from vschneid-thinkpadt14sgen2i.remote.csb (unknown [10.39.193.36]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 3BAC92022C1E; Wed, 27 Mar 2024 11:29:17 +0000 (UTC) From: Valentin Schneider To: rcu@vger.kernel.org, linux-kernel@vger.kernel.org Cc: Frederic Weisbecker , "Paul E. McKenney" , Peter Zijlstra , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Boqun Feng , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang Subject: [PATCH 1/2] treewide: context_tracking: Rename CONTEXT_FOO to CT_STATE_FOO Date: Wed, 27 Mar 2024 12:29:01 +0100 Message-ID: <20240327112902.1184822-2-vschneid@redhat.com> In-Reply-To: <20240327112902.1184822-1-vschneid@redhat.com> References: <20240327112902.1184822-1-vschneid@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.4.1 on 10.11.54.4 Content-Type: text/plain; charset="utf-8" Context tracking state related symbols currently use a mix of the CONTEXT_ (e.g. CONTEXT_KERNEL) and CT_SATE_ (e.g. CT_STATE_MASK) prefixes. Clean up the naming and make the ctx_state enum use the CT_STATE_ prefix. Suggested-by: Frederic Weisbecker Signed-off-by: Valentin Schneider Acked-by: Frederic Weisbecker --- arch/Kconfig | 2 +- arch/arm64/kernel/entry-common.c | 2 +- arch/powerpc/include/asm/interrupt.h | 6 +++--- arch/powerpc/kernel/interrupt.c | 6 +++--- arch/powerpc/kernel/syscall.c | 2 +- arch/x86/entry/common.c | 2 +- include/linux/context_tracking.h | 16 ++++++++-------- include/linux/context_tracking_state.h | 20 ++++++++++---------- include/linux/entry-common.h | 2 +- kernel/context_tracking.c | 12 ++++++------ kernel/entry/common.c | 2 +- kernel/sched/core.c | 4 ++-- 12 files changed, 38 insertions(+), 38 deletions(-) diff --git a/arch/Kconfig b/arch/Kconfig index 9f066785bb71d..b0fb7182648a2 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -845,7 +845,7 @@ config HAVE_CONTEXT_TRACKING_USER_OFFSTACK Architecture neither relies on exception_enter()/exception_exit() nor on schedule_user(). Also preempt_schedule_notrace() and preempt_schedule_irq() can't be called in a preemptible section - while context tracking is CONTEXT_USER. This feature reflects a sane + while context tracking is CT_STATE_USER. This feature reflects a sane entry implementation where the following requirements are met on critical entry code, ie: before user_exit() or after user_enter(): =20 diff --git a/arch/arm64/kernel/entry-common.c b/arch/arm64/kernel/entry-com= mon.c index b77a15955f28b..3fcd9d080bf2a 100644 --- a/arch/arm64/kernel/entry-common.c +++ b/arch/arm64/kernel/entry-common.c @@ -103,7 +103,7 @@ static void noinstr exit_to_kernel_mode(struct pt_regs = *regs) static __always_inline void __enter_from_user_mode(void) { lockdep_hardirqs_off(CALLER_ADDR0); - CT_WARN_ON(ct_state() !=3D CONTEXT_USER); + CT_WARN_ON(ct_state() !=3D CT_STATE_USER); user_exit_irqoff(); trace_hardirqs_off_finish(); mte_disable_tco_entry(current); diff --git a/arch/powerpc/include/asm/interrupt.h b/arch/powerpc/include/as= m/interrupt.h index 7b610864b3645..dcb4bd8529f68 100644 --- a/arch/powerpc/include/asm/interrupt.h +++ b/arch/powerpc/include/asm/interrupt.h @@ -177,7 +177,7 @@ static inline void interrupt_enter_prepare(struct pt_re= gs *regs) =20 if (user_mode(regs)) { kuap_lock(); - CT_WARN_ON(ct_state() !=3D CONTEXT_USER); + CT_WARN_ON(ct_state() !=3D CT_STATE_USER); user_exit_irqoff(); =20 account_cpu_user_entry(); @@ -189,8 +189,8 @@ static inline void interrupt_enter_prepare(struct pt_re= gs *regs) * so avoid recursion. */ if (TRAP(regs) !=3D INTERRUPT_PROGRAM) - CT_WARN_ON(ct_state() !=3D CONTEXT_KERNEL && - ct_state() !=3D CONTEXT_IDLE); + CT_WARN_ON(ct_state() !=3D CT_STATE_KERNEL && + ct_state() !=3D CT_STATE_IDLE); INT_SOFT_MASK_BUG_ON(regs, is_implicit_soft_masked(regs)); INT_SOFT_MASK_BUG_ON(regs, arch_irq_disabled_regs(regs) && search_kernel_restart_table(regs->nip)); diff --git a/arch/powerpc/kernel/interrupt.c b/arch/powerpc/kernel/interrup= t.c index eca293794a1e8..af62ec974b970 100644 --- a/arch/powerpc/kernel/interrupt.c +++ b/arch/powerpc/kernel/interrupt.c @@ -266,7 +266,7 @@ notrace unsigned long syscall_exit_prepare(unsigned lon= g r3, unsigned long ret =3D 0; bool is_not_scv =3D !IS_ENABLED(CONFIG_PPC_BOOK3S_64) || !scv; =20 - CT_WARN_ON(ct_state() =3D=3D CONTEXT_USER); + CT_WARN_ON(ct_state() =3D=3D CT_STATE_USER); =20 kuap_assert_locked(); =20 @@ -344,7 +344,7 @@ notrace unsigned long interrupt_exit_user_prepare(struc= t pt_regs *regs) =20 BUG_ON(regs_is_unrecoverable(regs)); BUG_ON(arch_irq_disabled_regs(regs)); - CT_WARN_ON(ct_state() =3D=3D CONTEXT_USER); + CT_WARN_ON(ct_state() =3D=3D CT_STATE_USER); =20 /* * We don't need to restore AMR on the way back to userspace for KUAP. @@ -386,7 +386,7 @@ notrace unsigned long interrupt_exit_kernel_prepare(str= uct pt_regs *regs) if (!IS_ENABLED(CONFIG_PPC_BOOK3E_64) && TRAP(regs) !=3D INTERRUPT_PROGRAM && TRAP(regs) !=3D INTERRUPT_PERFMON) - CT_WARN_ON(ct_state() =3D=3D CONTEXT_USER); + CT_WARN_ON(ct_state() =3D=3D CT_STATE_USER); =20 kuap =3D kuap_get_and_assert_locked(); =20 diff --git a/arch/powerpc/kernel/syscall.c b/arch/powerpc/kernel/syscall.c index f6f868e817e63..be159ad4b77bd 100644 --- a/arch/powerpc/kernel/syscall.c +++ b/arch/powerpc/kernel/syscall.c @@ -27,7 +27,7 @@ notrace long system_call_exception(struct pt_regs *regs, = unsigned long r0) =20 trace_hardirqs_off(); /* finish reconciling */ =20 - CT_WARN_ON(ct_state() =3D=3D CONTEXT_KERNEL); + CT_WARN_ON(ct_state() =3D=3D CT_STATE_KERNEL); user_exit_irqoff(); =20 BUG_ON(regs_is_unrecoverable(regs)); diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c index 6356060caaf31..f42a125093e54 100644 --- a/arch/x86/entry/common.c +++ b/arch/x86/entry/common.c @@ -150,7 +150,7 @@ early_param("ia32_emulation", ia32_emulation_override_c= mdline); #endif =20 /* - * Invoke a 32-bit syscall. Called with IRQs on in CONTEXT_KERNEL. + * Invoke a 32-bit syscall. Called with IRQs on in CT_STATE_KERNEL. */ static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs, in= t nr) { diff --git a/include/linux/context_tracking.h b/include/linux/context_track= ing.h index 6e76b9dba00e7..28fcfa1849032 100644 --- a/include/linux/context_tracking.h +++ b/include/linux/context_tracking.h @@ -26,26 +26,26 @@ extern void user_exit_callable(void); static inline void user_enter(void) { if (context_tracking_enabled()) - ct_user_enter(CONTEXT_USER); + ct_user_enter(CT_STATE_USER); =20 } static inline void user_exit(void) { if (context_tracking_enabled()) - ct_user_exit(CONTEXT_USER); + ct_user_exit(CT_STATE_USER); } =20 /* Called with interrupts disabled. */ static __always_inline void user_enter_irqoff(void) { if (context_tracking_enabled()) - __ct_user_enter(CONTEXT_USER); + __ct_user_enter(CT_STATE_USER); =20 } static __always_inline void user_exit_irqoff(void) { if (context_tracking_enabled()) - __ct_user_exit(CONTEXT_USER); + __ct_user_exit(CT_STATE_USER); } =20 static inline enum ctx_state exception_enter(void) @@ -57,7 +57,7 @@ static inline enum ctx_state exception_enter(void) return 0; =20 prev_ctx =3D __ct_state(); - if (prev_ctx !=3D CONTEXT_KERNEL) + if (prev_ctx !=3D CT_STATE_KERNEL) ct_user_exit(prev_ctx); =20 return prev_ctx; @@ -67,7 +67,7 @@ static inline void exception_exit(enum ctx_state prev_ctx) { if (!IS_ENABLED(CONFIG_HAVE_CONTEXT_TRACKING_USER_OFFSTACK) && context_tracking_enabled()) { - if (prev_ctx !=3D CONTEXT_KERNEL) + if (prev_ctx !=3D CT_STATE_KERNEL) ct_user_enter(prev_ctx); } } @@ -75,7 +75,7 @@ static inline void exception_exit(enum ctx_state prev_ctx) static __always_inline bool context_tracking_guest_enter(void) { if (context_tracking_enabled()) - __ct_user_enter(CONTEXT_GUEST); + __ct_user_enter(CT_STATE_GUEST); =20 return context_tracking_enabled_this_cpu(); } @@ -83,7 +83,7 @@ static __always_inline bool context_tracking_guest_enter(= void) static __always_inline void context_tracking_guest_exit(void) { if (context_tracking_enabled()) - __ct_user_exit(CONTEXT_GUEST); + __ct_user_exit(CT_STATE_GUEST); } =20 #define CT_WARN_ON(cond) WARN_ON(context_tracking_enabled() && (cond)) diff --git a/include/linux/context_tracking_state.h b/include/linux/context= _tracking_state.h index bbff5f7f88030..f1c53125edee2 100644 --- a/include/linux/context_tracking_state.h +++ b/include/linux/context_tracking_state.h @@ -10,18 +10,18 @@ #define DYNTICK_IRQ_NONIDLE ((LONG_MAX / 2) + 1) =20 enum ctx_state { - CONTEXT_DISABLED =3D -1, /* returned by ct_state() if unknown */ - CONTEXT_KERNEL =3D 0, - CONTEXT_IDLE =3D 1, - CONTEXT_USER =3D 2, - CONTEXT_GUEST =3D 3, - CONTEXT_MAX =3D 4, + CT_STATE_DISABLED =3D -1, /* returned by ct_state() if unknown */ + CT_STATE_KERNEL =3D 0, + CT_STATE_IDLE =3D 1, + CT_STATE_USER =3D 2, + CT_STATE_GUEST =3D 3, + CT_STATE_MAX =3D 4, }; =20 /* Even value for idle, else odd. */ -#define RCU_DYNTICKS_IDX CONTEXT_MAX +#define RCU_DYNTICKS_IDX CT_STATE_MAX =20 -#define CT_STATE_MASK (CONTEXT_MAX - 1) +#define CT_STATE_MASK (CT_STATE_MAX - 1) #define CT_DYNTICKS_MASK (~CT_STATE_MASK) =20 struct context_tracking { @@ -123,14 +123,14 @@ static inline bool context_tracking_enabled_this_cpu(= void) * * Returns the current cpu's context tracking state if context tracking * is enabled. If context tracking is disabled, returns - * CONTEXT_DISABLED. This should be used primarily for debugging. + * CT_STATE_DISABLED. This should be used primarily for debugging. */ static __always_inline int ct_state(void) { int ret; =20 if (!context_tracking_enabled()) - return CONTEXT_DISABLED; + return CT_STATE_DISABLED; =20 preempt_disable(); ret =3D __ct_state(); diff --git a/include/linux/entry-common.h b/include/linux/entry-common.h index b0fb775a600d9..1e50cdb83ae50 100644 --- a/include/linux/entry-common.h +++ b/include/linux/entry-common.h @@ -108,7 +108,7 @@ static __always_inline void enter_from_user_mode(struct= pt_regs *regs) arch_enter_from_user_mode(regs); lockdep_hardirqs_off(CALLER_ADDR0); =20 - CT_WARN_ON(__ct_state() !=3D CONTEXT_USER); + CT_WARN_ON(__ct_state() !=3D CT_STATE_USER); user_exit_irqoff(); =20 instrumentation_begin(); diff --git a/kernel/context_tracking.c b/kernel/context_tracking.c index 70ae70d038233..21f2cf90ed0bf 100644 --- a/kernel/context_tracking.c +++ b/kernel/context_tracking.c @@ -317,7 +317,7 @@ void noinstr ct_nmi_enter(void) void noinstr ct_idle_enter(void) { WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !raw_irqs_disabled()); - ct_kernel_exit(false, RCU_DYNTICKS_IDX + CONTEXT_IDLE); + ct_kernel_exit(false, RCU_DYNTICKS_IDX + CT_STATE_IDLE); } EXPORT_SYMBOL_GPL(ct_idle_enter); =20 @@ -335,7 +335,7 @@ void noinstr ct_idle_exit(void) unsigned long flags; =20 raw_local_irq_save(flags); - ct_kernel_enter(false, RCU_DYNTICKS_IDX - CONTEXT_IDLE); + ct_kernel_enter(false, RCU_DYNTICKS_IDX - CT_STATE_IDLE); raw_local_irq_restore(flags); } EXPORT_SYMBOL_GPL(ct_idle_exit); @@ -485,7 +485,7 @@ void noinstr __ct_user_enter(enum ctx_state state) * user_exit() or ct_irq_enter(). Let's remove RCU's dependency * on the tick. */ - if (state =3D=3D CONTEXT_USER) { + if (state =3D=3D CT_STATE_USER) { instrumentation_begin(); trace_user_enter(0); vtime_user_enter(current); @@ -621,7 +621,7 @@ void noinstr __ct_user_exit(enum ctx_state state) * run a RCU read side critical section anytime. */ ct_kernel_enter(true, RCU_DYNTICKS_IDX - state); - if (state =3D=3D CONTEXT_USER) { + if (state =3D=3D CT_STATE_USER) { instrumentation_begin(); vtime_user_exit(current); trace_user_exit(0); @@ -634,12 +634,12 @@ void noinstr __ct_user_exit(enum ctx_state state) * In this we case we don't care about any concurrency/ordering. */ if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE)) - raw_atomic_set(&ct->state, CONTEXT_KERNEL); + raw_atomic_set(&ct->state, CT_STATE_KERNEL); =20 } else { if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE)) { /* Tracking for vtime only, no concurrent RCU EQS accounting */ - raw_atomic_set(&ct->state, CONTEXT_KERNEL); + raw_atomic_set(&ct->state, CT_STATE_KERNEL); } else { /* * Tracking for vtime and RCU EQS. Make sure we don't race diff --git a/kernel/entry/common.c b/kernel/entry/common.c index 90843cc385880..5b6934e23c21d 100644 --- a/kernel/entry/common.c +++ b/kernel/entry/common.c @@ -182,7 +182,7 @@ static void syscall_exit_to_user_mode_prepare(struct pt= _regs *regs) unsigned long work =3D READ_ONCE(current_thread_info()->syscall_work); unsigned long nr =3D syscall_get_nr(current, regs); =20 - CT_WARN_ON(ct_state() !=3D CONTEXT_KERNEL); + CT_WARN_ON(ct_state() !=3D CT_STATE_KERNEL); =20 if (IS_ENABLED(CONFIG_PROVE_LOCKING)) { if (WARN(irqs_disabled(), "syscall %lu left IRQs disabled", nr)) diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 7019a40457a6d..35dd462a55abe 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -5980,7 +5980,7 @@ static inline void schedule_debug(struct task_struct = *prev, bool preempt) preempt_count_set(PREEMPT_DISABLED); } rcu_sleep_check(); - SCHED_WARN_ON(ct_state() =3D=3D CONTEXT_USER); + SCHED_WARN_ON(ct_state() =3D=3D CT_STATE_USER); =20 profile_hit(SCHED_PROFILING, __builtin_return_address(0)); =20 @@ -6875,7 +6875,7 @@ asmlinkage __visible void __sched schedule_user(void) * we find a better solution. * * NB: There are buggy callers of this function. Ideally we - * should warn if prev_state !=3D CONTEXT_USER, but that will trigger + * should warn if prev_state !=3D CT_STATE_USER, but that will trigger * too frequently to make sense yet. */ enum ctx_state prev_state =3D exception_enter(); --=20 2.43.0 From nobody Sun Feb 8 03:57:23 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0B65B7FBD4 for ; Wed, 27 Mar 2024 11:29:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711538971; cv=none; b=sQxBD/YwCb9uZBaaY8LcMux9fspKLkhNgjbkBT15M119Kf7ZjQpdUrGYA+cc1IAaHQlATdSLGwoTTOFt8QNOo7UgxMMCdyVqy1gPPuEx9un60CCnX6XI7uXoHl7gnwOq7a/9Iw8VU3EmNF2rrcT7yg3LNbEhFhHIsY0pw3f4c1I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711538971; c=relaxed/simple; bh=C50o+8uXXJwHdRyJixvsculdOK38RLdhtA/bSjgUNt8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=D4mebsn25pi+Irzpvt9Tj51SKwfMfu3rd3/gR5x93WYL7GPJ2/JzDrfne4i3qPoXJE/OrWUfGCyoibzG3Ix8CuxiVRhBxCDYyNipn5hlLD137UksqltjATyI57iAQrtWPconJvOpOIfOFD++R5ZDRwUYJzAeuK1/c23bZlfCMvo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=R36MxAgI; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="R36MxAgI" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1711538969; 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=5OgXz6VKYWg4imdUs16+mQMvgLCUYBLnNjkDDHsPnsk=; b=R36MxAgIPSAJELmg+52/aVxzSMsMi6ns2cnAu4MwAFYEb3HmztRPdmtUwEXS9hLC+vI2lG Wsd8hhY8I/THTaqd5qqdef8aW+d6YXXIl0+Vow3Cz/fuMOGc2FbdG5IDi9F/sFp/3UeZde sYv9HY3HwcKzCeZpfAQ/4l/54Gl06Yw= Received: from mimecast-mx02.redhat.com (mx-ext.redhat.com [66.187.233.73]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-127-pqP_EEavN32C8GDwjRtfnQ-1; Wed, 27 Mar 2024 07:29:22 -0400 X-MC-Unique: pqP_EEavN32C8GDwjRtfnQ-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id E21533C0E206; Wed, 27 Mar 2024 11:29:21 +0000 (UTC) Received: from vschneid-thinkpadt14sgen2i.remote.csb (unknown [10.39.193.36]) by smtp.corp.redhat.com (Postfix) with ESMTPS id C326A2024517; Wed, 27 Mar 2024 11:29:19 +0000 (UTC) From: Valentin Schneider To: rcu@vger.kernel.org, linux-kernel@vger.kernel.org Cc: Frederic Weisbecker , "Paul E. McKenney" , Peter Zijlstra , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Boqun Feng , Steven Rostedt , Mathieu Desnoyers , Lai Jiangshan , Zqiang Subject: [PATCH 2/2] context_tracking, rcu: Rename RCU_DYNTICKS_IDX to CT_DYNTICKS_IDX Date: Wed, 27 Mar 2024 12:29:02 +0100 Message-ID: <20240327112902.1184822-3-vschneid@redhat.com> In-Reply-To: <20240327112902.1184822-1-vschneid@redhat.com> References: <20240327112902.1184822-1-vschneid@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.4.1 on 10.11.54.4 Content-Type: text/plain; charset="utf-8" The symbols relating to the CT_STATE part of context_tracking.state are now all prefixed with CT_STATE. The RCU dynticks counter part of that atomic variable still involves symbols with different prefixes, align them all to be prefixed with CT_DYNTICKS, as CT_DYNTICKS_MASK already is. Signed-off-by: Valentin Schneider --- include/linux/context_tracking.h | 6 +++--- include/linux/context_tracking_state.h | 2 +- kernel/context_tracking.c | 22 +++++++++++----------- kernel/rcu/tree.c | 12 ++++++------ 4 files changed, 21 insertions(+), 21 deletions(-) diff --git a/include/linux/context_tracking.h b/include/linux/context_track= ing.h index 28fcfa1849032..a9c3f2c0e04e3 100644 --- a/include/linux/context_tracking.h +++ b/include/linux/context_tracking.h @@ -119,7 +119,7 @@ extern void ct_idle_exit(void); */ static __always_inline bool rcu_dynticks_curr_cpu_in_eqs(void) { - return !(raw_atomic_read(this_cpu_ptr(&context_tracking.state)) & RCU_DYN= TICKS_IDX); + return !(raw_atomic_read(this_cpu_ptr(&context_tracking.state)) & CT_DYNT= ICKS_IDX); } =20 /* @@ -142,7 +142,7 @@ static __always_inline bool warn_rcu_enter(void) preempt_disable_notrace(); if (rcu_dynticks_curr_cpu_in_eqs()) { ret =3D true; - ct_state_inc(RCU_DYNTICKS_IDX); + ct_state_inc(CT_DYNTICKS_IDX); } =20 return ret; @@ -151,7 +151,7 @@ static __always_inline bool warn_rcu_enter(void) static __always_inline void warn_rcu_exit(bool rcu) { if (rcu) - ct_state_inc(RCU_DYNTICKS_IDX); + ct_state_inc(CT_DYNTICKS_IDX); preempt_enable_notrace(); } =20 diff --git a/include/linux/context_tracking_state.h b/include/linux/context= _tracking_state.h index f1c53125edee2..73af5a13b4fc5 100644 --- a/include/linux/context_tracking_state.h +++ b/include/linux/context_tracking_state.h @@ -19,7 +19,7 @@ enum ctx_state { }; =20 /* Even value for idle, else odd. */ -#define RCU_DYNTICKS_IDX CT_STATE_MAX +#define CT_DYNTICKS_IDX CT_STATE_MAX =20 #define CT_STATE_MASK (CT_STATE_MAX - 1) #define CT_DYNTICKS_MASK (~CT_STATE_MASK) diff --git a/kernel/context_tracking.c b/kernel/context_tracking.c index 21f2cf90ed0bf..586c17fef1327 100644 --- a/kernel/context_tracking.c +++ b/kernel/context_tracking.c @@ -31,7 +31,7 @@ DEFINE_PER_CPU(struct context_tracking, context_tracking)= =3D { .dynticks_nesting =3D 1, .dynticks_nmi_nesting =3D DYNTICK_IRQ_NONIDLE, #endif - .state =3D ATOMIC_INIT(RCU_DYNTICKS_IDX), + .state =3D ATOMIC_INIT(CT_DYNTICKS_IDX), }; EXPORT_SYMBOL_GPL(context_tracking); =20 @@ -90,7 +90,7 @@ static noinstr void ct_kernel_exit_state(int offset) rcu_dynticks_task_trace_enter(); // Before ->dynticks update! seq =3D ct_state_inc(offset); // RCU is no longer watching. Better be in extended quiescent state! - WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && (seq & RCU_DYNTICKS_IDX)= ); + WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && (seq & CT_DYNTICKS_IDX)); } =20 /* @@ -110,7 +110,7 @@ static noinstr void ct_kernel_enter_state(int offset) seq =3D ct_state_inc(offset); // RCU is now watching. Better not be in an extended quiescent state! rcu_dynticks_task_trace_exit(); // After ->dynticks update! - WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !(seq & RCU_DYNTICKS_IDX= )); + WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !(seq & CT_DYNTICKS_IDX)= ); } =20 /* @@ -236,7 +236,7 @@ void noinstr ct_nmi_exit(void) instrumentation_end(); =20 // RCU is watching here ... - ct_kernel_exit_state(RCU_DYNTICKS_IDX); + ct_kernel_exit_state(CT_DYNTICKS_IDX); // ... but is no longer watching here. =20 if (!in_nmi()) @@ -277,7 +277,7 @@ void noinstr ct_nmi_enter(void) rcu_dynticks_task_exit(); =20 // RCU is not watching here ... - ct_kernel_enter_state(RCU_DYNTICKS_IDX); + ct_kernel_enter_state(CT_DYNTICKS_IDX); // ... but is watching here. =20 instrumentation_begin(); @@ -317,7 +317,7 @@ void noinstr ct_nmi_enter(void) void noinstr ct_idle_enter(void) { WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !raw_irqs_disabled()); - ct_kernel_exit(false, RCU_DYNTICKS_IDX + CT_STATE_IDLE); + ct_kernel_exit(false, CT_DYNTICKS_IDX + CT_STATE_IDLE); } EXPORT_SYMBOL_GPL(ct_idle_enter); =20 @@ -335,7 +335,7 @@ void noinstr ct_idle_exit(void) unsigned long flags; =20 raw_local_irq_save(flags); - ct_kernel_enter(false, RCU_DYNTICKS_IDX - CT_STATE_IDLE); + ct_kernel_enter(false, CT_DYNTICKS_IDX - CT_STATE_IDLE); raw_local_irq_restore(flags); } EXPORT_SYMBOL_GPL(ct_idle_exit); @@ -504,7 +504,7 @@ void noinstr __ct_user_enter(enum ctx_state state) * CPU doesn't need to maintain the tick for RCU maintenance purposes * when the CPU runs in userspace. */ - ct_kernel_exit(true, RCU_DYNTICKS_IDX + state); + ct_kernel_exit(true, CT_DYNTICKS_IDX + state); =20 /* * Special case if we only track user <-> kernel transitions for tickle= ss @@ -534,7 +534,7 @@ void noinstr __ct_user_enter(enum ctx_state state) /* * Tracking for vtime and RCU EQS. Make sure we don't race * with NMIs. OTOH we don't care about ordering here since - * RCU only requires RCU_DYNTICKS_IDX increments to be fully + * RCU only requires CT_DYNTICKS_IDX increments to be fully * ordered. */ raw_atomic_add(state, &ct->state); @@ -620,7 +620,7 @@ void noinstr __ct_user_exit(enum ctx_state state) * Exit RCU idle mode while entering the kernel because it can * run a RCU read side critical section anytime. */ - ct_kernel_enter(true, RCU_DYNTICKS_IDX - state); + ct_kernel_enter(true, CT_DYNTICKS_IDX - state); if (state =3D=3D CT_STATE_USER) { instrumentation_begin(); vtime_user_exit(current); @@ -644,7 +644,7 @@ void noinstr __ct_user_exit(enum ctx_state state) /* * Tracking for vtime and RCU EQS. Make sure we don't race * with NMIs. OTOH we don't care about ordering here since - * RCU only requires RCU_DYNTICKS_IDX increments to be fully + * RCU only requires CT_DYNTICKS_IDX increments to be fully * ordered. */ raw_atomic_sub(state, &ct->state); diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c index d9642dd06c253..3dbdcd12b876e 100644 --- a/kernel/rcu/tree.c +++ b/kernel/rcu/tree.c @@ -259,9 +259,9 @@ void rcu_softirq_qs(void) */ static void rcu_dynticks_eqs_online(void) { - if (ct_dynticks() & RCU_DYNTICKS_IDX) + if (ct_dynticks() & CT_DYNTICKS_IDX) return; - ct_state_inc(RCU_DYNTICKS_IDX); + ct_state_inc(CT_DYNTICKS_IDX); } =20 /* @@ -280,7 +280,7 @@ static int rcu_dynticks_snap(int cpu) */ static bool rcu_dynticks_in_eqs(int snap) { - return !(snap & RCU_DYNTICKS_IDX); + return !(snap & CT_DYNTICKS_IDX); } =20 /* @@ -302,7 +302,7 @@ bool rcu_dynticks_zero_in_eqs(int cpu, int *vp) int snap; =20 // If not quiescent, force back to earlier extended quiescent state. - snap =3D ct_dynticks_cpu(cpu) & ~RCU_DYNTICKS_IDX; + snap =3D ct_dynticks_cpu(cpu) & ~CT_DYNTICKS_IDX; smp_rmb(); // Order ->dynticks and *vp reads. if (READ_ONCE(*vp)) return false; // Non-zero, so report failure; @@ -328,9 +328,9 @@ notrace void rcu_momentary_dyntick_idle(void) int seq; =20 raw_cpu_write(rcu_data.rcu_need_heavy_qs, false); - seq =3D ct_state_inc(2 * RCU_DYNTICKS_IDX); + seq =3D ct_state_inc(2 * CT_DYNTICKS_IDX); /* It is illegal to call this from idle state. */ - WARN_ON_ONCE(!(seq & RCU_DYNTICKS_IDX)); + WARN_ON_ONCE(!(seq & CT_DYNTICKS_IDX)); rcu_preempt_deferred_qs(current); } EXPORT_SYMBOL_GPL(rcu_momentary_dyntick_idle); --=20 2.43.0