69f63d08b6da757e818499f9122f786de61d7721
[people/mcb30/busybox.git] / procps / top.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * A tiny 'top' utility.
4  *
5  * This is written specifically for the linux /proc/<PID>/stat(m)
6  * files format.
7
8  * This reads the PIDs of all processes and their status and shows
9  * the status of processes (first ones that fit to screen) at given
10  * intervals.
11  *
12  * NOTES:
13  * - At startup this changes to /proc, all the reads are then
14  *   relative to that.
15  *
16  * (C) Eero Tamminen <oak at welho dot com>
17  *
18  * Rewritten by Vladimir Oleynik (C) 2002 <dzo@simtreas.ru>
19  */
20
21 /* Original code Copyrights */
22 /*
23  * Copyright (c) 1992 Branko Lankester
24  * Copyright (c) 1992 Roger Binns
25  * Copyright (C) 1994-1996 Charles L. Blake.
26  * Copyright (C) 1992-1998 Michael K. Johnson
27  * May be distributed under the conditions of the
28  * GNU Library General Public License
29  */
30
31 #include "libbb.h"
32
33
34 typedef struct top_status_t {
35         unsigned long vsz;
36 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
37         unsigned long ticks;
38         unsigned pcpu; /* delta of ticks */
39 #endif
40         unsigned pid, ppid;
41         unsigned uid;
42         char state[4];
43         char comm[COMM_LEN];
44 } top_status_t;
45
46 typedef struct jiffy_counts_t {
47         unsigned long long usr,nic,sys,idle,iowait,irq,softirq,steal;
48         unsigned long long total;
49         unsigned long long busy;
50 } jiffy_counts_t;
51
52 /* This structure stores some critical information from one frame to
53    the next. Used for finding deltas. */
54 typedef struct save_hist {
55         unsigned long ticks;
56         unsigned pid;
57 } save_hist;
58
59 typedef int (*cmp_funcp)(top_status_t *P, top_status_t *Q);
60
61
62 enum { SORT_DEPTH = 3 };
63
64
65 struct globals {
66         top_status_t *top;
67         int ntop;
68 #if ENABLE_FEATURE_TOPMEM
69         smallint sort_field;
70         smallint inverted;
71 #endif
72 #if ENABLE_FEATURE_USE_TERMIOS
73         struct termios initial_settings;
74 #endif
75 #if !ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
76         cmp_funcp sort_function[1];
77 #else
78         cmp_funcp sort_function[SORT_DEPTH];
79         struct save_hist *prev_hist;
80         int prev_hist_count;
81         jiffy_counts_t jif, prev_jif;
82         /* int hist_iterations; */
83         unsigned total_pcpu;
84         /* unsigned long total_vsz; */
85 #endif
86 };
87 #define G (*(struct globals*)&bb_common_bufsiz1)
88 #define top              (G.top               )
89 #define ntop             (G.ntop              )
90 #define sort_field       (G.sort_field        )
91 #define inverted         (G.inverted          )
92 #define initial_settings (G.initial_settings  )
93 #define sort_function    (G.sort_function     )
94 #define prev_hist        (G.prev_hist         )
95 #define prev_hist_count  (G.prev_hist_count   )
96 #define jif              (G.jif               )
97 #define prev_jif         (G.prev_jif          )
98 #define total_pcpu       (G.total_pcpu        )
99
100
101 #define OPT_BATCH_MODE (option_mask32 & 0x4)
102
103
104 #if ENABLE_FEATURE_USE_TERMIOS
105 static int pid_sort(top_status_t *P, top_status_t *Q)
106 {
107         /* Buggy wrt pids with high bit set */
108         /* (linux pids are in [1..2^15-1]) */
109         return (Q->pid - P->pid);
110 }
111 #endif
112
113 static int mem_sort(top_status_t *P, top_status_t *Q)
114 {
115         /* We want to avoid unsigned->signed and truncation errors */
116         if (Q->vsz < P->vsz) return -1;
117         return Q->vsz != P->vsz; /* 0 if ==, 1 if > */
118 }
119
120
121 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
122
123 static int pcpu_sort(top_status_t *P, top_status_t *Q)
124 {
125         /* Buggy wrt ticks with high bit set */
126         /* Affects only processes for which ticks overflow */
127         return (int)Q->pcpu - (int)P->pcpu;
128 }
129
130 static int time_sort(top_status_t *P, top_status_t *Q)
131 {
132         /* We want to avoid unsigned->signed and truncation errors */
133         if (Q->ticks < P->ticks) return -1;
134         return Q->ticks != P->ticks; /* 0 if ==, 1 if > */
135 }
136
137 static int mult_lvl_cmp(void* a, void* b)
138 {
139         int i, cmp_val;
140
141         for (i = 0; i < SORT_DEPTH; i++) {
142                 cmp_val = (*sort_function[i])(a, b);
143                 if (cmp_val != 0)
144                         return cmp_val;
145         }
146         return 0;
147 }
148
149
150 static void get_jiffy_counts(void)
151 {
152         FILE* fp = xfopen("stat", "r");
153         prev_jif = jif;
154         if (fscanf(fp, "cpu  %lld %lld %lld %lld %lld %lld %lld %lld",
155                         &jif.usr,&jif.nic,&jif.sys,&jif.idle,
156                         &jif.iowait,&jif.irq,&jif.softirq,&jif.steal) < 4) {
157                 bb_error_msg_and_die("failed to read /proc/stat");
158         }
159         fclose(fp);
160         jif.total = jif.usr + jif.nic + jif.sys + jif.idle
161                         + jif.iowait + jif.irq + jif.softirq + jif.steal;
162         /* procps 2.x does not count iowait as busy time */
163         jif.busy = jif.total - jif.idle - jif.iowait;
164 }
165
166
167 static void do_stats(void)
168 {
169         top_status_t *cur;
170         pid_t pid;
171         int i, last_i, n;
172         struct save_hist *new_hist;
173
174         get_jiffy_counts();
175         total_pcpu = 0;
176         /* total_vsz = 0; */
177         new_hist = xmalloc(sizeof(struct save_hist)*ntop);
178         /*
179          * Make a pass through the data to get stats.
180          */
181         /* hist_iterations = 0; */
182         i = 0;
183         for (n = 0; n < ntop; n++) {
184                 cur = top + n;
185
186                 /*
187                  * Calculate time in cur process.  Time is sum of user time
188                  * and system time
189                  */
190                 pid = cur->pid;
191                 new_hist[n].ticks = cur->ticks;
192                 new_hist[n].pid = pid;
193
194                 /* find matching entry from previous pass */
195                 cur->pcpu = 0;
196                 /* do not start at index 0, continue at last used one
197                  * (brought hist_iterations from ~14000 down to 172) */
198                 last_i = i;
199                 if (prev_hist_count) do {
200                         if (prev_hist[i].pid == pid) {
201                                 cur->pcpu = cur->ticks - prev_hist[i].ticks;
202                                 total_pcpu += cur->pcpu;
203                                 break;
204                         }
205                         i = (i+1) % prev_hist_count;
206                         /* hist_iterations++; */
207                 } while (i != last_i);
208                 /* total_vsz += cur->vsz; */
209         }
210
211         /*
212          * Save cur frame's information.
213          */
214         free(prev_hist);
215         prev_hist = new_hist;
216         prev_hist_count = ntop;
217 }
218 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
219
220 #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS && ENABLE_FEATURE_TOP_DECIMALS
221 /* formats 7 char string (8 with terminating NUL) */
222 static char *fmt_100percent_8(char pbuf[8], unsigned value, unsigned total)
223 {
224         unsigned t;
225         if (value >= total) { /* 100% ? */
226                 strcpy(pbuf, "  100% ");
227                 return pbuf;
228         }
229         /* else generate " [N/space]N.N% " string */
230         value = 1000 * value / total;
231         t = value / 100;
232         value = value % 100;
233         pbuf[0] = ' ';
234         pbuf[1] = t ? t + '0' : ' ';
235         pbuf[2] = '0' + (value / 10);
236         pbuf[3] = '.';
237         pbuf[4] = '0' + (value % 10);
238         pbuf[5] = '%';
239         pbuf[6] = ' ';
240         pbuf[7] = '\0';
241         return pbuf;
242 }
243 #endif
244
245 static unsigned long display_header(int scr_width)
246 {
247         FILE *fp;
248         char buf[80];
249         char scrbuf[80];
250         unsigned long total, used, mfree, shared, buffers, cached;
251 #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS
252         unsigned total_diff;
253 #endif
254
255         /* read memory info */
256         fp = xfopen("meminfo", "r");
257
258         /*
259          * Old kernels (such as 2.4.x) had a nice summary of memory info that
260          * we could parse, however this is gone entirely in 2.6. Try parsing
261          * the old way first, and if that fails, parse each field manually.
262          *
263          * First, we read in the first line. Old kernels will have bogus
264          * strings we don't care about, whereas new kernels will start right
265          * out with MemTotal:
266          *                              -- PFM.
267          */
268         if (fscanf(fp, "MemTotal: %lu %s\n", &total, buf) != 2) {
269                 fgets(buf, sizeof(buf), fp);    /* skip first line */
270
271                 fscanf(fp, "Mem: %lu %lu %lu %lu %lu %lu",
272                         &total, &used, &mfree, &shared, &buffers, &cached);
273                 /* convert to kilobytes */
274                 used /= 1024;
275                 mfree /= 1024;
276                 shared /= 1024;
277                 buffers /= 1024;
278                 cached /= 1024;
279                 total /= 1024;
280         } else {
281                 /*
282                  * Revert to manual parsing, which incidentally already has the
283                  * sizes in kilobytes. This should be safe for both 2.4 and
284                  * 2.6.
285                  */
286
287                 fscanf(fp, "MemFree: %lu %s\n", &mfree, buf);
288
289                 /*
290                  * MemShared: is no longer present in 2.6. Report this as 0,
291                  * to maintain consistent behavior with normal procps.
292                  */
293                 if (fscanf(fp, "MemShared: %lu %s\n", &shared, buf) != 2)
294                         shared = 0;
295
296                 fscanf(fp, "Buffers: %lu %s\n", &buffers, buf);
297                 fscanf(fp, "Cached: %lu %s\n", &cached, buf);
298
299                 used = total - mfree;
300         }
301         fclose(fp);
302
303         /* output memory info */
304         if (scr_width > sizeof(scrbuf))
305                 scr_width = sizeof(scrbuf);
306         snprintf(scrbuf, scr_width,
307                 "Mem: %luK used, %luK free, %luK shrd, %luK buff, %luK cached",
308                 used, mfree, shared, buffers, cached);
309         /* clear screen & go to top */
310         printf(OPT_BATCH_MODE ? "%s\n" : "\e[H\e[J%s\n", scrbuf);
311
312 #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS
313         /*
314          * xxx% = (jif.xxx - prev_jif.xxx) / (jif.total - prev_jif.total) * 100%
315          */
316         /* using (unsigned) casts to make operations cheaper */
317         total_diff = ((unsigned)(jif.total - prev_jif.total) ? : 1);
318 #if ENABLE_FEATURE_TOP_DECIMALS
319 /* Generated code is approx +0.3k */
320 #define CALC_STAT(xxx) char xxx[8]
321 #define SHOW_STAT(xxx) fmt_100percent_8(xxx, (unsigned)(jif.xxx - prev_jif.xxx), total_diff)
322 #define FMT "%s"
323 #else
324 #define CALC_STAT(xxx) unsigned xxx = 100 * (unsigned)(jif.xxx - prev_jif.xxx) / total_diff
325 #define SHOW_STAT(xxx) xxx
326 #define FMT "%4u%% "
327 #endif
328         { /* need block: CALC_STAT are declarations */
329                 CALC_STAT(usr);
330                 CALC_STAT(sys);
331                 CALC_STAT(nic);
332                 CALC_STAT(idle);
333                 CALC_STAT(iowait);
334                 CALC_STAT(irq);
335                 CALC_STAT(softirq);
336                 //CALC_STAT(steal);
337
338                 snprintf(scrbuf, scr_width,
339                         /* Barely fits in 79 chars when in "decimals" mode. */
340                         "CPU:"FMT"usr"FMT"sys"FMT"nice"FMT"idle"FMT"io"FMT"irq"FMT"softirq",
341                         SHOW_STAT(usr), SHOW_STAT(sys), SHOW_STAT(nic), SHOW_STAT(idle),
342                         SHOW_STAT(iowait), SHOW_STAT(irq), SHOW_STAT(softirq)
343                         //, SHOW_STAT(steal) - what is this 'steal' thing?
344                         // I doubt anyone wants to know it
345                 );
346         }
347         puts(scrbuf);
348 #undef SHOW_STAT
349 #undef CALC_STAT
350 #undef FMT
351 #endif
352
353         /* read load average as a string */
354         buf[0] = '\0';
355         open_read_close("loadavg", buf, sizeof("N.NN N.NN N.NN")-1);
356         buf[sizeof("N.NN N.NN N.NN")-1] = '\0';
357         snprintf(scrbuf, scr_width, "Load average: %s", buf);
358         puts(scrbuf);
359
360         return total;
361 }
362
363 static void display_process_list(int count, int scr_width)
364 {
365         enum {
366                 BITS_PER_INT = sizeof(int)*8
367         };
368
369         top_status_t *s = top;
370         char vsz_str_buf[8];
371         unsigned long total_memory = display_header(scr_width); /* or use total_vsz? */
372         /* xxx_shift and xxx_scale variables allow us to replace
373          * expensive divides with multiply and shift */
374         unsigned pmem_shift, pmem_scale, pmem_half;
375 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
376         unsigned pcpu_shift, pcpu_scale, pcpu_half;
377         unsigned busy_jifs;
378
379         /* what info of the processes is shown */
380         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
381                 "  PID  PPID USER     STAT   VSZ %MEM %CPU COMMAND");
382 #else
383
384         /* !CPU_USAGE_PERCENTAGE */
385         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
386                 "  PID  PPID USER     STAT   VSZ %MEM COMMAND");
387 #endif
388
389 #if ENABLE_FEATURE_TOP_DECIMALS
390 #define UPSCALE 1000
391 #define CALC_STAT(name, val) div_t name = div((val), 10)
392 #define SHOW_STAT(name) name.quot, '0'+name.rem
393 #define FMT "%3u.%c"
394 #else
395 #define UPSCALE 100
396 #define CALC_STAT(name, val) unsigned name = (val)
397 #define SHOW_STAT(name) name
398 #define FMT "%4u%%"
399 #endif
400         /*
401          * MEM% = s->vsz/MemTotal
402          */
403         pmem_shift = BITS_PER_INT-11;
404         pmem_scale = UPSCALE*(1U<<(BITS_PER_INT-11)) / total_memory;
405         /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */
406         while (pmem_scale >= 512) {
407                 pmem_scale /= 4;
408                 pmem_shift -= 2;
409         }
410         pmem_half = (1U << pmem_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2);
411 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
412         busy_jifs = jif.busy - prev_jif.busy;
413         /* This happens if there were lots of short-lived processes
414          * between two top updates (e.g. compilation) */
415         if (total_pcpu < busy_jifs) total_pcpu = busy_jifs;
416
417         /*
418          * CPU% = s->pcpu/sum(s->pcpu) * busy_cpu_ticks/total_cpu_ticks
419          * (pcpu is delta of sys+user time between samples)
420          */
421         /* (jif.xxx - prev_jif.xxx) and s->pcpu are
422          * in 0..~64000 range (HZ*update_interval).
423          * we assume that unsigned is at least 32-bit.
424          */
425         pcpu_shift = 6;
426         pcpu_scale = (UPSCALE*64*(uint16_t)busy_jifs ? : 1);
427         while (pcpu_scale < (1U<<(BITS_PER_INT-2))) {
428                 pcpu_scale *= 4;
429                 pcpu_shift += 2;
430         }
431         pcpu_scale /= ( (uint16_t)(jif.total-prev_jif.total)*total_pcpu ? : 1);
432         /* we want (s->pcpu * pcpu_scale) to never overflow */
433         while (pcpu_scale >= 1024) {
434                 pcpu_scale /= 4;
435                 pcpu_shift -= 2;
436         }
437         pcpu_half = (1U << pcpu_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2);
438         /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */
439 #endif
440
441         scr_width += 2; /* account for leading '\n' and trailing NUL */
442         /* Ok, all preliminary data is ready, go thru the list */
443         while (count-- > 0) {
444                 char buf[scr_width];
445                 unsigned col;
446                 CALC_STAT(pmem, (s->vsz*pmem_scale + pmem_half) >> pmem_shift);
447 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
448                 CALC_STAT(pcpu, (s->pcpu*pcpu_scale + pcpu_half) >> pcpu_shift);
449 #endif
450
451                 if (s->vsz >= 100000)
452                         sprintf(vsz_str_buf, "%6ldm", s->vsz/1024);
453                 else
454                         sprintf(vsz_str_buf, "%7ld", s->vsz);
455                 // PID PPID USER STAT VSZ %MEM [%CPU] COMMAND
456                 col = snprintf(buf, scr_width,
457                                 "\n" "%5u%6u %-8.8s %s%s" FMT
458 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
459                                 FMT
460 #endif
461                                 " ",
462                                 s->pid, s->ppid, get_cached_username(s->uid),
463                                 s->state, vsz_str_buf,
464                                 SHOW_STAT(pmem)
465 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
466                                 , SHOW_STAT(pcpu)
467 #endif
468                 );
469                 if (col < scr_width)
470                         read_cmdline(buf + col, scr_width - col, s->pid, s->comm);
471                 fputs(buf, stdout);
472                 /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu,
473                         jif.busy - prev_jif.busy, jif.total - prev_jif.total); */
474                 s++;
475         }
476         /* printf(" %d", hist_iterations); */
477         putchar(OPT_BATCH_MODE ? '\n' : '\r');
478         fflush(stdout);
479 }
480 #undef UPSCALE
481 #undef SHOW_STAT
482 #undef CALC_STAT
483 #undef FMT
484
485 static void clearmems(void)
486 {
487         clear_username_cache();
488         free(top);
489         top = NULL;
490         ntop = 0;
491 }
492
493 #if ENABLE_FEATURE_USE_TERMIOS
494 #include <termios.h>
495 #include <signal.h>
496
497 static void reset_term(void)
498 {
499         tcsetattr(0, TCSANOW, (void *) &initial_settings);
500         if (ENABLE_FEATURE_CLEAN_UP) {
501                 clearmems();
502 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
503                 free(prev_hist);
504 #endif
505         }
506 }
507
508 static void sig_catcher(int sig ATTRIBUTE_UNUSED)
509 {
510         reset_term();
511         exit(1);
512 }
513 #endif /* FEATURE_USE_TERMIOS */
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530 typedef unsigned long mem_t;
531
532 typedef struct topmem_status_t {
533         unsigned pid;
534         char comm[COMM_LEN];
535         /* vsz doesn't count /dev/xxx mappings except /dev/zero */
536         mem_t vsz     ;
537         mem_t vszrw   ;
538         mem_t rss     ;
539         mem_t rss_sh  ;
540         mem_t dirty   ;
541         mem_t dirty_sh;
542         mem_t stack   ;
543 } topmem_status_t;
544
545 enum { NUM_SORT_FIELD = 7 };
546
547 #define topmem ((topmem_status_t*)top)
548
549 #if ENABLE_FEATURE_TOPMEM
550 static int topmem_sort(char *a, char *b)
551 {
552         int n;
553         mem_t l, r;
554
555         n = offsetof(topmem_status_t, vsz) + (sort_field * sizeof(mem_t));
556         l = *(mem_t*)(a + n);
557         r = *(mem_t*)(b + n);
558 //      if (l == r) {
559 //              l = a->mapped_rw;
560 //              r = b->mapped_rw;
561 //      }
562         /* We want to avoid unsigned->signed and truncation errors */
563         /* l>r: -1, l=r: 0, l<r: 1 */
564         n = (l > r) ? -1 : (l != r);
565         return inverted ? -n : n;
566 }
567
568 /* Cut "NNNN " out of "    NNNN kb" */
569 static char *grab_number(char *str, const char *match, unsigned sz)
570 {
571         if (strncmp(str, match, sz) == 0) {
572                 str = skip_whitespace(str + sz);
573                 (skip_non_whitespace(str))[1] = '\0';
574                 return xstrdup(str);
575         }
576         return NULL;
577 }
578
579 /* display header info (meminfo / loadavg) */
580 static void display_topmem_header(int scr_width)
581 {
582         char linebuf[128];
583         int i;
584         FILE *fp;
585         union {
586                 struct {
587                         /*  1 */ char *total;
588                         /*  2 */ char *mfree;
589                         /*  3 */ char *buf;
590                         /*  4 */ char *cache;
591                         /*  5 */ char *swaptotal;
592                         /*  6 */ char *swapfree;
593                         /*  7 */ char *dirty;
594                         /*  8 */ char *mwrite;
595                         /*  9 */ char *anon;
596                         /* 10 */ char *map;
597                         /* 11 */ char *slab;
598                 };
599                 char *str[11];
600         } Z;
601 #define total     Z.total
602 #define mfree     Z.mfree
603 #define buf       Z.buf
604 #define cache     Z.cache
605 #define swaptotal Z.swaptotal
606 #define swapfree  Z.swapfree
607 #define dirty     Z.dirty
608 #define mwrite    Z.mwrite
609 #define anon      Z.anon
610 #define map       Z.map
611 #define slab      Z.slab
612 #define str       Z.str
613
614         memset(&Z, 0, sizeof(Z));
615
616         /* read memory info */
617         fp = xfopen("meminfo", "r");
618         while (fgets(linebuf, sizeof(linebuf), fp)) {
619                 char *p;
620
621 #define SCAN(match, name) \
622                 p = grab_number(linebuf, match, sizeof(match)-1); \
623                 if (p) { name = p; continue; }
624
625                 SCAN("MemTotal:", total);
626                 SCAN("MemFree:", mfree);
627                 SCAN("Buffers:", buf);
628                 SCAN("Cached:", cache);
629                 SCAN("SwapTotal:", swaptotal);
630                 SCAN("SwapFree:", swapfree);
631                 SCAN("Dirty:", dirty);
632                 SCAN("Writeback:", mwrite);
633                 SCAN("AnonPages:", anon);
634                 SCAN("Mapped:", map);
635                 SCAN("Slab:", slab);
636 #undef SCAN
637         }
638         fclose(fp);
639
640 #define S(s) (s ? s : "0")
641         snprintf(linebuf, sizeof(linebuf),
642                 "Mem %stotal %sanon %smap %sfree",
643                 S(total), S(anon), S(map), S(mfree));
644         printf(OPT_BATCH_MODE ? "%.*s\n" : "\e[H\e[J%.*s\n", scr_width, linebuf);
645
646         snprintf(linebuf, sizeof(linebuf),
647                 " %sslab %sbuf %scache %sdirty %swrite",
648                 S(slab), S(buf), S(cache), S(dirty), S(mwrite));
649         printf("%.*s\n", scr_width, linebuf);
650
651         snprintf(linebuf, sizeof(linebuf),
652                 "Swap %stotal %sfree", // TODO: % used?
653                 S(swaptotal), S(swapfree));
654         printf("%.*s\n", scr_width, linebuf);
655 #undef S
656
657         for (i = 0; i < ARRAY_SIZE(str); i++)
658                 free(str[i]);
659 #undef total
660 #undef free
661 #undef buf
662 #undef cache
663 #undef swaptotal
664 #undef swapfree
665 #undef dirty
666 #undef write
667 #undef anon
668 #undef map
669 #undef slab
670 #undef str
671 }
672
673 // Converts unsigned long long value into compact 5-char
674 // representation. Sixth char is always ' '
675 static void smart_ulltoa6(unsigned long long ul, char buf[6])
676 {
677         const char *fmt;
678         char c;
679         unsigned v, u, idx = 0;
680
681         if (ul > 99999) { // do not scale if 99999 or less
682                 ul *= 10;
683                 do {
684                         ul /= 1024;
685                         idx++;
686                 } while (ul >= 100000);
687         }
688         v = ul; // ullong divisions are expensive, avoid them
689
690         fmt = " 123456789";
691         u = v / 10;
692         v = v % 10;
693         if (!idx) {
694                 // 99999 or less: use "12345" format
695                 // u is value/10, v is last digit
696                 c = buf[0] = " 123456789"[u/1000];
697                 if (c != ' ') fmt = "0123456789";
698                 c = buf[1] = fmt[u/100%10];
699                 if (c != ' ') fmt = "0123456789";
700                 c = buf[2] = fmt[u/10%10];
701                 if (c != ' ') fmt = "0123456789";
702                 buf[3] = fmt[u%10];
703                 buf[4] = "0123456789"[v];
704         } else {
705                 // value has been scaled into 0..9999.9 range
706                 // u is value, v is 1/10ths (allows for 92.1M format)
707                 if (u >= 100) {
708                         // value is >= 100: use "1234M', " 123M" formats
709                         c = buf[0] = " 123456789"[u/1000];
710                         if (c != ' ') fmt = "0123456789";
711                         c = buf[1] = fmt[u/100%10];
712                         if (c != ' ') fmt = "0123456789";
713                         v = u % 10;
714                         u = u / 10;
715                         buf[2] = fmt[u%10];
716                 } else {
717                         // value is < 100: use "92.1M" format
718                         c = buf[0] = " 123456789"[u/10];
719                         if (c != ' ') fmt = "0123456789";
720                         buf[1] = fmt[u%10];
721                         buf[2] = '.';
722                 }
723                 buf[3] = "0123456789"[v];
724                 // see http://en.wikipedia.org/wiki/Tera
725                 buf[4] = " mgtpezy"[idx];
726         }
727         buf[5] = ' ';
728 }
729
730 static void display_topmem_process_list(int count, int scr_width)
731 {
732 #define HDR_STR "  PID   VSZ VSZRW   RSS (SHR) DIRTY (SHR) STACK"
733 #define MIN_WIDTH sizeof(HDR_STR)
734         const topmem_status_t *s = topmem;
735         char buf[scr_width | MIN_WIDTH]; /* a|b is a cheap max(a,b) */
736
737         display_topmem_header(scr_width);
738         strcpy(buf, HDR_STR " COMMAND");
739         buf[5 + sort_field * 6] = '*';
740         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width, buf);
741
742         while (--count >= 0) {
743                 // PID VSZ VSZRW RSS (SHR) DIRTY (SHR) COMMAND
744                 smart_ulltoa6(s->pid     , &buf[0*6]);
745                 smart_ulltoa6(s->vsz     , &buf[1*6]);
746                 smart_ulltoa6(s->vszrw   , &buf[2*6]);
747                 smart_ulltoa6(s->rss     , &buf[3*6]);
748                 smart_ulltoa6(s->rss_sh  , &buf[4*6]);
749                 smart_ulltoa6(s->dirty   , &buf[5*6]);
750                 smart_ulltoa6(s->dirty_sh, &buf[6*6]);
751                 smart_ulltoa6(s->stack   , &buf[7*6]);
752                 buf[8*6] = '\0';
753                 if (scr_width > MIN_WIDTH) {
754                         read_cmdline(&buf[8*6], scr_width - MIN_WIDTH, s->pid, s->comm);
755                 }
756                 printf("\n""%.*s", scr_width, buf);
757                 s++;
758         }
759         putchar(OPT_BATCH_MODE ? '\n' : '\r');
760         fflush(stdout);
761 #undef HDR_STR
762 #undef MIN_WIDTH
763 }
764 #else
765 void display_topmem_process_list(int count, int scr_width);
766 int topmem_sort(char *a, char *b);
767 #endif /* TOPMEM */
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784 enum {
785         TOP_MASK = 0
786                 | PSSCAN_PID
787                 | PSSCAN_PPID
788                 | PSSCAN_VSZ
789                 | PSSCAN_STIME
790                 | PSSCAN_UTIME
791                 | PSSCAN_STATE
792                 | PSSCAN_COMM
793                 | PSSCAN_UIDGID,
794         TOPMEM_MASK = 0
795                 | PSSCAN_PID
796                 | PSSCAN_SMAPS
797                 | PSSCAN_COMM,
798 };
799
800 int top_main(int argc, char **argv);
801 int top_main(int argc, char **argv)
802 {
803         int count, lines, col;
804         unsigned interval;
805         int iterations = 0; /* infinite */
806         char *sinterval, *siterations;
807         SKIP_FEATURE_TOPMEM(const) unsigned scan_mask = TOP_MASK;
808 #if ENABLE_FEATURE_USE_TERMIOS
809         struct termios new_settings;
810         struct pollfd pfd[1];
811         unsigned char c;
812
813         pfd[0].fd = 0;
814         pfd[0].events = POLLIN;
815 #endif /* FEATURE_USE_TERMIOS */
816
817         interval = 5; /* default update rate is 5 seconds */
818
819         /* do normal option parsing */
820         opt_complementary = "-";
821         getopt32(argv, "d:n:b", &sinterval, &siterations);
822         if (option_mask32 & 0x1) {
823                 /* Need to limit it to not overflow poll timeout */
824                 interval = xatou16(sinterval); // -d
825         }
826         if (option_mask32 & 0x2)
827                 iterations = xatoi_u(siterations); // -n
828         //if (option_mask32 & 0x4) // -b
829
830         /* change to /proc */
831         xchdir("/proc");
832 #if ENABLE_FEATURE_USE_TERMIOS
833         tcgetattr(0, (void *) &initial_settings);
834         memcpy(&new_settings, &initial_settings, sizeof(new_settings));
835         /* unbuffered input, turn off echo */
836         new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL);
837
838         signal(SIGTERM, sig_catcher);
839         signal(SIGINT, sig_catcher);
840         tcsetattr(0, TCSANOW, (void *) &new_settings);
841         atexit(reset_term);
842 #endif /* FEATURE_USE_TERMIOS */
843
844 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
845         sort_function[0] = pcpu_sort;
846         sort_function[1] = mem_sort;
847         sort_function[2] = time_sort;
848 #else
849         sort_function[0] = mem_sort;
850 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
851
852         while (1) {
853                 procps_status_t *p = NULL;
854
855                 /* Default */
856                 lines = 24;
857                 col = 79;
858 #if ENABLE_FEATURE_USE_TERMIOS
859                 get_terminal_width_height(0, &col, &lines);
860                 if (lines < 5 || col < 10) {
861                         sleep(interval);
862                         continue;
863                 }
864 #endif /* FEATURE_USE_TERMIOS */
865                 if (!ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS && scan_mask == TOP_MASK)
866                         lines -= 3;
867                 else
868                         lines -= 4;
869
870                 /* read process IDs & status for all the processes */
871                 while ((p = procps_scan(p, scan_mask)) != NULL) {
872                         int n;
873                         if (scan_mask == TOP_MASK) {
874                                 n = ntop;
875                                 top = xrealloc(top, (++ntop) * sizeof(*top));
876                                 top[n].pid = p->pid;
877                                 top[n].ppid = p->ppid;
878                                 top[n].vsz = p->vsz;
879 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
880                                 top[n].ticks = p->stime + p->utime;
881 #endif
882                                 top[n].uid = p->uid;
883                                 strcpy(top[n].state, p->state);
884                                 strcpy(top[n].comm, p->comm);
885                         } else { /* TOPMEM */
886 #if ENABLE_FEATURE_TOPMEM
887                                 if (!(p->mapped_ro | p->mapped_rw))
888                                         continue; /* kernel threads are ignored */
889                                 n = ntop;
890                                 top = xrealloc(topmem, (++ntop) * sizeof(*topmem));
891                                 strcpy(topmem[n].comm, p->comm);
892                                 topmem[n].pid      = p->pid;
893                                 topmem[n].vsz      = p->mapped_rw + p->mapped_ro;
894                                 topmem[n].vszrw    = p->mapped_rw;
895                                 topmem[n].rss_sh   = p->shared_clean + p->shared_dirty;
896                                 topmem[n].rss      = p->private_clean + p->private_dirty + topmem[n].rss_sh;
897                                 topmem[n].dirty    = p->private_dirty + p->shared_dirty;
898                                 topmem[n].dirty_sh = p->shared_dirty;
899                                 topmem[n].stack    = p->stack;
900 #endif
901                         }
902                 }
903                 if (ntop == 0) {
904                         bb_error_msg_and_die("no process info in /proc");
905                 }
906
907                 if (scan_mask == TOP_MASK) {
908 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
909                         if (!prev_hist_count) {
910                                 do_stats();
911                                 usleep(100000);
912                                 clearmems();
913                                 continue;
914                         }
915                         do_stats();
916 /* TODO: we don't need to sort all 10000 processes, we need to find top 24! */
917                         qsort(top, ntop, sizeof(top_status_t), (void*)mult_lvl_cmp);
918 #else
919                         qsort(top, ntop, sizeof(top_status_t), (void*)(sort_function[0]));
920 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
921                 } else { /* TOPMEM */
922                         qsort(topmem, ntop, sizeof(topmem_status_t), (void*)topmem_sort);
923                 }
924                 count = lines;
925                 if (OPT_BATCH_MODE || count > ntop) {
926                         count = ntop;
927                 }
928                 if (scan_mask == TOP_MASK)
929                         display_process_list(count, col);
930                 else
931                         display_topmem_process_list(count, col);
932                 clearmems();
933                 if (iterations >= 0 && !--iterations)
934                         break;
935 #if !ENABLE_FEATURE_USE_TERMIOS
936                 sleep(interval);
937 #else
938                 if (poll(pfd, 1, interval * 1000) != 0) {
939                         if (read(0, &c, 1) != 1)    /* signal */
940                                 break;
941                         if (c == initial_settings.c_cc[VINTR])
942                                 break;
943                         c |= 0x20; /* lowercase */
944                         if (c == 'q')
945                                 break;
946                         if (c == 'n') {
947                                 USE_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
948                                 sort_function[0] = pid_sort;
949                         }
950                         if (c == 'm') {
951                                 USE_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
952                                 sort_function[0] = mem_sort;
953 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
954                                 sort_function[1] = pcpu_sort;
955                                 sort_function[2] = time_sort;
956 #endif
957                         }
958 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
959                         if (c == 'p') {
960                                 USE_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
961                                 sort_function[0] = pcpu_sort;
962                                 sort_function[1] = mem_sort;
963                                 sort_function[2] = time_sort;
964                         }
965                         if (c == 't') {
966                                 USE_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
967                                 sort_function[0] = time_sort;
968                                 sort_function[1] = mem_sort;
969                                 sort_function[2] = pcpu_sort;
970                         }
971 #if ENABLE_FEATURE_TOPMEM
972                         if (c == 's') {
973                                 scan_mask = TOPMEM_MASK;
974                                 free(prev_hist);
975                                 prev_hist = NULL;
976                                 prev_hist_count = 0;
977                                 sort_field = (sort_field + 1) % NUM_SORT_FIELD;
978                         }
979                         if (c == 'r')
980                                 inverted ^= 1;
981 #endif
982 #endif
983                 }
984 #endif /* FEATURE_USE_TERMIOS */
985         }
986         putchar('\n');
987         return EXIT_SUCCESS;
988 }