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