Merge pull request #2796 from elfiesmelfie/feat_ipmi_SEL_ignore_list
[collectd.git] / 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 */