src/lib/psensor.c

   1 /*
   2  * Copyright (C) 2010-2014 jeanfi@gmail.com
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301 USA
  18  */
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #include <locale.h>
  23 #include <libintl.h>
  24 #define _(str) gettext(str)
  25
  26 #include <hdd.h>
  27 #include <psensor.h>
  28 #include <lmsensor.h>
  29 #include <temperature.h>
  30
  31 #ifdef HAVE_GTOP
  32 #include <cpu.h>
  33 #include <pmem.h>
  34 #endif
  35
  36 struct psensor *psensor_create(char *id,
  37                                char *name,
  38                                char *chip,
  39                                unsigned int type,
  40                                int values_max_length)
  41 {
  42         struct psensor *psensor;
  43
  44         psensor = (struct psensor *)malloc(sizeof(struct psensor));
  45
  46         psensor->id = id;
  47         psensor->name = name;
  48         psensor->chip = chip;
  49         psensor->min = UNKNOWN_DBL_VALUE;
  50         psensor->max = UNKNOWN_DBL_VALUE;
  51
  52         psensor->type = type;
  53
  54         psensor->values_max_length = values_max_length;
  55         psensor->measures = measures_dbl_create(values_max_length);
  56
  57         psensor->alarm_enabled = 0;
  58         psensor->alarm_high_threshold = 0;
  59         psensor->alarm_low_threshold = 0;
  60
  61         psensor->cb_alarm_raised = NULL;
  62         psensor->cb_alarm_raised_data = NULL;
  63         psensor->alarm_raised = 0;
  64
  65         psensor->url = NULL;
  66
  67         psensor->color = NULL;
  68
  69         psensor->graph_enabled = 1;
  70         psensor->appindicator_enabled = 0;
  71
  72         return psensor;
  73 }
  74
  75 void psensor_values_resize(struct psensor *s, int new_size)
  76 {
  77         struct measure *new_ms, *cur_ms;
  78         int cur_size;
  79
  80         cur_size = s->values_max_length;
  81         cur_ms = s->measures;
  82         new_ms = measures_dbl_create(new_size);
  83
  84         if (cur_ms) {
  85                 int i;
  86                 for (i = 0; i < new_size - 1 && i < cur_size - 1; i++)
  87                         measure_copy(&cur_ms[cur_size - i - 1],
  88                                      &new_ms[new_size - i - 1]);
  89
  90                 measures_free(s->measures);
  91         }
  92
  93         s->values_max_length = new_size;
  94         s->measures = new_ms;
  95 }
  96
  97 void psensor_free(struct psensor *sensor)
  98 {
  99         if (sensor) {
 100                 log_debug("Cleanup %s", sensor->id);
 101
 102                 free(sensor->name);
 103                 free(sensor->id);
 104
 105                 if (sensor->chip)
 106                         free(sensor->chip);
 107
 108                 if (sensor->color)
 109                         free(sensor->color);
 110
 111                 measures_free(sensor->measures);
 112
 113                 free(sensor->url);
 114
 115                 free(sensor);
 116         }
 117 }
 118
 119 void psensor_list_free(struct psensor **sensors)
 120 {
 121         struct psensor **sensor_cur;
 122
 123         if (sensors) {
 124                 sensor_cur = sensors;
 125
 126                 while (*sensor_cur) {
 127                         psensor_free(*sensor_cur);
 128
 129                         sensor_cur++;
 130                 }
 131
 132                 free(sensors);
 133
 134                 sensors = NULL;
 135         }
 136 }
 137
 138 int psensor_list_size(struct psensor **sensors)
 139 {
 140         int size;
 141         struct psensor **sensor_cur;
 142
 143         if (!sensors)
 144                 return 0;
 145
 146         size = 0;
 147         sensor_cur = sensors;
 148
 149         while (*sensor_cur) {
 150                 size++;
 151                 sensor_cur++;
 152         }
 153         return size;
 154 }
 155
 156 int psensor_list_contains_type(struct psensor **sensors, unsigned int type)
 157 {
 158         struct psensor **s;
 159
 160         if (!sensors)
 161                 return 0;
 162
 163         s = sensors;
 164         while (*s) {
 165                 if ((*s)->type & type)
 166                         return 1;
 167                 s++;
 168         }
 169
 170         return 0;
 171 }
 172
 173 struct psensor **psensor_list_add(struct psensor **sensors,
 174                                   struct psensor *sensor)
 175 {
 176         int size;
 177
 178         size = psensor_list_size(sensors);
 179
 180         struct psensor **result
 181             = malloc((size + 1 + 1) * sizeof(struct psensor *));
 182
 183         if (sensors)
 184                 memcpy(result, sensors, size * sizeof(struct psensor *));
 185
 186         result[size] = sensor;
 187         result[size + 1] = NULL;
 188
 189         return result;
 190 }
 191
 192 void psensor_list_append(struct psensor ***sensors, struct psensor *sensor)
 193 {
 194         struct psensor **tmp;
 195
 196         if (!sensor)
 197                 return ;
 198
 199         tmp = psensor_list_add(*sensors, sensor);
 200
 201         if (tmp != *sensors) {
 202                 free(*sensors);
 203                 *sensors = tmp;
 204         }
 205 }
 206
 207
 208 struct psensor *psensor_list_get_by_id(struct psensor **sensors, const char *id)
 209 {
 210         struct psensor **sensors_cur = sensors;
 211
 212         while (*sensors_cur) {
 213                 if (!strcmp((*sensors_cur)->id, id))
 214                         return *sensors_cur;
 215
 216                 sensors_cur++;
 217         }
 218
 219         return NULL;
 220 }
 221
 222 int is_temp_type(unsigned int type)
 223 {
 224         return type & SENSOR_TYPE_TEMP;
 225 }
 226
 227 char *
 228 psensor_value_to_str(unsigned int type, double value, int use_celsius)
 229 {
 230         char *str;
 231         const char *unit;
 232
 233         /*
 234          * should not be possible to exceed 20 characters with temp or
 235          * rpm values the .x part is never displayed
 236          */
 237         str = malloc(20);
 238
 239         unit = psensor_type_to_unit_str(type, use_celsius);
 240
 241         if (is_temp_type(type) && !use_celsius)
 242                 value = celsius_to_fahrenheit(value);
 243
 244         sprintf(str, "%.0f%s", value, unit);
 245
 246         return str;
 247 }
 248
 249 char *
 250 psensor_measure_to_str(const struct measure *m,
 251                        unsigned int type,
 252                        unsigned int use_celsius)
 253 {
 254         return psensor_value_to_str(type, m->value, use_celsius);
 255 }
 256
 257 void psensor_set_current_value(struct psensor *sensor, double value)
 258 {
 259         struct timeval tv;
 260
 261         if (gettimeofday(&tv, NULL) != 0)
 262                 timerclear(&tv);
 263
 264         psensor_set_current_measure(sensor, value, tv);
 265 }
 266
 267 void psensor_set_current_measure(struct psensor *s, double v, struct timeval tv)
 268 {
 269         memmove(s->measures,
 270                 &s->measures[1],
 271                 (s->values_max_length - 1) * sizeof(struct measure));
 272
 273         s->measures[s->values_max_length - 1].value = v;
 274         s->measures[s->values_max_length - 1].time = tv;
 275
 276         if (s->min == UNKNOWN_DBL_VALUE || v < s->min)
 277                 s->min = v;
 278
 279         if (s->max == UNKNOWN_DBL_VALUE || v > s->max)
 280                 s->max = v;
 281
 282         if (s->alarm_enabled) {
 283                 if (v > s->alarm_high_threshold || v < s->alarm_low_threshold) {
 284                         if (!s->alarm_raised && s->cb_alarm_raised)
 285                                 s->cb_alarm_raised(s, s->cb_alarm_raised_data);
 286
 287                         s->alarm_raised = 1;
 288                 } else {
 289                         s->alarm_raised = 0;
 290                 }
 291         }
 292 }
 293
 294 double psensor_get_current_value(const struct psensor *sensor)
 295 {
 296         return sensor->measures[sensor->values_max_length - 1].value;
 297 }
 298
 299 struct measure *psensor_get_current_measure(struct psensor *sensor)
 300 {
 301         return &sensor->measures[sensor->values_max_length - 1];
 302 }
 303
 304 /*
 305   Returns the minimal value of a given 'type' (SENSOR_TYPE_TEMP or
 306   SENSOR_TYPE_FAN)
 307  */
 308 static double get_min_value(struct psensor **sensors, int type)
 309 {
 310         double m = UNKNOWN_DBL_VALUE;
 311         struct psensor **s = sensors;
 312
 313         while (*s) {
 314                 struct psensor *sensor = *s;
 315
 316                 if (sensor->type & type) {
 317                         int i;
 318                         double t;
 319
 320                         for (i = 0; i < sensor->values_max_length; i++) {
 321                                 t = sensor->measures[i].value;
 322
 323                                 if (t == UNKNOWN_DBL_VALUE)
 324                                         continue;
 325
 326                                 if (m == UNKNOWN_DBL_VALUE || t < m)
 327                                         m = t;
 328                         }
 329                 }
 330                 s++;
 331         }
 332
 333         return m;
 334 }
 335
 336 /*
 337   Returns the maximal value of a given 'type' (SENSOR_TYPE_TEMP or
 338   SENSOR_TYPE_FAN)
 339  */
 340 double get_max_value(struct psensor **sensors, int type)
 341 {
 342         double m = UNKNOWN_DBL_VALUE;
 343         struct psensor **s = sensors;
 344
 345         while (*s) {
 346                 struct psensor *sensor = *s;
 347
 348                 if (sensor->type & type) {
 349                         int i;
 350                         double t;
 351                         for (i = 0; i < sensor->values_max_length; i++) {
 352                                 t = sensor->measures[i].value;
 353
 354                                 if (t == UNKNOWN_DBL_VALUE)
 355                                         continue;
 356
 357                                 if (m == UNKNOWN_DBL_VALUE || t > m)
 358                                         m = t;
 359                         }
 360                 }
 361                 s++;
 362         }
 363
 364         return m;
 365 }
 366
 367 double
 368 psensor_get_max_current_value(struct psensor **sensors, unsigned int type)
 369 {
 370         double m = UNKNOWN_DBL_VALUE;
 371         struct psensor **s_cur = sensors;
 372
 373         while (*s_cur) {
 374                 struct psensor *s = *s_cur;
 375
 376                 if (s->graph_enabled && (s->type & type)) {
 377                         double v = psensor_get_current_value(s);
 378
 379                         if (m == UNKNOWN_DBL_VALUE || v > m)
 380                                 m = v;
 381                 }
 382
 383                 s_cur++;
 384         }
 385
 386         return m;
 387 }
 388
 389 double get_min_temp(struct psensor **sensors)
 390 {
 391         return get_min_value(sensors, SENSOR_TYPE_TEMP);
 392 }
 393
 394 double get_min_rpm(struct psensor **sensors)
 395 {
 396         return get_min_value(sensors, SENSOR_TYPE_FAN);
 397 }
 398
 399 double get_max_rpm(struct psensor **sensors)
 400 {
 401         return get_max_value(sensors, SENSOR_TYPE_FAN);
 402 }
 403
 404 double get_max_temp(struct psensor **sensors)
 405 {
 406         return get_max_value(sensors, SENSOR_TYPE_TEMP);
 407 }
 408
 409 struct psensor **get_all_sensors(int use_libatasmart, int values_max_length)
 410 {
 411         struct psensor **psensors;
 412         struct psensor **tmp_psensors;
 413
 414         psensors = lmsensor_psensor_list_add(NULL, values_max_length);
 415
 416         if (!use_libatasmart) {
 417                 tmp_psensors = hddtemp_psensor_list_add(psensors,
 418                                                         values_max_length);
 419                 if (tmp_psensors != psensors) {
 420                         free(psensors);
 421                         psensors = tmp_psensors;
 422                 }
 423         }
 424 #ifdef HAVE_ATASMART
 425                 else {
 426                         tmp_psensors = hdd_psensor_list_add(psensors,
 427                                                             values_max_length);
 428                         if (tmp_psensors != psensors) {
 429                                 free(psensors);
 430                                 psensors = tmp_psensors;
 431                         }
 432                 }
 433 #endif
 434
 435 #ifdef HAVE_GTOP
 436         mem_psensor_list_add(&psensors, values_max_length);
 437 #endif
 438
 439         if (!psensors) {        /* there is no detected sensors */
 440                 psensors = malloc(sizeof(struct psensor *));
 441                 *psensors = NULL;
 442         }
 443
 444         return psensors;
 445 }
 446
 447 const char *psensor_type_to_str(unsigned int type)
 448 {
 449         if (type & SENSOR_TYPE_NVCTRL) {
 450                 if (type & SENSOR_TYPE_TEMP)
 451                         return "Temperature";
 452                 else if (type & SENSOR_TYPE_GRAPHICS)
 453                         return "Graphics usage";
 454                 else if (type & SENSOR_TYPE_VIDEO)
 455                         return "Video usage";
 456                 else if (type & SENSOR_TYPE_MEMORY)
 457                         return "Memory usage";
 458                 else if (type & SENSOR_TYPE_PCIE)
 459                         return "PCIe usage";
 460                 else
 461                         return "NVIDIA GPU";
 462         }
 463
 464         if (type & SENSOR_TYPE_ATIADL) {
 465                 if (type & SENSOR_TYPE_TEMP)
 466                         return "AMD GPU Temperature";
 467                 else if (type & SENSOR_TYPE_RPM)
 468                         return "AMD GPU Fan Speed";
 469                 else /* type & SENSOR_TYPE_USAGE */
 470                         return "AMD GPU Usage";
 471         }
 472
 473         if ((type & SENSOR_TYPE_HDD_TEMP) == SENSOR_TYPE_HDD_TEMP)
 474                 return "HDD Temperature";
 475
 476         if ((type & SENSOR_TYPE_CPU_USAGE) == SENSOR_TYPE_CPU_USAGE)
 477                 return "CPU Usage";
 478
 479         if (type & SENSOR_TYPE_TEMP)
 480                 return "Temperature";
 481
 482         if (type & SENSOR_TYPE_RPM)
 483                 return "Fan";
 484
 485         if (type & SENSOR_TYPE_CPU)
 486                 return "CPU";
 487
 488         if (type & SENSOR_TYPE_REMOTE)
 489                 return "Remote";
 490
 491         if (type & SENSOR_TYPE_MEMORY)
 492                 return "Memory";
 493
 494         return "N/A";
 495 }
 496
 497
 498 const char *psensor_type_to_unit_str(unsigned int type, int use_celsius)
 499 {
 500         if (is_temp_type(type)) {
 501                 if (use_celsius)
 502                         return "\302\260C";
 503                 else
 504                         return "\302\260F";
 505         } else if (type & SENSOR_TYPE_RPM) {
 506                 return _("RPM");
 507         } else if (type & SENSOR_TYPE_PERCENT) {
 508                 return _("%");
 509         } else {
 510                 return _("N/A");
 511         }
 512 }
 513
 514 void psensor_list_update_measures(struct psensor **sensors)
 515 {
 516         lmsensor_psensor_list_update(sensors);
 517
 518 #ifdef HAVE_GTOP
 519         cpu_psensor_list_update(sensors);
 520         mem_psensor_list_update(sensors);
 521 #endif
 522
 523         if (psensor_list_contains_type(sensors, SENSOR_TYPE_HDDTEMP))
 524                 hddtemp_psensor_list_update(sensors);
 525
 526 #ifdef HAVE_ATASMART
 527         if (psensor_list_contains_type(sensors, SENSOR_TYPE_ATASMART))
 528                 hdd_psensor_list_update(sensors);
 529 #endif
 530 }
 531
 532 void psensor_log_measures(struct psensor **sensors)
 533 {
 534         if (log_level == LOG_DEBUG)
 535                 while (*sensors) {
 536                         log_debug("Measure: %s %.2f",
 537                                    (*sensors)->name,
 538                                    psensor_get_current_value(*sensors));
 539
 540                         sensors++;
 541                 }
 542 }
 543
 544 void psensor_init()
 545 {
 546         lmsensor_init();
 547 }
 548
 549 void psensor_cleanup()
 550 {
 551         lmsensor_cleanup();
 552 }
 553
 554 struct psensor **psensor_list_copy(struct psensor **sensors)
 555 {
 556         struct psensor **result;
 557         int n, i;
 558
 559         n = psensor_list_size(sensors);
 560         result = malloc((n+1) * sizeof(struct psensor *));
 561         for (i = 0; i < n; i++)
 562                 result[i] = sensors[i];
 563         result[n] = NULL;
 564
 565         return result;
 566 }
 567
 568 char *
 569 psensor_current_value_to_str(const struct psensor *s, unsigned int use_celsius)
 570 {
 571         return psensor_value_to_str(s->type,
 572                                     psensor_get_current_value(s),
 573                                     use_celsius);
 574 }
 575
 576 struct psensor **psensor_list_filter_graph_enabled(struct psensor **sensors)
 577 {
 578         int n, i;
 579         struct psensor **result, **cur, *s;
 580
 581         if (!sensors)
 582                 return NULL;
 583
 584         n = psensor_list_size(sensors);
 585         result = malloc((n+1) * sizeof(struct psensor *));
 586
 587         for (cur = sensors, i = 0; *cur; cur++) {
 588                 s = *cur;
 589
 590                 if (s->graph_enabled)
 591                         result[i++] = s;
 592         }
 593
 594         result[i] = NULL;
 595
 596         return result;
 597 }