src/hddtemp.c

   1 /**
   2  * collectd - src/hddtemp.c
   3  * Copyright (C) 2005,2006  Vincent Stehlé
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Vincent Stehlé <vincent.stehle at free.fr>
  21  *   Florian octo Forster <octo at verplant.org>
  22  *
  23  * TODO:
  24  *   Do a pass, some day, and spare some memory. We consume too much for now
  25  *   in string buffers and the like.
  26  *
  27  **/
  28
  29 #include "collectd.h"
  30 #include "common.h"
  31 #include "plugin.h"
  32 #include "configfile.h"
  33 #include "utils_debug.h"
  34
  35 #define MODULE_NAME "hddtemp"
  36
  37 #include <netdb.h>
  38 #include <sys/socket.h>
  39 #include <netinet/in.h>
  40 #include <netinet/tcp.h>
  41 #include <libgen.h> /* for basename */
  42
  43 #if HAVE_LINUX_MAJOR_H
  44 # include <linux/major.h>
  45 #endif
  46
  47 #define HDDTEMP_DEF_HOST "127.0.0.1"
  48 #define HDDTEMP_DEF_PORT "7634"
  49
  50 /* BUFFER_SIZE
  51    Size of the buffer we use to receive from the hddtemp daemon. */
  52 #define BUFFER_SIZE 1024
  53
  54 static char *filename_format = "hddtemp-%s.rrd";
  55
  56 static char *ds_def[] =
  57 {
  58         "DS:value:GAUGE:"COLLECTD_HEARTBEAT":U:U",
  59         NULL
  60 };
  61 static int ds_num = 1;
  62
  63 static char *config_keys[] =
  64 {
  65         "Host",
  66         "Port",
  67         NULL
  68 };
  69 static int config_keys_num = 2;
  70
  71 typedef struct hddname
  72 {
  73         int major;
  74         int minor;
  75         char *name;
  76         struct hddname *next;
  77 } hddname_t;
  78
  79 static hddname_t *first_hddname = NULL;
  80 static char *hddtemp_host = NULL;
  81 static char *hddtemp_port = NULL;
  82
  83 /*
  84  * NAME
  85  *  hddtemp_query_daemon
  86  *
  87  * DESCRIPTION
  88  * Connect to the hddtemp daemon and receive data.
  89  *
  90  * ARGUMENTS:
  91  *  `buffer'            The buffer where we put the received ascii string.
  92  *  `buffer_size'       Size of the buffer
  93  *
  94  * RETURN VALUE:
  95  *   >= 0 if ok, < 0 otherwise.
  96  *
  97  * NOTES:
  98  *  Example of possible strings, as received from daemon:
  99  *    |/dev/hda|ST340014A|36|C|
 100  *    |/dev/hda|ST380011A|46|C||/dev/hdd|ST340016A|SLP|*|
 101  *
 102  * FIXME:
 103  *  we need to create a new socket each time. Is there another way?
 104  *  Hm, maybe we can re-use the `sockaddr' structure? -octo
 105  */
 106 static int hddtemp_query_daemon (char *buffer, int buffer_size)
 107 {
 108         int fd;
 109         ssize_t status;
 110         int buffer_fill;
 111
 112         const char *host;
 113         const char *port;
 114
 115         struct addrinfo  ai_hints;
 116         struct addrinfo *ai_list, *ai_ptr;
 117         int              ai_return;
 118
 119         memset (&ai_hints, '\0', sizeof (ai_hints));
 120         ai_hints.ai_flags    = AI_ADDRCONFIG;
 121         ai_hints.ai_family   = PF_UNSPEC;
 122         ai_hints.ai_socktype = SOCK_STREAM;
 123         ai_hints.ai_protocol = IPPROTO_TCP;
 124
 125         host = hddtemp_host;
 126         if (host == NULL)
 127                 host = HDDTEMP_DEF_HOST;
 128
 129         port = hddtemp_port;
 130         if (port == NULL)
 131                 port = HDDTEMP_DEF_PORT;
 132
 133         if ((ai_return = getaddrinfo (host, port, &ai_hints, &ai_list)) != 0)
 134         {
 135                 syslog (LOG_ERR, "hddtemp: getaddrinfo (%s, %s): %s",
 136                                 host, port,
 137                                 ai_return == EAI_SYSTEM ? strerror (errno) : gai_strerror (ai_return));
 138                 return (-1);
 139         }
 140
 141         fd = -1;
 142         for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
 143         {
 144                 /* create our socket descriptor */
 145                 if ((fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol)) < 0)
 146                 {
 147                         syslog (LOG_ERR, "hddtemp: socket: %s",
 148                                         strerror (errno));
 149                         continue;
 150                 }
 151
 152                 /* connect to the hddtemp daemon */
 153                 if (connect (fd, (struct sockaddr *) ai_ptr->ai_addr, ai_ptr->ai_addrlen))
 154                 {
 155                         DBG ("hddtemp: connect (%s, %s): %s", host, port,
 156                                         strerror (errno));
 157                         close (fd);
 158                         fd = -1;
 159                         continue;
 160                 }
 161
 162                 /* A socket could be opened and connecting succeeded. We're
 163                  * done. */
 164                 break;
 165         }
 166
 167         freeaddrinfo (ai_list);
 168
 169         if (fd < 0)
 170         {
 171                 syslog (LOG_ERR, "hddtemp: Could not connect to daemon.");
 172                 return (-1);
 173         }
 174
 175         /* receive data from the hddtemp daemon */
 176         memset (buffer, '\0', buffer_size);
 177
 178         buffer_fill = 0;
 179         while ((status = read (fd, buffer + buffer_fill, buffer_size - buffer_fill)) != 0)
 180         {
 181                 if (status == -1)
 182                 {
 183                         if ((errno == EAGAIN) || (errno == EINTR))
 184                                 continue;
 185
 186                         syslog (LOG_ERR, "hddtemp: Error reading from socket: %s",
 187                                                 strerror (errno));
 188                         close (fd);
 189                         return (-1);
 190                 }
 191                 buffer_fill += status;
 192
 193                 if (buffer_fill >= buffer_size)
 194                         break;
 195         }
 196
 197         if (buffer_fill >= buffer_size)
 198         {
 199                 buffer[buffer_size - 1] = '\0';
 200                 syslog (LOG_WARNING, "hddtemp: Message from hddtemp has been truncated.");
 201         }
 202         else if (buffer_fill == 0)
 203         {
 204                 syslog (LOG_WARNING, "hddtemp: Peer has unexpectedly shut down the socket. "
 205                                 "Buffer: `%s'", buffer);
 206                 close (fd);
 207                 return (-1);
 208         }
 209
 210         close (fd);
 211         return (0);
 212 }
 213
 214 static int hddtemp_config (char *key, char *value)
 215 {
 216         if (strcasecmp (key, "host") == 0)
 217         {
 218                 if (hddtemp_host != NULL)
 219                         free (hddtemp_host);
 220                 hddtemp_host = strdup (value);
 221         }
 222         else if (strcasecmp (key, "port") == 0)
 223         {
 224                 if (hddtemp_port != NULL)
 225                         free (hddtemp_port);
 226                 hddtemp_port = strdup (value);
 227         }
 228         else
 229         {
 230                 return (-1);
 231         }
 232
 233         return (0);
 234 }
 235
 236 /* In the init-function we initialize the `hddname_t' list used to translate
 237  * disk-names. Under Linux that's done using `/proc/partitions'. Under other
 238  * operating-systems, it's not done at all. */
 239 static void hddtemp_init (void)
 240 {
 241 #if KERNEL_LINUX
 242         FILE *fh;
 243         char buf[BUFFER_SIZE];
 244         int buflen;
 245
 246         char *fields[16];
 247         int num_fields;
 248
 249         int major;
 250         int minor;
 251         char *name;
 252         hddname_t *next;
 253         hddname_t *entry;
 254
 255         next = first_hddname;
 256         while (next != NULL)
 257         {
 258                 entry = next;
 259                 next = entry->next;
 260
 261                 free (entry->name);
 262                 free (entry);
 263         }
 264         first_hddname = NULL;
 265
 266         if ((fh = fopen ("/proc/partitions", "r")) != NULL)
 267         {
 268                 DBG ("Looking at /proc/partitions...");
 269
 270                 while (fgets (buf, BUFFER_SIZE, fh) != NULL)
 271                 {
 272                         /* Delete trailing newlines */
 273                         buflen = strlen (buf);
 274
 275                         while ((buflen > 0) && ((buf[buflen-1] == '\n') || (buf[buflen-1] == '\r')))
 276                                 buf[--buflen] = '\0';
 277
 278                         /* We want lines of the form:
 279                          *
 280                          *     3     1   77842926 hda1
 281                          *
 282                          * ...so, skip everything else. */
 283                         if (buflen == 0)
 284                                 continue;
 285
 286                         num_fields = strsplit (buf, fields, 16);
 287
 288                         if (num_fields != 4)
 289                                 continue;
 290
 291                         major = atoi (fields[0]);
 292                         minor = atoi (fields[1]);
 293
 294                         /* We try to keep only entries, which may correspond to
 295                          * physical disks and that may have a corresponding
 296                          * entry in the hddtemp daemon. Basically, this means
 297                          * IDE and SCSI. */
 298                         switch (major)
 299                         {
 300                                 /* SCSI. */
 301                                 case SCSI_DISK0_MAJOR:
 302                                 case SCSI_DISK1_MAJOR:
 303                                 case SCSI_DISK2_MAJOR:
 304                                 case SCSI_DISK3_MAJOR:
 305                                 case SCSI_DISK4_MAJOR:
 306                                 case SCSI_DISK5_MAJOR:
 307                                 case SCSI_DISK6_MAJOR:
 308                                 case SCSI_DISK7_MAJOR:
 309                                 case SCSI_DISK8_MAJOR:
 310                                 case SCSI_DISK9_MAJOR:
 311                                 case SCSI_DISK10_MAJOR:
 312                                 case SCSI_DISK11_MAJOR:
 313                                 case SCSI_DISK12_MAJOR:
 314                                 case SCSI_DISK13_MAJOR:
 315                                 case SCSI_DISK14_MAJOR:
 316                                 case SCSI_DISK15_MAJOR:
 317                                         /* SCSI disks minors are multiples of 16.
 318                                          * Keep only those. */
 319                                         if (minor % 16)
 320                                                 continue;
 321                                         break;
 322
 323                                 /* IDE. */
 324                                 case IDE0_MAJOR:
 325                                 case IDE1_MAJOR:
 326                                 case IDE2_MAJOR:
 327                                 case IDE3_MAJOR:
 328                                 case IDE4_MAJOR:
 329                                 case IDE5_MAJOR:
 330                                 case IDE6_MAJOR:
 331                                 case IDE7_MAJOR:
 332                                 case IDE8_MAJOR:
 333                                 case IDE9_MAJOR:
 334                                         /* IDE disks minors can only be 0 or 64.
 335                                          * Keep only those. */
 336                                         if(minor != 0 && minor != 64)
 337                                                 continue;
 338                                         break;
 339
 340                                 /* Skip all other majors. */
 341                                 default:
 342                                         DBG ("Skipping unknown major %i", major);
 343                                         continue;
 344                         } /* switch (major) */
 345
 346                         if ((name = strdup (fields[3])) == NULL)
 347                         {
 348                                 syslog (LOG_ERR, "hddtemp: strdup(%s) == NULL", fields[3]);
 349                                 continue;
 350                         }
 351
 352                         if ((entry = (hddname_t *) malloc (sizeof (hddname_t))) == NULL)
 353                         {
 354                                 syslog (LOG_ERR, "hddtemp: malloc (%u) == NULL",
 355                                                 (unsigned int) sizeof (hddname_t));
 356                                 free (name);
 357                                 continue;
 358                         }
 359
 360                         DBG ("Found disk: %s (%u:%u).", name, major, minor);
 361
 362                         entry->major = major;
 363                         entry->minor = minor;
 364                         entry->name  = name;
 365                         entry->next  = NULL;
 366
 367                         if (first_hddname == NULL)
 368                         {
 369                                 first_hddname = entry;
 370                         }
 371                         else
 372                         {
 373                                 entry->next = first_hddname;
 374                                 first_hddname = entry;
 375                         }
 376                 }
 377                 fclose (fh);
 378         }
 379         else
 380                 DBG ("Could not open /proc/partitions: %s",
 381                                 strerror (errno));
 382 #endif /* KERNEL_LINUX */
 383 }
 384
 385 static void hddtemp_write (char *host, char *inst, char *val)
 386 {
 387         char filename[BUFFER_SIZE];
 388         int status;
 389
 390         /* construct filename */
 391         status = snprintf (filename, BUFFER_SIZE, filename_format, inst);
 392         if (status < 1)
 393                 return;
 394         else if (status >= BUFFER_SIZE)
 395                 return;
 396
 397         rrd_update_file (host, filename, val, ds_def, ds_num);
 398 }
 399
 400 /*
 401  * hddtemp_get_name
 402  *
 403  * Description:
 404  *   Try to "cook" a bit the drive name as returned
 405  *   by the hddtemp daemon. The intend is to transform disk
 406  *   names into <major>-<minor> when possible.
 407  */
 408 static char *hddtemp_get_name (char *drive)
 409 {
 410         hddname_t *list;
 411         char *ret;
 412
 413         for (list = first_hddname; list != NULL; list = list->next)
 414                 if (strcmp (drive, list->name) == 0)
 415                         break;
 416
 417         if (list == NULL)
 418         {
 419                 DBG ("Don't know %s, keeping name as-is.", drive);
 420                 return (strdup (drive));
 421         }
 422
 423         if ((ret = (char *) malloc (128 * sizeof (char))) == NULL)
 424                 return (NULL);
 425
 426         if (snprintf (ret, 128, "%i-%i", list->major, list->minor) >= 128)
 427         {
 428                 free (ret);
 429                 return (NULL);
 430         }
 431
 432         return (ret);
 433 }
 434
 435 static void hddtemp_submit (char *inst, double temperature)
 436 {
 437         char buf[BUFFER_SIZE];
 438
 439         if (snprintf (buf, BUFFER_SIZE, "%u:%.3f", (unsigned int) curtime, temperature)
 440             >= BUFFER_SIZE)
 441                 return;
 442
 443         plugin_submit (MODULE_NAME, inst, buf);
 444 }
 445
 446 static void hddtemp_read (void)
 447 {
 448         char buf[BUFFER_SIZE];
 449         char *fields[128];
 450         char *ptr;
 451         int num_fields;
 452         int num_disks;
 453         int i;
 454
 455         static int wait_time = 1;
 456         static int wait_left = 0;
 457
 458         if (wait_left >= 10)
 459         {
 460                 wait_left -= 10;
 461                 return;
 462         }
 463
 464         /* get data from daemon */
 465         if (hddtemp_query_daemon (buf, BUFFER_SIZE) < 0)
 466         {
 467                 /* This limit is reached in log2(86400) =~ 17 steps. Since
 468                  * there is a 2^n seconds wait between each step it will need
 469                  * roughly one day to reach this limit. -octo */
 470
 471                 wait_time *= 2;
 472                 if (wait_time > 86400)
 473                         wait_time = 86400;
 474
 475                 wait_left = wait_time;
 476
 477                 return;
 478         }
 479         else
 480         {
 481                 wait_time = 1;
 482                 wait_left = 0;
 483         }
 484
 485         /* NB: strtok will eat up "||" and leading "|"'s */
 486         num_fields = 0;
 487         ptr = buf;
 488         while ((fields[num_fields] = strtok (ptr, "|")) != NULL)
 489         {
 490                 ptr = NULL;
 491                 num_fields++;
 492
 493                 if (num_fields >= 128)
 494                         break;
 495         }
 496
 497         num_disks = num_fields / 4;
 498
 499         for (i = 0; i < num_disks; i++)
 500         {
 501                 char *name, *submit_name;
 502                 double temperature;
 503                 char *mode;
 504
 505                 mode = fields[4*i + 3];
 506                 name = basename (fields[4*i + 0]);
 507
 508                 /* Skip non-temperature information */
 509                 if (mode[0] != 'C' && mode[0] != 'F')
 510                         continue;
 511
 512                 temperature = atof (fields[4*i + 2]);
 513
 514                 /* Convert farenheit to celsius */
 515                 if (mode[0] == 'F')
 516                         temperature = (temperature - 32.0) * 5.0 / 9.0;
 517
 518                 if ((submit_name = hddtemp_get_name (name)) != NULL)
 519                 {
 520                         hddtemp_submit (submit_name, temperature);
 521                         free (submit_name);
 522                 }
 523                 else
 524                 {
 525                         hddtemp_submit (name, temperature);
 526                 }
 527         }
 528 }
 529
 530 /* module_register
 531    Register collectd plugin. */
 532 void module_register (void)
 533 {
 534         plugin_register (MODULE_NAME, hddtemp_init, hddtemp_read, hddtemp_write);
 535         cf_register (MODULE_NAME, hddtemp_config, config_keys, config_keys_num);
 536 }
 537
 538 #undef MODULE_NAME