top: correct a small typo in manual page
[procps:procps.git] / proc / sysinfo.c
1 /*
2  * File for parsing top-level /proc entities.
3  * Copyright (C) 1992-1998 by Michael K. Johnson, johnsonm@redhat.com
4  * Copyright 1998-2003 Albert Cahalan
5  * June 2003, Fabian Frederick, disk and slab info
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #include <stdbool.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <locale.h>
28
29 #include <unistd.h>
30 #include <fcntl.h>
31 #include "alloc.h"
32 #include "version.h"
33 #include "sysinfo.h" /* include self to verify prototypes */
34
35 #ifndef HZ
36 #include <netinet/in.h>  /* htons */
37 #endif
38
39 long smp_num_cpus;     /* number of CPUs */
40 long page_bytes;       /* this architecture's page size */
41
42 #define BAD_OPEN_MESSAGE                                        \
43 "Error: /proc must be mounted\n"                                \
44 "  To mount /proc at boot you need an /etc/fstab line like:\n"  \
45 "      proc   /proc   proc    defaults\n"                       \
46 "  In the meantime, run \"mount proc /proc -t proc\"\n"
47
48 #define STAT_FILE    "/proc/stat"
49 static int stat_fd = -1;
50 #define UPTIME_FILE  "/proc/uptime"
51 static int uptime_fd = -1;
52 #define LOADAVG_FILE "/proc/loadavg"
53 static int loadavg_fd = -1;
54 #define MEMINFO_FILE "/proc/meminfo"
55 static int meminfo_fd = -1;
56 #define VMINFO_FILE "/proc/vmstat"
57 static int vminfo_fd = -1;
58 #define VM_MIN_FREE_FILE "/proc/sys/vm/min_free_kbytes"
59 static int vm_min_free_fd = -1;
60
61 // As of 2.6.24 /proc/meminfo seems to need 888 on 64-bit,
62 // and would need 1258 if the obsolete fields were there.
63 // As of 3.13 /proc/vmstat needs 2623,
64 // and /proc/stat needs 3076.
65 static char buf[8192];
66
67 /* This macro opens filename only if necessary and seeks to 0 so
68  * that successive calls to the functions are more efficient.
69  * It also reads the current contents of the file into the global buf.
70  */
71 #define FILE_TO_BUF(filename, fd) do{                           \
72     static int local_n;                                         \
73     if (fd == -1 && (fd = open(filename, O_RDONLY)) == -1) {    \
74         fputs(BAD_OPEN_MESSAGE, stderr);                        \
75         fflush(NULL);                                           \
76         _exit(102);                                             \
77     }                                                           \
78     lseek(fd, 0L, SEEK_SET);                                    \
79     if ((local_n = read(fd, buf, sizeof buf - 1)) < 0) {        \
80         perror(filename);                                       \
81         fflush(NULL);                                           \
82         _exit(103);                                             \
83     }                                                           \
84     buf[local_n] = '\0';                                        \
85 }while(0)
86
87 /* evals 'x' twice */
88 #define SET_IF_DESIRED(x,y) do{  if(x) *(x) = (y); }while(0)
89
90 /* return minimum of two values */
91 #define MIN(x,y) ((x) < (y) ? (x) : (y))
92
93 /***********************************************************************/
94 int uptime(double *restrict uptime_secs, double *restrict idle_secs) {
95     double up=0, idle=0;
96     char *savelocale;
97
98     FILE_TO_BUF(UPTIME_FILE,uptime_fd);
99     savelocale = strdup(setlocale(LC_NUMERIC, NULL));
100     setlocale(LC_NUMERIC,"C");
101     if (sscanf(buf, "%lf %lf", &up, &idle) < 2) {
102         setlocale(LC_NUMERIC,savelocale);
103         free(savelocale);
104         fputs("bad data in " UPTIME_FILE "\n", stderr);
105             return 0;
106     }
107     setlocale(LC_NUMERIC,savelocale);
108     free(savelocale);
109     SET_IF_DESIRED(uptime_secs, up);
110     SET_IF_DESIRED(idle_secs, idle);
111     return up;  /* assume never be zero seconds in practice */
112 }
113
114 unsigned long getbtime(void) {
115     static unsigned long btime = 0;
116     bool found_btime = false;
117     FILE *f;
118
119     if (btime)
120         return btime;
121
122     /* /proc/stat can get very large on multi-CPU systems so we
123        can't use FILE_TO_BUF */
124     if (!(f = fopen(STAT_FILE, "r"))) {
125         fputs(BAD_OPEN_MESSAGE, stderr);
126         fflush(NULL);
127         _exit(102);
128     }
129
130     while ((fgets(buf, sizeof buf, f))) {
131         if (sscanf(buf, "btime %lu", &btime) == 1) {
132             found_btime = true;
133             break;
134         }
135     }
136     fclose(f);
137
138     if (!found_btime) {
139         fputs("missing btime in " STAT_FILE "\n", stderr);
140         exit(1);
141     }
142
143     return btime;
144 }
145
146 /***********************************************************************
147  * Some values in /proc are expressed in units of 1/HZ seconds, where HZ
148  * is the kernel clock tick rate. One of these units is called a jiffy.
149  * The HZ value used in the kernel may vary according to hacker desire.
150  * According to Linus Torvalds, this is not true. He considers the values
151  * in /proc as being in architecture-dependent units that have no relation
152  * to the kernel clock tick rate. Examination of the kernel source code
153  * reveals that opinion as wishful thinking.
154  *
155  * In any case, we need the HZ constant as used in /proc. (the real HZ value
156  * may differ, but we don't care) There are several ways we could get HZ:
157  *
158  * 1. Include the kernel header file. If it changes, recompile this library.
159  * 2. Use the sysconf() function. When HZ changes, recompile the C library!
160  * 3. Ask the kernel. This is obviously correct...
161  *
162  * Linus Torvalds won't let us ask the kernel, because he thinks we should
163  * not know the HZ value. Oh well, we don't have to listen to him.
164  * Someone smuggled out the HZ value. :-)
165  *
166  * This code should work fine, even if Linus fixes the kernel to match his
167  * stated behavior. The code only fails in case of a partial conversion.
168  *
169  * Recent update: on some architectures, the 2.4 kernel provides an
170  * ELF note to indicate HZ. This may be for ARM or user-mode Linux
171  * support. This ought to be investigated. Note that sysconf() is still
172  * unreliable, because it doesn't return an error code when it is
173  * used with a kernel that doesn't support the ELF note. On some other
174  * architectures there may be a system call or sysctl() that will work.
175  */
176
177 unsigned long long Hertz;
178
179 static void old_Hertz_hack(void){
180   unsigned long long user_j, nice_j, sys_j, other_j, wait_j, hirq_j, sirq_j, stol_j;  /* jiffies (clock ticks) */
181   double up_1, up_2, seconds;
182   unsigned long long jiffies;
183   unsigned h;
184   char *savelocale;
185   long hz;
186
187 #ifdef _SC_CLK_TCK
188   if((hz = sysconf(_SC_CLK_TCK)) > 0){
189     Hertz = hz;
190     return;
191   }
192 #endif
193
194   wait_j = hirq_j = sirq_j = stol_j = 0;
195   savelocale = strdup(setlocale(LC_NUMERIC, NULL));
196   setlocale(LC_NUMERIC, "C");
197   do{
198     FILE_TO_BUF(UPTIME_FILE,uptime_fd);  sscanf(buf, "%lf", &up_1);
199     /* uptime(&up_1, NULL); */
200     FILE_TO_BUF(STAT_FILE,stat_fd);
201     sscanf(buf, "cpu %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu", &user_j, &nice_j, &sys_j, &other_j, &wait_j, &hirq_j, &sirq_j, &stol_j);
202     FILE_TO_BUF(UPTIME_FILE,uptime_fd);  sscanf(buf, "%lf", &up_2);
203     /* uptime(&up_2, NULL); */
204   } while((long long)( (up_2-up_1)*1000.0/up_1 )); /* want under 0.1% error */
205   setlocale(LC_NUMERIC, savelocale);
206   free(savelocale);
207   jiffies = user_j + nice_j + sys_j + other_j + wait_j + hirq_j + sirq_j + stol_j ;
208   seconds = (up_1 + up_2) / 2;
209   h = (unsigned)( (double)jiffies/seconds/smp_num_cpus );
210   /* actual values used by 2.4 kernels: 32 64 100 128 1000 1024 1200 */
211   switch(h){
212   case    9 ...   11 :  Hertz =   10; break; /* S/390 (sometimes) */
213   case   18 ...   22 :  Hertz =   20; break; /* user-mode Linux */
214   case   30 ...   34 :  Hertz =   32; break; /* ia64 emulator */
215   case   48 ...   52 :  Hertz =   50; break;
216   case   58 ...   61 :  Hertz =   60; break;
217   case   62 ...   65 :  Hertz =   64; break; /* StrongARM /Shark */
218   case   95 ...  105 :  Hertz =  100; break; /* normal Linux */
219   case  124 ...  132 :  Hertz =  128; break; /* MIPS, ARM */
220   case  195 ...  204 :  Hertz =  200; break; /* normal << 1 */
221   case  247 ...  252 :  Hertz =  250; break;
222   case  253 ...  260 :  Hertz =  256; break;
223   case  393 ...  408 :  Hertz =  400; break; /* normal << 2 */
224   case  790 ...  808 :  Hertz =  800; break; /* normal << 3 */
225   case  990 ... 1010 :  Hertz = 1000; break; /* ARM */
226   case 1015 ... 1035 :  Hertz = 1024; break; /* Alpha, ia64 */
227   case 1180 ... 1220 :  Hertz = 1200; break; /* Alpha */
228   default:
229 #ifdef HZ
230     Hertz = (unsigned long long)HZ;    /* <asm/param.h> */
231 #else
232     /* If 32-bit or big-endian (not Alpha or ia64), assume HZ is 100. */
233     Hertz = (sizeof(long)==sizeof(int) || htons(999)==999) ? 100UL : 1024UL;
234 #endif
235     fprintf(stderr, "Unknown HZ value! (%d) Assume %Ld.\n", h, Hertz);
236   }
237 }
238
239 // same as:   euid != uid || egid != gid
240 #ifndef AT_SECURE
241 #define AT_SECURE      23     // secure mode boolean (true if setuid, etc.)
242 #endif
243
244 #ifndef AT_CLKTCK
245 #define AT_CLKTCK       17    // frequency of times()
246 #endif
247
248 #define NOTE_NOT_FOUND 42
249
250 extern char** environ;
251
252 /* for ELF executables, notes are pushed before environment and args */
253 static unsigned long find_elf_note(unsigned long findme){
254   unsigned long *ep = (unsigned long *)environ;
255   while(*ep++);
256   while(*ep){
257     if(ep[0]==findme) return ep[1];
258     ep+=2;
259   }
260   return NOTE_NOT_FOUND;
261 }
262
263 int have_privs;
264
265 static int check_for_privs(void){
266   unsigned long rc = find_elf_note(AT_SECURE);
267   if(rc==NOTE_NOT_FOUND){
268     // not valid to run this code after UID or GID change!
269     // (if needed, may use AT_UID and friends instead)
270     rc = geteuid() != getuid() || getegid() != getgid();
271   }
272   return !!rc;
273 }
274
275 static void init_libproc(void) __attribute__((constructor));
276 static void init_libproc(void){
277   have_privs = check_for_privs();
278   init_Linux_version(); /* Must be called before we check code */
279
280   cpuinfo();
281   page_bytes = sysconf(_SC_PAGESIZE);
282
283 #ifdef __linux__
284   if(linux_version_code > LINUX_VERSION(2, 4, 0)){
285     Hertz = find_elf_note(AT_CLKTCK);
286     if(Hertz!=NOTE_NOT_FOUND) return;
287 //  fputs("2.4+ kernel w/o ELF notes? -- report this\n", stderr);
288   }
289 #endif /* __linux __ */
290 #if defined(__FreeBSD_kernel__) || defined(__FreeBSD__)
291   /* On FreeBSD the Hertz hack is unrelaible, there is no ELF note and
292    * Hertz isn't defined in asm/params.h
293    * See Debian Bug #460331
294    */
295   Hertz = 100;
296   return;
297 #endif /* __FreeBSD__ */
298   old_Hertz_hack();
299 }
300
301 #if 0
302 /***********************************************************************
303  * The /proc filesystem calculates idle=jiffies-(user+nice+sys) and we
304  * recover jiffies by adding up the 4 or 5 numbers we are given. SMP kernels
305  * (as of pre-2.4 era) can report idle time going backwards, perhaps due
306  * to non-atomic reads and updates. There is no locking for these values.
307  */
308 #ifndef NAN
309 #define NAN (-0.0)
310 #endif
311 #define JT unsigned long long
312 void eight_cpu_numbers(double *restrict uret, double *restrict nret, double *restrict sret, double *restrict iret, double *restrict wret, double *restrict xret, double *restrict yret, double *restrict zret){
313     double tmp_u, tmp_n, tmp_s, tmp_i, tmp_w, tmp_x, tmp_y, tmp_z;
314     double scale;  /* scale values to % */
315     static JT old_u, old_n, old_s, old_i, old_w, old_x, old_y, old_z;
316     JT new_u, new_n, new_s, new_i, new_w, new_x, new_y, new_z;
317     JT ticks_past; /* avoid div-by-0 by not calling too often :-( */
318
319     tmp_w = 0.0;
320     new_w = 0;
321     tmp_x = 0.0;
322     new_x = 0;
323     tmp_y = 0.0;
324     new_y = 0;
325     tmp_z = 0.0;
326     new_z = 0;
327
328     FILE_TO_BUF(STAT_FILE,stat_fd);
329     sscanf(buf, "cpu %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu", &new_u, &new_n, &new_s, &new_i, &new_w, &new_x, &new_y, &new_z);
330     ticks_past = (new_u+new_n+new_s+new_i+new_w+new_x+new_y+new_z)-(old_u+old_n+old_s+old_i+old_w+old_x+old_y+old_z);
331     if(ticks_past){
332       scale = 100.0 / (double)ticks_past;
333       tmp_u = ( (double)new_u - (double)old_u ) * scale;
334       tmp_n = ( (double)new_n - (double)old_n ) * scale;
335       tmp_s = ( (double)new_s - (double)old_s ) * scale;
336       tmp_i = ( (double)new_i - (double)old_i ) * scale;
337       tmp_w = ( (double)new_w - (double)old_w ) * scale;
338       tmp_x = ( (double)new_x - (double)old_x ) * scale;
339       tmp_y = ( (double)new_y - (double)old_y ) * scale;
340       tmp_z = ( (double)new_z - (double)old_z ) * scale;
341     }else{
342       tmp_u = NAN;
343       tmp_n = NAN;
344       tmp_s = NAN;
345       tmp_i = NAN;
346       tmp_w = NAN;
347       tmp_x = NAN;
348       tmp_y = NAN;
349       tmp_z = NAN;
350     }
351     SET_IF_DESIRED(uret, tmp_u);
352     SET_IF_DESIRED(nret, tmp_n);
353     SET_IF_DESIRED(sret, tmp_s);
354     SET_IF_DESIRED(iret, tmp_i);
355     SET_IF_DESIRED(wret, tmp_w);
356     SET_IF_DESIRED(xret, tmp_x);
357     SET_IF_DESIRED(yret, tmp_y);
358     SET_IF_DESIRED(zret, tmp_z);
359     old_u=new_u;
360     old_n=new_n;
361     old_s=new_s;
362     old_i=new_i;
363     old_w=new_w;
364     old_x=new_x;
365     old_y=new_y;
366     old_z=new_z;
367 }
368 #undef JT
369 #endif
370
371 /***********************************************************************/
372 void loadavg(double *restrict av1, double *restrict av5, double *restrict av15) {
373     double avg_1=0, avg_5=0, avg_15=0;
374     char *savelocale;
375
376     FILE_TO_BUF(LOADAVG_FILE,loadavg_fd);
377     savelocale = strdup(setlocale(LC_NUMERIC, NULL));
378     setlocale(LC_NUMERIC, "C");
379     if (sscanf(buf, "%lf %lf %lf", &avg_1, &avg_5, &avg_15) < 3) {
380         fputs("bad data in " LOADAVG_FILE "\n", stderr);
381         free(savelocale);
382         exit(1);
383     }
384     setlocale(LC_NUMERIC, savelocale);
385     free(savelocale);
386     SET_IF_DESIRED(av1,  avg_1);
387     SET_IF_DESIRED(av5,  avg_5);
388     SET_IF_DESIRED(av15, avg_15);
389 }
390
391   static char buff[BUFFSIZE]; /* used in the procedures */
392 /***********************************************************************/
393
394 static void crash(const char *filename) {
395     perror(filename);
396     exit(EXIT_FAILURE);
397 }
398
399 /***********************************************************************/
400
401 static void getrunners(unsigned int *restrict running, unsigned int *restrict blocked) {
402   struct dirent *ent;
403   DIR *proc;
404
405   *running=0;
406   *blocked=0;
407
408   if((proc=opendir("/proc"))==NULL) crash("/proc");
409
410   while(( ent=readdir(proc) )) {
411     char tbuf[32];
412     char *cp;
413     int fd;
414     char c;
415
416     if (!isdigit(ent->d_name[0])) continue;
417     sprintf(tbuf, "/proc/%s/stat", ent->d_name);
418
419     fd = open(tbuf, O_RDONLY, 0);
420     if (fd == -1) continue;
421     memset(tbuf, '\0', sizeof tbuf); // didn't feel like checking read()
422     read(fd, tbuf, sizeof tbuf - 1); // need 32 byte buffer at most
423     close(fd);
424
425     cp = strrchr(tbuf, ')');
426     if(!cp) continue;
427     c = cp[2];
428
429     if (c=='R') {
430       (*running)++;
431       continue;
432     }
433     if (c=='D') {
434       (*blocked)++;
435       continue;
436     }
437   }
438   closedir(proc);
439 }
440
441 /***********************************************************************/
442
443 void getstat(jiff *restrict cuse, jiff *restrict cice, jiff *restrict csys, jiff *restrict cide, jiff *restrict ciow, jiff *restrict cxxx, jiff *restrict cyyy, jiff *restrict czzz,
444              unsigned long *restrict pin, unsigned long *restrict pout, unsigned long *restrict s_in, unsigned long *restrict sout,
445              unsigned *restrict intr, unsigned *restrict ctxt,
446              unsigned int *restrict running, unsigned int *restrict blocked,
447              unsigned int *restrict btime, unsigned int *restrict processes) {
448   static int fd;
449   unsigned long long llbuf = 0;
450   int need_vmstat_file = 0;
451   int need_proc_scan = 0;
452   const char* b;
453   buff[BUFFSIZE-1] = 0;  /* ensure null termination in buffer */
454
455   if(fd){
456     lseek(fd, 0L, SEEK_SET);
457   }else{
458     fd = open("/proc/stat", O_RDONLY, 0);
459     if(fd == -1) crash("/proc/stat");
460   }
461   read(fd,buff,BUFFSIZE-1);
462   *intr = 0;
463   *ciow = 0;  /* not separated out until the 2.5.41 kernel */
464   *cxxx = 0;  /* not separated out until the 2.6.0-test4 kernel */
465   *cyyy = 0;  /* not separated out until the 2.6.0-test4 kernel */
466   *czzz = 0;  /* not separated out until the 2.6.11 kernel */
467
468   b = strstr(buff, "cpu ");
469   if(b) sscanf(b,  "cpu  %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu", cuse, cice, csys, cide, ciow, cxxx, cyyy, czzz);
470
471   b = strstr(buff, "page ");
472   if(b) sscanf(b,  "page %lu %lu", pin, pout);
473   else need_vmstat_file = 1;
474
475   b = strstr(buff, "swap ");
476   if(b) sscanf(b,  "swap %lu %lu", s_in, sout);
477   else need_vmstat_file = 1;
478
479   b = strstr(buff, "intr ");
480   if(b) sscanf(b,  "intr %Lu", &llbuf);
481   *intr = llbuf;
482
483   b = strstr(buff, "ctxt ");
484   if(b) sscanf(b,  "ctxt %Lu", &llbuf);
485   *ctxt = llbuf;
486
487   b = strstr(buff, "btime ");
488   if(b) sscanf(b,  "btime %u", btime);
489
490   b = strstr(buff, "processes ");
491   if(b) sscanf(b,  "processes %u", processes);
492
493   b = strstr(buff, "procs_running ");
494   if(b) sscanf(b,  "procs_running %u", running);
495   else need_proc_scan = 1;
496
497   b = strstr(buff, "procs_blocked ");
498   if(b) sscanf(b,  "procs_blocked %u", blocked);
499   else need_proc_scan = 1;
500
501   if(need_proc_scan){   /* Linux 2.5.46 (approximately) and below */
502     getrunners(running, blocked);
503   }
504
505   if(*running)
506     (*running)--;   // exclude vmstat itself
507
508   if(need_vmstat_file){  /* Linux 2.5.40-bk4 and above */
509     vminfo();
510     *pin  = vm_pgpgin;
511     *pout = vm_pgpgout;
512     *s_in = vm_pswpin;
513     *sout = vm_pswpout;
514   }
515 }
516
517 /***********************************************************************/
518 /*
519  * Copyright 1999 by Albert Cahalan; all rights reserved.
520  * This file may be used subject to the terms and conditions of the
521  * GNU Library General Public License Version 2, or any later version
522  * at your option, as published by the Free Software Foundation.
523  * This program is distributed in the hope that it will be useful,
524  * but WITHOUT ANY WARRANTY; without even the implied warranty of
525  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
526  * GNU Library General Public License for more details.
527  */
528
529 typedef struct mem_table_struct {
530   const char *name;     /* memory type name */
531   unsigned long *slot; /* slot in return struct */
532 } mem_table_struct;
533
534 static int compare_mem_table_structs(const void *a, const void *b){
535   return strcmp(((const mem_table_struct*)a)->name,((const mem_table_struct*)b)->name);
536 }
537
538 /* example data, following junk, with comments added:
539  *
540  * MemTotal:        61768 kB    old
541  * MemFree:          1436 kB    old
542  * Buffers:          1312 kB    old
543  * Cached:          20932 kB    old
544  * Active:          12464 kB    new
545  * Inact_dirty:      7772 kB    new
546  * Inact_clean:      2008 kB    new
547  * Inact_target:        0 kB    new
548  * Inact_laundry:       0 kB    new, and might be missing too
549  * HighTotal:           0 kB
550  * HighFree:            0 kB
551  * LowTotal:        61768 kB
552  * LowFree:          1436 kB
553  * SwapTotal:      122580 kB    old
554  * SwapFree:        60352 kB    old
555  * Inactive:        20420 kB    2.5.41+
556  * Dirty:               0 kB    2.5.41+
557  * Writeback:           0 kB    2.5.41+
558  * Mapped:           9792 kB    2.5.41+
559  * Shmem:              28 kB    2.6.32+
560  * Slab:             4564 kB    2.5.41+
561  * Committed_AS:     8440 kB    2.5.41+
562  * PageTables:        304 kB    2.5.41+
563  * ReverseMaps:      5738       2.5.41+
564  * SwapCached:          0 kB    2.5.??+
565  * HugePages_Total:   220       2.5.??+
566  * HugePages_Free:    138       2.5.??+
567  * Hugepagesize:     4096 kB    2.5.??+
568  */
569
570 /* Shmem in 2.6.32+ */
571 unsigned long kb_main_shared;
572 /* old but still kicking -- the important stuff */
573 static unsigned long kb_page_cache;
574 unsigned long kb_main_buffers;
575 unsigned long kb_main_free;
576 unsigned long kb_main_total;
577 unsigned long kb_swap_free;
578 unsigned long kb_swap_total;
579 /* recently introduced */
580 unsigned long kb_high_free;
581 unsigned long kb_high_total;
582 unsigned long kb_low_free;
583 unsigned long kb_low_total;
584 unsigned long kb_main_available;
585 /* 2.4.xx era */
586 unsigned long kb_active;
587 unsigned long kb_inact_laundry;
588 unsigned long kb_inact_dirty;
589 unsigned long kb_inact_clean;
590 unsigned long kb_inact_target;
591 unsigned long kb_swap_cached;  /* late 2.4 and 2.6+ only */
592 /* derived values */
593 unsigned long kb_main_cached;
594 unsigned long kb_swap_used;
595 unsigned long kb_main_used;
596 /* 2.5.41+ */
597 unsigned long kb_writeback;
598 unsigned long kb_slab;
599 unsigned long nr_reversemaps;
600 unsigned long kb_committed_as;
601 unsigned long kb_dirty;
602 unsigned long kb_inactive;
603 unsigned long kb_mapped;
604 unsigned long kb_pagetables;
605 // seen on a 2.6.x kernel:
606 static unsigned long kb_vmalloc_chunk;
607 static unsigned long kb_vmalloc_total;
608 static unsigned long kb_vmalloc_used;
609 // seen on 2.6.24-rc6-git12
610 static unsigned long kb_anon_pages;
611 static unsigned long kb_bounce;
612 static unsigned long kb_commit_limit;
613 static unsigned long kb_nfs_unstable;
614 // seen on 2.6.18
615 static unsigned long kb_min_free;
616 // 2.6.19+
617 static unsigned long kb_slab_reclaimable;
618 static unsigned long kb_slab_unreclaimable;
619 // 2.6.27+
620 static unsigned long kb_active_file;
621 static unsigned long kb_inactive_file;
622
623
624 void meminfo(void){
625   char namebuf[32]; /* big enough to hold any row name */
626   mem_table_struct findme = { namebuf, NULL};
627   mem_table_struct *found;
628   char *head;
629   char *tail;
630   static const mem_table_struct mem_table[] = {
631   {"Active",       &kb_active},       // important
632   {"Active(file)", &kb_active_file},
633   {"AnonPages",    &kb_anon_pages},
634   {"Bounce",       &kb_bounce},
635   {"Buffers",      &kb_main_buffers}, // important
636   {"Cached",       &kb_page_cache},  // important
637   {"CommitLimit",  &kb_commit_limit},
638   {"Committed_AS", &kb_committed_as},
639   {"Dirty",        &kb_dirty},        // kB version of vmstat nr_dirty
640   {"HighFree",     &kb_high_free},
641   {"HighTotal",    &kb_high_total},
642   {"Inact_clean",  &kb_inact_clean},
643   {"Inact_dirty",  &kb_inact_dirty},
644   {"Inact_laundry",&kb_inact_laundry},
645   {"Inact_target", &kb_inact_target},
646   {"Inactive",     &kb_inactive},     // important
647   {"Inactive(file)",&kb_inactive_file},
648   {"LowFree",      &kb_low_free},
649   {"LowTotal",     &kb_low_total},
650   {"Mapped",       &kb_mapped},       // kB version of vmstat nr_mapped
651   {"MemAvailable", &kb_main_available}, // important
652   {"MemFree",      &kb_main_free},    // important
653   {"MemTotal",     &kb_main_total},   // important
654   {"NFS_Unstable", &kb_nfs_unstable},
655   {"PageTables",   &kb_pagetables},   // kB version of vmstat nr_page_table_pages
656   {"ReverseMaps",  &nr_reversemaps},  // same as vmstat nr_page_table_pages
657   {"SReclaimable", &kb_slab_reclaimable}, // "slab reclaimable" (dentry and inode structures)
658   {"SUnreclaim",   &kb_slab_unreclaimable},
659   {"Shmem",        &kb_main_shared},  // kernel 2.6.32 and later
660   {"Slab",         &kb_slab},         // kB version of vmstat nr_slab
661   {"SwapCached",   &kb_swap_cached},
662   {"SwapFree",     &kb_swap_free},    // important
663   {"SwapTotal",    &kb_swap_total},   // important
664   {"VmallocChunk", &kb_vmalloc_chunk},
665   {"VmallocTotal", &kb_vmalloc_total},
666   {"VmallocUsed",  &kb_vmalloc_used},
667   {"Writeback",    &kb_writeback},    // kB version of vmstat nr_writeback
668   };
669   const int mem_table_count = sizeof(mem_table)/sizeof(mem_table_struct);
670   unsigned long watermark_low;
671   signed long mem_available;
672
673   FILE_TO_BUF(MEMINFO_FILE,meminfo_fd);
674
675   kb_inactive = ~0UL;
676   kb_low_total = kb_main_available = 0;
677
678   head = buf;
679   for(;;){
680     tail = strchr(head, ':');
681     if(!tail) break;
682     *tail = '\0';
683     if(strlen(head) >= sizeof(namebuf)){
684       head = tail+1;
685       goto nextline;
686     }
687     strcpy(namebuf,head);
688     found = bsearch(&findme, mem_table, mem_table_count,
689         sizeof(mem_table_struct), compare_mem_table_structs
690     );
691     head = tail+1;
692     if(!found) goto nextline;
693     *(found->slot) = (unsigned long)strtoull(head,&tail,10);
694 nextline:
695     tail = strchr(head, '\n');
696     if(!tail) break;
697     head = tail+1;
698   }
699   if(!kb_low_total){  /* low==main except with large-memory support */
700     kb_low_total = kb_main_total;
701     kb_low_free  = kb_main_free;
702   }
703   if(kb_inactive==~0UL){
704     kb_inactive = kb_inact_dirty + kb_inact_clean + kb_inact_laundry;
705   }
706   kb_main_cached = kb_page_cache + kb_slab;
707   kb_swap_used = kb_swap_total - kb_swap_free;
708   kb_main_used = kb_main_total - kb_main_free - kb_main_cached - kb_main_buffers;
709
710   /* zero? might need fallback for 2.6.27 <= kernel <? 3.14 */
711   if (!kb_main_available) {
712     if (linux_version_code < LINUX_VERSION(2, 6, 27))
713       kb_main_available = kb_main_free;
714     else {
715       FILE_TO_BUF(VM_MIN_FREE_FILE, vm_min_free_fd);
716       kb_min_free = (unsigned long) strtoull(buf,&tail,10);
717
718       watermark_low = kb_min_free * 5 / 4; /* should be equal to sum of all 'low' fields in /proc/zoneinfo */
719
720       mem_available = (signed long)kb_main_free - watermark_low
721       + kb_inactive_file + kb_active_file - MIN((kb_inactive_file + kb_active_file) / 2, watermark_low)
722       + kb_slab_reclaimable - MIN(kb_slab_reclaimable / 2, watermark_low);
723
724       if (mem_available < 0) mem_available = 0;
725       kb_main_available = (unsigned long)mem_available;
726     }
727   }
728 }
729
730 /*****************************************************************/
731
732 /* read /proc/vminfo only for 2.5.41 and above */
733
734 typedef struct vm_table_struct {
735   const char *name;     /* VM statistic name */
736   unsigned long *slot;       /* slot in return struct */
737 } vm_table_struct;
738
739 static int compare_vm_table_structs(const void *a, const void *b){
740   return strcmp(((const vm_table_struct*)a)->name,((const vm_table_struct*)b)->name);
741 }
742
743 // see include/linux/page-flags.h and mm/page_alloc.c
744 unsigned long vm_nr_dirty;           // dirty writable pages
745 unsigned long vm_nr_writeback;       // pages under writeback
746 unsigned long vm_nr_pagecache;       // pages in pagecache -- gone in 2.5.66+ kernels
747 unsigned long vm_nr_page_table_pages;// pages used for pagetables
748 unsigned long vm_nr_reverse_maps;    // includes PageDirect
749 unsigned long vm_nr_mapped;          // mapped into pagetables
750 unsigned long vm_nr_slab;            // in slab
751 unsigned long vm_nr_slab_reclaimable;  // 2.6.19+ kernels
752 unsigned long vm_nr_slab_unreclaimable;// 2.6.19+ kernels
753 unsigned long vm_nr_active_file;       // 2.6.27+ kernels
754 unsigned long vm_nr_inactive_file;     // 2.6.27+ kernels
755 unsigned long vm_nr_free_pages;        // 2.6.21+ kernels
756 unsigned long vm_pgpgin;             // kB disk reads  (same as 1st num on /proc/stat page line)
757 unsigned long vm_pgpgout;            // kB disk writes (same as 2nd num on /proc/stat page line)
758 unsigned long vm_pswpin;             // swap reads     (same as 1st num on /proc/stat swap line)
759 unsigned long vm_pswpout;            // swap writes    (same as 2nd num on /proc/stat swap line)
760 unsigned long vm_pgalloc;            // page allocations
761 unsigned long vm_pgfree;             // page freeings
762 unsigned long vm_pgactivate;         // pages moved inactive -> active
763 unsigned long vm_pgdeactivate;       // pages moved active -> inactive
764 unsigned long vm_pgfault;           // total faults (major+minor)
765 unsigned long vm_pgmajfault;       // major faults
766 unsigned long vm_pgscan;          // pages scanned by page reclaim
767 unsigned long vm_pgrefill;       // inspected by refill_inactive_zone
768 unsigned long vm_pgsteal;       // total pages reclaimed
769 unsigned long vm_kswapd_steal; // pages reclaimed by kswapd
770 // next 3 as defined by the 2.5.52 kernel
771 unsigned long vm_pageoutrun;  // times kswapd ran page reclaim
772 unsigned long vm_allocstall; // times a page allocator ran direct reclaim
773 unsigned long vm_pgrotated; // pages rotated to the tail of the LRU for immediate reclaim
774 // seen on a 2.6.8-rc1 kernel, apparently replacing old fields
775 static unsigned long vm_pgalloc_dma;          //
776 static unsigned long vm_pgalloc_high;         //
777 static unsigned long vm_pgalloc_normal;       //
778 static unsigned long vm_pgrefill_dma;         //
779 static unsigned long vm_pgrefill_high;        //
780 static unsigned long vm_pgrefill_normal;      //
781 static unsigned long vm_pgscan_direct_dma;    //
782 static unsigned long vm_pgscan_direct_high;   //
783 static unsigned long vm_pgscan_direct_normal; //
784 static unsigned long vm_pgscan_kswapd_dma;    //
785 static unsigned long vm_pgscan_kswapd_high;   //
786 static unsigned long vm_pgscan_kswapd_normal; //
787 static unsigned long vm_pgsteal_dma;          //
788 static unsigned long vm_pgsteal_high;         //
789 static unsigned long vm_pgsteal_normal;       //
790 // seen on a 2.6.8-rc1 kernel
791 static unsigned long vm_kswapd_inodesteal;    //
792 static unsigned long vm_nr_unstable;          //
793 static unsigned long vm_pginodesteal;         //
794 static unsigned long vm_slabs_scanned;        //
795
796 void vminfo(void){
797   char namebuf[32]; /* big enough to hold any row name */
798   vm_table_struct findme = { namebuf, NULL};
799   vm_table_struct *found;
800   char *head;
801   char *tail;
802   static const vm_table_struct vm_table[] = {
803   {"allocstall",          &vm_allocstall},
804   {"kswapd_inodesteal",   &vm_kswapd_inodesteal},
805   {"kswapd_steal",        &vm_kswapd_steal},
806   {"nr_active_file",      &vm_nr_active_file},     // 2.6.27+ kernels
807   {"nr_dirty",            &vm_nr_dirty},           // page version of meminfo Dirty
808   {"nr_free_pages",       &vm_nr_free_pages},      // 2.6.21+ kernels
809   {"nr_inactive_file",    &vm_nr_inactive_file},   // 2.6.27+ kernels
810   {"nr_mapped",           &vm_nr_mapped},          // page version of meminfo Mapped
811   {"nr_page_table_pages", &vm_nr_page_table_pages},// same as meminfo PageTables
812   {"nr_pagecache",        &vm_nr_pagecache},       // gone in 2.5.66+ kernels
813   {"nr_reverse_maps",     &vm_nr_reverse_maps},    // page version of meminfo ReverseMaps GONE
814   {"nr_slab",             &vm_nr_slab},            // page version of meminfo Slab (gone in 2.6.19+)
815   {"nr_slab_reclaimable", &vm_nr_slab_reclaimable},// 2.6.19+ kernels
816  {"nr_slab_unreclaimable",&vm_nr_slab_unreclaimable},// 2.6.19+ kernels
817   {"nr_unstable",         &vm_nr_unstable},
818   {"nr_writeback",        &vm_nr_writeback},       // page version of meminfo Writeback
819   {"pageoutrun",          &vm_pageoutrun},
820   {"pgactivate",          &vm_pgactivate},
821   {"pgalloc",             &vm_pgalloc},  // GONE (now separate dma,high,normal)
822   {"pgalloc_dma",         &vm_pgalloc_dma},
823   {"pgalloc_high",        &vm_pgalloc_high},
824   {"pgalloc_normal",      &vm_pgalloc_normal},
825   {"pgdeactivate",        &vm_pgdeactivate},
826   {"pgfault",             &vm_pgfault},
827   {"pgfree",              &vm_pgfree},
828   {"pginodesteal",        &vm_pginodesteal},
829   {"pgmajfault",          &vm_pgmajfault},
830   {"pgpgin",              &vm_pgpgin},     // important
831   {"pgpgout",             &vm_pgpgout},     // important
832   {"pgrefill",            &vm_pgrefill},  // GONE (now separate dma,high,normal)
833   {"pgrefill_dma",        &vm_pgrefill_dma},
834   {"pgrefill_high",       &vm_pgrefill_high},
835   {"pgrefill_normal",     &vm_pgrefill_normal},
836   {"pgrotated",           &vm_pgrotated},
837   {"pgscan",              &vm_pgscan},  // GONE (now separate direct,kswapd and dma,high,normal)
838   {"pgscan_direct_dma",   &vm_pgscan_direct_dma},
839   {"pgscan_direct_high",  &vm_pgscan_direct_high},
840   {"pgscan_direct_normal",&vm_pgscan_direct_normal},
841   {"pgscan_kswapd_dma",   &vm_pgscan_kswapd_dma},
842   {"pgscan_kswapd_high",  &vm_pgscan_kswapd_high},
843   {"pgscan_kswapd_normal",&vm_pgscan_kswapd_normal},
844   {"pgsteal",             &vm_pgsteal},  // GONE (now separate dma,high,normal)
845   {"pgsteal_dma",         &vm_pgsteal_dma},
846   {"pgsteal_high",        &vm_pgsteal_high},
847   {"pgsteal_normal",      &vm_pgsteal_normal},
848   {"pswpin",              &vm_pswpin},     // important
849   {"pswpout",             &vm_pswpout},     // important
850   {"slabs_scanned",       &vm_slabs_scanned},
851   };
852   const int vm_table_count = sizeof(vm_table)/sizeof(vm_table_struct);
853
854 #if __SIZEOF_LONG__ == 4
855   unsigned long long slotll;
856 #endif
857
858   vm_pgalloc = 0;
859   vm_pgrefill = 0;
860   vm_pgscan = 0;
861   vm_pgsteal = 0;
862
863   FILE_TO_BUF(VMINFO_FILE,vminfo_fd);
864
865   head = buf;
866   for(;;){
867     tail = strchr(head, ' ');
868     if(!tail) break;
869     *tail = '\0';
870     if(strlen(head) >= sizeof(namebuf)){
871       head = tail+1;
872       goto nextline;
873     }
874     strcpy(namebuf,head);
875     found = bsearch(&findme, vm_table, vm_table_count,
876         sizeof(vm_table_struct), compare_vm_table_structs
877     );
878     head = tail+1;
879     if(!found) goto nextline;
880 #if __SIZEOF_LONG__ == 4
881     // A 32 bit kernel would have already truncated the value, a 64 bit kernel
882     // doesn't need to.  Truncate here to let 32 bit programs to continue to get
883     // truncated values.  It's that or change the API for a larger data type.
884     slotll = strtoull(head,&tail,10);
885     *(found->slot) = (unsigned long)slotll;
886 #else
887     *(found->slot) = strtoul(head,&tail,10);
888 #endif
889 nextline:
890
891 //if(found) fprintf(stderr,"%s=%d\n",found->name,*(found->slot));
892 //else      fprintf(stderr,"%s not found\n",findme.name);
893
894     tail = strchr(head, '\n');
895     if(!tail) break;
896     head = tail+1;
897   }
898   if(!vm_pgalloc)
899     vm_pgalloc  = vm_pgalloc_dma + vm_pgalloc_high + vm_pgalloc_normal;
900   if(!vm_pgrefill)
901     vm_pgrefill = vm_pgrefill_dma + vm_pgrefill_high + vm_pgrefill_normal;
902   if(!vm_pgscan)
903     vm_pgscan   = vm_pgscan_direct_dma + vm_pgscan_direct_high + vm_pgscan_direct_normal
904                 + vm_pgscan_kswapd_dma + vm_pgscan_kswapd_high + vm_pgscan_kswapd_normal;
905   if(!vm_pgsteal)
906     vm_pgsteal  = vm_pgsteal_dma + vm_pgsteal_high + vm_pgsteal_normal;
907 }
908
909 ///////////////////////////////////////////////////////////////////////
910 // based on Fabian Frederick's /proc/diskstats parser
911
912
913 unsigned int getpartitions_num(struct disk_stat *disks, int ndisks){
914   int i=0;
915   int partitions=0;
916
917   for (i=0;i<ndisks;i++){
918         partitions+=disks[i].partitions;
919   }
920   return partitions;
921
922 }
923
924 /////////////////////////////////////////////////////////////////////////////
925 static int is_disk(char *dev)
926 {
927   char syspath[32];
928   char *slash;
929
930   while ((slash = strchr(dev, '/')))
931     *slash = '!';
932   snprintf(syspath, sizeof(syspath), "/sys/block/%s", dev);
933   return !(access(syspath, F_OK));
934 }
935
936 /////////////////////////////////////////////////////////////////////////////
937
938 unsigned int getdiskstat(struct disk_stat **disks, struct partition_stat **partitions){
939   FILE* fd;
940   int cDisk = 0;
941   int cPartition = 0;
942   int fields;
943   unsigned dummy;
944   char devname[32];
945
946   *disks = NULL;
947   *partitions = NULL;
948   buff[BUFFSIZE-1] = 0;
949   fd = fopen("/proc/diskstats", "rb");
950   if(!fd) crash("/proc/diskstats");
951
952   for (;;) {
953     if (!fgets(buff,BUFFSIZE-1,fd)){
954       fclose(fd);
955       break;
956     }
957     fields = sscanf(buff, " %*d %*d %15s %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %u", devname, &dummy);
958     if (fields == 2 && is_disk(devname)){
959       (*disks) = xrealloc(*disks, (cDisk+1)*sizeof(struct disk_stat));
960       sscanf(buff,  "   %*d    %*d %15s %u %u %llu %u %u %u %llu %u %u %u %u",
961         //&disk_major,
962         //&disk_minor,
963         (*disks)[cDisk].disk_name,
964         &(*disks)[cDisk].reads,
965         &(*disks)[cDisk].merged_reads,
966         &(*disks)[cDisk].reads_sectors,
967         &(*disks)[cDisk].milli_reading,
968         &(*disks)[cDisk].writes,
969         &(*disks)[cDisk].merged_writes,
970         &(*disks)[cDisk].written_sectors,
971         &(*disks)[cDisk].milli_writing,
972         &(*disks)[cDisk].inprogress_IO,
973         &(*disks)[cDisk].milli_spent_IO,
974         &(*disks)[cDisk].weighted_milli_spent_IO
975       );
976         (*disks)[cDisk].partitions=0;
977       cDisk++;
978     }else{
979       (*partitions) = xrealloc(*partitions, (cPartition+1)*sizeof(struct partition_stat));
980       fflush(stdout);
981       sscanf(buff,  (fields == 2)
982           ? "   %*d    %*d %15s %u %*u %llu %*u %u %*u %llu %*u %*u %*u %*u"
983           : "   %*d    %*d %15s %u %llu %u %llu",
984         //&part_major,
985         //&part_minor,
986         (*partitions)[cPartition].partition_name,
987         &(*partitions)[cPartition].reads,
988         &(*partitions)[cPartition].reads_sectors,
989         &(*partitions)[cPartition].writes,
990         &(*partitions)[cPartition].requested_writes
991       );
992
993       if (cDisk > 0) {
994         (*partitions)[cPartition++].parent_disk = cDisk-1;
995         (*disks)[cDisk-1].partitions++;
996       }
997     }
998   }
999
1000   return cDisk;
1001 }
1002
1003 /////////////////////////////////////////////////////////////////////////////
1004 // based on Fabian Frederick's /proc/slabinfo parser
1005
1006 unsigned int getslabinfo (struct slab_cache **slab){
1007   FILE* fd;
1008   int cSlab = 0;
1009   buff[BUFFSIZE-1] = 0;
1010   *slab = NULL;
1011   fd = fopen("/proc/slabinfo", "rb");
1012   if(!fd) crash("/proc/slabinfo");
1013   while (fgets(buff,BUFFSIZE-1,fd)){
1014     if(!memcmp("slabinfo - version:",buff,19)) continue; // skip header
1015     if(*buff == '#')                           continue; // skip comments
1016     (*slab) = xrealloc(*slab, (cSlab+1)*sizeof(struct slab_cache));
1017     sscanf(buff,  "%47s %u %u %u %u",  // allow 47; max seen is 24
1018       (*slab)[cSlab].name,
1019       &(*slab)[cSlab].active_objs,
1020       &(*slab)[cSlab].num_objs,
1021       &(*slab)[cSlab].objsize,
1022       &(*slab)[cSlab].objperslab
1023     ) ;
1024     cSlab++;
1025   }
1026   fclose(fd);
1027   return cSlab;
1028 }
1029
1030 ///////////////////////////////////////////////////////////////////////////
1031
1032 unsigned get_pid_digits(void){
1033   char pidbuf[24];
1034   char *endp;
1035   long rc;
1036   int fd;
1037   static unsigned ret;
1038
1039   if(ret) goto out;
1040   ret = 5;
1041   fd = open("/proc/sys/kernel/pid_max", O_RDONLY);
1042   if(fd==-1) goto out;
1043   rc = read(fd, pidbuf, sizeof pidbuf);
1044   close(fd);
1045   if(rc<3) goto out;
1046   pidbuf[rc] = '\0';
1047   rc = strtol(pidbuf,&endp,10);
1048   if(rc<42) goto out;
1049   if(*endp && *endp!='\n') goto out;
1050   rc--;  // the pid_max value is really the max PID plus 1
1051   ret = 0;
1052   while(rc){
1053     rc /= 10;
1054     ret++;
1055   }
1056 out:
1057   return ret;
1058 }
1059
1060 ///////////////////////////////////////////////////////////////////////////
1061
1062 void cpuinfo (void) {
1063   // ought to count CPUs in /proc/stat instead of relying
1064   // on glibc, which foolishly tries to parse /proc/cpuinfo
1065   // note: that may have been the case but now /proc/stat
1066   //       is the default source.  parsing of /proc/cpuinfo
1067   //       only occurs if the open on /proc/stat fails
1068   //
1069   // SourceForge has an old Alpha running Linux 2.2.20 that
1070   // appears to have a non-SMP kernel on a 2-way SMP box.
1071   // _SC_NPROCESSORS_CONF returns 2, resulting in HZ=512
1072   // _SC_NPROCESSORS_ONLN returns 1, which should work OK
1073
1074   smp_num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
1075   if (smp_num_cpus<1)        /* SPARC glibc is buggy */
1076     smp_num_cpus=1;
1077 }