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
263 sprintf(tz_path, CLASS_THERMAL"/%s/temp", path);
264
265 fd = open(tz_path, O_RDONLY);
266 if (fd < 0) {
267 ERROR("Failed to open '%s': %m\n", tz_path);
268 return -1;
269 }
270
271 thermometer->tz = realloc(thermometer->tz,
272 sizeof(*thermometer->tz) * (thermometer->nr_tz + 1));
273 if (!thermometer->tz) {
274 ERROR("Failed to allocate thermometer->tz\n");
275 return -1;
276 }
277
278 thermometer->tz[thermometer->nr_tz].fd_temp = fd;
279 thermometer->tz[thermometer->nr_tz].name = strdup(name);
280 thermometer->tz[thermometer->nr_tz].polling = polling;
281 thermometer->nr_tz++;
282
283 INFO("Added thermal zone '%s->%s (polling:%d)'\n", path, name, polling);
284
285 return 0;
286 }
287
288 static int thermometer_init(struct configuration *config,
289 struct thermometer *thermometer)
290 {
291 DIR *dir;
292 struct dirent *dirent;
293 struct tz_regex *tz_regex;
294 const char *tz_dirname = "thermal_zone";
295
296 if (mainloop_init()) {
297 ERROR("Failed to start mainloop\n");
298 return -1;
299 }
300
301 dir = opendir(CLASS_THERMAL);
302 if (!dir) {
303 ERROR("failed to open '%s'\n", CLASS_THERMAL);
304 return -1;
305 }
306
307 while ((dirent = readdir(dir))) {
308 char tz_type[THERMAL_NAME_LENGTH];
309 char tz_path[PATH_MAX];
310 FILE *tz_file;
311
312 if (strncmp(dirent->d_name, tz_dirname, strlen(tz_dirname)))
313 continue;
314
315 sprintf(tz_path, CLASS_THERMAL"/%s/type", dirent->d_name);
316
317 tz_file = fopen(tz_path, "r");
318 if (!tz_file) {
319 ERROR("Failed to open '%s': %m", tz_path);
320 continue;
321 }
322
323 fscanf(tz_file, "%s", tz_type);
324
325 fclose(tz_file);
326
327 tz_regex = configuration_tz_match(tz_type, config);
328 if (!tz_regex)
329 continue;
330
331 if (thermometer_add_tz(dirent->d_name, tz_type,
332 tz_regex->polling, thermometer))
333 continue;
334 }
335
336 closedir(dir);
337
338 return 0;
339 }
340
341 static int timer_temperature_callback(int fd, void *arg)
342 {
343 struct tz *tz = arg;
344 char buf[16] = { 0 };
345
346 pread(tz->fd_temp, buf, sizeof(buf), 0);
347
348 fprintf(tz->file_out, "%ld %s", getuptimeofday_ms(), buf);
349
350 read(fd, buf, sizeof(buf));
351
352 return 0;
353 }
354
355 static int thermometer_start(struct thermometer *thermometer,
356 struct options *options)
357 {
358 struct itimerspec timer_it = { 0 };
359 char *path;
360 FILE *f;
361 int i;
362
363 INFO("Capturing %d thermal zone(s) temperature...\n", thermometer->nr_tz);
364
365 if (access(options->output, F_OK) && mkdir(options->output, 0700)) {
366 ERROR("Failed to create directory '%s'\n", options->output);
367 return -1;
368 }
369
370 for (i = 0; i < thermometer->nr_tz; i++) {
371
372 asprintf(&path, "%s/%s%s", options->output,
373 thermometer->tz[i].name, options->postfix);
374
375 if (!options->overwrite && !access(path, F_OK)) {
376 ERROR("'%s' already exists\n", path);
377 return -1;
378 }
379
380 f = fopen(path, "w");
381 if (!f) {
382 ERROR("Failed to create '%s':%m\n", path);
383 return -1;
384 }
385
386 fprintf(f, "timestamp(ms) %s(°mC)\n", thermometer->tz[i].name);
387
388 thermometer->tz[i].file_out = f;
389
390 DEBUG("Created '%s' file for thermal zone '%s'\n", path, thermometer->tz[i].name);
391
392 /*
393 * Create polling timer
394 */
395 thermometer->tz[i].fd_timer = timerfd_create(CLOCK_MONOTONIC, 0);
396 if (thermometer->tz[i].fd_timer < 0) {
397 ERROR("Failed to create timer for '%s': %m\n",
398 thermometer->tz[i].name);
399 return -1;
400 }
401
402 DEBUG("Watching '%s' every %d ms\n",
403 thermometer->tz[i].name, thermometer->tz[i].polling);
404
405 timer_it.it_interval = timer_it.it_value =
406 msec_to_timespec(thermometer->tz[i].polling);
407
408 if (timerfd_settime(thermometer->tz[i].fd_timer, 0,
409 &timer_it, NULL) < 0)
410 return -1;
411
412 if (mainloop_add(thermometer->tz[i].fd_timer,
413 timer_temperature_callback,
414 &thermometer->tz[i]))
415 return -1;
416 }
417
418 return 0;
419 }
420
421 static int thermometer_execute(int argc, char *argv[], char *const envp[], pid_t *pid)
422 {
423 if (!argc)
424 return 0;
425
426 *pid = fork();
427 if (*pid < 0) {
428 ERROR("Failed to fork process: %m");
429 return -1;
430 }
431
432 if (!(*pid)) {
433 execvpe(argv[0], argv, envp);
434 exit(1);
435 }
436
437 return 0;
438 }
439
440 static int kill_process(__maybe_unused int fd, void *arg)
441 {
442 pid_t pid = *(pid_t *)arg;
443
444 if (kill(pid, SIGTERM))
445 ERROR("Failed to send SIGTERM signal to '%d': %p\n", pid);
446 else if (waitpid(pid, NULL, 0))
447 ERROR("Failed to wait pid '%d': %p\n", pid);
448
449 mainloop_exit();
450
451 return 0;
452 }
453
454 static int exit_mainloop(__maybe_unused int fd, __maybe_unused void *arg)
455 {
456 mainloop_exit();
457 return 0;
458 }
459
460 static int thermometer_wait(struct options *options, pid_t pid)
461 {
462 int fd;
463 sigset_t mask;
464
465 /*
466 * If there is a duration specified, we will exit the mainloop
467 * and gracefully close all the files which will flush the
468 * file system cache
469 */
470 if (options->duration) {
471 struct itimerspec timer_it = { 0 };
472
473 timer_it.it_value = msec_to_timespec(options->duration);
474
475 fd = timerfd_create(CLOCK_MONOTONIC, 0);
476 if (fd < 0) {
477 ERROR("Failed to create duration timer: %m\n");
478 return -1;
479 }
480
481 if (timerfd_settime(fd, 0, &timer_it, NULL)) {
482 ERROR("Failed to set timer time: %m\n");
483 return -1;
484 }
485
486 if (mainloop_add(fd, pid < 0 ? exit_mainloop : kill_process, &pid)) {
487 ERROR("Failed to set timer exit mainloop callback\n");
488 return -1;
489 }
490 }
491
492 /*
493 * We want to catch any keyboard interrupt, as well as child
494 * signals if any in order to exit properly
495 */
496 sigemptyset(&mask);
497 sigaddset(&mask, SIGINT);
498 sigaddset(&mask, SIGQUIT);
499 sigaddset(&mask, SIGCHLD);
500
501 if (sigprocmask(SIG_BLOCK, &mask, NULL)) {
502 ERROR("Failed to set sigprocmask: %m\n");
503 return -1;
504 }
505
506 fd = signalfd(-1, &mask, 0);
507 if (fd < 0) {
508 ERROR("Failed to set the signalfd: %m\n");
509 return -1;
510 }
511
512 if (mainloop_add(fd, exit_mainloop, NULL)) {
513 ERROR("Failed to set timer exit mainloop callback\n");
514 return -1;
515 }
516
517 return mainloop(-1);
518 }
519
520 static int thermometer_stop(struct thermometer *thermometer)
521 {
522 int i;
523
524 INFO("Closing/flushing output files\n");
525
526 for (i = 0; i < thermometer->nr_tz; i++)
527 fclose(thermometer->tz[i].file_out);
528
529 return 0;
530 }
531
532 int main(int argc, char *argv[], char *const envp[])
533 {
534 struct options options = {
535 .loglvl = LOG_DEBUG,
536 .logopt = TO_STDOUT,
537 .output = ".",
538 };
539 struct configuration config = { 0 };
540 struct thermometer thermometer = { 0 };
541
542 pid_t pid = -1;
543
544 if (options_init(argc, argv, &options))
545 return THERMOMETER_OPTION_ERROR;
546
547 if (log_init(options.loglvl, argv[0], options.logopt))
548 return THERMOMETER_LOG_ERROR;
549
550 if (configuration_init(options.config, &config))
551 return THERMOMETER_CONFIG_ERROR;
552
553 if (uptimeofday_init())
554 return THERMOMETER_TIME_ERROR;
555
556 if (thermometer_init(&config, &thermometer))
557 return THERMOMETER_INIT_ERROR;
558
559 if (thermometer_start(&thermometer, &options))
560 return THERMOMETER_RUNTIME_ERROR;
561
562 if (thermometer_execute(argc - optind, &argv[optind], envp, &pid))
563 return THERMOMETER_RUNTIME_ERROR;
564
565 if (thermometer_wait(&options, pid))
566 return THERMOMETER_RUNTIME_ERROR;
567
568 if (thermometer_stop(&thermometer))
569 return THERMOMETER_RUNTIME_ERROR;
570
571 return THERMOMETER_SUCCESS;
572 }
573
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.