Battery.c 8.22 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
htop - linux/Battery.c
(C) 2004-2014 Hisham H. Muhammad
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.

Linux battery readings written by Ian P. Hands (iphands@gmail.com, ihands@redhat.com).
*/

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <dirent.h>
14
#include <errno.h>
15
16
17
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
18
19
#include <fcntl.h>
#include <time.h>
20
#include "BatteryMeter.h"
David Hunt's avatar
David Hunt committed
21
#include "StringUtils.h"
22

23
24
25
26
27
28
29
30
31
#define SYS_POWERSUPPLY_DIR "/sys/class/power_supply"

// ----------------------------------------
// READ FROM /proc
// ----------------------------------------

// This implementation reading from from /proc/acpi is really inefficient,
// but I think this is on the way out so I did not rewrite it.
// The /sys implementation below does things the right way.
32
33
34
35
36
37
38
39
40
41
42
43
44

static unsigned long int parseBatInfo(const char *fileName, const unsigned short int lineNum, const unsigned short int wordNum) {
   const char batteryPath[] = PROCDIR "/acpi/battery/";
   DIR* batteryDir = opendir(batteryPath);
   if (!batteryDir)
      return 0;

   #define MAX_BATTERIES 64
   char* batteries[MAX_BATTERIES];
   unsigned int nBatteries = 0;
   memset(batteries, 0, MAX_BATTERIES * sizeof(char*));

   while (nBatteries < MAX_BATTERIES) {
45
46
      struct dirent* dirEntry = readdir(batteryDir);
      if (!dirEntry)
47
48
49
50
         break;
      char* entryName = dirEntry->d_name;
      if (strncmp(entryName, "BAT", 3))
         continue;
Hisham's avatar
Hisham committed
51
      batteries[nBatteries] = xStrdup(entryName);
52
53
54
55
56
57
58
      nBatteries++;
   }
   closedir(batteryDir);

   unsigned long int total = 0;
   for (unsigned int i = 0; i < nBatteries; i++) {
      char infoPath[30];
59
      xSnprintf(infoPath, sizeof infoPath, "%s%s/%s", batteryPath, batteries[i], fileName);
60
61
62
63
64
65

      FILE* file = fopen(infoPath, "r");
      if (!file) {
         break;
      }

66
      char* line = NULL;
67
      for (unsigned short int i = 0; i < lineNum; i++) {
68
69
70
         free(line);
         line = String_readLine(file);
         if (!line) break;
71
72
73
74
75
76
77
      }

      fclose(file);

      char *foundNumStr = String_getToken(line, wordNum);
      const unsigned long int foundNum = atoi(foundNumStr);
      free(foundNumStr);
78
79
      free(line);
      
80
81
82
83
84
85
86
87
88
89
90
91
92
      total += foundNum;
   }

   for (unsigned int i = 0; i < nBatteries; i++) {
      free(batteries[i]);
   }

   return total;
}

static ACPresence procAcpiCheck() {
   ACPresence isOn = AC_ERROR;
   const char *power_supplyPath = PROCDIR "/acpi/ac_adapter";
93
94
   DIR *dir = opendir(power_supplyPath);
   if (!dir) {
95
96
97
98
      return AC_ERROR;
   }

   for (;;) {
99
100
      struct dirent* dirEntry = readdir((DIR *) dir);
      if (!dirEntry)
101
102
103
104
105
106
107
108
         break;

      char* entryName = (char *) dirEntry->d_name;

      if (entryName[0] != 'A')
         continue;

      char statePath[50];
109
      xSnprintf((char *) statePath, sizeof statePath, "%s/%s/state", power_supplyPath, entryName);
110
111
112
113
114
115
116
      FILE* file = fopen(statePath, "r");

      if (!file) {
         isOn = AC_ERROR;
         continue;
      }

117
118
      char* line = String_readLine(file);
      if (!line) continue;
119
120
121
122

      fclose(file);

      const char *isOnline = String_getToken(line, 2);
123
      free(line);
124
125
126
127
128
129
130
131
132
133
134
135

      if (strcmp(isOnline, "on-line") == 0) {
         isOn = AC_PRESENT;
      } else {
         isOn = AC_ABSENT;
      }
      free((char *) isOnline);
      if (isOn == AC_PRESENT) {
         break;
      }
   }

136
137
   if (dir)
      closedir(dir);
138
139
140
   return isOn;
}

141
static double Battery_getProcBatData() {
142
143
144
145
146
147
148
149
150
151
152
   const unsigned long int totalFull = parseBatInfo("info", 3, 4);
   if (totalFull == 0)
      return 0;

   const unsigned long int totalRemain = parseBatInfo("state", 5, 3);
   if (totalRemain == 0)
      return 0;

   return totalRemain * 100.0 / (double) totalFull;
}

153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
static void Battery_getProcData(double* level, ACPresence* isOnAC) {
   *level = Battery_getProcBatData();
   *isOnAC = procAcpiCheck();
}

// ----------------------------------------
// READ FROM /sys
// ----------------------------------------

static inline ssize_t xread(int fd, void *buf, size_t count) {
  // Read some bytes. Retry on EINTR and when we don't get as many bytes as we requested.
  size_t alreadyRead = 0;
  for(;;) {
     ssize_t res = read(fd, buf, count);
     if (res == -1 && errno == EINTR) continue;
     if (res > 0) {
       buf = ((char*)buf)+res;
       count -= res;
       alreadyRead += res;
     }
     if (res == -1) return -1;
     if (count == 0 || res == 0) return alreadyRead;
  }
}

static void Battery_getSysData(double* level, ACPresence* isOnAC) {
      
   *level = 0;
   *isOnAC = AC_ERROR;

   DIR *dir = opendir(SYS_POWERSUPPLY_DIR);
   if (!dir)
      return;
186
187
188
189
190

   unsigned long int totalFull = 0;
   unsigned long int totalRemain = 0;

   for (;;) {
191
192
      struct dirent* dirEntry = readdir((DIR *) dir);
      if (!dirEntry)
193
194
         break;
      char* entryName = (char *) dirEntry->d_name;
195
196
197
198
      const char filePath[50];

      if (entryName[0] == 'B' && entryName[1] == 'A' && entryName[2] == 'T') {
         
199
         xSnprintf((char *) filePath, sizeof filePath, SYS_POWERSUPPLY_DIR "/%s/uevent", entryName);
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
         int fd = open(filePath, O_RDONLY);
         if (fd == -1) {
            closedir(dir);
            return;
         }
         char buffer[1024];
         ssize_t buflen = xread(fd, buffer, 1023);
         close(fd);
         if (buflen < 1) {
            closedir(dir);
            return;
         }
         buffer[buflen] = '\0';
         char *buf = buffer;
         char *line = NULL;
         bool full = false;
         bool now = false;
         while ((line = strsep(&buf, "\n")) != NULL) {
Explorer09's avatar
Explorer09 committed
218
219
   #define match(str,prefix) \
           (String_startsWith(str,prefix) ? (str) + strlen(prefix) : NULL)
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
            const char* ps = match(line, "POWER_SUPPLY_");
            if (!ps) {
               continue;
            }
            const char* energy = match(ps, "ENERGY_");
            if (!energy) {
               energy = match(ps, "CHARGE_");
            }
            if (!energy) {
               continue;
            }
            const char* value = (!full) ? match(energy, "FULL=") : NULL;
            if (value) {
               totalFull += atoi(value);
               full = true;
               if (now) break;
               continue;
            }
            value = (!now) ? match(energy, "NOW=") : NULL;
            if (value) {
               totalRemain += atoi(value);
               now = true;
               if (full) break;
               continue;
            }
         }
Explorer09's avatar
Explorer09 committed
246
   #undef match
247
248
249
250
251
      } else if (entryName[0] == 'A') {
         if (*isOnAC != AC_ERROR) {
            continue;
         }
      
252
         xSnprintf((char *) filePath, sizeof filePath, SYS_POWERSUPPLY_DIR "/%s/online", entryName);
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
         int fd = open(filePath, O_RDONLY);
         if (fd == -1) {
            closedir(dir);
            return;
         }
         char buffer[2] = "";
         for(;;) {
            ssize_t res = read(fd, buffer, 1);
            if (res == -1 && errno == EINTR) continue;
            break;
         }
         close(fd);
         if (buffer[0] == '0') {
            *isOnAC = AC_ABSENT;
         } else if (buffer[0] == '1') {
            *isOnAC = AC_PRESENT;
         }
270
      }
271
272
273
274
   }
   closedir(dir);
   *level = totalFull > 0 ? ((double) totalRemain * 100) / (double) totalFull : 0;
}
275

276
static enum { BAT_PROC, BAT_SYS, BAT_ERR } Battery_method = BAT_PROC;
277

278
279
280
static time_t Battery_cacheTime = 0;
static double Battery_cacheLevel = 0;
static ACPresence Battery_cacheIsOnAC = 0;
281

282
283
284
285
286
287
288
289
void Battery_getData(double* level, ACPresence* isOnAC) {
   time_t now = time(NULL);
   // update battery reading is slow. Update it each 10 seconds only.
   if (now < Battery_cacheTime + 10) {
      *level = Battery_cacheLevel;
      *isOnAC = Battery_cacheIsOnAC;
      return;
   }
290

291
292
293
294
   if (Battery_method == BAT_PROC) {
      Battery_getProcData(level, isOnAC);
      if (*level == 0) {
         Battery_method = BAT_SYS;
295
      }
296
297
298
299
300
   }
   if (Battery_method == BAT_SYS) {
      Battery_getSysData(level, isOnAC);
      if (*level == 0) {
         Battery_method = BAT_ERR;
301
302
      }
   }
303
304
305
306
   if (Battery_method == BAT_ERR) {
      *level = -1;
      *isOnAC = AC_ERROR;
   }
Hisham's avatar
Hisham committed
307
308
309
   if (*level > 100.0) {
      *level = 100.0;
   }
310
311
312
   Battery_cacheLevel = *level;
   Battery_cacheIsOnAC = *isOnAC;
   Battery_cacheTime = now;
313
}