From nobody Fri Sep 25 16:01:28 2026 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.19]) (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 39659545DB8; Thu, 10 Sep 2026 17:40:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.175.65.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062065; cv=none; b=MCuSxz68+gCq5L67J4U0W0q+MaDC0xtZieikhA8ffctVINLwQZvY2NUGEhufnJtFxStWxz/oUeFDH48GNMN7QQNErc/My3tta+zHA4qa122kp0Bp3AW7rTFfzLe5qRzF3mb6hMlO7FIzCXlMEXSIVtHRVH2poZSdLuBI7s1sWcA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062065; c=relaxed/simple; bh=xFCDOkvk2TofjVGFvEcPYHDr8qB7EOl4xYV+VmLtdNo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=JqjL3qICAkX5G2r88QmDd86jpsXcpnzAH+inL74NKOXd4R7sAC4yCwOhzNgOyggbq3nW683yuoGmSh9S1Bc9YmOzbSQM+MTTkhvCSuHLaD6pjkobhSBOKz3H4T6H6A4FSASqE7vIFXpq4v/pjY/yXYZIdJuZOrQ7c+JKdPCZVrg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com; spf=pass smtp.mailfrom=linux.intel.com; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b=D7TVETxk; arc=none smtp.client-ip=198.175.65.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b="D7TVETxk" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1789062057; x=1820598057; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=xFCDOkvk2TofjVGFvEcPYHDr8qB7EOl4xYV+VmLtdNo=; b=D7TVETxkfzJHJ3PSU1LnkOuQiw6bHpYMwoflJv9pmQ3TlhEdcii7KPl7 8mYkkvk1CIGO7WRg90GeQQfWKfHhGe7z/FObih0mjD9yBO/DZXnj2xwlt K6IvRgq0l5V31d4UMmIKNefIuM81kiSUi6sqBFmgtPpT79UqU64ENnMcp pYXVUOAtztYhu20i/0VE/oivHqjgMuR9I/3hwEUzLBpKc387w2P98w6hw 9HNit/e4+JR0SSK6CfqhSn/VVzWcloWjm1y03ueuxI9lV4GQQSTaN/dUk JYlBPN4S3tb6udWDXTxdxkkrnmqbJY3gwbxpOEex4AAHzns3OS5Oh5mp1 g==; X-CSE-ConnectionGUID: OTTKg9IbQTWuG3TQLQQuJg== X-CSE-MsgGUID: JeoGrdE5TNeg/9B3788QWw== X-IronPort-AV: E=McAfee;i="6800,10657,11901"; a="89453788" X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="89453788" Received: from orviesa003.jf.intel.com ([10.64.159.143]) by orvoesa111.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Sep 2026 10:40:50 -0700 X-CSE-ConnectionGUID: ikLY6dI3QV64wg6PT8UPgw== X-CSE-MsgGUID: UanPt+boQNeAlNLKbJnhTg== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="275222012" Received: from b04f130c83f2.jf.intel.com ([10.165.154.98]) by orviesa003.jf.intel.com with ESMTP; 10 Sep 2026 10:40:50 -0700 From: Tim Chen To: Peter Zijlstra , Ingo Molnar Cc: Tim Chen , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Valentin Schneider , K Prateek Nayak , Kees Cook , Christian Brauner , Alexander Viro , Jan Kara , Shrikanth Hegde , Qais Yousef , Aaron Lu , Srikar Dronamraju , Vineeth Remanan Pillai , Ricardo Neri-Calderon , Chen Yu , Lu Wang , Hyunwoo Kim , Zhan Xusheng , Zhan Xusheng , Yi Lai , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org Subject: [PATCH 1/4] sched/cache: Keep nr_pref_llc_running in the runnable domain Date: Thu, 10 Sep 2026 10:46:09 -0700 Message-Id: <82736e1329bf8ed195bbbc4990486c87094e6789.1789061845.git.tim.c.chen@linux.intel.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: References: 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" alb_break_llc() decides whether to break LLC preference during active load balance. It does so by testing that every runnable fair task on the source rq prefers its LLC: env->src_rq->nr_pref_llc_running =3D=3D env->src_rq->cfs.h_nr_runnable But the two counters cover different sets. nr_pref_llc_running is updated in account_llc_enqueue()/account_llc_dequeue(), next to cfs_rq->nr_queued, so it follows queued tasks. h_nr_runnable is updated in set_delayed()/ clear_delayed() and drops delay-dequeued tasks. So under DELAY_DEQUEUE, a preferring task that goes to sleep stays counted in nr_pref_llc_running while h_nr_runnable falls. The equality then breaks, alb_break_llc() returns false, and active balance is free to pull a task off its preferred LLC. Active balance only moves runnable tasks, and this is the only LLC check it consults: once the stopper runs, LBF_ACTIVE_LB skips the per-task test in can_migrate_task(). The runnable set is the one we want. Fix it on the counter side. A task should be counted in nr_pref_llc_running exactly while it is both queued on its preferred LLC (pref_llc_queued) and runnable (!sched_delayed). Define that membership once in task_pref_llc_runnable(), and adjust the counter only through pref_llc_running_inc()/pref_llc_running_dec() from the four sites that change either input: account_llc_enqueue(), account_llc_dequeue(), set_delayed() and clear_delayed(). Gating every update on the same predicate keeps the delay, wake and dequeue paths from double-counting or underflowing; see the comments at those sites for the ordering. nr_llc_running and sd->llc_counts are not touched and stay on queued semantics. Reported-by: Zhan Xusheng Closes: https://lore.kernel.org/lkml/20260827135000.735138-1-zhanxusheng@xi= aomi.com/ Suggested-by: Chen Yu Signed-off-by: Tim Chen Reviewed-by: Kayra Cizmeci --- kernel/sched/fair.c | 52 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 50 insertions(+), 2 deletions(-) diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index d5989b53adef..b1ef013b0342 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -1551,6 +1551,28 @@ static bool invalid_llc_nr(struct mm_struct *mm, str= uct task_struct *p, (scale * per_cpu(sd_llc_size, cpu))); } =20 +/* + * A task counts in nr_pref_llc_running while it is queued on its preferred + * LLC (pref_llc_queued) and runnable (!sched_delayed), keeping the counte= r in + * the runnable domain so alb_break_llc() can compare it with h_nr_runnabl= e. + */ +static bool task_pref_llc_runnable(struct task_struct *p) +{ + return p->pref_llc_queued && !p->se.sched_delayed; +} + +static void pref_llc_running_inc(struct rq *rq, struct task_struct *p) +{ + if (task_pref_llc_runnable(p)) + rq->nr_pref_llc_running++; +} + +static void pref_llc_running_dec(struct rq *rq, struct task_struct *p) +{ + if (task_pref_llc_runnable(p)) + rq->nr_pref_llc_running--; +} + static void account_llc_enqueue(struct rq *rq, struct task_struct *p) { int pref_llc, pref_llc_queued; @@ -1562,7 +1584,6 @@ static void account_llc_enqueue(struct rq *rq, struct= task_struct *p) =20 pref_llc_queued =3D (pref_llc =3D=3D task_llc(p)); rq->nr_llc_running++; - rq->nr_pref_llc_running +=3D pref_llc_queued; =20 /* * Record whether p is enqueued on its preferred @@ -1580,6 +1601,9 @@ static void account_llc_enqueue(struct rq *rq, struct= task_struct *p) */ p->pref_llc_queued =3D pref_llc_queued; =20 + /* Skipped while delayed; clear_delayed() adds it back on wake. */ + pref_llc_running_inc(rq, p); + sd =3D rcu_dereference_all(rq->sd); if (sd && (unsigned int)pref_llc < sd->llc_max) sd->llc_counts[pref_llc]++; @@ -1596,7 +1620,12 @@ static void account_llc_dequeue(struct rq *rq, struc= t task_struct *p) =20 rq->nr_llc_running--; if (p->pref_llc_queued) { - rq->nr_pref_llc_running--; + /* + * Skipped if still delayed (set_delayed() already removed it); + * clearing pref_llc_queued below also stops clear_delayed() + * from re-adding it. + */ + pref_llc_running_dec(rq, p); /* * Update the status in case * other logic might query @@ -2021,6 +2050,10 @@ static void account_llc_enqueue(struct rq *rq, struc= t task_struct *p) {} =20 static void account_llc_dequeue(struct rq *rq, struct task_struct *p) {} =20 +static void pref_llc_running_inc(struct rq *rq, struct task_struct *p) {} + +static void pref_llc_running_dec(struct rq *rq, struct task_struct *p) {} + #endif /* CONFIG_SCHED_CACHE */ =20 /* @@ -6395,6 +6428,14 @@ static __always_inline void return_cfs_rq_runtime(st= ruct cfs_rq *cfs_rq); =20 static void set_delayed(struct sched_entity *se) { + /* + * Drop a task leaving the runnable set. Must run before sched_delayed + * is set, or task_pref_llc_runnable() would already exclude it; + * clear_delayed() mirrors this after clearing the flag. + */ + if (entity_is_task(se)) + pref_llc_running_dec(rq_of(cfs_rq_of(se)), task_of(se)); + se->sched_delayed =3D 1; =20 /* @@ -6425,6 +6466,13 @@ static void clear_delayed(struct sched_entity *se) if (!entity_is_task(se)) return; =20 + /* + * Re-add on wake, after sched_delayed is cleared. On a final delayed + * dequeue account_llc_dequeue() already cleared pref_llc_queued, so + * this does nothing. + */ + pref_llc_running_inc(rq_of(cfs_rq_of(se)), task_of(se)); + for_each_sched_entity(se) { struct cfs_rq *cfs_rq =3D cfs_rq_of(se); =20 --=20 2.32.0 From nobody Fri Sep 25 16:01:28 2026 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.19]) (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 DC0F75111B6; Thu, 10 Sep 2026 17:40:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.175.65.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062064; cv=none; b=gXdysPnHg95r40ewUcVqVRicwBANYYtj9R4W9I22Zpt3gGESkRA0g80SfQxoryA+s1Wv0wVe8WlqOfUDphdEmeJAYSulxL2FnsrxldNoJxif1Z4jwyN3NJ+U2ZhP3UXUwlxUotV0AxgG4nOa/PKy2F6zvbMv93KBOEjH0TBGH2E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062064; c=relaxed/simple; bh=/x/tN7WmmH/4PHrZfpNrj4Si0ibG5LSvyskeb6D3gbU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=K8sep5mg8N1lIO6FF8QzppEF0BrdXcNLGcTOq6T0RyHi+BgJUCGqjnLvpYcQNOwBl+wp/1lFMiDRSix7V1b8Yu1NcKyandYgdjaeYm/awrOHAcNAldmIkjLRLkPGvsRl1rv3aVZr1ddbVye4GUF8i6gIgF09UhiNDXLkYC0EHPY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com; spf=pass smtp.mailfrom=linux.intel.com; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b=Of4wpspE; arc=none smtp.client-ip=198.175.65.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b="Of4wpspE" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1789062057; x=1820598057; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=/x/tN7WmmH/4PHrZfpNrj4Si0ibG5LSvyskeb6D3gbU=; b=Of4wpspEOvN66naMbEEI3uAzjSqHZJIAhansykcayEwuwSde4AR1e+EP owuUrqBvqgCIYbtzYwIHYKo2oVVoneKuGHimzWDGWwNYE6l4MwF0CgViC 9jGwDALgdnS3WGWE9Sp5AMXP77wFYRpYCtB6c993Y5PnDtT4ulrLv2cQo LMactqJGDV/XB0fdcmJDDuwPqvnPdZh9+BAK8DLPFbS/KBhozAikst0ND qIrU0yg3juigO+ifMMaYaGEa1hO5MrWH26YeMPt4NvzM+qT4GlI4xtDNB No01m/rca/g/BZKcVI2JadVrTdFdayi7cOX0Dutm2QrGijgAX9ligGj/k A==; X-CSE-ConnectionGUID: W8RRPW0nSTixucnbstcWiA== X-CSE-MsgGUID: xH1BWo6YTyGCULFStck2DQ== X-IronPort-AV: E=McAfee;i="6800,10657,11901"; a="89453806" X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="89453806" Received: from orviesa003.jf.intel.com ([10.64.159.143]) by orvoesa111.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Sep 2026 10:40:51 -0700 X-CSE-ConnectionGUID: e+BP3wmrSN2jUJdv9UnRHQ== X-CSE-MsgGUID: hO178K8CTNel8PY+P6Q4jQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="275222018" Received: from b04f130c83f2.jf.intel.com ([10.165.154.98]) by orviesa003.jf.intel.com with ESMTP; 10 Sep 2026 10:40:51 -0700 From: Tim Chen To: Peter Zijlstra , Ingo Molnar Cc: Lu Wang , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Valentin Schneider , K Prateek Nayak , Kees Cook , Christian Brauner , Alexander Viro , Jan Kara , Shrikanth Hegde , Qais Yousef , Aaron Lu , Srikar Dronamraju , Vineeth Remanan Pillai , Ricardo Neri-Calderon , Chen Yu , Hyunwoo Kim , Zhan Xusheng , Zhan Xusheng , Yi Lai , Tim Chen , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org Subject: [PATCH 2/4] sched/cache: Honor migrate_llc_task semantics in active load balance Date: Thu, 10 Sep 2026 10:46:10 -0700 Message-Id: <4c921888d81e4a7eefa14322bf04058a1a30f4e9.1789061845.git.tim.c.chen@linux.intel.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: References: 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" From: Lu Wang CAS introduced the migrate_llc_task migration type to direct tasks toward their preferred LLC, but its semantics can be lost when passive load balance falls back to active load balance. This may allow ALB to select a candidate whose preferred LLC does not match the destination, moving it away from its preferred LLC. Example scenario: src_rq has two runnable tasks, p1 and p2. p1 prefers dst_rq (dst_llc), while p2 prefers src_rq (src_llc). In this case, migrate_llc_task is set because src_rq has at least one task, p1, that wants to migrate to dst_rq. In ALB, can_migrate_task() finds p2 and returns true for it, thus moving p2 out of its preferred LLC. Solution: The CPU stopper in ALB constructs a fresh lb_env that does not inherit migration_type from the passive load-balance pass. Two approaches are possible: (a) Add a new member to struct rq so ALB can inherit migrate_llc_task from the passive LB that triggered it. (b) Define a new flag LBF_ACTIVE_LB_LLC and select the stopper callback at kick time to preserve the migration semantics across the asynchronous boundary. We choose (b) because it avoids passing migration_type through the stopper, which would affect the meaning of migration_type for delayed-dequeue tasks. Fixes: e4c9a4cb244a ("sched/cache: Add migrate_llc_task migration type for = cache-aware balancing") Suggested-by: "Chen, Yu C" Reviewed-by: Tim Chen Reviewed-by: Chen Yu Signed-off-by: Lu Wang Signed-off-by: Tim Chen --- kernel/sched/fair.c | 57 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 51 insertions(+), 6 deletions(-) diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index b1ef013b0342..32213801ea39 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -10448,6 +10448,7 @@ enum migration_type { #define LBF_SOME_PINNED 0x08 #define LBF_ACTIVE_LB 0x10 #define LBF_LLC_PINNED 0x20 +#define LBF_ACTIVE_LB_LLC 0x40 =20 struct lb_env { struct sched_domain *sd; @@ -10866,6 +10867,21 @@ alb_break_llc(struct lb_env *env) return false; } =20 +/* + * Returns true if p's preferred LLC does not match the destination CPU + * under migrate_llc_task semantics. Passive LB passes migrate_llc_task + * in env->migration_type, while active LB carries LBF_ACTIVE_LB_LLC in + * env->flags to avoid overwriting env->migration_type. + */ +static inline bool +migrate_llc_task_wrong_dst(struct task_struct *p, struct lb_env *env) +{ + return sched_cache_enabled() && + (env->migration_type =3D=3D migrate_llc_task || + env->flags & LBF_ACTIVE_LB_LLC) && + READ_ONCE(p->preferred_llc) !=3D llc_id(env->dst_cpu); +} + /* * Check if migrating task p from env->src_cpu to * env->dst_cpu breaks LLC localiy. @@ -10894,8 +10910,7 @@ static bool migrate_degrades_llc(struct task_struct= *p, struct lb_env *env) * run on env->dst_cpu, skip the tasks do not prefer * env->dst_cpu, and find the one that prefers. */ - if (env->migration_type =3D=3D migrate_llc_task && - READ_ONCE(p->preferred_llc) !=3D llc_id(env->dst_cpu)) + if (migrate_llc_task_wrong_dst(p, env)) return true; =20 if (can_migrate_llc_task(env, p) !=3D mig_forbid) @@ -10917,6 +10932,12 @@ alb_break_llc(struct lb_env *env) return false; } =20 +static inline bool +migrate_llc_task_wrong_dst(struct task_struct *p, struct lb_env *env) +{ + return false; +} + static inline bool migrate_degrades_llc(struct task_struct *p, struct lb_env *env) { @@ -11016,7 +11037,7 @@ int can_migrate_task(struct task_struct *p, struct = lb_env *env) * 4) too many balance attempts have failed. */ if (env->flags & LBF_ACTIVE_LB) - return 1; + return !migrate_llc_task_wrong_dst(p, env); =20 degrades =3D migrate_degrades_locality(p, env); if (!degrades) { @@ -13415,6 +13436,20 @@ static int need_active_balance(struct lb_env *env) } =20 static int active_load_balance_cpu_stop(void *data); +static int active_load_balance_llc_cpu_stop(void *data); + +/* + * migration_type is checked elsewhere to decide migration policy, so + * it shouldn't be repurposed just to flag an LLC-directed active + * balance across the stopper. Pick the callback here instead. + */ +static inline cpu_stop_fn_t alb_stop_fn(struct lb_env *env) +{ + if (env->migration_type =3D=3D migrate_llc_task) + return active_load_balance_llc_cpu_stop; + + return active_load_balance_cpu_stop; +} =20 static int should_we_balance(struct lb_env *env) { @@ -13760,7 +13795,7 @@ static int sched_balance_rq(int this_cpu, struct rq= *this_rq, } if (active_balance) { stop_one_cpu_nowait(cpu_of(busiest), - active_load_balance_cpu_stop, busiest, + alb_stop_fn(&env), busiest, &busiest->active_balance_work); } preempt_enable(); @@ -13865,7 +13900,7 @@ update_next_balance(struct sched_domain *sd, unsign= ed long *next_balance) * least 1 task to be running on each physical CPU where possible, and * avoids physical / logical imbalances. */ -static int active_load_balance_cpu_stop(void *data) +static int __active_load_balance_cpu_stop(void *data, unsigned int lb_flag= s) { struct rq *busiest_rq =3D data; int busiest_cpu =3D cpu_of(busiest_rq); @@ -13915,7 +13950,7 @@ static int active_load_balance_cpu_stop(void *data) .src_cpu =3D busiest_rq->cpu, .src_rq =3D busiest_rq, .idle =3D CPU_IDLE, - .flags =3D LBF_ACTIVE_LB, + .flags =3D LBF_ACTIVE_LB | lb_flags, }; =20 schedstat_inc(sd->alb_count); @@ -13943,6 +13978,16 @@ static int active_load_balance_cpu_stop(void *data) return 0; } =20 +static int active_load_balance_cpu_stop(void *data) +{ + return __active_load_balance_cpu_stop(data, 0); +} + +static int active_load_balance_llc_cpu_stop(void *data) +{ + return __active_load_balance_cpu_stop(data, LBF_ACTIVE_LB_LLC); +} + /* * Scale the max sched_balance_rq interval with the number of CPUs in the = system. * This trades load-balance latency on larger machines for less cross talk. --=20 2.32.0 From nobody Fri Sep 25 16:01:28 2026 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.19]) (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 BF947565118; Thu, 10 Sep 2026 17:41:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.175.65.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062073; cv=none; b=t/Qc8WU1V+eohnRA67yOE6m6LJ+lGD+ki6FX69+K6BR8Vf8T0MuGcJZJdFlCPGlbU+c6VG45JIirA+BSTj6kN939TkO8KjbYPiVtQ56ofcb2awAX+7Z9msBbFkIaZLfTxAzJBq/E3fpV486U75ty7OfqW5RjC5JZpYdJcPKMs54= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062073; c=relaxed/simple; bh=dc2RMLeUehLuIVfyB7SwlY7vmORAF8TywZmeXgYir0k=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=EE9bzLHrhRZ9FqvrhOaABF54RrRmEuF59MMAmODdZzbYrb1sk3uLTGrJs1NYZQ7cczbS2w0Ma7b4tWotLr1DMWtG4FCPYdjQJrzibH+S6VuYAvJbetBm/l3ubA93UOEyJ0qYrT8jBK81Gtu7MDrfJX1AY+0Mrs6rqc/ORanECp8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com; spf=pass smtp.mailfrom=linux.intel.com; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b=WOx0cdkb; arc=none smtp.client-ip=198.175.65.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b="WOx0cdkb" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1789062066; x=1820598066; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=dc2RMLeUehLuIVfyB7SwlY7vmORAF8TywZmeXgYir0k=; b=WOx0cdkbbG3N3PoeZiFP8fg9bx0xgVhJ2q6sgEZQp+QMzkTbwPnscpsr S2KmI+Y7T2qSJjBM6d2f0Tc1D12Ybmf+DaNZjh1zfW7ILwzgWCTMLNZH9 BVXWXG7JSZc6eW4JMndoPgpp4Q2FF1XQtayprl+xPLE9PSc+ZssDrpmKn 8eLbFelMZ7/BOugSlap6Dz596I+km/ezhxyhX8yQqXws/hikw8pNXQFU7 pA5drZUF4LJY9t/E0A+NN1H/LdG75UOccfhQ5B9dBZcIeHjnKoBXswQPg deyFBOBUk7QjKoeMQig3U+HlXjCQW0fgCpOzcyKMFwO8C5Z0JdK9YEM7g A==; X-CSE-ConnectionGUID: 58BTVDJwQhaLIJIUZvM0fw== X-CSE-MsgGUID: 1sKntH/YRj6dloWx8K9lXg== X-IronPort-AV: E=McAfee;i="6800,10657,11901"; a="89453824" X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="89453824" Received: from orviesa003.jf.intel.com ([10.64.159.143]) by orvoesa111.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Sep 2026 10:40:52 -0700 X-CSE-ConnectionGUID: rmltQ60YQxmnoyF6tpw5lA== X-CSE-MsgGUID: Iax3Joh0TFeIm2CtQ2sinQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="275222021" Received: from b04f130c83f2.jf.intel.com ([10.165.154.98]) by orviesa003.jf.intel.com with ESMTP; 10 Sep 2026 10:40:51 -0700 From: Tim Chen To: Peter Zijlstra , Ingo Molnar Cc: Tim Chen , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Valentin Schneider , K Prateek Nayak , Kees Cook , Christian Brauner , Alexander Viro , Jan Kara , Shrikanth Hegde , Qais Yousef , Aaron Lu , Srikar Dronamraju , Vineeth Remanan Pillai , Ricardo Neri-Calderon , Chen Yu , Lu Wang , Hyunwoo Kim , Zhan Xusheng , Zhan Xusheng , Yi Lai , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org Subject: [PATCH 3/4] sched/cache: Decouple sched_cache_group from mm Date: Thu, 10 Sep 2026 10:46:11 -0700 Message-Id: X-Mailer: git-send-email 2.32.0 In-Reply-To: References: 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 sched cache grouping is by mm and the scheduling statistics sched_cache_stat lives in the mm structure. This ties the life cycle of scheduling stats with mm. In account_mm_sched(), the scheduling stats are accessed by task->mm->sc_stat. However, a task may be switching mm on one CPU when another CPU is running account_mm_sched(), and possibly accessing the old mm that was freed. This problem was found when running tests with KASAN by Hyunwoo. https://lore.kernel.org/lkml/apPb-Dr4nPYuHQOK@v4bel/ Instead of serializing the mm access by introducing extra acquisition of rq lock in the mm free path, extract sched_cache_stat from mm_struct, rename it as sched_cache_group and manage its life cycle apart from mm_struct with its own ref counting. This allows us in the next patch access sched_cache_group directly from task, and add a refcount on sched_cache_group when a task links to it. This prevents the use after free issue when accessing stale and released old mm and its sched cache stat a task switches to a new mm while account_mm_sched() is done elsewhere. The other benefit of this restructure is in the future, the grouping of tasks to a LLC would have the flexibility to be associated with a user defined grouping, or cgroup, cookie group, numa_group or others instead of just with a single mm address space. Rename sched_cache_stat to sched_cache_group and turn it into a refcounted object allocated from mm_struct. The mm_struct now holds a pointer (sched_cache_grp) to this object instead of embedding it. Introduce kernel/sched/cache_sched.c to host the cache aware scheduling helpers and define sched_cache_group_put() there. Meanwhile skip kthreads in account_mm_sched(), consistent with task_tick_cache(). Reported-by: Hyunwoo Kim Closes: https://lore.kernel.org/lkml/apPb-Dr4nPYuHQOK@v4bel/ Tested-by: Hyunwoo Kim Fixes: df0d98475954 ("sched/cache: Introduce infrastructure for cache-aware= load balancing") Co-developed-by: Chen Yu Signed-off-by: Chen Yu Signed-off-by: Tim Chen --- include/linux/mm_types.h | 15 ++--- include/linux/sched.h | 8 ++- kernel/exit.c | 6 +- kernel/sched/build_utility.c | 4 ++ kernel/sched/cache_sched.c | 20 ++++++ kernel/sched/fair.c | 118 ++++++++++++++++++++++------------- 6 files changed, 113 insertions(+), 58 deletions(-) create mode 100644 kernel/sched/cache_sched.c diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h index 6d815f6440c9..f3e5a2fadbe5 100644 --- a/include/linux/mm_types.h +++ b/include/linux/mm_types.h @@ -1226,7 +1226,7 @@ struct mm_struct { struct mm_mm_cid mm_cid; =20 /* sched_cache related statistics */ - struct sched_cache_stat sc_stat; + struct sched_cache_group *sched_cache_grp; #ifdef CONFIG_MMU atomic_long_t pgtables_bytes; /* size of all page tables */ #endif @@ -1624,8 +1624,9 @@ static inline unsigned int mm_cid_size(void) #endif /* CONFIG_SCHED_MM_CID */ =20 #ifdef CONFIG_SCHED_CACHE -void mm_init_sched(struct mm_struct *mm, - struct sched_cache_time __percpu *pcpu_sched); +int mm_init_sched(struct mm_struct *mm, + struct sched_cache_time __percpu *pcpu_sched); +void mm_destroy_sched(struct mm_struct *mm); =20 static inline int mm_alloc_sched_noprof(struct mm_struct *mm) { @@ -1635,17 +1636,11 @@ static inline int mm_alloc_sched_noprof(struct mm_s= truct *mm) if (!pcpu_sched) return -ENOMEM; =20 - mm_init_sched(mm, pcpu_sched); - return 0; + return mm_init_sched(mm, pcpu_sched); } =20 #define mm_alloc_sched(...) alloc_hooks(mm_alloc_sched_noprof(__VA_ARGS__)) =20 -static inline void mm_destroy_sched(struct mm_struct *mm) -{ - free_percpu(mm->sc_stat.pcpu_sched); - mm->sc_stat.pcpu_sched =3D NULL; -} #else /* !CONFIG_SCHED_CACHE */ =20 static inline int mm_alloc_sched(struct mm_struct *mm) { return 0; } diff --git a/include/linux/sched.h b/include/linux/sched.h index 8b3d47a325cc..1f254364f216 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -2405,7 +2405,7 @@ struct sched_cache_time { unsigned long epoch; }; =20 -struct sched_cache_stat { +struct sched_cache_group { struct sched_cache_time __percpu *pcpu_sched; raw_spinlock_t lock; unsigned long epoch; @@ -2413,11 +2413,15 @@ struct sched_cache_stat { unsigned long next_scan; unsigned long footprint; int cpu; + refcount_t refcnt; + struct rcu_head rcu; } ____cacheline_aligned_in_smp; =20 +void sched_cache_group_put(struct sched_cache_group *grp); + #else =20 -struct sched_cache_stat { }; +struct sched_cache_group { }; =20 #endif =20 diff --git a/kernel/exit.c b/kernel/exit.c index 97686af89501..006edcc0c2c5 100644 --- a/kernel/exit.c +++ b/kernel/exit.c @@ -560,12 +560,12 @@ static void exit_mm_sched_cache(struct mm_struct *mm) return; /* * No lock protection due to performance considerations. - * Make sure mm->sc_stat.footprint does not become + * Make sure the group footprint does not become * negative. */ - fp =3D READ_ONCE(mm->sc_stat.footprint); + fp =3D READ_ONCE(mm->sched_cache_grp->footprint); sub =3D min(fp, current->total_numa_faults); - WRITE_ONCE(mm->sc_stat.footprint, fp - sub); + WRITE_ONCE(mm->sched_cache_grp->footprint, fp - sub); } #else static inline void exit_mm_sched_cache(struct mm_struct *mm) diff --git a/kernel/sched/build_utility.c b/kernel/sched/build_utility.c index e2cf3b08d4e9..24202893b262 100644 --- a/kernel/sched/build_utility.c +++ b/kernel/sched/build_utility.c @@ -89,6 +89,10 @@ # include "core_sched.c" #endif =20 +#ifdef CONFIG_SCHED_CACHE +# include "cache_sched.c" +#endif + #ifdef CONFIG_PSI # include "psi.c" #endif diff --git a/kernel/sched/cache_sched.c b/kernel/sched/cache_sched.c new file mode 100644 index 000000000000..d492df55f9d5 --- /dev/null +++ b/kernel/sched/cache_sched.c @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include "sched.h" + +static void sched_cache_group_free_rcu(struct rcu_head *rcu) +{ + struct sched_cache_group *grp =3D + container_of(rcu, struct sched_cache_group, rcu); + + /* free_percpu() may be called from atomic context. */ + free_percpu(grp->pcpu_sched); + kfree(grp); +} + +void sched_cache_group_put(struct sched_cache_group *grp) +{ + if (!grp || !refcount_dec_and_test(&grp->refcnt)) + return; + + call_rcu(&grp->rcu, sched_cache_group_free_rcu); +} diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 32213801ea39..b5a823f0a622 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -1502,7 +1502,7 @@ static bool exceed_llc_capacity(struct mm_struct *mm,= int cpu) * excluded. */ llc =3D sd->llc_bytes; - footprint =3D READ_ONCE(mm->sc_stat.footprint); + footprint =3D READ_ONCE(mm->sched_cache_grp->footprint); =20 /* * Scale the LLC size by 256*llc_aggr_tolerance @@ -1547,7 +1547,7 @@ static bool invalid_llc_nr(struct mm_struct *mm, stru= ct task_struct *p, if (scale =3D=3D INT_MAX) return false; =20 - return !fits_capacity((mm->sc_stat.nr_running_avg * cpu_smt_num_threads), + return !fits_capacity((mm->sched_cache_grp->nr_running_avg * cpu_smt_num_= threads), (scale * per_cpu(sd_llc_size, cpu))); } =20 @@ -1653,12 +1653,20 @@ static void account_llc_dequeue(struct rq *rq, stru= ct task_struct *p) } } =20 -void mm_init_sched(struct mm_struct *mm, - struct sched_cache_time __percpu *_pcpu_sched) +int mm_init_sched(struct mm_struct *mm, + struct sched_cache_time __percpu *_pcpu_sched) { + struct sched_cache_group *grp; unsigned long epoch =3D 0; int i; =20 + grp =3D kzalloc_obj(*grp); + if (!grp) { + free_percpu(_pcpu_sched); + mm->sched_cache_grp =3D NULL; + return -ENOMEM; + } + for_each_possible_cpu(i) { struct sched_cache_time *pcpu_sched =3D per_cpu_ptr(_pcpu_sched, i); struct rq *rq =3D cpu_rq(i); @@ -1669,18 +1677,35 @@ void mm_init_sched(struct mm_struct *mm, epoch =3D rq->cpu_epoch; } =20 - raw_spin_lock_init(&mm->sc_stat.lock); - mm->sc_stat.epoch =3D epoch; - mm->sc_stat.cpu =3D -1; - mm->sc_stat.next_scan =3D jiffies; - mm->sc_stat.nr_running_avg =3D 0; - mm->sc_stat.footprint =3D 0; + raw_spin_lock_init(&grp->lock); + grp->epoch =3D epoch; + grp->cpu =3D -1; + grp->next_scan =3D jiffies; + grp->nr_running_avg =3D 0; + grp->footprint =3D 0; + refcount_set(&grp->refcnt, 1); /* - * The update to mm->sc_stat should not be reordered - * before initialization to mm's other fields, in case + * The update to grp->pcpu_sched should not be reordered + * before initialization to grp's other fields, in case * the readers may get invalid mm_sched_epoch, etc. */ - smp_store_release(&mm->sc_stat.pcpu_sched, _pcpu_sched); + smp_store_release(&grp->pcpu_sched, _pcpu_sched); + /* + * Publish the group last. Not every reader qualifies it by + * grp->pcpu_sched - can_migrate_llc_task() only checks that the + * pointer is non-NULL before reading grp->footprint and + * grp->nr_running_avg - so a reachable group must already be + * fully initialized. + */ + mm->sched_cache_grp =3D grp; + return 0; +} + +void mm_destroy_sched(struct mm_struct *mm) +{ + if (mm->sched_cache_grp) + sched_cache_group_put(mm->sched_cache_grp); + mm->sched_cache_grp =3D NULL; } =20 /* because why would C be fully specified */ @@ -1738,7 +1763,7 @@ static int get_pref_llc(struct task_struct *p, struct= mm_struct *mm) if (!mm) return -1; =20 - mm_sched_cpu =3D READ_ONCE(mm->sc_stat.cpu); + mm_sched_cpu =3D READ_ONCE(mm->sched_cache_grp->cpu); if (mm_sched_cpu !=3D -1) { mm_sched_llc =3D llc_id(mm_sched_cpu); =20 @@ -1781,11 +1806,15 @@ void account_mm_sched(struct rq *rq, struct task_st= ruct *p, s64 delta_exec) /* * init_task, kthreads and user thread created * by user_mode_thread() don't have mm. + * + * A kthread can temporarily adopt an mm via kthread_use_mm(), + * so p->mm alone does not imply a user task. */ - if (!mm || !mm->sc_stat.pcpu_sched) + if (!mm || p->flags & PF_KTHREAD || !mm->sched_cache_grp || + !mm->sched_cache_grp->pcpu_sched) return; =20 - pcpu_sched =3D per_cpu_ptr(mm->sc_stat.pcpu_sched, cpu_of(rq)); + pcpu_sched =3D per_cpu_ptr(mm->sched_cache_grp->pcpu_sched, cpu_of(rq)); =20 scoped_guard (raw_spinlock, &rq->cpu_epoch_lock) { __update_mm_sched(rq, pcpu_sched); @@ -1798,11 +1827,11 @@ void account_mm_sched(struct rq *rq, struct task_st= ruct *p, s64 delta_exec) * If this process hasn't hit task_cache_work() for a while invalidate * its preferred state. */ - if ((long)(epoch - READ_ONCE(mm->sc_stat.epoch)) > llc_epoch_affinity_tim= eout || + if ((long)(epoch - READ_ONCE(mm->sched_cache_grp->epoch)) > llc_epoch_aff= inity_timeout || invalid_llc_nr(mm, p, cpu_of(rq)) || exceed_llc_capacity(mm, cpu_of(rq))) { - if (READ_ONCE(mm->sc_stat.cpu) !=3D -1) - WRITE_ONCE(mm->sc_stat.cpu, -1); + if (READ_ONCE(mm->sched_cache_grp->cpu) !=3D -1) + WRITE_ONCE(mm->sched_cache_grp->cpu, -1); } =20 mm_sched_llc =3D get_pref_llc(p, mm); @@ -1826,19 +1855,19 @@ static void task_tick_cache(struct rq *rq, struct t= ask_struct *p) return; =20 if (!mm || p->flags & PF_KTHREAD || - !mm->sc_stat.pcpu_sched) + !mm->sched_cache_grp->pcpu_sched) return; =20 epoch =3D rq->cpu_epoch; /* avoid moving backwards */ - if (time_after_eq(mm->sc_stat.epoch, epoch)) + if (time_after_eq(mm->sched_cache_grp->epoch, epoch)) return; =20 - guard(raw_spinlock)(&mm->sc_stat.lock); + guard(raw_spinlock)(&mm->sched_cache_grp->lock); =20 if (work->next =3D=3D work) { task_work_add(p, work, TWA_RESUME); - WRITE_ONCE(mm->sc_stat.epoch, epoch); + WRITE_ONCE(mm->sched_cache_grp->epoch, epoch); } } =20 @@ -1850,7 +1879,7 @@ static void get_scan_cpumasks(cpumask_var_t cpus, str= uct task_struct *p) if (!static_branch_likely(&sched_numa_balancing)) goto out; =20 - cpu =3D READ_ONCE(p->mm->sc_stat.cpu); + cpu =3D READ_ONCE(p->mm->sched_cache_grp->cpu); if (cpu !=3D -1) nid =3D cpu_to_node(cpu); curr_cpu =3D task_cpu(p); @@ -1922,12 +1951,12 @@ static void task_cache_work(struct callback_head *w= ork) if (p->flags & PF_EXITING) return; =20 - next_scan =3D READ_ONCE(mm->sc_stat.next_scan); + next_scan =3D READ_ONCE(mm->sched_cache_grp->next_scan); if (time_before(now, next_scan)) return; =20 /* only 1 thread is allowed to scan */ - if (!try_cmpxchg(&mm->sc_stat.next_scan, &next_scan, + if (!try_cmpxchg(&mm->sched_cache_grp->next_scan, &next_scan, now + max_t(unsigned long, READ_ONCE(llc_epoch_period), 1))) return; @@ -1935,8 +1964,8 @@ static void task_cache_work(struct callback_head *wor= k) curr_cpu =3D task_cpu(p); if (invalid_llc_nr(mm, p, curr_cpu) || exceed_llc_capacity(mm, curr_cpu)) { - if (READ_ONCE(mm->sc_stat.cpu) !=3D -1) - WRITE_ONCE(mm->sc_stat.cpu, -1); + if (READ_ONCE(mm->sched_cache_grp->cpu) !=3D -1) + WRITE_ONCE(mm->sched_cache_grp->cpu, -1); =20 return; } @@ -1959,8 +1988,10 @@ static void task_cache_work(struct callback_head *wo= rk) continue; =20 for_each_cpu(i, sched_domain_span(sd)) { + struct sched_cache_group *grp =3D mm->sched_cache_grp; + occ =3D fraction_mm_sched(cpu_rq(i), - per_cpu_ptr(mm->sc_stat.pcpu_sched, i)); + per_cpu_ptr(grp->pcpu_sched, i)); a_occ +=3D occ; if (occ > m_occ) { m_occ =3D occ; @@ -1993,7 +2024,7 @@ static void task_cache_work(struct callback_head *wor= k) m_a_cpu =3D m_cpu; } =20 - if (llc_id(cpu) =3D=3D llc_id(READ_ONCE(mm->sc_stat.cpu))) + if (llc_id(cpu) =3D=3D llc_id(READ_ONCE(mm->sched_cache_grp->cpu))) curr_m_a_occ =3D a_occ; =20 cpumask_andnot(cpus, cpus, sched_domain_span(sd)); @@ -2002,7 +2033,7 @@ static void task_cache_work(struct callback_head *wor= k) =20 if (m_a_occ > (2 * curr_m_a_occ)) { /* - * Avoid switching sc_stat.cpu too fast. + * Avoid switching sched_cache_grp->cpu too fast. * The reason to choose 2X is because: * 1. It is better to keep the preferred LLC stable, * rather than changing it frequently and cause migrations @@ -2011,10 +2042,10 @@ static void task_cache_work(struct callback_head *w= ork) * 3. 2X is chosen based on test results, as it delivers * the optimal performance gain so far. */ - WRITE_ONCE(mm->sc_stat.cpu, m_a_cpu); + WRITE_ONCE(mm->sched_cache_grp->cpu, m_a_cpu); } =20 - update_avg_scale(&mm->sc_stat.nr_running_avg, nr_running); + update_avg_scale(&mm->sched_cache_grp->nr_running_avg, nr_running); free_cpumask_var(cpus); } =20 @@ -3822,18 +3853,19 @@ static void task_numa_placement(struct task_struct = *p) * heuristic and occasional lost updates are tolerable. * * If a task exits, its corresponding footprint must - * be subtracted from the mm->sc_stat.footprint, otherwise - * the mm->sc_stat.footprint will not converge: - * the exiting thread's footprint remains unchanged/undecayed - * in mm->sc_stat.footprint. See exit_mm(). + * be subtracted from the mm->sched_cache_grp->footprint, + * otherwise the mm->sched_cache_grp->footprint will not + * converge: the exiting thread's footprint remains + * unchanged/undecayed in mm->sched_cache_grp->footprint. + * See exit_mm(). * * Lost updates and unsynchronized subtraction * in exit_mm() can cause footprint + diff to * go negative. Clamp to zero to prevent the * unsigned footprint from wrapping. */ - new_fp =3D (long)READ_ONCE(p->mm->sc_stat.footprint) + diff; - WRITE_ONCE(p->mm->sc_stat.footprint, + new_fp =3D (long)READ_ONCE(p->mm->sched_cache_grp->footprint) + diff; + WRITE_ONCE(p->mm->sched_cache_grp->footprint, max(new_fp, 0L)); #endif } @@ -10788,18 +10820,18 @@ static enum llc_mig can_migrate_llc_task(struct l= b_env *env, src_cpu =3D env->src_cpu; dst_cpu =3D env->dst_cpu; mm =3D p->mm; - if (!mm) + if (!mm || !mm->sched_cache_grp) return mig_unrestricted; =20 - cpu =3D READ_ONCE(mm->sc_stat.cpu); + cpu =3D READ_ONCE(mm->sched_cache_grp->cpu); if (cpu < 0 || cpus_share_cache(src_cpu, dst_cpu)) return mig_unrestricted; =20 /* skip cache aware load balance for too many threads */ if (invalid_llc_nr(mm, p, dst_cpu) || exceed_llc_capacity(mm, dst_cpu)) { - if (READ_ONCE(mm->sc_stat.cpu) !=3D -1) - WRITE_ONCE(mm->sc_stat.cpu, -1); + if (READ_ONCE(mm->sched_cache_grp->cpu) !=3D -1) + WRITE_ONCE(mm->sched_cache_grp->cpu, -1); return mig_unrestricted; } =20 --=20 2.32.0 From nobody Fri Sep 25 16:01:28 2026 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.19]) (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 8D1C157D211; Thu, 10 Sep 2026 17:41:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=198.175.65.19 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062077; cv=none; b=d6BDcH8/NyM11I+S6gve2kdRsjOfnjRZ/qL4BK+/iU5ZSa7aCa5YxBMuhTrJ/gB2Tosad2z/gahJ2l0eer/PCkb9hiAFNOLrkpvz01/KyQA3c/otEN/JeEwJGVvaHyehcGBpPOVrfBdwcj2vO2wbeGvkWgyH8z4iDENRnPkC9pE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789062077; c=relaxed/simple; bh=W/pI4hTTfxyMkrIZX8ZwYEyYg5lb1ZUW7C0sBU/8BTY=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=pAszVYBawuEZQ35bkXdx+SFTVtpB9zmD1DiDuM1hI5dKDwROddfRBWGRDqCd4gQFZY/fsoyQqzqIHxNHfZNKLQ9BfCm+uwvbmErOHlsI3Z3an1P02LgjZ+SQtMdVifgQT9aKwQlsgD04TQOvZ0Bz+udL/21WE5RgF1CBhxCpaBo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com; spf=pass smtp.mailfrom=linux.intel.com; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b=IrohzmoJ; arc=none smtp.client-ip=198.175.65.19 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b="IrohzmoJ" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1789062067; x=1820598067; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=W/pI4hTTfxyMkrIZX8ZwYEyYg5lb1ZUW7C0sBU/8BTY=; b=IrohzmoJZPC8y92KEjL+tEAd2OyRMaNuGkZcfRabfsvwf+or972Zw/Rj dUCD9WI9Dq7Ai6kaaOn1bUlR8gCREIu6X7I23SLGTvpr62im8VRGbDIUZ MJB6c0BMeh/AyjHETs2eA1VBc1us1w3w6rmyLEV3KBrMOQva2nerxLnGk qenYsGoeXWH+1cDfYTCXhIYk63RH0dDI1HAtobSzZn8xN12h4qe/RHfGP FW08tmu5QlA7JTeRyH7IfL/ugSfSX/uasaELW6hzk91WABK5ifuG9Z4fn bpcyPp7pVa6IU0fmhPMqlR/ahPnqOhiFKfX02Qwzo/sWiKU+hS+hU5y77 A==; X-CSE-ConnectionGUID: dsQGJNWxSduMUUgXGuV3AA== X-CSE-MsgGUID: 9f5mT+d6ScGJRH4LDQSVmg== X-IronPort-AV: E=McAfee;i="6800,10657,11901"; a="89453844" X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="89453844" Received: from orviesa003.jf.intel.com ([10.64.159.143]) by orvoesa111.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Sep 2026 10:40:52 -0700 X-CSE-ConnectionGUID: 6uQBSPgeTyGTOUUc6ZJn3w== X-CSE-MsgGUID: o7jgm3nbS5SyroIxV1zu3A== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.27,95,1787036400"; d="scan'208";a="275222027" Received: from b04f130c83f2.jf.intel.com ([10.165.154.98]) by orviesa003.jf.intel.com with ESMTP; 10 Sep 2026 10:40:52 -0700 From: Tim Chen To: Peter Zijlstra , Ingo Molnar Cc: Tim Chen , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Valentin Schneider , K Prateek Nayak , Kees Cook , Christian Brauner , Alexander Viro , Jan Kara , Shrikanth Hegde , Qais Yousef , Aaron Lu , Srikar Dronamraju , Vineeth Remanan Pillai , Ricardo Neri-Calderon , Chen Yu , Lu Wang , Hyunwoo Kim , Zhan Xusheng , Zhan Xusheng , Yi Lai , linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org Subject: [PATCH 4/4] sched/cache: Introduce task_struct->sched_cache_grp Date: Thu, 10 Sep 2026 10:46:12 -0700 Message-Id: <4532ec4fd5beb829bccb85822a19360fa4191fe6.1789061845.git.tim.c.chen@linux.intel.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: References: 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" Add a sched_cache_grp pointer to task_struct so that scheduler code can access the cache group directly via the task, without going through mm->sched_cache_grp. This decouples the scheduler's hot-path accesses from the mm_struct. Each task holds its own refcount on the sched_cache_group, separate from the reference held by its mm_struct. The reference is acquired in copy_mm() (fork) and exec_mmap() (exec), and released in exit_mm(). This fixes use after free problem when accessing sched_cache_grp in account_mm_sched() via mm as reported in https://lore.kernel.org/lkml/apPb-Dr4nPYuHQOK@v4bel/ Convert all scheduler code in fair.c and exit.c to use p->sched_cache_grp instead of p->mm->sched_cache_grp. Add sched_cache_group_get() to kernel/sched/cache_sched.c. Reported-by: Hyunwoo Kim Closes: https://lore.kernel.org/lkml/apPb-Dr4nPYuHQOK@v4bel/ Tested-by: Hyunwoo Kim Fixes: df0d98475954 ("sched/cache: Introduce infrastructure for cache-aware= load balancing") Co-developed-by: Chen Yu Signed-off-by: Chen Yu Signed-off-by: Tim Chen --- fs/exec.c | 14 ++++ include/linux/sched.h | 3 + kernel/exit.c | 26 +++++-- kernel/fork.c | 23 ++++++ kernel/sched/cache_sched.c | 19 +++++ kernel/sched/fair.c | 142 +++++++++++++++++++++---------------- kernel/sched/sched.h | 3 + 7 files changed, 164 insertions(+), 66 deletions(-) diff --git a/fs/exec.c b/fs/exec.c index 745f6eb5279e..7a8a9954343e 100644 --- a/fs/exec.c +++ b/fs/exec.c @@ -882,6 +882,20 @@ static int exec_mmap(struct linux_binprm *bprm) active_mm =3D tsk->active_mm; tsk->active_mm =3D mm; tsk->mm =3D mm; +#ifdef CONFIG_SCHED_CACHE + { + struct sched_cache_group *old_grp, *new_grp; + + old_grp =3D rcu_dereference_protected(tsk->sched_cache_grp, true); + + /* Acquire the reference before publishing the pointer. */ + new_grp =3D sched_cache_group_get(mm->sched_cache_grp); + + rcu_assign_pointer(tsk->sched_cache_grp, new_grp); + if (old_grp) + sched_cache_group_put(old_grp); + } +#endif mm_init_cid(mm, tsk); exec_state =3D task_exec_state_replace(tsk, exec_state); /* diff --git a/include/linux/sched.h b/include/linux/sched.h index 1f254364f216..cab8e89b1462 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -1434,6 +1434,7 @@ struct task_struct { #ifdef CONFIG_SCHED_CACHE struct callback_head cache_work; int preferred_llc; + struct sched_cache_group __rcu *sched_cache_grp; /* 1: task was enqueued to its preferred LLC, 0 otherwise */ int pref_llc_queued; #endif @@ -2418,6 +2419,8 @@ struct sched_cache_group { } ____cacheline_aligned_in_smp; =20 void sched_cache_group_put(struct sched_cache_group *grp); +struct sched_cache_group *sched_cache_group_get(struct sched_cache_group *= grp); +struct sched_cache_group *task_cache_group_get(struct task_struct *p); =20 #else =20 diff --git a/kernel/exit.c b/kernel/exit.c index 006edcc0c2c5..442535778ce1 100644 --- a/kernel/exit.c +++ b/kernel/exit.c @@ -552,23 +552,25 @@ void mm_update_next_owner(struct mm_struct *mm) * Subtract the memory footprint of the current task from * mm. */ -static void exit_mm_sched_cache(struct mm_struct *mm) +static void exit_mm_sched_cache(void) { + struct sched_cache_group *grp =3D + rcu_dereference_protected(current->sched_cache_grp, true); unsigned long fp, sub; =20 - if (!current->total_numa_faults) + if (!grp || !current->total_numa_faults) return; /* * No lock protection due to performance considerations. * Make sure the group footprint does not become * negative. */ - fp =3D READ_ONCE(mm->sched_cache_grp->footprint); + fp =3D READ_ONCE(grp->footprint); sub =3D min(fp, current->total_numa_faults); - WRITE_ONCE(mm->sched_cache_grp->footprint, fp - sub); + WRITE_ONCE(grp->footprint, fp - sub); } #else -static inline void exit_mm_sched_cache(struct mm_struct *mm) +static inline void exit_mm_sched_cache(void) { } #endif /* CONFIG_SCHED_CACHE CONFIG_NUMA_BALANCING */ @@ -585,7 +587,19 @@ static void exit_mm(void) if (!mm) return; =20 - exit_mm_sched_cache(mm); + exit_mm_sched_cache(); + +#ifdef CONFIG_SCHED_CACHE + { + struct sched_cache_group *grp =3D + rcu_dereference_protected(current->sched_cache_grp, true); + + rcu_assign_pointer(current->sched_cache_grp, NULL); + + if (grp) + sched_cache_group_put(grp); + } +#endif =20 mmap_read_lock(mm); mmgrab_lazy_tlb(mm); diff --git a/kernel/fork.c b/kernel/fork.c index 416758c8a3d4..2e79548cb7c1 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -1599,6 +1599,19 @@ static int copy_mm(u64 clone_flags, struct task_stru= ct *tsk) =20 tsk->mm =3D mm; tsk->active_mm =3D mm; +#ifdef CONFIG_SCHED_CACHE + { + /* + * A task holds its own reference on the group, separate from + * the reference held by its mm_struct. Acquire it before + * publishing the pointer. + */ + struct sched_cache_group *grp =3D + sched_cache_group_get(mm->sched_cache_grp); + + rcu_assign_pointer(tsk->sched_cache_grp, grp); + } +#endif return 0; } =20 @@ -2599,6 +2612,16 @@ __latent_entropy struct task_struct *copy_process( bad_fork_cleanup_namespaces: exit_nsproxy_namespaces(p); bad_fork_cleanup_mm: +#ifdef CONFIG_SCHED_CACHE + /* + * copy_mm() took a task reference on the cache group; a failed fork + * never reaches exit_mm(), so release it here to avoid leaking the + * group and its per-CPU buffer. + */ + sched_cache_group_put(rcu_dereference_protected(p->sched_cache_grp, true)= ); + RCU_INIT_POINTER(p->sched_cache_grp, NULL); +#endif + if (p->mm) { mm_clear_owner(p->mm, p); mmput(p->mm); diff --git a/kernel/sched/cache_sched.c b/kernel/sched/cache_sched.c index d492df55f9d5..99d07e1e067c 100644 --- a/kernel/sched/cache_sched.c +++ b/kernel/sched/cache_sched.c @@ -1,6 +1,25 @@ // SPDX-License-Identifier: GPL-2.0-only #include "sched.h" =20 +struct sched_cache_group *sched_cache_group_get(struct sched_cache_group *= grp) +{ + /* + * refcount_inc_not_zero() is the acquire primitive for lockless + * (RCU) lookups; plain refcount_inc() would scribble the count if + * it already reached zero. Return NULL in that case. + */ + if (grp && !refcount_inc_not_zero(&grp->refcnt)) + grp =3D NULL; + + return grp; +} + +struct sched_cache_group *task_cache_group_get(struct task_struct *p) +{ + guard(rcu)(); + return sched_cache_group_get(rcu_dereference(p->sched_cache_grp)); +} + static void sched_cache_group_free_rcu(struct rcu_head *rcu) { struct sched_cache_group *grp =3D diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index b5a823f0a622..272dce2baf32 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -1483,7 +1483,7 @@ static inline int get_sched_cache_scale(int mul) return (1 + (tol - 1) * mul); } =20 -static bool exceed_llc_capacity(struct mm_struct *mm, int cpu) +static bool exceed_llc_capacity(struct sched_cache_group *grp, int cpu) { #ifdef CONFIG_NUMA_BALANCING unsigned long llc, footprint; @@ -1502,7 +1502,7 @@ static bool exceed_llc_capacity(struct mm_struct *mm,= int cpu) * excluded. */ llc =3D sd->llc_bytes; - footprint =3D READ_ONCE(mm->sched_cache_grp->footprint); + footprint =3D READ_ONCE(grp->footprint); =20 /* * Scale the LLC size by 256*llc_aggr_tolerance @@ -1531,7 +1531,7 @@ static bool exceed_llc_capacity(struct mm_struct *mm,= int cpu) return false; } =20 -static bool invalid_llc_nr(struct mm_struct *mm, struct task_struct *p, +static bool invalid_llc_nr(struct sched_cache_group *grp, struct task_stru= ct *p, int cpu) { int scale; @@ -1547,7 +1547,7 @@ static bool invalid_llc_nr(struct mm_struct *mm, stru= ct task_struct *p, if (scale =3D=3D INT_MAX) return false; =20 - return !fits_capacity((mm->sched_cache_grp->nr_running_avg * cpu_smt_num_= threads), + return !fits_capacity((grp->nr_running_avg * cpu_smt_num_threads), (scale * per_cpu(sd_llc_size, cpu))); } =20 @@ -1756,14 +1756,14 @@ static unsigned long fraction_mm_sched(struct rq *r= q, return div64_u64(NICE_0_LOAD * pcpu_sched->runtime, rq->cpu_runtime + 1); } =20 -static int get_pref_llc(struct task_struct *p, struct mm_struct *mm) +static int get_pref_llc(struct task_struct *p, struct sched_cache_group *g= rp) { int mm_sched_llc =3D -1, mm_sched_cpu; =20 - if (!mm) + if (!grp) return -1; =20 - mm_sched_cpu =3D READ_ONCE(mm->sched_cache_grp->cpu); + mm_sched_cpu =3D READ_ONCE(grp->cpu); if (mm_sched_cpu !=3D -1) { mm_sched_llc =3D llc_id(mm_sched_cpu); =20 @@ -1793,8 +1793,8 @@ static unsigned int task_running_on_cpu(int cpu, stru= ct task_struct *p); static inline void account_mm_sched(struct rq *rq, struct task_struct *p, s64 delta_exec) { + struct sched_cache_group *grp =3D rcu_dereference_all(p->sched_cache_grp); struct sched_cache_time *pcpu_sched; - struct mm_struct *mm =3D p->mm; int mm_sched_llc =3D -1; unsigned long epoch; =20 @@ -1805,16 +1805,12 @@ void account_mm_sched(struct rq *rq, struct task_st= ruct *p, s64 delta_exec) return; /* * init_task, kthreads and user thread created - * by user_mode_thread() don't have mm. - * - * A kthread can temporarily adopt an mm via kthread_use_mm(), - * so p->mm alone does not imply a user task. + * by user_mode_thread() don't have a cache group. */ - if (!mm || p->flags & PF_KTHREAD || !mm->sched_cache_grp || - !mm->sched_cache_grp->pcpu_sched) + if (!grp || p->flags & PF_KTHREAD || !grp->pcpu_sched) return; =20 - pcpu_sched =3D per_cpu_ptr(mm->sched_cache_grp->pcpu_sched, cpu_of(rq)); + pcpu_sched =3D per_cpu_ptr(grp->pcpu_sched, cpu_of(rq)); =20 scoped_guard (raw_spinlock, &rq->cpu_epoch_lock) { __update_mm_sched(rq, pcpu_sched); @@ -1827,14 +1823,14 @@ void account_mm_sched(struct rq *rq, struct task_st= ruct *p, s64 delta_exec) * If this process hasn't hit task_cache_work() for a while invalidate * its preferred state. */ - if ((long)(epoch - READ_ONCE(mm->sched_cache_grp->epoch)) > llc_epoch_aff= inity_timeout || - invalid_llc_nr(mm, p, cpu_of(rq)) || - exceed_llc_capacity(mm, cpu_of(rq))) { - if (READ_ONCE(mm->sched_cache_grp->cpu) !=3D -1) - WRITE_ONCE(mm->sched_cache_grp->cpu, -1); + if ((long)(epoch - READ_ONCE(grp->epoch)) > llc_epoch_affinity_timeout || + invalid_llc_nr(grp, p, cpu_of(rq)) || + exceed_llc_capacity(grp, cpu_of(rq))) { + if (READ_ONCE(grp->cpu) !=3D -1) + WRITE_ONCE(grp->cpu, -1); } =20 - mm_sched_llc =3D get_pref_llc(p, mm); + mm_sched_llc =3D get_pref_llc(p, grp); =20 /* task not on rq accounted later in account_entity_enqueue() */ if (task_running_on_cpu(rq->cpu, p) && @@ -1847,31 +1843,32 @@ void account_mm_sched(struct rq *rq, struct task_st= ruct *p, s64 delta_exec) =20 static void task_tick_cache(struct rq *rq, struct task_struct *p) { + struct sched_cache_group *grp =3D rcu_dereference_all(p->sched_cache_grp); struct callback_head *work =3D &p->cache_work; - struct mm_struct *mm =3D p->mm; unsigned long epoch; =20 if (!sched_cache_enabled()) return; =20 - if (!mm || p->flags & PF_KTHREAD || - !mm->sched_cache_grp->pcpu_sched) + if (!grp || p->flags & PF_KTHREAD || + !grp->pcpu_sched) return; =20 epoch =3D rq->cpu_epoch; /* avoid moving backwards */ - if (time_after_eq(mm->sched_cache_grp->epoch, epoch)) + if (time_after_eq(grp->epoch, epoch)) return; =20 - guard(raw_spinlock)(&mm->sched_cache_grp->lock); + guard(raw_spinlock)(&grp->lock); =20 if (work->next =3D=3D work) { task_work_add(p, work, TWA_RESUME); - WRITE_ONCE(mm->sched_cache_grp->epoch, epoch); + WRITE_ONCE(grp->epoch, epoch); } } =20 -static void get_scan_cpumasks(cpumask_var_t cpus, struct task_struct *p) +static void get_scan_cpumasks(cpumask_var_t cpus, struct task_struct *p, + struct sched_cache_group *grp) { #ifdef CONFIG_NUMA_BALANCING int cpu, curr_cpu, nid, pref_nid; @@ -1879,7 +1876,7 @@ static void get_scan_cpumasks(cpumask_var_t cpus, str= uct task_struct *p) if (!static_branch_likely(&sched_numa_balancing)) goto out; =20 - cpu =3D READ_ONCE(p->mm->sched_cache_grp->cpu); + cpu =3D READ_ONCE(grp->cpu); if (cpu !=3D -1) nid =3D cpu_to_node(cpu); curr_cpu =3D task_cpu(p); @@ -1940,9 +1937,7 @@ static void task_cache_work(struct callback_head *wor= k) unsigned long next_scan, now =3D jiffies; struct task_struct *p =3D current, *cur; unsigned long curr_m_a_occ =3D 0; - struct mm_struct *mm =3D p->mm; unsigned long m_a_occ =3D 0; - cpumask_var_t cpus; =20 WARN_ON_ONCE(work !=3D &p->cache_work); =20 @@ -1951,32 +1946,44 @@ static void task_cache_work(struct callback_head *w= ork) if (p->flags & PF_EXITING) return; =20 - next_scan =3D READ_ONCE(mm->sched_cache_grp->next_scan); + /* + * A reference makes sure grp is not released by others. The rcu + * lock can not be held till after zalloc_cpumask_var() below, + * because the latter might sleep. + */ + struct sched_cache_group *grp __free(sched_cache_group_put) =3D + task_cache_group_get(p); + if (!grp) + return; + + next_scan =3D READ_ONCE(grp->next_scan); if (time_before(now, next_scan)) return; =20 /* only 1 thread is allowed to scan */ - if (!try_cmpxchg(&mm->sched_cache_grp->next_scan, &next_scan, + if (!try_cmpxchg(&grp->next_scan, &next_scan, now + max_t(unsigned long, READ_ONCE(llc_epoch_period), 1))) return; =20 curr_cpu =3D task_cpu(p); - if (invalid_llc_nr(mm, p, curr_cpu) || - exceed_llc_capacity(mm, curr_cpu)) { - if (READ_ONCE(mm->sched_cache_grp->cpu) !=3D -1) - WRITE_ONCE(mm->sched_cache_grp->cpu, -1); + if (invalid_llc_nr(grp, p, curr_cpu) || + exceed_llc_capacity(grp, curr_cpu)) { + if (READ_ONCE(grp->cpu) !=3D -1) + WRITE_ONCE(grp->cpu, -1); =20 return; } =20 + cpumask_var_t cpus __free(free_cpumask_var) =3D CPUMASK_VAR_NULL; + if (!zalloc_cpumask_var(&cpus, GFP_KERNEL)) return; =20 scoped_guard (cpus_read_lock) { guard(rcu)(); =20 - get_scan_cpumasks(cpus, p); + get_scan_cpumasks(cpus, p, grp); =20 for_each_cpu(cpu, cpus) { /* XXX sched_cluster_active */ @@ -1988,8 +1995,6 @@ static void task_cache_work(struct callback_head *wor= k) continue; =20 for_each_cpu(i, sched_domain_span(sd)) { - struct sched_cache_group *grp =3D mm->sched_cache_grp; - occ =3D fraction_mm_sched(cpu_rq(i), per_cpu_ptr(grp->pcpu_sched, i)); a_occ +=3D occ; @@ -1998,9 +2003,13 @@ static void task_cache_work(struct callback_head *wo= rk) m_cpu =3D i; } =20 + /* + * rcu_access_pointer() is used because the + * pointer is only compared, never dereferenced. + */ cur =3D rcu_dereference_all(cpu_rq(i)->curr); if (cur && !(cur->flags & (PF_EXITING | PF_KTHREAD)) && - cur->mm =3D=3D mm) + rcu_access_pointer(cur->sched_cache_grp) =3D=3D grp) nr_running++; } =20 @@ -2024,7 +2033,7 @@ static void task_cache_work(struct callback_head *wor= k) m_a_cpu =3D m_cpu; } =20 - if (llc_id(cpu) =3D=3D llc_id(READ_ONCE(mm->sched_cache_grp->cpu))) + if (llc_id(cpu) =3D=3D llc_id(READ_ONCE(grp->cpu))) curr_m_a_occ =3D a_occ; =20 cpumask_andnot(cpus, cpus, sched_domain_span(sd)); @@ -2042,11 +2051,10 @@ static void task_cache_work(struct callback_head *w= ork) * 3. 2X is chosen based on test results, as it delivers * the optimal performance gain so far. */ - WRITE_ONCE(mm->sched_cache_grp->cpu, m_a_cpu); + WRITE_ONCE(grp->cpu, m_a_cpu); } =20 - update_avg_scale(&mm->sched_cache_grp->nr_running_avg, nr_running); - free_cpumask_var(cpus); + update_avg_scale(&grp->nr_running_avg, nr_running); } =20 void init_sched_mm(struct task_struct *p) @@ -2055,6 +2063,13 @@ void init_sched_mm(struct task_struct *p) =20 init_task_work(work, task_cache_work); work->next =3D work; + /* + * dup_task_struct() copies the parent's task_struct, including its + * sched_cache_grp, for which the child holds no reference. Clear it + * here - before copy_mm() runs - so the child never carries a + * borrowed pointer that the fork error path would put. + */ + RCU_INIT_POINTER(p->sched_cache_grp, NULL); /* * Reset new task's preference to avoid * polluting account_llc_enqueue(). @@ -3853,10 +3868,9 @@ static void task_numa_placement(struct task_struct *= p) * heuristic and occasional lost updates are tolerable. * * If a task exits, its corresponding footprint must - * be subtracted from the mm->sched_cache_grp->footprint, - * otherwise the mm->sched_cache_grp->footprint will not - * converge: the exiting thread's footprint remains - * unchanged/undecayed in mm->sched_cache_grp->footprint. + * be subtracted from p->sched_cache_grp->footprint, + * otherwise the footprint will not converge: the + * exiting thread's footprint remains unchanged/undecayed. * See exit_mm(). * * Lost updates and unsynchronized subtraction @@ -3864,9 +3878,17 @@ static void task_numa_placement(struct task_struct *= p) * go negative. Clamp to zero to prevent the * unsigned footprint from wrapping. */ - new_fp =3D (long)READ_ONCE(p->mm->sched_cache_grp->footprint) + diff; - WRITE_ONCE(p->mm->sched_cache_grp->footprint, - max(new_fp, 0L)); + { + struct sched_cache_group *grp; + + guard(rcu)(); + grp =3D rcu_dereference(p->sched_cache_grp); + + if (grp) { + new_fp =3D (long)READ_ONCE(grp->footprint) + diff; + WRITE_ONCE(grp->footprint, max(new_fp, 0L)); + } + } #endif } =20 @@ -10810,7 +10832,7 @@ static inline bool task_misfits_asym_cpu(struct lb_= env *env, struct task_struct static enum llc_mig can_migrate_llc_task(struct lb_env *env, struct task_struct *p) { - struct mm_struct *mm; + struct sched_cache_group *grp; bool to_pref; int cpu, src_cpu, dst_cpu; =20 @@ -10819,19 +10841,19 @@ static enum llc_mig can_migrate_llc_task(struct l= b_env *env, =20 src_cpu =3D env->src_cpu; dst_cpu =3D env->dst_cpu; - mm =3D p->mm; - if (!mm || !mm->sched_cache_grp) + grp =3D rcu_dereference_all(p->sched_cache_grp); + if (!grp) return mig_unrestricted; =20 - cpu =3D READ_ONCE(mm->sched_cache_grp->cpu); + cpu =3D READ_ONCE(grp->cpu); if (cpu < 0 || cpus_share_cache(src_cpu, dst_cpu)) return mig_unrestricted; =20 /* skip cache aware load balance for too many threads */ - if (invalid_llc_nr(mm, p, dst_cpu) || - exceed_llc_capacity(mm, dst_cpu)) { - if (READ_ONCE(mm->sched_cache_grp->cpu) !=3D -1) - WRITE_ONCE(mm->sched_cache_grp->cpu, -1); + if (invalid_llc_nr(grp, p, dst_cpu) || + exceed_llc_capacity(grp, dst_cpu)) { + if (READ_ONCE(grp->cpu) !=3D -1) + WRITE_ONCE(grp->cpu, -1); return mig_unrestricted; } =20 diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h index e656c7059bf8..8b67af28a471 100644 --- a/kernel/sched/sched.h +++ b/kernel/sched/sched.h @@ -4145,6 +4145,9 @@ static inline bool sched_cache_enabled(void) return static_branch_unlikely(&sched_cache_active); } =20 +DEFINE_FREE(sched_cache_group_put, struct sched_cache_group *, + sched_cache_group_put(_T)); + extern void sched_cache_active_set(void); =20 #endif --=20 2.32.0