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 "common.h"
  29 #include "plugin.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 = 0;
  76 static _Bool report_degraded = 0;
  77 static _Bool query_statefs = 0;
  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   ssnprintf(filename, sizeof(filename), "%s/%s/%s", dir, power_supply,
 351             basename);
 352
 353   status = (int)read_file_contents(filename, buffer, buffer_size);
 354   if (status < 0)
 355     return status;
 356
 357   strstripnewline(buffer);
 358   return 0;
 359 } /* }}} int sysfs_file_to_buffer */
 360
 361 /* Reads a file which contains only a number (and optionally a trailing
 362  * newline) and parses that number. */
 363 static int sysfs_file_to_gauge(char const *dir, /* {{{ */
 364                                char const *power_supply, char const *basename,
 365                                gauge_t *ret_value) {
 366   int status;
 367   char buffer[32] = "";
 368
 369   status =
 370       sysfs_file_to_buffer(dir, power_supply, basename, buffer, sizeof(buffer));
 371   if (status != 0)
 372     return (status);
 373
 374   return (strtogauge(buffer, ret_value));
 375 } /* }}} sysfs_file_to_gauge */
 376
 377 static int read_sysfs_capacity(char const *dir, /* {{{ */
 378                                char const *power_supply,
 379                                char const *plugin_instance) {
 380   gauge_t capacity_charged = NAN;
 381   gauge_t capacity_full = NAN;
 382   gauge_t capacity_design = NAN;
 383   int status;
 384
 385   status =
 386       sysfs_file_to_gauge(dir, power_supply, "energy_now", &capacity_charged);
 387   if (status != 0)
 388     return (status);
 389
 390   status =
 391       sysfs_file_to_gauge(dir, power_supply, "energy_full", &capacity_full);
 392   if (status != 0)
 393     return (status);
 394
 395   status = sysfs_file_to_gauge(dir, power_supply, "energy_full_design",
 396                                &capacity_design);
 397   if (status != 0)
 398     return (status);
 399
 400   submit_capacity(plugin_instance, capacity_charged * SYSFS_FACTOR,
 401                   capacity_full * SYSFS_FACTOR, capacity_design * SYSFS_FACTOR);
 402   return (0);
 403 } /* }}} int read_sysfs_capacity */
 404
 405 static int read_sysfs_callback(char const *dir, /* {{{ */
 406                                char const *power_supply, void *user_data) {
 407   int *battery_index = user_data;
 408
 409   char const *plugin_instance;
 410   char buffer[32];
 411   gauge_t v = NAN;
 412   _Bool discharging = 0;
 413   int status;
 414
 415   /* Ignore non-battery directories, such as AC power. */
 416   status =
 417       sysfs_file_to_buffer(dir, power_supply, "type", buffer, sizeof(buffer));
 418   if (status != 0)
 419     return (0);
 420   if (strcasecmp("Battery", buffer) != 0)
 421     return (0);
 422
 423   (void)sysfs_file_to_buffer(dir, power_supply, "status", buffer,
 424                              sizeof(buffer));
 425   if (strcasecmp("Discharging", buffer) == 0)
 426     discharging = 1;
 427
 428   /* FIXME: This is a dirty hack for backwards compatibility: The battery
 429    * plugin, for a very long time, has had the plugin_instance
 430    * hard-coded to "0". So, to keep backwards compatibility, we'll use
 431    * "0" for the first battery we find and the power_supply name for all
 432    * following. This should be reverted in a future major version. */
 433   plugin_instance = (*battery_index == 0) ? "0" : power_supply;
 434   (*battery_index)++;
 435
 436   read_sysfs_capacity(dir, power_supply, plugin_instance);
 437
 438   if (sysfs_file_to_gauge(dir, power_supply, "power_now", &v) == 0) {
 439     if (discharging)
 440       v *= -1.0;
 441     battery_submit(plugin_instance, "power", v * SYSFS_FACTOR);
 442   }
 443   if (sysfs_file_to_gauge(dir, power_supply, "current_now", &v) == 0) {
 444     if (discharging)
 445       v *= -1.0;
 446     battery_submit(plugin_instance, "current", v * SYSFS_FACTOR);
 447   }
 448
 449   if (sysfs_file_to_gauge(dir, power_supply, "voltage_now", &v) == 0)
 450     battery_submit(plugin_instance, "voltage", v * SYSFS_FACTOR);
 451
 452   return (0);
 453 } /* }}} int read_sysfs_callback */
 454
 455 static int read_sysfs(void) /* {{{ */
 456 {
 457   int status;
 458   int battery_counter = 0;
 459
 460   if (access(SYSFS_PATH, R_OK) != 0)
 461     return (ENOENT);
 462
 463   status = walk_directory(SYSFS_PATH, read_sysfs_callback,
 464                           /* user_data = */ &battery_counter,
 465                           /* include hidden */ 0);
 466   return (status);
 467 } /* }}} int read_sysfs */
 468
 469 static int read_acpi_full_capacity(char const *dir, /* {{{ */
 470                                    char const *power_supply,
 471                                    gauge_t *ret_capacity_full,
 472                                    gauge_t *ret_capacity_design)
 473
 474 {
 475   char filename[PATH_MAX];
 476   char buffer[1024];
 477
 478   FILE *fh;
 479
 480   ssnprintf(filename, sizeof(filename), "%s/%s/info", dir, power_supply);
 481   fh = fopen(filename, "r");
 482   if (fh == NULL)
 483     return (errno);
 484
 485   /* last full capacity:      40090 mWh */
 486   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
 487     gauge_t *value_ptr;
 488     int fields_num;
 489     char *fields[8];
 490     int index;
 491
 492     if (strncmp("last full capacity:", buffer, strlen("last full capacity:")) ==
 493         0) {
 494       value_ptr = ret_capacity_full;
 495       index = 3;
 496     } else if (strncmp("design capacity:", buffer,
 497                        strlen("design capacity:")) == 0) {
 498       value_ptr = ret_capacity_design;
 499       index = 2;
 500     } else {
 501       continue;
 502     }
 503
 504     fields_num = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
 505     if (fields_num <= index)
 506       continue;
 507
 508     strtogauge(fields[index], value_ptr);
 509   }
 510
 511   fclose(fh);
 512   return (0);
 513 } /* }}} int read_acpi_full_capacity */
 514
 515 static int read_acpi_callback(char const *dir, /* {{{ */
 516                               char const *power_supply, void *user_data) {
 517   int *battery_index = user_data;
 518
 519   gauge_t power = NAN;
 520   gauge_t voltage = NAN;
 521   gauge_t capacity_charged = NAN;
 522   gauge_t capacity_full = NAN;
 523   gauge_t capacity_design = NAN;
 524   _Bool charging = 0;
 525   _Bool is_current = 0;
 526
 527   char const *plugin_instance;
 528   char filename[PATH_MAX];
 529   char buffer[1024];
 530
 531   FILE *fh;
 532
 533   ssnprintf(filename, sizeof(filename), "%s/%s/state", dir, power_supply);
 534   fh = fopen(filename, "r");
 535   if (fh == NULL) {
 536     if ((errno == EAGAIN) || (errno == EINTR) || (errno == ENOENT))
 537       return (0);
 538     else
 539       return (errno);
 540   }
 541
 542   /*
 543    * [11:00] <@tokkee> $ cat /proc/acpi/battery/BAT1/state
 544    * [11:00] <@tokkee> present:                 yes
 545    * [11:00] <@tokkee> capacity state:          ok
 546    * [11:00] <@tokkee> charging state:          charging
 547    * [11:00] <@tokkee> present rate:            1724 mA
 548    * [11:00] <@tokkee> remaining capacity:      4136 mAh
 549    * [11:00] <@tokkee> present voltage:         12428 mV
 550    */
 551   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
 552     char *fields[8];
 553     int numfields;
 554
 555     numfields = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
 556     if (numfields < 3)
 557       continue;
 558
 559     if ((strcmp(fields[0], "charging") == 0) &&
 560         (strcmp(fields[1], "state:") == 0)) {
 561       if (strcmp(fields[2], "charging") == 0)
 562         charging = 1;
 563       else
 564         charging = 0;
 565       continue;
 566     }
 567
 568     /* The unit of "present rate" depends on the battery. Modern
 569      * batteries export power (watts), older batteries (used to)
 570      * export current (amperes). We check the fourth column and try
 571      * to find old batteries this way. */
 572     if ((strcmp(fields[0], "present") == 0) &&
 573         (strcmp(fields[1], "rate:") == 0)) {
 574       strtogauge(fields[2], &power);
 575
 576       if ((numfields >= 4) && (strcmp("mA", fields[3]) == 0))
 577         is_current = 1;
 578     } else if ((strcmp(fields[0], "remaining") == 0) &&
 579                (strcmp(fields[1], "capacity:") == 0))
 580       strtogauge(fields[2], &capacity_charged);
 581     else if ((strcmp(fields[0], "present") == 0) &&
 582              (strcmp(fields[1], "voltage:") == 0))
 583       strtogauge(fields[2], &voltage);
 584   } /* while (fgets (buffer, sizeof (buffer), fh) != NULL) */
 585
 586   fclose(fh);
 587
 588   if (!charging)
 589     power *= -1.0;
 590
 591   /* FIXME: This is a dirty hack for backwards compatibility: The battery
 592    * plugin, for a very long time, has had the plugin_instance
 593    * hard-coded to "0". So, to keep backwards compatibility, we'll use
 594    * "0" for the first battery we find and the power_supply name for all
 595    * following. This should be reverted in a future major version. */
 596   plugin_instance = (*battery_index == 0) ? "0" : power_supply;
 597   (*battery_index)++;
 598
 599   read_acpi_full_capacity(dir, power_supply, &capacity_full, &capacity_design);
 600
 601   submit_capacity(plugin_instance, capacity_charged * PROC_ACPI_FACTOR,
 602                   capacity_full * PROC_ACPI_FACTOR,
 603                   capacity_design * PROC_ACPI_FACTOR);
 604
 605   battery_submit(plugin_instance, is_current ? "current" : "power",
 606                  power * PROC_ACPI_FACTOR);
 607   battery_submit(plugin_instance, "voltage", voltage * PROC_ACPI_FACTOR);
 608
 609   return 0;
 610 } /* }}} int read_acpi_callback */
 611
 612 static int read_acpi(void) /* {{{ */
 613 {
 614   int status;
 615   int battery_counter = 0;
 616
 617   if (access(PROC_ACPI_PATH, R_OK) != 0)
 618     return (ENOENT);
 619
 620   status = walk_directory(PROC_ACPI_PATH, read_acpi_callback,
 621                           /* user_data = */ &battery_counter,
 622                           /* include hidden */ 0);
 623   return (status);
 624 } /* }}} int read_acpi */
 625
 626 static int read_pmu(void) /* {{{ */
 627 {
 628   int i = 0;
 629   /* The upper limit here is just a safeguard. If there is a system with
 630    * more than 100 batteries, this can easily be increased. */
 631   for (; i < 100; i++) {
 632     FILE *fh;
 633
 634     char buffer[1024];
 635     char filename[PATH_MAX];
 636     char plugin_instance[DATA_MAX_NAME_LEN];
 637
 638     gauge_t current = NAN;
 639     gauge_t voltage = NAN;
 640     gauge_t charge = NAN;
 641
 642     ssnprintf(filename, sizeof(filename), PROC_PMU_PATH_FORMAT, i);
 643     if (access(filename, R_OK) != 0)
 644       break;
 645
 646     ssnprintf(plugin_instance, sizeof(plugin_instance), "%i", i);
 647
 648     fh = fopen(filename, "r");
 649     if (fh == NULL) {
 650       if (errno == ENOENT)
 651         break;
 652       else if ((errno == EAGAIN) || (errno == EINTR))
 653         continue;
 654       else
 655         return (errno);
 656     }
 657
 658     while (fgets(buffer, sizeof(buffer), fh) != NULL) {
 659       char *fields[8];
 660       int numfields;
 661
 662       numfields = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
 663       if (numfields < 3)
 664         continue;
 665
 666       if (strcmp("current", fields[0]) == 0)
 667         strtogauge(fields[2], &current);
 668       else if (strcmp("voltage", fields[0]) == 0)
 669         strtogauge(fields[2], &voltage);
 670       else if (strcmp("charge", fields[0]) == 0)
 671         strtogauge(fields[2], &charge);
 672     }
 673
 674     fclose(fh);
 675     fh = NULL;
 676
 677     battery_submit(plugin_instance, "charge", charge / 1000.0);
 678     battery_submit(plugin_instance, "current", current / 1000.0);
 679     battery_submit(plugin_instance, "voltage", voltage / 1000.0);
 680   }
 681
 682   if (i == 0)
 683     return (ENOENT);
 684   return (0);
 685 } /* }}} int read_pmu */
 686
 687 static int battery_read(void) /* {{{ */
 688 {
 689   int status;
 690
 691   if (query_statefs)
 692     return battery_read_statefs();
 693
 694   DEBUG("battery plugin: Trying sysfs ...");
 695   status = read_sysfs();
 696   if (status == 0)
 697     return (0);
 698
 699   DEBUG("battery plugin: Trying acpi ...");
 700   status = read_acpi();
 701   if (status == 0)
 702     return (0);
 703
 704   DEBUG("battery plugin: Trying pmu ...");
 705   status = read_pmu();
 706   if (status == 0)
 707     return (0);
 708
 709   ERROR("battery plugin: All available input methods failed.");
 710   return (-1);
 711 } /* }}} int battery_read */
 712 #endif /* KERNEL_LINUX */
 713
 714 static int battery_config(oconfig_item_t *ci) {
 715   for (int i = 0; i < ci->children_num; i++) {
 716     oconfig_item_t *child = ci->children + i;
 717
 718     if (strcasecmp("ValuesPercentage", child->key) == 0)
 719       cf_util_get_boolean(child, &report_percent);
 720     else if (strcasecmp("ReportDegraded", child->key) == 0)
 721       cf_util_get_boolean(child, &report_degraded);
 722     else if (strcasecmp("QueryStateFS", child->key) == 0)
 723       cf_util_get_boolean(child, &query_statefs);
 724     else
 725       WARNING("battery plugin: Ignoring unknown "
 726               "configuration option \"%s\".",
 727               child->key);
 728   }
 729
 730   return (0);
 731 } /* }}} int battery_config */
 732
 733 void module_register(void) {
 734   plugin_register_complex_config("battery", battery_config);
 735   plugin_register_read("battery", battery_read);
 736 } /* void module_register */