tools/thermal/thermometer/thermometer.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright (C) 2022, Linaro Ltd - Daniel Lezcano <daniel.lezcano@linaro.org>
   3 #define _GNU_SOURCE
   4 #include <dirent.h>
   5 #include <fcntl.h>
   6 #include <getopt.h>
   7 #include <regex.h>
   8 #include <signal.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <sys/stat.h>
  13 #include <sys/signalfd.h>
  14 #include <sys/timerfd.h>
  15 #include <sys/types.h>
  16 #include <sys/wait.h>
  17 #include <time.h>
  18 #include <unistd.h>
  19 #include <linux/thermal.h>
  20
  21 #include <libconfig.h>
  22 #include "thermal-tools.h"
  23
  24 #define CLASS_THERMAL "/sys/class/thermal"
  25
  26 enum {
  27         THERMOMETER_SUCCESS = 0,
  28         THERMOMETER_OPTION_ERROR,
  29         THERMOMETER_LOG_ERROR,
  30         THERMOMETER_CONFIG_ERROR,
  31         THERMOMETER_TIME_ERROR,
  32         THERMOMETER_INIT_ERROR,
  33         THERMOMETER_RUNTIME_ERROR
  34 };
  35
  36 struct options {
  37         int loglvl;
  38         int logopt;
  39         int overwrite;
  40         int duration;
  41         const char *config;
  42         char postfix[PATH_MAX];
  43         char output[PATH_MAX];
  44 };
  45
  46 struct tz_regex {
  47         regex_t regex;
  48         int polling;
  49 };
  50
  51 struct configuration {
  52         struct tz_regex *tz_regex;
  53         int nr_tz_regex;
  54
  55 };
  56
  57 struct tz {
  58         FILE *file_out;
  59         int fd_temp;
  60         int fd_timer;
  61         int polling;
  62         const char *name;
  63 };
  64
  65 struct thermometer {
  66         struct tz *tz;
  67         int nr_tz;
  68 };
  69
  70 static struct tz_regex *configuration_tz_match(const char *expr,
  71                                                struct configuration *config)
  72 {
  73         int i;
  74
  75         for (i = 0; i < config->nr_tz_regex; i++) {
  76
  77                 if (!regexec(&config->tz_regex[i].regex, expr, 0, NULL, 0))
  78                         return &config->tz_regex[i];
  79         }
  80
  81         return NULL;
  82 }
  83
  84 static int configuration_default_init(struct configuration *config)
  85 {
  86         config->tz_regex = realloc(config->tz_regex, sizeof(*config->tz_regex) *
  87                                    (config->nr_tz_regex + 1));
  88
  89         if (regcomp(&config->tz_regex[config->nr_tz_regex].regex, ".*",
  90                     REG_NOSUB | REG_EXTENDED)) {
  91                 ERROR("Invalid regular expression\n");
  92                 return -1;
  93         }
  94
  95         config->tz_regex[config->nr_tz_regex].polling = 250;
  96         config->nr_tz_regex = 1;
  97
  98         return 0;
  99 }
 100
 101 static int configuration_init(const char *path, struct configuration *config)
 102 {
 103         config_t cfg;
 104
 105         config_setting_t *tz;
 106         int i, length;
 107
 108         if (path && access(path, F_OK)) {
 109                 ERROR("'%s' is not accessible\n", path);
 110                 return -1;
 111         }
 112
 113         if (!path && !config->nr_tz_regex) {
 114                 INFO("No thermal zones configured, using wildcard for all of them\n");
 115                 return configuration_default_init(config);
 116         }
 117
 118         config_init(&cfg);
 119
 120         if (!config_read_file(&cfg, path)) {
 121                 ERROR("Failed to parse %s:%d - %s\n", config_error_file(&cfg),
 122                       config_error_line(&cfg), config_error_text(&cfg));
 123
 124                 return -1;
 125         }
 126
 127         tz = config_lookup(&cfg, "thermal-zones");
 128         if (!tz) {
 129                 ERROR("No thermal zone configured to be monitored\n");
 130                 return -1;
 131         }
 132
 133         length = config_setting_length(tz);
 134
 135         INFO("Found %d thermal zone(s) regular expression\n", length);
 136
 137         for (i = 0; i < length; i++) {
 138
 139                 config_setting_t *node;
 140                 const char *name;
 141                 int polling;
 142
 143                 node = config_setting_get_elem(tz, i);
 144                 if (!node) {
 145                         ERROR("Missing node name '%d'\n", i);
 146                         return -1;
 147                 }
 148
 149                 if (!config_setting_lookup_string(node, "name", &name)) {
 150                         ERROR("Thermal zone name not found\n");
 151                         return -1;
 152                 }
 153
 154                 if (!config_setting_lookup_int(node, "polling", &polling)) {
 155                         ERROR("Polling value not found");
 156                         return -1;
 157                 }
 158
 159                 config->tz_regex = realloc(config->tz_regex, sizeof(*config->tz_regex) *
 160                                         (config->nr_tz_regex + 1));
 161
 162                 if (regcomp(&config->tz_regex[config->nr_tz_regex].regex, name,
 163                             REG_NOSUB | REG_EXTENDED)) {
 164                         ERROR("Invalid regular expression '%s'\n", name);
 165                         continue;
 166                 }
 167
 168                 config->tz_regex[config->nr_tz_regex].polling = polling;
 169                 config->nr_tz_regex++;
 170
 171                 INFO("Thermal zone regular expression '%s' with polling %d\n",
 172                      name, polling);
 173         }
 174
 175         return 0;
 176 }
 177
 178 static void usage(const char *cmd)
 179 {
 180         printf("%s Version: %s\n", cmd, VERSION);
 181         printf("Usage: %s [options]\n", cmd);
 182         printf("\t-h, --help\t\tthis help\n");
 183         printf("\t-o, --output <dir>\toutput directory for temperature capture\n");
 184         printf("\t-c, --config <file>\tconfiguration file\n");
 185         printf("\t-d, --duration <seconds>\tcapture duration\n");
 186         printf("\t-l, --loglevel <level>\tlog level: ");
 187         printf("DEBUG, INFO, NOTICE, WARN, ERROR\n");
 188         printf("\t-p, --postfix <string>\tpostfix to be happened at the end of the files\n");
 189         printf("\t-s, --syslog\t\toutput to syslog\n");
 190         printf("\t-w, --overwrite\t\toverwrite the temperature capture files if they exist\n");
 191         printf("\n");
 192         exit(0);
 193 }
 194
 195 static int options_init(int argc, char *argv[], struct options *options)
 196 {
 197         int opt;
 198         time_t now = time(NULL);
 199
 200         struct option long_options[] = {
 201                 { "help",       no_argument, NULL, 'h' },
 202                 { "config",     required_argument, NULL, 'c' },
 203                 { "duration",   required_argument, NULL, 'd' },
 204                 { "loglevel",   required_argument, NULL, 'l' },
 205                 { "postfix",    required_argument, NULL, 'p' },
 206                 { "output",     required_argument, NULL, 'o' },
 207                 { "syslog",     required_argument, NULL, 's' },
 208                 { "overwrite",  no_argument, NULL, 'w' },
 209                 { 0, 0, 0, 0 }
 210         };
 211
 212         strftime(options->postfix, sizeof(options->postfix),
 213                  "-%Y-%m-%d_%H:%M:%S", gmtime(&now));
 214
 215         while (1) {
 216
 217                 int optindex = 0;
 218
 219                 opt = getopt_long(argc, argv, "ho:c:d:l:p:sw", long_options, &optindex);
 220                 if (opt == -1)
 221                         break;
 222
 223                 switch (opt) {
 224                 case 'c':
 225                         options->config = optarg;
 226                         break;
 227                 case 'd':
 228                         options->duration = atoi(optarg) * 1000;
 229                         break;
 230                 case 'l':
 231                         options->loglvl = log_str2level(optarg);
 232                         break;
 233                 case 'h':
 234                         usage(basename(argv[0]));
 235                         break;
 236                 case 'p':
 237                         strcpy(options->postfix, optarg);
 238                         break;
 239                 case 'o':
 240                         strcpy(options->output, optarg);
 241                         break;
 242                 case 's':
 243                         options->logopt = TO_SYSLOG;
 244                         break;
 245                 case 'w':
 246                         options->overwrite = 1;
 247                         break;
 248                 default: /* '?' */
 249                         ERROR("Usage: %s --help\n", argv[0]);
 250                         return -1;
 251                 }
 252         }
 253
 254         return 0;
 255 }
 256
 257 static int thermometer_add_tz(const char *path, const char *name, int polling,
 258                               struct thermometer *thermometer)
 259 {
 260         int fd;
 261         char tz_path[PATH_MAX];
 262         struct tz *tz;
 263
 264         sprintf(tz_path, CLASS_THERMAL"/%s/temp", path);
 265
 266         fd = open(tz_path, O_RDONLY);
 267         if (fd < 0) {
 268                 ERROR("Failed to open '%s': %m\n", tz_path);
 269                 return -1;
 270         }
 271
 272         tz = realloc(thermometer->tz, sizeof(*thermometer->tz) * (thermometer->nr_tz + 1));
 273         if (!tz) {
 274                 ERROR("Failed to allocate thermometer->tz\n");
 275                 return -1;
 276         }
 277
 278         thermometer->tz = tz;
 279         thermometer->tz[thermometer->nr_tz].fd_temp = fd;
 280         thermometer->tz[thermometer->nr_tz].name = strdup(name);
 281         thermometer->tz[thermometer->nr_tz].polling = polling;
 282         thermometer->nr_tz++;
 283
 284         INFO("Added thermal zone '%s->%s (polling:%d)'\n", path, name, polling);
 285
 286         return 0;
 287 }
 288
 289 static int thermometer_init(struct configuration *config,
 290                             struct thermometer *thermometer)
 291 {
 292         DIR *dir;
 293         struct dirent *dirent;
 294         struct tz_regex *tz_regex;
 295         const char *tz_dirname = "thermal_zone";
 296
 297         if (mainloop_init()) {
 298                 ERROR("Failed to start mainloop\n");
 299                 return -1;
 300         }
 301
 302         dir = opendir(CLASS_THERMAL);
 303         if (!dir) {
 304                 ERROR("failed to open '%s'\n", CLASS_THERMAL);
 305                 return -1;
 306         }
 307
 308         while ((dirent = readdir(dir))) {
 309                 char tz_type[THERMAL_NAME_LENGTH];
 310                 char tz_path[PATH_MAX];
 311                 FILE *tz_file;
 312
 313                 if (strncmp(dirent->d_name, tz_dirname, strlen(tz_dirname)))
 314                         continue;
 315
 316                 sprintf(tz_path, CLASS_THERMAL"/%s/type", dirent->d_name);
 317
 318                 tz_file = fopen(tz_path, "r");
 319                 if (!tz_file) {
 320                         ERROR("Failed to open '%s': %m", tz_path);
 321                         continue;
 322                 }
 323
 324                 fscanf(tz_file, "%s", tz_type);
 325
 326                 fclose(tz_file);
 327
 328                 tz_regex = configuration_tz_match(tz_type, config);
 329                 if (!tz_regex)
 330                         continue;
 331
 332                 if (thermometer_add_tz(dirent->d_name, tz_type,
 333                                        tz_regex->polling, thermometer))
 334                         continue;
 335         }
 336
 337         closedir(dir);
 338
 339         return 0;
 340 }
 341
 342 static int timer_temperature_callback(int fd, void *arg)
 343 {
 344         struct tz *tz = arg;
 345         char buf[16] = { 0 };
 346
 347         pread(tz->fd_temp, buf, sizeof(buf), 0);
 348
 349         fprintf(tz->file_out, "%ld %s", getuptimeofday_ms(), buf);
 350
 351         read(fd, buf, sizeof(buf));
 352
 353         return 0;
 354 }
 355
 356 static int thermometer_start(struct thermometer *thermometer,
 357                              struct options *options)
 358 {
 359         struct itimerspec timer_it = { 0 };
 360         char *path;
 361         FILE *f;
 362         int i;
 363
 364         INFO("Capturing %d thermal zone(s) temperature...\n", thermometer->nr_tz);
 365
 366         if (access(options->output, F_OK) && mkdir(options->output, 0700)) {
 367                 ERROR("Failed to create directory '%s'\n", options->output);
 368                 return -1;
 369         }
 370
 371         for (i = 0; i < thermometer->nr_tz; i++) {
 372
 373                 asprintf(&path, "%s/%s%s", options->output,
 374                          thermometer->tz[i].name, options->postfix);
 375
 376                 if (!options->overwrite && !access(path, F_OK)) {
 377                         ERROR("'%s' already exists\n", path);
 378                         return -1;
 379                 }
 380
 381                 f = fopen(path, "w");
 382                 if (!f) {
 383                         ERROR("Failed to create '%s':%m\n", path);
 384                         return -1;
 385                 }
 386
 387                 fprintf(f, "timestamp(ms) %s(°mC)\n", thermometer->tz[i].name);
 388
 389                 thermometer->tz[i].file_out = f;
 390
 391                 DEBUG("Created '%s' file for thermal zone '%s'\n", path, thermometer->tz[i].name);
 392
 393                 /*
 394                  * Create polling timer
 395                  */
 396                 thermometer->tz[i].fd_timer = timerfd_create(CLOCK_MONOTONIC, 0);
 397                 if (thermometer->tz[i].fd_timer < 0) {
 398                         ERROR("Failed to create timer for '%s': %m\n",
 399                               thermometer->tz[i].name);
 400                         return -1;
 401                 }
 402
 403                 DEBUG("Watching '%s' every %d ms\n",
 404                       thermometer->tz[i].name, thermometer->tz[i].polling);
 405
 406                 timer_it.it_interval = timer_it.it_value =
 407                         msec_to_timespec(thermometer->tz[i].polling);
 408
 409                 if (timerfd_settime(thermometer->tz[i].fd_timer, 0,
 410                                     &timer_it, NULL) < 0)
 411                         return -1;
 412
 413                 if (mainloop_add(thermometer->tz[i].fd_timer,
 414                                  timer_temperature_callback,
 415                                  &thermometer->tz[i]))
 416                         return -1;
 417         }
 418
 419         return 0;
 420 }
 421
 422 static int thermometer_execute(int argc, char *argv[], char *const envp[], pid_t *pid)
 423 {
 424         if (!argc)
 425                 return 0;
 426
 427         *pid = fork();
 428         if (*pid < 0) {
 429                 ERROR("Failed to fork process: %m");
 430                 return -1;
 431         }
 432
 433         if (!(*pid)) {
 434                 execvpe(argv[0], argv, envp);
 435                 exit(1);
 436         }
 437
 438         return 0;
 439 }
 440
 441 static int kill_process(__maybe_unused int fd, void *arg)
 442 {
 443         pid_t pid = *(pid_t *)arg;
 444
 445         if (kill(pid, SIGTERM))
 446                 ERROR("Failed to send SIGTERM signal to '%d': %p\n", pid);
 447         else if (waitpid(pid, NULL, 0))
 448                 ERROR("Failed to wait pid '%d': %p\n", pid);
 449
 450         mainloop_exit();
 451
 452         return 0;
 453 }
 454
 455 static int exit_mainloop(__maybe_unused int fd, __maybe_unused void *arg)
 456 {
 457         mainloop_exit();
 458         return 0;
 459 }
 460
 461 static int thermometer_wait(struct options *options, pid_t pid)
 462 {
 463         int fd;
 464         sigset_t mask;
 465
 466         /*
 467          * If there is a duration specified, we will exit the mainloop
 468          * and gracefully close all the files which will flush the
 469          * file system cache
 470          */
 471         if (options->duration) {
 472                 struct itimerspec timer_it = { 0 };
 473
 474                 timer_it.it_value = msec_to_timespec(options->duration);
 475
 476                 fd = timerfd_create(CLOCK_MONOTONIC, 0);
 477                 if (fd < 0) {
 478                         ERROR("Failed to create duration timer: %m\n");
 479                         return -1;
 480                 }
 481
 482                 if (timerfd_settime(fd, 0, &timer_it, NULL)) {
 483                         ERROR("Failed to set timer time: %m\n");
 484                         return -1;
 485                 }
 486
 487                 if (mainloop_add(fd, pid < 0 ? exit_mainloop : kill_process, &pid)) {
 488                         ERROR("Failed to set timer exit mainloop callback\n");
 489                         return -1;
 490                 }
 491         }
 492
 493         /*
 494          * We want to catch any keyboard interrupt, as well as child
 495          * signals if any in order to exit properly
 496          */
 497         sigemptyset(&mask);
 498         sigaddset(&mask, SIGINT);
 499         sigaddset(&mask, SIGQUIT);
 500         sigaddset(&mask, SIGCHLD);
 501
 502         if (sigprocmask(SIG_BLOCK, &mask, NULL)) {
 503                 ERROR("Failed to set sigprocmask: %m\n");
 504                 return -1;
 505         }
 506
 507         fd = signalfd(-1, &mask, 0);
 508         if (fd < 0) {
 509                 ERROR("Failed to set the signalfd: %m\n");
 510                 return -1;
 511         }
 512
 513         if (mainloop_add(fd, exit_mainloop, NULL)) {
 514                 ERROR("Failed to set timer exit mainloop callback\n");
 515                 return -1;
 516         }
 517
 518         return mainloop(-1);
 519 }
 520
 521 static int thermometer_stop(struct thermometer *thermometer)
 522 {
 523         int i;
 524
 525         INFO("Closing/flushing output files\n");
 526
 527         for (i = 0; i < thermometer->nr_tz; i++)
 528                 fclose(thermometer->tz[i].file_out);
 529
 530         return 0;
 531 }
 532
 533 int main(int argc, char *argv[], char *const envp[])
 534 {
 535         struct options options = {
 536                 .loglvl = LOG_DEBUG,
 537                 .logopt = TO_STDOUT,
 538                 .output = ".",
 539         };
 540         struct configuration config = { 0 };
 541         struct thermometer thermometer = { 0 };
 542
 543         pid_t pid = -1;
 544
 545         if (options_init(argc, argv, &options))
 546                 return THERMOMETER_OPTION_ERROR;
 547
 548         if (log_init(options.loglvl, argv[0], options.logopt))
 549                 return THERMOMETER_LOG_ERROR;
 550
 551         if (configuration_init(options.config, &config))
 552                 return THERMOMETER_CONFIG_ERROR;
 553
 554         if (uptimeofday_init())
 555                 return THERMOMETER_TIME_ERROR;
 556
 557         if (thermometer_init(&config, &thermometer))
 558                 return THERMOMETER_INIT_ERROR;
 559
 560         if (thermometer_start(&thermometer, &options))
 561                 return THERMOMETER_RUNTIME_ERROR;
 562
 563         if (thermometer_execute(argc - optind, &argv[optind], envp, &pid))
 564                 return THERMOMETER_RUNTIME_ERROR;
 565
 566         if (thermometer_wait(&options, pid))
 567                 return THERMOMETER_RUNTIME_ERROR;
 568
 569         if (thermometer_stop(&thermometer))
 570                 return THERMOMETER_RUNTIME_ERROR;
 571
 572         return THERMOMETER_SUCCESS;
 573 }