isst-daemon.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Intel Speed Select -- Allow speed select to daemonize
  4 * Copyright (c) 2022 Intel Corporation.
  5 */
  6
  7#include <stdio.h>
  8#include <stdlib.h>
  9#include <stdarg.h>
 10#include <string.h>
 11#include <unistd.h>
 12#include <fcntl.h>
 13#include <sys/file.h>
 14#include <sys/types.h>
 15#include <sys/stat.h>
 16#include <errno.h>
 17#include <getopt.h>
 18#include <signal.h>
 19#include <time.h>
 20
 21#include "isst.h"
 22
 23static int per_package_levels_info[MAX_PACKAGE_COUNT][MAX_DIE_PER_PACKAGE][MAX_PUNIT_PER_DIE];
 24static time_t per_package_levels_tm[MAX_PACKAGE_COUNT][MAX_DIE_PER_PACKAGE][MAX_PUNIT_PER_DIE];
 25
 26static void init_levels(void)
 27{
 28	int i, j, k;
 29
 30	for (i = 0; i < MAX_PACKAGE_COUNT; ++i)
 31		for (j = 0; j < MAX_DIE_PER_PACKAGE; ++j)
 32			for (k = 0; k < MAX_PUNIT_PER_DIE; ++k)
 33				per_package_levels_info[i][j][k] = -1;
 34}
 35
 36void process_level_change(struct isst_id *id)
 37{
 38	struct isst_pkg_ctdp_level_info ctdp_level;
 39	struct isst_pkg_ctdp pkg_dev;
 40	time_t tm;
 41	int ret;
 42
 43	if (id->pkg < 0 || id->die < 0 || id->punit < 0) {
 44		debug_printf("Invalid package/die info for cpu:%d\n", id->cpu);
 45		return;
 46	}
 47
 48	tm = time(NULL);
 49	if (tm - per_package_levels_tm[id->pkg][id->die][id->punit] < 2)
 50		return;
 51
 52	per_package_levels_tm[id->pkg][id->die][id->punit] = tm;
 53
 54	ret = isst_get_ctdp_levels(id, &pkg_dev);
 55	if (ret) {
 56		debug_printf("Can't get tdp levels for cpu:%d\n", id->cpu);
 57		return;
 58	}
 59
 60	debug_printf("Get Config level %d pkg:%d die:%d current_level:%d\n", id->cpu,
 61		      id->pkg, id->die, pkg_dev.current_level);
 62
 63	if (pkg_dev.locked) {
 64		debug_printf("config TDP s locked \n");
 65		return;
 66	}
 67
 68	if (per_package_levels_info[id->pkg][id->die][id->punit] == pkg_dev.current_level)
 69		return;
 70
 71	debug_printf("**Config level change for cpu:%d pkg:%d die:%d from %d to %d\n",
 72		      id->cpu, id->pkg, id->die, per_package_levels_info[id->pkg][id->die][id->punit],
 73		      pkg_dev.current_level);
 74
 75	per_package_levels_info[id->pkg][id->die][id->punit] = pkg_dev.current_level;
 76
 77	ctdp_level.core_cpumask_size =
 78		alloc_cpu_set(&ctdp_level.core_cpumask);
 79	ret = isst_get_coremask_info(id, pkg_dev.current_level, &ctdp_level);
 80	if (ret) {
 81		free_cpu_set(ctdp_level.core_cpumask);
 82		debug_printf("Can't get core_mask:%d\n", id->cpu);
 83		return;
 84	}
 85
 86	if (use_cgroupv2()) {
 87		int ret;
 88
 89		ret = enable_cpuset_controller();
 90		if (ret)
 91			goto use_offline;
 92
 93		isolate_cpus(id, ctdp_level.core_cpumask_size, ctdp_level.core_cpumask,
 94			     pkg_dev.current_level, 0);
 95
 96		goto free_mask;
 97	}
 98
 99use_offline:
100	if (ctdp_level.cpu_count) {
101		int i, max_cpus = get_topo_max_cpus();
102		for (i = 0; i < max_cpus; ++i) {
103			if (!is_cpu_in_power_domain(i, id))
104				continue;
105			if (CPU_ISSET_S(i, ctdp_level.core_cpumask_size, ctdp_level.core_cpumask)) {
106				fprintf(stderr, "online cpu %d\n", i);
107				set_cpu_online_offline(i, 1);
108			} else {
109				fprintf(stderr, "offline cpu %d\n", i);
110				set_cpu_online_offline(i, 0);
111			}
112		}
113	}
114free_mask:
115	free_cpu_set(ctdp_level.core_cpumask);
116}
117
118static void _poll_for_config_change(struct isst_id *id, void *arg1, void *arg2,
119				    void *arg3, void *arg4)
120{
121	process_level_change(id);
122}
123
124static void poll_for_config_change(void)
125{
126	for_each_online_power_domain_in_set(_poll_for_config_change, NULL, NULL,
127				       NULL, NULL);
128}
129
130static int done = 0;
131static int pid_file_handle;
132
133static void signal_handler(int sig)
134{
135	switch (sig) {
136	case SIGINT:
137	case SIGTERM:
138		done = 1;
139		hfi_exit();
140		exit(0);
141		break;
142	default:
143		break;
144	}
145}
146
147static void daemonize(char *rundir, char *pidfile)
148{
149	int pid, sid, i;
150	char str[10];
151	struct sigaction sig_actions;
152	sigset_t sig_set;
153	int ret;
154
155	if (getppid() == 1)
156		return;
157
158	sigemptyset(&sig_set);
159	sigaddset(&sig_set, SIGCHLD);
160	sigaddset(&sig_set, SIGTSTP);
161	sigaddset(&sig_set, SIGTTOU);
162	sigaddset(&sig_set, SIGTTIN);
163	sigprocmask(SIG_BLOCK, &sig_set, NULL);
164
165	sig_actions.sa_handler = signal_handler;
166	sigemptyset(&sig_actions.sa_mask);
167	sig_actions.sa_flags = 0;
168
169	sigaction(SIGHUP, &sig_actions, NULL);
170	sigaction(SIGTERM, &sig_actions, NULL);
171	sigaction(SIGINT, &sig_actions, NULL);
172
173	pid = fork();
174	if (pid < 0) {
175		/* Could not fork */
176		exit(EXIT_FAILURE);
177	}
178	if (pid > 0)
179		exit(EXIT_SUCCESS);
180
181	umask(027);
182
183	sid = setsid();
184	if (sid < 0)
185		exit(EXIT_FAILURE);
186
187	/* close all descriptors */
188	for (i = getdtablesize(); i >= 0; --i)
189		close(i);
190
191	i = open("/dev/null", O_RDWR);
192	if (i < 0)
193		exit(EXIT_FAILURE);
194
195	ret = dup(i);
196	if (ret == -1)
197		exit(EXIT_FAILURE);
198
199	ret = chdir(rundir);
200	if (ret == -1)
201		exit(EXIT_FAILURE);
202
203	pid_file_handle = open(pidfile, O_RDWR | O_CREAT, 0600);
204	if (pid_file_handle == -1) {
205		/* Couldn't open lock file */
206		exit(1);
207	}
208	/* Try to lock file */
209#ifdef LOCKF_SUPPORT
210	if (lockf(pid_file_handle, F_TLOCK, 0) == -1) {
211#else
212	if (flock(pid_file_handle, LOCK_EX|LOCK_NB) < 0) {
213#endif
214		/* Couldn't get lock on lock file */
215		fprintf(stderr, "Couldn't get lock file %d\n", getpid());
216		exit(1);
217	}
218	snprintf(str, sizeof(str), "%d\n", getpid());
219	ret = write(pid_file_handle, str, strlen(str));
220	if (ret == -1)
221		exit(EXIT_FAILURE);
222
223	close(i);
224}
225
226int isst_daemon(int debug_mode, int poll_interval, int no_daemon)
227{
228	int ret;
229
230	if (!no_daemon && poll_interval < 0 && !debug_mode) {
231		fprintf(stderr, "OOB mode is enabled and will run as daemon\n");
232		daemonize((char *) "/tmp/",
233				(char *)"/tmp/hfi-events.pid");
234	} else {
235		signal(SIGINT, signal_handler);
236	}
237
238	init_levels();
239
240	if (poll_interval < 0) {
241		ret = hfi_main();
242		if (ret) {
243			fprintf(stderr, "HFI initialization failed\n");
244		}
245		fprintf(stderr, "Must specify poll-interval\n");
246		return ret;
247	}
248
249	debug_printf("Starting loop\n");
250	while (!done) {
251		sleep(poll_interval);
252		poll_for_config_change();
253	}
254
255	return 0;
256}