vcs.maemo.org Git - monky/blob - src/linux.c

   1 /* Conky, a system monitor, based on torsmo
   2  *
   3  * Any original torsmo code is licensed under the BSD license
   4  *
   5  * All code written since the fork of torsmo is licensed under the GPL
   6  *
   7  * Please see COPYING for details
   8  *
   9  * Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
  10  * Copyright (c) 2007 Toni Spets
  11  * Copyright (c) 2005-2007 Brenden Matthews, Philip Kovacs, et. al.
  12  *      (see AUTHORS)
  13  * All rights reserved.
  14  *
  15  * This program is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation, either version 3 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26  *
  27  * $Id$ */
  28
  29 #include "conky.h"
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <dirent.h>
  34 #include <ctype.h>
  35 #include <errno.h>
  36 #include <limits.h>
  37 #include <sys/types.h>
  38 #include <sys/sysinfo.h>
  39 #include <sys/stat.h>
  40 #ifndef HAVE_CLOCK_GETTIME
  41 #include <sys/time.h>
  42 #endif
  43 #include <fcntl.h>
  44 #include <unistd.h>
  45 // #include <assert.h>
  46 #include <time.h>
  47 #include "top.h"
  48
  49 #include <sys/ioctl.h>
  50 #include <sys/socket.h>
  51 #include <netinet/in.h>
  52 #include <linux/sockios.h>
  53 #include <net/if.h>
  54 #include <arpa/inet.h>
  55 #ifdef _NET_IF_H
  56 #define _LINUX_IF_H
  57 #endif
  58 #include <linux/route.h>
  59 #include <math.h>
  60
  61 #ifdef HAVE_IWLIB
  62 #include <iwlib.h>
  63 #endif
  64
  65 #define SHORTSTAT_TEMPL "%*s %llu %llu %llu"
  66 #define LONGSTAT_TEMPL "%*s %llu %llu %llu "
  67
  68 static int show_nice_processes;
  69
  70 /* This flag tells the linux routines to use the /proc system where possible,
  71  * even if other api's are available, e.g. sysinfo() or getloadavg().
  72  * the reason for this is to allow for /proc-based distributed monitoring.
  73  * using a flag in this manner creates less confusing code. */
  74 static int prefer_proc = 0;
  75
  76 void prepare_update()
  77 {
  78 }
  79
  80 void update_uptime()
  81 {
  82 #ifdef HAVE_SYSINFO
  83         if (!prefer_proc) {
  84                 struct sysinfo s_info;
  85
  86                 sysinfo(&s_info);
  87                 info.uptime = (double) s_info.uptime;
  88         } else
  89 #endif
  90         {
  91                 static int rep = 0;
  92                 FILE *fp;
  93
  94                 if (!(fp = open_file("/proc/uptime", &rep))) {
  95                         info.uptime = 0.0;
  96                         return;
  97                 }
  98                 fscanf(fp, "%lf", &info.uptime);
  99                 fclose(fp);
 100         }
 101         info.mask |= (1 << INFO_UPTIME);
 102 }
 103
 104 int check_mount(char *s)
 105 {
 106         int ret = 0;
 107         FILE *mtab = fopen("/etc/mtab", "r");
 108
 109         if (mtab) {
 110                 char buf1[256], buf2[128];
 111
 112                 while (fgets(buf1, 256, mtab)) {
 113                         sscanf(buf1, "%*s %128s", buf2);
 114                         if (!strcmp(s, buf2)) {
 115                                 ret = 1;
 116                                 break;
 117                         }
 118                 }
 119                 fclose(mtab);
 120         } else {
 121                 ERR("Could not open mtab");
 122         }
 123         return ret;
 124 }
 125
 126 /* these things are also in sysinfo except Buffers:
 127  * (that's why I'm reading them from proc) */
 128
 129 void update_meminfo()
 130 {
 131         FILE *meminfo_fp;
 132         static int rep = 0;
 133
 134         /* unsigned int a; */
 135         char buf[256];
 136
 137         info.mem = info.memmax = info.swap = info.swapmax = info.bufmem =
 138                 info.buffers = info.cached = 0;
 139
 140         if (!(meminfo_fp = open_file("/proc/meminfo", &rep))) {
 141                 return;
 142         }
 143
 144         while (!feof(meminfo_fp)) {
 145                 if (fgets(buf, 255, meminfo_fp) == NULL) {
 146                         break;
 147                 }
 148
 149                 if (strncmp(buf, "MemTotal:", 9) == 0) {
 150                         sscanf(buf, "%*s %Lu", &info.memmax);
 151                 } else if (strncmp(buf, "MemFree:", 8) == 0) {
 152                         sscanf(buf, "%*s %Lu", &info.mem);
 153                 } else if (strncmp(buf, "SwapTotal:", 10) == 0) {
 154                         sscanf(buf, "%*s %Lu", &info.swapmax);
 155                 } else if (strncmp(buf, "SwapFree:", 9) == 0) {
 156                         sscanf(buf, "%*s %Lu", &info.swap);
 157                 } else if (strncmp(buf, "Buffers:", 8) == 0) {
 158                         sscanf(buf, "%*s %Lu", &info.buffers);
 159                 } else if (strncmp(buf, "Cached:", 7) == 0) {
 160                         sscanf(buf, "%*s %Lu", &info.cached);
 161                 }
 162         }
 163
 164         info.mem = info.memmax - info.mem;
 165         info.swap = info.swapmax - info.swap;
 166
 167         info.bufmem = info.cached + info.buffers;
 168
 169         info.mask |= (1 << INFO_MEM) | (1 << INFO_BUFFERS);
 170
 171         fclose(meminfo_fp);
 172 }
 173
 174 int get_laptop_mode()
 175 {
 176         FILE *fp;
 177         int val = -1;
 178
 179         if ((fp = fopen("/proc/sys/vm/laptop_mode", "r")) != NULL)
 180                 fscanf(fp, "%d\n", &val);
 181         fclose(fp);
 182         return val;
 183 }
 184
 185 /* my system says:
 186  * # cat /sys/block/sda/queue/scheduler
 187  * noop [anticipatory] cfq
 188  */
 189 char *get_ioscheduler(char *disk)
 190 {
 191         FILE *fp;
 192         char buf[128];
 193
 194         if (!disk)
 195                 return "n/a";
 196
 197         snprintf(buf, 127, "/sys/block/%s/queue/scheduler", disk);
 198         if ((fp = fopen(buf, "r")) == NULL) {
 199                 return strdup("n/a");
 200         }
 201         while (!feof(fp)) {
 202                 fscanf(fp, "%127s", buf);
 203                 if (buf[0] == '[') {
 204                         buf[strlen(buf) - 1] = '\0';
 205                         fclose(fp);
 206                         return strdup(buf + 1);
 207                 }
 208         }
 209         fclose(fp);
 210         return strdup("n/a");
 211 }
 212
 213 int interface_up(const char *dev)
 214 {
 215         int fd;
 216         struct ifreq ifr;
 217
 218         if((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
 219                 CRIT_ERR("could not create sockfd");
 220                 return 0;
 221         }
 222         strncpy(ifr.ifr_name, dev, IFNAMSIZ);
 223         if(ioctl(fd, SIOCGIFFLAGS, &ifr)) {
 224                 /* if device does not exist, treat like not up */
 225                 if (errno != ENODEV)
 226                         perror("SIOCGIFFLAGS");
 227         } else {
 228                 close(fd);
 229                 return (ifr.ifr_flags & IFF_UP);
 230         }
 231         close(fd);
 232         return 0;
 233 }
 234
 235 #define COND_FREE(x) if(x) free(x); x = 0
 236 #define SAVE_SET_STRING(x, y) \
 237         if (x && strcmp((char *)x, (char *)y)) { \
 238                 free(x); \
 239                 x = strdup("multiple"); \
 240         } else if (!x) { \
 241                 x = strdup(y); \
 242         }
 243
 244 void update_gateway_info()
 245 {
 246         FILE *fp;
 247         struct in_addr ina;
 248         char iface[64];
 249         unsigned long dest, gate, mask;
 250         unsigned int flags;
 251         short ref, use, metric, mtu, win, irtt;
 252
 253         struct gateway_info *gw_info = &info.gw_info;
 254
 255         COND_FREE(gw_info->iface);
 256         COND_FREE(gw_info->ip);
 257         gw_info->count = 0;
 258
 259         if ((fp = fopen("/proc/net/route", "r")) == NULL) {
 260                 perror("fopen()");
 261                 goto FAIL;
 262         }
 263         if (fscanf(fp, "%*[^\n]\n") == EOF) {
 264                 perror("fscanf()");
 265                 goto CLOSE_FAIL;
 266         }
 267         while (!feof(fp)) {
 268                 // Iface Destination Gateway Flags RefCnt Use Metric Mask MTU Window IRTT
 269                 if(fscanf(fp, "%63s %lx %lx %x %hd %hd %hd %lx %hd %hd %hd\n",
 270                                 iface, &dest, &gate, &flags, &ref, &use,
 271                                 &metric, &mask, &mtu, &win, &irtt) != 11) {
 272                         perror("fscanf()");
 273                         goto CLOSE_FAIL;
 274                 }
 275                 if (flags & RTF_GATEWAY && dest == 0 && mask == 0) {
 276                         gw_info->count++;
 277                         SAVE_SET_STRING(gw_info->iface, iface)
 278                         ina.s_addr = gate;
 279                         SAVE_SET_STRING(gw_info->ip, inet_ntoa(ina))
 280                 }
 281         }
 282         fclose(fp);
 283         return;
 284 CLOSE_FAIL:
 285         fclose(fp);
 286 FAIL:
 287         info.gw_info.iface = info.gw_info.ip = strdup("failed");
 288         return;
 289 }
 290
 291 inline void update_net_stats()
 292 {
 293         FILE *net_dev_fp;
 294         static int rep = 0;
 295
 296         // FIXME: arbitrary size chosen to keep code simple.
 297         int i, i2;
 298         unsigned int curtmp1, curtmp2;
 299         unsigned int k;
 300         struct ifconf conf;
 301         char buf[256];
 302         double delta;
 303
 304 #ifdef HAVE_IWLIB
 305         // wireless info variables
 306         int skfd, has_bitrate = 0;
 307         struct wireless_info *winfo;
 308         struct iwreq wrq;
 309 #endif
 310
 311         /* get delta */
 312         delta = current_update_time - last_update_time;
 313         if (delta <= 0.0001) {
 314                 return;
 315         }
 316
 317         /* open file and ignore first two lines */
 318         if (!(net_dev_fp = open_file("/proc/net/dev", &rep))) {
 319                 clear_net_stats();
 320                 return;
 321         }
 322
 323         fgets(buf, 255, net_dev_fp);    /* garbage */
 324         fgets(buf, 255, net_dev_fp);    /* garbage (field names) */
 325
 326         /* read each interface */
 327         for (i2 = 0; i2 < 16; i2++) {
 328                 struct net_stat *ns;
 329                 char *s, *p;
 330                 char temp_addr[17];
 331                 long long r, t, last_recv, last_trans;
 332
 333                 if (fgets(buf, 255, net_dev_fp) == NULL) {
 334                         break;
 335                 }
 336                 p = buf;
 337                 while (isspace((int) *p)) {
 338                         p++;
 339                 }
 340
 341                 s = p;
 342
 343                 while (*p && *p != ':') {
 344                         p++;
 345                 }
 346                 if (*p == '\0') {
 347                         continue;
 348                 }
 349                 *p = '\0';
 350                 p++;
 351
 352                 ns = get_net_stat(s);
 353                 ns->up = 1;
 354                 memset(&(ns->addr.sa_data), 0, 14);
 355
 356                 if(NULL == ns->addrs)
 357                         ns->addrs = (char*) malloc(17 * 16);
 358                 if(NULL != ns->addrs)
 359                         memset(ns->addrs, 0, 17 * 16); /* Up to 17 chars per ip, max 16 interfaces. Nasty memory usage... */
 360
 361                 last_recv = ns->recv;
 362                 last_trans = ns->trans;
 363
 364                 /* bytes packets errs drop fifo frame compressed multicast|bytes ... */
 365                 sscanf(p, "%Ld  %*d     %*d  %*d  %*d  %*d   %*d        %*d       %Ld",
 366                         &r, &t);
 367
 368                 /* if recv or trans is less than last time, an overflow happened */
 369                 if (r < ns->last_read_recv) {
 370                         last_recv = 0;
 371                 } else {
 372                         ns->recv += (r - ns->last_read_recv);
 373                 }
 374                 ns->last_read_recv = r;
 375
 376                 if (t < ns->last_read_trans) {
 377                         last_trans = 0;
 378                 } else {
 379                         ns->trans += (t - ns->last_read_trans);
 380                 }
 381                 ns->last_read_trans = t;
 382
 383                 /*** ip addr patch ***/
 384                 i = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 385
 386                 conf.ifc_buf = malloc(sizeof(struct ifreq) * 16);
 387                 conf.ifc_len = sizeof(struct ifreq) * 16;
 388                 memset(conf.ifc_buf, 0, conf.ifc_len);
 389
 390                 ioctl((long) i, SIOCGIFCONF, &conf);
 391
 392                 for (k = 0; k < conf.ifc_len / sizeof(struct ifreq); k++) {
 393                         struct net_stat *ns;
 394
 395                         if (!(((struct ifreq *) conf.ifc_buf) + k))
 396                                 break;
 397
 398                         ns = get_net_stat(
 399                                 ((struct ifreq *) conf.ifc_buf)[k].ifr_ifrn.ifrn_name);
 400                         ns->addr = ((struct ifreq *) conf.ifc_buf)[k].ifr_ifru.ifru_addr;
 401                         if(NULL != ns->addrs) {
 402                                 sprintf(temp_addr, "%u.%u.%u.%u, ",
 403                                         ns->addr.sa_data[2] & 255,
 404                                         ns->addr.sa_data[3] & 255,
 405                                         ns->addr.sa_data[4] & 255,
 406                                         ns->addr.sa_data[5] & 255);
 407                                 if(NULL == strstr(ns->addrs, temp_addr))
 408                                         strncpy(ns->addrs + strlen(ns->addrs), temp_addr, 17);
 409                         }
 410                 }
 411
 412                 close((long) i);
 413
 414                 free(conf.ifc_buf);
 415
 416                 /*** end ip addr patch ***/
 417
 418                 /* calculate speeds */
 419                 ns->net_rec[0] = (ns->recv - last_recv) / delta;
 420                 ns->net_trans[0] = (ns->trans - last_trans) / delta;
 421                 curtmp1 = 0;
 422                 curtmp2 = 0;
 423                 // get an average
 424                 for (i = 0; (unsigned) i < info.net_avg_samples; i++) {
 425                         curtmp1 += ns->net_rec[i];
 426                         curtmp2 += ns->net_trans[i];
 427                 }
 428                 if (curtmp1 == 0) {
 429                         curtmp1 = 1;
 430                 }
 431                 if (curtmp2 == 0) {
 432                         curtmp2 = 1;
 433                 }
 434                 ns->recv_speed = curtmp1 / (double) info.net_avg_samples;
 435                 ns->trans_speed = curtmp2 / (double) info.net_avg_samples;
 436                 if (info.net_avg_samples > 1) {
 437                         for (i = info.net_avg_samples; i > 1; i--) {
 438                                 ns->net_rec[i - 1] = ns->net_rec[i - 2];
 439                                 ns->net_trans[i - 1] = ns->net_trans[i - 2];
 440                         }
 441                 }
 442
 443 #ifdef HAVE_IWLIB
 444                 /* update wireless info */
 445                 winfo = malloc(sizeof(struct wireless_info));
 446                 memset(winfo, 0, sizeof(struct wireless_info));
 447
 448                 skfd = iw_sockets_open();
 449                 if (iw_get_basic_config(skfd, s, &(winfo->b)) > -1) {
 450
 451                         // set present winfo variables
 452                         if (iw_get_stats(skfd, s, &(winfo->stats),
 453                                         &winfo->range, winfo->has_range) >= 0) {
 454                                 winfo->has_stats = 1;
 455                         }
 456                         if (iw_get_range_info(skfd, s, &(winfo->range)) >= 0) {
 457                                 winfo->has_range = 1;
 458                         }
 459                         if (iw_get_ext(skfd, s, SIOCGIWAP, &wrq) >= 0) {
 460                                 winfo->has_ap_addr = 1;
 461                                 memcpy(&(winfo->ap_addr), &(wrq.u.ap_addr), sizeof(sockaddr));
 462                         }
 463
 464                         // get bitrate
 465                         if (iw_get_ext(skfd, s, SIOCGIWRATE, &wrq) >= 0) {
 466                                 memcpy(&(winfo->bitrate), &(wrq.u.bitrate), sizeof(iwparam));
 467                                 iw_print_bitrate(ns->bitrate, 16, winfo->bitrate.value);
 468                                 has_bitrate = 1;
 469                         }
 470
 471                         // get link quality
 472                         if (winfo->has_range && winfo->has_stats
 473                                         && ((winfo->stats.qual.level != 0)
 474                                         || (winfo->stats.qual.updated & IW_QUAL_DBM))) {
 475                                 if (!(winfo->stats.qual.updated & IW_QUAL_QUAL_INVALID)) {
 476                                         ns->link_qual = winfo->stats.qual.qual;
 477                                         ns->link_qual_max = winfo->range.max_qual.qual;
 478                                 }
 479                         }
 480
 481                         // get ap mac
 482                         if (winfo->has_ap_addr) {
 483                                 iw_sawap_ntop(&winfo->ap_addr, ns->ap);
 484                         }
 485
 486                         // get essid
 487                         if (winfo->b.has_essid) {
 488                                 if (winfo->b.essid_on) {
 489                                         snprintf(ns->essid, 32, "%s", winfo->b.essid);
 490                                 } else {
 491                                         snprintf(ns->essid, 32, "off/any");
 492                                 }
 493                         }
 494
 495                         snprintf(ns->mode, 16, "%s", iw_operation_mode[winfo->b.mode]);
 496                 }
 497                 iw_sockets_close(skfd);
 498                 free(winfo);
 499 #endif
 500         }
 501
 502         fclose(net_dev_fp);
 503
 504         info.mask |= (1 << INFO_NET);
 505 }
 506
 507 int result;
 508
 509 void update_total_processes()
 510 {
 511 #ifdef HAVE_SYSINFO
 512         if (!prefer_proc) {
 513                 struct sysinfo s_info;
 514
 515                 sysinfo(&s_info);
 516                 info.procs = s_info.procs;
 517         } else
 518 #endif
 519         {
 520                 static int rep = 0;
 521                 FILE *fp;
 522
 523                 if (!(fp = open_file("/proc/loadavg", &rep))) {
 524                         info.procs = 0;
 525                         return;
 526                 }
 527                 fscanf(fp, "%*f %*f %*f %*d/%hd", &info.procs);
 528                 fclose(fp);
 529         }
 530         info.mask |= (1 << INFO_PROCS);
 531 }
 532
 533 #define CPU_SAMPLE_COUNT 15
 534 struct cpu_info {
 535         unsigned long long cpu_user;
 536         unsigned long long cpu_system;
 537         unsigned long long cpu_nice;
 538         unsigned long long cpu_idle;
 539         unsigned long long cpu_iowait;
 540         unsigned long long cpu_irq;
 541         unsigned long long cpu_softirq;
 542         unsigned long long cpu_steal;
 543         unsigned long long cpu_total;
 544         unsigned long long cpu_active_total;
 545         unsigned long long cpu_last_total;
 546         unsigned long long cpu_last_active_total;
 547         double cpu_val[CPU_SAMPLE_COUNT];
 548 };
 549 static short cpu_setup = 0;
 550
 551 /* Determine if this kernel gives us "extended" statistics information in
 552  * /proc/stat.
 553  * Kernels around 2.5 and earlier only reported user, system, nice, and
 554  * idle values in proc stat.
 555  * Kernels around 2.6 and greater report these PLUS iowait, irq, softirq,
 556  * and steal */
 557 void determine_longstat(char *buf)
 558 {
 559         unsigned long long iowait = 0;
 560
 561         KFLAG_SETOFF(KFLAG_IS_LONGSTAT);
 562         /* scanf will either return -1 or 1 because there is only 1 assignment */
 563         if (sscanf(buf, "%*s %*d %*d %*d %*d %llu", &iowait) > 0) {
 564                 KFLAG_SETON(KFLAG_IS_LONGSTAT);
 565         }
 566 }
 567
 568 void get_cpu_count()
 569 {
 570         FILE *stat_fp;
 571         static int rep = 0;
 572
 573         if (info.cpu_usage) {
 574                 return;
 575         }
 576         char buf[256];
 577
 578         if (!(stat_fp = open_file("/proc/stat", &rep))) {
 579                 return;
 580         }
 581
 582         info.cpu_count = 0;
 583
 584         while (!feof(stat_fp)) {
 585                 if (fgets(buf, 255, stat_fp) == NULL) {
 586                         break;
 587                 }
 588
 589                 if (strncmp(buf, "cpu", 3) == 0 && isdigit(buf[3])) {
 590                         if (info.cpu_count == 0) {
 591                                 determine_longstat(buf);
 592                         }
 593                         info.cpu_count++;
 594                 }
 595         }
 596         info.cpu_usage = malloc((info.cpu_count + 1) * sizeof(float));
 597
 598         fclose(stat_fp);
 599 }
 600
 601 #define TMPL_LONGSTAT "%*s %llu %llu %llu %llu %llu %llu %llu %llu"
 602 #define TMPL_SHORTSTAT "%*s %llu %llu %llu %llu"
 603
 604 inline static void update_stat()
 605 {
 606         FILE *stat_fp;
 607         static int rep = 0;
 608         static struct cpu_info *cpu = NULL;
 609         char buf[256];
 610         unsigned int i;
 611         unsigned int index;
 612         double curtmp;
 613         char *stat_template = NULL;
 614         unsigned int malloc_cpu_size = 0;
 615
 616         /* add check for !info.cpu_usage since that mem is freed on a SIGUSR1 */
 617         if (!cpu_setup || !info.cpu_usage) {
 618                 get_cpu_count();
 619                 cpu_setup = 1;
 620         }
 621
 622         if (!stat_template) {
 623                 stat_template =
 624                         KFLAG_ISSET(KFLAG_IS_LONGSTAT) ? TMPL_LONGSTAT : TMPL_SHORTSTAT;
 625         }
 626
 627         if (!cpu) {
 628                 malloc_cpu_size = (info.cpu_count + 1) * sizeof(struct cpu_info);
 629                 cpu = malloc(malloc_cpu_size);
 630                 memset(cpu, 0, malloc_cpu_size);
 631         }
 632
 633         if (!(stat_fp = open_file("/proc/stat", &rep))) {
 634                 info.run_procs = 0;
 635                 if (info.cpu_usage) {
 636                         memset(info.cpu_usage, 0, info.cpu_count * sizeof(float));
 637                 }
 638                 return;
 639         }
 640
 641         index = 0;
 642         while (!feof(stat_fp)) {
 643                 if (fgets(buf, 255, stat_fp) == NULL) {
 644                         break;
 645                 }
 646
 647                 if (strncmp(buf, "procs_running ", 14) == 0) {
 648                         sscanf(buf, "%*s %hu", &info.run_procs);
 649                         info.mask |= (1 << INFO_RUN_PROCS);
 650                 } else if (strncmp(buf, "cpu", 3) == 0) {
 651                         index = isdigit(buf[3]) ? ((int) buf[3]) - 0x2F : 0;
 652                         sscanf(buf, stat_template, &(cpu[index].cpu_user),
 653                                 &(cpu[index].cpu_nice), &(cpu[index].cpu_system),
 654                                 &(cpu[index].cpu_idle), &(cpu[index].cpu_iowait),
 655                                 &(cpu[index].cpu_irq), &(cpu[index].cpu_softirq),
 656                                 &(cpu[index].cpu_steal));
 657
 658                         cpu[index].cpu_total = cpu[index].cpu_user + cpu[index].cpu_nice +
 659                                 cpu[index].cpu_system + cpu[index].cpu_idle +
 660                                 cpu[index].cpu_iowait + cpu[index].cpu_irq +
 661                                 cpu[index].cpu_softirq + cpu[index].cpu_steal;
 662
 663                         cpu[index].cpu_active_total = cpu[index].cpu_total -
 664                                 (cpu[index].cpu_idle + cpu[index].cpu_iowait);
 665                         info.mask |= (1 << INFO_CPU);
 666
 667                         double delta = current_update_time - last_update_time;
 668
 669                         if (delta <= 0.001) {
 670                                 break;
 671                         }
 672
 673                         cpu[index].cpu_val[0] = (cpu[index].cpu_active_total -
 674                                 cpu[index].cpu_last_active_total) /
 675                                 (float) (cpu[index].cpu_total - cpu[index].cpu_last_total);
 676                         curtmp = 0;
 677                         for (i = 0; i < info.cpu_avg_samples; i++) {
 678                                 curtmp += cpu[index].cpu_val[i];
 679                         }
 680                         /* TESTING -- I've removed this, because I don't think it is right.
 681                          * You shouldn't divide by the cpu count here ...
 682                          * removing for testing */
 683                         /* if (index == 0) {
 684                                 info.cpu_usage[index] = curtmp / info.cpu_avg_samples /
 685                                         info.cpu_count;
 686                         } else {
 687                                 info.cpu_usage[index] = curtmp / info.cpu_avg_samples;
 688                         } */
 689                         /* TESTING -- this line replaces the prev. "suspect" if/else */
 690                         info.cpu_usage[index] = curtmp / info.cpu_avg_samples;
 691
 692                         cpu[index].cpu_last_total = cpu[index].cpu_total;
 693                         cpu[index].cpu_last_active_total = cpu[index].cpu_active_total;
 694                         for (i = info.cpu_avg_samples - 1; i > 0; i--) {
 695                                 cpu[index].cpu_val[i] = cpu[index].cpu_val[i - 1];
 696                         }
 697                 }
 698         }
 699         fclose(stat_fp);
 700 }
 701
 702 void update_running_processes()
 703 {
 704         update_stat();
 705 }
 706
 707 void update_cpu_usage()
 708 {
 709         update_stat();
 710 }
 711
 712 void update_load_average()
 713 {
 714 #ifdef HAVE_GETLOADAVG
 715         if (!prefer_proc) {
 716                 double v[3];
 717
 718                 getloadavg(v, 3);
 719                 info.loadavg[0] = (float) v[0];
 720                 info.loadavg[1] = (float) v[1];
 721                 info.loadavg[2] = (float) v[2];
 722         } else
 723 #endif
 724         {
 725                 static int rep = 0;
 726                 FILE *fp;
 727
 728                 if (!(fp = open_file("/proc/loadavg", &rep))) {
 729                         info.loadavg[0] = info.loadavg[1] = info.loadavg[2] = 0.0;
 730                         return;
 731                 }
 732                 fscanf(fp, "%f %f %f", &info.loadavg[0], &info.loadavg[1],
 733                         &info.loadavg[2]);
 734                 fclose(fp);
 735         }
 736         info.mask |= (1 << INFO_LOADAVG);
 737 }
 738
 739 #define PROC_I8K "/proc/i8k"
 740 #define I8K_DELIM " "
 741 static char *i8k_procbuf = NULL;
 742 void update_i8k()
 743 {
 744         FILE *fp;
 745
 746         if (!i8k_procbuf) {
 747                 i8k_procbuf = (char *) malloc(128 * sizeof(char));
 748         }
 749         if ((fp = fopen(PROC_I8K, "r")) == NULL) {
 750                 CRIT_ERR("/proc/i8k doesn't exist! use insmod to make sure the kernel "
 751                         "driver is loaded...");
 752         }
 753
 754         memset(&i8k_procbuf[0], 0, 128);
 755         if (fread(&i8k_procbuf[0], sizeof(char), 128, fp) == 0) {
 756                 ERR("something wrong with /proc/i8k...");
 757         }
 758
 759         fclose(fp);
 760
 761         i8k.version = strtok(&i8k_procbuf[0], I8K_DELIM);
 762         i8k.bios = strtok(NULL, I8K_DELIM);
 763         i8k.serial = strtok(NULL, I8K_DELIM);
 764         i8k.cpu_temp = strtok(NULL, I8K_DELIM);
 765         i8k.left_fan_status = strtok(NULL, I8K_DELIM);
 766         i8k.right_fan_status = strtok(NULL, I8K_DELIM);
 767         i8k.left_fan_rpm = strtok(NULL, I8K_DELIM);
 768         i8k.right_fan_rpm = strtok(NULL, I8K_DELIM);
 769         i8k.ac_status = strtok(NULL, I8K_DELIM);
 770         i8k.buttons_status = strtok(NULL, I8K_DELIM);
 771 }
 772
 773 /***********************************************************/
 774 /***********************************************************/
 775 /***********************************************************/
 776
 777 static int no_dots(const struct dirent *d)
 778 {
 779         if (d->d_name[0] == '.') {
 780                 return 0;
 781         }
 782         return 1;
 783 }
 784
 785 static int get_first_file_in_a_directory(const char *dir, char *s, int *rep)
 786 {
 787         struct dirent **namelist;
 788         int i, n;
 789
 790         n = scandir(dir, &namelist, no_dots, alphasort);
 791         if (n < 0) {
 792                 if (!rep || !*rep) {
 793                         ERR("scandir for %s: %s", dir, strerror(errno));
 794                         if (rep) {
 795                                 *rep = 1;
 796                         }
 797                 }
 798                 return 0;
 799         } else {
 800                 if (n == 0) {
 801                         return 0;
 802                 }
 803
 804                 strncpy(s, namelist[0]->d_name, 255);
 805                 s[255] = '\0';
 806
 807                 for (i = 0; i < n; i++) {
 808                         free(namelist[i]);
 809                 }
 810                 free(namelist);
 811
 812                 return 1;
 813         }
 814 }
 815
 816 int open_sysfs_sensor(const char *dir, const char *dev, const char *type, int n,
 817                 int *div, char *devtype)
 818 {
 819         char path[256];
 820         char buf[256];
 821         int fd;
 822         int divfd;
 823
 824         memset(buf, 0, sizeof(buf));
 825
 826         /* if device is NULL or *, get first */
 827         if (dev == NULL || strcmp(dev, "*") == 0) {
 828                 static int rep = 0;
 829
 830                 if (!get_first_file_in_a_directory(dir, buf, &rep)) {
 831                         return -1;
 832                 }
 833                 dev = buf;
 834         }
 835
 836         if (strcmp(dir, "/sys/class/hwmon/") == 0) {
 837                 if (*buf) {
 838                         /* buf holds result from get_first_file_in_a_directory() above,
 839                          * e.g. "hwmon0" -- append "/device" */
 840                         strcat(buf, "/device");
 841                 } else {
 842                         /* dev holds device number N as a string,
 843                          * e.g. "0", -- convert to "hwmon0/device" */
 844                         sprintf(buf, "hwmon%s/device", dev);
 845                         dev = buf;
 846                 }
 847         }
 848
 849         /* change vol to in */
 850         if (strcmp(type, "vol") == 0) {
 851                 type = "in";
 852         }
 853
 854         if (strcmp(type, "tempf") == 0) {
 855                 snprintf(path, 255, "%s%s/%s%d_input", dir, dev, "temp", n);
 856         } else {
 857                 snprintf(path, 255, "%s%s/%s%d_input", dir, dev, type, n);
 858         }
 859         strncpy(devtype, path, 255);
 860
 861         /* open file */
 862         fd = open(path, O_RDONLY);
 863         if (fd < 0) {
 864                 CRIT_ERR("can't open '%s': %s\nplease check your device or remove this "
 865                         "var from Conky", path, strerror(errno));
 866         }
 867
 868         if (strcmp(type, "in") == 0 || strcmp(type, "temp") == 0
 869                         || strcmp(type, "tempf") == 0) {
 870                 *div = 1;
 871         } else {
 872                 *div = 0;
 873         }
 874         /* fan does not use *_div as a read divisor */
 875         if (strcmp("fan", type) == 0) {
 876                 return fd;
 877         }
 878
 879         /* test if *_div file exist, open it and use it as divisor */
 880         if (strcmp(type, "tempf") == 0) {
 881                 snprintf(path, 255, "%s%s/%s%d_div", dir, "one", "two", n);
 882         } else {
 883                 snprintf(path, 255, "%s%s/%s%d_div", dir, dev, type, n);
 884         }
 885
 886         divfd = open(path, O_RDONLY);
 887         if (divfd > 0) {
 888                 /* read integer */
 889                 char divbuf[64];
 890                 int divn;
 891
 892                 divn = read(divfd, divbuf, 63);
 893                 /* should read until n == 0 but I doubt that kernel will give these
 894                  * in multiple pieces. :) */
 895                 if (divn < 0) {
 896                         ERR("open_sysfs_sensor(): can't read from sysfs");
 897                 } else {
 898                         divbuf[divn] = '\0';
 899                         *div = atoi(divbuf);
 900                 }
 901         }
 902
 903         close(divfd);
 904
 905         return fd;
 906 }
 907
 908 double get_sysfs_info(int *fd, int div, char *devtype, char *type)
 909 {
 910         int val = 0;
 911
 912         if (*fd <= 0) {
 913                 return 0;
 914         }
 915
 916         lseek(*fd, 0, SEEK_SET);
 917
 918         /* read integer */
 919         {
 920                 char buf[64];
 921                 int n;
 922                 n = read(*fd, buf, 63);
 923                 /* should read until n == 0 but I doubt that kernel will give these
 924                  * in multiple pieces. :) */
 925                 if (n < 0) {
 926                         ERR("get_sysfs_info(): read from %s failed\n", devtype);
 927                 } else {
 928                         buf[n] = '\0';
 929                         val = atoi(buf);
 930                 }
 931         }
 932
 933         close(*fd);
 934         /* open file */
 935         *fd = open(devtype, O_RDONLY);
 936         if (*fd < 0) {
 937                 ERR("can't open '%s': %s", devtype, strerror(errno));
 938         }
 939
 940         /* My dirty hack for computing CPU value
 941          * Filedil, from forums.gentoo.org */
 942         /* if (strstr(devtype, "temp1_input") != NULL) {
 943                 return -15.096 + 1.4893 * (val / 1000.0);
 944         } */
 945
 946         /* divide voltage and temperature by 1000 */
 947         /* or if any other divisor is given, use that */
 948         if (strcmp(type, "tempf") == 0) {
 949                 if (div > 1) {
 950                         return ((val / div + 40) * 9.0 / 5) - 40;
 951                 } else if (div) {
 952                         return ((val / 1000.0 + 40) * 9.0 / 5) - 40;
 953                 } else {
 954                         return ((val + 40) * 9.0 / 5) - 40;
 955                 }
 956         } else {
 957                 if (div > 1) {
 958                         return val / div;
 959                 } else if (div) {
 960                         return val / 1000.0;
 961                 } else {
 962                         return val;
 963                 }
 964         }
 965 }
 966
 967 /* Prior to kernel version 2.6.12, the CPU fan speed was available in
 968  * ADT746X_FAN_OLD, whereas later kernel versions provide this information in
 969  * ADT746X_FAN. */
 970 #define ADT746X_FAN "/sys/devices/temperatures/sensor1_fan_speed"
 971 #define ADT746X_FAN_OLD "/sys/devices/temperatures/cpu_fan_speed"
 972
 973 void get_adt746x_fan(char *p_client_buffer, size_t client_buffer_size)
 974 {
 975         static int rep = 0;
 976         char adt746x_fan_state[64];
 977         FILE *fp;
 978
 979         if (!p_client_buffer || client_buffer_size <= 0) {
 980                 return;
 981         }
 982
 983         if ((fp = open_file(ADT746X_FAN, &rep)) == NULL
 984                         && (fp = open_file(ADT746X_FAN_OLD, &rep)) == NULL) {
 985                 sprintf(adt746x_fan_state, "adt746x not found");
 986         } else {
 987                 fgets(adt746x_fan_state, sizeof(adt746x_fan_state), fp);
 988                 adt746x_fan_state[strlen(adt746x_fan_state) - 1] = 0;
 989                 fclose(fp);
 990         }
 991
 992         snprintf(p_client_buffer, client_buffer_size, "%s", adt746x_fan_state);
 993 }
 994
 995 /* Prior to kernel version 2.6.12, the CPU temperature was found in
 996  * ADT746X_CPU_OLD, whereas later kernel versions provide this information in
 997  * ADT746X_CPU. */
 998 #define ADT746X_CPU "/sys/devices/temperatures/sensor1_temperature"
 999 #define ADT746X_CPU_OLD "/sys/devices/temperatures/cpu_temperature"
1000
1001 void get_adt746x_cpu(char *p_client_buffer, size_t client_buffer_size)
1002 {
1003         static int rep = 0;
1004         char adt746x_cpu_state[64];
1005         FILE *fp;
1006
1007         if (!p_client_buffer || client_buffer_size <= 0) {
1008                 return;
1009         }
1010
1011         if ((fp = open_file(ADT746X_CPU, &rep)) == NULL
1012                         && (fp = open_file(ADT746X_CPU_OLD, &rep)) == NULL) {
1013                 sprintf(adt746x_cpu_state, "adt746x not found");
1014         } else {
1015                 fscanf(fp, "%2s", adt746x_cpu_state);
1016                 fclose(fp);
1017         }
1018
1019         snprintf(p_client_buffer, client_buffer_size, "%s", adt746x_cpu_state);
1020 }
1021
1022 /* Thanks to "Walt Nelson" <wnelsonjr@comcast.net> */
1023
1024 /***********************************************************************/
1025 /* This file is part of x86info.
1026  * (C) 2001 Dave Jones.
1027  *
1028  * Licensed under the terms of the GNU GPL License version 2.
1029  *
1030  * Estimate CPU MHz routine by Andrea Arcangeli <andrea@suse.de>
1031  * Small changes by David Sterba <sterd9am@ss1000.ms.mff.cuni.cz> */
1032
1033 #if  defined(__i386) || defined(__x86_64)
1034 __inline__ unsigned long long int rdtsc()
1035 {
1036         unsigned long long int x;
1037
1038         __asm__ volatile(".byte 0x0f, 0x31":"=A" (x));
1039         return x;
1040 }
1041 #endif
1042
1043 /* return system frequency in MHz (use divisor=1) or GHz (use divisor=1000) */
1044 void get_freq_dynamic(char *p_client_buffer, size_t client_buffer_size,
1045                 char *p_format, int divisor)
1046 {
1047 #if  defined(__i386) || defined(__x86_64)
1048         struct timezone tz;
1049         struct timeval tvstart, tvstop;
1050         unsigned long long cycles[2];   /* gotta be 64 bit */
1051         unsigned int microseconds;      /* total time taken */
1052
1053         if (!p_client_buffer || client_buffer_size <= 0 || !p_format
1054                         || divisor <= 0) {
1055                 return;
1056         }
1057
1058         memset(&tz, 0, sizeof(tz));
1059
1060         /* get this function in cached memory */
1061         gettimeofday(&tvstart, &tz);
1062         cycles[0] = rdtsc();
1063         gettimeofday(&tvstart, &tz);
1064
1065         /* we don't trust that this is any specific length of time */
1066         usleep(100);
1067         cycles[1] = rdtsc();
1068         gettimeofday(&tvstop, &tz);
1069         microseconds = ((tvstop.tv_sec - tvstart.tv_sec) * 1000000) +
1070                 (tvstop.tv_usec - tvstart.tv_usec);
1071
1072         snprintf(p_client_buffer, client_buffer_size, p_format,
1073                 (float) ((cycles[1] - cycles[0]) / microseconds) / divisor);
1074         return;
1075 #else
1076         /* FIXME: hardwired: get freq for first cpu!
1077          * this whole function needs to be rethought and redone for
1078          * multi-cpu/multi-core/multi-threaded environments and
1079          * arbitrary combinations thereof */
1080         get_freq(p_client_buffer, client_buffer_size, p_format, divisor, 1);
1081         return;
1082 #endif
1083 }
1084
1085 #define CPUFREQ_PREFIX "/sys/devices/system/cpu"
1086 #define CPUFREQ_POSTFIX "cpufreq/scaling_cur_freq"
1087
1088 /* return system frequency in MHz (use divisor=1) or GHz (use divisor=1000) */
1089 char get_freq(char *p_client_buffer, size_t client_buffer_size, char *p_format,
1090                 int divisor, unsigned int cpu)
1091 {
1092         FILE *f;
1093         static int rep = 0;
1094         char frequency[32];
1095         char s[256];
1096         double freq = 0;
1097
1098         if (!p_client_buffer || client_buffer_size <= 0 || !p_format
1099                         || divisor <= 0) {
1100                 return 0;
1101         }
1102
1103         if (!prefer_proc) {
1104                 char current_freq_file[128];
1105
1106                 snprintf(current_freq_file, 127, "%s/cpu%d/%s", CPUFREQ_PREFIX, cpu - 1,
1107                         CPUFREQ_POSTFIX);
1108                 f = fopen(current_freq_file, "r");
1109                 if (f) {
1110                         /* if there's a cpufreq /sys node, read the current frequency from
1111                          * this node and divide by 1000 to get Mhz. */
1112                         if (fgets(s, sizeof(s), f)) {
1113                                 s[strlen(s) - 1] = '\0';
1114                                 freq = strtod(s, NULL);
1115                         }
1116                         fclose(f);
1117                         snprintf(p_client_buffer, client_buffer_size, p_format,
1118                                 (freq / 1000) / divisor);
1119                         return 1;
1120                 }
1121         }
1122
1123         // open the CPU information file
1124         f = open_file("/proc/cpuinfo", &rep);
1125         if (!f) {
1126                 perror("Conky: Failed to access '/proc/cpuinfo' at get_freq()");
1127                 return 0;
1128         }
1129
1130         // read the file
1131         while (fgets(s, sizeof(s), f) != NULL) {
1132
1133 #if defined(__i386) || defined(__x86_64)
1134                 // and search for the cpu mhz
1135                 if (strncmp(s, "cpu MHz", 7) == 0 && cpu == 0) {
1136 #else
1137 #if defined(__alpha)
1138                 // different on alpha
1139                 if (strncmp(s, "cycle frequency [Hz]", 20) == 0 && cpu == 0) {
1140 #else
1141                 // this is different on ppc for some reason
1142                 if (strncmp(s, "clock", 5) == 0 && cpu == 0) {
1143 #endif // defined(__alpha)
1144 #endif // defined(__i386) || defined(__x86_64)
1145
1146                         // copy just the number
1147                         strcpy(frequency, strchr(s, ':') + 2);
1148 #if defined(__alpha)
1149                         // strip " est.\n"
1150                         frequency[strlen(frequency) - 6] = '\0';
1151                         // kernel reports in Hz
1152                         freq = strtod(frequency, NULL) / 1000000;
1153 #else
1154                         // strip \n
1155                         frequency[strlen(frequency) - 1] = '\0';
1156                         freq = strtod(frequency, NULL);
1157 #endif
1158                         break;
1159                 }
1160                 if (strncmp(s, "processor", 9) == 0) {
1161                         cpu--;
1162                         continue;
1163                 }
1164         }
1165
1166         fclose(f);
1167         snprintf(p_client_buffer, client_buffer_size, p_format,
1168                 (float) freq / divisor);
1169         return 1;
1170 }
1171
1172 #define CPUFREQ_VOLTAGE "cpufreq/scaling_voltages"
1173
1174 /* /sys/devices/system/cpu/cpu0/cpufreq/scaling_voltages looks something
1175  * like this:
1176 # frequency voltage
1177 1800000 1340
1178 1600000 1292
1179 1400000 1100
1180 1200000 988
1181 1000000 1116
1182 800000 1004
1183 600000 988
1184  * Peter Tarjan (ptarjan@citromail.hu) */
1185
1186 /* return cpu voltage in mV (use divisor=1) or V (use divisor=1000) */
1187 char get_voltage(char *p_client_buffer, size_t client_buffer_size,
1188                 char *p_format, int divisor, unsigned int cpu)
1189 {
1190         FILE *f;
1191         char s[256];
1192         int freq = 0;
1193         int voltage = 0;
1194         char current_freq_file[128];
1195         int freq_comp = 0;
1196
1197         /* build the voltage file name */
1198         cpu--;
1199         snprintf(current_freq_file, 127, "%s/cpu%d/%s", CPUFREQ_PREFIX, cpu,
1200                 CPUFREQ_POSTFIX);
1201
1202         if (!p_client_buffer || client_buffer_size <= 0 || !p_format
1203                         || divisor <= 0) {
1204                 return 0;
1205         }
1206
1207         /* read the current cpu frequency from the /sys node */
1208         f = fopen(current_freq_file, "r");
1209         if (f) {
1210                 if (fgets(s, sizeof(s), f)) {
1211                         s[strlen(s) - 1] = '\0';
1212                         freq = strtod(s, NULL);
1213                 }
1214                 fclose(f);
1215         } else {
1216                 fprintf(stderr, "Conky: Failed to access '%s' at ", current_freq_file);
1217                 perror("get_voltage()");
1218                 if (f) {
1219                         fclose(f);
1220                 }
1221                 return 0;
1222         }
1223
1224         snprintf(current_freq_file, 127, "%s/cpu%d/%s", CPUFREQ_PREFIX, cpu,
1225                 CPUFREQ_VOLTAGE);
1226
1227         /* use the current cpu frequency to find the corresponding voltage */
1228         f = fopen(current_freq_file, "r");
1229
1230         if (f) {
1231                 while (!feof(f)) {
1232                         char line[256];
1233
1234                         if (fgets(line, 255, f) == NULL) {
1235                                 break;
1236                         }
1237                         sscanf(line, "%d %d", &freq_comp, &voltage);
1238                         if (freq_comp == freq) {
1239                                 break;
1240                         }
1241                 }
1242                 fclose(f);
1243         } else {
1244                 fprintf(stderr, "Conky: Failed to access '%s' at ", current_freq_file);
1245                 perror("get_voltage()");
1246                 if (f) {
1247                         fclose(f);
1248                 }
1249                 return 0;
1250         }
1251         snprintf(p_client_buffer, client_buffer_size, p_format,
1252                 (float) voltage / divisor);
1253         return 1;
1254 }
1255
1256 #define ACPI_FAN_DIR "/proc/acpi/fan/"
1257
1258 void get_acpi_fan(char *p_client_buffer, size_t client_buffer_size)
1259 {
1260         static int rep = 0;
1261         char buf[256];
1262         char buf2[256];
1263         FILE *fp;
1264
1265         if (!p_client_buffer || client_buffer_size <= 0) {
1266                 return;
1267         }
1268
1269         /* yeah, slow... :/ */
1270         if (!get_first_file_in_a_directory(ACPI_FAN_DIR, buf, &rep)) {
1271                 snprintf(p_client_buffer, client_buffer_size, "no fans?");
1272                 return;
1273         }
1274
1275         snprintf(buf2, sizeof(buf2), "%s%s/state", ACPI_FAN_DIR, buf);
1276
1277         fp = open_file(buf2, &rep);
1278         if (!fp) {
1279                 snprintf(p_client_buffer, client_buffer_size,
1280                         "can't open fan's state file");
1281                 return;
1282         }
1283         memset(buf, 0, sizeof(buf));
1284         fscanf(fp, "%*s %99s", buf);
1285         fclose(fp);
1286
1287         snprintf(p_client_buffer, client_buffer_size, "%s", buf);
1288 }
1289
1290 #define ACPI_AC_ADAPTER_DIR "/proc/acpi/ac_adapter/"
1291
1292 void get_acpi_ac_adapter(char *p_client_buffer, size_t client_buffer_size)
1293 {
1294         static int rep = 0;
1295         char buf[256];
1296         char buf2[256];
1297         FILE *fp;
1298
1299         if (!p_client_buffer || client_buffer_size <= 0) {
1300                 return;
1301         }
1302
1303         /* yeah, slow... :/ */
1304         if (!get_first_file_in_a_directory(ACPI_AC_ADAPTER_DIR, buf, &rep)) {
1305                 snprintf(p_client_buffer, client_buffer_size, "no ac_adapters?");
1306                 return;
1307         }
1308
1309         snprintf(buf2, sizeof(buf2), "%s%s/state", ACPI_AC_ADAPTER_DIR, buf);
1310
1311         fp = open_file(buf2, &rep);
1312         if (!fp) {
1313                 snprintf(p_client_buffer, client_buffer_size,
1314                         "No ac adapter found.... where is it?");
1315                 return;
1316         }
1317         memset(buf, 0, sizeof(buf));
1318         fscanf(fp, "%*s %99s", buf);
1319         fclose(fp);
1320
1321         snprintf(p_client_buffer, client_buffer_size, "%s", buf);
1322 }
1323
1324 /*
1325 /proc/acpi/thermal_zone/THRM/cooling_mode
1326 cooling mode:            active
1327 /proc/acpi/thermal_zone/THRM/polling_frequency
1328 <polling disabled>
1329 /proc/acpi/thermal_zone/THRM/state
1330 state:                   ok
1331 /proc/acpi/thermal_zone/THRM/temperature
1332 temperature:             45 C
1333 /proc/acpi/thermal_zone/THRM/trip_points
1334 critical (S5):           73 C
1335 passive:                 73 C: tc1=4 tc2=3 tsp=40 devices=0xcdf6e6c0
1336 */
1337
1338 #define ACPI_THERMAL_DIR "/proc/acpi/thermal_zone/"
1339 #define ACPI_THERMAL_FORMAT "/proc/acpi/thermal_zone/%s/temperature"
1340
1341 int open_acpi_temperature(const char *name)
1342 {
1343         char path[256];
1344         char buf[256];
1345         int fd;
1346
1347         if (name == NULL || strcmp(name, "*") == 0) {
1348                 static int rep = 0;
1349
1350                 if (!get_first_file_in_a_directory(ACPI_THERMAL_DIR, buf, &rep)) {
1351                         return -1;
1352                 }
1353                 name = buf;
1354         }
1355
1356         snprintf(path, 255, ACPI_THERMAL_FORMAT, name);
1357
1358         fd = open(path, O_RDONLY);
1359         if (fd < 0) {
1360                 ERR("can't open '%s': %s", path, strerror(errno));
1361         }
1362
1363         return fd;
1364 }
1365
1366 static double last_acpi_temp;
1367 static double last_acpi_temp_time;
1368
1369 double get_acpi_temperature(int fd)
1370 {
1371         if (fd <= 0) {
1372                 return 0;
1373         }
1374
1375         /* don't update acpi temperature too often */
1376         if (current_update_time - last_acpi_temp_time < 11.32) {
1377                 return last_acpi_temp;
1378         }
1379         last_acpi_temp_time = current_update_time;
1380
1381         /* seek to beginning */
1382         lseek(fd, 0, SEEK_SET);
1383
1384         /* read */
1385         {
1386                 char buf[256];
1387                 int n;
1388
1389                 n = read(fd, buf, 255);
1390                 if (n < 0) {
1391                         ERR("can't read fd %d: %s", fd, strerror(errno));
1392                 } else {
1393                         buf[n] = '\0';
1394                         sscanf(buf, "temperature: %lf", &last_acpi_temp);
1395                 }
1396         }
1397
1398         return last_acpi_temp;
1399 }
1400
1401 /*
1402 hipo@lepakko hipo $ cat /proc/acpi/battery/BAT1/info
1403 present:                 yes
1404 design capacity:         4400 mAh
1405 last full capacity:      4064 mAh
1406 battery technology:      rechargeable
1407 design voltage:          14800 mV
1408 design capacity warning: 300 mAh
1409 design capacity low:     200 mAh
1410 capacity granularity 1:  32 mAh
1411 capacity granularity 2:  32 mAh
1412 model number:            02KT
1413 serial number:           16922
1414 battery type:            LION
1415 OEM info:                SANYO
1416 */
1417
1418 /*
1419 hipo@lepakko conky $ cat /proc/acpi/battery/BAT1/state
1420 present:                 yes
1421 capacity state:          ok
1422 charging state:          unknown
1423 present rate:            0 mA
1424 remaining capacity:      4064 mAh
1425 present voltage:         16608 mV
1426 */
1427
1428 /*
1429 2213<@jupet�kellari��> jupet@lagi-unstable:~$ cat /proc/apm
1430 2213<@jupet�kellari��> 1.16 1.2 0x03 0x01 0xff 0x10 -1% -1 ?
1431 2213<@jupet�kellari��> (-1 ollee ei akkua kiinni, koska akku on p�yd�ll�)
1432 2214<@jupet�kellari��> jupet@lagi-unstable:~$ cat /proc/apm
1433 2214<@jupet�kellari��> 1.16 1.2 0x03 0x01 0x03 0x09 98% -1 ?
1434
1435 2238<@jupet�kellari��> 1.16 1.2 0x03 0x00 0x00 0x01 100% -1 ? ilman verkkovirtaa
1436 2239<@jupet�kellari��> 1.16 1.2 0x03 0x01 0x00 0x01 99% -1 ? verkkovirralla
1437
1438 2240<@jupet�kellari��> 1.16 1.2 0x03 0x01 0x03 0x09 100% -1 ? verkkovirralla ja monitori p��ll�
1439 2241<@jupet�kellari��> 1.16 1.2 0x03 0x00 0x00 0x01 99% -1 ? monitori p��ll� mutta ilman verkkovirtaa
1440 */
1441
1442 /* Kapil Hari Paranjape <kapil@imsc.res.in>
1443   Linux 2.6.24 onwards battery info is in
1444   /sys/class/power_supply/BAT0/
1445   On my system I get the following.
1446         /sys/class/power_supply/BAT0/uevent:
1447         PHYSDEVPATH=/devices/LNXSYSTM:00/device:00/PNP0A03:00/device:01/PNP0C09:00/PNP0C0A:00
1448         PHYSDEVBUS=acpi
1449         PHYSDEVDRIVER=battery
1450         POWER_SUPPLY_NAME=BAT0
1451         POWER_SUPPLY_TYPE=Battery
1452         POWER_SUPPLY_STATUS=Discharging
1453         POWER_SUPPLY_PRESENT=1
1454         POWER_SUPPLY_TECHNOLOGY=Li-ion
1455         POWER_SUPPLY_VOLTAGE_MIN_DESIGN=10800000
1456         POWER_SUPPLY_VOLTAGE_NOW=10780000
1457         POWER_SUPPLY_CURRENT_NOW=13970000
1458         POWER_SUPPLY_ENERGY_FULL_DESIGN=47510000
1459         POWER_SUPPLY_ENERGY_FULL=27370000
1460         POWER_SUPPLY_ENERGY_NOW=11810000
1461         POWER_SUPPLY_MODEL_NAME=IBM-92P1060
1462         POWER_SUPPLY_MANUFACTURER=Panasonic
1463   On some systems POWER_SUPPLY_ENERGY_* is replaced by POWER_SUPPLY_CHARGE_*
1464 */
1465
1466 #define SYSFS_BATTERY_BASE_PATH "/sys/class/power_supply"
1467 #define ACPI_BATTERY_BASE_PATH "/proc/acpi/battery"
1468 #define APM_PATH "/proc/apm"
1469 #define MAX_BATTERY_COUNT 4
1470
1471 static FILE *sysfs_bat_fp[MAX_BATTERY_COUNT];
1472 static FILE *acpi_bat_fp[MAX_BATTERY_COUNT];
1473 static FILE *apm_bat_fp[MAX_BATTERY_COUNT];
1474
1475 static int batteries_initialized = 0;
1476 static char batteries[MAX_BATTERY_COUNT][32];
1477
1478 static int acpi_last_full[MAX_BATTERY_COUNT];
1479 static int acpi_design_capacity[MAX_BATTERY_COUNT];
1480
1481 /* e.g. "charging 75%" */
1482 static char last_battery_str[MAX_BATTERY_COUNT][64];
1483 /* e.g. "3h 15m" */
1484 static char last_battery_time_str[MAX_BATTERY_COUNT][64];
1485
1486 static double last_battery_time[MAX_BATTERY_COUNT];
1487
1488 static int last_battery_perct[MAX_BATTERY_COUNT];
1489 static double last_battery_perct_time[MAX_BATTERY_COUNT];
1490
1491 void init_batteries(void)
1492 {
1493         int idx;
1494
1495         if (batteries_initialized) {
1496                 return;
1497         }
1498         for (idx = 0; idx < MAX_BATTERY_COUNT; idx++) {
1499                 batteries[idx][0] = '\0';
1500         }
1501         batteries_initialized = 1;
1502 }
1503
1504 int get_battery_idx(const char *bat)
1505 {
1506         int idx;
1507
1508         for (idx = 0; idx < MAX_BATTERY_COUNT; idx++) {
1509                 if (!strlen(batteries[idx]) || !strcmp(batteries[idx], bat)) {
1510                         break;
1511                 }
1512         }
1513
1514         /* if not found, enter a new entry */
1515         if (!strlen(batteries[idx])) {
1516                 snprintf(batteries[idx], 31, "%s", bat);
1517         }
1518
1519         return idx;
1520 }
1521
1522 void get_battery_stuff(char *buf, unsigned int n, const char *bat, int item)
1523 {
1524         static int idx, rep = 0, rep2 = 0;
1525         char acpi_path[128];
1526
1527         snprintf(acpi_path, 127, ACPI_BATTERY_BASE_PATH "/%s/state", bat);
1528         char sysfs_path[128];
1529         snprintf(sysfs_path, 127, SYSFS_BATTERY_BASE_PATH "/%s/uevent", bat);
1530
1531         init_batteries();
1532
1533         idx = get_battery_idx(bat);
1534
1535         /* don't update battery too often */
1536         if (current_update_time - last_battery_time[idx] < 29.5) {
1537                 goto set_return_value;
1538         }
1539
1540         last_battery_time[idx] = current_update_time;
1541
1542         memset(last_battery_str[idx], 0, sizeof(last_battery_str[idx]));
1543         memset(last_battery_time_str[idx], 0, sizeof(last_battery_time_str[idx]));
1544
1545         /* first try SYSFS if that fails try ACPI */
1546
1547         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
1548                 sysfs_bat_fp[idx] = open_file(sysfs_path, &rep);
1549
1550         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
1551                 acpi_bat_fp[idx] = open_file(acpi_path, &rep);
1552
1553         if (sysfs_bat_fp[idx] != NULL) {
1554                 /* SYSFS */
1555                 int present_rate = -1;
1556                 int remaining_capacity = -1;
1557                 char charging_state[64];
1558                 char present[4];
1559
1560                 strcpy(charging_state, "Unknown");
1561
1562                 while (!feof(sysfs_bat_fp[idx])) {
1563                         char buf[256];
1564                         if (fgets(buf, 256, sysfs_bat_fp[idx]) == NULL)
1565                                 break;
1566
1567                         /* let's just hope units are ok */
1568                         if (strncmp (buf, "POWER_SUPPLY_PRESENT=1", 22) == 0)
1569                                 strcpy(present, "Yes");
1570                         else if (strncmp (buf, "POWER_SUPPLY_PRESENT=0", 22) == 0)
1571                                 strcpy(present, "No");
1572                         else if (strncmp (buf, "POWER_SUPPLY_STATUS=", 20) == 0)
1573                                 sscanf(buf, "POWER_SUPPLY_STATUS=%63s", charging_state);
1574                         /* present_rate is not the same as the
1575                         current flowing now but it is the same value
1576                         which was used in the past. so we continue
1577                         the tradition! */
1578                         else if (strncmp(buf, "POWER_SUPPLY_CURRENT_NOW=", 25) == 0)
1579                                 sscanf(buf, "POWER_SUPPLY_CURRENT_NOW=%d", &present_rate);
1580                         else if (strncmp(buf, "POWER_SUPPLY_ENERGY_NOW=", 24) == 0)
1581                                 sscanf(buf, "POWER_SUPPLY_ENERGY_NOW=%d", &remaining_capacity);
1582                         else if (strncmp(buf, "POWER_SUPPLY_ENERGY_FULL=", 25) == 0)
1583                                 sscanf(buf, "POWER_SUPPLY_ENERGY_FULL=%d", &acpi_last_full[idx]);
1584                         else if (strncmp(buf, "POWER_SUPPLY_CHARGE_NOW=", 24) == 0)
1585                                 sscanf(buf, "POWER_SUPPLY_CHARGE_NOW=%d", &remaining_capacity);
1586                         else if (strncmp(buf, "POWER_SUPPLY_CHARGE_FULL=", 25) == 0)
1587                                 sscanf(buf, "POWER_SUPPLY_CHARGE_FULL=%d", &acpi_last_full[idx]);
1588                 }
1589
1590                 fclose(sysfs_bat_fp[idx]);
1591                 sysfs_bat_fp[idx] = NULL;
1592
1593                 /* Hellf[i]re notes that remaining capacity can exceed acpi_last_full */
1594                 if (remaining_capacity > acpi_last_full[idx])
1595                         acpi_last_full[idx] = remaining_capacity;  /* normalize to 100% */
1596
1597                 /* not present */
1598                 if (strcmp(present, "No") == 0) {
1599                         strncpy(last_battery_str[idx], "not present", 64);
1600                 }
1601                 /* charging */
1602                 else if (strcmp(charging_state, "Charging") == 0) {
1603                         if (acpi_last_full[idx] != 0 && present_rate > 0) {
1604                                 /* e.g. charging 75% */
1605                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Charging %i%%",
1606                                         (int) (((float) remaining_capacity / acpi_last_full[idx]) * 100 ));
1607                                 /* e.g. 2h 37m */
1608                                 format_seconds(last_battery_time_str[idx], sizeof(last_battery_time_str[idx])-1,
1609                                               (long) (((float)(acpi_last_full[idx] - remaining_capacity) / present_rate) * 3600));
1610                         } else if (acpi_last_full[idx] != 0 && present_rate <= 0) {
1611                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Charging %d%%",
1612                                         (int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
1613                         } else {
1614                                 strncpy(last_battery_str[idx], "Charging", sizeof(last_battery_str[idx])-1);
1615                         }
1616                 }
1617                 /* discharging */
1618                 else if (strncmp(charging_state, "Discharging", 64) == 0) {
1619                         if (present_rate > 0) {
1620                                 /* e.g. discharging 35% */
1621                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Discharging %i%%",
1622                                         (int) (((float) remaining_capacity / acpi_last_full[idx]) * 100 ));
1623                                 /* e.g. 1h 12m */
1624                                 format_seconds(last_battery_time_str[idx], sizeof(last_battery_time_str[idx])-1,
1625                                               (long) (((float)(acpi_last_full[idx] - remaining_capacity) / present_rate) * 3600));
1626                         } else if (present_rate == 0) { /* Thanks to Nexox for this one */
1627                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1, "Full");
1628                         } else {
1629                                 snprintf(last_battery_str[idx], sizeof(last_battery_str[idx])-1,
1630                                         "Discharging %d%%",
1631                                         (int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
1632                         }
1633                 }
1634                 /* charged */
1635                 /* thanks to Lukas Zapletal <lzap@seznam.cz> */
1636                 else if (strncmp(charging_state, "Charged", 64) == 0) {
1637                                 /* Below happens with the second battery on my X40,
1638                                  * when the second one is empty and the first one
1639                                  * being charged. */
1640                                 if (remaining_capacity == 0)
1641                                         strcpy(last_battery_str[idx], "Empty");
1642                                 else
1643                                         strcpy(last_battery_str[idx], "Charged");
1644                 }
1645                 /* unknown, probably full / AC */
1646                 else {
1647                         if (acpi_last_full[idx] != 0
1648                             && remaining_capacity != acpi_last_full[idx])
1649                                 snprintf(last_battery_str[idx], 64, "Unknown %d%%",
1650                                         (int) (((float)remaining_capacity / acpi_last_full[idx]) * 100));
1651                         else
1652                                 strncpy(last_battery_str[idx], "AC", 64);
1653                 }
1654         } else if (acpi_bat_fp[idx] != NULL) {
1655                 /* ACPI */
1656                 int present_rate = -1;
1657                 int remaining_capacity = -1;
1658                 char charging_state[64];
1659                 char present[4];
1660
1661                 /* read last full capacity if it's zero */
1662                 if (acpi_last_full[idx] == 0) {
1663                         static int rep = 0;
1664                         char path[128];
1665                         FILE *fp;
1666
1667                         snprintf(path, 127, ACPI_BATTERY_BASE_PATH "/%s/info", bat);
1668                         fp = open_file(path, &rep);
1669                         if (fp != NULL) {
1670                                 while (!feof(fp)) {
1671                                         char b[256];
1672
1673                                         if (fgets(b, 256, fp) == NULL) {
1674                                                 break;
1675                                         }
1676                                         if (sscanf(b, "last full capacity: %d",
1677                                                         &acpi_last_full[idx]) != 0) {
1678                                                 break;
1679                                         }
1680                                 }
1681
1682                                 fclose(fp);
1683                         }
1684                 }
1685
1686                 fseek(acpi_bat_fp[idx], 0, SEEK_SET);
1687
1688                 strcpy(charging_state, "unknown");
1689
1690                 while (!feof(acpi_bat_fp[idx])) {
1691                         char buf[256];
1692
1693                         if (fgets(buf, 256, acpi_bat_fp[idx]) == NULL) {
1694                                 break;
1695                         }
1696
1697                         /* let's just hope units are ok */
1698                         if (strncmp(buf, "present:", 8) == 0) {
1699                                 sscanf(buf, "present: %4s", present);
1700                         } else if (strncmp(buf, "charging state:", 15) == 0) {
1701                                 sscanf(buf, "charging state: %63s", charging_state);
1702                         } else if (strncmp(buf, "present rate:", 13) == 0) {
1703                                 sscanf(buf, "present rate: %d", &present_rate);
1704                         } else if (strncmp(buf, "remaining capacity:", 19) == 0) {
1705                                 sscanf(buf, "remaining capacity: %d", &remaining_capacity);
1706                         }
1707                 }
1708                 /* Hellf[i]re notes that remaining capacity can exceed acpi_last_full */
1709                 if (remaining_capacity > acpi_last_full[idx]) {
1710                         /* normalize to 100% */
1711                         acpi_last_full[idx] = remaining_capacity;
1712                 }
1713
1714                 /* not present */
1715                 if (strcmp(present, "no") == 0) {
1716                         strncpy(last_battery_str[idx], "not present", 64);
1717                 /* charging */
1718                 } else if (strcmp(charging_state, "charging") == 0) {
1719                         if (acpi_last_full[idx] != 0 && present_rate > 0) {
1720                                 /* e.g. charging 75% */
1721                                 snprintf(last_battery_str[idx],
1722                                         sizeof(last_battery_str[idx]) - 1, "charging %i%%",
1723                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1724                                 /* e.g. 2h 37m */
1725                                 format_seconds(last_battery_time_str[idx],
1726                                         sizeof(last_battery_time_str[idx]) - 1,
1727                                         (long) (((acpi_last_full[idx] - remaining_capacity) *
1728                                         3600) / present_rate));
1729                         } else if (acpi_last_full[idx] != 0 && present_rate <= 0) {
1730                                 snprintf(last_battery_str[idx],
1731                                         sizeof(last_battery_str[idx]) - 1, "charging %d%%",
1732                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1733                         } else {
1734                                 strncpy(last_battery_str[idx], "charging",
1735                                         sizeof(last_battery_str[idx]) - 1);
1736                         }
1737                 /* discharging */
1738                 } else if (strncmp(charging_state, "discharging", 64) == 0) {
1739                         if (present_rate > 0) {
1740                                 /* e.g. discharging 35% */
1741                                 snprintf(last_battery_str[idx],
1742                                         sizeof(last_battery_str[idx]) - 1, "discharging %i%%",
1743                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1744                                 /* e.g. 1h 12m */
1745                                 format_seconds(last_battery_time_str[idx],
1746                                         sizeof(last_battery_time_str[idx]) - 1,
1747                                         (long) ((remaining_capacity * 3600) / present_rate));
1748                         } else if (present_rate == 0) { /* Thanks to Nexox for this one */
1749                                 snprintf(last_battery_str[idx],
1750                                         sizeof(last_battery_str[idx]) - 1, "full");
1751                         } else {
1752                                 snprintf(last_battery_str[idx],
1753                                         sizeof(last_battery_str[idx]) - 1, "discharging %d%%",
1754                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1755                         }
1756                 /* charged */
1757                 } else if (strncmp(charging_state, "charged", 64) == 0) {
1758                         /* thanks to Lukas Zapletal <lzap@seznam.cz> */
1759                         /* Below happens with the second battery on my X40,
1760                          * when the second one is empty and the first one being charged. */
1761                         if (remaining_capacity == 0) {
1762                                 strcpy(last_battery_str[idx], "empty");
1763                         } else {
1764                                 strcpy(last_battery_str[idx], "charged");
1765                         }
1766                 /* unknown, probably full / AC */
1767                 } else {
1768                         if (acpi_last_full[idx] != 0
1769                                         && remaining_capacity != acpi_last_full[idx]) {
1770                                 snprintf(last_battery_str[idx], 64, "unknown %d%%",
1771                                         (int) ((remaining_capacity * 100) / acpi_last_full[idx]));
1772                         } else {
1773                                 strncpy(last_battery_str[idx], "AC", 64);
1774                         }
1775                 }
1776         } else {
1777                 /* APM */
1778                 if (apm_bat_fp[idx] == NULL) {
1779                         apm_bat_fp[idx] = open_file(APM_PATH, &rep2);
1780                 }
1781
1782                 if (apm_bat_fp[idx] != NULL) {
1783                         int ac, status, flag, life;
1784
1785                         fscanf(apm_bat_fp[idx], "%*s %*s %*x %x   %x       %x     %d%%",
1786                                 &ac, &status, &flag, &life);
1787
1788                         if (life == -1) {
1789                                 /* could check now that there is ac */
1790                                 snprintf(last_battery_str[idx], 64, "AC");
1791
1792                         /* could check that status == 3 here? */
1793                         } else if (ac && life != 100) {
1794                                 snprintf(last_battery_str[idx], 64, "charging %d%%", life);
1795                         } else {
1796                                 snprintf(last_battery_str[idx], 64, "%d%%", life);
1797                         }
1798
1799                         /* it seemed to buffer it so file must be closed (or could use
1800                          * syscalls directly but I don't feel like coding it now) */
1801                         fclose(apm_bat_fp[idx]);
1802                         apm_bat_fp[idx] = NULL;
1803                 }
1804         }
1805
1806 set_return_value:
1807         switch (item) {
1808                 case BATTERY_STATUS:
1809                         snprintf(buf, n, "%s", last_battery_str[idx]);
1810                         break;
1811                 case BATTERY_TIME:
1812                         snprintf(buf, n, "%s", last_battery_time_str[idx]);
1813                         break;
1814                 default:
1815                         break;
1816         }
1817 }
1818
1819 int get_battery_perct(const char *bat)
1820 {
1821         static int rep;
1822         int idx;
1823         char acpi_path[128];
1824
1825         snprintf(acpi_path, 127, ACPI_BATTERY_BASE_PATH "/%s/state", bat);
1826         char sysfs_path[128];
1827         snprintf(sysfs_path, 127, SYSFS_BATTERY_BASE_PATH "/%s/uevent", bat);
1828
1829         init_batteries();
1830
1831         idx = get_battery_idx(bat);
1832
1833         /* don't update battery too often */
1834         if (current_update_time - last_battery_perct_time[idx] < 30) {
1835                 return last_battery_perct[idx];
1836         }
1837         last_battery_perct_time[idx] = current_update_time;
1838
1839         /* Only check for SYSFS or ACPI */
1840
1841         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
1842                 sysfs_bat_fp[idx] = open_file(sysfs_path, &rep);
1843
1844         if (sysfs_bat_fp[idx] == NULL && acpi_bat_fp[idx] == NULL && apm_bat_fp[idx] == NULL)
1845                 acpi_bat_fp[idx] = open_file(acpi_path, &rep);
1846
1847         int remaining_capacity = -1;
1848
1849         if (sysfs_bat_fp[idx] != NULL) {
1850                 /* SYSFS */
1851                 while (!feof(sysfs_bat_fp[idx])) {
1852                         char buf[256];
1853                         if (fgets(buf, 256, sysfs_bat_fp[idx]) == NULL)
1854                                 break;
1855
1856                         if (strncmp(buf, "POWER_SUPPLY_CHARGE_NOW=", 24) == 0) {
1857                                 sscanf(buf, "POWER_SUPPLY_CHARGE_NOW=%d", &remaining_capacity);
1858                         } else if (strncmp(buf, "POWER_SUPPLY_CHARGE_FULL=",25) == 0) {
1859                                 sscanf(buf, "POWER_SUPPLY_CHARGE_FULL=%d", &acpi_design_capacity[idx]);
1860                         } else if (strncmp(buf, "POWER_SUPPLY_ENERGY_NOW=", 24) == 0) {
1861                                 sscanf(buf, "POWER_SUPPLY_ENERGY_NOW=%d", &remaining_capacity);
1862                         } else if (strncmp(buf, "POWER_SUPPLY_ENERGY_FULL=",25) == 0) {
1863                                 sscanf(buf, "POWER_SUPPLY_ENERGY_FULL=%d", &acpi_design_capacity[idx]);
1864                         }
1865                 }
1866
1867                 fclose(sysfs_bat_fp[idx]);
1868                 sysfs_bat_fp[idx] = NULL;
1869
1870         } else if (acpi_bat_fp[idx] != NULL) {
1871                 /* ACPI */
1872                 /* read last full capacity if it's zero */
1873                 if (acpi_design_capacity[idx] == 0) {
1874                         static int rep;
1875                         char path[128];
1876                         FILE *fp;
1877
1878                         snprintf(path, 127, ACPI_BATTERY_BASE_PATH "/%s/info", bat);
1879                         fp = open_file(path, &rep);
1880                         if (fp != NULL) {
1881                                 while (!feof(fp)) {
1882                                         char b[256];
1883
1884                                         if (fgets(b, 256, fp) == NULL) {
1885                                                 break;
1886                                         }
1887                                         if (sscanf(b, "last full capacity: %d",
1888                                                                 &acpi_design_capacity[idx]) != 0) {
1889                                                 break;
1890                                         }
1891                                 }
1892                                 fclose(fp);
1893                         }
1894                 }
1895
1896                 fseek(acpi_bat_fp[idx], 0, SEEK_SET);
1897
1898                 while (!feof(acpi_bat_fp[idx])) {
1899                         char buf[256];
1900
1901                         if (fgets(buf, 256, acpi_bat_fp[idx]) == NULL) {
1902                                 break;
1903                         }
1904
1905                         if (buf[0] == 'r') {
1906                                 sscanf(buf, "remaining capacity: %d", &remaining_capacity);
1907                         }
1908                 }
1909         }
1910         if (remaining_capacity < 0) {
1911                 return 0;
1912         }
1913         /* compute the battery percentage */
1914         last_battery_perct[idx] =
1915                 (int) (((float) remaining_capacity / acpi_design_capacity[idx]) * 100);
1916         return last_battery_perct[idx];
1917 }
1918
1919 int get_battery_perct_bar(const char *bar)
1920 {
1921         int idx;
1922
1923         get_battery_perct(bar);
1924         idx = get_battery_idx(bar);
1925         return (int) (last_battery_perct[idx] * 2.56 - 1);
1926 }
1927
1928 /* On Apple powerbook and ibook:
1929 $ cat /proc/pmu/battery_0
1930 flags      : 00000013
1931 charge     : 3623
1932 max_charge : 3720
1933 current    : 388
1934 voltage    : 16787
1935 time rem.  : 900
1936 $ cat /proc/pmu/info
1937 PMU driver version     : 2
1938 PMU firmware version   : 0c
1939 AC Power               : 1
1940 Battery count          : 1
1941 */
1942
1943 /* defines as in <linux/pmu.h> */
1944 #define PMU_BATT_PRESENT                0x00000001
1945 #define PMU_BATT_CHARGING               0x00000002
1946
1947 static FILE *pmu_battery_fp;
1948 static FILE *pmu_info_fp;
1949 static char pb_battery_info[3][32];
1950 static double pb_battery_info_update;
1951
1952 #define PMU_PATH "/proc/pmu"
1953 void get_powerbook_batt_info(char *buf, size_t n, int i)
1954 {
1955         static int rep = 0;
1956         const char *batt_path = PMU_PATH "/battery_0";
1957         const char *info_path = PMU_PATH "/info";
1958         int flags, charge, max_charge, ac = -1;
1959         long time = -1;
1960
1961         /* don't update battery too often */
1962         if (current_update_time - pb_battery_info_update < 29.5) {
1963                 snprintf(buf, n, "%s", pb_battery_info[i]);
1964                 return;
1965         }
1966         pb_battery_info_update = current_update_time;
1967
1968         if (pmu_battery_fp == NULL) {
1969                 pmu_battery_fp = open_file(batt_path, &rep);
1970         }
1971
1972         if (pmu_battery_fp != NULL) {
1973                 rewind(pmu_battery_fp);
1974                 while (!feof(pmu_battery_fp)) {
1975                         char buf[32];
1976
1977                         if (fgets(buf, sizeof(buf), pmu_battery_fp) == NULL) {
1978                                 break;
1979                         }
1980
1981                         if (buf[0] == 'f') {
1982                                 sscanf(buf, "flags      : %8x", &flags);
1983                         } else if (buf[0] == 'c' && buf[1] == 'h') {
1984                                 sscanf(buf, "charge     : %d", &charge);
1985                         } else if (buf[0] == 'm') {
1986                                 sscanf(buf, "max_charge : %d", &max_charge);
1987                         } else if (buf[0] == 't') {
1988                                 sscanf(buf, "time rem.  : %ld", &time);
1989                         }
1990                 }
1991         }
1992         if (pmu_info_fp == NULL) {
1993                 pmu_info_fp = open_file(info_path, &rep);
1994         }
1995
1996         if (pmu_info_fp != NULL) {
1997                 rewind(pmu_info_fp);
1998                 while (!feof(pmu_info_fp)) {
1999                         char buf[32];
2000
2001                         if (fgets(buf, sizeof(buf), pmu_info_fp) == NULL) {
2002                                 break;
2003                         }
2004                         if (buf[0] == 'A') {
2005                                 sscanf(buf, "AC Power               : %d", &ac);
2006                         }
2007                 }
2008         }
2009         /* update status string */
2010         if ((ac && !(flags & PMU_BATT_PRESENT))) {
2011                 strcpy(pb_battery_info[PB_BATT_STATUS], "AC");
2012         } else if (ac && (flags & PMU_BATT_PRESENT)
2013                         && !(flags & PMU_BATT_CHARGING)) {
2014                 strcpy(pb_battery_info[PB_BATT_STATUS], "charged");
2015         } else if ((flags & PMU_BATT_PRESENT) && (flags & PMU_BATT_CHARGING)) {
2016                 strcpy(pb_battery_info[PB_BATT_STATUS], "charging");
2017         } else {
2018                 strcpy(pb_battery_info[PB_BATT_STATUS], "discharging");
2019         }
2020
2021         /* update percentage string */
2022         if (time == 0) {
2023                 pb_battery_info[PB_BATT_PERCENT][0] = 0;
2024         } else {
2025                 snprintf(pb_battery_info[PB_BATT_PERCENT],
2026                         sizeof(pb_battery_info[PB_BATT_PERCENT]), "%d%%",
2027                         (charge * 100) / max_charge);
2028         }
2029
2030         /* update time string */
2031         if (time == 0) {                        /* fully charged or battery not present */
2032                 pb_battery_info[PB_BATT_TIME][0] = 0;
2033         } else if (time < 60 * 60) {    /* don't show secs */
2034                 format_seconds_short(pb_battery_info[PB_BATT_TIME],
2035                         sizeof(pb_battery_info[PB_BATT_TIME]), time);
2036         } else {
2037                 format_seconds(pb_battery_info[PB_BATT_TIME],
2038                         sizeof(pb_battery_info[PB_BATT_TIME]), time);
2039         }
2040
2041         snprintf(buf, n, "%s", pb_battery_info[i]);
2042 }
2043
2044 void update_top()
2045 {
2046         show_nice_processes = 1;
2047         process_find_top(info.cpu, info.memu);
2048         info.first_process = get_first_process();
2049 }
2050
2051 /* The following ifdefs were adapted from gkrellm */
2052 #include <linux/major.h>
2053
2054 #if !defined(MD_MAJOR)
2055 #define MD_MAJOR 9
2056 #endif
2057
2058 #if !defined(LVM_BLK_MAJOR)
2059 #define LVM_BLK_MAJOR 58
2060 #endif
2061
2062 #if !defined(NBD_MAJOR)
2063 #define NBD_MAJOR 43
2064 #endif
2065
2066 void update_diskio()
2067 {
2068         static unsigned int last = UINT_MAX;
2069         static unsigned int last_read = UINT_MAX;
2070         static unsigned int last_write = UINT_MAX;
2071         FILE *fp;
2072         static int rep = 0;
2073
2074         char buf[512], devbuf[64];
2075         int major, minor, i;
2076         unsigned int current = 0;
2077         unsigned int current_read = 0;
2078         unsigned int current_write = 0;
2079         unsigned int reads, writes = 0;
2080         int col_count = 0;
2081
2082         if (!(fp = open_file("/proc/diskstats", &rep))) {
2083                 diskio_value = 0;
2084                 return;
2085         }
2086
2087         /* read reads and writes from all disks (minor = 0), including cd-roms
2088          * and floppies, and sum them up */
2089         while (!feof(fp)) {
2090                 fgets(buf, 512, fp);
2091                 col_count = sscanf(buf, "%u %u %s %*u %*u %u %*u %*u %*u %u", &major,
2092                         &minor, devbuf, &reads, &writes);
2093                 /* ignore subdevices (they have only 3 matching entries in their line)
2094                  * and virtual devices (LVM, network block devices, RAM disks, Loopback)
2095                  *
2096                  * XXX: ignore devices which are part of a SW RAID (MD_MAJOR) */
2097                 if (col_count == 5 && major != LVM_BLK_MAJOR && major != NBD_MAJOR
2098                                 && major != RAMDISK_MAJOR && major != LOOP_MAJOR) {
2099                         current += reads + writes;
2100                         current_read += reads;
2101                         current_write += writes;
2102                 } else {
2103                         col_count = sscanf(buf, "%u %u %s %*u %u %*u %u",
2104                                 &major, &minor, devbuf, &reads, &writes);
2105                         if (col_count != 5) {
2106                                 continue;
2107                         }
2108                 }
2109                 for (i = 0; i < MAX_DISKIO_STATS; i++) {
2110                         if (diskio_stats[i].dev &&
2111                                         strcmp(devbuf, diskio_stats[i].dev) == 0) {
2112                                 diskio_stats[i].current =
2113                                         (reads + writes - diskio_stats[i].last) / 2;
2114                                 diskio_stats[i].current_read =
2115                                         (reads - diskio_stats[i].last_read) / 2;
2116                                 diskio_stats[i].current_write =
2117                                         (writes - diskio_stats[i].last_write) / 2;
2118                                 if (reads + writes < diskio_stats[i].last) {
2119                                         diskio_stats[i].current = 0;
2120                                 }
2121                                 if (reads < diskio_stats[i].last_read) {
2122                                         diskio_stats[i].current_read = 0;
2123                                         diskio_stats[i].current = diskio_stats[i].current_write;
2124                                 }
2125                                 if (writes < diskio_stats[i].last_write) {
2126                                         diskio_stats[i].current_write = 0;
2127                                         diskio_stats[i].current = diskio_stats[i].current_read;
2128                                 }
2129                                 diskio_stats[i].last = reads + writes;
2130                                 diskio_stats[i].last_read = reads;
2131                                 diskio_stats[i].last_write = writes;
2132                         }
2133                 }
2134         }
2135
2136         /* since the values in /proc/diststats are absolute, we have to substract
2137          * our last reading. The numbers stand for "sectors read", and we therefore
2138          * have to divide by two to get KB */
2139         int tot = ((double) (current - last) / 2);
2140         int tot_read = ((double) (current_read - last_read) / 2);
2141         int tot_write = ((double) (current_write - last_write) / 2);
2142
2143         if (last_read > current_read) {
2144                 tot_read = 0;
2145         }
2146         if (last_write > current_write) {
2147                 tot_write = 0;
2148         }
2149
2150         if (last > current) {
2151                 /* we hit this either if it's the very first time we run this, or
2152                  * when /proc/diskstats overflows; while 0 is not correct, it's at
2153                  * least not way off */
2154                 tot = 0;
2155         }
2156         last = current;
2157         last_read = current_read;
2158         last_write = current_write;
2159
2160         diskio_value = tot;
2161         diskio_read_value = tot_read;
2162         diskio_write_value = tot_write;
2163
2164         fclose(fp);
2165 }
2166
2167 /* Here come the IBM ACPI-specific things. For reference, see
2168  * http://ibm-acpi.sourceforge.net/README
2169  * If IBM ACPI is installed, /proc/acpi/ibm contains the following files:
2170 bay
2171 beep
2172 bluetooth
2173 brightness
2174 cmos
2175 dock
2176 driver
2177 ecdump
2178 fan
2179 hotkey
2180 led
2181 light
2182 thermal
2183 video
2184 volume
2185  * The content of these files is described in detail in the aforementioned
2186  * README - some of them also in the following functions accessing them.
2187  * Peter Tarjan (ptarjan@citromail.hu) */
2188
2189 #define IBM_ACPI_DIR "/proc/acpi/ibm"
2190
2191 /* get fan speed on IBM/Lenovo laptops running the ibm acpi.
2192  * /proc/acpi/ibm/fan looks like this (3 lines):
2193 status:         disabled
2194 speed:          2944
2195 commands:       enable, disable
2196  * Peter Tarjan (ptarjan@citromail.hu) */
2197
2198 void get_ibm_acpi_fan(char *p_client_buffer, size_t client_buffer_size)
2199 {
2200         if (!p_client_buffer || client_buffer_size <= 0) {
2201                 return;
2202         }
2203
2204         FILE *fp;
2205         unsigned int speed = 0;
2206         char fan[128];
2207
2208         snprintf(fan, 127, "%s/fan", IBM_ACPI_DIR);
2209
2210         fp = fopen(fan, "r");
2211         if (fp != NULL) {
2212                 while (!feof(fp)) {
2213                         char line[256];
2214
2215                         if (fgets(line, 255, fp) == NULL) {
2216                                 break;
2217                         }
2218                         if (sscanf(line, "speed: %d", &speed)) {
2219                                 break;
2220                         }
2221                 }
2222         } else {
2223                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2224                         "ibm* from your Conky config file.", fan, strerror(errno));
2225         }
2226
2227         fclose(fp);
2228         snprintf(p_client_buffer, client_buffer_size, "%d", speed);
2229 }
2230
2231 /* get the measured temperatures from the temperature sensors
2232  * on IBM/Lenovo laptops running the ibm acpi.
2233  * There are 8 values in /proc/acpi/ibm/thermal, and according to
2234  * http://ibm-acpi.sourceforge.net/README
2235  * these mean the following (at least on an IBM R51...)
2236  * 0:  CPU (also on the T series laptops)
2237  * 1:  Mini PCI Module (?)
2238  * 2:  HDD (?)
2239  * 3:  GPU (also on the T series laptops)
2240  * 4:  Battery (?)
2241  * 5:  N/A
2242  * 6:  Battery (?)
2243  * 7:  N/A
2244  * I'm not too sure about those with the question mark, but the values I'm
2245  * reading from *my* thermal file (on a T42p) look realistic for the
2246  * hdd and the battery.
2247  * #5 and #7 are always -128.
2248  * /proc/acpi/ibm/thermal looks like this (1 line):
2249 temperatures:   41 43 31 46 33 -128 29 -128
2250  * Peter Tarjan (ptarjan@citromail.hu) */
2251
2252 static double last_ibm_acpi_temp_time;
2253 void get_ibm_acpi_temps()
2254 {
2255
2256         /* don't update too often */
2257         if (current_update_time - last_ibm_acpi_temp_time < 10.00) {
2258                 return;
2259         }
2260         last_ibm_acpi_temp_time = current_update_time;
2261
2262         /* if (!p_client_buffer || client_buffer_size <= 0) {
2263                 return;
2264         } */
2265
2266         FILE *fp;
2267
2268         char thermal[128];
2269
2270         snprintf(thermal, 127, "%s/thermal", IBM_ACPI_DIR);
2271         fp = fopen(thermal, "r");
2272
2273         if (fp != NULL) {
2274                 while (!feof(fp)) {
2275                         char line[256];
2276
2277                         if (fgets(line, 255, fp) == NULL) {
2278                                 break;
2279                         }
2280                         if (sscanf(line, "temperatures: %d %d %d %d %d %d %d %d",
2281                                         &ibm_acpi.temps[0], &ibm_acpi.temps[1], &ibm_acpi.temps[2],
2282                                         &ibm_acpi.temps[3], &ibm_acpi.temps[4], &ibm_acpi.temps[5],
2283                                         &ibm_acpi.temps[6], &ibm_acpi.temps[7])) {
2284                                 break;
2285                         }
2286                 }
2287         } else {
2288                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2289                         "ibm* from your Conky config file.", thermal, strerror(errno));
2290         }
2291
2292         fclose(fp);
2293 }
2294
2295 /* get volume (0-14) on IBM/Lenovo laptops running the ibm acpi.
2296  * "Volume" here is none of the mixer volumes, but a "master of masters"
2297  * volume adjusted by the IBM volume keys.
2298  * /proc/acpi/ibm/fan looks like this (4 lines):
2299 level:          4
2300 mute:           off
2301 commands:       up, down, mute
2302 commands:       level <level> (<level> is 0-15)
2303  * Peter Tarjan (ptarjan@citromail.hu) */
2304
2305 void get_ibm_acpi_volume(char *p_client_buffer, size_t client_buffer_size)
2306 {
2307         if (!p_client_buffer || client_buffer_size <= 0) {
2308                 return;
2309         }
2310
2311         FILE *fp;
2312
2313         char volume[128];
2314
2315         snprintf(volume, 127, "%s/volume", IBM_ACPI_DIR);
2316         unsigned int vol = -1;
2317         char mute[3] = "";
2318
2319         fp = fopen(volume, "r");
2320         if (fp != NULL) {
2321                 while (!feof(fp)) {
2322                         char line[256];
2323                         unsigned int read_vol = -1;
2324
2325                         if (fgets(line, 255, fp) == NULL) {
2326                                 break;
2327                         }
2328                         if (sscanf(line, "level: %d", &read_vol)) {
2329                                 vol = read_vol;
2330                                 continue;
2331                         }
2332                         if (sscanf(line, "mute: %s", mute)) {
2333                                 break;
2334                         }
2335                 }
2336         } else {
2337                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2338                         "ibm* from your Conky config file.", volume, strerror(errno));
2339         }
2340
2341         fclose(fp);
2342
2343         if (strcmp(mute, "on") == 0) {
2344                 snprintf(p_client_buffer, client_buffer_size, "%s", "mute");
2345                 return;
2346         } else {
2347                 snprintf(p_client_buffer, client_buffer_size, "%d", vol);
2348                 return;
2349         }
2350 }
2351
2352 /* static FILE *fp = NULL; */
2353
2354 /* get LCD brightness on IBM/Lenovo laptops running the ibm acpi.
2355  * /proc/acpi/ibm/brightness looks like this (3 lines):
2356 level:          7
2357 commands:       up, down
2358 commands:       level <level> (<level> is 0-7)
2359  * Peter Tarjan (ptarjan@citromail.hu) */
2360
2361 void get_ibm_acpi_brightness(char *p_client_buffer, size_t client_buffer_size)
2362 {
2363         if (!p_client_buffer || client_buffer_size <= 0) {
2364                 return;
2365         }
2366
2367         FILE *fp;
2368         unsigned int brightness = 0;
2369         char filename[128];
2370
2371         snprintf(filename, 127, "%s/brightness", IBM_ACPI_DIR);
2372
2373         fp = fopen(filename, "r");
2374         if (fp != NULL) {
2375                 while (!feof(fp)) {
2376                         char line[256];
2377
2378                         if (fgets(line, 255, fp) == NULL) {
2379                                 break;
2380                         }
2381                         if (sscanf(line, "level: %d", &brightness)) {
2382                                 break;
2383                         }
2384                 }
2385         } else {
2386                 CRIT_ERR("can't open '%s': %s\nYou are not using the IBM ACPI. Remove "
2387                         "ibm* from your Conky config file.", filename, strerror(errno));
2388         }
2389
2390         fclose(fp);
2391
2392         snprintf(p_client_buffer, client_buffer_size, "%d", brightness);
2393 }
2394
2395 void update_entropy(void)
2396 {
2397         static int rep = 0;
2398         const char *entropy_avail = "/proc/sys/kernel/random/entropy_avail";
2399         const char *entropy_poolsize = "/proc/sys/kernel/random/poolsize";
2400         FILE *fp1, *fp2;
2401
2402         info.entropy.entropy_avail = 0;
2403         info.entropy.poolsize = 0;
2404
2405         if ((fp1 = open_file(entropy_avail, &rep)) == NULL) {
2406                 return;
2407         }
2408
2409         if ((fp2 = open_file(entropy_poolsize, &rep)) == NULL) {
2410                 fclose(fp1);
2411                 return;
2412         }
2413
2414         fscanf(fp1, "%u", &info.entropy.entropy_avail);
2415         fscanf(fp2, "%u", &info.entropy.poolsize);
2416
2417         fclose(fp1);
2418         fclose(fp2);
2419
2420         info.mask |= (1 << INFO_ENTROPY);
2421 }
2422
2423 char *get_disk_protect_queue(char *disk)
2424 {
2425         FILE *fp;
2426         char path[128];
2427         int state;
2428
2429         snprintf(path, 127, "/sys/block/%s/queue/protect", disk);
2430         if ((fp = fopen(path, "r")) == NULL)
2431                 return "n/a   ";
2432         if (fscanf(fp, "%d\n", &state) != 1) {
2433                 fclose(fp);
2434                 return "failed";
2435         }
2436         fclose(fp);
2437         return state ? "frozen" : "free  ";
2438 }
2439