src/lib/psensor.c

   1 /*
   2  * Copyright (C) 2010-2012 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
  30 #ifdef HAVE_GTOP
  31 #include "cpu.h"
  32 #endif
  33
  34
  35 struct psensor *psensor_create(char *id, char *name,
  36                                unsigned int type, int values_max_length)
  37 {
  38         struct psensor *psensor
  39             = (struct psensor *)malloc(sizeof(struct psensor));
  40
  41         psensor->id = id;
  42         psensor->name = name;
  43         psensor->enabled = 1;
  44         psensor->min = UNKNOWN_DBL_VALUE;
  45         psensor->max = UNKNOWN_DBL_VALUE;
  46
  47         psensor->type = type;
  48
  49         psensor->values_max_length = values_max_length;
  50         psensor->measures = measures_dbl_create(values_max_length);
  51
  52         psensor->alarm_limit = 0;
  53
  54         psensor->cb_alarm_raised = NULL;
  55         psensor->cb_alarm_raised_data = NULL;
  56         psensor->alarm_raised = 0;
  57
  58         psensor->alarm_enabled = 0;
  59
  60         psensor->url = NULL;
  61
  62         psensor->color = NULL;
  63
  64         return psensor;
  65 }
  66
  67 void psensor_values_resize(struct psensor *s, int new_size)
  68 {
  69         struct measure *new_ms, *cur_ms;
  70         int cur_size;
  71
  72         cur_size = s->values_max_length;
  73         cur_ms = s->measures;
  74         new_ms = measures_dbl_create(new_size);
  75
  76         if (cur_ms) {
  77                 int i;
  78                 for (i = 0; i < new_size - 1 && i < cur_size - 1; i++)
  79                         measure_copy(&cur_ms[cur_size - i - 1],
  80                                      &new_ms[new_size - i - 1]);
  81
  82                 measures_free(s->measures);
  83         }
  84
  85         s->values_max_length = new_size;
  86         s->measures = new_ms;
  87 }
  88
  89 void psensor_free(struct psensor *sensor)
  90 {
  91         if (sensor) {
  92                 free(sensor->name);
  93                 free(sensor->id);
  94
  95                 if (sensor->color)
  96                         free(sensor->color);
  97
  98                 measures_free(sensor->measures);
  99
 100                 free(sensor->url);
 101
 102                 free(sensor);
 103         }
 104 }
 105
 106 void psensor_list_free(struct psensor **sensors)
 107 {
 108         struct psensor **sensor_cur;
 109
 110         if (sensors) {
 111                 sensor_cur = sensors;
 112
 113                 while (*sensor_cur) {
 114                         psensor_free(*sensor_cur);
 115
 116                         sensor_cur++;
 117                 }
 118
 119                 free(sensors);
 120
 121                 sensors = NULL;
 122         }
 123 }
 124
 125 int psensor_list_size(struct psensor **sensors)
 126 {
 127         int size;
 128         struct psensor **sensor_cur;
 129
 130         if (!sensors)
 131                 return 0;
 132
 133         size = 0;
 134         sensor_cur = sensors;
 135
 136         while (*sensor_cur) {
 137                 size++;
 138                 sensor_cur++;
 139         }
 140         return size;
 141 }
 142
 143 int psensor_list_contains_type(struct psensor **sensors, unsigned int type)
 144 {
 145         struct psensor **s;
 146
 147         if (!sensors)
 148                 return 0;
 149
 150         s = sensors;
 151         while (*s) {
 152                 if ((*s)->type == type)
 153                         return 1;
 154                 s++;
 155         }
 156
 157         return 0;
 158 }
 159
 160 struct psensor **psensor_list_add(struct psensor **sensors,
 161                                   struct psensor *sensor)
 162 {
 163         int size = psensor_list_size(sensors);
 164
 165         struct psensor **result
 166             = malloc((size + 1 + 1) * sizeof(struct psensor *));
 167
 168         if (sensors)
 169                 memcpy(result, sensors, size * sizeof(struct psensor *));
 170
 171         result[size] = sensor;
 172         result[size + 1] = NULL;
 173
 174         return result;
 175 }
 176
 177 struct psensor *psensor_list_get_by_id(struct psensor **sensors, const char *id)
 178 {
 179         struct psensor **sensors_cur = sensors;
 180
 181         while (*sensors_cur) {
 182                 if (!strcmp((*sensors_cur)->id, id))
 183                         return *sensors_cur;
 184
 185                 sensors_cur++;
 186         }
 187
 188         return NULL;
 189 }
 190
 191 int is_temp_type(unsigned int type)
 192 {
 193         return type & SENSOR_TYPE_TEMP;
 194 }
 195
 196 int is_fan_type(unsigned int type)
 197 {
 198         return type & SENSOR_TYPE_FAN;
 199 }
 200
 201 char *psensor_value_to_string(unsigned int type, double value)
 202 {
 203         /* should not be possible to exceed 20 characters with temp or
 204            rpm values the .x part is never displayed */
 205         char *str = malloc(20);
 206
 207         char *unit;
 208
 209         if (is_temp_type(type))
 210                 unit = "C";
 211         else if (type & SENSOR_TYPE_CPU_USAGE)
 212                 unit = "%";
 213         else
 214                 unit = "";
 215
 216         sprintf(str, "%.0f%s", value, unit);
 217
 218         return str;
 219 }
 220
 221 void psensor_set_current_value(struct psensor *sensor, double value)
 222 {
 223         struct timeval tv;
 224
 225         if (gettimeofday(&tv, NULL) != 0)
 226                 timerclear(&tv);
 227
 228         psensor_set_current_measure(sensor, value, tv);
 229 }
 230
 231 void
 232 psensor_set_current_measure(struct psensor *s,
 233                             double v, struct timeval tv)
 234 {
 235         memmove(s->measures,
 236                 &s->measures[1],
 237                 (s->values_max_length - 1) * sizeof(struct measure));
 238
 239         s->measures[s->values_max_length - 1].value.d_num = v;
 240         s->measures[s->values_max_length - 1].time = tv;
 241
 242         if (s->min == UNKNOWN_DBL_VALUE || v < s->min)
 243                 s->min = v;
 244
 245         if (s->max == UNKNOWN_DBL_VALUE || v > s->max)
 246                 s->max = v;
 247
 248         if (s->alarm_limit && s->alarm_enabled) {
 249                 if (v > s->alarm_limit) {
 250                         if (!s->alarm_raised && s->cb_alarm_raised)
 251                                 s->cb_alarm_raised(s,
 252                                                    s->cb_alarm_raised_data);
 253
 254                         s->alarm_raised = 1;
 255                 } else {
 256                         s->alarm_raised = 0;
 257                 }
 258         }
 259 }
 260
 261 double psensor_get_current_value(struct psensor *sensor)
 262 {
 263         return sensor->measures[sensor->values_max_length - 1].value.d_num;
 264 }
 265
 266 struct measure *psensor_get_current_measure(struct psensor *sensor)
 267 {
 268         return &sensor->measures[sensor->values_max_length - 1];
 269 }
 270
 271 /*
 272   Returns the minimal value of a given 'type' (SENSOR_TYPE_TEMP or
 273   SENSOR_TYPE_FAN)
 274  */
 275 double get_min_value(struct psensor **sensors, int type)
 276 {
 277         double m = UNKNOWN_DBL_VALUE;
 278         struct psensor **s = sensors;
 279
 280         while (*s) {
 281                 struct psensor *sensor = *s;
 282
 283                 if (sensor->enabled && (sensor->type & type)) {
 284                         int i;
 285                         double t;
 286
 287                         for (i = 0; i < sensor->values_max_length; i++) {
 288                                 t = sensor->measures[i].value.d_num;
 289
 290                                 if (t == UNKNOWN_DBL_VALUE)
 291                                         continue;
 292
 293                                 if (m == UNKNOWN_DBL_VALUE || t < m)
 294                                         m = t;
 295                         }
 296                 }
 297                 s++;
 298         }
 299
 300         return m;
 301 }
 302
 303 /*
 304   Returns the maximal value of a given 'type' (SENSOR_TYPE_TEMP or
 305   SENSOR_TYPE_FAN)
 306  */
 307 double get_max_value(struct psensor **sensors, int type)
 308 {
 309         double m = UNKNOWN_DBL_VALUE;
 310         struct psensor **s = sensors;
 311
 312         while (*s) {
 313                 struct psensor *sensor = *s;
 314
 315                 if (sensor->enabled && (sensor->type & type)) {
 316                         int i;
 317                         double t;
 318                         for (i = 0; i < sensor->values_max_length; i++) {
 319                                 t = sensor->measures[i].value.d_num;
 320
 321                                 if (t == UNKNOWN_DBL_VALUE)
 322                                         continue;
 323
 324                                 if (m == UNKNOWN_DBL_VALUE || t > m)
 325                                         m = t;
 326                         }
 327                 }
 328                 s++;
 329         }
 330
 331         return m;
 332 }
 333
 334 double
 335 psensor_get_max_current_value(struct psensor **sensors, unsigned int type)
 336 {
 337         double m = UNKNOWN_DBL_VALUE;
 338         struct psensor **s_cur = sensors;
 339
 340         while (*s_cur) {
 341                 struct psensor *s = *s_cur;
 342
 343                 if (s->enabled && (s->type & type)) {
 344                         double v = psensor_get_current_value(s);
 345
 346                         if (m == UNKNOWN_DBL_VALUE || v > m)
 347                                 m = v;
 348                 }
 349
 350                 s_cur++;
 351         }
 352
 353         return m;
 354 }
 355
 356 double get_min_temp(struct psensor **sensors)
 357 {
 358         return get_min_value(sensors, SENSOR_TYPE_TEMP);
 359 }
 360
 361 double get_min_rpm(struct psensor **sensors)
 362 {
 363         return get_min_value(sensors, SENSOR_TYPE_FAN);
 364 }
 365
 366 double get_max_rpm(struct psensor **sensors)
 367 {
 368         return get_max_value(sensors, SENSOR_TYPE_FAN);
 369 }
 370
 371 double get_max_temp(struct psensor **sensors)
 372 {
 373         return get_max_value(sensors, SENSOR_TYPE_TEMP);
 374 }
 375
 376 struct psensor **get_all_sensors(int use_libatasmart, int values_max_length)
 377 {
 378         struct psensor **psensors = NULL;
 379         struct psensor **tmp_psensors;
 380
 381         psensors = lmsensor_psensor_list_add(NULL, values_max_length);
 382
 383         if (!use_libatasmart) {
 384                 tmp_psensors = hddtemp_psensor_list_add(psensors,
 385                                                         values_max_length);
 386                 if (tmp_psensors != psensors) {
 387                         free(psensors);
 388                         psensors = tmp_psensors;
 389                 }
 390         }
 391 #ifdef HAVE_ATASMART
 392                 else {
 393                         tmp_psensors = hdd_psensor_list_add(psensors,
 394                                                             values_max_length);
 395                         if (tmp_psensors != psensors) {
 396                                 free(psensors);
 397                                 psensors = tmp_psensors;
 398                         }
 399                 }
 400 #endif
 401
 402         if (!psensors) {        /* there is no detected sensors */
 403                 psensors = malloc(sizeof(struct psensor *));
 404                 *psensors = NULL;
 405         }
 406
 407         return psensors;
 408 }
 409
 410 const char *psensor_type_to_str(unsigned int type)
 411 {
 412         if ((type & SENSOR_TYPE_NVIDIA_TEMP) == SENSOR_TYPE_NVIDIA_TEMP)
 413                 return "NVidia GPU Temperature";
 414
 415         if ((type & SENSOR_TYPE_AMD_TEMP) == SENSOR_TYPE_AMD_TEMP)
 416                 return "AMD GPU Temperature";
 417
 418         if ((type & SENSOR_TYPE_AMD_FAN) == SENSOR_TYPE_AMD_FAN)
 419                 return "AMD GPU Fan Speed";
 420
 421         if ((type & SENSOR_TYPE_HDD_TEMP) == SENSOR_TYPE_HDD_TEMP)
 422                 return "HDD Temperature";
 423
 424         if (type & SENSOR_TYPE_CPU_USAGE)
 425                 return "CPU Usage";
 426
 427         if (type & SENSOR_TYPE_TEMP)
 428                 return "Temperature";
 429
 430         if (type & SENSOR_TYPE_FAN)
 431                 return "Fan";
 432
 433         if (type & SENSOR_TYPE_REMOTE)
 434                 return "Remote";
 435
 436         return "N/A";           /* should not be possible */
 437 }
 438
 439
 440 const char *psensor_type_to_unit_str(unsigned int type)
 441 {
 442         if (type & SENSOR_TYPE_TEMP)
 443                 return _("C");
 444
 445         if (type & SENSOR_TYPE_FAN)
 446                 return _("RPM");
 447
 448         if (type & SENSOR_TYPE_CPU_USAGE)
 449                 return _("%");
 450
 451         return "N/A";
 452 }
 453
 454 void psensor_list_update_measures(struct psensor **sensors)
 455 {
 456         lmsensor_psensor_list_update(sensors);
 457
 458 #ifdef HAVE_GTOP
 459         cpu_psensor_list_update(sensors);
 460 #endif
 461
 462         if (psensor_list_contains_type(sensors, SENSOR_TYPE_HDD_TEMP_HDDTEMP))
 463                 hddtemp_psensor_list_update(sensors);
 464
 465 #ifdef HAVE_ATASMART
 466         if (psensor_list_contains_type(sensors,
 467                                        SENSOR_TYPE_HDD_TEMP_ATASMART))
 468                 hdd_psensor_list_update(sensors);
 469 #endif
 470 }
 471
 472 void psensor_init()
 473 {
 474         lmsensor_init();
 475 }
 476
 477 void psensor_cleanup()
 478 {
 479         lmsensor_cleanup();
 480 }