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