1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Thermal monitoring tool based on the thermal netlink events. 4 * 5 * Copyright (C) 2022 Linaro Ltd. 6 * 7 * Author: Daniel Lezcano <daniel.lezcano@kernel.org> 8 */ 9 #include <errno.h> 10 #include <fcntl.h> 11 #include <getopt.h> 12 #include <libgen.h> 13 #include <limits.h> 14 #include <stdio.h> 15 #include <stdlib.h> 16 #include <string.h> 17 #include <signal.h> 18 #include <unistd.h> 19 20 #include <syslog.h> 21 22 #include <sys/epoll.h> 23 #include <sys/stat.h> 24 #include <sys/types.h> 25 26 #include <thermal.h> 27 #include "thermal-tools.h" 28 29 struct options { 30 int loglevel; 31 int logopt; 32 int interactive; 33 int daemonize; 34 }; 35 36 struct thermal_data { 37 struct thermal_zone *tz; 38 struct thermal_handler *th; 39 }; 40 41 static int show_threshold(struct thermal_threshold *th, __maybe_unused void *arg) 42 { 43 INFO("threshold temp=%d, direction=%d\n", 44 th->temperature, th->direction); 45 46 return 0; 47 } 48 49 static int show_trip(struct thermal_trip *tt, __maybe_unused void *arg) 50 { 51 INFO("trip id=%d, type=%d, temp=%d, hyst=%d\n", 52 tt->id, tt->type, tt->temp, tt->hyst); 53 54 return 0; 55 } 56 57 static int show_temp(struct thermal_zone *tz, __maybe_unused void *arg) 58 { 59 thermal_cmd_get_temp(arg, tz); 60 61 INFO("temperature: %d\n", tz->temp); 62 63 return 0; 64 } 65 66 static int show_governor(struct thermal_zone *tz, __maybe_unused void *arg) 67 { 68 thermal_cmd_get_governor(arg, tz); 69 70 INFO("governor: '%s'\n", tz->governor); 71 72 return 0; 73 } 74 75 static int show_tz(struct thermal_zone *tz, __maybe_unused void *arg) 76 { 77 INFO("thermal zone '%s', id=%d\n", tz->name, tz->id); 78 79 for_each_thermal_trip(tz->trip, show_trip, NULL); 80 81 for_each_thermal_threshold(tz->thresholds, show_threshold, NULL); 82 83 show_temp(tz, arg); 84 85 show_governor(tz, arg); 86 87 return 0; 88 } 89 90 static int set_threshold(struct thermal_zone *tz, __maybe_unused void *arg) 91 { 92 struct thermal_handler *th = arg; 93 int thresholds[] = { 43000, 65000, 49000, 55000, 57000 }; 94 size_t i; 95 96 INFO("Setting threshold for thermal zone '%s', id=%d\n", tz->name, tz->id); 97 98 if (thermal_cmd_threshold_flush(th, tz)) { 99 ERROR("Failed to flush all previous thresholds\n"); 100 return -1; 101 } 102 103 for (i = 0; i < sizeof(thresholds) / sizeof(thresholds[0]); i++) 104 if (thermal_cmd_threshold_add(th, tz, thresholds[i], 105 THERMAL_THRESHOLD_WAY_UP | 106 THERMAL_THRESHOLD_WAY_DOWN)) { 107 ERROR("Failed to set threshold\n"); 108 return -1; 109 } 110 111 return 0; 112 } 113 114 static int tz_create(const char *name, int tz_id, __maybe_unused void *arg) 115 { 116 INFO("Thermal zone '%s'/%d created\n", name, tz_id); 117 118 return 0; 119 } 120 121 static int tz_delete(int tz_id, __maybe_unused void *arg) 122 { 123 INFO("Thermal zone %d deleted\n", tz_id); 124 125 return 0; 126 } 127 128 static int tz_disable(int tz_id, void *arg) 129 { 130 struct thermal_data *td = arg; 131 struct thermal_zone *tz = thermal_zone_find_by_id(td->tz, tz_id); 132 133 INFO("Thermal zone %d ('%s') disabled\n", tz_id, tz->name); 134 135 return 0; 136 } 137 138 static int tz_enable(int tz_id, void *arg) 139 { 140 struct thermal_data *td = arg; 141 struct thermal_zone *tz = thermal_zone_find_by_id(td->tz, tz_id); 142 143 INFO("Thermal zone %d ('%s') enabled\n", tz_id, tz->name); 144 145 return 0; 146 } 147 148 static int trip_high(int tz_id, int trip_id, int temp, void *arg) 149 { 150 struct thermal_data *td = arg; 151 struct thermal_zone *tz = thermal_zone_find_by_id(td->tz, tz_id); 152 153 INFO("Thermal zone %d ('%s'): trip point %d crossed way up with %d °C\n", 154 tz_id, tz->name, trip_id, temp); 155 156 return 0; 157 } 158 159 static int trip_low(int tz_id, int trip_id, int temp, void *arg) 160 { 161 struct thermal_data *td = arg; 162 struct thermal_zone *tz = thermal_zone_find_by_id(td->tz, tz_id); 163 164 INFO("Thermal zone %d ('%s'): trip point %d crossed way down with %d °C\n", 165 tz_id, tz->name, trip_id, temp); 166 167 return 0; 168 } 169 170 static int trip_add(int tz_id, int trip_id, int type, int temp, int hyst, __maybe_unused void *arg) 171 { 172 INFO("Trip point added %d: id=%d, type=%d, temp=%d, hyst=%d\n", 173 tz_id, trip_id, type, temp, hyst); 174 175 return 0; 176 } 177 178 static int trip_delete(int tz_id, int trip_id, __maybe_unused void *arg) 179 { 180 INFO("Trip point deleted %d: id=%d\n", tz_id, trip_id); 181 182 return 0; 183 } 184 185 static int trip_change(int tz_id, int trip_id, int type, int temp, 186 int hyst, __maybe_unused void *arg) 187 { 188 struct thermal_data *td = arg; 189 struct thermal_zone *tz = thermal_zone_find_by_id(td->tz, tz_id); 190 191 INFO("Trip point changed %d: id=%d, type=%d, temp=%d, hyst=%d\n", 192 tz_id, trip_id, type, temp, hyst); 193 194 tz->trip[trip_id].type = type; 195 tz->trip[trip_id].temp = temp; 196 tz->trip[trip_id].hyst = hyst; 197 198 return 0; 199 } 200 201 static int cdev_add(const char *name, int cdev_id, int max_state, __maybe_unused void *arg) 202 { 203 INFO("Cooling device '%s'/%d (max state=%d) added\n", name, cdev_id, max_state); 204 205 return 0; 206 } 207 208 static int cdev_delete(int cdev_id, __maybe_unused void *arg) 209 { 210 INFO("Cooling device %d deleted", cdev_id); 211 212 return 0; 213 } 214 215 static int cdev_update(int cdev_id, int cur_state, __maybe_unused void *arg) 216 { 217 INFO("cdev:%d state:%d\n", cdev_id, cur_state); 218 219 return 0; 220 } 221 222 static int gov_change(int tz_id, const char *name, __maybe_unused void *arg) 223 { 224 struct thermal_data *td = arg; 225 struct thermal_zone *tz = thermal_zone_find_by_id(td->tz, tz_id); 226 227 INFO("%s: governor changed %s -> %s\n", tz->name, tz->governor, name); 228 229 strcpy(tz->governor, name); 230 231 return 0; 232 } 233 234 static int threshold_add(int tz_id, int temp, int direction, __maybe_unused void *arg) 235 { 236 INFO("Threshold added tz_id=%d: temp=%d, direction=%d\n", tz_id, temp, direction); 237 238 return 0; 239 } 240 241 static int threshold_delete(int tz_id, int temp, int direction, __maybe_unused void *arg) 242 { 243 INFO("Threshold deleted tz_id=%d: temp=%d, direction=%d\n", tz_id, temp, direction); 244 245 return 0; 246 } 247 248 static int threshold_flush(int tz_id, __maybe_unused void *arg) 249 { 250 INFO("Thresholds flushed tz_id=%d\n", tz_id); 251 252 return 0; 253 } 254 255 static int threshold_up(int tz_id, int temp, int prev_temp, __maybe_unused void *arg) 256 { 257 INFO("Threshold crossed way up tz_id=%d: temp=%d, prev_temp=%d\n", 258 tz_id, temp, prev_temp); 259 260 return 0; 261 } 262 263 static int threshold_down(int tz_id, int temp, int prev_temp, __maybe_unused void *arg) 264 { 265 INFO("Threshold crossed way down tz_id=%d: temp=%d, prev_temp=%d\n", 266 tz_id, temp, prev_temp); 267 268 return 0; 269 } 270 271 static struct thermal_ops ops = { 272 .events.tz_create = tz_create, 273 .events.tz_delete = tz_delete, 274 .events.tz_disable = tz_disable, 275 .events.tz_enable = tz_enable, 276 .events.trip_high = trip_high, 277 .events.trip_low = trip_low, 278 .events.trip_add = trip_add, 279 .events.trip_delete = trip_delete, 280 .events.trip_change = trip_change, 281 .events.cdev_add = cdev_add, 282 .events.cdev_delete = cdev_delete, 283 .events.cdev_update = cdev_update, 284 .events.gov_change = gov_change, 285 .events.threshold_add = threshold_add, 286 .events.threshold_delete = threshold_delete, 287 .events.threshold_flush = threshold_flush, 288 .events.threshold_up = threshold_up, 289 .events.threshold_down = threshold_down, 290 }; 291 292 static int thermal_event(__maybe_unused int fd, __maybe_unused void *arg) 293 { 294 struct thermal_data *td = arg; 295 296 return thermal_events_handle(td->th, td); 297 } 298 299 static void usage(const char *cmd) 300 { 301 printf("%s : A thermal monitoring engine based on notifications\n", cmd); 302 printf("Usage: %s [options]\n", cmd); 303 printf("\t-h, --help\t\tthis help\n"); 304 printf("\t-d, --daemonize\n"); 305 printf("\t-l <level>, --loglevel <level>\tlog level: "); 306 printf("DEBUG, INFO, NOTICE, WARN, ERROR\n"); 307 printf("\t-s, --syslog\t\toutput to syslog\n"); 308 printf("\n"); 309 exit(0); 310 } 311 312 static int options_init(int argc, char *argv[], struct options *options) 313 { 314 int opt; 315 316 struct option long_options[] = { 317 { "help", no_argument, NULL, 'h' }, 318 { "daemonize", no_argument, NULL, 'd' }, 319 { "syslog", no_argument, NULL, 's' }, 320 { "loglevel", required_argument, NULL, 'l' }, 321 { 0, 0, 0, 0 } 322 }; 323 324 while (1) { 325 326 int optindex = 0; 327 328 opt = getopt_long(argc, argv, "l:dhs", long_options, &optindex); 329 if (opt == -1) 330 break; 331 332 switch (opt) { 333 case 'l': 334 options->loglevel = log_str2level(optarg); 335 break; 336 case 'd': 337 options->daemonize = 1; 338 break; 339 case 's': 340 options->logopt = TO_SYSLOG; 341 break; 342 case 'h': 343 usage(basename(argv[0])); 344 break; 345 default: /* '?' */ 346 return -1; 347 } 348 } 349 350 return 0; 351 } 352 353 enum { 354 THERMAL_ENGINE_SUCCESS = 0, 355 THERMAL_ENGINE_OPTION_ERROR, 356 THERMAL_ENGINE_DAEMON_ERROR, 357 THERMAL_ENGINE_LOG_ERROR, 358 THERMAL_ENGINE_THERMAL_ERROR, 359 THERMAL_ENGINE_THRESHOLD_ERROR, 360 THERMAL_ENGINE_MAINLOOP_ERROR, 361 }; 362 363 int main(int argc, char *argv[]) 364 { 365 struct thermal_data td; 366 struct options options = { 367 .loglevel = LOG_INFO, 368 .logopt = TO_STDOUT, 369 }; 370 371 if (options_init(argc, argv, &options)) { 372 ERROR("Usage: %s --help\n", argv[0]); 373 return THERMAL_ENGINE_OPTION_ERROR; 374 } 375 376 if (options.daemonize && daemon(0, 0)) { 377 ERROR("Failed to daemonize: %p\n"); 378 return THERMAL_ENGINE_DAEMON_ERROR; 379 } 380 381 if (log_init(options.loglevel, basename(argv[0]), options.logopt)) { 382 ERROR("Failed to initialize logging facility\n"); 383 return THERMAL_ENGINE_LOG_ERROR; 384 } 385 386 td.th = thermal_init(&ops); 387 if (!td.th) { 388 ERROR("Failed to initialize the thermal library\n"); 389 return THERMAL_ENGINE_THERMAL_ERROR; 390 } 391 392 td.tz = thermal_zone_discover(td.th); 393 if (!td.tz) { 394 ERROR("No thermal zone available\n"); 395 return THERMAL_ENGINE_THERMAL_ERROR; 396 } 397 398 for_each_thermal_zone(td.tz, set_threshold, td.th); 399 400 for_each_thermal_zone(td.tz, show_tz, td.th); 401 402 if (mainloop_init()) { 403 ERROR("Failed to initialize the mainloop\n"); 404 return THERMAL_ENGINE_MAINLOOP_ERROR; 405 } 406 407 if (mainloop_add(thermal_events_fd(td.th), thermal_event, &td)) { 408 ERROR("Failed to setup the mainloop\n"); 409 return THERMAL_ENGINE_MAINLOOP_ERROR; 410 } 411 412 INFO("Waiting for thermal events ...\n"); 413 414 if (mainloop(-1)) { 415 ERROR("Mainloop failed\n"); 416 return THERMAL_ENGINE_MAINLOOP_ERROR; 417 } 418 419 return THERMAL_ENGINE_SUCCESS; 420 } 421