| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Srinivas Pandruvada | 12303 | 81.44% | 76 | 66.09% |
| Rui Zhang | 1546 | 10.23% | 27 | 23.48% |
| Prarit Bhargava | 1223 | 8.10% | 10 | 8.70% |
| Jonathan Doman | 34 | 0.23% | 1 | 0.87% |
| Dan Carpenter | 1 | 0.01% | 1 | 0.87% |
| Total | 15107 | 115 |
// SPDX-License-Identifier: GPL-2.0 /* * Intel Speed Select -- Enumerate and control features * Copyright (c) 2019 Intel Corporation. */ #include <ctype.h> #include <linux/isst_if.h> #include "isst.h" struct process_cmd_struct { char *feature; char *command; void (*process_fn)(int arg); int arg; }; static const char *version_str = "v1.20"; static const int supported_api_ver = 3; static struct isst_if_platform_info isst_platform_info; static char *progname; static int debug_flag; static FILE *outf; static int cpu_model; static int cpu_stepping; #define MAX_CPUS_IN_ONE_REQ 512 static short max_target_cpus; static unsigned short target_cpus[MAX_CPUS_IN_ONE_REQ]; static int topo_max_cpus; static size_t present_cpumask_size; static cpu_set_t *present_cpumask; static size_t target_cpumask_size; static cpu_set_t *target_cpumask; static int tdp_level = 0xFF; static int fact_bucket = 0xFF; static int fact_avx = 0xFF; static unsigned long long fact_trl; static int out_format_json; static int cmd_help; static int force_online_offline; static int auto_mode; static int fact_enable_fail; static int cgroupv2; static int max_die_id; static int max_punit_id; /* clos related */ static int current_clos = -1; static int clos_epp = -1; static int clos_prop_prio = -1; static int clos_min = -1; static int clos_max = -1; static int clos_desired = -1; static int clos_priority_type; static int cpu_0_cgroupv2; static int cpu_0_workaround(int isolate); struct _cpu_map { unsigned short core_id; unsigned short pkg_id; unsigned short die_id; unsigned short punit_id; unsigned short punit_cpu; unsigned short punit_cpu_core; unsigned short initialized; }; struct _cpu_map *cpu_map; struct cpu_topology { short cpu; short core_id; short pkg_id; short die_id; }; FILE *get_output_file(void) { return outf; } int is_debug_enabled(void) { return debug_flag; } void debug_printf(const char *format, ...) { va_list args; va_start(args, format); if (debug_flag) vprintf(format, args); va_end(args); } int is_clx_n_platform(void) { if (cpu_model == 0x55) if (cpu_stepping == 0x6 || cpu_stepping == 0x7) return 1; return 0; } int is_skx_based_platform(void) { if (cpu_model == 0x55) return 1; return 0; } int is_spr_platform(void) { if (cpu_model == 0x8F) return 1; return 0; } int is_emr_platform(void) { if (cpu_model == 0xCF) return 1; return 0; } int is_icx_platform(void) { if (cpu_model == 0x6A || cpu_model == 0x6C) return 1; return 0; } static int update_cpu_model(void) { unsigned int ebx, ecx, edx; unsigned int fms, family; __cpuid(1, fms, ebx, ecx, edx); family = (fms >> 8) & 0xf; cpu_model = (fms >> 4) & 0xf; if (family == 6 || family == 0xf) cpu_model += ((fms >> 16) & 0xf) << 4; cpu_stepping = fms & 0xf; /* only three CascadeLake-N models are supported */ if (is_clx_n_platform()) { FILE *fp; size_t n = 0; char *line = NULL; int ret = 1; fp = fopen("/proc/cpuinfo", "r"); if (!fp) err(-1, "cannot open /proc/cpuinfo\n"); while (getline(&line, &n, fp) > 0) { if (strstr(line, "model name")) { if (strstr(line, "6252N") || strstr(line, "6230N") || strstr(line, "5218N")) ret = 0; break; } } free(line); fclose(fp); return ret; } return 0; } int api_version(void) { return isst_platform_info.api_version; } /* Open a file, and exit on failure */ static FILE *fopen_or_exit(const char *path, const char *mode) { FILE *filep = fopen(path, mode); if (!filep) err(1, "%s: open failed", path); return filep; } /* Parse a file containing a single int */ static int parse_int_file(int fatal, const char *fmt, ...) { va_list args; char path[PATH_MAX]; FILE *filep; int value; va_start(args, fmt); vsnprintf(path, sizeof(path), fmt, args); va_end(args); if (fatal) { filep = fopen_or_exit(path, "r"); } else { filep = fopen(path, "r"); if (!filep) return -1; } if (fscanf(filep, "%d", &value) != 1) err(1, "%s: failed to parse number from file", path); fclose(filep); return value; } int cpufreq_sysfs_present(void) { DIR *dir; dir = opendir("/sys/devices/system/cpu/cpu0/cpufreq"); if (dir) { closedir(dir); return 1; } return 0; } int out_format_is_json(void) { return out_format_json; } static int get_stored_topology_info(int cpu, int *core_id, int *pkg_id, int *die_id) { const char *pathname = "/var/run/isst_cpu_topology.dat"; struct cpu_topology cpu_top; FILE *fp; int ret; fp = fopen(pathname, "rb"); if (!fp) return -1; ret = fseek(fp, cpu * sizeof(cpu_top), SEEK_SET); if (ret) goto err_ret; ret = fread(&cpu_top, sizeof(cpu_top), 1, fp); if (ret != 1) { ret = -1; goto err_ret; } *pkg_id = cpu_top.pkg_id; *core_id = cpu_top.core_id; *die_id = cpu_top.die_id; ret = 0; err_ret: fclose(fp); return ret; } static void store_cpu_topology(void) { const char *pathname = "/var/run/isst_cpu_topology.dat"; FILE *fp; int i; fp = fopen(pathname, "rb"); if (fp) { /* Mapping already exists */ fclose(fp); return; } fp = fopen(pathname, "wb"); if (!fp) { fprintf(stderr, "Can't create file:%s\n", pathname); return; } fprintf(stderr, "Caching topology information\n"); for (i = 0; i < topo_max_cpus; ++i) { struct cpu_topology cpu_top; cpu_top.core_id = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/topology/core_id", i); if (cpu_top.core_id < 0) cpu_top.core_id = -1; cpu_top.pkg_id = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/topology/physical_package_id", i); if (cpu_top.pkg_id < 0) cpu_top.pkg_id = -1; cpu_top.die_id = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/topology/die_id", i); if (cpu_top.die_id < 0) cpu_top.die_id = -1; cpu_top.cpu = i; if (fwrite(&cpu_top, sizeof(cpu_top), 1, fp) != 1) { fprintf(stderr, "Can't write to:%s\n", pathname); break; } } fclose(fp); } static int get_physical_package_id(int cpu) { int ret; if (cpu < 0) return -1; if (cpu_map && cpu_map[cpu].initialized) return cpu_map[cpu].pkg_id; ret = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu); if (ret < 0) { int core_id, pkg_id, die_id; ret = get_stored_topology_info(cpu, &core_id, &pkg_id, &die_id); if (!ret) return pkg_id; } return ret; } static int get_physical_core_id(int cpu) { int ret; if (cpu < 0) return -1; if (cpu_map && cpu_map[cpu].initialized) return cpu_map[cpu].core_id; ret = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/topology/core_id", cpu); if (ret < 0) { int core_id, pkg_id, die_id; ret = get_stored_topology_info(cpu, &core_id, &pkg_id, &die_id); if (!ret) return core_id; } return ret; } static int get_physical_die_id(int cpu) { int ret; if (cpu < 0) return -1; if (cpu_map && cpu_map[cpu].initialized) return cpu_map[cpu].die_id; ret = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/topology/die_id", cpu); if (ret < 0) { int core_id, pkg_id, die_id; ret = get_stored_topology_info(cpu, &core_id, &pkg_id, &die_id); if (!ret) { if (die_id < 0) die_id = 0; return die_id; } } if (ret < 0) ret = 0; return ret; } static int get_physical_punit_id(int cpu) { if (cpu < 0) return -1; if (cpu_map && cpu_map[cpu].initialized) return cpu_map[cpu].punit_id; return -1; } void set_isst_id(struct isst_id *id, int cpu) { id->cpu = cpu; id->pkg = get_physical_package_id(cpu); if (id->pkg >= MAX_PACKAGE_COUNT) id->pkg = -1; id->die = get_physical_die_id(cpu); if (id->die >= MAX_DIE_PER_PACKAGE) id->die = -1; id->punit = get_physical_punit_id(cpu); if (id->punit >= MAX_PUNIT_PER_DIE) id->punit = -1; } int is_cpu_in_power_domain(int cpu, struct isst_id *id) { struct isst_id tid; set_isst_id(&tid, cpu); if (id->pkg == tid.pkg && id->die == tid.die && id->punit == tid.punit) return 1; return 0; } int get_cpufreq_base_freq(int cpu) { return parse_int_file(0, "/sys/devices/system/cpu/cpu%d/cpufreq/base_frequency", cpu); } int get_topo_max_cpus(void) { return topo_max_cpus; } static unsigned int is_cpu_online(int cpu) { char buffer[128]; int fd, ret; unsigned char online; snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/online", cpu); fd = open(buffer, O_RDONLY); if (fd < 0) return fd; ret = read(fd, &online, sizeof(online)); close(fd); if (ret == -1) return ret; if (online == '1') online = 1; else online = 0; return online; } void set_cpu_online_offline(int cpu, int state) { char buffer[128]; int fd, ret; if (cpu_0_cgroupv2 && !cpu) { fprintf(stderr, "Will use cgroup v2 for CPU 0\n"); cpu_0_workaround(!state); return; } snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/online", cpu); fd = open(buffer, O_WRONLY); if (fd < 0) { if (!cpu) { fprintf(stderr, "This system is not configured for CPU 0 online/offline\n"); fprintf(stderr, "Will use cgroup v2\n"); cpu_0_workaround(!state); return; } err(-1, "%s open failed", buffer); } if (state) ret = write(fd, "1\n", 2); else ret = write(fd, "0\n", 2); if (ret == -1) perror("Online/Offline: Operation failed\n"); close(fd); } static void force_all_cpus_online(void) { int i; fprintf(stderr, "Forcing all CPUs online\n"); for (i = 0; i < topo_max_cpus; ++i) set_cpu_online_offline(i, 1); unlink("/var/run/isst_cpu_topology.dat"); } void for_each_online_power_domain_in_set(void (*callback)(struct isst_id *, void *, void *, void *, void *), void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_id id; int cpus[MAX_PACKAGE_COUNT][MAX_DIE_PER_PACKAGE][MAX_PUNIT_PER_DIE]; int valid_mask[MAX_PACKAGE_COUNT][MAX_DIE_PER_PACKAGE] = {0}; int i, j, k; memset(cpus, -1, sizeof(cpus)); for (i = 0; i < topo_max_cpus; ++i) { int online; if (!CPU_ISSET_S(i, present_cpumask_size, present_cpumask)) continue; online = parse_int_file( i != 0, "/sys/devices/system/cpu/cpu%d/online", i); if (online < 0) online = 1; /* online entry for CPU 0 needs some special configs */ if (!online) continue; set_isst_id(&id, i); if (id.pkg < 0 || id.die < 0 || id.punit < 0) continue; valid_mask[id.pkg][id.die] = 1; if (cpus[id.pkg][id.die][id.punit] == -1) cpus[id.pkg][id.die][id.punit] = i; } for (i = 0; i < MAX_PACKAGE_COUNT; i++) { if (max_die_id == max_punit_id) { for (k = 0; k < MAX_PUNIT_PER_DIE && k < MAX_DIE_PER_PACKAGE; k++) { id.cpu = cpus[i][k][k]; id.pkg = i; id.die = k; id.punit = k; if (isst_is_punit_valid(&id)) callback(&id, arg1, arg2, arg3, arg4); } continue; } for (j = 0; j < MAX_DIE_PER_PACKAGE; j++) { /* * Fix me: * How to check a non-cpu die for a package/die with all cpu offlined? */ if (!valid_mask[i][j]) continue; for (k = 0; k < MAX_PUNIT_PER_DIE; k++) { id.cpu = cpus[i][j][k]; id.pkg = i; id.die = j; id.punit = k; if (isst_is_punit_valid(&id)) callback(&id, arg1, arg2, arg3, arg4); } } } } static void for_each_online_target_cpu_in_set( void (*callback)(struct isst_id *, void *, void *, void *, void *), void *arg1, void *arg2, void *arg3, void *arg4) { int i, found = 0; struct isst_id id; for (i = 0; i < topo_max_cpus; ++i) { int online; if (!CPU_ISSET_S(i, target_cpumask_size, target_cpumask)) continue; if (i) online = parse_int_file( 1, "/sys/devices/system/cpu/cpu%d/online", i); else online = 1; /* online entry for CPU 0 needs some special configs */ set_isst_id(&id, i); if (online && callback) { callback(&id, arg1, arg2, arg3, arg4); found = 1; } } if (!found) fprintf(stderr, "No valid CPU in the list\n"); } #define BITMASK_SIZE 32 static void set_max_cpu_num(void) { FILE *filep; unsigned long dummy; int i; topo_max_cpus = 0; for (i = 0; i < 256; ++i) { char path[256]; snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%d/topology/thread_siblings", i); filep = fopen(path, "r"); if (filep) break; } if (!filep) { fprintf(stderr, "Can't get max cpu number\n"); exit(0); } while (fscanf(filep, "%lx,", &dummy) == 1) topo_max_cpus += BITMASK_SIZE; fclose(filep); debug_printf("max cpus %d\n", topo_max_cpus); } size_t alloc_cpu_set(cpu_set_t **cpu_set) { cpu_set_t *_cpu_set; size_t size; _cpu_set = CPU_ALLOC((topo_max_cpus + 1)); if (_cpu_set == NULL) err(3, "CPU_ALLOC"); size = CPU_ALLOC_SIZE((topo_max_cpus + 1)); CPU_ZERO_S(size, _cpu_set); *cpu_set = _cpu_set; return size; } void free_cpu_set(cpu_set_t *cpu_set) { CPU_FREE(cpu_set); } static int cpu_cnt[MAX_PACKAGE_COUNT][MAX_DIE_PER_PACKAGE][MAX_PUNIT_PER_DIE]; int get_max_punit_core_id(struct isst_id *id) { int max_id = 0; int i; for (i = 0; i < topo_max_cpus; ++i) { if (!CPU_ISSET_S(i, present_cpumask_size, present_cpumask)) continue; if (is_cpu_in_power_domain(i, id) && cpu_map[i].punit_cpu_core > max_id) max_id = cpu_map[i].punit_cpu_core; } return max_id; } int get_cpu_count(struct isst_id *id) { if (id->pkg < 0 || id->die < 0 || id->punit < 0) return 0; return cpu_cnt[id->pkg][id->die][id->punit]; } static void update_punit_cpu_info(__u32 physical_cpu, struct _cpu_map *cpu_map) { if (api_version() > 1) { /* * MSR 0x54 format * [15:11] PM_DOMAIN_ID * [10:3] MODULE_ID (aka IDI_AGENT_ID) * [2:0] LP_ID (We don't care about these bits we only * care die and core id * For Atom: * [2] Always 0 * [1:0] core ID within module * For Core * [2:1] Always 0 * [0] thread ID */ cpu_map->punit_id = (physical_cpu >> 11) & 0x1f; cpu_map->punit_cpu_core = (physical_cpu >> 3) & 0xff; cpu_map->punit_cpu = physical_cpu & 0x7ff; } else { int punit_id; /* * MSR 0x53 format * Format * Bit 0 – thread ID * Bit 8:1 – core ID * Bit 13:9 – punit ID */ cpu_map->punit_cpu = physical_cpu & 0x1ff; cpu_map->punit_cpu_core = (cpu_map->punit_cpu >> 1); // shift to get core id punit_id = (physical_cpu >> 9) & 0x1f; if (punit_id >= MAX_PUNIT_PER_DIE) punit_id = 0; cpu_map->punit_id = punit_id; } } static void create_cpu_map(void) { const char *pathname = "/dev/isst_interface"; size_t size; DIR *dir; int i, fd = 0; struct isst_if_cpu_maps map; /* Use calloc to make sure the memory is initialized to Zero */ cpu_map = calloc(topo_max_cpus, sizeof(*cpu_map)); if (!cpu_map) err(3, "cpumap"); fd = open(pathname, O_RDWR); if (fd < 0 && !is_clx_n_platform()) err(-1, "%s open failed", pathname); size = alloc_cpu_set(&present_cpumask); present_cpumask_size = size; for (i = 0; i < topo_max_cpus; ++i) { char buffer[256]; int pkg_id, die_id, core_id, punit_id; /* check if CPU is online */ snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d", i); dir = opendir(buffer); if (!dir) continue; closedir(dir); CPU_SET_S(i, size, present_cpumask); pkg_id = get_physical_package_id(i); die_id = get_physical_die_id(i); core_id = get_physical_core_id(i); if (pkg_id < 0 || die_id < 0 || core_id < 0) continue; cpu_map[i].pkg_id = pkg_id; cpu_map[i].die_id = die_id; cpu_map[i].core_id = core_id; punit_id = 0; if (fd >= 0) { map.cmd_count = 1; map.cpu_map[0].logical_cpu = i; debug_printf(" map logical_cpu:%d\n", map.cpu_map[0].logical_cpu); if (ioctl(fd, ISST_IF_GET_PHY_ID, &map) == -1) { perror("ISST_IF_GET_PHY_ID"); fprintf(outf, "Error: map logical_cpu:%d\n", map.cpu_map[0].logical_cpu); } else { update_punit_cpu_info(map.cpu_map[0].physical_cpu, &cpu_map[i]); punit_id = cpu_map[i].punit_id; } } cpu_map[i].initialized = 1; cpu_cnt[pkg_id][die_id][punit_id]++; if (max_die_id < die_id) max_die_id = die_id; if (max_punit_id < cpu_map[i].punit_id) max_punit_id = cpu_map[i].punit_id; debug_printf( "map logical_cpu:%d core: %d die:%d pkg:%d punit:%d punit_cpu:%d punit_core:%d\n", i, cpu_map[i].core_id, cpu_map[i].die_id, cpu_map[i].pkg_id, cpu_map[i].punit_id, cpu_map[i].punit_cpu, cpu_map[i].punit_cpu_core); } if (fd >= 0) close(fd); size = alloc_cpu_set(&target_cpumask); target_cpumask_size = size; for (i = 0; i < max_target_cpus; ++i) { if (!CPU_ISSET_S(target_cpus[i], present_cpumask_size, present_cpumask)) continue; CPU_SET_S(target_cpus[i], size, target_cpumask); } } void set_cpu_mask_from_punit_coremask(struct isst_id *id, unsigned long long core_mask, size_t core_cpumask_size, cpu_set_t *core_cpumask, int *cpu_cnt) { int i, cnt = 0; if (id->cpu < 0) return; *cpu_cnt = 0; for (i = 0; i < 64; ++i) { if (core_mask & BIT_ULL(i)) { int j; for (j = 0; j < topo_max_cpus; ++j) { if (!CPU_ISSET_S(j, present_cpumask_size, present_cpumask)) continue; if (is_cpu_in_power_domain(j, id) && cpu_map[j].punit_cpu_core == i) { CPU_SET_S(j, core_cpumask_size, core_cpumask); ++cnt; } } } } *cpu_cnt = cnt; } int find_phy_core_num(int logical_cpu) { if (logical_cpu < topo_max_cpus) return cpu_map[logical_cpu].punit_cpu_core; return -EINVAL; } int use_cgroupv2(void) { return cgroupv2; } int enable_cpuset_controller(void) { int fd, ret; fd = open("/sys/fs/cgroup/cgroup.subtree_control", O_RDWR, 0); if (fd < 0) { debug_printf("Can't activate cpuset controller\n"); debug_printf("Either you are not root user or CGroup v2 is not supported\n"); return fd; } ret = write(fd, " +cpuset", strlen(" +cpuset")); close(fd); if (ret == -1) { debug_printf("Can't activate cpuset controller: Write failed\n"); return ret; } return 0; } int isolate_cpus(struct isst_id *id, int mask_size, cpu_set_t *cpu_mask, int level, int cpu_0_only) { int i, first, curr_index, index, ret, fd; static char str[512], dir_name[64]; static char cpuset_cpus[128]; int str_len = sizeof(str); DIR *dir; snprintf(dir_name, sizeof(dir_name), "/sys/fs/cgroup/%d-%d-%d", id->pkg, id->die, id->punit); dir = opendir(dir_name); if (!dir) { ret = mkdir(dir_name, 0744); if (ret) { debug_printf("Can't create dir:%s errno:%d\n", dir_name, errno); return ret; } } closedir(dir); if (!level) { sprintf(cpuset_cpus, "%s/cpuset.cpus.partition", dir_name); fd = open(cpuset_cpus, O_RDWR, 0); if (fd < 0) { return fd; } ret = write(fd, "member", strlen("member")); if (ret == -1) { printf("Can't update to member\n"); return ret; } return 0; } if (!CPU_COUNT_S(mask_size, cpu_mask)) { return -1; } curr_index = 0; first = 1; str[0] = '\0'; if (cpu_0_only) { snprintf(str, str_len, "0"); goto create_partition; } for (i = 0; i < get_topo_max_cpus(); ++i) { if (!is_cpu_in_power_domain(i, id)) continue; if (CPU_ISSET_S(i, mask_size, cpu_mask)) continue; if (!first) { index = snprintf(&str[curr_index], str_len - curr_index, ","); curr_index += index; if (curr_index >= str_len) break; } index = snprintf(&str[curr_index], str_len - curr_index, "%d", i); curr_index += index; if (curr_index >= str_len) break; first = 0; } create_partition: debug_printf("isolated CPUs list: package:%d curr_index:%d [%s]\n", id->pkg, curr_index ,str); snprintf(cpuset_cpus, sizeof(cpuset_cpus), "%s/cpuset.cpus", dir_name); fd = open(cpuset_cpus, O_RDWR, 0); if (fd < 0) { return fd; } ret = write(fd, str, strlen(str)); close(fd); if (ret == -1) { debug_printf("Can't activate cpuset controller: Write failed\n"); return ret; } snprintf(cpuset_cpus, sizeof(cpuset_cpus), "%s/cpuset.cpus.partition", dir_name); fd = open(cpuset_cpus, O_RDWR, 0); if (fd < 0) { return fd; } ret = write(fd, "isolated", strlen("isolated")); if (ret == -1) { debug_printf("Can't update to isolated\n"); ret = write(fd, "root", strlen("root")); if (ret == -1) debug_printf("Can't update to root\n"); } close(fd); if (ret < 0) return ret; return 0; } static int cpu_0_workaround(int isolate) { int fd, fd1, len, ret; cpu_set_t cpu_mask; struct isst_id id; char str[2]; debug_printf("isolate CPU 0 state: %d\n", isolate); if (isolate) goto isolate; /* First check if CPU 0 was isolated to remove isolation. */ /* If the cpuset.cpus doesn't exist, that means that none of the CPUs are isolated*/ fd = open("/sys/fs/cgroup/0-0-0/cpuset.cpus", O_RDONLY, 0); if (fd < 0) return 0; len = read(fd, str, sizeof(str)); /* Error check, but unlikely to fail. If fails that means that not isolated */ if (len == -1) return 0; /* Is CPU 0 is in isolate list, the display is sorted so first element will be CPU 0*/ if (str[0] != '0') { close(fd); return 0; } fd1 = open("/sys/fs/cgroup/0-0-0/cpuset.cpus.partition", O_RDONLY, 0); /* Unlikely that, this attribute is not present, but handle error */ if (fd1 < 0) { close(fd); return 0; } /* Is CPU 0 already changed partition to "member" */ len = read(fd1, str, sizeof(str)); if (len != -1 && str[0] == 'm') { close(fd1); close(fd); return 0; } close(fd1); close(fd); debug_printf("CPU 0 was isolated before, so remove isolation\n"); isolate: ret = enable_cpuset_controller(); if (ret) goto isolate_fail; CPU_ZERO(&cpu_mask); memset(&id, 0, sizeof(struct isst_id)); CPU_SET(0, &cpu_mask); ret = isolate_cpus(&id, sizeof(cpu_mask), &cpu_mask, isolate, 1); isolate_fail: if (ret) fprintf(stderr, "Can't isolate CPU 0\n"); return ret; } static int isst_fill_platform_info(void) { const char *pathname = "/dev/isst_interface"; int fd; if (is_clx_n_platform()) { isst_platform_info.api_version = 1; goto set_platform_ops; } fd = open(pathname, O_RDWR); if (fd < 0) err(-1, "%s open failed", pathname); if (ioctl(fd, ISST_IF_GET_PLATFORM_INFO, &isst_platform_info) == -1) { perror("ISST_IF_GET_PLATFORM_INFO"); close(fd); return -1; } close(fd); if (isst_platform_info.api_version > supported_api_ver) { printf("Incompatible API versions; Upgrade of tool is required\n"); return -1; } set_platform_ops: if (isst_set_platform_ops(isst_platform_info.api_version)) { fprintf(stderr, "Failed to set platform callbacks\n"); exit(0); } return 0; } void get_isst_status(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_pkg_ctdp pkg_dev; struct isst_id *tid = (struct isst_id *)arg2; int *mask = (int *)arg3; int *max_level = (int *)arg4; int j, ret; /* Only check the first cpu power domain */ if (id->cpu < 0 || tid->cpu >= 0) return; ret = isst_get_ctdp_levels(id, &pkg_dev); if (ret) return; if (pkg_dev.enabled) *mask |= BIT(0); if (pkg_dev.locked) *mask |= BIT(1); if (*max_level < pkg_dev.levels) *max_level = pkg_dev.levels; for (j = 0; j <= pkg_dev.levels; ++j) { struct isst_pkg_ctdp_level_info ctdp_level; ret = isst_get_ctdp_control(id, j, &ctdp_level); if (ret) continue; if (ctdp_level.fact_support) *mask |= BIT(2); if (ctdp_level.pbf_support) *mask |= BIT(3); } tid->cpu = id->cpu; tid->pkg = id->pkg; tid->die = id->die; tid->punit = id->punit; } static void isst_print_extended_platform_info(void) { int cp_state, cp_cap; struct isst_id id; int mask = 0, max_level = 0; id.cpu = -1; for_each_online_power_domain_in_set(get_isst_status, NULL, &id, &mask, &max_level); if (mask & BIT(0)) { fprintf(outf, "Intel(R) SST-PP (feature perf-profile) is supported\n"); } else { fprintf(outf, "Intel(R) SST-PP (feature perf-profile) is not supported\n"); fprintf(outf, "Only performance level 0 (base level) is present\n"); } if (mask & BIT(1)) fprintf(outf, "TDP level change control is locked\n"); else fprintf(outf, "TDP level change control is unlocked, max level: %d\n", max_level); if (mask & BIT(2)) fprintf(outf, "Intel(R) SST-TF (feature turbo-freq) is supported\n"); else fprintf(outf, "Intel(R) SST-TF (feature turbo-freq) is not supported\n"); if (mask & BIT(3)) fprintf(outf, "Intel(R) SST-BF (feature base-freq) is supported\n"); else fprintf(outf, "Intel(R) SST-BF (feature base-freq) is not supported\n"); if (isst_read_pm_config(&id, &cp_state, &cp_cap)) { fprintf(outf, "Intel(R) SST-CP (feature core-power) status is unknown\n"); return; } if (cp_cap) fprintf(outf, "Intel(R) SST-CP (feature core-power) is supported\n"); else fprintf(outf, "Intel(R) SST-CP (feature core-power) is not supported\n"); } static void isst_print_platform_information(void) { if (is_clx_n_platform()) { fprintf(stderr, "\nThis option in not supported on this platform\n"); exit(0); } /* Early initialization to create working cpu_map */ set_max_cpu_num(); create_cpu_map(); fprintf(outf, "Platform: API version : %d\n", isst_platform_info.api_version); fprintf(outf, "Platform: Driver version : %d\n", isst_platform_info.driver_version); fprintf(outf, "Platform: mbox supported : %d\n", isst_platform_info.mbox_supported); fprintf(outf, "Platform: mmio supported : %d\n", isst_platform_info.mmio_supported); isst_print_extended_platform_info(); exit(0); } static char *local_str0, *local_str1; static void exec_on_get_ctdp_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { int (*fn_ptr)(struct isst_id *id, void *arg); int ret; fn_ptr = arg1; ret = fn_ptr(id, arg2); if (ret) isst_display_error_info_message(1, "get_tdp_* failed", 0, 0); else isst_ctdp_display_core_info(id, outf, arg3, *(unsigned int *)arg4, local_str0, local_str1); } #define _get_tdp_level(desc, suffix, object, help, str0, str1) \ static void get_tdp_##object(int arg) \ { \ struct isst_pkg_ctdp ctdp; \ \ if (cmd_help) { \ fprintf(stderr, \ "Print %s [No command arguments are required]\n", \ help); \ exit(0); \ } \ local_str0 = str0; \ local_str1 = str1; \ isst_ctdp_display_information_start(outf); \ if (max_target_cpus) \ for_each_online_target_cpu_in_set( \ exec_on_get_ctdp_cpu, isst_get_ctdp_##suffix, \ &ctdp, desc, &ctdp.object); \ else \ for_each_online_power_domain_in_set(exec_on_get_ctdp_cpu, \ isst_get_ctdp_##suffix, \ &ctdp, desc, \ &ctdp.object); \ isst_ctdp_display_information_end(outf); \ } _get_tdp_level("get-config-levels", levels, levels, "Max TDP level", NULL, NULL); _get_tdp_level("get-config-version", levels, version, "TDP version", NULL, NULL); _get_tdp_level("get-config-enabled", levels, enabled, "perf-profile enable status", "disabled", "enabled"); _get_tdp_level("get-config-current_level", levels, current_level, "Current TDP Level", NULL, NULL); _get_tdp_level("get-lock-status", levels, locked, "TDP lock status", "unlocked", "locked"); struct isst_pkg_ctdp clx_n_pkg_dev; static int clx_n_get_base_ratio(void) { FILE *fp; char *begin, *end, *line = NULL; char number[5]; float value = 0; size_t n = 0; fp = fopen("/proc/cpuinfo", "r"); if (!fp) err(-1, "cannot open /proc/cpuinfo\n"); while (getline(&line, &n, fp) > 0) { if (strstr(line, "model name")) { /* this is true for CascadeLake-N */ begin = strstr(line, "@ ") + 2; end = strstr(line, "GHz"); strncpy(number, begin, end - begin); value = atof(number) * 10; break; } } free(line); fclose(fp); return (int)(value); } static int clx_n_config(struct isst_id *id) { int i, ret; unsigned long cpu_bf; struct isst_pkg_ctdp_level_info *ctdp_level; struct isst_pbf_info *pbf_info; ctdp_level = &clx_n_pkg_dev.ctdp_level[0]; pbf_info = &ctdp_level->pbf_info; ctdp_level->core_cpumask_size = alloc_cpu_set(&ctdp_level->core_cpumask); /* find the frequency base ratio */ ctdp_level->tdp_ratio = clx_n_get_base_ratio(); if (ctdp_level->tdp_ratio == 0) { debug_printf("CLX: cn base ratio is zero\n"); ret = -1; goto error_ret; } /* find the high and low priority frequencies */ pbf_info->p1_high = 0; pbf_info->p1_low = ~0; for (i = 0; i < topo_max_cpus; i++) { if (!CPU_ISSET_S(i, present_cpumask_size, present_cpumask)) continue; if (!is_cpu_in_power_domain(i, id)) continue; CPU_SET_S(i, ctdp_level->core_cpumask_size, ctdp_level->core_cpumask); cpu_bf = parse_int_file(1, "/sys/devices/system/cpu/cpu%d/cpufreq/base_frequency", i); if (cpu_bf > pbf_info->p1_high) pbf_info->p1_high = cpu_bf; if (cpu_bf < pbf_info->p1_low) pbf_info->p1_low = cpu_bf; } if (pbf_info->p1_high == ~0UL) { debug_printf("CLX: maximum base frequency not set\n"); ret = -1; goto error_ret; } if (pbf_info->p1_low == 0) { debug_printf("CLX: minimum base frequency not set\n"); ret = -1; goto error_ret; } /* convert frequencies back to ratios */ pbf_info->p1_high = pbf_info->p1_high / 100000; pbf_info->p1_low = pbf_info->p1_low / 100000; /* create high priority cpu mask */ pbf_info->core_cpumask_size = alloc_cpu_set(&pbf_info->core_cpumask); for (i = 0; i < topo_max_cpus; i++) { if (!CPU_ISSET_S(i, present_cpumask_size, present_cpumask)) continue; if (!is_cpu_in_power_domain(i, id)) continue; cpu_bf = parse_int_file(1, "/sys/devices/system/cpu/cpu%d/cpufreq/base_frequency", i); cpu_bf = cpu_bf / 100000; if (cpu_bf == pbf_info->p1_high) CPU_SET_S(i, pbf_info->core_cpumask_size, pbf_info->core_cpumask); } /* extra ctdp & pbf struct parameters */ ctdp_level->processed = 1; ctdp_level->pbf_support = 1; /* PBF is always supported and enabled */ ctdp_level->pbf_enabled = 1; ctdp_level->fact_support = 0; /* FACT is never supported */ ctdp_level->fact_enabled = 0; return 0; error_ret: free_cpu_set(ctdp_level->core_cpumask); return ret; } static void dump_clx_n_config_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { int ret; if (tdp_level != 0xff && tdp_level != 0) { isst_display_error_info_message(1, "Invalid level", 1, tdp_level); exit(0); } ret = clx_n_config(id); if (ret) { debug_printf("clx_n_config failed"); } else { struct isst_pkg_ctdp_level_info *ctdp_level; struct isst_pbf_info *pbf_info; ctdp_level = &clx_n_pkg_dev.ctdp_level[0]; pbf_info = &ctdp_level->pbf_info; clx_n_pkg_dev.processed = 1; isst_ctdp_display_information(id, outf, tdp_level, &clx_n_pkg_dev); free_cpu_set(ctdp_level->core_cpumask); free_cpu_set(pbf_info->core_cpumask); } } static void dump_isst_config_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_pkg_ctdp pkg_dev; int ret; memset(&pkg_dev, 0, sizeof(pkg_dev)); ret = isst_get_process_ctdp(id, tdp_level, &pkg_dev); if (ret) { isst_display_error_info_message(1, "Failed to get perf-profile info on cpu", 1, id->cpu); isst_ctdp_display_information_end(outf); exit(1); } else { isst_ctdp_display_information(id, outf, tdp_level, &pkg_dev); isst_get_process_ctdp_complete(id, &pkg_dev); } } static void dump_isst_config(int arg) { void *fn; if (cmd_help) { fprintf(stderr, "Print Intel(R) Speed Select Technology Performance profile configuration\n"); fprintf(stderr, "including base frequency and turbo frequency configurations\n"); fprintf(stderr, "Optional: -l|--level : Specify tdp level\n"); fprintf(stderr, "\tIf no arguments, dump information for all TDP levels\n"); exit(0); } if (!is_clx_n_platform()) fn = dump_isst_config_for_cpu; else fn = dump_clx_n_config_for_cpu; isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(fn, NULL, NULL, NULL, NULL); else for_each_online_power_domain_in_set(fn, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static void adjust_scaling_max_from_base_freq(int cpu); static void set_tdp_level_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_pkg_ctdp pkg_dev; int ret; ret = isst_get_ctdp_levels(id, &pkg_dev); if (ret) { isst_display_error_info_message(1, "Get TDP level failed", 0, 0); isst_ctdp_display_information_end(outf); exit(1); } if (pkg_dev.current_level == tdp_level) { debug_printf("TDP level already set. Skipped\n"); goto display_result; } ret = isst_set_tdp_level(id, tdp_level); if (ret) { isst_display_error_info_message(1, "Set TDP level failed", 0, 0); isst_ctdp_display_information_end(outf); exit(1); } display_result: isst_display_result(id, outf, "perf-profile", "set_tdp_level", ret); if (force_online_offline && id->cpu >= 0) { struct isst_pkg_ctdp_level_info ctdp_level; /* Wait for updated base frequencies */ usleep(2000); /* Adjusting uncore freq */ isst_adjust_uncore_freq(id, tdp_level, &ctdp_level); fprintf(stderr, "Option is set to online/offline\n"); ctdp_level.core_cpumask_size = alloc_cpu_set(&ctdp_level.core_cpumask); ret = isst_get_coremask_info(id, tdp_level, &ctdp_level); if (ret) { isst_display_error_info_message(1, "Can't get coremask, online/offline option is ignored", 0, 0); goto free_mask; } if (use_cgroupv2()) { int ret; fprintf(stderr, "Using cgroup v2 in lieu of online/offline\n"); ret = enable_cpuset_controller(); if (ret) goto use_offline; ret = isolate_cpus(id, ctdp_level.core_cpumask_size, ctdp_level.core_cpumask, tdp_level, 0); if (ret) goto use_offline; goto free_mask; } use_offline: if (ctdp_level.cpu_count) { int i, max_cpus = get_topo_max_cpus(); for (i = 0; i < max_cpus; ++i) { if (!is_cpu_in_power_domain(i, id)) continue; if (CPU_ISSET_S(i, ctdp_level.core_cpumask_size, ctdp_level.core_cpumask)) { fprintf(stderr, "online cpu %d\n", i); set_cpu_online_offline(i, 1); adjust_scaling_max_from_base_freq(i); } else { fprintf(stderr, "offline cpu %d\n", i); set_cpu_online_offline(i, 0); } } } free_mask: free_cpu_set(ctdp_level.core_cpumask); } } static void set_tdp_level(int arg) { if (cmd_help) { fprintf(stderr, "Set Config TDP level\n"); fprintf(stderr, "\t Arguments: -l|--level : Specify tdp level\n"); fprintf(stderr, "\t Optional Arguments: -o | online : online/offline for the tdp level\n"); fprintf(stderr, "\t online/offline operation has limitations, refer to Linux hotplug documentation\n"); exit(0); } if (tdp_level == 0xff) { isst_display_error_info_message(1, "Invalid command: specify tdp_level", 0, 0); exit(1); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(set_tdp_level_for_cpu, NULL, NULL, NULL, NULL); else for_each_online_power_domain_in_set(set_tdp_level_for_cpu, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static void clx_n_dump_pbf_config_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { int ret; ret = clx_n_config(id); if (ret) { isst_display_error_info_message(1, "clx_n_config failed", 0, 0); } else { struct isst_pkg_ctdp_level_info *ctdp_level; struct isst_pbf_info *pbf_info; ctdp_level = &clx_n_pkg_dev.ctdp_level[0]; pbf_info = &ctdp_level->pbf_info; isst_pbf_display_information(id, outf, tdp_level, pbf_info); free_cpu_set(ctdp_level->core_cpumask); free_cpu_set(pbf_info->core_cpumask); } } static void dump_pbf_config_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_pbf_info pbf_info; int ret; ret = isst_get_pbf_info(id, tdp_level, &pbf_info); if (ret) { isst_display_error_info_message(1, "Failed to get base-freq info at this level", 1, tdp_level); isst_ctdp_display_information_end(outf); exit(1); } else { isst_pbf_display_information(id, outf, tdp_level, &pbf_info); free_cpu_set(pbf_info.core_cpumask); } } static void dump_pbf_config(int arg) { void *fn; if (cmd_help) { fprintf(stderr, "Print Intel(R) Speed Select Technology base frequency configuration for a TDP level\n"); fprintf(stderr, "\tArguments: -l|--level : Specify tdp level\n"); exit(0); } if (tdp_level == 0xff) { isst_display_error_info_message(1, "Invalid command: specify tdp_level", 0, 0); exit(1); } if (!is_clx_n_platform()) fn = dump_pbf_config_for_cpu; else fn = clx_n_dump_pbf_config_for_cpu; isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(fn, NULL, NULL, NULL, NULL); else for_each_online_power_domain_in_set(fn, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static int set_clos_param(struct isst_id *id, int clos, int epp, int wt, int min, int max) { struct isst_clos_config clos_config; int ret; ret = isst_pm_get_clos(id, clos, &clos_config); if (ret) { isst_display_error_info_message(1, "isst_pm_get_clos failed", 0, 0); return ret; } clos_config.clos_min = min; clos_config.clos_max = max; clos_config.epp = epp; clos_config.clos_prop_prio = wt; ret = isst_set_clos(id, clos, &clos_config); if (ret) { isst_display_error_info_message(1, "isst_set_clos failed", 0, 0); return ret; } return 0; } static int set_cpufreq_scaling_min_max(int cpu, int max, int freq) { char buffer[128], freq_str[16]; int fd, ret, len; if (max) snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_max_freq", cpu); else snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_min_freq", cpu); fd = open(buffer, O_WRONLY); if (fd < 0) return fd; snprintf(freq_str, sizeof(freq_str), "%d", freq); len = strlen(freq_str); ret = write(fd, freq_str, len); if (ret == -1) { close(fd); return ret; } close(fd); return 0; } static int no_turbo(void) { return parse_int_file(0, "/sys/devices/system/cpu/intel_pstate/no_turbo"); } static void adjust_scaling_max_from_base_freq(int cpu) { int base_freq, scaling_max_freq; scaling_max_freq = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_max_freq", cpu); base_freq = get_cpufreq_base_freq(cpu); if (scaling_max_freq < base_freq || no_turbo()) set_cpufreq_scaling_min_max(cpu, 1, base_freq); } static void adjust_scaling_min_from_base_freq(int cpu) { int base_freq, scaling_min_freq; scaling_min_freq = parse_int_file(0, "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_min_freq", cpu); base_freq = get_cpufreq_base_freq(cpu); if (scaling_min_freq < base_freq) set_cpufreq_scaling_min_max(cpu, 0, base_freq); } static int set_clx_pbf_cpufreq_scaling_min_max(struct isst_id *id) { struct isst_pkg_ctdp_level_info *ctdp_level; struct isst_pbf_info *pbf_info; int i, freq, freq_high, freq_low; int ret; ret = clx_n_config(id); if (ret) { debug_printf("cpufreq_scaling_min_max failed for CLX"); return ret; } ctdp_level = &clx_n_pkg_dev.ctdp_level[0]; pbf_info = &ctdp_level->pbf_info; freq_high = pbf_info->p1_high * 100000; freq_low = pbf_info->p1_low * 100000; for (i = 0; i < get_topo_max_cpus(); ++i) { if (!is_cpu_in_power_domain(i, id)) continue; if (CPU_ISSET_S(i, pbf_info->core_cpumask_size, pbf_info->core_cpumask)) freq = freq_high; else freq = freq_low; set_cpufreq_scaling_min_max(i, 1, freq); set_cpufreq_scaling_min_max(i, 0, freq); } return 0; } static int set_cpufreq_scaling_min_max_from_cpuinfo(int cpu, int cpuinfo_max, int scaling_max) { char buffer[128], min_freq[16]; int fd, ret, len; if (!CPU_ISSET_S(cpu, present_cpumask_size, present_cpumask)) return -1; if (cpuinfo_max) snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", cpu); else snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_min_freq", cpu); fd = open(buffer, O_RDONLY); if (fd < 0) return fd; len = read(fd, min_freq, sizeof(min_freq)); close(fd); if (len < 0) return len; if (scaling_max) snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_max_freq", cpu); else snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_min_freq", cpu); fd = open(buffer, O_WRONLY); if (fd < 0) return fd; min_freq[15] = '\0'; len = strlen(min_freq); ret = write(fd, min_freq, len); if (ret == -1) { close(fd); return ret; } close(fd); return 0; } static void set_scaling_min_to_cpuinfo_max(struct isst_id *id) { int i; if (id->cpu < 0) return; for (i = 0; i < get_topo_max_cpus(); ++i) { if (!is_cpu_in_power_domain(i, id)) continue; if (is_cpu_online(i) != 1) continue; adjust_scaling_max_from_base_freq(i); set_cpufreq_scaling_min_max_from_cpuinfo(i, 1, 0); adjust_scaling_min_from_base_freq(i); } } static void set_scaling_min_to_cpuinfo_min(struct isst_id *id) { int i; if (id->cpu < 0) return; for (i = 0; i < get_topo_max_cpus(); ++i) { if (!is_cpu_in_power_domain(i, id)) continue; if (is_cpu_online(i) != 1) continue; adjust_scaling_max_from_base_freq(i); set_cpufreq_scaling_min_max_from_cpuinfo(i, 0, 0); } } static void set_scaling_max_to_cpuinfo_max(struct isst_id *id) { int i; for (i = 0; i < get_topo_max_cpus(); ++i) { if (!is_cpu_in_power_domain(i, id)) continue; set_cpufreq_scaling_min_max_from_cpuinfo(i, 1, 1); } } static int set_core_priority_and_min(struct isst_id *id, int mask_size, cpu_set_t *cpu_mask, int min_high, int min_low) { int ret, i; if (!CPU_COUNT_S(mask_size, cpu_mask)) return -1; ret = set_clos_param(id, 0, 0, 0, min_high, 0xff); if (ret) return ret; ret = set_clos_param(id, 1, 15, 15, min_low, 0xff); if (ret) return ret; ret = set_clos_param(id, 2, 15, 15, min_low, 0xff); if (ret) return ret; ret = set_clos_param(id, 3, 15, 15, min_low, 0xff); if (ret) return ret; for (i = 0; i < get_topo_max_cpus(); ++i) { int clos; struct isst_id tid; if (!is_cpu_in_power_domain(i, id)) continue; if (CPU_ISSET_S(i, mask_size, cpu_mask)) clos = 0; else clos = 3; debug_printf("Associate cpu: %d clos: %d\n", i, clos); set_isst_id(&tid, i); ret = isst_clos_associate(&tid, clos); if (ret) { isst_display_error_info_message(1, "isst_clos_associate failed", 0, 0); return ret; } } return 0; } static int set_pbf_core_power(struct isst_id *id) { struct isst_pbf_info pbf_info; struct isst_pkg_ctdp pkg_dev; int ret; if (id->cpu < 0) return 0; ret = isst_get_ctdp_levels(id, &pkg_dev); if (ret) { debug_printf("isst_get_ctdp_levels failed"); return ret; } debug_printf("Current_level: %d\n", pkg_dev.current_level); ret = isst_get_pbf_info(id, pkg_dev.current_level, &pbf_info); if (ret) { debug_printf("isst_get_pbf_info failed"); return ret; } debug_printf("p1_high: %d p1_low: %d\n", pbf_info.p1_high, pbf_info.p1_low); ret = set_core_priority_and_min(id, pbf_info.core_cpumask_size, pbf_info.core_cpumask, pbf_info.p1_high, pbf_info.p1_low); if (ret) { debug_printf("set_core_priority_and_min failed"); return ret; } ret = isst_pm_qos_config(id, 1, 1); if (ret) { debug_printf("isst_pm_qos_config failed"); return ret; } return 0; } static void set_pbf_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_pkg_ctdp_level_info ctdp_level; struct isst_pkg_ctdp pkg_dev; int ret; int status = *(int *)arg4; if (is_clx_n_platform()) { ret = 0; if (status) { set_clx_pbf_cpufreq_scaling_min_max(id); } else { set_scaling_max_to_cpuinfo_max(id); set_scaling_min_to_cpuinfo_min(id); } goto disp_result; } ret = isst_get_ctdp_levels(id, &pkg_dev); if (ret) { isst_display_error_info_message(1, "Failed to get number of levels", 0, 0); goto disp_result; } ret = isst_get_ctdp_control(id, pkg_dev.current_level, &ctdp_level); if (ret) { isst_display_error_info_message(1, "Failed to get current level", 0, 0); goto disp_result; } if (!ctdp_level.pbf_support) { isst_display_error_info_message(1, "base-freq feature is not present at this level", 1, pkg_dev.current_level); ret = -1; goto disp_result; } if (auto_mode && status) { ret = set_pbf_core_power(id); if (ret) goto disp_result; } ret = isst_set_pbf_fact_status(id, 1, status); if (ret) { debug_printf("isst_set_pbf_fact_status failed"); if (auto_mode) isst_pm_qos_config(id, 0, 0); } else { if (auto_mode) { if (status) set_scaling_min_to_cpuinfo_max(id); else set_scaling_min_to_cpuinfo_min(id); } } if (auto_mode && !status) isst_pm_qos_config(id, 0, 1); disp_result: if (status) isst_display_result(id, outf, "base-freq", "enable", ret); else isst_display_result(id, outf, "base-freq", "disable", ret); } static void set_pbf_enable(int arg) { int enable = arg; if (cmd_help) { if (enable) { fprintf(stderr, "Enable Intel Speed Select Technology base frequency feature\n"); if (is_clx_n_platform()) { fprintf(stderr, "\tOn this platform this command doesn't enable feature in the hardware.\n"); fprintf(stderr, "\tIt updates the cpufreq scaling_min_freq to match cpufreq base_frequency.\n"); exit(0); } fprintf(stderr, "\tOptional Arguments: -a|--auto : Use priority of cores to set core-power associations\n"); } else { if (is_clx_n_platform()) { fprintf(stderr, "\tOn this platform this command doesn't disable feature in the hardware.\n"); fprintf(stderr, "\tIt updates the cpufreq scaling_min_freq to match cpuinfo_min_freq\n"); exit(0); } fprintf(stderr, "Disable Intel Speed Select Technology base frequency feature\n"); fprintf(stderr, "\tOptional Arguments: -a|--auto : Also disable core-power associations\n"); } exit(0); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(set_pbf_for_cpu, NULL, NULL, NULL, &enable); else for_each_online_power_domain_in_set(set_pbf_for_cpu, NULL, NULL, NULL, &enable); isst_ctdp_display_information_end(outf); } static void dump_fact_config_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_fact_info fact_info; int ret; memset(&fact_info, 0, sizeof(fact_info)); ret = isst_get_fact_info(id, tdp_level, fact_bucket, &fact_info); if (ret) { isst_display_error_info_message(1, "Failed to get turbo-freq info at this level", 1, tdp_level); isst_ctdp_display_information_end(outf); exit(1); } else { isst_fact_display_information(id, outf, tdp_level, fact_bucket, fact_avx, &fact_info); } } static void dump_fact_config(int arg) { if (cmd_help) { fprintf(stderr, "Print complete Intel Speed Select Technology turbo frequency configuration for a TDP level. Other arguments are optional.\n"); fprintf(stderr, "\tArguments: -l|--level : Specify tdp level\n"); fprintf(stderr, "\tArguments: -b|--bucket : Bucket index to dump\n"); fprintf(stderr, "\tArguments: -r|--trl-type : Specify trl type: sse|avx2|avx512\n"); exit(0); } if (tdp_level == 0xff) { isst_display_error_info_message(1, "Invalid command: specify tdp_level\n", 0, 0); exit(1); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(dump_fact_config_for_cpu, NULL, NULL, NULL, NULL); else for_each_online_power_domain_in_set(dump_fact_config_for_cpu, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static void set_fact_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_pkg_ctdp_level_info ctdp_level; struct isst_pkg_ctdp pkg_dev; int ret; int status = *(int *)arg4; if (status && no_turbo()) { isst_display_error_info_message(1, "Turbo mode is disabled", 0, 0); ret = -1; goto disp_results; } ret = isst_get_ctdp_levels(id, &pkg_dev); if (ret) { isst_display_error_info_message(1, "Failed to get number of levels", 0, 0); goto disp_results; } ret = isst_get_ctdp_control(id, pkg_dev.current_level, &ctdp_level); if (ret) { isst_display_error_info_message(1, "Failed to get current level", 0, 0); goto disp_results; } if (!ctdp_level.fact_support) { isst_display_error_info_message(1, "turbo-freq feature is not present at this level", 1, pkg_dev.current_level); ret = -1; goto disp_results; } if (status) { ret = isst_pm_qos_config(id, 1, 1); if (ret) goto disp_results; } ret = isst_set_pbf_fact_status(id, 0, status); if (ret) { debug_printf("isst_set_pbf_fact_status failed"); if (auto_mode) isst_pm_qos_config(id, 0, 0); goto disp_results; } /* Set TRL */ if (status) { struct isst_pkg_ctdp pkg_dev; ret = isst_get_ctdp_levels(id, &pkg_dev); if (!ret && id->cpu >= 0) ret = isst_set_trl(id, fact_trl); if (ret && auto_mode) isst_pm_qos_config(id, 0, 0); } else { if (auto_mode) isst_pm_qos_config(id, 0, 0); } disp_results: if (status) { isst_display_result(id, outf, "turbo-freq", "enable", ret); if (ret) fact_enable_fail = ret; } else { /* Since we modified TRL during Fact enable, restore it */ isst_set_trl_from_current_tdp(id, fact_trl); isst_display_result(id, outf, "turbo-freq", "disable", ret); } } static void set_fact_enable(int arg) { int i, ret, enable = arg; struct isst_id id; if (cmd_help) { if (enable) { fprintf(stderr, "Enable Intel Speed Select Technology Turbo frequency feature\n"); fprintf(stderr, "Optional: -t|--trl : Specify turbo ratio limit in hex starting with 0x\n"); fprintf(stderr, "\tOptional Arguments: -a|--auto : Designate specified target CPUs with"); fprintf(stderr, "-C|--cpu option as as high priority using core-power feature\n"); } else { fprintf(stderr, "Disable Intel Speed Select Technology turbo frequency feature\n"); fprintf(stderr, "Optional: -t|--trl : Specify turbo ratio limit in hex starting with 0x\n"); fprintf(stderr, "\tOptional Arguments: -a|--auto : Also disable core-power associations\n"); } exit(0); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(set_fact_for_cpu, NULL, NULL, NULL, &enable); else for_each_online_power_domain_in_set(set_fact_for_cpu, NULL, NULL, NULL, &enable); if (!fact_enable_fail && enable && auto_mode) { /* * When we adjust CLOS param, we have to set for siblings also. * So for the each user specified CPU, also add the sibling * in the present_cpu_mask. */ for (i = 0; i < get_topo_max_cpus(); ++i) { char buffer[128], sibling_list[128], *cpu_str; int fd, len; if (!CPU_ISSET_S(i, target_cpumask_size, target_cpumask)) continue; snprintf(buffer, sizeof(buffer), "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", i); fd = open(buffer, O_RDONLY); if (fd < 0) continue; len = read(fd, sibling_list, sizeof(sibling_list)); close(fd); if (len < 0) continue; sibling_list[127] = '\0'; cpu_str = strtok(sibling_list, ","); while (cpu_str != NULL) { int cpu; sscanf(cpu_str, "%d", &cpu); CPU_SET_S(cpu, target_cpumask_size, target_cpumask); cpu_str = strtok(NULL, ","); } } for (i = 0; i < get_topo_max_cpus(); ++i) { int clos; if (!CPU_ISSET_S(i, present_cpumask_size, present_cpumask)) continue; if (is_cpu_online(i) != 1) continue; set_isst_id(&id, i); ret = set_clos_param(&id, 0, 0, 0, 0, 0xff); if (ret) goto error_disp; ret = set_clos_param(&id, 1, 15, 15, 0, 0xff); if (ret) goto error_disp; ret = set_clos_param(&id, 2, 15, 15, 0, 0xff); if (ret) goto error_disp; ret = set_clos_param(&id, 3, 15, 15, 0, 0xff); if (ret) goto error_disp; if (CPU_ISSET_S(i, target_cpumask_size, target_cpumask)) clos = 0; else clos = 3; debug_printf("Associate cpu: %d clos: %d\n", i, clos); ret = isst_clos_associate(&id, clos); if (ret) goto error_disp; } set_isst_id(&id, -1); isst_display_result(&id, outf, "turbo-freq --auto", "enable", 0); } isst_ctdp_display_information_end(outf); return; error_disp: isst_display_result(&id, outf, "turbo-freq --auto", "enable", ret); isst_ctdp_display_information_end(outf); } static void enable_clos_qos_config(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { int ret; int status = *(int *)arg4; int cp_state, cp_cap; if (!isst_read_pm_config(id, &cp_state, &cp_cap)) { if (!cp_cap) { isst_display_error_info_message(1, "core-power not supported", 0, 0); return; } } if (is_skx_based_platform()) clos_priority_type = 1; ret = isst_pm_qos_config(id, status, clos_priority_type); if (ret) isst_display_error_info_message(1, "isst_pm_qos_config failed", 0, 0); if (status) isst_display_result(id, outf, "core-power", "enable", ret); else isst_display_result(id, outf, "core-power", "disable", ret); } static void set_clos_enable(int arg) { int enable = arg; if (cmd_help) { if (enable) { fprintf(stderr, "Enable core-power for a package/die\n"); if (!is_skx_based_platform()) { fprintf(stderr, "\tClos Enable: Specify priority type with [--priority|-p]\n"); fprintf(stderr, "\t\t 0: Proportional, 1: Ordered\n"); } } else { fprintf(stderr, "Disable core-power: [No command arguments are required]\n"); } exit(0); } if (enable && cpufreq_sysfs_present()) { fprintf(stderr, "cpufreq subsystem and core-power enable will interfere with each other!\n"); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(enable_clos_qos_config, NULL, NULL, NULL, &enable); else for_each_online_power_domain_in_set(enable_clos_qos_config, NULL, NULL, NULL, &enable); isst_ctdp_display_information_end(outf); } static void dump_clos_config_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_clos_config clos_config; int ret; ret = isst_pm_get_clos(id, current_clos, &clos_config); if (ret) isst_display_error_info_message(1, "isst_pm_get_clos failed", 0, 0); else isst_clos_display_information(id, outf, current_clos, &clos_config); } static void dump_clos_config(int arg) { if (cmd_help) { fprintf(stderr, "Print Intel Speed Select Technology core power configuration\n"); fprintf(stderr, "\tArguments: [-c | --clos]: Specify clos id\n"); exit(0); } if (current_clos < 0 || current_clos > 3) { isst_display_error_info_message(1, "Invalid clos id\n", 0, 0); isst_ctdp_display_information_end(outf); exit(0); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(dump_clos_config_for_cpu, NULL, NULL, NULL, NULL); else for_each_online_power_domain_in_set(dump_clos_config_for_cpu, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static void get_clos_info_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { int enable, ret, prio_type; ret = isst_clos_get_clos_information(id, &enable, &prio_type); if (ret) isst_display_error_info_message(1, "isst_clos_get_info failed", 0, 0); else { int cp_state, cp_cap; isst_read_pm_config(id, &cp_state, &cp_cap); isst_clos_display_clos_information(id, outf, enable, prio_type, cp_state, cp_cap); } } static void dump_clos_info(int arg) { if (cmd_help) { fprintf(stderr, "Print Intel Speed Select Technology core power information\n"); fprintf(stderr, "\t Optionally specify targeted cpu id with [--cpu|-c]\n"); exit(0); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(get_clos_info_for_cpu, NULL, NULL, NULL, NULL); else for_each_online_power_domain_in_set(get_clos_info_for_cpu, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static void set_clos_config_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { struct isst_clos_config clos_config; int ret; if (id->cpu < 0) return; clos_config.epp = clos_epp; clos_config.clos_prop_prio = clos_prop_prio; clos_config.clos_min = clos_min; clos_config.clos_max = clos_max; clos_config.clos_desired = clos_desired; ret = isst_set_clos(id, current_clos, &clos_config); if (ret) isst_display_error_info_message(1, "isst_set_clos failed", 0, 0); else isst_display_result(id, outf, "core-power", "config", ret); } static void set_clos_config(int arg) { if (cmd_help) { fprintf(stderr, "Set core-power configuration for one of the four clos ids\n"); fprintf(stderr, "\tSpecify targeted clos id with [--clos|-c]\n"); if (!is_skx_based_platform()) { fprintf(stderr, "\tSpecify clos EPP with [--epp|-e]\n"); fprintf(stderr, "\tSpecify clos Proportional Priority [--weight|-w]\n"); } fprintf(stderr, "\tSpecify clos min in MHz with [--min|-n]\n"); fprintf(stderr, "\tSpecify clos max in MHz with [--max|-m]\n"); exit(0); } if (current_clos < 0 || current_clos > 3) { isst_display_error_info_message(1, "Invalid clos id\n", 0, 0); exit(0); } if (!is_skx_based_platform() && (clos_epp < 0 || clos_epp > 0x0F)) { fprintf(stderr, "clos epp is not specified or invalid, default: 0\n"); clos_epp = 0; } if (!is_skx_based_platform() && (clos_prop_prio < 0 || clos_prop_prio > 0x0F)) { fprintf(stderr, "clos frequency weight is not specified or invalid, default: 0\n"); clos_prop_prio = 0; } if (clos_min < 0) { fprintf(stderr, "clos min is not specified, default: 0\n"); clos_min = 0; } if (clos_max < 0) { fprintf(stderr, "clos max is not specified, default: Max frequency (ratio 0xff)\n"); clos_max = 0xff; } if (clos_desired) { fprintf(stderr, "clos desired is not supported on this platform\n"); clos_desired = 0x00; } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(set_clos_config_for_cpu, NULL, NULL, NULL, NULL); else for_each_online_power_domain_in_set(set_clos_config_for_cpu, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static void set_clos_assoc_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { int ret; ret = isst_clos_associate(id, current_clos); if (ret) debug_printf("isst_clos_associate failed"); else isst_display_result(id, outf, "core-power", "assoc", ret); } static void set_clos_assoc(int arg) { if (cmd_help) { fprintf(stderr, "Associate a clos id to a CPU\n"); fprintf(stderr, "\tSpecify targeted clos id with [--clos|-c]\n"); fprintf(stderr, "\tFor example to associate clos 1 to CPU 0: issue\n"); fprintf(stderr, "\tintel-speed-select --cpu 0 core-power assoc --clos 1\n"); exit(0); } if (current_clos < 0 || current_clos > 3) { isst_display_error_info_message(1, "Invalid clos id\n", 0, 0); exit(0); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(set_clos_assoc_for_cpu, NULL, NULL, NULL, NULL); else { isst_display_error_info_message(1, "Invalid target cpu. Specify with [-c|--cpu]", 0, 0); } isst_ctdp_display_information_end(outf); } static void get_clos_assoc_for_cpu(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { int clos, ret; ret = isst_clos_get_assoc_status(id, &clos); if (ret) isst_display_error_info_message(1, "isst_clos_get_assoc_status failed", 0, 0); else isst_clos_display_assoc_information(id, outf, clos); } static void get_clos_assoc(int arg) { if (cmd_help) { fprintf(stderr, "Get associate clos id to a CPU\n"); fprintf(stderr, "\tSpecify targeted cpu id with [--cpu|-c]\n"); exit(0); } if (!max_target_cpus) { isst_display_error_info_message(1, "Invalid target cpu. Specify with [-c|--cpu]", 0, 0); exit(0); } isst_ctdp_display_information_start(outf); for_each_online_target_cpu_in_set(get_clos_assoc_for_cpu, NULL, NULL, NULL, NULL); isst_ctdp_display_information_end(outf); } static void set_turbo_mode_for_cpu(struct isst_id *id, int status) { int base_freq; if (status) { base_freq = get_cpufreq_base_freq(id->cpu); set_cpufreq_scaling_min_max(id->cpu, 1, base_freq); } else { set_scaling_max_to_cpuinfo_max(id); } if (status) { isst_display_result(id, outf, "turbo-mode", "disable", 0); } else { isst_display_result(id, outf, "turbo-mode", "enable", 0); } } static void set_turbo_mode(int arg) { int i, disable = arg; struct isst_id id; if (cmd_help) { if (disable) fprintf(stderr, "Set turbo mode disable\n"); else fprintf(stderr, "Set turbo mode enable\n"); exit(0); } isst_ctdp_display_information_start(outf); for (i = 0; i < topo_max_cpus; ++i) { int online; if (i) online = parse_int_file( 1, "/sys/devices/system/cpu/cpu%d/online", i); else online = 1; /* online entry for CPU 0 needs some special configs */ if (online) { set_isst_id(&id, i); set_turbo_mode_for_cpu(&id, disable); } } isst_ctdp_display_information_end(outf); } static void get_set_trl(struct isst_id *id, void *arg1, void *arg2, void *arg3, void *arg4) { unsigned long long trl; int set = *(int *)arg4; int ret; if (id->cpu < 0) return; if (set && !fact_trl) { isst_display_error_info_message(1, "Invalid TRL. Specify with [-t|--trl]", 0, 0); exit(0); } if (set) { ret = isst_set_trl(id, fact_trl); isst_display_result(id, outf, "turbo-mode", "set-trl", ret); return; } ret = isst_get_trl(id, &trl); if (ret) isst_display_result(id, outf, "turbo-mode", "get-trl", ret); else isst_trl_display_information(id, outf, trl); } static void process_trl(int arg) { if (cmd_help) { if (arg) { fprintf(stderr, "Set TRL (turbo ratio limits)\n"); fprintf(stderr, "\t t|--trl: Specify turbo ratio limit for setting TRL in hex starting with 0x\n"); } else { fprintf(stderr, "Get TRL (turbo ratio limits)\n"); } exit(0); } isst_ctdp_display_information_start(outf); if (max_target_cpus) for_each_online_target_cpu_in_set(get_set_trl, NULL, NULL, NULL, &arg); else for_each_online_power_domain_in_set(get_set_trl, NULL, NULL, NULL, &arg); isst_ctdp_display_information_end(outf); } static struct process_cmd_struct clx_n_cmds[] = { { "perf-profile", "info", dump_isst_config, 0 }, { "base-freq", "info", dump_pbf_config, 0 }, { "base-freq", "enable", set_pbf_enable, 1 }, { "base-freq", "disable", set_pbf_enable, 0 }, { NULL, NULL, NULL, 0 } }; static struct process_cmd_struct isst_cmds[] = { { "perf-profile", "get-lock-status", get_tdp_locked, 0 }, { "perf-profile", "get-config-levels", get_tdp_levels, 0 }, { "perf-profile", "get-config-version", get_tdp_version, 0 }, { "perf-profile", "get-config-enabled", get_tdp_enabled, 0 }, { "perf-profile", "get-config-current-level", get_tdp_current_level, 0 }, { "perf-profile", "set-config-level", set_tdp_level, 0 }, { "perf-profile", "info", dump_isst_config, 0 }, { "base-freq", "info", dump_pbf_config, 0 }, { "base-freq", "enable", set_pbf_enable, 1 }, { "base-freq", "disable", set_pbf_enable, 0 }, { "turbo-freq", "info", dump_fact_config, 0 }, { "turbo-freq", "enable", set_fact_enable, 1 }, { "turbo-freq", "disable", set_fact_enable, 0 }, { "core-power", "info", dump_clos_info, 0 }, { "core-power", "enable", set_clos_enable, 1 }, { "core-power", "disable", set_clos_enable, 0 }, { "core-power", "config", set_clos_config, 0 }, { "core-power", "get-config", dump_clos_config, 0 }, { "core-power", "assoc", set_clos_assoc, 0 }, { "core-power", "get-assoc", get_clos_assoc, 0 }, { "turbo-mode", "enable", set_turbo_mode, 0 }, { "turbo-mode", "disable", set_turbo_mode, 1 }, { "turbo-mode", "get-trl", process_trl, 0 }, { "turbo-mode", "set-trl", process_trl, 1 }, { NULL, NULL, NULL } }; /* * parse cpuset with following syntax * 1,2,4..6,8-10 and set bits in cpu_subset */ void parse_cpu_command(char *optarg) { unsigned int start, end, invalid_count; char *next; next = optarg; invalid_count = 0; while (next && *next) { if (*next == '-') /* no negative cpu numbers */ goto error; start = strtoul(next, &next, 10); if (max_target_cpus < MAX_CPUS_IN_ONE_REQ) target_cpus[max_target_cpus++] = start; else invalid_count = 1; if (*next == '\0') break; if (*next == ',') { next += 1; continue; } if (*next == '-') { next += 1; /* start range */ } else if (*next == '.') { next += 1; if (*next == '.') next += 1; /* start range */ else goto error; } end = strtoul(next, &next, 10); if (end <= start) goto error; while (++start <= end) { if (max_target_cpus < MAX_CPUS_IN_ONE_REQ) target_cpus[max_target_cpus++] = start; else invalid_count = 1; } if (*next == ',') next += 1; else if (*next != '\0') goto error; } if (invalid_count) { isst_ctdp_display_information_start(outf); isst_display_error_info_message(1, "Too many CPUs in one request: max is", 1, MAX_CPUS_IN_ONE_REQ - 1); isst_ctdp_display_information_end(outf); exit(-1); } #ifdef DEBUG { int i; for (i = 0; i < max_target_cpus; ++i) printf("cpu [%d] in arg\n", target_cpus[i]); } #endif return; error: fprintf(stderr, "\"--cpu %s\" malformed\n", optarg); exit(-1); } static void check_optarg(char *option, int hex) { if (optarg) { char *start = optarg; int i; if (hex && strlen(optarg) < 3) { /* At least 0x plus one character must be present */ fprintf(stderr, "malformed arguments for:%s [%s]\n", option, optarg); exit(0); } if (hex) { if (optarg[0] != '0' || tolower(optarg[1]) != 'x') { fprintf(stderr, "malformed arguments for:%s [%s]\n", option, optarg); exit(0); } start = &optarg[2]; } for (i = 0; i < strlen(start); ++i) { if (hex) { if (!isxdigit(start[i])) { fprintf(stderr, "malformed arguments for:%s [%s]\n", option, optarg); exit(0); } } else if (!isdigit(start[i])) { fprintf(stderr, "malformed arguments for:%s [%s]\n", option, optarg); exit(0); } } } } static void parse_cmd_args(int argc, int start, char **argv) { int opt; int option_index; static struct option long_options[] = { { "bucket", required_argument, 0, 'b' }, { "level", required_argument, 0, 'l' }, { "online", required_argument, 0, 'o' }, { "trl-type", required_argument, 0, 'r' }, { "trl", required_argument, 0, 't' }, { "help", no_argument, 0, 'h' }, { "clos", required_argument, 0, 'c' }, { "desired", required_argument, 0, 'd' }, { "epp", required_argument, 0, 'e' }, { "min", required_argument, 0, 'n' }, { "max", required_argument, 0, 'm' }, { "priority", required_argument, 0, 'p' }, { "weight", required_argument, 0, 'w' }, { "auto", no_argument, 0, 'a' }, { 0, 0, 0, 0 } }; option_index = start; optind = start + 1; while ((opt = getopt_long(argc, argv, "b:l:t:c:d:e:n:m:p:w:r:hoa", long_options, &option_index)) != -1) { switch (opt) { case 'a': auto_mode = 1; break; case 'b': check_optarg("bucket", 0); fact_bucket = atoi(optarg); break; case 'h': cmd_help = 1; break; case 'l': check_optarg("level", 0); tdp_level = atoi(optarg); break; case 'o': force_online_offline = 1; break; case 't': check_optarg("trl", 1); sscanf(optarg, "0x%llx", &fact_trl); break; case 'r': if (!strncmp(optarg, "sse", 3)) { fact_avx = 0x01; } else if (!strncmp(optarg, "avx2", 4)) { fact_avx = 0x02; } else if (!strncmp(optarg, "avx512", 6)) { fact_avx = 0x04; } else { fprintf(outf, "Invalid sse,avx options\n"); exit(1); } break; /* CLOS related */ case 'c': check_optarg("clos", 0); current_clos = atoi(optarg); break; case 'd': check_optarg("desired", 0); clos_desired = atoi(optarg); clos_desired /= isst_get_disp_freq_multiplier(); break; case 'e': check_optarg("epp", 0); clos_epp = atoi(optarg); if (is_skx_based_platform()) { isst_display_error_info_message(1, "epp can't be specified on this platform", 0, 0); exit(0); } break; case 'n': check_optarg("min", 0); clos_min = atoi(optarg); clos_min /= isst_get_disp_freq_multiplier(); break; case 'm': check_optarg("max", 0); clos_max = atoi(optarg); clos_max /= isst_get_disp_freq_multiplier(); break; case 'p': check_optarg("priority", 0); clos_priority_type = atoi(optarg); if (is_skx_based_platform() && !clos_priority_type) { isst_display_error_info_message(1, "Invalid clos priority type: proportional for this platform", 0, 0); exit(0); } break; case 'w': check_optarg("weight", 0); clos_prop_prio = atoi(optarg); if (is_skx_based_platform()) { isst_display_error_info_message(1, "weight can't be specified on this platform", 0, 0); exit(0); } break; default: printf("Unknown option: ignore\n"); } } if (argv[optind]) printf("Garbage at the end of command: ignore\n"); } static void isst_help(void) { printf("perf-profile:\tAn architectural mechanism that allows multiple optimized \n\ performance profiles per system via static and/or dynamic\n\ adjustment of core count, workload, Tjmax, and\n\ TDP, etc.\n"); printf("\nCommands : For feature=perf-profile\n"); printf("\tinfo\n"); if (!is_clx_n_platform()) { printf("\tget-lock-status\n"); printf("\tget-config-levels\n"); printf("\tget-config-version\n"); printf("\tget-config-enabled\n"); printf("\tget-config-current-level\n"); printf("\tset-config-level\n"); } } static void pbf_help(void) { printf("base-freq:\tEnables users to increase guaranteed base frequency\n\ on certain cores (high priority cores) in exchange for lower\n\ base frequency on remaining cores (low priority cores).\n"); printf("\tcommand : info\n"); printf("\tcommand : enable\n"); printf("\tcommand : disable\n"); } static void fact_help(void) { printf("turbo-freq:\tEnables the ability to set different turbo ratio\n\ limits to cores based on priority.\n"); printf("\nCommand: For feature=turbo-freq\n"); printf("\tcommand : info\n"); printf("\tcommand : enable\n"); printf("\tcommand : disable\n"); } static void turbo_mode_help(void) { printf("turbo-mode:\tEnables users to enable/disable turbo mode by adjusting frequency settings. Also allows to get and set turbo ratio limits (TRL).\n"); printf("\tcommand : enable\n"); printf("\tcommand : disable\n"); printf("\tcommand : get-trl\n"); printf("\tcommand : set-trl\n"); } static void core_power_help(void) { printf("core-power:\tInterface that allows user to define per core/tile\n\ priority.\n"); printf("\nCommands : For feature=core-power\n"); printf("\tinfo\n"); printf("\tenable\n"); printf("\tdisable\n"); printf("\tconfig\n"); printf("\tget-config\n"); printf("\tassoc\n"); printf("\tget-assoc\n"); } struct process_cmd_help_struct { char *feature; void (*process_fn)(void); }; static struct process_cmd_help_struct isst_help_cmds[] = { { "perf-profile", isst_help }, { "base-freq", pbf_help }, { "turbo-freq", fact_help }, { "core-power", core_power_help }, { "turbo-mode", turbo_mode_help }, { NULL, NULL } }; static struct process_cmd_help_struct clx_n_help_cmds[] = { { "perf-profile", isst_help }, { "base-freq", pbf_help }, { NULL, NULL } }; void process_command(int argc, char **argv, struct process_cmd_help_struct *help_cmds, struct process_cmd_struct *cmds) { int i = 0, matched = 0; char *feature = argv[optind]; char *cmd = argv[optind + 1]; if (!feature || !cmd) return; debug_printf("feature name [%s] command [%s]\n", feature, cmd); if (!strcmp(cmd, "-h") || !strcmp(cmd, "--help")) { while (help_cmds[i].feature) { if (!strcmp(help_cmds[i].feature, feature)) { help_cmds[i].process_fn(); exit(0); } ++i; } } i = 0; while (cmds[i].feature) { if (!strcmp(cmds[i].feature, feature) && !strcmp(cmds[i].command, cmd)) { parse_cmd_args(argc, optind + 1, argv); cmds[i].process_fn(cmds[i].arg); matched = 1; break; } ++i; } if (!matched) fprintf(stderr, "Invalid command\n"); } static void usage(void) { if (is_clx_n_platform()) { fprintf(stderr, "\nThere is limited support of Intel Speed Select features on this platform.\n"); fprintf(stderr, "Everything is pre-configured using BIOS options, this tool can't enable any feature in the hardware.\n\n"); } printf("\nUsage:\n"); printf("intel-speed-select [OPTIONS] FEATURE COMMAND COMMAND_ARGUMENTS\n"); printf("\nUse this tool to enumerate and control the Intel Speed Select Technology features:\n"); if (is_clx_n_platform()) printf("\nFEATURE : [perf-profile|base-freq]\n"); else printf("\nFEATURE : [perf-profile|base-freq|turbo-freq|core-power|turbo-mode]\n"); printf("\nFor help on each feature, use -h|--help\n"); printf("\tFor example: intel-speed-select perf-profile -h\n"); printf("\nFor additional help on each command for a feature, use --h|--help\n"); printf("\tFor example: intel-speed-select perf-profile get-lock-status -h\n"); printf("\t\t This will print help for the command \"get-lock-status\" for the feature \"perf-profile\"\n"); printf("\nOPTIONS\n"); printf("\t[-c|--cpu] : logical cpu number\n"); printf("\t\tDefault: Die scoped for all dies in the system with multiple dies/package\n"); printf("\t\t\t Or Package scoped for all Packages when each package contains one die\n"); printf("\t[-d|--debug] : Debug mode\n"); printf("\t[-f|--format] : output format [json|text]. Default: text\n"); printf("\t[-h|--help] : Print help\n"); printf("\t[-i|--info] : Print platform information\n"); printf("\t[-a|--all-cpus-online] : Force online every CPU in the system\n"); printf("\t[-o|--out] : Output file\n"); printf("\t\t\tDefault : stderr\n"); printf("\t[-p|--pause] : Delay between two mail box commands in milliseconds\n"); printf("\t[-r|--retry] : Retry count for mail box commands on failure, default 3\n"); printf("\t[-v|--version] : Print version\n"); printf("\t[-b|--oob : Start a daemon to process HFI events for perf profile change from Out of Band agent.\n"); printf("\t[-n|--no-daemon : Don't run as daemon. By default --oob will turn on daemon mode\n"); printf("\t[-w|--delay : Delay for reading config level state change in OOB poll mode.\n"); printf("\t[-g|--cgroupv2 : Try to use cgroup v2 CPU isolation instead of CPU online/offline.\n"); printf("\t[-u|--cpu0-workaround : Don't try to online/offline CPU0 instead use cgroup v2.\n"); printf("\nResult format\n"); printf("\tResult display uses a common format for each command:\n"); printf("\tResults are formatted in text/JSON with\n"); printf("\t\tPackage, Die, CPU, and command specific results.\n"); printf("\nExamples\n"); printf("\tTo get platform information:\n"); printf("\t\tintel-speed-select --info\n"); printf("\tTo get full perf-profile information dump:\n"); printf("\t\tintel-speed-select perf-profile info\n"); printf("\tTo get full base-freq information dump:\n"); printf("\t\tintel-speed-select base-freq info -l 0\n"); if (!is_clx_n_platform()) { printf("\tTo get full turbo-freq information dump:\n"); printf("\t\tintel-speed-select turbo-freq info -l 0\n"); } exit(1); } static void print_version(void) { fprintf(outf, "Version %s\n", version_str); exit(0); } static void cmdline(int argc, char **argv) { const char *pathname = "/dev/isst_interface"; char *ptr; FILE *fp; int opt, force_cpus_online = 0; int option_index = 0; int ret; int oob_mode = 0; int poll_interval = -1; int no_daemon = 0; int mbox_delay = 0, mbox_retries = 3; static struct option long_options[] = { { "all-cpus-online", no_argument, 0, 'a' }, { "cpu", required_argument, 0, 'c' }, { "debug", no_argument, 0, 'd' }, { "format", required_argument, 0, 'f' }, { "help", no_argument, 0, 'h' }, { "info", no_argument, 0, 'i' }, { "pause", required_argument, 0, 'p' }, { "out", required_argument, 0, 'o' }, { "retry", required_argument, 0, 'r' }, { "version", no_argument, 0, 'v' }, { "oob", no_argument, 0, 'b' }, { "no-daemon", no_argument, 0, 'n' }, { "poll-interval", required_argument, 0, 'w' }, { "cgroupv2", required_argument, 0, 'g' }, { "cpu0-workaround", required_argument, 0, 'u' }, { 0, 0, 0, 0 } }; if (geteuid() != 0) { fprintf(stderr, "Must run as root\n"); exit(0); } ret = update_cpu_model(); if (ret) err(-1, "Invalid CPU model (%d)\n", cpu_model); printf("Intel(R) Speed Select Technology\n"); printf("Executing on CPU model:%d[0x%x]\n", cpu_model, cpu_model); if (!is_clx_n_platform()) { fp = fopen(pathname, "rb"); if (!fp) { fprintf(stderr, "Intel speed select drivers are not loaded on this system.\n"); fprintf(stderr, "Verify that kernel config includes CONFIG_INTEL_SPEED_SELECT_INTERFACE.\n"); fprintf(stderr, "If the config is included then this is not a supported platform.\n"); exit(0); } fclose(fp); } ret = isst_fill_platform_info(); if (ret) goto out; progname = argv[0]; while ((opt = getopt_long_only(argc, argv, "+c:df:hio:vabw:ngu", long_options, &option_index)) != -1) { switch (opt) { case 'a': force_cpus_online = 1; break; case 'c': parse_cpu_command(optarg); break; case 'd': debug_flag = 1; printf("Debug Mode ON\n"); break; case 'f': if (!strncmp(optarg, "json", 4)) out_format_json = 1; break; case 'h': usage(); break; case 'i': isst_print_platform_information(); break; case 'o': if (outf) fclose(outf); outf = fopen_or_exit(optarg, "w"); break; case 'p': ret = strtol(optarg, &ptr, 10); if (!ret) fprintf(stderr, "Invalid pause interval, ignore\n"); else mbox_delay = ret; break; case 'r': ret = strtol(optarg, &ptr, 10); if (!ret) fprintf(stderr, "Invalid retry count, ignore\n"); else mbox_retries = ret; break; case 'v': print_version(); break; case 'b': oob_mode = 1; break; case 'n': no_daemon = 1; break; case 'w': ret = strtol(optarg, &ptr, 10); if (!ret) { fprintf(stderr, "Invalid poll interval count\n"); exit(0); } poll_interval = ret; break; case 'g': cgroupv2 = 1; break; case 'u': cpu_0_cgroupv2 = 1; break; default: usage(); } } if (optind > (argc - 2) && !oob_mode) { usage(); exit(0); } isst_update_platform_param(ISST_PARAM_MBOX_DELAY, mbox_delay); isst_update_platform_param(ISST_PARAM_MBOX_RETRIES, mbox_retries); set_max_cpu_num(); if (force_cpus_online) force_all_cpus_online(); store_cpu_topology(); create_cpu_map(); if (oob_mode) { if (debug_flag) fprintf(stderr, "OOB mode is enabled in debug mode\n"); ret = isst_daemon(debug_flag, poll_interval, no_daemon); if (ret) fprintf(stderr, "OOB mode enable failed\n"); goto out; } if (!is_clx_n_platform()) { process_command(argc, argv, isst_help_cmds, isst_cmds); } else { process_command(argc, argv, clx_n_help_cmds, clx_n_cmds); } out: free_cpu_set(present_cpumask); free_cpu_set(target_cpumask); } int main(int argc, char **argv) { outf = stderr; cmdline(argc, argv); return 0; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1