From nobody Mon Feb 9 14:14:19 2026 Received: from mail-dy1-f180.google.com (mail-dy1-f180.google.com [74.125.82.180]) (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 16B6E2D781B for ; Fri, 6 Feb 2026 07:06:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.180 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770361592; cv=none; b=cRhGp5OLq0LzCusEiyS5IyZBpXd0QPa8xpPVf4h/GB7oAuRlqaq3sgUGb/HTrklihYmMEPCrv/xYieul8lNnElsGWtXZKzx9s2Co6C/2hY3GNsflXZIX2jTMV9T+Mtu9bIAvJt0r3vd8rwWkyz8o0kaStFEm5XoGtyPOCZuNng4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770361592; c=relaxed/simple; bh=0oqbxcPwmQ5t2qh5YHGbOBPIaUL1kS8QlSZU9gar1mY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=AGEryzSidre07A4u8dSqzSBgGrNZNqqi2RTXvxgeN9w5eB0MKy/LcADAti6IAswFRpPScmp5fOdBADYJCgP/YYqumQGE+jPxlGleNY9ABfVXJ6WUO/9xbCmO2Am5UzO1AWn7ezGaYqRDuD86Xp5mjEoZDJFoVRjFHKsSQuL6pJo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=nhEdV8wA; arc=none smtp.client-ip=74.125.82.180 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="nhEdV8wA" Received: by mail-dy1-f180.google.com with SMTP id 5a478bee46e88-2b81ebac5d6so2345089eec.1 for ; Thu, 05 Feb 2026 23:06:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1770361591; x=1770966391; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=l9mXbrAaMtQHRTGDa3ewvpAsXiHuJtYFWMHk8lDDECc=; b=nhEdV8wAm8LCyL/K2fRETkMujedzYBHStEG2ueMYUD6YKZ1jbz5ksXhPCQN8Z++mz8 Vb5kqK7MclKdo1/p+tKaQ+dKej5HBRCH10oPFglnkZy9DjG6QKe+off5joxKVhKqHPeM xjQXvcczHJmvWD011Zt5S0v8o1k1zMaxrYA0zPBwtW+1630j9UkuDpZSUTAB/2w5J6Ie 8V+P++I0FjfhU77L3RUj+bqWAV6YxB193dA32ivjz8oJ3m1/y1xyM5ldG37593T9ZaZS PN/qCPcn/htDXhi5Q8BE30YS2XNrU8xwaUJ9PKVduK0uy8LJ5xz112FPOpAMx5Z7ceLS 8wGg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1770361591; x=1770966391; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=l9mXbrAaMtQHRTGDa3ewvpAsXiHuJtYFWMHk8lDDECc=; b=AtHAy/dciDzUvlzGwKVs5qt+i0vkxP77urIKV6uNjI7TbuEg7+/idcIl9iC5PTAXlm ignV0JPS8lO7vg1jllNiIPMWkZMS3hKtIAqzFVlMv/v2xCPriCDIhM6dgvUlCq9CI5r7 3aR4CZEtsthgynRdFbQEavRwxMnFc9bjfb+vY+mL06aXzhGaZbeJBwPGgOVq/4YWIsqx B8yXDYJVIyuNyLiPqh/FmsJbnJ8jAkpmHmOtD9fjnKcmZRL/ZEMJrlooYiA8BgmMp95t WNID3TtvSyVNancqnOlPGNFFXVzhE/qjTXv0x+oXZonHoaa/+rlpcEt/9K3Rn2aw16yf iAjA== X-Gm-Message-State: AOJu0Yxtfdfw6pj6hkeqIRXZRjgdslkmwxqFO2qz5Ixydj3p8DLKZM5X 1pPokMbNQAMUuSjrI4NSjU8pDWVcZpuNA1PLLDHocoSPjT6U0ZxQLBUr X-Gm-Gg: AZuq6aLZ32J7iM7I2h7PFbH4zBUZax+nK6VRiWIN3AmAKYs0gMdS49OaEBfT5a5Z4Jk NRcXHrovgy5L6IdGUsrYH+LJ68Z5oiJz1fIuH+F2e1ItGKGShgH6gifZgsslGwAb6dnp9qBVWm9 hagSEoeRxG9P85RiMsjJtak189kP5KyR//OeOk/ZumfmGqFVQmRCBwYj41c9R+W5lPodxva7HJ4 HtjLBE3mEXhAqK131BxzsFSKD/ezHjF9Zh0cVvdrNQsvGX2kKs56cR6SIcV5eqNvmpXzHujvjFh BU7vVv/oMLRVGO7OJOpC/wuecrICL247pM7C8xVGKlol0R2nlBQOegK7/mTVKlzr1q8hRCJEnQw umRz6zrVrcPrbuk9EeW2NPyp0Vb1p6/+j310uYdNGshmRssDE2RoWPAMKpWp+8/x1UImRBmuYpp iuW8XIPJMzhA1FlBdNYgWAjg== X-Received: by 2002:a05:7022:6612:b0:11b:9386:826c with SMTP id a92af1059eb24-1270405f72cmr986038c88.41.1770361591067; Thu, 05 Feb 2026 23:06:31 -0800 (PST) Received: from [127.0.1.1] ([74.48.213.230]) by smtp.gmail.com with ESMTPSA id a92af1059eb24-127041e61b9sm1592601c88.8.2026.02.05.23.06.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Feb 2026 23:06:30 -0800 (PST) From: Qiliang Yuan Date: Fri, 06 Feb 2026 02:04:30 -0500 Subject: [PATCH RFC 09/12] sched/isolation: Separate housekeeping types and add sysfs interface Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260206-feature-dynamic_isolcpus_dhei-v1-9-00a711eb0c74@gmail.com> References: <20260206-feature-dynamic_isolcpus_dhei-v1-0-00a711eb0c74@gmail.com> In-Reply-To: <20260206-feature-dynamic_isolcpus_dhei-v1-0-00a711eb0c74@gmail.com> To: Ingo Molnar , Peter Zijlstra , Juri Lelli , Vincent Guittot , Dietmar Eggemann , Steven Rostedt , Ben Segall , Mel Gorman , Valentin Schneider , Thomas Gleixner , "Paul E. McKenney" , Frederic Weisbecker , Neeraj Upadhyay , Joel Fernandes , Josh Triplett , Boqun Feng , Uladzislau Rezki , Mathieu Desnoyers , Lai Jiangshan , Zqiang , Tejun Heo , Andrew Morton , Vlastimil Babka , Suren Baghdasaryan , Michal Hocko , Brendan Jackman , Johannes Weiner , Zi Yan , Anna-Maria Behnsen , Ingo Molnar Cc: linux-kernel@vger.kernel.org, rcu@vger.kernel.org, linux-mm@kvack.org, Qiliang Yuan , Qiliang Yuan X-Mailer: b4 0.14.3 Currently, most housekeeping types (timer, rcu, misc, etc.) share the same mask (HK_TYPE_KERNEL_NOISE), preventing fine-grained control over CPU isolation. Additionally, there is no way to update these masks at runtime. Separate the housekeeping types into individual enum entries and expand the cpumasks array to accommodate them. Introduce a sysfs interface at /sys/kernel/housekeeping/ that allows users to view and update the housekeeping masks for each type at runtime. When a mask is updated via sysfs, a notifier is triggered to re-affine the relevant kernel subsystems and services. Signed-off-by: Qiliang Yuan Signed-off-by: Qiliang Yuan --- include/linux/sched/isolation.h | 20 +++--- kernel/sched/isolation.c | 134 ++++++++++++++++++++++++++++++++++++= +++- 2 files changed, 140 insertions(+), 14 deletions(-) diff --git a/include/linux/sched/isolation.h b/include/linux/sched/isolatio= n.h index 5c07e3e9b8d1..e8fe1cfa5022 100644 --- a/include/linux/sched/isolation.h +++ b/include/linux/sched/isolation.h @@ -10,21 +10,17 @@ enum hk_type { HK_TYPE_DOMAIN, HK_TYPE_MANAGED_IRQ, - HK_TYPE_KERNEL_NOISE, + HK_TYPE_TICK, + HK_TYPE_TIMER, + HK_TYPE_RCU, + HK_TYPE_MISC, + HK_TYPE_WQ, + HK_TYPE_KTHREAD, HK_TYPE_MAX, - - /* - * The following housekeeping types are only set by the nohz_full - * boot commandline option. So they can share the same value. - */ - HK_TYPE_TICK =3D HK_TYPE_KERNEL_NOISE, - HK_TYPE_TIMER =3D HK_TYPE_KERNEL_NOISE, - HK_TYPE_RCU =3D HK_TYPE_KERNEL_NOISE, - HK_TYPE_MISC =3D HK_TYPE_KERNEL_NOISE, - HK_TYPE_WQ =3D HK_TYPE_KERNEL_NOISE, - HK_TYPE_KTHREAD =3D HK_TYPE_KERNEL_NOISE }; =20 +#define HK_TYPE_KERNEL_NOISE HK_TYPE_TICK + struct housekeeping_update { enum hk_type type; const struct cpumask *new_mask; diff --git a/kernel/sched/isolation.c b/kernel/sched/isolation.c index 97cc41626a33..d9ce26cf31fe 100644 --- a/kernel/sched/isolation.c +++ b/kernel/sched/isolation.c @@ -9,14 +9,26 @@ */ #include #include +#include +#include +#include +#include #include "sched.h" =20 enum hk_flags { HK_FLAG_DOMAIN =3D BIT(HK_TYPE_DOMAIN), HK_FLAG_MANAGED_IRQ =3D BIT(HK_TYPE_MANAGED_IRQ), - HK_FLAG_KERNEL_NOISE =3D BIT(HK_TYPE_KERNEL_NOISE), + HK_FLAG_TICK =3D BIT(HK_TYPE_TICK), + HK_FLAG_TIMER =3D BIT(HK_TYPE_TIMER), + HK_FLAG_RCU =3D BIT(HK_TYPE_RCU), + HK_FLAG_MISC =3D BIT(HK_TYPE_MISC), + HK_FLAG_WQ =3D BIT(HK_TYPE_WQ), + HK_FLAG_KTHREAD =3D BIT(HK_TYPE_KTHREAD), }; =20 +#define HK_FLAG_KERNEL_NOISE (HK_FLAG_TICK | HK_FLAG_TIMER | HK_FLAG_RCU |= \ + HK_FLAG_MISC | HK_FLAG_WQ | HK_FLAG_KTHREAD) + static DEFINE_MUTEX(housekeeping_mutex); static BLOCKING_NOTIFIER_HEAD(housekeeping_notifier_list); DEFINE_STATIC_KEY_FALSE(housekeeping_overridden); @@ -99,7 +111,7 @@ int housekeeping_unregister_notifier(struct notifier_blo= ck *nb) } EXPORT_SYMBOL_GPL(housekeeping_unregister_notifier); =20 -static int __maybe_unused housekeeping_update_notify(enum hk_type type, co= nst struct cpumask *new_mask) +static int housekeeping_update_notify(enum hk_type type, const struct cpum= ask *new_mask) { struct housekeeping_update update =3D { .type =3D type, @@ -109,6 +121,124 @@ static int __maybe_unused housekeeping_update_notify(= enum hk_type type, const st return blocking_notifier_call_chain(&housekeeping_notifier_list, HK_UPDAT= E_MASK, &update); } =20 +static const char * const hk_type_names[] =3D { + [HK_TYPE_TIMER] =3D "timer", + [HK_TYPE_RCU] =3D "rcu", + [HK_TYPE_MISC] =3D "misc", + [HK_TYPE_TICK] =3D "tick", + [HK_TYPE_DOMAIN] =3D "domain", + [HK_TYPE_WQ] =3D "workqueue", + [HK_TYPE_MANAGED_IRQ] =3D "managed_irq", + [HK_TYPE_KTHREAD] =3D "kthread", +}; + +struct hk_attribute { + struct kobj_attribute kattr; + enum hk_type type; +}; + +#define to_hk_attr(_kattr) container_of(_kattr, struct hk_attribute, kattr) + +static ssize_t housekeeping_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct hk_attribute *hk_attr =3D to_hk_attr(attr); + const struct cpumask *mask =3D housekeeping_cpumask(hk_attr->type); + + return cpumap_print_to_pagebuf(false, buf, mask); +} + +static ssize_t housekeeping_store(struct kobject *kobject, + struct kobj_attribute *attr, + const char *buf, size_t count) +{ + struct hk_attribute *hk_attr =3D to_hk_attr(attr); + enum hk_type type =3D hk_attr->type; + cpumask_var_t new_mask; + int err; + + if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) + return -ENOMEM; + + err =3D cpulist_parse(buf, new_mask); + if (err) + goto out_free; + + if (cpumask_empty(new_mask)) { + err =3D -EINVAL; + goto out_free; + } + + mutex_lock(&housekeeping_mutex); +=09 + if (!housekeeping.cpumasks[type]) { + if (!alloc_cpumask_var(&housekeeping.cpumasks[type], GFP_KERNEL)) { + err =3D -ENOMEM; + goto out_unlock; + } + } + + if (cpumask_equal(housekeeping.cpumasks[type], new_mask)) { + err =3D 0; + goto out_unlock; + } + + cpumask_copy(housekeeping.cpumasks[type], new_mask); + housekeeping.flags |=3D BIT(type); + static_branch_enable(&housekeeping_overridden); +=09 + housekeeping_update_notify(type, new_mask); +=09 + err =3D count; + +out_unlock: + mutex_unlock(&housekeeping_mutex); +out_free: + free_cpumask_var(new_mask); + return err < 0 ? err : count; +} + +static struct hk_attribute housekeeping_attrs[HK_TYPE_MAX]; +static struct attribute *housekeeping_attr_ptr[HK_TYPE_MAX + 1]; + +static const struct attribute_group housekeeping_attr_group =3D { + .attrs =3D housekeeping_attr_ptr, +}; + +static int __init housekeeping_sysfs_init(void) +{ + struct kobject *housekeeping_kobj; + int i, j =3D 0; + int ret; + + housekeeping_kobj =3D kobject_create_and_add("housekeeping", kernel_kobj); + if (!housekeeping_kobj) + return -ENOMEM; + + for (i =3D 0; i < HK_TYPE_MAX; i++) { + if (!hk_type_names[i]) + continue; + + housekeeping_attrs[i].type =3D i; + sysfs_attr_init(&housekeeping_attrs[i].kattr.attr); + housekeeping_attrs[i].kattr.attr.name =3D hk_type_names[i]; + housekeeping_attrs[i].kattr.attr.mode =3D 0644; + housekeeping_attrs[i].kattr.show =3D housekeeping_show; + housekeeping_attrs[i].kattr.store =3D housekeeping_store; + housekeeping_attr_ptr[j++] =3D &housekeeping_attrs[i].kattr.attr; + } + housekeeping_attr_ptr[j] =3D NULL; + + ret =3D sysfs_create_group(housekeeping_kobj, &housekeeping_attr_group); + if (ret) { + kobject_put(housekeeping_kobj); + return ret; + } + + return 0; +} +late_initcall(housekeeping_sysfs_init); + void housekeeping_init(void) { enum hk_type type; --=20 2.51.0