x86/intel-speed-select/isst-daemon.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Intel Speed Select -- Allow speed select to daemonize
0004  * Copyright (c) 2022 Intel Corporation.
0005  */
0006
0007 #include <stdio.h>
0008 #include <stdlib.h>
0009 #include <stdarg.h>
0010 #include <string.h>
0011 #include <unistd.h>
0012 #include <fcntl.h>
0013 #include <sys/file.h>
0014 #include <sys/types.h>
0015 #include <sys/stat.h>
0016 #include <errno.h>
0017 #include <getopt.h>
0018 #include <signal.h>
0019 #include <time.h>
0020
0021 #include "isst.h"
0022
0023 static int per_package_levels_info[MAX_PACKAGE_COUNT][MAX_DIE_PER_PACKAGE];
0024 static time_t per_package_levels_tm[MAX_PACKAGE_COUNT][MAX_DIE_PER_PACKAGE];
0025
0026 static void init_levels(void)
0027 {
0028     int i, j;
0029
0030     for (i = 0; i < MAX_PACKAGE_COUNT; ++i)
0031         for (j = 0; j < MAX_DIE_PER_PACKAGE; ++j)
0032             per_package_levels_info[i][j] = -1;
0033 }
0034
0035 void process_level_change(int cpu)
0036 {
0037     struct isst_pkg_ctdp_level_info ctdp_level;
0038     int pkg_id = get_physical_package_id(cpu);
0039     int die_id = get_physical_die_id(cpu);
0040     struct isst_pkg_ctdp pkg_dev;
0041     time_t tm;
0042     int ret;
0043
0044     if (pkg_id >= MAX_PACKAGE_COUNT || die_id >= MAX_DIE_PER_PACKAGE) {
0045         debug_printf("Invalid package/die info for cpu:%d\n", cpu);
0046         return;
0047     }
0048
0049     tm = time(NULL);
0050     if (tm - per_package_levels_tm[pkg_id][die_id] < 2 )
0051         return;
0052
0053     per_package_levels_tm[pkg_id][die_id] = tm;
0054
0055     ret = isst_get_ctdp_levels(cpu, &pkg_dev);
0056     if (ret) {
0057         debug_printf("Can't get tdp levels for cpu:%d\n", cpu);
0058         return;
0059     }
0060
0061     debug_printf("Get Config level %d pkg:%d die:%d current_level:%d \n", cpu,
0062               pkg_id, die_id, pkg_dev.current_level);
0063
0064     if (pkg_dev.locked) {
0065         debug_printf("config TDP s locked \n");
0066         return;
0067     }
0068
0069     if (per_package_levels_info[pkg_id][die_id] == pkg_dev.current_level)
0070         return;
0071
0072     debug_printf("**Config level change for cpu:%d pkg:%d die:%d from %d to %d\n",
0073               cpu, pkg_id, die_id, per_package_levels_info[pkg_id][die_id],
0074               pkg_dev.current_level);
0075
0076     per_package_levels_info[pkg_id][die_id] = pkg_dev.current_level;
0077
0078     ctdp_level.core_cpumask_size =
0079         alloc_cpu_set(&ctdp_level.core_cpumask);
0080     ret = isst_get_coremask_info(cpu, pkg_dev.current_level, &ctdp_level);
0081     if (ret) {
0082         free_cpu_set(ctdp_level.core_cpumask);
0083         debug_printf("Can't get core_mask:%d\n", cpu);
0084         return;
0085     }
0086
0087     if (ctdp_level.cpu_count) {
0088         int i, max_cpus = get_topo_max_cpus();
0089         for (i = 0; i < max_cpus; ++i) {
0090             if (pkg_id != get_physical_package_id(i) || die_id != get_physical_die_id(i))
0091                 continue;
0092             if (CPU_ISSET_S(i, ctdp_level.core_cpumask_size, ctdp_level.core_cpumask)) {
0093                 fprintf(stderr, "online cpu %d\n", i);
0094                 set_cpu_online_offline(i, 1);
0095             } else {
0096                 fprintf(stderr, "offline cpu %d\n", i);
0097                 set_cpu_online_offline(i, 0);
0098             }
0099         }
0100     }
0101
0102     free_cpu_set(ctdp_level.core_cpumask);
0103 }
0104
0105 static void _poll_for_config_change(int cpu, void *arg1, void *arg2,
0106                     void *arg3, void *arg4)
0107 {
0108     process_level_change(cpu);
0109 }
0110
0111 static void poll_for_config_change(void)
0112 {
0113     for_each_online_package_in_set(_poll_for_config_change, NULL, NULL,
0114                        NULL, NULL);
0115 }
0116
0117 static int done = 0;
0118 static int pid_file_handle;
0119
0120 static void signal_handler(int sig)
0121 {
0122     switch (sig) {
0123     case SIGINT:
0124     case SIGTERM:
0125         done = 1;
0126         hfi_exit();
0127         exit(0);
0128         break;
0129     default:
0130         break;
0131     }
0132 }
0133
0134 static void daemonize(char *rundir, char *pidfile)
0135 {
0136     int pid, sid, i;
0137     char str[10];
0138     struct sigaction sig_actions;
0139     sigset_t sig_set;
0140     int ret;
0141
0142     if (getppid() == 1)
0143         return;
0144
0145     sigemptyset(&sig_set);
0146     sigaddset(&sig_set, SIGCHLD);
0147     sigaddset(&sig_set, SIGTSTP);
0148     sigaddset(&sig_set, SIGTTOU);
0149     sigaddset(&sig_set, SIGTTIN);
0150     sigprocmask(SIG_BLOCK, &sig_set, NULL);
0151
0152     sig_actions.sa_handler = signal_handler;
0153     sigemptyset(&sig_actions.sa_mask);
0154     sig_actions.sa_flags = 0;
0155
0156     sigaction(SIGHUP, &sig_actions, NULL);
0157     sigaction(SIGTERM, &sig_actions, NULL);
0158     sigaction(SIGINT, &sig_actions, NULL);
0159
0160     pid = fork();
0161     if (pid < 0) {
0162         /* Could not fork */
0163         exit(EXIT_FAILURE);
0164     }
0165     if (pid > 0)
0166         exit(EXIT_SUCCESS);
0167
0168     umask(027);
0169
0170     sid = setsid();
0171     if (sid < 0)
0172         exit(EXIT_FAILURE);
0173
0174     /* close all descriptors */
0175     for (i = getdtablesize(); i >= 0; --i)
0176         close(i);
0177
0178     i = open("/dev/null", O_RDWR);
0179     ret = dup(i);
0180     if (ret == -1)
0181         exit(EXIT_FAILURE);
0182
0183     ret = dup(i);
0184     if (ret == -1)
0185         exit(EXIT_FAILURE);
0186
0187     ret = chdir(rundir);
0188     if (ret == -1)
0189         exit(EXIT_FAILURE);
0190
0191     pid_file_handle = open(pidfile, O_RDWR | O_CREAT, 0600);
0192     if (pid_file_handle == -1) {
0193         /* Couldn't open lock file */
0194         exit(1);
0195     }
0196     /* Try to lock file */
0197 #ifdef LOCKF_SUPPORT
0198     if (lockf(pid_file_handle, F_TLOCK, 0) == -1) {
0199 #else
0200     if (flock(pid_file_handle, LOCK_EX|LOCK_NB) < 0) {
0201 #endif
0202         /* Couldn't get lock on lock file */
0203         fprintf(stderr, "Couldn't get lock file %d\n", getpid());
0204         exit(1);
0205     }
0206     snprintf(str, sizeof(str), "%d\n", getpid());
0207     ret = write(pid_file_handle, str, strlen(str));
0208     if (ret == -1)
0209         exit(EXIT_FAILURE);
0210
0211     close(i);
0212 }
0213
0214 int isst_daemon(int debug_mode, int poll_interval, int no_daemon)
0215 {
0216     int ret;
0217
0218     if (!no_daemon && poll_interval < 0 && !debug_mode) {
0219         fprintf(stderr, "OOB mode is enabled and will run as daemon\n");
0220         daemonize((char *) "/tmp/",
0221                 (char *)"/tmp/hfi-events.pid");
0222     } else {
0223         signal(SIGINT, signal_handler);
0224     }
0225
0226     init_levels();
0227
0228     if (poll_interval < 0) {
0229         ret = hfi_main();
0230         if (ret) {
0231             fprintf(stderr, "HFI initialization failed\n");
0232         }
0233         fprintf(stderr, "Must specify poll-interval\n");
0234         return ret;
0235     }
0236
0237     debug_printf("Starting loop\n");
0238     while (!done) {
0239         sleep(poll_interval);
0240         poll_for_config_change();
0241     }
0242
0243     return 0;
0244 }