From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mta0.migadu.com (out-58.mta0.migadu.com [91.218.175.58]) (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 A5860448B93 for ; Wed, 16 Sep 2026 07:23:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.218.175.58 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789543439; cv=none; b=V/I8NqmG+Y83ivuVv2XWCGUYf/OUCRvXCobf5ZhnGxrWteyTJuXheO81wqMlR5o28/nzVPi2SRHaN317DwptDsaFEyz0KWLfzObcEAUtEEANGQvcMVCDFgglVcsc10TSwn/48r6fhG9uvw5L6Rr3y7MAIZ3Rsr5RjQdZe04Rpew= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789543439; c=relaxed/simple; bh=aiFgk0UbBEjxU1IIYRxCV2UZME6MIuY5pKn3Rxf8kdk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rIbg/Ow9wBY+xxJkIpFnCHhC3u6KqwImrZLMg7MS5LdQoseznFDAJl9YhW4qUT65hPCGm36k41rRLCAA2G6TqxIhRV43cu+crGr3osS5FeHuWXjaafewW8sjO33QeawLmIf9iBXb7IyWZUR7sVsqq2/FS980vCPJmCj76RmyjMI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=EEvITN0o; arc=none smtp.client-ip=91.218.175.58 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="EEvITN0o" X-Envelope-To: linux-kernel@vger.kernel.org DKIM-Signature: a=rsa-sha256; bh=aiFgk0UbBEjxU1IIYRxCV2UZME6MIuY5pKn3Rxf8kdk=; c=simple/simple; d=linux.dev; h=from:to:subject:date:message-id:mime-version:content-type; s=key1; t=1789543418; v=1; x=1790148218; b=EEvITN0oBpezCXP941HPGShMocCVnbU53vsYZGb89ym5uOxG1m5QYXWJwo7WcgU63ab5f0vk 5g9+ANYdfxIOHr7WO4o1vwynFvoSARuMjv3e7uoQFmBXoD+ziEwKQsRaZ5CLJKvvDkrhTvwv80R +KUzmMBWY6Os+STPobufjuIM= X-Envelope-To: linux-kernel@vger.kernel.org Received: by smtp.migadu.com with ESMTPS id d581e65a9509904b; Wed, 16 Sep 2026 07:23:37 +0000 X-Mizu-Trace-ID: d581e65a9509904b X-Migadu-Flow: FLOW_OUT From: Tao Cui To: tj@kernel.org, josef@toxicopanda.com, axboe@kernel.dk, ameryhung@gmail.com Cc: cgroups@vger.kernel.org, linux-block@vger.kernel.org, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, andrii@kernel.org, ast@kernel.org, daniel@iogearbox.net, linux-kselftest@vger.kernel.org, cui.tao@linux.dev, cuitao@kylinos.cn Subject: [RFC PATCH v4 3/5] blk-iocost: add iocost_ioc_tick tracepoint for per-period device summary Date: Wed, 16 Sep 2026 15:23:00 +0800 Message-ID: <20260916072302.1068871-4-cui.tao@linux.dev> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260916072302.1068871-1-cui.tao@linux.dev> References: <20260916072302.1068871-1-cui.tao@linux.dev> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit From: Tao Cui The existing iocost tracepoints are state-change driven: vrate_adj fires only when the adjustment logic runs, inuse_* only on surplus state transitions, activate/idle only on cgroup state changes. In a steady state none of them fire. The only other way to observe the controller (period length, vrate, busy level, active cgroup count, device utilization) is iocost_monitor.py, which reads kernel memory through drgn and is not usable in most production environments. Add iocost_ioc_tick, emitted once per period from the tail of ioc_timer_fn() with the overall controller state: period_us, vrate, busy_level, active iocg count, usage percentage and running state. It fires every period the controller runs, including steady states, plus one final tick before the controller goes idle, which makes dormancy (e.g. a device saturated entirely by uncharged IO) directly visible. Depending on the autop profile this is 2-100 events per second per device; the added cost outside the tracepoint static key is one increment per active cgroup per period. Signed-off-by: Tao Cui --- block/blk-iocost.c | 32 +++++++++++++++++++++++++ include/trace/events/iocost.h | 45 +++++++++++++++++++++++++++++++++++ 2 files changed, 77 insertions(+) diff --git a/block/blk-iocost.c b/block/blk-iocost.c index 65d4371e4ac45..73c8dcfda65b2 100644 --- a/block/blk-iocost.c +++ b/block/blk-iocost.c @@ -2244,6 +2244,10 @@ static void ioc_timer_fn(struct timer_list *timer) struct ioc_now now; LIST_HEAD(surpluses); int nr_debtors, nr_shortages = 0, nr_lagging = 0; + int nr_active = 0; + u32 tick_period_us; + u64 tick_vrate, tick_dur; + int tick_busy, tick_running; u64 usage_us_sum = 0; u32 ppm_rthr; u32 ppm_wthr; @@ -2280,6 +2284,8 @@ static void ioc_timer_fn(struct timer_list *timer) u64 vdone, vtime, usage_us; u32 hw_active, hw_inuse; + nr_active++; + /* * Collect unused and wind vtime closer to vnow to prevent * iocgs from accumulating a large amount of budget. @@ -2441,6 +2447,14 @@ static void ioc_timer_fn(struct timer_list *timer) ioc->busy_level = clamp(ioc->busy_level, -1000, 1000); + /* + * vrate and period_us change right below; snapshot the values + * this period ran in so the tick below reports the period's own + * parameters instead of the next period's. + */ + tick_period_us = ioc->period_us; + tick_vrate = ioc->vtime_base_rate; + ioc_adjust_base_vrate(ioc, rq_wait_pct, nr_lagging, nr_shortages, prev_busy_level, missed_ppm); @@ -2448,6 +2462,24 @@ static void ioc_timer_fn(struct timer_list *timer) ioc_forgive_debts(ioc, usage_us_sum, nr_debtors, &now); + /* + * Snapshot the state this period ran in before the idle + * transition below wipes it, so the final tick reports the period's + * own busy level (e.g. the saturation that drove the controller + * idle) instead of the cleared one. usage is normalized by the + * measured period length, captured before ioc_start_period() + * overwrites period_at, the same way the donation loop does. + * Emitted before cur_period is bumped, so the tick carries the + * number of the period it describes. + */ + tick_busy = ioc->busy_level; + tick_running = ioc->running; + tick_dur = now.now - ioc->period_at; + + trace_iocost_ioc_tick(ioc, nr_active, usage_us_sum, + tick_period_us, tick_vrate, + tick_busy, tick_running, tick_dur); + /* * This period is done. Move onto the next one. If nothing's * going on with the device, stop the timer. diff --git a/include/trace/events/iocost.h b/include/trace/events/iocost.h index e772b1bc60d60..32f19861a78fd 100644 --- a/include/trace/events/iocost.h +++ b/include/trace/events/iocost.h @@ -178,6 +178,51 @@ TRACE_EVENT(iocost_ioc_vrate_adj, ) ); +/* + * Periodic per-device summary, emitted once per period from the tail of + * ioc_timer_fn(). Unlike the state-change events above, this fires every + * period the controller is running, including steady states, and carries + * the overall controller state so basic monitoring doesn't require drgn. + */ +TRACE_EVENT(iocost_ioc_tick, + + TP_PROTO(struct ioc *ioc, int nr_active, u64 usage_us_sum, + u32 tick_period_us, u64 tick_vrate, + int tick_busy, int tick_running, u64 tick_dur), + + TP_ARGS(ioc, nr_active, usage_us_sum, tick_period_us, tick_vrate, + tick_busy, tick_running, tick_dur), + + TP_STRUCT__entry ( + __string(devname, ioc_name(ioc)) + __field(u64, cur_period) + __field(u32, period_us) + __field(u64, vrate) + __field(int, busy_level) + __field(int, nr_active) + __field(u32, usage_pct) + __field(int, running) + ), + + TP_fast_assign( + __assign_str(devname); + __entry->cur_period = atomic64_read(&ioc->cur_period); + __entry->period_us = tick_period_us; + __entry->vrate = tick_vrate; + __entry->busy_level = tick_busy; + __entry->nr_active = nr_active; + __entry->usage_pct = tick_dur ? + div64_u64(usage_us_sum * 100, tick_dur) : 0; + __entry->running = tick_running; + ), + + TP_printk("[%s] period=%llu:%uus vrate=%llu busy=%d active=%d usage=%u%% running=%d", + __get_str(devname), __entry->cur_period, __entry->period_us, + __entry->vrate, __entry->busy_level, __entry->nr_active, + __entry->usage_pct, __entry->running + ) +); + TRACE_EVENT(iocost_iocg_forgive_debt, TP_PROTO(struct ioc_gq *iocg, const char *path, struct ioc_now *now, -- 2.43.0