src/ipmi.c

   1 /**
   2  * collectd - src/ipmi.c
   3  * Copyright (C) 2008-2009  Florian octo Forster
   4  * Copyright (C) 2008       Peter Holik
   5  * Copyright (C) 2009       Bruno Prémont
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; only version 2 of the License is applicable.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  *
  20  * Authors:
  21  *   Florian octo Forster <octo at collectd.org>
  22  *   Peter Holik <peter at holik.at>
  23  *   Bruno Prémont <bonbons at linux-vserver.org>
  24  **/
  25
  26 #include "collectd.h"
  27 #include "common.h"
  28 #include "plugin.h"
  29 #include "utils_ignorelist.h"
  30
  31 #include <OpenIPMI/ipmiif.h>
  32 #include <OpenIPMI/ipmi_err.h>
  33 #include <OpenIPMI/ipmi_posix.h>
  34 #include <OpenIPMI/ipmi_conn.h>
  35 #include <OpenIPMI/ipmi_smi.h>
  36
  37 /*
  38  * Private data types
  39  */
  40 struct c_ipmi_sensor_list_s;
  41 typedef struct c_ipmi_sensor_list_s c_ipmi_sensor_list_t;
  42
  43 struct c_ipmi_sensor_list_s
  44 {
  45   ipmi_sensor_id_t sensor_id;
  46   char sensor_name[DATA_MAX_NAME_LEN];
  47   char sensor_type[DATA_MAX_NAME_LEN];
  48   int sensor_not_present;
  49   c_ipmi_sensor_list_t *next;
  50 };
  51
  52 /*
  53  * Module global variables
  54  */
  55 static pthread_mutex_t sensor_list_lock = PTHREAD_MUTEX_INITIALIZER;
  56 static c_ipmi_sensor_list_t *sensor_list = NULL;
  57
  58 static int c_ipmi_init_in_progress = 0;
  59 static int c_ipmi_active = 0;
  60 static pthread_t thread_id = (pthread_t) 0;
  61
  62 static const char *config_keys[] =
  63 {
  64         "Sensor",
  65         "IgnoreSelected",
  66         "NotifySensorAdd",
  67         "NotifySensorRemove",
  68         "NotifySensorNotPresent"
  69 };
  70 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  71
  72 static ignorelist_t *ignorelist = NULL;
  73
  74 static int c_ipmi_nofiy_add = 0;
  75 static int c_ipmi_nofiy_remove = 0;
  76 static int c_ipmi_nofiy_notpresent = 0;
  77
  78 /*
  79  * Misc private functions
  80  */
  81 static void c_ipmi_error (const char *func, int status)
  82 {
  83   char errbuf[4096] = { 0 };
  84
  85   if (IPMI_IS_OS_ERR (status))
  86   {
  87     sstrerror (IPMI_GET_OS_ERR (status), errbuf, sizeof (errbuf));
  88   }
  89   else if (IPMI_IS_IPMI_ERR (status))
  90   {
  91     ipmi_get_error_string (IPMI_GET_IPMI_ERR (status), errbuf, sizeof (errbuf));
  92   }
  93
  94   if (errbuf[0] == 0)
  95   {
  96     ssnprintf (errbuf, sizeof (errbuf), "Unknown error %#x", status);
  97   }
  98   errbuf[sizeof (errbuf) - 1] = 0;
  99
 100   ERROR ("ipmi plugin: %s failed: %s", func, errbuf);
 101 } /* void c_ipmi_error */
 102
 103 /*
 104  * Sensor handlers
 105  */
 106 /* Prototype for sensor_list_remove, so sensor_read_handler can call it. */
 107 static int sensor_list_remove (ipmi_sensor_t *sensor);
 108
 109 static void sensor_read_handler (ipmi_sensor_t *sensor,
 110     int err,
 111     enum ipmi_value_present_e value_present,
 112     unsigned int __attribute__((unused)) raw_value,
 113     double value,
 114     ipmi_states_t __attribute__((unused)) *states,
 115     void *user_data)
 116 {
 117   value_t values[1];
 118   value_list_t vl = VALUE_LIST_INIT;
 119
 120   c_ipmi_sensor_list_t *list_item = (c_ipmi_sensor_list_t *)user_data;
 121
 122   if (err != 0)
 123   {
 124     if ((err & 0xff) == IPMI_NOT_PRESENT_CC)
 125     {
 126       if (list_item->sensor_not_present == 0)
 127       {
 128         list_item->sensor_not_present = 1;
 129
 130         INFO ("ipmi plugin: sensor_read_handler: sensor %s "
 131             "not present.", list_item->sensor_name);
 132
 133         if (c_ipmi_nofiy_notpresent)
 134         {
 135           notification_t n = { NOTIF_WARNING, cdtime (), "", "", "ipmi",
 136             "", "", "", NULL };
 137
 138           sstrncpy (n.host, hostname_g, sizeof (n.host));
 139           sstrncpy (n.type_instance, list_item->sensor_name,
 140               sizeof (n.type_instance));
 141           sstrncpy (n.type, list_item->sensor_type, sizeof (n.type));
 142           ssnprintf (n.message, sizeof (n.message),
 143               "sensor %s not present", list_item->sensor_name);
 144
 145           plugin_dispatch_notification (&n);
 146         }
 147       }
 148     }
 149     else if (IPMI_IS_IPMI_ERR(err) && IPMI_GET_IPMI_ERR(err) == IPMI_NOT_SUPPORTED_IN_PRESENT_STATE_CC)
 150     {
 151       INFO ("ipmi plugin: sensor_read_handler: Sensor %s not ready",
 152           list_item->sensor_name);
 153     }
 154     else
 155     {
 156       if (IPMI_IS_IPMI_ERR(err))
 157         INFO ("ipmi plugin: sensor_read_handler: Removing sensor %s, "
 158             "because it failed with IPMI error %#x.",
 159             list_item->sensor_name, IPMI_GET_IPMI_ERR(err));
 160       else if (IPMI_IS_OS_ERR(err))
 161         INFO ("ipmi plugin: sensor_read_handler: Removing sensor %s, "
 162             "because it failed with OS error %#x.",
 163             list_item->sensor_name, IPMI_GET_OS_ERR(err));
 164       else if (IPMI_IS_RMCPP_ERR(err))
 165         INFO ("ipmi plugin: sensor_read_handler: Removing sensor %s, "
 166             "because it failed with RMCPP error %#x.",
 167             list_item->sensor_name, IPMI_GET_RMCPP_ERR(err));
 168       else if (IPMI_IS_SOL_ERR(err))
 169         INFO ("ipmi plugin: sensor_read_handler: Removing sensor %s, "
 170             "because it failed with RMCPP error %#x.",
 171             list_item->sensor_name, IPMI_GET_SOL_ERR(err));
 172       else
 173         INFO ("ipmi plugin: sensor_read_handler: Removing sensor %s, "
 174             "because it failed with error %#x. of class %#x",
 175             list_item->sensor_name, err & 0xff, err & 0xffffff00);
 176       sensor_list_remove (sensor);
 177     }
 178     return;
 179   }
 180   else if (list_item->sensor_not_present == 1)
 181   {
 182     list_item->sensor_not_present = 0;
 183
 184     INFO ("ipmi plugin: sensor_read_handler: sensor %s present.",
 185         list_item->sensor_name);
 186
 187     if (c_ipmi_nofiy_notpresent)
 188     {
 189       notification_t n = { NOTIF_OKAY, cdtime (), "", "", "ipmi",
 190         "", "", "", NULL };
 191
 192       sstrncpy (n.host, hostname_g, sizeof (n.host));
 193       sstrncpy (n.type_instance, list_item->sensor_name,
 194           sizeof (n.type_instance));
 195       sstrncpy (n.type, list_item->sensor_type, sizeof (n.type));
 196       ssnprintf (n.message, sizeof (n.message),
 197           "sensor %s present", list_item->sensor_name);
 198
 199       plugin_dispatch_notification (&n);
 200     }
 201   }
 202
 203   if (value_present != IPMI_BOTH_VALUES_PRESENT)
 204   {
 205     INFO ("ipmi plugin: sensor_read_handler: Removing sensor %s, "
 206         "because it provides %s. If you need this sensor, "
 207         "please file a bug report.",
 208         list_item->sensor_name,
 209         (value_present == IPMI_RAW_VALUE_PRESENT)
 210         ? "only the raw value"
 211         : "no value");
 212     sensor_list_remove (sensor);
 213     return;
 214   }
 215
 216   values[0].gauge = value;
 217
 218   vl.values = values;
 219   vl.values_len = 1;
 220
 221   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 222   sstrncpy (vl.plugin, "ipmi", sizeof (vl.plugin));
 223   sstrncpy (vl.type, list_item->sensor_type, sizeof (vl.type));
 224   sstrncpy (vl.type_instance, list_item->sensor_name, sizeof (vl.type_instance));
 225
 226   plugin_dispatch_values (&vl);
 227 } /* void sensor_read_handler */
 228
 229 static int sensor_list_add (ipmi_sensor_t *sensor)
 230 {
 231   ipmi_sensor_id_t sensor_id;
 232   c_ipmi_sensor_list_t *list_item;
 233   c_ipmi_sensor_list_t *list_prev;
 234
 235   char buffer[DATA_MAX_NAME_LEN] = { 0 };
 236   const char *entity_id_string;
 237   char sensor_name[DATA_MAX_NAME_LEN];
 238   char *sensor_name_ptr;
 239   int sensor_type;
 240   const char *type;
 241   ipmi_entity_t *ent = ipmi_sensor_get_entity(sensor);
 242
 243   sensor_id = ipmi_sensor_convert_to_id (sensor);
 244
 245   ipmi_sensor_get_name (sensor, buffer, sizeof (buffer));
 246   buffer[sizeof (buffer) - 1] = 0;
 247
 248   entity_id_string = ipmi_entity_get_entity_id_string (ent);
 249
 250   if (entity_id_string == NULL)
 251     sstrncpy (sensor_name, buffer, sizeof (sensor_name));
 252   else
 253     ssnprintf (sensor_name, sizeof (sensor_name),
 254         "%s %s", buffer, entity_id_string);
 255
 256   sstrncpy (buffer, sensor_name, sizeof (buffer));
 257   sensor_name_ptr = strstr (buffer, ").");
 258   if (sensor_name_ptr != NULL)
 259   {
 260     /* If name is something like "foo (123).bar",
 261      * change that to "bar (123)".
 262      * Both, sensor_name_ptr and sensor_id_ptr point to memory within the
 263      * `buffer' array, which holds a copy of the current `sensor_name'. */
 264     char *sensor_id_ptr;
 265
 266     /* `sensor_name_ptr' points to ").bar". */
 267     sensor_name_ptr[1] = 0;
 268     /* `buffer' holds "foo (123)\0bar\0". */
 269     sensor_name_ptr += 2;
 270     /* `sensor_name_ptr' now points to "bar". */
 271
 272     sensor_id_ptr = strstr (buffer, "(");
 273     if (sensor_id_ptr != NULL)
 274     {
 275       /* `sensor_id_ptr' now points to "(123)". */
 276       ssnprintf (sensor_name, sizeof (sensor_name),
 277           "%s %s", sensor_name_ptr, sensor_id_ptr);
 278     }
 279     /* else: don't touch sensor_name. */
 280   }
 281   sensor_name_ptr = sensor_name;
 282
 283   /* Both `ignorelist' and `plugin_instance' may be NULL. */
 284   if (ignorelist_match (ignorelist, sensor_name_ptr) != 0)
 285     return (0);
 286
 287   /* FIXME: Use rate unit or base unit to scale the value */
 288
 289   sensor_type = ipmi_sensor_get_sensor_type (sensor);
 290   switch (sensor_type)
 291   {
 292     case IPMI_SENSOR_TYPE_TEMPERATURE:
 293       type = "temperature";
 294       break;
 295
 296     case IPMI_SENSOR_TYPE_VOLTAGE:
 297       type = "voltage";
 298       break;
 299
 300     case IPMI_SENSOR_TYPE_CURRENT:
 301       type = "current";
 302       break;
 303
 304     case IPMI_SENSOR_TYPE_FAN:
 305       type = "fanspeed";
 306       break;
 307
 308     default:
 309       {
 310         const char *sensor_type_str;
 311
 312         sensor_type_str = ipmi_sensor_get_sensor_type_string (sensor);
 313         INFO ("ipmi plugin: sensor_list_add: Ignore sensor %s, "
 314             "because I don't know how to handle its type (%#x, %s). "
 315             "If you need this sensor, please file a bug report.",
 316             sensor_name_ptr, sensor_type, sensor_type_str);
 317         return (-1);
 318       }
 319   } /* switch (sensor_type) */
 320
 321   pthread_mutex_lock (&sensor_list_lock);
 322
 323   list_prev = NULL;
 324   for (list_item = sensor_list;
 325       list_item != NULL;
 326       list_item = list_item->next)
 327   {
 328     if (ipmi_cmp_sensor_id (sensor_id, list_item->sensor_id) == 0)
 329       break;
 330     list_prev = list_item;
 331   } /* for (list_item) */
 332
 333   if (list_item != NULL)
 334   {
 335     pthread_mutex_unlock (&sensor_list_lock);
 336     return (0);
 337   }
 338
 339   list_item = (c_ipmi_sensor_list_t *) calloc (1, sizeof (c_ipmi_sensor_list_t));
 340   if (list_item == NULL)
 341   {
 342     pthread_mutex_unlock (&sensor_list_lock);
 343     return (-1);
 344   }
 345
 346   list_item->sensor_id = ipmi_sensor_convert_to_id (sensor);
 347
 348   if (list_prev != NULL)
 349     list_prev->next = list_item;
 350   else
 351     sensor_list = list_item;
 352
 353   sstrncpy (list_item->sensor_name, sensor_name_ptr,
 354             sizeof (list_item->sensor_name));
 355   sstrncpy (list_item->sensor_type, type, sizeof (list_item->sensor_type));
 356
 357   pthread_mutex_unlock (&sensor_list_lock);
 358
 359   if (c_ipmi_nofiy_add && (c_ipmi_init_in_progress == 0))
 360   {
 361     notification_t n = { NOTIF_OKAY, cdtime (), "", "", "ipmi",
 362                          "", "", "", NULL };
 363
 364     sstrncpy (n.host, hostname_g, sizeof (n.host));
 365     sstrncpy (n.type_instance, list_item->sensor_name,
 366               sizeof (n.type_instance));
 367     sstrncpy (n.type, list_item->sensor_type, sizeof (n.type));
 368     ssnprintf (n.message, sizeof (n.message),
 369               "sensor %s added", list_item->sensor_name);
 370
 371     plugin_dispatch_notification (&n);
 372   }
 373
 374   return (0);
 375 } /* int sensor_list_add */
 376
 377 static int sensor_list_remove (ipmi_sensor_t *sensor)
 378 {
 379   ipmi_sensor_id_t sensor_id;
 380   c_ipmi_sensor_list_t *list_item;
 381   c_ipmi_sensor_list_t *list_prev;
 382
 383   sensor_id = ipmi_sensor_convert_to_id (sensor);
 384
 385   pthread_mutex_lock (&sensor_list_lock);
 386
 387   list_prev = NULL;
 388   for (list_item = sensor_list;
 389       list_item != NULL;
 390       list_item = list_item->next)
 391   {
 392     if (ipmi_cmp_sensor_id (sensor_id, list_item->sensor_id) == 0)
 393       break;
 394     list_prev = list_item;
 395   } /* for (list_item) */
 396
 397   if (list_item == NULL)
 398   {
 399     pthread_mutex_unlock (&sensor_list_lock);
 400     return (-1);
 401   }
 402
 403   if (list_prev == NULL)
 404     sensor_list = list_item->next;
 405   else
 406     list_prev->next = list_item->next;
 407
 408   list_prev = NULL;
 409   list_item->next = NULL;
 410
 411   pthread_mutex_unlock (&sensor_list_lock);
 412
 413   if (c_ipmi_nofiy_remove && c_ipmi_active)
 414   {
 415     notification_t n = { NOTIF_WARNING, cdtime (), "", "",
 416                          "ipmi", "", "", "", NULL };
 417
 418     sstrncpy (n.host, hostname_g, sizeof (n.host));
 419     sstrncpy (n.type_instance, list_item->sensor_name,
 420               sizeof (n.type_instance));
 421     sstrncpy (n.type, list_item->sensor_type, sizeof (n.type));
 422     ssnprintf (n.message, sizeof (n.message),
 423               "sensor %s removed", list_item->sensor_name);
 424
 425     plugin_dispatch_notification (&n);
 426   }
 427
 428   free (list_item);
 429   return (0);
 430 } /* int sensor_list_remove */
 431
 432 static int sensor_list_read_all (void)
 433 {
 434   c_ipmi_sensor_list_t *list_item;
 435
 436   pthread_mutex_lock (&sensor_list_lock);
 437
 438   for (list_item = sensor_list;
 439       list_item != NULL;
 440       list_item = list_item->next)
 441   {
 442     ipmi_sensor_id_get_reading (list_item->sensor_id,
 443         sensor_read_handler, /* user data = */ list_item);
 444   } /* for (list_item) */
 445
 446   pthread_mutex_unlock (&sensor_list_lock);
 447
 448   return (0);
 449 } /* int sensor_list_read_all */
 450
 451 static int sensor_list_remove_all (void)
 452 {
 453   c_ipmi_sensor_list_t *list_item;
 454
 455   pthread_mutex_lock (&sensor_list_lock);
 456
 457   list_item = sensor_list;
 458   sensor_list = NULL;
 459
 460   pthread_mutex_unlock (&sensor_list_lock);
 461
 462   while (list_item != NULL)
 463   {
 464     c_ipmi_sensor_list_t *list_next = list_item->next;
 465
 466     free (list_item);
 467
 468     list_item = list_next;
 469   } /* while (list_item) */
 470
 471   return (0);
 472 } /* int sensor_list_remove_all */
 473
 474 /*
 475  * Entity handlers
 476  */
 477 static void entity_sensor_update_handler (enum ipmi_update_e op,
 478     ipmi_entity_t __attribute__((unused)) *entity,
 479     ipmi_sensor_t *sensor,
 480     void __attribute__((unused)) *user_data)
 481 {
 482   /* TODO: Ignore sensors we cannot read */
 483
 484   if ((op == IPMI_ADDED) || (op == IPMI_CHANGED))
 485   {
 486     /* Will check for duplicate entries.. */
 487     sensor_list_add (sensor);
 488   }
 489   else if (op == IPMI_DELETED)
 490   {
 491     sensor_list_remove (sensor);
 492   }
 493 } /* void entity_sensor_update_handler */
 494
 495 /*
 496  * Domain handlers
 497  */
 498 static void domain_entity_update_handler (enum ipmi_update_e op,
 499     ipmi_domain_t __attribute__((unused)) *domain,
 500     ipmi_entity_t *entity,
 501     void __attribute__((unused)) *user_data)
 502 {
 503   int status;
 504
 505   if (op == IPMI_ADDED)
 506   {
 507     status = ipmi_entity_add_sensor_update_handler (entity,
 508         entity_sensor_update_handler, /* user data = */ NULL);
 509     if (status != 0)
 510     {
 511       c_ipmi_error ("ipmi_entity_add_sensor_update_handler", status);
 512     }
 513   }
 514   else if (op == IPMI_DELETED)
 515   {
 516     status = ipmi_entity_remove_sensor_update_handler (entity,
 517         entity_sensor_update_handler, /* user data = */ NULL);
 518     if (status != 0)
 519     {
 520       c_ipmi_error ("ipmi_entity_remove_sensor_update_handler", status);
 521     }
 522   }
 523 } /* void domain_entity_update_handler */
 524
 525 static void domain_connection_change_handler (ipmi_domain_t *domain,
 526     int err,
 527     unsigned int conn_num,
 528     unsigned int port_num,
 529     int still_connected,
 530     void *user_data)
 531 {
 532   int status;
 533
 534   DEBUG ("domain_connection_change_handler (domain = %p, err = %i, "
 535       "conn_num = %u, port_num = %u, still_connected = %i, "
 536       "user_data = %p);\n",
 537       (void *) domain, err, conn_num, port_num, still_connected, user_data);
 538
 539   status = ipmi_domain_add_entity_update_handler (domain,
 540       domain_entity_update_handler, /* user data = */ NULL);
 541   if (status != 0)
 542   {
 543     c_ipmi_error ("ipmi_domain_add_entity_update_handler", status);
 544   }
 545 } /* void domain_connection_change_handler */
 546
 547 static int thread_init (os_handler_t **ret_os_handler)
 548 {
 549   os_handler_t *os_handler;
 550   ipmi_con_t *smi_connection = NULL;
 551   ipmi_domain_id_t domain_id;
 552   int status;
 553
 554   os_handler = ipmi_posix_thread_setup_os_handler (SIGIO);
 555   if (os_handler == NULL)
 556   {
 557     ERROR ("ipmi plugin: ipmi_posix_thread_setup_os_handler failed.");
 558     return (-1);
 559   }
 560
 561   ipmi_init (os_handler);
 562
 563   status = ipmi_smi_setup_con (/* if_num = */ 0,
 564       os_handler,
 565       /* user data = */ NULL,
 566       &smi_connection);
 567   if (status != 0)
 568   {
 569     c_ipmi_error ("ipmi_smi_setup_con", status);
 570     return (-1);
 571   }
 572
 573   ipmi_open_option_t open_option[1] = {
 574     [0] = {
 575       .option = IPMI_OPEN_OPTION_ALL,
 576       { .ival = 1 }
 577     }
 578   };
 579
 580   status = ipmi_open_domain ("mydomain", &smi_connection, /* num_con = */ 1,
 581       domain_connection_change_handler, /* user data = */ NULL,
 582       /* domain_fully_up_handler = */ NULL, /* user data = */ NULL,
 583       open_option, sizeof (open_option) / sizeof (open_option[0]),
 584       &domain_id);
 585   if (status != 0)
 586   {
 587     c_ipmi_error ("ipmi_open_domain", status);
 588     return (-1);
 589   }
 590
 591   *ret_os_handler = os_handler;
 592   return (0);
 593 } /* int thread_init */
 594
 595 static void *thread_main (void __attribute__((unused)) *user_data)
 596 {
 597   int status;
 598   os_handler_t *os_handler = NULL;
 599
 600   status = thread_init (&os_handler);
 601   if (status != 0)
 602   {
 603     ERROR ("ipmi plugin: thread_init failed.\n");
 604     return ((void *) -1);
 605   }
 606
 607   while (c_ipmi_active != 0)
 608   {
 609     struct timeval tv = { 1, 0 };
 610     os_handler->perform_one_op (os_handler, &tv);
 611   }
 612
 613   ipmi_posix_thread_free_os_handler (os_handler);
 614
 615   return ((void *) 0);
 616 } /* void *thread_main */
 617
 618 static int c_ipmi_config (const char *key, const char *value)
 619 {
 620   if (ignorelist == NULL)
 621     ignorelist = ignorelist_create (/* invert = */ 1);
 622   if (ignorelist == NULL)
 623     return (1);
 624
 625   if (strcasecmp ("Sensor", key) == 0)
 626   {
 627     ignorelist_add (ignorelist, value);
 628   }
 629   else if (strcasecmp ("IgnoreSelected", key) == 0)
 630   {
 631     int invert = 1;
 632     if (IS_TRUE (value))
 633       invert = 0;
 634     ignorelist_set_invert (ignorelist, invert);
 635   }
 636   else if (strcasecmp ("NotifySensorAdd", key) == 0)
 637   {
 638     if (IS_TRUE (value))
 639       c_ipmi_nofiy_add = 1;
 640   }
 641   else if (strcasecmp ("NotifySensorRemove", key) == 0)
 642   {
 643     if (IS_TRUE (value))
 644       c_ipmi_nofiy_remove = 1;
 645   }
 646   else if (strcasecmp ("NotifySensorNotPresent", key) == 0)
 647   {
 648     if (IS_TRUE (value))
 649       c_ipmi_nofiy_notpresent = 1;
 650   }
 651   else
 652   {
 653     return (-1);
 654   }
 655
 656   return (0);
 657 } /* int c_ipmi_config */
 658
 659 static int c_ipmi_init (void)
 660 {
 661   int status;
 662
 663   /* Don't send `ADD' notifications during startup (~ 1 minute) */
 664   time_t iv = CDTIME_T_TO_TIME_T (plugin_get_interval ());
 665   c_ipmi_init_in_progress = 1 + (60 / iv);
 666
 667   c_ipmi_active = 1;
 668
 669   status = plugin_thread_create (&thread_id, /* attr = */ NULL, thread_main,
 670       /* user data = */ NULL);
 671   if (status != 0)
 672   {
 673     c_ipmi_active = 0;
 674     thread_id = (pthread_t) 0;
 675     ERROR ("ipmi plugin: pthread_create failed.");
 676     return (-1);
 677   }
 678
 679   return (0);
 680 } /* int c_ipmi_init */
 681
 682 static int c_ipmi_read (void)
 683 {
 684   if ((c_ipmi_active == 0) || (thread_id == (pthread_t) 0))
 685   {
 686     INFO ("ipmi plugin: c_ipmi_read: I'm not active, returning false.");
 687     return (-1);
 688   }
 689
 690   sensor_list_read_all ();
 691
 692   if (c_ipmi_init_in_progress > 0)
 693     c_ipmi_init_in_progress--;
 694   else
 695     c_ipmi_init_in_progress = 0;
 696
 697   return (0);
 698 } /* int c_ipmi_read */
 699
 700 static int c_ipmi_shutdown (void)
 701 {
 702   c_ipmi_active = 0;
 703
 704   if (thread_id != (pthread_t) 0)
 705   {
 706     pthread_join (thread_id, NULL);
 707     thread_id = (pthread_t) 0;
 708   }
 709
 710   sensor_list_remove_all ();
 711
 712   return (0);
 713 } /* int c_ipmi_shutdown */
 714
 715 void module_register (void)
 716 {
 717   plugin_register_config ("ipmi", c_ipmi_config,
 718       config_keys, config_keys_num);
 719   plugin_register_init ("ipmi", c_ipmi_init);
 720   plugin_register_read ("ipmi", c_ipmi_read);
 721   plugin_register_shutdown ("ipmi", c_ipmi_shutdown);
 722 } /* void module_register */
 723
 724 /* vim: set sw=2 sts=2 ts=8 fdm=marker et : */