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