samples/bpf/cpustat_user.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #define _GNU_SOURCE
   4 #include <errno.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <signal.h>
   8 #include <sched.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <fcntl.h>
  12 #include <locale.h>
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <sys/time.h>
  16 #include <sys/wait.h>
  17
  18 #include <bpf/bpf.h>
  19 #include <bpf/libbpf.h>
  20
  21 static int cstate_map_fd, pstate_map_fd;
  22
  23 #define MAX_CPU                 8
  24 #define MAX_PSTATE_ENTRIES      5
  25 #define MAX_CSTATE_ENTRIES      3
  26 #define MAX_STARS               40
  27
  28 #define CPUFREQ_MAX_SYSFS_PATH  "/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq"
  29 #define CPUFREQ_LOWEST_FREQ     "208000"
  30 #define CPUFREQ_HIGHEST_FREQ    "12000000"
  31
  32 struct cpu_stat_data {
  33         unsigned long cstate[MAX_CSTATE_ENTRIES];
  34         unsigned long pstate[MAX_PSTATE_ENTRIES];
  35 };
  36
  37 static struct cpu_stat_data stat_data[MAX_CPU];
  38
  39 static void cpu_stat_print(void)
  40 {
  41         int i, j;
  42         char state_str[sizeof("cstate-9")];
  43         struct cpu_stat_data *data;
  44
  45         /* Clear screen */
  46         printf("\033[2J");
  47
  48         /* Header */
  49         printf("\nCPU states statistics:\n");
  50         printf("%-10s ", "state(ms)");
  51
  52         for (i = 0; i < MAX_CSTATE_ENTRIES; i++) {
  53                 sprintf(state_str, "cstate-%d", i);
  54                 printf("%-11s ", state_str);
  55         }
  56
  57         for (i = 0; i < MAX_PSTATE_ENTRIES; i++) {
  58                 sprintf(state_str, "pstate-%d", i);
  59                 printf("%-11s ", state_str);
  60         }
  61
  62         printf("\n");
  63
  64         for (j = 0; j < MAX_CPU; j++) {
  65                 data = &stat_data[j];
  66
  67                 printf("CPU-%-6d ", j);
  68                 for (i = 0; i < MAX_CSTATE_ENTRIES; i++)
  69                         printf("%-11ld ", data->cstate[i] / 1000000);
  70
  71                 for (i = 0; i < MAX_PSTATE_ENTRIES; i++)
  72                         printf("%-11ld ", data->pstate[i] / 1000000);
  73
  74                 printf("\n");
  75         }
  76 }
  77
  78 static void cpu_stat_update(int cstate_fd, int pstate_fd)
  79 {
  80         unsigned long key, value;
  81         int c, i;
  82
  83         for (c = 0; c < MAX_CPU; c++) {
  84                 for (i = 0; i < MAX_CSTATE_ENTRIES; i++) {
  85                         key = c * MAX_CSTATE_ENTRIES + i;
  86                         bpf_map_lookup_elem(cstate_fd, &key, &value);
  87                         stat_data[c].cstate[i] = value;
  88                 }
  89
  90                 for (i = 0; i < MAX_PSTATE_ENTRIES; i++) {
  91                         key = c * MAX_PSTATE_ENTRIES + i;
  92                         bpf_map_lookup_elem(pstate_fd, &key, &value);
  93                         stat_data[c].pstate[i] = value;
  94                 }
  95         }
  96 }
  97
  98 /*
  99  * This function is copied from 'idlestat' tool function
 100  * idlestat_wake_all() in idlestate.c.
 101  *
 102  * It sets the self running task affinity to cpus one by one so can wake up
 103  * the specific CPU to handle scheduling; this results in all cpus can be
 104  * waken up once and produce ftrace event 'trace_cpu_idle'.
 105  */
 106 static int cpu_stat_inject_cpu_idle_event(void)
 107 {
 108         int rcpu, i, ret;
 109         cpu_set_t cpumask;
 110         cpu_set_t original_cpumask;
 111
 112         ret = sysconf(_SC_NPROCESSORS_CONF);
 113         if (ret < 0)
 114                 return -1;
 115
 116         rcpu = sched_getcpu();
 117         if (rcpu < 0)
 118                 return -1;
 119
 120         /* Keep track of the CPUs we will run on */
 121         sched_getaffinity(0, sizeof(original_cpumask), &original_cpumask);
 122
 123         for (i = 0; i < ret; i++) {
 124
 125                 /* Pointless to wake up ourself */
 126                 if (i == rcpu)
 127                         continue;
 128
 129                 /* Pointless to wake CPUs we will not run on */
 130                 if (!CPU_ISSET(i, &original_cpumask))
 131                         continue;
 132
 133                 CPU_ZERO(&cpumask);
 134                 CPU_SET(i, &cpumask);
 135
 136                 sched_setaffinity(0, sizeof(cpumask), &cpumask);
 137         }
 138
 139         /* Enable all the CPUs of the original mask */
 140         sched_setaffinity(0, sizeof(original_cpumask), &original_cpumask);
 141         return 0;
 142 }
 143
 144 /*
 145  * It's possible to have no any frequency change for long time and cannot
 146  * get ftrace event 'trace_cpu_frequency' for long period, this introduces
 147  * big deviation for pstate statistics.
 148  *
 149  * To solve this issue, below code forces to set 'scaling_max_freq' to 208MHz
 150  * for triggering ftrace event 'trace_cpu_frequency' and then recovery back to
 151  * the maximum frequency value 1.2GHz.
 152  */
 153 static int cpu_stat_inject_cpu_frequency_event(void)
 154 {
 155         int len, fd;
 156
 157         fd = open(CPUFREQ_MAX_SYSFS_PATH, O_WRONLY);
 158         if (fd < 0) {
 159                 printf("failed to open scaling_max_freq, errno=%d\n", errno);
 160                 return fd;
 161         }
 162
 163         len = write(fd, CPUFREQ_LOWEST_FREQ, strlen(CPUFREQ_LOWEST_FREQ));
 164         if (len < 0) {
 165                 printf("failed to open scaling_max_freq, errno=%d\n", errno);
 166                 goto err;
 167         }
 168
 169         len = write(fd, CPUFREQ_HIGHEST_FREQ, strlen(CPUFREQ_HIGHEST_FREQ));
 170         if (len < 0) {
 171                 printf("failed to open scaling_max_freq, errno=%d\n", errno);
 172                 goto err;
 173         }
 174
 175 err:
 176         close(fd);
 177         return len;
 178 }
 179
 180 static void int_exit(int sig)
 181 {
 182         cpu_stat_inject_cpu_idle_event();
 183         cpu_stat_inject_cpu_frequency_event();
 184         cpu_stat_update(cstate_map_fd, pstate_map_fd);
 185         cpu_stat_print();
 186         exit(0);
 187 }
 188
 189 int main(int argc, char **argv)
 190 {
 191         struct bpf_link *link = NULL;
 192         struct bpf_program *prog;
 193         struct bpf_object *obj;
 194         char filename[256];
 195         int ret;
 196
 197         snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
 198         obj = bpf_object__open_file(filename, NULL);
 199         if (libbpf_get_error(obj)) {
 200                 fprintf(stderr, "ERROR: opening BPF object file failed\n");
 201                 return 0;
 202         }
 203
 204         prog = bpf_object__find_program_by_name(obj, "bpf_prog1");
 205         if (!prog) {
 206                 printf("finding a prog in obj file failed\n");
 207                 goto cleanup;
 208         }
 209
 210         /* load BPF program */
 211         if (bpf_object__load(obj)) {
 212                 fprintf(stderr, "ERROR: loading BPF object file failed\n");
 213                 goto cleanup;
 214         }
 215
 216         cstate_map_fd = bpf_object__find_map_fd_by_name(obj, "cstate_duration");
 217         pstate_map_fd = bpf_object__find_map_fd_by_name(obj, "pstate_duration");
 218         if (cstate_map_fd < 0 || pstate_map_fd < 0) {
 219                 fprintf(stderr, "ERROR: finding a map in obj file failed\n");
 220                 goto cleanup;
 221         }
 222
 223         link = bpf_program__attach(prog);
 224         if (libbpf_get_error(link)) {
 225                 fprintf(stderr, "ERROR: bpf_program__attach failed\n");
 226                 link = NULL;
 227                 goto cleanup;
 228         }
 229
 230         ret = cpu_stat_inject_cpu_idle_event();
 231         if (ret < 0)
 232                 return 1;
 233
 234         ret = cpu_stat_inject_cpu_frequency_event();
 235         if (ret < 0)
 236                 return 1;
 237
 238         signal(SIGINT, int_exit);
 239         signal(SIGTERM, int_exit);
 240
 241         while (1) {
 242                 cpu_stat_update(cstate_map_fd, pstate_map_fd);
 243                 cpu_stat_print();
 244                 sleep(5);
 245         }
 246
 247 cleanup:
 248         bpf_link__destroy(link);
 249         bpf_object__close(obj);
 250         return 0;
 251 }