xref: /linux/tools/thermal/thermometer/thermometer.c (revision 7f71507851fc7764b36a3221839607d3a45c2025) 
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 }
574