From nobody Sat Feb 7 21:14:50 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 B48CE3EF0A4; Fri, 6 Feb 2026 14:23:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770387816; cv=none; b=f7eX+vgGLKxuVjIQ7odAgmnHXp0hhDUjERzl2p15kJN+Az1WBDtYRnGZO9paHsDGLafzIjYzQCNTAO5PDrMpve4F4jlg+F24Ji0iCEUZHWJSSjAwV8wx48PiGzFFNrGGUh9WoCDSJGbwYi7EIgtTbeCssOm24f/J4HkxzV9S+zE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770387816; c=relaxed/simple; bh=DaRfqtPxemmkp+aTTTQoiIZqc3SEzpEw+S8gq3cyoPY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=EbuDHij1Sn1FA8lQ8FQNcyHxe1abnePMkhueH8jn3RWTMpuEuo/eYaLLj5O8bTmAtBn/E8+GLAnePZyKUEpCAUnqCUAX4X8WGSTJ4UbmOBp/7YHplnN4jH+QQyU5kl2K6SmfYzXaFguDjuAsrlz6VnYH8ZPMiyosmr9iTUeigFU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=BU84qQiq; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="BU84qQiq" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 223F1C19421; Fri, 6 Feb 2026 14:23:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770387816; bh=DaRfqtPxemmkp+aTTTQoiIZqc3SEzpEw+S8gq3cyoPY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=BU84qQiqPenzVeN7b6iVXZU3Aq98TI8RnVWp5ThVnZaQ61YRQiT8g8RJ4n31aWvM+ Bc8FPIVGx6kobB/Pk0WfSAe1Q7nrqN3RQ2LAeyq3lQJyFcTZVmJaB8Dkd4LJpIa0cb F6F5ZKuxGoI8CQ7TisaeuHWEm46TNDEGIRT6xlIGKC63IuNB282k3riJV1x8sy8HsH dNuPM3JGMwVOfV3JK8DMe7cYWVli/dyd2Fdo5kUBNs3VoO/CrsP/Y2zKlpbxEq11o1 r2W+zflG36srXMqKgrj9zAMyOgMwEEFX0e0e/CiLQdsskyHwQsb2+jC82mVhAVo5pF dfIwwG2nb3dNw== From: Frederic Weisbecker To: LKML Cc: Frederic Weisbecker , "Christophe Leroy (CS GROUP)" , "Rafael J. Wysocki" , Alexander Gordeev , Anna-Maria Behnsen , Ben Segall , Boqun Feng , Christian Borntraeger , Dietmar Eggemann , Heiko Carstens , Ingo Molnar , Jan Kiszka , Joel Fernandes , Juri Lelli , Kieran Bingham , Madhavan Srinivasan , Mel Gorman , Michael Ellerman , Neeraj Upadhyay , Nicholas Piggin , "Paul E . McKenney" , Peter Zijlstra , Steven Rostedt , Sven Schnelle , Thomas Gleixner , Uladzislau Rezki , Valentin Schneider , Vasily Gorbik , Vincent Guittot , Viresh Kumar , Xin Zhao , linux-pm@vger.kernel.org, linux-s390@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, Shrikanth Hegde Subject: [PATCH 05/15] s390/time: Prepare to stop elapsing in dynticks-idle Date: Fri, 6 Feb 2026 15:22:35 +0100 Message-ID: <20260206142245.58987-6-frederic@kernel.org> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20260206142245.58987-1-frederic@kernel.org> References: <20260206142245.58987-1-frederic@kernel.org> 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 Content-Type: text/plain; charset="utf-8" Currently the tick subsystem stores the idle cputime accounting in private fields, allowing cohabitation with architecture idle vtime accounting. The former is fetched on online CPUs, the latter on offline CPUs. For consolidation purpose, architecture vtime accounting will continue to account the cputime but will make a break when the idle tick is stopped. The dyntick cputime accounting will then be relayed by the tick subsystem so that the idle cputime is still seen advancing coherently even when the tick isn't there to flush the idle vtime. Prepare for that and introduce three new APIs which will be used in subsequent patches: _ vtime_dynticks_start() is deemed to be called when idle enters in dyntick mode. The idle cputime that elapsed so far is accumulated and accounted. Also idle time accounting is ignored. - vtime_dynticks_stop() is deemed to be called when idle exits from dyntick mode. The vtime entry clocks are fast-forward to current time so that idle accounting restarts elapsing from now. Also idle time accounting is resumed. - vtime_reset() is deemed to be called from dynticks idle IRQ entry to fast-forward the clock to current time so that the IRQ time is still accounted by vtime while nohz cputime is paused. Also accumulated vtime won't be flushed from dyntick-idle ticks to avoid accounting twice the idle cputime, along with nohz accounting. Signed-off-by: Frederic Weisbecker --- arch/s390/include/asm/idle.h | 14 +++++--- arch/s390/kernel/idle.c | 19 +++++++---- arch/s390/kernel/vtime.c | 65 ++++++++++++++++++++++++++++++------ 3 files changed, 77 insertions(+), 21 deletions(-) diff --git a/arch/s390/include/asm/idle.h b/arch/s390/include/asm/idle.h index 09f763b9eb40..285b3da318d6 100644 --- a/arch/s390/include/asm/idle.h +++ b/arch/s390/include/asm/idle.h @@ -8,17 +8,21 @@ #ifndef _S390_IDLE_H #define _S390_IDLE_H =20 +#include #include #include =20 struct s390_idle_data { - unsigned long idle_count; - unsigned long idle_time; - unsigned long clock_idle_enter; - unsigned long timer_idle_enter; - unsigned long mt_cycles_enter[8]; + bool idle_dyntick; + unsigned long idle_count; + unsigned long idle_time; + unsigned long clock_idle_enter; + unsigned long timer_idle_enter; + unsigned long mt_cycles_enter[8]; }; =20 +DECLARE_PER_CPU(struct s390_idle_data, s390_idle); + extern struct device_attribute dev_attr_idle_count; extern struct device_attribute dev_attr_idle_time_us; =20 diff --git a/arch/s390/kernel/idle.c b/arch/s390/kernel/idle.c index 39cb8d0ae348..614db5ea6ea3 100644 --- a/arch/s390/kernel/idle.c +++ b/arch/s390/kernel/idle.c @@ -19,7 +19,7 @@ #include #include "entry.h" =20 -static DEFINE_PER_CPU(struct s390_idle_data, s390_idle); +DEFINE_PER_CPU(struct s390_idle_data, s390_idle); =20 void account_idle_time_irq(void) { @@ -35,7 +35,15 @@ void account_idle_time_irq(void) this_cpu_add(mt_cycles[i], cycles_new[i] - idle->mt_cycles_enter[i]); } =20 + WRITE_ONCE(idle->idle_count, READ_ONCE(idle->idle_count) + 1); + + /* Account time spent with enabled wait psw loaded as idle time. */ idle_time =3D lc->int_clock - idle->clock_idle_enter; + WRITE_ONCE(idle->idle_time, READ_ONCE(idle->idle_time) + idle_time); + + /* Dyntick idle time accounted by nohz/scheduler */ + if (idle->idle_dyntick) + return; =20 lc->steal_timer +=3D idle->clock_idle_enter - lc->last_update_clock; lc->last_update_clock =3D lc->int_clock; @@ -43,9 +51,6 @@ void account_idle_time_irq(void) lc->system_timer +=3D lc->last_update_timer - idle->timer_idle_enter; lc->last_update_timer =3D lc->sys_enter_timer; =20 - /* Account time spent with enabled wait psw loaded as idle time. */ - WRITE_ONCE(idle->idle_time, READ_ONCE(idle->idle_time) + idle_time); - WRITE_ONCE(idle->idle_count, READ_ONCE(idle->idle_count) + 1); account_idle_time(cputime_to_nsecs(idle_time)); } =20 @@ -61,8 +66,10 @@ void noinstr arch_cpu_idle(void) set_cpu_flag(CIF_ENABLED_WAIT); if (smp_cpu_mtid) stcctm(MT_DIAG, smp_cpu_mtid, (u64 *)&idle->mt_cycles_enter); - idle->clock_idle_enter =3D get_tod_clock_fast(); - idle->timer_idle_enter =3D get_cpu_timer(); + if (!idle->idle_dyntick) { + idle->clock_idle_enter =3D get_tod_clock_fast(); + idle->timer_idle_enter =3D get_cpu_timer(); + } bpon(); __load_psw_mask(psw_mask); } diff --git a/arch/s390/kernel/vtime.c b/arch/s390/kernel/vtime.c index 234a0ba30510..c19528eb4ee3 100644 --- a/arch/s390/kernel/vtime.c +++ b/arch/s390/kernel/vtime.c @@ -17,6 +17,7 @@ #include #include #include +#include #include =20 #include "entry.h" @@ -111,23 +112,30 @@ static void account_system_index_scaled(struct task_s= truct *p, u64 cputime, account_system_index_time(p, cputime_to_nsecs(cputime), index); } =20 -/* - * Update process times based on virtual cpu times stored by entry.S - * to the lowcore fields user_timer, system_timer & steal_clock. - */ -static int do_account_vtime(struct task_struct *tsk) +static inline void vtime_reset_last_update(struct lowcore *lc) { - u64 timer, clock, user, guest, system, hardirq, softirq; - struct lowcore *lc =3D get_lowcore(); - - timer =3D lc->last_update_timer; - clock =3D lc->last_update_clock; asm volatile( " stpt %0\n" /* Store current cpu timer value */ " stckf %1" /* Store current tod clock value */ : "=3DQ" (lc->last_update_timer), "=3DQ" (lc->last_update_clock) : : "cc"); +} + +/* + * Update process times based on virtual cpu times stored by entry.S + * to the lowcore fields user_timer, system_timer & steal_clock. + */ +static int do_account_vtime(struct task_struct *tsk) +{ + u64 timer, clock, user, guest, system, hardirq, softirq; + struct lowcore *lc =3D get_lowcore(); + + timer =3D lc->last_update_timer; + clock =3D lc->last_update_clock; + + vtime_reset_last_update(lc); + clock =3D lc->last_update_clock - clock; timer -=3D lc->last_update_timer; =20 @@ -261,6 +269,43 @@ void vtime_account_hardirq(struct task_struct *tsk) virt_timer_forward(delta); } =20 +#ifdef CONFIG_NO_HZ_COMMON +/** + * vtime_reset - Fast forward vtime entry clocks + * + * Called from dynticks idle IRQ entry to fast-forward the clocks to curre= nt time + * so that the IRQ time is still accounted by vtime while nohz cputime is = paused. + */ +void vtime_reset(void) +{ + vtime_reset_last_update(get_lowcore()); +} + +/** + * vtime_dyntick_start - Inform vtime about entry to idle-dynticks + * + * Called when idle enters in dyntick mode. The idle cputime that elapsed = so far + * is flushed and the tick subsystem takes over the idle cputime accountin= g. + */ +void vtime_dyntick_start(void) +{ + __this_cpu_write(s390_idle.idle_dyntick, true); + vtime_flush(current); +} + +/** + * vtime_dyntick_stop - Inform vtime about exit from idle-dynticks + * + * Called when idle exits from dyntick mode. The vtime entry clocks are + * fast-forward to current time and idle accounting resumes. + */ +void vtime_dyntick_stop(void) +{ + vtime_reset_last_update(get_lowcore()); + __this_cpu_write(s390_idle.idle_dyntick, false); +} +#endif /* CONFIG_NO_HZ_COMMON */ + /* * Sorted add to a list. List is linear searched until first bigger * element is found. --=20 2.51.1