netdev - [PATCH 3/3] thermal: intel: hfi: Enable interface only when required

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-Id: <20240131120535.933424-4-stanislaw.gruszka@linux.intel.com>
Date: Wed, 31 Jan 2024 13:05:35 +0100
From: Stanislaw Gruszka <stanislaw.gruszka@...ux.intel.com>
To: linux-pm@...r.kernel.org
Cc: "Rafael J. Wysocki" <rafael@...nel.org>,
	Srinivas Pandruvada <srinivas.pandruvada@...ux.intel.com>,
	Ricardo Neri <ricardo.neri-calderon@...ux.intel.com>,
	Daniel Lezcano <daniel.lezcano@...aro.org>,
	"David S. Miller" <davem@...emloft.net>,
	Eric Dumazet <edumazet@...gle.com>,
	Jakub Kicinski <kuba@...nel.org>,
	Paolo Abeni <pabeni@...hat.com>,
	netdev@...r.kernel.org
Subject: [PATCH 3/3] thermal: intel: hfi: Enable interface only when required

Enable and disable hardware feedback interface (HFI) when user space
handler is present. For example, enable HFI, when intel-speed-select or
Intel Low Power daemon is running and subscribing to thermal netlink
events,. When user space handlers exit or remove subscription for
thermal netlink events, disable HFI.

Summary of changes:

- When CPU is online, instead of blindly enabling HFI by calling
hfi_enable(), check if the thermal netlink group has any listener.
This will make sure that HFI is not enabled by default during boot
time.

- Register a netlink notifier.

- In the notifier process reason code NETLINK_CHANGE and
NETLINK_URELEASE. If thermal netlink group has any listener enable
HFI on all packages. If there are no listener disable HFI on all
packages.

- Actual processing to enable/disable matches what is done in
suspend/resume callbacks. So, create two functions hfi_do_enable()
and hfi_do_disable(), which can be called from  the netlink notifier
callback and suspend/resume callbacks.

Signed-off-by: Stanislaw Gruszka <stanislaw.gruszka@...ux.intel.com>
---
 drivers/thermal/intel/intel_hfi.c | 82 +++++++++++++++++++++++++++----
 1 file changed, 73 insertions(+), 9 deletions(-)

diff --git a/drivers/thermal/intel/intel_hfi.c b/drivers/thermal/intel/intel_hfi.c
index 3b04c6ec4fca..50601f75f6dc 100644
--- a/drivers/thermal/intel/intel_hfi.c
+++ b/drivers/thermal/intel/intel_hfi.c
@@ -30,6 +30,7 @@
 #include <linux/kernel.h>
 #include <linux/math.h>
 #include <linux/mutex.h>
+#include <linux/netlink.h>
 #include <linux/percpu-defs.h>
 #include <linux/printk.h>
 #include <linux/processor.h>
@@ -480,7 +481,8 @@ void intel_hfi_online(unsigned int cpu)
 	/* Enable this HFI instance if this is its first online CPU. */
 	if (cpumask_weight(hfi_instance->cpus) == 1) {
 		hfi_set_hw_table(hfi_instance);
-		hfi_enable();
+		if (thermal_group_has_listeners(THERMAL_GENL_EVENT_GROUP))
+			hfi_enable();
 	}
 
 unlock:
@@ -573,28 +575,84 @@ static __init int hfi_parse_features(void)
 	return 0;
 }
 
-static void hfi_do_enable(void)
+/*
+ * HFI enable/disable run in non-concurrent manner on boot CPU in syscore
+ * callbacks or under protection of hfi_instance_lock.
+ */
+static void hfi_do_enable(void *ptr)
+{
+	struct hfi_instance *hfi_instance = ptr;
+
+	hfi_set_hw_table(hfi_instance);
+	hfi_enable();
+}
+
+static void hfi_do_disable(void *ptr)
+{
+	hfi_disable();
+}
+
+static void hfi_syscore_resume(void)
 {
 	/* This code runs only on the boot CPU. */
 	struct hfi_cpu_info *info = &per_cpu(hfi_cpu_info, 0);
 	struct hfi_instance *hfi_instance = info->hfi_instance;
 
-	/* No locking needed. There is no concurrency with CPU online. */
-	hfi_set_hw_table(hfi_instance);
-	hfi_enable();
+	hfi_do_enable(hfi_instance);
 }
 
-static int hfi_do_disable(void)
+static int hfi_syscore_suspend(void)
 {
-	/* No locking needed. There is no concurrency with CPU offline. */
 	hfi_disable();
 
 	return 0;
 }
 
 static struct syscore_ops hfi_pm_ops = {
-	.resume = hfi_do_enable,
-	.suspend = hfi_do_disable,
+	.resume = hfi_syscore_resume,
+	.suspend = hfi_syscore_suspend,
+};
+
+static int hfi_netlink_notify(struct notifier_block *nb, unsigned long state,
+			      void *_notify)
+{
+	struct netlink_notify *notify = _notify;
+	struct hfi_instance *hfi_instance;
+	smp_call_func_t func;
+	unsigned int cpu;
+	int i;
+
+	if (notify->protocol != NETLINK_GENERIC)
+		return NOTIFY_DONE;
+
+	switch (state) {
+	case NETLINK_CHANGE:
+	case NETLINK_URELEASE:
+		mutex_lock(&hfi_instance_lock);
+
+		if (thermal_group_has_listeners(THERMAL_GENL_EVENT_GROUP))
+			func = hfi_do_enable;
+		else
+			func = hfi_do_disable;
+
+		for (i = 0; i < max_hfi_instances; i++) {
+			hfi_instance = &hfi_instances[i];
+			if (cpumask_empty(hfi_instance->cpus))
+				continue;
+
+			cpu = cpumask_any(hfi_instance->cpus);
+			smp_call_function_single(cpu, func, hfi_instance, true);
+		}
+
+		mutex_unlock(&hfi_instance_lock);
+		return NOTIFY_OK;
+	}
+
+	return NOTIFY_DONE;
+}
+
+static struct notifier_block hfi_netlink_nb = {
+	.notifier_call = hfi_netlink_notify,
 };
 
 void __init intel_hfi_init(void)
@@ -628,10 +686,16 @@ void __init intel_hfi_init(void)
 	if (!hfi_updates_wq)
 		goto err_nomem;
 
+	if (netlink_register_notifier(&hfi_netlink_nb))
+		goto err_nl_notif;
+
 	register_syscore_ops(&hfi_pm_ops);
 
 	return;
 
+err_nl_notif:
+	destroy_workqueue(hfi_updates_wq);
+
 err_nomem:
 	for (j = 0; j < i; ++j) {
 		hfi_instance = &hfi_instances[j];
-- 
2.34.1