src/battery.c

   1 /**
   2  * collectd - src/battery.c
   3  * Copyright (C) 2006-2014  Florian octo Forster
   4  * Copyright (C) 2008       Michał Mirosław
   5  * Copyright (C) 2014       Andy Parkins
   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  *   Michał Mirosław <mirq-linux at rere.qmqm.pl>
  23  *   Andy Parkins <andyp at fussylogic.co.uk>
  24  **/
  25
  26 #include "collectd.h"
  27
  28 #include "plugin.h"
  29 #include "utils/common/common.h"
  30
  31 #if HAVE_MACH_MACH_TYPES_H
  32 #include <mach/mach_types.h>
  33 #endif
  34 #if HAVE_MACH_MACH_INIT_H
  35 #include <mach/mach_init.h>
  36 #endif
  37 #if HAVE_MACH_MACH_ERROR_H
  38 #include <mach/mach_error.h>
  39 #endif
  40 #if HAVE_COREFOUNDATION_COREFOUNDATION_H
  41 #include <CoreFoundation/CoreFoundation.h>
  42 #endif
  43 #if HAVE_IOKIT_IOKITLIB_H
  44 #include <IOKit/IOKitLib.h>
  45 #endif
  46 #if HAVE_IOKIT_IOTYPES_H
  47 #include <IOKit/IOTypes.h>
  48 #endif
  49 #if HAVE_IOKIT_PS_IOPOWERSOURCES_H
  50 #include <IOKit/ps/IOPowerSources.h>
  51 #endif
  52 #if HAVE_IOKIT_PS_IOPSKEYS_H
  53 #include <IOKit/ps/IOPSKeys.h>
  54 #endif
  55
  56 #if !HAVE_IOKIT_IOKITLIB_H && !HAVE_IOKIT_PS_IOPOWERSOURCES_H && !KERNEL_LINUX
  57 #error "No applicable input method."
  58 #endif
  59
  60 #if HAVE_IOKIT_IOKITLIB_H || HAVE_IOKIT_PS_IOPOWERSOURCES_H
  61 /* No global variables */
  62 /* #endif HAVE_IOKIT_IOKITLIB_H || HAVE_IOKIT_PS_IOPOWERSOURCES_H */
  63
  64 #elif KERNEL_LINUX
  65 #define PROC_PMU_PATH_FORMAT "/proc/pmu/battery_%i"
  66 #define PROC_ACPI_PATH "/proc/acpi/battery"
  67 #define PROC_ACPI_FACTOR 0.001
  68 #define SYSFS_PATH "/sys/class/power_supply"
  69 #define SYSFS_FACTOR 0.000001
  70 #endif /* KERNEL_LINUX */
  71
  72 int battery_read_statefs(
  73     void); /* defined in battery_statefs; used by StateFS backend */
  74
  75 static bool report_percent;
  76 static bool report_degraded;
  77 static bool query_statefs;
  78
  79 static void battery_submit2(char const *plugin_instance, /* {{{ */
  80                             char const *type, char const *type_instance,
  81                             gauge_t value) {
  82   value_list_t vl = VALUE_LIST_INIT;
  83
  84   vl.values = &(value_t){.gauge = value};
  85   vl.values_len = 1;
  86   sstrncpy(vl.plugin, "battery", sizeof(vl.plugin));
  87   sstrncpy(vl.plugin_instance, plugin_instance, sizeof(vl.plugin_instance));
  88   sstrncpy(vl.type, type, sizeof(vl.type));
  89   if (type_instance != NULL)
  90     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
  91
  92   plugin_dispatch_values(&vl);
  93 } /* }}} void battery_submit2 */
  94
  95 static void battery_submit(char const *plugin_instance, /* {{{ */
  96                            char const *type, gauge_t value) {
  97   battery_submit2(plugin_instance, type, NULL, value);
  98 } /* }}} void battery_submit */
  99
 100 static void submit_capacity(char const *plugin_instance, /* {{{ */
 101                             gauge_t capacity_charged, gauge_t capacity_full,
 102                             gauge_t capacity_design) {
 103   if (report_percent && (capacity_charged > capacity_full))
 104     return;
 105   if (report_degraded && (capacity_full > capacity_design))
 106     return;
 107
 108   if (report_percent) {
 109     gauge_t capacity_max;
 110
 111     if (report_degraded)
 112       capacity_max = capacity_design;
 113     else
 114       capacity_max = capacity_full;
 115
 116     battery_submit2(plugin_instance, "percent", "charged",
 117                     100.0 * capacity_charged / capacity_max);
 118     battery_submit2(plugin_instance, "percent", "discharged",
 119                     100.0 * (capacity_full - capacity_charged) / capacity_max);
 120
 121     if (report_degraded)
 122       battery_submit2(plugin_instance, "percent", "degraded",
 123                       100.0 * (capacity_design - capacity_full) / capacity_max);
 124   } else if (report_degraded) /* && !report_percent */
 125   {
 126     battery_submit2(plugin_instance, "capacity", "charged", capacity_charged);
 127     battery_submit2(plugin_instance, "capacity", "discharged",
 128                     (capacity_full - capacity_charged));
 129     battery_submit2(plugin_instance, "capacity", "degraded",
 130                     (capacity_design - capacity_full));
 131   } else /* !report_percent && !report_degraded */
 132   {
 133     battery_submit(plugin_instance, "capacity", capacity_charged);
 134   }
 135 } /* }}} void submit_capacity */
 136
 137 #if HAVE_IOKIT_PS_IOPOWERSOURCES_H || HAVE_IOKIT_IOKITLIB_H
 138 static double dict_get_double(CFDictionaryRef dict,
 139                               const char *key_string) /* {{{ */
 140 {
 141   double val_double;
 142   long long val_int;
 143   CFNumberRef val_obj;
 144   CFStringRef key_obj;
 145
 146   key_obj = CFStringCreateWithCString(kCFAllocatorDefault, key_string,
 147                                       kCFStringEncodingASCII);
 148   if (key_obj == NULL) {
 149     DEBUG("CFStringCreateWithCString (%s) failed.\n", key_string);
 150     return NAN;
 151   }
 152
 153   if ((val_obj = CFDictionaryGetValue(dict, key_obj)) == NULL) {
 154     DEBUG("CFDictionaryGetValue (%s) failed.", key_string);
 155     CFRelease(key_obj);
 156     return NAN;
 157   }
 158   CFRelease(key_obj);
 159
 160   if (CFGetTypeID(val_obj) == CFNumberGetTypeID()) {
 161     if (CFNumberIsFloatType(val_obj)) {
 162       CFNumberGetValue(val_obj, kCFNumberDoubleType, &val_double);
 163     } else {
 164       CFNumberGetValue(val_obj, kCFNumberLongLongType, &val_int);
 165       val_double = val_int;
 166     }
 167   } else {
 168     DEBUG("CFGetTypeID (val_obj) = %i", (int)CFGetTypeID(val_obj));
 169     return NAN;
 170   }
 171
 172   return val_double;
 173 } /* }}} double dict_get_double */
 174
 175 #if HAVE_IOKIT_PS_IOPOWERSOURCES_H
 176 static void get_via_io_power_sources(double *ret_charge, /* {{{ */
 177                                      double *ret_current, double *ret_voltage) {
 178   CFTypeRef ps_raw;
 179   CFArrayRef ps_array;
 180   int ps_array_len;
 181   CFDictionaryRef ps_dict;
 182   CFTypeRef ps_obj;
 183
 184   double temp_double;
 185
 186   ps_raw = IOPSCopyPowerSourcesInfo();
 187   ps_array = IOPSCopyPowerSourcesList(ps_raw);
 188   ps_array_len = CFArrayGetCount(ps_array);
 189
 190   DEBUG("ps_array_len == %i", ps_array_len);
 191
 192   for (int i = 0; i < ps_array_len; i++) {
 193     ps_obj = CFArrayGetValueAtIndex(ps_array, i);
 194     ps_dict = IOPSGetPowerSourceDescription(ps_raw, ps_obj);
 195
 196     if (ps_dict == NULL) {
 197       DEBUG("IOPSGetPowerSourceDescription failed.");
 198       continue;
 199     }
 200
 201     if (CFGetTypeID(ps_dict) != CFDictionaryGetTypeID()) {
 202       DEBUG("IOPSGetPowerSourceDescription did not return a CFDictionaryRef");
 203       continue;
 204     }
 205
 206     /* FIXME: Check if this is really an internal battery */
 207
 208     if (isnan(*ret_charge)) {
 209       /* This is the charge in percent. */
 210       temp_double = dict_get_double(ps_dict, kIOPSCurrentCapacityKey);
 211       if (!isnan((temp_double)) && (temp_double >= 0.0) &&
 212           (temp_double <= 100.0))
 213         *ret_charge = temp_double;
 214     }
 215
 216     if (isnan(*ret_current)) {
 217       temp_double = dict_get_double(ps_dict, kIOPSCurrentKey);
 218       if (!isnan(temp_double))
 219         *ret_current = temp_double / 1000.0;
 220     }
 221
 222     if (isnan(*ret_voltage)) {
 223       temp_double = dict_get_double(ps_dict, kIOPSVoltageKey);
 224       if (!isnan(temp_double))
 225         *ret_voltage = temp_double / 1000.0;
 226     }
 227   }
 228
 229   CFRelease(ps_array);
 230   CFRelease(ps_raw);
 231 } /* }}} void get_via_io_power_sources */
 232 #endif /* HAVE_IOKIT_PS_IOPOWERSOURCES_H */
 233
 234 #if HAVE_IOKIT_IOKITLIB_H
 235 static void get_via_generic_iokit(double *ret_capacity_full, /* {{{ */
 236                                   double *ret_capacity_design,
 237                                   double *ret_current, double *ret_voltage) {
 238   kern_return_t status;
 239   io_iterator_t iterator;
 240   io_object_t io_obj;
 241
 242   CFDictionaryRef bat_root_dict;
 243   CFArrayRef bat_info_arry;
 244   CFIndex bat_info_arry_len;
 245   CFDictionaryRef bat_info_dict;
 246
 247   double temp_double;
 248
 249   status = IOServiceGetMatchingServices(
 250       kIOMasterPortDefault, IOServiceNameMatching("battery"), &iterator);
 251   if (status != kIOReturnSuccess) {
 252     DEBUG("IOServiceGetMatchingServices failed.");
 253     return;
 254   }
 255
 256   while ((io_obj = IOIteratorNext(iterator))) {
 257     status = IORegistryEntryCreateCFProperties(
 258         io_obj, (CFMutableDictionaryRef *)&bat_root_dict, kCFAllocatorDefault,
 259         kNilOptions);
 260     if (status != kIOReturnSuccess) {
 261       DEBUG("IORegistryEntryCreateCFProperties failed.");
 262       continue;
 263     }
 264
 265     bat_info_arry =
 266         (CFArrayRef)CFDictionaryGetValue(bat_root_dict, CFSTR("IOBatteryInfo"));
 267     if (bat_info_arry == NULL) {
 268       CFRelease(bat_root_dict);
 269       continue;
 270     }
 271     bat_info_arry_len = CFArrayGetCount(bat_info_arry);
 272
 273     for (CFIndex bat_info_arry_pos = 0; bat_info_arry_pos < bat_info_arry_len;
 274          bat_info_arry_pos++) {
 275       bat_info_dict = (CFDictionaryRef)CFArrayGetValueAtIndex(
 276           bat_info_arry, bat_info_arry_pos);
 277
 278       if (isnan(*ret_capacity_full)) {
 279         temp_double = dict_get_double(bat_info_dict, "Capacity");
 280         *ret_capacity_full = temp_double / 1000.0;
 281       }
 282
 283       if (isnan(*ret_capacity_design)) {
 284         temp_double = dict_get_double(bat_info_dict, "AbsoluteMaxCapacity");
 285         *ret_capacity_design = temp_double / 1000.0;
 286       }
 287
 288       if (isnan(*ret_current)) {
 289         temp_double = dict_get_double(bat_info_dict, "Current");
 290         *ret_current = temp_double / 1000.0;
 291       }
 292
 293       if (isnan(*ret_voltage)) {
 294         temp_double = dict_get_double(bat_info_dict, "Voltage");
 295         *ret_voltage = temp_double / 1000.0;
 296       }
 297     }
 298
 299     CFRelease(bat_root_dict);
 300   }
 301
 302   IOObjectRelease(iterator);
 303 } /* }}} void get_via_generic_iokit */
 304 #endif /* HAVE_IOKIT_IOKITLIB_H */
 305
 306 static int battery_read(void) /* {{{ */
 307 {
 308   gauge_t current = NAN; /* Current in A */
 309   gauge_t voltage = NAN; /* Voltage in V */
 310
 311   /* We only get the charged capacity as a percentage from
 312    * IOPowerSources. IOKit, on the other hand, only reports the full
 313    * capacity. We use the two to calculate the current charged capacity. */
 314   gauge_t charge_rel = NAN;      /* Current charge in percent */
 315   gauge_t capacity_charged;      /* Charged capacity */
 316   gauge_t capacity_full = NAN;   /* Total capacity */
 317   gauge_t capacity_design = NAN; /* Full design capacity */
 318
 319   if (query_statefs)
 320     return battery_read_statefs();
 321
 322 #if HAVE_IOKIT_PS_IOPOWERSOURCES_H
 323   get_via_io_power_sources(&charge_rel, &current, &voltage);
 324 #endif
 325 #if HAVE_IOKIT_IOKITLIB_H
 326   get_via_generic_iokit(&capacity_full, &capacity_design, &current, &voltage);
 327 #endif
 328
 329   capacity_charged = charge_rel * capacity_full / 100.0;
 330   submit_capacity("0", capacity_charged, capacity_full, capacity_design);
 331
 332   if (!isnan(current))
 333     battery_submit("0", "current", current);
 334   if (!isnan(voltage))
 335     battery_submit("0", "voltage", voltage);
 336
 337   return 0;
 338 } /* }}} int battery_read */
 339   /* #endif HAVE_IOKIT_IOKITLIB_H || HAVE_IOKIT_PS_IOPOWERSOURCES_H */
 340
 341 #elif KERNEL_LINUX
 342 /* Reads a file which contains only a number (and optionally a trailing
 343  * newline) and parses that number. */
 344 static int sysfs_file_to_buffer(char const *dir, /* {{{ */
 345                                 char const *power_supply, char const *basename,
 346                                 char *buffer, size_t buffer_size) {
 347   char filename[PATH_MAX];
 348   int status;
 349
 350   snprintf(filename, sizeof(filename), "%s/%s/%s", dir, power_supply, basename);
 351
 352   status = (int)read_text_file_contents(filename, buffer, buffer_size);
 353   if (status < 0)
 354     return status;
 355
 356   strstripnewline(buffer);
 357   return 0;
 358 } /* }}} int sysfs_file_to_buffer */
 359
 360 /* Reads a file which contains only a number (and optionally a trailing
 361  * newline) and parses that number. */
 362 static int sysfs_file_to_gauge(char const *dir, /* {{{ */
 363                                char const *power_supply, char const *basename,
 364                                gauge_t *ret_value) {
 365   int status;
 366   char buffer[32];
 367
 368   status =
 369       sysfs_file_to_buffer(dir, power_supply, basename, buffer, sizeof(buffer));
 370   if (status != 0)
 371     return status;
 372
 373   return strtogauge(buffer, ret_value);
 374 } /* }}} sysfs_file_to_gauge */
 375
 376 static int read_sysfs_capacity(char const *dir, /* {{{ */
 377                                char const *power_supply,
 378                                char const *plugin_instance) {
 379   gauge_t capacity_charged = NAN;
 380   gauge_t capacity_full = NAN;
 381   gauge_t capacity_design = NAN;
 382   int status;
 383
 384   status =
 385       sysfs_file_to_gauge(dir, power_supply, "energy_now", &capacity_charged);
 386   if (status != 0)
 387     return status;
 388
 389   status =
 390       sysfs_file_to_gauge(dir, power_supply, "energy_full", &capacity_full);
 391   if (status != 0)
 392     return status;
 393
 394   status = sysfs_file_to_gauge(dir, power_supply, "energy_full_design",
 395                                &capacity_design);
 396   if (status != 0)
 397     return status;
 398
 399   submit_capacity(plugin_instance, capacity_charged * SYSFS_FACTOR,
 400                   capacity_full * SYSFS_FACTOR, capacity_design * SYSFS_FACTOR);
 401   return 0;
 402 } /* }}} int read_sysfs_capacity */
 403
 404 static int read_sysfs_callback(char const *dir, /* {{{ */
 405                                char const *power_supply, void *user_data) {
 406   int *battery_index = user_data;
 407
 408   char const *plugin_instance;
 409   char buffer[32];
 410   gauge_t v = NAN;
 411   bool discharging = false;
 412   int status;
 413
 414   /* Ignore non-battery directories, such as AC power. */
 415   status =
 416       sysfs_file_to_buffer(dir, power_supply, "type", buffer, sizeof(buffer));
 417   if (status != 0)
 418     return 0;
 419   if (strcasecmp("Battery", buffer) != 0)
 420     return 0;
 421
 422   (void)sysfs_file_to_buffer(dir, power_supply, "status", buffer,
 423                              sizeof(buffer));
 424   if (strcasecmp("Discharging", buffer) == 0)
 425     discharging = true;
 426
 427   /* FIXME: This is a dirty hack for backwards compatibility: The battery
 428    * plugin, for a very long time, has had the plugin_instance
 429    * hard-coded to "0". So, to keep backwards compatibility, we'll use
 430    * "0" for the first battery we find and the power_supply name for all
 431    * following. This should be reverted in a future major version. */
 432   plugin_instance = (*battery_index == 0) ? "0" : power_supply;
 433   (*battery_index)++;
 434
 435   read_sysfs_capacity(dir, power_supply, plugin_instance);
 436
 437   if (sysfs_file_to_gauge(dir, power_supply, "power_now", &v) == 0) {
 438     if (discharging)
 439       v *= -1.0;
 440     battery_submit(plugin_instance, "power", v * SYSFS_FACTOR);
 441   }
 442   if (sysfs_file_to_gauge(dir, power_supply, "current_now", &v) == 0) {
 443     if (discharging)
 444       v *= -1.0;
 445     battery_submit(plugin_instance, "current", v * SYSFS_FACTOR);
 446   }
 447
 448   if (sysfs_file_to_gauge(dir, power_supply, "voltage_now", &v) == 0)
 449     battery_submit(plugin_instance, "voltage", v * SYSFS_FACTOR);
 450
 451   return 0;
 452 } /* }}} int read_sysfs_callback */
 453
 454 static int read_sysfs(void) /* {{{ */
 455 {
 456   int status;
 457   int battery_counter = 0;
 458
 459   if (access(SYSFS_PATH, R_OK) != 0)
 460     return ENOENT;
 461
 462   status = walk_directory(SYSFS_PATH, read_sysfs_callback,
 463                           /* user_data = */ &battery_counter,
 464                           /* include hidden */ 0);
 465   return status;
 466 } /* }}} int read_sysfs */
 467
 468 static int read_acpi_full_capacity(char const *dir, /* {{{ */
 469                                    char const *power_supply,
 470                                    gauge_t *ret_capacity_full,
 471                                    gauge_t *ret_capacity_design)
 472
 473 {
 474   char filename[PATH_MAX];
 475   char buffer[1024];
 476
 477   FILE *fh;
 478
 479   snprintf(filename, sizeof(filename), "%s/%s/info", dir, power_supply);
 480   fh = fopen(filename, "r");
 481   if (fh == NULL)
 482     return errno;
 483
 484   /* last full capacity:      40090 mWh */
 485   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
 486     gauge_t *value_ptr;
 487     int fields_num;
 488     char *fields[8];
 489     int index;
 490
 491     if (strncmp("last full capacity:", buffer, strlen("last full capacity:")) ==
 492         0) {
 493       value_ptr = ret_capacity_full;
 494       index = 3;
 495     } else if (strncmp("design capacity:", buffer,
 496                        strlen("design capacity:")) == 0) {
 497       value_ptr = ret_capacity_design;
 498       index = 2;
 499     } else {
 500       continue;
 501     }
 502
 503     fields_num = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
 504     if (fields_num <= index)
 505       continue;
 506
 507     strtogauge(fields[index], value_ptr);
 508   }
 509
 510   fclose(fh);
 511   return 0;
 512 } /* }}} int read_acpi_full_capacity */
 513
 514 static int read_acpi_callback(char const *dir, /* {{{ */
 515                               char const *power_supply, void *user_data) {
 516   int *battery_index = user_data;
 517
 518   gauge_t power = NAN;
 519   gauge_t voltage = NAN;
 520   gauge_t capacity_charged = NAN;
 521   gauge_t capacity_full = NAN;
 522   gauge_t capacity_design = NAN;
 523   bool charging = false;
 524   bool is_current = false;
 525
 526   char const *plugin_instance;
 527   char filename[PATH_MAX];
 528   char buffer[1024];
 529
 530   FILE *fh;
 531
 532   snprintf(filename, sizeof(filename), "%s/%s/state", dir, power_supply);
 533   fh = fopen(filename, "r");
 534   if (fh == NULL) {
 535     if ((errno == EAGAIN) || (errno == EINTR) || (errno == ENOENT))
 536       return 0;
 537     else
 538       return errno;
 539   }
 540
 541   /*
 542    * [11:00] <@tokkee> $ cat /proc/acpi/battery/BAT1/state
 543    * [11:00] <@tokkee> present:                 yes
 544    * [11:00] <@tokkee> capacity state:          ok
 545    * [11:00] <@tokkee> charging state:          charging
 546    * [11:00] <@tokkee> present rate:            1724 mA
 547    * [11:00] <@tokkee> remaining capacity:      4136 mAh
 548    * [11:00] <@tokkee> present voltage:         12428 mV
 549    */
 550   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
 551     char *fields[8];
 552     int numfields;
 553
 554     numfields = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
 555     if (numfields < 3)
 556       continue;
 557
 558     if ((strcmp(fields[0], "charging") == 0) &&
 559         (strcmp(fields[1], "state:") == 0)) {
 560       if (strcmp(fields[2], "charging") == 0)
 561         charging = true;
 562       else
 563         charging = false;
 564       continue;
 565     }
 566
 567     /* The unit of "present rate" depends on the battery. Modern
 568      * batteries export power (watts), older batteries (used to)
 569      * export current (amperes). We check the fourth column and try
 570      * to find old batteries this way. */
 571     if ((strcmp(fields[0], "present") == 0) &&
 572         (strcmp(fields[1], "rate:") == 0)) {
 573       strtogauge(fields[2], &power);
 574
 575       if ((numfields >= 4) && (strcmp("mA", fields[3]) == 0))
 576         is_current = true;
 577     } else if ((strcmp(fields[0], "remaining") == 0) &&
 578                (strcmp(fields[1], "capacity:") == 0))
 579       strtogauge(fields[2], &capacity_charged);
 580     else if ((strcmp(fields[0], "present") == 0) &&
 581              (strcmp(fields[1], "voltage:") == 0))
 582       strtogauge(fields[2], &voltage);
 583   } /* while (fgets (buffer, sizeof (buffer), fh) != NULL) */
 584
 585   fclose(fh);
 586
 587   if (!charging)
 588     power *= -1.0;
 589
 590   /* FIXME: This is a dirty hack for backwards compatibility: The battery
 591    * plugin, for a very long time, has had the plugin_instance
 592    * hard-coded to "0". So, to keep backwards compatibility, we'll use
 593    * "0" for the first battery we find and the power_supply name for all
 594    * following. This should be reverted in a future major version. */
 595   plugin_instance = (*battery_index == 0) ? "0" : power_supply;
 596   (*battery_index)++;
 597
 598   read_acpi_full_capacity(dir, power_supply, &capacity_full, &capacity_design);
 599
 600   submit_capacity(plugin_instance, capacity_charged * PROC_ACPI_FACTOR,
 601                   capacity_full * PROC_ACPI_FACTOR,
 602                   capacity_design * PROC_ACPI_FACTOR);
 603
 604   battery_submit(plugin_instance, is_current ? "current" : "power",
 605                  power * PROC_ACPI_FACTOR);
 606   battery_submit(plugin_instance, "voltage", voltage * PROC_ACPI_FACTOR);
 607
 608   return 0;
 609 } /* }}} int read_acpi_callback */
 610
 611 static int read_acpi(void) /* {{{ */
 612 {
 613   int status;
 614   int battery_counter = 0;
 615
 616   if (access(PROC_ACPI_PATH, R_OK) != 0)
 617     return ENOENT;
 618
 619   status = walk_directory(PROC_ACPI_PATH, read_acpi_callback,
 620                           /* user_data = */ &battery_counter,
 621                           /* include hidden */ 0);
 622   return status;
 623 } /* }}} int read_acpi */
 624
 625 static int read_pmu(void) /* {{{ */
 626 {
 627   int i = 0;
 628   /* The upper limit here is just a safeguard. If there is a system with
 629    * more than 100 batteries, this can easily be increased. */
 630   for (; i < 100; i++) {
 631     FILE *fh;
 632
 633     char buffer[1024];
 634     char filename[PATH_MAX];
 635     char plugin_instance[DATA_MAX_NAME_LEN];
 636
 637     gauge_t current = NAN;
 638     gauge_t voltage = NAN;
 639     gauge_t charge = NAN;
 640
 641     snprintf(filename, sizeof(filename), PROC_PMU_PATH_FORMAT, i);
 642     if (access(filename, R_OK) != 0)
 643       break;
 644
 645     snprintf(plugin_instance, sizeof(plugin_instance), "%i", i);
 646
 647     fh = fopen(filename, "r");
 648     if (fh == NULL) {
 649       if (errno == ENOENT)
 650         break;
 651       else if ((errno == EAGAIN) || (errno == EINTR))
 652         continue;
 653       else
 654         return errno;
 655     }
 656
 657     while (fgets(buffer, sizeof(buffer), fh) != NULL) {
 658       char *fields[8];
 659       int numfields;
 660
 661       numfields = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
 662       if (numfields < 3)
 663         continue;
 664
 665       if (strcmp("current", fields[0]) == 0)
 666         strtogauge(fields[2], &current);
 667       else if (strcmp("voltage", fields[0]) == 0)
 668         strtogauge(fields[2], &voltage);
 669       else if (strcmp("charge", fields[0]) == 0)
 670         strtogauge(fields[2], &charge);
 671     }
 672
 673     fclose(fh);
 674     fh = NULL;
 675
 676     battery_submit(plugin_instance, "charge", charge / 1000.0);
 677     battery_submit(plugin_instance, "current", current / 1000.0);
 678     battery_submit(plugin_instance, "voltage", voltage / 1000.0);
 679   }
 680
 681   if (i == 0)
 682     return ENOENT;
 683   return 0;
 684 } /* }}} int read_pmu */
 685
 686 static int battery_read(void) /* {{{ */
 687 {
 688   int status;
 689
 690   if (query_statefs)
 691     return battery_read_statefs();
 692
 693   DEBUG("battery plugin: Trying sysfs ...");
 694   status = read_sysfs();
 695   if (status == 0)
 696     return 0;
 697
 698   DEBUG("battery plugin: Trying acpi ...");
 699   status = read_acpi();
 700   if (status == 0)
 701     return 0;
 702
 703   DEBUG("battery plugin: Trying pmu ...");
 704   status = read_pmu();
 705   if (status == 0)
 706     return 0;
 707
 708   ERROR("battery plugin: All available input methods failed.");
 709   return -1;
 710 } /* }}} int battery_read */
 711 #endif /* KERNEL_LINUX */
 712
 713 static int battery_config(oconfig_item_t *ci) {
 714   for (int i = 0; i < ci->children_num; i++) {
 715     oconfig_item_t *child = ci->children + i;
 716
 717     if (strcasecmp("ValuesPercentage", child->key) == 0)
 718       cf_util_get_boolean(child, &report_percent);
 719     else if (strcasecmp("ReportDegraded", child->key) == 0)
 720       cf_util_get_boolean(child, &report_degraded);
 721     else if (strcasecmp("QueryStateFS", child->key) == 0)
 722       cf_util_get_boolean(child, &query_statefs);
 723     else
 724       WARNING("battery plugin: Ignoring unknown "
 725               "configuration option \"%s\".",
 726               child->key);
 727   }
 728
 729   return 0;
 730 } /* }}} int battery_config */
 731
 732 void module_register(void) {
 733   plugin_register_complex_config("battery", battery_config);
 734   plugin_register_read("battery", battery_read);
 735 } /* void module_register */