+ * Copyright (c) 2025 Intel Corporation.

+#define ROUND_UP_TO_PAGE_SIZE(n) (((n) + 0x1000UL-1UL) & ~(0x1000UL-1UL))

+

+ { 0x0, "NMI", NULL, 0, 0, 0, NULL, 0 },

+ { 0x0, "CPU%c1e", NULL, 0, 0, 0, NULL, 0 },

+#define BIC_NMI (1ULL << 61)

+#define BIC_CPU_c1e (1ULL << 62)

+#define BIC_TOPOLOGY (BIC_Package | BIC_Node | BIC_CoreCnt | BIC_PkgCnt | BIC_Core | BIC_CPU | BIC_Die)

+#define BIC_THERMAL_PWR (BIC_CoreTmp | BIC_PkgTmp | BIC_PkgWatt | BIC_CorWatt | BIC_GFXWatt | BIC_RAMWatt | BIC_PKG__ | BIC_RAM__ | BIC_SysWatt)

+#define BIC_IDLE (BIC_Busy | BIC_sysfs | BIC_CPU_c1 | BIC_CPU_c3 | BIC_CPU_c6 | BIC_CPU_c7 | BIC_GFX_rc6 | BIC_Pkgpc2 | BIC_Pkgpc3 | BIC_Pkgpc6 | BIC_Pkgpc7 | BIC_Pkgpc8 | BIC_Pkgpc9 | BIC_Pkgpc10 | BIC_CPU_LPI | BIC_SYS_LPI | BIC_Mod_c6 | BIC_Totl_c0 | BIC_Any_c0 | BIC_GFX_c0 | BIC_CPUGFX | BIC_SAM_mc6 | BIC_Diec6)

+#define BIC_OTHER (BIC_IRQ | BIC_NMI | BIC_SMI | BIC_ThreadC | BIC_CoreTmp | BIC_IPC)

+#define BIC_DISABLED_BY_DEFAULT (BIC_USEC | BIC_TOD | BIC_APIC | BIC_X2APIC)

+unsigned int force_load;

+double rapl_dram_energy_units, rapl_energy_units, rapl_psys_energy_units;

+

+static struct timeval procsysfs_tv_begin;

+

+ bool has_fixed_rapl_psys_unit; /* Fixed Energy Unit used for PSYS RAPL Domain */

+ .has_fixed_rapl_psys_unit = 1,

+ { INTEL_PANTHERLAKE_L, &lnl_features },

+ { INTEL_ATOM_DARKMONT_X, &srf_features },

+ * INTEL_ATOM_SILVERMONT_MID2

+ /* fallback to default features on unsupported models */

+ force_load++;

+ goto end;

+ goto end;

+

+end:

+ if (force_load && !platform) {

+ fprintf(outf, "Forced to run on unsupported platform!\n");

+ platform = &default_features;

+ }

+

+ if (platform)

+ return;

+

+ fprintf(stderr, "Unsupported platform detected.\n"

+ "\tSee RUN THE LATEST VERSION on turbostat(8)\n");

+ exit(1);

+cpu_set_t *cpu_present_set, *cpu_possible_set, *cpu_effective_set, *cpu_allowed_set, *cpu_affinity_set, *cpu_subset;

+size_t cpu_present_setsize, cpu_possible_setsize, cpu_effective_setsize, cpu_allowed_setsize, cpu_affinity_setsize, cpu_subset_size;

+ .platform_rapl_msr_scale = &rapl_psys_energy_units,

+#define PMT_MTL_DC6_SEQ 0

+

+#define PMT_COUNTER_CWF_MC1E_OFFSET_BASE 20936

+#define PMT_COUNTER_CWF_MC1E_OFFSET_INCREMENT 24

+#define PMT_COUNTER_CWF_MC1E_NUM_MODULES_PER_FILE 12

+#define PMT_COUNTER_CWF_CPUS_PER_MODULE 4

+#define PMT_COUNTER_CWF_MC1E_LSB 0

+#define PMT_COUNTER_CWF_MC1E_MSB 63

+#define PMT_CWF_MC1E_GUID 0x14421519

+

+unsigned long long tcore_clock_freq_hz = 800000000;

+ PMT_TYPE_TCORE_CLOCK,

+/*

+ * PMT telemetry directory iterator.

+ * Used to iterate telemetry files in sysfs in correct order.

+ */

+struct pmt_diriter_t {

+ DIR *dir;

+ struct dirent **namelist;

+ unsigned int num_names;

+ unsigned int current_name_idx;

+};

+

+int pmt_telemdir_filter(const struct dirent *e)

+{

+ unsigned int dummy;

+

+ return sscanf(e->d_name, "telem%u", &dummy);

+}

+

+int pmt_telemdir_sort(const struct dirent **a, const struct dirent **b)

+{

+ unsigned int aidx = 0, bidx = 0;

+

+ sscanf((*a)->d_name, "telem%u", &aidx);

+ sscanf((*b)->d_name, "telem%u", &bidx);

+

+ return aidx >= bidx;

+}

+

+const struct dirent *pmt_diriter_next(struct pmt_diriter_t *iter)

+{

+ const struct dirent *ret = NULL;

+

+ if (!iter->dir)

+ return NULL;

+

+ if (iter->current_name_idx >= iter->num_names)

+ return NULL;

+

+ ret = iter->namelist[iter->current_name_idx];

+ ++iter->current_name_idx;

+

+ return ret;

+}

+

+const struct dirent *pmt_diriter_begin(struct pmt_diriter_t *iter, const char *pmt_root_path)

+{

+ int num_names = iter->num_names;

+

+ if (!iter->dir) {

+ iter->dir = opendir(pmt_root_path);

+ if (iter->dir == NULL)

+ return NULL;

+

+ num_names = scandir(pmt_root_path, &iter->namelist, pmt_telemdir_filter, pmt_telemdir_sort);

+ if (num_names == -1)

+ return NULL;

+ }

+

+ iter->current_name_idx = 0;

+ iter->num_names = num_names;

+

+ return pmt_diriter_next(iter);

+}

+

+void pmt_diriter_init(struct pmt_diriter_t *iter)

+{

+ memset(iter, 0, sizeof(*iter));

+}

+

+void pmt_diriter_remove(struct pmt_diriter_t *iter)

+{

+ if (iter->namelist) {

+ for (unsigned int i = 0; i < iter->num_names; i++) {

+ free(iter->namelist[i]);

+ iter->namelist[i] = NULL;

+ }

+ }

+

+ free(iter->namelist);

+ iter->namelist = NULL;

+ iter->num_names = 0;

+ iter->current_name_idx = 0;

+

+ closedir(iter->dir);

+ iter->dir = NULL;

+}

+

+ unsigned long long nmi_count;

+int *nmi_per_cpu; /* indexed by cpu_num */

+ retval = 0;

+

+ retval |= func(t, c, p);

+ return retval;

+ unsigned long long value;

+ retval = pread(get_msr_fd(cpu), &value, sizeof(value), offset);

+ /*

+ * Expect MSRs to accumulate some non-zero value since the system was powered on.

+ * Treat zero as a read failure.

+ */

+ if (retval != sizeof(value) || value == 0)

+ " -a, --add counter\n"

+ " add a counter\n"

+ " -c, --cpu cpu-set\n"

+ " limit output to summary plus cpu-set:\n"

+ " -d, --debug\n"

+ " displays usec, Time_Of_Day_Seconds and more debugging\n"

+ " -D, --Dump\n"

+ " displays the raw counter values\n"

+ " -e, --enable [all | column]\n"

+ " -f, --force\n"

+ " force load turbostat with minimum default features on unsupported platforms.\n"

+ " -H, --hide [column | column,column,...]\n"

+ " override default 5-second measurement interval\n"

+ " -J, --Joules\n"

+ " displays energy in Joules instead of Watts\n"

+ " -l, --list\n"

+ " list column headers only\n"

+ " -M, --no-msr\n"

+ " disable all uses of the MSR driver\n"

+ " -P, --no-perf\n"

+ " disable all uses of the perf API\n"

+ " -q, --quiet\n"

+ " skip decoding system configuration header\n"

+ " -s, --show [column | column,column,...]\n"

+ " -h, --help\n"

+ " print this help message\n"

+ " -v, --version\n"

+ " print version information\n\nFor more help, run \"man turbostat\"\n");

+ if (DO_BIC(BIC_NMI)) {

+ if (sums_need_wide_columns)

+ outp += sprintf(outp, "%s NMI", (printed++ ? delim : ""));

+ else

+ outp += sprintf(outp, "%sNMI", (printed++ ? delim : ""));

+ }

+ case PMT_TYPE_TCORE_CLOCK:

+ case PMT_TYPE_TCORE_CLOCK:

+ case PMT_TYPE_TCORE_CLOCK:

+ if (DO_BIC(BIC_NMI))

+ outp += sprintf(outp, "IRQ: %lld\n", t->nmi_count);

+ /* NMI */

+ if (DO_BIC(BIC_NMI)) {

+ if (sums_need_wide_columns)

+ outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), t->nmi_count);

+ else

+ outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), t->nmi_count);

+ }

+

+ double value_converted;

+ value_converted = 100.0 * value_raw / crystal_hz / interval_float;

+

+ case PMT_TYPE_TCORE_CLOCK:

+ value_converted = 100.0 * value_raw / tcore_clock_freq_hz / interval_float;

+ outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), value_converted);

+ double value_converted;

+ value_converted = 100.0 * value_raw / crystal_hz / interval_float;

+

+ case PMT_TYPE_TCORE_CLOCK:

+ value_converted = 100.0 * value_raw / tcore_clock_freq_hz / interval_float;

+ outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), value_converted);

+ double value_converted;

+ value_converted = 100.0 * value_raw / crystal_hz / interval_float;

+

+ case PMT_TYPE_TCORE_CLOCK:

+ value_converted = 100.0 * value_raw / tcore_clock_freq_hz / interval_float;

+ outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), value_converted);

+ if (DO_BIC(BIC_NMI))

+ old->nmi_count = new->nmi_count - old->nmi_count;

+

+ retval |= delta_package(p, p2);

+ t->nmi_count = 0;

+ average.threads.tv_begin = procsysfs_tv_begin;

+ average.threads.nmi_count += t->nmi_count;

+ if (average.threads.nmi_count > 9999999)

+ sums_need_wide_columns = 1;

+

+ if (domain_id >= ppmt->num_domains)

+ return 0;

+ if (DO_BIC(BIC_NMI))

+ t->nmi_count = nmi_per_cpu[cpu];

+ free(nmi_per_cpu);

+ retval = 0;

+

+ retval |= func(t, c, p, t2, c2, p2);

+ return retval;

+ nmi_per_cpu[cpu_number] = 0;

+ int this_row_is_nmi = 0;

+ retval = fscanf(fp, " %s:", buf); /* irq# "N:" */

+ if (strncmp(buf, "NMI", strlen("NMI")) == 0)

+ this_row_is_nmi = 1;

+

+

+ if (this_row_is_nmi)

+ nmi_per_cpu[cpu_number] += irq_count;

+ gettimeofday(&procsysfs_tv_begin, (struct timezone *)NULL);

+

+ if (DO_BIC(BIC_IRQ) || DO_BIC(BIC_NMI))

+ if (platform->has_fixed_rapl_psys_unit)

+ rapl_psys_energy_units = 1.0;

+ else

+ rapl_psys_energy_units = rapl_energy_units;

+

+ BIC_PRESENT(BIC_NMI);

+char *possible_file = "/sys/devices/system/cpu/possible";

+char possible_buf[1024];

+

+int initialize_cpu_possible_set(void)

+{

+ FILE *fp;

+

+ fp = fopen(possible_file, "r");

+ if (!fp) {

+ warn("open %s", possible_file);

+ return -1;

+ }

+ if (fread(possible_buf, sizeof(char), 1024, fp) == 0) {

+ warn("read %s", possible_file);

+ goto err;

+ }

+ if (parse_cpu_str(possible_buf, cpu_possible_set, cpu_possible_setsize)) {

+ warnx("%s: cpu str malformat %s\n", possible_file, cpu_effective_str);

+ goto err;

+ }

+ return 0;

+

+err:

+ fclose(fp);

+ return -1;

+}

+

+ * Allocate and initialize cpu_possible_set

+ */

+ cpu_possible_set = CPU_ALLOC((topo.max_cpu_num + 1));

+ if (cpu_possible_set == NULL)

+ err(3, "CPU_ALLOC");

+ cpu_possible_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));

+ CPU_ZERO_S(cpu_possible_setsize, cpu_possible_set);

+ initialize_cpu_possible_set();

+

+ /*

+ err(-1, "calloc %d IRQ", topo.max_cpu_num + 1);

+

+ nmi_per_cpu = calloc(topo.max_cpu_num + 1, sizeof(int));

+ if (nmi_per_cpu == NULL)

+ err(-1, "calloc %d NMI", topo.max_cpu_num + 1);

+ struct pmt_diriter_t pmt_iter;

+ const struct dirent *entry;

+ struct pmt_mmio *head = NULL, *last = NULL;

+ struct pmt_mmio *new_pmt = NULL;

+ pmt_diriter_init(&pmt_iter);

+ entry = pmt_diriter_begin(&pmt_iter, SYSFS_TELEM_PATH);

+ if (!entry) {

+ pmt_diriter_remove(&pmt_iter);

+ }

+ for ( ; entry != NULL; entry = pmt_diriter_next(&pmt_iter)) {

+ if (fstatat(dirfd(pmt_iter.dir), entry->d_name, &st, 0) == -1)

+ fd_telem_dir = openat(dirfd(pmt_iter.dir), entry->d_name, O_RDONLY);

+ if (fd_telem_dir == -1)

+ mmap_size = ROUND_UP_TO_PAGE_SIZE(size);

+ new_pmt = calloc(1, sizeof(*new_pmt));

+ if (!new_pmt) {

+ /*

+ * Create linked list of mmaped regions,

+ * but preserve the ordering from sysfs.

+ * Ordering is important for the user to

+ * use the seq=%u parameter when adding a counter.

+ */

+ new_pmt->guid = guid;

+ new_pmt->mmio_base = mmio;

+ new_pmt->pmt_offset = offset;

+ new_pmt->size = size;

+ new_pmt->next = pmt_mmios;

+

+ if (last)

+ last->next = new_pmt;

+ else

+ head = new_pmt;

+ last = new_pmt;

+ pmt_diriter_remove(&pmt_iter);

+ /*

+ * If we found something, stick just

+ * created linked list to the front.

+ */

+ if (head)

+ pmt_mmios = head;

+

+ return head;

+struct pmt_mmio *pmt_add_guid(unsigned int guid, unsigned int seq)

+ while (ret && seq) {

+ ret = ret->next;

+ --seq;

+ }

+

+int pmt_add_counter(unsigned int guid, unsigned int seq, const char *name, enum pmt_datatype type,

+ mmio = pmt_add_guid(guid, seq);

+ fprintf(stderr, "%s: failed to map PMT MMIO for guid %x, seq %u\n", __func__, guid, seq);

+ int cpu_num;

+ unsigned long seq, offset, mod_num;

+

+ pmt_add_counter(PMT_MTL_DC6_GUID, PMT_MTL_DC6_SEQ, "Die%c6", PMT_TYPE_XTAL_TIME,

+ PMT_COUNTER_MTL_DC6_LSB, PMT_COUNTER_MTL_DC6_MSB, PMT_COUNTER_MTL_DC6_OFFSET,

+ SCOPE_PACKAGE, FORMAT_DELTA, 0, PMT_OPEN_TRY);

+ }

+

+ if (BIC_IS_ENABLED(BIC_CPU_c1e)) {

+ seq = 0;

+ offset = PMT_COUNTER_CWF_MC1E_OFFSET_BASE;

+ mod_num = 0; /* Relative module number for current PMT file. */

+

+ /* Open the counter for each CPU. */

+ for (cpu_num = 0; cpu_num < topo.max_cpu_num;) {

+

+ if (cpu_is_not_allowed(cpu_num))

+ goto next_loop_iter;

+

+ /*

+ * Set the scope to CPU, even though CWF report the counter per module.

+ * CPUs inside the same module will read from the same location, instead of reporting zeros.

+ *

+ * CWF with newer firmware might require a PMT_TYPE_XTAL_TIME intead of PMT_TYPE_TCORE_CLOCK.

+ */

+ pmt_add_counter(PMT_CWF_MC1E_GUID, seq, "CPU%c1e", PMT_TYPE_TCORE_CLOCK,

+ PMT_COUNTER_CWF_MC1E_LSB, PMT_COUNTER_CWF_MC1E_MSB, offset, SCOPE_CPU,

+ FORMAT_DELTA, cpu_num, PMT_OPEN_TRY);

+

+ /*

+ * Rather complex logic for each time we go to the next loop iteration,

+ * so keep it as a label.

+ */

+next_loop_iter:

+ /*

+ * Advance the cpu number and check if we should also advance offset to

+ * the next counter inside the PMT file.

+ *

+ * On Clearwater Forest platform, the counter is reported per module,

+ * so open the same counter for all of the CPUs inside the module.

+ * That way, reported table show the correct value for all of the CPUs inside the module,

+ * instead of zeros.

+ */

+ ++cpu_num;

+ if (cpu_num % PMT_COUNTER_CWF_CPUS_PER_MODULE == 0) {

+ offset += PMT_COUNTER_CWF_MC1E_OFFSET_INCREMENT;

+ ++mod_num;

+ }

+

+ /*

+ * There are PMT_COUNTER_CWF_MC1E_NUM_MODULES_PER_FILE in each PMT file.

+ *

+ * If that number is reached, seq must be incremented to advance to the next file in a sequence.

+ * Offset inside that file and a module counter has to be reset.

+ */

+ if (mod_num == PMT_COUNTER_CWF_MC1E_NUM_MODULES_PER_FILE) {

+ ++seq;

+ offset = PMT_COUNTER_CWF_MC1E_OFFSET_BASE;

+ mod_num = 0;

+ }

+ }

+void affinitize_child(void)

+{

+ /* Prefer cpu_possible_set, if available */

+ if (sched_setaffinity(0, cpu_possible_setsize, cpu_possible_set)) {

+ warn("sched_setaffinity cpu_possible_set");

+

+ /* Otherwise, allow child to run on same cpu set as turbostat */

+ if (sched_setaffinity(0, cpu_allowed_setsize, cpu_allowed_set))

+ warn("sched_setaffinity cpu_allowed_set");

+ }

+}

+

+ affinitize_child();

+

+ compute_average(EVEN_COUNTERS);

+ format_all_counters(EVEN_COUNTERS);

+ fprintf(outf, "turbostat version 2025.02.02 - Len Brown <lenb@kernel.org>\n");

+ fprintf(stderr, "--add: (msrDDD | msr0xXXX | /path_to_counter | perf/device/event) required\n");

+int pmt_parse_from_path(const char *target_path, unsigned int *out_guid, unsigned int *out_seq)

+{

+ struct pmt_diriter_t pmt_iter;

+ const struct dirent *dirname;

+ struct stat stat, target_stat;

+ int fd_telem_dir = -1;

+ int fd_target_dir;

+ unsigned int seq = 0;

+ unsigned long guid, target_guid;

+ int ret = -1;

+

+ fd_target_dir = open(target_path, O_RDONLY | O_DIRECTORY);

+ if (fd_target_dir == -1) {

+ return -1;

+ }

+

+ if (fstat(fd_target_dir, &target_stat) == -1) {

+ fprintf(stderr, "%s: Failed to stat the target: %s", __func__, strerror(errno));

+ exit(1);

+ }

+

+ if (parse_telem_info_file(fd_target_dir, "guid", "%lx", &target_guid)) {

+ fprintf(stderr, "%s: Failed to parse the target guid file: %s", __func__, strerror(errno));

+ exit(1);

+ }

+

+ close(fd_target_dir);

+

+ pmt_diriter_init(&pmt_iter);

+

+ for (dirname = pmt_diriter_begin(&pmt_iter, SYSFS_TELEM_PATH); dirname != NULL;

+ dirname = pmt_diriter_next(&pmt_iter)) {

+

+ fd_telem_dir = openat(dirfd(pmt_iter.dir), dirname->d_name, O_RDONLY | O_DIRECTORY);

+ if (fd_telem_dir == -1)

+ continue;

+

+ if (parse_telem_info_file(fd_telem_dir, "guid", "%lx", &guid)) {

+ fprintf(stderr, "%s: Failed to parse the guid file: %s", __func__, strerror(errno));

+ continue;

+ }

+

+ if (fstat(fd_telem_dir, &stat) == -1) {

+ fprintf(stderr, "%s: Failed to stat %s directory: %s", __func__,

+ dirname->d_name, strerror(errno));

+ continue;

+ }

+

+ /*

+ * If reached the same directory as target, exit the loop.

+ * Seq has the correct value now.

+ */

+ if (stat.st_dev == target_stat.st_dev && stat.st_ino == target_stat.st_ino) {

+ ret = 0;

+ break;

+ }

+

+ /*

+ * If reached directory with the same guid,

+ * but it's not the target directory yet,

+ * increment seq and continue the search.

+ */

+ if (guid == target_guid)

+ ++seq;

+

+ close(fd_telem_dir);

+ fd_telem_dir = -1;

+ }

+

+ pmt_diriter_remove(&pmt_iter);

+

+ if (fd_telem_dir != -1)

+ close(fd_telem_dir);

+

+ if (!ret) {

+ *out_guid = target_guid;

+ *out_seq = seq;

+ }

+

+ return ret;

+}

+

+ char *direct_path = NULL;

+ static const char direct_path_prefix[] = "path=";

+ unsigned int seq = 0; /* By default, pick first file in a sequence with a given GUID. */

+ if (sscanf(add_command, "seq=%x", &seq) == 1)

+ goto next;

+

+ if (strncmp(add_command, direct_path_prefix, strlen(direct_path_prefix)) == 0) {

+ direct_path = add_command + strlen(direct_path_prefix);

+ goto next;

+ }

+ if (strcmp("tcore_clock", type_name) == 0) {

+ type = PMT_TYPE_TCORE_CLOCK;

+ has_type = true;

+ }

+

+ if (direct_path && has_guid) {

+ printf("%s: path and guid+seq parameters are mutually exclusive\n"

+ "notice: passed guid=0x%x and path=%s\n", __func__, guid, direct_path);

+ exit(1);

+ }

+

+ if (direct_path) {

+ if (pmt_parse_from_path(direct_path, &guid, &seq)) {

+ printf("%s: failed to parse PMT file from %s\n", __func__, direct_path);

+ exit(1);

+ }

+

+ /* GUID was just infered from the direct path. */

+ has_guid = true;

+ }

+

+ printf("%s: missing %s\n", __func__, "guid or path");

+ pmt_add_counter(guid, seq, name, type, lsb, msb, offset, scope, format, domain_id, PMT_OPEN_REQUIRED);

+ { "force", no_argument, 0, 'f' },

+ case 'f':

+ force_load++;

+ break;