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  * Sept 2008: Vineet Gupta <vineet.gupta@arc.com>
  21  * Added Support for reporting SMP Information
  22  * - CPU where process was last seen running
  23  *   (to see effect of sched_setaffinity() etc)
  24  * - CPU time split (idle/IO/wait etc) per CPU
  25  *
  26  * Copyright (c) 1992 Branko Lankester
  27  * Copyright (c) 1992 Roger Binns
  28  * Copyright (C) 1994-1996 Charles L. Blake.
  29  * Copyright (C) 1992-1998 Michael K. Johnson
  30  *
  31  * Licensed under GPLv2, see file LICENSE in this source tree.
  32  */
  33 /* How to snapshot /proc for debugging top problems:
  34  * for f in /proc/[0-9]*""/stat; do
  35  *         n=${f#/proc/}
  36  *         n=${n%/stat}_stat
  37  *         cp $f $n
  38  * done
  39  * cp /proc/stat /proc/meminfo /proc/loadavg .
  40  * top -bn1 >top.out
  41  *
  42  * ...and how to run top on it on another machine:
  43  * rm -rf proc; mkdir proc
  44  * for f in [0-9]*_stat; do
  45  *         p=${f%_stat}
  46  *         mkdir -p proc/$p
  47  *         cp $f proc/$p/stat
  48  * done
  49  * cp stat meminfo loadavg proc
  50  * chroot . ./top -bn1 >top1.out
  51  */
  52 //config:config TOP
  53 //config:       bool "top (17 kb)"
  54 //config:       default y
  55 //config:       help
  56 //config:       The top program provides a dynamic real-time view of a running
  57 //config:       system.
  58 //config:
  59 //config:config FEATURE_TOP_INTERACTIVE
  60 //config:       bool "Accept keyboard commands"
  61 //config:       default y
  62 //config:       depends on TOP
  63 //config:       help
  64 //config:       Without this, top will only refresh display every 5 seconds.
  65 //config:       No keyboard commands will work, only ^C to terminate.
  66 //config:
  67 //config:config FEATURE_TOP_CPU_USAGE_PERCENTAGE
  68 //config:       bool "Show CPU per-process usage percentage"
  69 //config:       default y
  70 //config:       depends on TOP
  71 //config:       help
  72 //config:       Make top display CPU usage for each process.
  73 //config:       This adds about 2k.
  74 //config:
  75 //config:config FEATURE_TOP_CPU_GLOBAL_PERCENTS
  76 //config:       bool "Show CPU global usage percentage"
  77 //config:       default y
  78 //config:       depends on FEATURE_TOP_CPU_USAGE_PERCENTAGE
  79 //config:       help
  80 //config:       Makes top display "CPU: NN% usr NN% sys..." line.
  81 //config:       This adds about 0.5k.
  82 //config:
  83 //config:config FEATURE_TOP_SMP_CPU
  84 //config:       bool "SMP CPU usage display ('c' key)"
  85 //config:       default y
  86 //config:       depends on FEATURE_TOP_CPU_GLOBAL_PERCENTS
  87 //config:       help
  88 //config:       Allow 'c' key to switch between individual/cumulative CPU stats
  89 //config:       This adds about 0.5k.
  90 //config:
  91 //config:config FEATURE_TOP_DECIMALS
  92 //config:       bool "Show 1/10th of a percent in CPU/mem statistics"
  93 //config:       default y
  94 //config:       depends on FEATURE_TOP_CPU_USAGE_PERCENTAGE
  95 //config:       help
  96 //config:       Show 1/10th of a percent in CPU/mem statistics.
  97 //config:       This adds about 0.3k.
  98 //config:
  99 //config:config FEATURE_TOP_SMP_PROCESS
 100 //config:       bool "Show CPU process runs on ('j' field)"
 101 //config:       default y
 102 //config:       depends on TOP
 103 //config:       help
 104 //config:       Show CPU where process was last found running on.
 105 //config:       This is the 'j' field.
 106 //config:
 107 //config:config FEATURE_TOPMEM
 108 //config:       bool "Topmem command ('s' key)"
 109 //config:       default y
 110 //config:       depends on TOP
 111 //config:       help
 112 //config:       Enable 's' in top (gives lots of memory info).
 113
 114 //applet:IF_TOP(APPLET(top, BB_DIR_USR_BIN, BB_SUID_DROP))
 115
 116 //kbuild:lib-$(CONFIG_TOP) += top.o
 117
 118 #include "libbb.h"
 119
 120
 121 typedef struct top_status_t {
 122         unsigned long vsz;
 123 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 124         unsigned long ticks;
 125         unsigned pcpu; /* delta of ticks */
 126 #endif
 127         unsigned pid, ppid;
 128         unsigned uid;
 129         char state[4];
 130         char comm[COMM_LEN];
 131 #if ENABLE_FEATURE_TOP_SMP_PROCESS
 132         int last_seen_on_cpu;
 133 #endif
 134 } top_status_t;
 135
 136 typedef struct jiffy_counts_t {
 137         /* Linux 2.4.x has only first four */
 138         unsigned long long usr, nic, sys, idle;
 139         unsigned long long iowait, irq, softirq, steal;
 140         unsigned long long total;
 141         unsigned long long busy;
 142 } jiffy_counts_t;
 143
 144 /* This structure stores some critical information from one frame to
 145    the next. Used for finding deltas. */
 146 typedef struct save_hist {
 147         unsigned long ticks;
 148         pid_t pid;
 149 } save_hist;
 150
 151 typedef int (*cmp_funcp)(top_status_t *P, top_status_t *Q);
 152
 153
 154 enum { SORT_DEPTH = 3 };
 155
 156 /* Screens wider than this are unlikely */
 157 enum { LINE_BUF_SIZE = 512 - 64 };
 158
 159 struct globals {
 160         top_status_t *top;
 161         int ntop;
 162         smallint inverted;
 163 #if ENABLE_FEATURE_TOPMEM
 164         smallint sort_field;
 165 #endif
 166 #if ENABLE_FEATURE_TOP_SMP_CPU
 167         smallint smp_cpu_info; /* one/many cpu info lines? */
 168 #endif
 169         unsigned lines;  /* screen height */
 170 #if ENABLE_FEATURE_TOP_INTERACTIVE
 171         struct termios initial_settings;
 172         int scroll_ofs;
 173 #define G_scroll_ofs G.scroll_ofs
 174 #else
 175 #define G_scroll_ofs 0
 176 #endif
 177 #if !ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 178         cmp_funcp sort_function[1];
 179 #else
 180         cmp_funcp sort_function[SORT_DEPTH];
 181         struct save_hist *prev_hist;
 182         int prev_hist_count;
 183         jiffy_counts_t cur_jif, prev_jif;
 184         /* int hist_iterations; */
 185         unsigned total_pcpu;
 186         /* unsigned long total_vsz; */
 187 #endif
 188 #if ENABLE_FEATURE_TOP_SMP_CPU
 189         /* Per CPU samples: current and last */
 190         jiffy_counts_t *cpu_jif, *cpu_prev_jif;
 191         int num_cpus;
 192 #endif
 193 #if ENABLE_FEATURE_TOP_INTERACTIVE
 194         char kbd_input[KEYCODE_BUFFER_SIZE];
 195 #endif
 196         char line_buf[LINE_BUF_SIZE];
 197 };
 198 #define G (*ptr_to_globals)
 199 #define top              (G.top               )
 200 #define ntop             (G.ntop              )
 201 #define sort_field       (G.sort_field        )
 202 #define inverted         (G.inverted          )
 203 #define smp_cpu_info     (G.smp_cpu_info      )
 204 #define initial_settings (G.initial_settings  )
 205 #define sort_function    (G.sort_function     )
 206 #define prev_hist        (G.prev_hist         )
 207 #define prev_hist_count  (G.prev_hist_count   )
 208 #define cur_jif          (G.cur_jif           )
 209 #define prev_jif         (G.prev_jif          )
 210 #define cpu_jif          (G.cpu_jif           )
 211 #define cpu_prev_jif     (G.cpu_prev_jif      )
 212 #define num_cpus         (G.num_cpus          )
 213 #define total_pcpu       (G.total_pcpu        )
 214 #define line_buf         (G.line_buf          )
 215 #define INIT_G() do { \
 216         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 217         BUILD_BUG_ON(LINE_BUF_SIZE <= 80); \
 218 } while (0)
 219
 220 enum {
 221         OPT_d = (1 << 0),
 222         OPT_n = (1 << 1),
 223         OPT_b = (1 << 2),
 224         OPT_m = (1 << 3),
 225         OPT_EOF = (1 << 4), /* pseudo: "we saw EOF in stdin" */
 226 };
 227 #define OPT_BATCH_MODE (option_mask32 & OPT_b)
 228
 229
 230 #if ENABLE_FEATURE_TOP_INTERACTIVE
 231 static int pid_sort(top_status_t *P, top_status_t *Q)
 232 {
 233         /* Buggy wrt pids with high bit set */
 234         /* (linux pids are in [1..2^15-1]) */
 235         return (Q->pid - P->pid);
 236 }
 237 #endif
 238
 239 static int mem_sort(top_status_t *P, top_status_t *Q)
 240 {
 241         /* We want to avoid unsigned->signed and truncation errors */
 242         if (Q->vsz < P->vsz) return -1;
 243         return Q->vsz != P->vsz; /* 0 if ==, 1 if > */
 244 }
 245
 246
 247 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 248
 249 static int pcpu_sort(top_status_t *P, top_status_t *Q)
 250 {
 251         /* Buggy wrt ticks with high bit set */
 252         /* Affects only processes for which ticks overflow */
 253         return (int)Q->pcpu - (int)P->pcpu;
 254 }
 255
 256 static int time_sort(top_status_t *P, top_status_t *Q)
 257 {
 258         /* We want to avoid unsigned->signed and truncation errors */
 259         if (Q->ticks < P->ticks) return -1;
 260         return Q->ticks != P->ticks; /* 0 if ==, 1 if > */
 261 }
 262
 263 static int mult_lvl_cmp(void* a, void* b)
 264 {
 265         int i, cmp_val;
 266
 267         for (i = 0; i < SORT_DEPTH; i++) {
 268                 cmp_val = (*sort_function[i])(a, b);
 269                 if (cmp_val != 0)
 270                         break;
 271         }
 272         return inverted ? -cmp_val : cmp_val;
 273 }
 274
 275 static NOINLINE int read_cpu_jiffy(FILE *fp, jiffy_counts_t *p_jif)
 276 {
 277 #if !ENABLE_FEATURE_TOP_SMP_CPU
 278         static const char fmt[] ALIGN1 = "cpu %llu %llu %llu %llu %llu %llu %llu %llu";
 279 #else
 280         static const char fmt[] ALIGN1 = "cp%*s %llu %llu %llu %llu %llu %llu %llu %llu";
 281 #endif
 282         int ret;
 283
 284         if (!fgets(line_buf, LINE_BUF_SIZE, fp) || line_buf[0] != 'c' /* not "cpu" */)
 285                 return 0;
 286         ret = sscanf(line_buf, fmt,
 287                         &p_jif->usr, &p_jif->nic, &p_jif->sys, &p_jif->idle,
 288                         &p_jif->iowait, &p_jif->irq, &p_jif->softirq,
 289                         &p_jif->steal);
 290         if (ret >= 4) {
 291                 p_jif->total = p_jif->usr + p_jif->nic + p_jif->sys + p_jif->idle
 292                         + p_jif->iowait + p_jif->irq + p_jif->softirq + p_jif->steal;
 293                 /* procps 2.x does not count iowait as busy time */
 294                 p_jif->busy = p_jif->total - p_jif->idle - p_jif->iowait;
 295         }
 296
 297         return ret;
 298 }
 299
 300 static void get_jiffy_counts(void)
 301 {
 302         FILE* fp = xfopen_for_read("stat");
 303
 304         /* We need to parse cumulative counts even if SMP CPU display is on,
 305          * they are used to calculate per process CPU% */
 306         prev_jif = cur_jif;
 307         if (read_cpu_jiffy(fp, &cur_jif) < 4)
 308                 bb_error_msg_and_die("can't read '%s'", "/proc/stat");
 309
 310 #if !ENABLE_FEATURE_TOP_SMP_CPU
 311         fclose(fp);
 312         return;
 313 #else
 314         if (!smp_cpu_info) {
 315                 fclose(fp);
 316                 return;
 317         }
 318
 319         if (!num_cpus) {
 320                 /* First time here. How many CPUs?
 321                  * There will be at least 1 /proc/stat line with cpu%d
 322                  */
 323                 while (1) {
 324                         cpu_jif = xrealloc_vector(cpu_jif, 1, num_cpus);
 325                         if (read_cpu_jiffy(fp, &cpu_jif[num_cpus]) <= 4)
 326                                 break;
 327                         num_cpus++;
 328                 }
 329                 if (num_cpus == 0) /* /proc/stat with only "cpu ..." line?! */
 330                         smp_cpu_info = 0;
 331
 332                 cpu_prev_jif = xzalloc(sizeof(cpu_prev_jif[0]) * num_cpus);
 333
 334                 /* Otherwise the first per cpu display shows all 100% idles */
 335                 usleep(50000);
 336         } else { /* Non first time invocation */
 337                 jiffy_counts_t *tmp;
 338                 int i;
 339
 340                 /* First switch the sample pointers: no need to copy */
 341                 tmp = cpu_prev_jif;
 342                 cpu_prev_jif = cpu_jif;
 343                 cpu_jif = tmp;
 344
 345                 /* Get the new samples */
 346                 for (i = 0; i < num_cpus; i++)
 347                         read_cpu_jiffy(fp, &cpu_jif[i]);
 348         }
 349 #endif
 350         fclose(fp);
 351 }
 352
 353 static void do_stats(void)
 354 {
 355         top_status_t *cur;
 356         pid_t pid;
 357         int i, last_i, n;
 358         struct save_hist *new_hist;
 359
 360         get_jiffy_counts();
 361         total_pcpu = 0;
 362         /* total_vsz = 0; */
 363         new_hist = xmalloc(sizeof(new_hist[0]) * ntop);
 364         /*
 365          * Make a pass through the data to get stats.
 366          */
 367         /* hist_iterations = 0; */
 368         i = 0;
 369         for (n = 0; n < ntop; n++) {
 370                 cur = top + n;
 371
 372                 /*
 373                  * Calculate time in cur process.  Time is sum of user time
 374                  * and system time
 375                  */
 376                 pid = cur->pid;
 377                 new_hist[n].ticks = cur->ticks;
 378                 new_hist[n].pid = pid;
 379
 380                 /* find matching entry from previous pass */
 381                 cur->pcpu = 0;
 382                 /* do not start at index 0, continue at last used one
 383                  * (brought hist_iterations from ~14000 down to 172) */
 384                 last_i = i;
 385                 if (prev_hist_count) do {
 386                         if (prev_hist[i].pid == pid) {
 387                                 cur->pcpu = cur->ticks - prev_hist[i].ticks;
 388                                 total_pcpu += cur->pcpu;
 389                                 break;
 390                         }
 391                         i = (i+1) % prev_hist_count;
 392                         /* hist_iterations++; */
 393                 } while (i != last_i);
 394                 /* total_vsz += cur->vsz; */
 395         }
 396
 397         /*
 398          * Save cur frame's information.
 399          */
 400         free(prev_hist);
 401         prev_hist = new_hist;
 402         prev_hist_count = ntop;
 403 }
 404
 405 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
 406
 407 #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS && ENABLE_FEATURE_TOP_DECIMALS
 408 /* formats 7 char string (8 with terminating NUL) */
 409 static char *fmt_100percent_8(char pbuf[8], unsigned value, unsigned total)
 410 {
 411         unsigned t;
 412         if (value >= total) { /* 100% ? */
 413                 strcpy(pbuf, "  100% ");
 414                 return pbuf;
 415         }
 416         /* else generate " [N/space]N.N% " string */
 417         value = 1000 * value / total;
 418         t = value / 100;
 419         value = value % 100;
 420         pbuf[0] = ' ';
 421         pbuf[1] = t ? t + '0' : ' ';
 422         pbuf[2] = '0' + (value / 10);
 423         pbuf[3] = '.';
 424         pbuf[4] = '0' + (value % 10);
 425         pbuf[5] = '%';
 426         pbuf[6] = ' ';
 427         pbuf[7] = '\0';
 428         return pbuf;
 429 }
 430 #endif
 431
 432 #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS
 433 static void display_cpus(int scr_width, char *scrbuf, int *lines_rem_p)
 434 {
 435         /*
 436          * xxx% = (cur_jif.xxx - prev_jif.xxx) / (cur_jif.total - prev_jif.total) * 100%
 437          */
 438         unsigned total_diff;
 439         jiffy_counts_t *p_jif, *p_prev_jif;
 440         int i;
 441 # if ENABLE_FEATURE_TOP_SMP_CPU
 442         int n_cpu_lines;
 443 # endif
 444
 445         /* using (unsigned) casts to make operations cheaper */
 446 # define  CALC_TOTAL_DIFF do { \
 447         total_diff = (unsigned)(p_jif->total - p_prev_jif->total); \
 448         if (total_diff == 0) total_diff = 1; \
 449 } while (0)
 450
 451 # if ENABLE_FEATURE_TOP_DECIMALS
 452 #  define CALC_STAT(xxx) char xxx[8]
 453 #  define SHOW_STAT(xxx) fmt_100percent_8(xxx, (unsigned)(p_jif->xxx - p_prev_jif->xxx), total_diff)
 454 #  define FMT "%s"
 455 # else
 456 #  define CALC_STAT(xxx) unsigned xxx = 100 * (unsigned)(p_jif->xxx - p_prev_jif->xxx) / total_diff
 457 #  define SHOW_STAT(xxx) xxx
 458 #  define FMT "%4u%% "
 459 # endif
 460
 461 # if !ENABLE_FEATURE_TOP_SMP_CPU
 462         {
 463                 i = 1;
 464                 p_jif = &cur_jif;
 465                 p_prev_jif = &prev_jif;
 466 # else
 467         /* Loop thru CPU(s) */
 468         n_cpu_lines = smp_cpu_info ? num_cpus : 1;
 469         if (n_cpu_lines > *lines_rem_p)
 470                 n_cpu_lines = *lines_rem_p;
 471
 472         for (i = 0; i < n_cpu_lines; i++) {
 473                 p_jif = &cpu_jif[i];
 474                 p_prev_jif = &cpu_prev_jif[i];
 475 # endif
 476                 CALC_TOTAL_DIFF;
 477
 478                 { /* Need a block: CALC_STAT are declarations */
 479                         CALC_STAT(usr);
 480                         CALC_STAT(sys);
 481                         CALC_STAT(nic);
 482                         CALC_STAT(idle);
 483                         CALC_STAT(iowait);
 484                         CALC_STAT(irq);
 485                         CALC_STAT(softirq);
 486                         /*CALC_STAT(steal);*/
 487
 488                         snprintf(scrbuf, scr_width,
 489                                 /* Barely fits in 79 chars when in "decimals" mode. */
 490 # if ENABLE_FEATURE_TOP_SMP_CPU
 491                                 "CPU%s:"FMT"usr"FMT"sys"FMT"nic"FMT"idle"FMT"io"FMT"irq"FMT"sirq",
 492                                 (smp_cpu_info ? utoa(i) : ""),
 493 # else
 494                                 "CPU:"FMT"usr"FMT"sys"FMT"nic"FMT"idle"FMT"io"FMT"irq"FMT"sirq",
 495 # endif
 496                                 SHOW_STAT(usr), SHOW_STAT(sys), SHOW_STAT(nic), SHOW_STAT(idle),
 497                                 SHOW_STAT(iowait), SHOW_STAT(irq), SHOW_STAT(softirq)
 498                                 /*, SHOW_STAT(steal) - what is this 'steal' thing? */
 499                                 /* I doubt anyone wants to know it */
 500                         );
 501                         puts(scrbuf);
 502                 }
 503         }
 504 # undef SHOW_STAT
 505 # undef CALC_STAT
 506 # undef FMT
 507         *lines_rem_p -= i;
 508 }
 509 #else  /* !ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS */
 510 # define display_cpus(scr_width, scrbuf, lines_rem) ((void)0)
 511 #endif
 512
 513 enum {
 514         MI_MEMTOTAL,
 515         MI_MEMFREE,
 516         MI_MEMSHARED,
 517         MI_SHMEM,
 518         MI_BUFFERS,
 519         MI_CACHED,
 520         MI_SWAPTOTAL,
 521         MI_SWAPFREE,
 522         MI_DIRTY,
 523         MI_WRITEBACK,
 524         MI_ANONPAGES,
 525         MI_MAPPED,
 526         MI_SLAB,
 527         MI_MAX
 528 };
 529
 530 static void parse_meminfo(unsigned long meminfo[MI_MAX])
 531 {
 532         static const char fields[] ALIGN1 =
 533                 "MemTotal\0"
 534                 "MemFree\0"
 535                 "MemShared\0"
 536                 "Shmem\0"
 537                 "Buffers\0"
 538                 "Cached\0"
 539                 "SwapTotal\0"
 540                 "SwapFree\0"
 541                 "Dirty\0"
 542                 "Writeback\0"
 543                 "AnonPages\0"
 544                 "Mapped\0"
 545                 "Slab\0";
 546         char buf[60]; /* actual lines we expect are ~30 chars or less */
 547         FILE *f;
 548         int i;
 549
 550         memset(meminfo, 0, sizeof(meminfo[0]) * MI_MAX);
 551         f = xfopen_for_read("meminfo");
 552         while (fgets(buf, sizeof(buf), f) != NULL) {
 553                 char *c = strchr(buf, ':');
 554                 if (!c)
 555                         continue;
 556                 *c = '\0';
 557                 i = index_in_strings(fields, buf);
 558                 if (i >= 0)
 559                         meminfo[i] = strtoul(c+1, NULL, 10);
 560         }
 561         fclose(f);
 562 }
 563
 564 static unsigned long display_header(int scr_width, int *lines_rem_p)
 565 {
 566         char scrbuf[100]; /* [80] was a bit too low on 8Gb ram box */
 567         char *buf;
 568         unsigned long meminfo[MI_MAX];
 569
 570         parse_meminfo(meminfo);
 571
 572         /* Output memory info */
 573         if (scr_width > (int)sizeof(scrbuf))
 574                 scr_width = sizeof(scrbuf);
 575         snprintf(scrbuf, scr_width,
 576                 "Mem: %luK used, %luK free, %luK shrd, %luK buff, %luK cached",
 577                 meminfo[MI_MEMTOTAL] - meminfo[MI_MEMFREE],
 578                 meminfo[MI_MEMFREE],
 579                 meminfo[MI_MEMSHARED] + meminfo[MI_SHMEM],
 580                 meminfo[MI_BUFFERS],
 581                 meminfo[MI_CACHED]);
 582         /* Go to top & clear to the end of screen */
 583         printf(OPT_BATCH_MODE ? "%s\n" : "\033[H\033[J%s\n", scrbuf);
 584         (*lines_rem_p)--;
 585
 586         /* Display CPU time split as percentage of total time.
 587          * This displays either a cumulative line or one line per CPU.
 588          */
 589         display_cpus(scr_width, scrbuf, lines_rem_p);
 590
 591         /* Read load average as a string */
 592         buf = stpcpy(scrbuf, "Load average: ");
 593         open_read_close("loadavg", buf, sizeof(scrbuf) - sizeof("Load average: "));
 594         scrbuf[scr_width - 1] = '\0';
 595         strchrnul(buf, '\n')[0] = '\0';
 596         puts(scrbuf);
 597         (*lines_rem_p)--;
 598
 599         return meminfo[MI_MEMTOTAL];
 600 }
 601
 602 static NOINLINE void display_process_list(int lines_rem, int scr_width)
 603 {
 604         enum {
 605                 BITS_PER_INT = sizeof(int) * 8
 606         };
 607
 608         top_status_t *s;
 609         char vsz_str_buf[8];
 610         unsigned long total_memory = display_header(scr_width, &lines_rem); /* or use total_vsz? */
 611         /* xxx_shift and xxx_scale variables allow us to replace
 612          * expensive divides with multiply and shift */
 613         unsigned pmem_shift, pmem_scale, pmem_half;
 614 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 615         unsigned tmp_unsigned;
 616         unsigned pcpu_shift, pcpu_scale, pcpu_half;
 617         unsigned busy_jifs;
 618 #endif
 619
 620         /* what info of the processes is shown */
 621         printf(OPT_BATCH_MODE ? "%.*s" : "\033[7m%.*s\033[0m", scr_width,
 622                 "  PID  PPID USER     STAT   VSZ %VSZ"
 623                 IF_FEATURE_TOP_SMP_PROCESS(" CPU")
 624                 IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(" %CPU")
 625                 " COMMAND");
 626         lines_rem--;
 627
 628 #if ENABLE_FEATURE_TOP_DECIMALS
 629 # define UPSCALE 1000
 630 # define CALC_STAT(name, val) div_t name = div((val), 10)
 631 # define SHOW_STAT(name) name.quot, '0'+name.rem
 632 # define FMT "%3u.%c"
 633 #else
 634 # define UPSCALE 100
 635 # define CALC_STAT(name, val) unsigned name = (val)
 636 # define SHOW_STAT(name) name
 637 # define FMT "%4u%%"
 638 #endif
 639         /*
 640          * %VSZ = s->vsz/MemTotal
 641          */
 642         pmem_shift = BITS_PER_INT-11;
 643         pmem_scale = UPSCALE*(1U<<(BITS_PER_INT-11)) / total_memory;
 644         /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */
 645         while (pmem_scale >= 512) {
 646                 pmem_scale /= 4;
 647                 pmem_shift -= 2;
 648         }
 649         pmem_half = (1U << pmem_shift) / (ENABLE_FEATURE_TOP_DECIMALS ? 20 : 2);
 650 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 651         busy_jifs = cur_jif.busy - prev_jif.busy;
 652         /* This happens if there were lots of short-lived processes
 653          * between two top updates (e.g. compilation) */
 654         if (total_pcpu < busy_jifs) total_pcpu = busy_jifs;
 655
 656         /*
 657          * CPU% = s->pcpu/sum(s->pcpu) * busy_cpu_ticks/total_cpu_ticks
 658          * (pcpu is delta of sys+user time between samples)
 659          */
 660         /* (cur_jif.xxx - prev_jif.xxx) and s->pcpu are
 661          * in 0..~64000 range (HZ*update_interval).
 662          * we assume that unsigned is at least 32-bit.
 663          */
 664         pcpu_shift = 6;
 665         pcpu_scale = UPSCALE*64 * (uint16_t)busy_jifs;
 666         if (pcpu_scale == 0)
 667                 pcpu_scale = 1;
 668         while (pcpu_scale < (1U << (BITS_PER_INT-2))) {
 669                 pcpu_scale *= 4;
 670                 pcpu_shift += 2;
 671         }
 672         tmp_unsigned = (uint16_t)(cur_jif.total - prev_jif.total) * total_pcpu;
 673         if (tmp_unsigned != 0)
 674                 pcpu_scale /= tmp_unsigned;
 675         /* we want (s->pcpu * pcpu_scale) to never overflow */
 676         while (pcpu_scale >= 1024) {
 677                 pcpu_scale /= 4;
 678                 pcpu_shift -= 2;
 679         }
 680         pcpu_half = (1U << pcpu_shift) / (ENABLE_FEATURE_TOP_DECIMALS ? 20 : 2);
 681         /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */
 682 #endif
 683
 684         /* Ok, all preliminary data is ready, go through the list */
 685         scr_width += 2; /* account for leading '\n' and trailing NUL */
 686         if (lines_rem > ntop - G_scroll_ofs)
 687                 lines_rem = ntop - G_scroll_ofs;
 688         s = top + G_scroll_ofs;
 689         while (--lines_rem >= 0) {
 690                 unsigned col;
 691                 CALC_STAT(pmem, (s->vsz*pmem_scale + pmem_half) >> pmem_shift);
 692 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 693                 CALC_STAT(pcpu, (s->pcpu*pcpu_scale + pcpu_half) >> pcpu_shift);
 694 #endif
 695
 696                 if (s->vsz >= 100000)
 697                         sprintf(vsz_str_buf, "%6ldm", s->vsz/1024);
 698                 else
 699                         sprintf(vsz_str_buf, "%7lu", s->vsz);
 700                 /* PID PPID USER STAT VSZ %VSZ [%CPU] COMMAND */
 701                 col = snprintf(line_buf, scr_width,
 702                                 "\n" "%5u%6u %-8.8s %s%s" FMT
 703                                 IF_FEATURE_TOP_SMP_PROCESS(" %3d")
 704                                 IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(FMT)
 705                                 " ",
 706                                 s->pid, s->ppid, get_cached_username(s->uid),
 707                                 s->state, vsz_str_buf,
 708                                 SHOW_STAT(pmem)
 709                                 IF_FEATURE_TOP_SMP_PROCESS(, s->last_seen_on_cpu)
 710                                 IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(, SHOW_STAT(pcpu))
 711                 );
 712                 if ((int)(col + 1) < scr_width)
 713                         read_cmdline(line_buf + col, scr_width - col, s->pid, s->comm);
 714                 fputs(line_buf, stdout);
 715                 /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu,
 716                         cur_jif.busy - prev_jif.busy, cur_jif.total - prev_jif.total); */
 717                 s++;
 718         }
 719         /* printf(" %d", hist_iterations); */
 720         bb_putchar(OPT_BATCH_MODE ? '\n' : '\r');
 721         fflush_all();
 722 }
 723 #undef UPSCALE
 724 #undef SHOW_STAT
 725 #undef CALC_STAT
 726 #undef FMT
 727
 728 static void clearmems(void)
 729 {
 730         clear_username_cache();
 731         free(top);
 732         top = NULL;
 733 }
 734
 735 #if ENABLE_FEATURE_TOP_INTERACTIVE
 736 static void reset_term(void)
 737 {
 738         if (!OPT_BATCH_MODE)
 739                 tcsetattr_stdin_TCSANOW(&initial_settings);
 740 }
 741
 742 static void sig_catcher(int sig)
 743 {
 744         reset_term();
 745         kill_myself_with_sig(sig);
 746 }
 747 #endif /* FEATURE_TOP_INTERACTIVE */
 748
 749 /*
 750  * TOPMEM support
 751  */
 752
 753 typedef unsigned long mem_t;
 754
 755 typedef struct topmem_status_t {
 756         unsigned pid;
 757         char comm[COMM_LEN];
 758         /* vsz doesn't count /dev/xxx mappings except /dev/zero */
 759         mem_t vsz     ;
 760         mem_t vszrw   ;
 761         mem_t rss     ;
 762         mem_t rss_sh  ;
 763         mem_t dirty   ;
 764         mem_t dirty_sh;
 765         mem_t stack   ;
 766 } topmem_status_t;
 767
 768 enum { NUM_SORT_FIELD = 7 };
 769
 770 #define topmem ((topmem_status_t*)top)
 771
 772 #if ENABLE_FEATURE_TOPMEM
 773
 774 static int topmem_sort(char *a, char *b)
 775 {
 776         int n;
 777         mem_t l, r;
 778
 779         n = offsetof(topmem_status_t, vsz) + (sort_field * sizeof(mem_t));
 780         l = *(mem_t*)(a + n);
 781         r = *(mem_t*)(b + n);
 782         if (l == r) {
 783                 l = ((topmem_status_t*)a)->dirty;
 784                 r = ((topmem_status_t*)b)->dirty;
 785         }
 786         /* We want to avoid unsigned->signed and truncation errors */
 787         /* l>r: -1, l=r: 0, l<r: 1 */
 788         n = (l > r) ? -1 : (l != r);
 789         return inverted ? -n : n;
 790 }
 791
 792 /* display header info (meminfo / loadavg) */
 793 static void display_topmem_header(int scr_width, int *lines_rem_p)
 794 {
 795         unsigned long meminfo[MI_MAX];
 796
 797         parse_meminfo(meminfo);
 798
 799         snprintf(line_buf, LINE_BUF_SIZE,
 800                 "Mem total:%lu anon:%lu map:%lu free:%lu",
 801                 meminfo[MI_MEMTOTAL],
 802                 meminfo[MI_ANONPAGES],
 803                 meminfo[MI_MAPPED],
 804                 meminfo[MI_MEMFREE]);
 805         printf(OPT_BATCH_MODE ? "%.*s\n" : "\033[H\033[J%.*s\n", scr_width, line_buf);
 806
 807         snprintf(line_buf, LINE_BUF_SIZE,
 808                 " slab:%lu buf:%lu cache:%lu dirty:%lu write:%lu",
 809                 meminfo[MI_SLAB],
 810                 meminfo[MI_BUFFERS],
 811                 meminfo[MI_CACHED],
 812                 meminfo[MI_DIRTY],
 813                 meminfo[MI_WRITEBACK]);
 814         printf("%.*s\n", scr_width, line_buf);
 815
 816         snprintf(line_buf, LINE_BUF_SIZE,
 817                 "Swap total:%lu free:%lu", // TODO: % used?
 818                 meminfo[MI_SWAPTOTAL],
 819                 meminfo[MI_SWAPFREE]);
 820         printf("%.*s\n", scr_width, line_buf);
 821
 822         (*lines_rem_p) -= 3;
 823 }
 824
 825 static void ulltoa6_and_space(unsigned long long ul, char buf[6])
 826 {
 827         /* see http://en.wikipedia.org/wiki/Tera */
 828         smart_ulltoa5(ul, buf, " mgtpezy")[0] = ' ';
 829 }
 830
 831 static NOINLINE void display_topmem_process_list(int lines_rem, int scr_width)
 832 {
 833 #define HDR_STR "  PID   VSZ VSZRW   RSS (SHR) DIRTY (SHR) STACK"
 834 #define MIN_WIDTH sizeof(HDR_STR)
 835         const topmem_status_t *s = topmem + G_scroll_ofs;
 836         char *cp, ch;
 837
 838         display_topmem_header(scr_width, &lines_rem);
 839
 840         strcpy(line_buf, HDR_STR " COMMAND");
 841         /* Mark the ^FIELD^ we sort by */
 842         cp = &line_buf[5 + sort_field * 6];
 843         ch = "^_"[inverted];
 844         cp[6] = ch;
 845         do *cp++ = ch; while (*cp == ' ');
 846
 847         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width, line_buf);
 848         lines_rem--;
 849
 850         if (lines_rem > ntop - G_scroll_ofs)
 851                 lines_rem = ntop - G_scroll_ofs;
 852         while (--lines_rem >= 0) {
 853                 /* PID VSZ VSZRW RSS (SHR) DIRTY (SHR) COMMAND */
 854                 ulltoa6_and_space(s->pid     , &line_buf[0*6]);
 855                 ulltoa6_and_space(s->vsz     , &line_buf[1*6]);
 856                 ulltoa6_and_space(s->vszrw   , &line_buf[2*6]);
 857                 ulltoa6_and_space(s->rss     , &line_buf[3*6]);
 858                 ulltoa6_and_space(s->rss_sh  , &line_buf[4*6]);
 859                 ulltoa6_and_space(s->dirty   , &line_buf[5*6]);
 860                 ulltoa6_and_space(s->dirty_sh, &line_buf[6*6]);
 861                 ulltoa6_and_space(s->stack   , &line_buf[7*6]);
 862                 line_buf[8*6] = '\0';
 863                 if (scr_width > (int)MIN_WIDTH) {
 864                         read_cmdline(&line_buf[8*6], scr_width - MIN_WIDTH, s->pid, s->comm);
 865                 }
 866                 printf("\n""%.*s", scr_width, line_buf);
 867                 s++;
 868         }
 869         bb_putchar(OPT_BATCH_MODE ? '\n' : '\r');
 870         fflush_all();
 871 #undef HDR_STR
 872 #undef MIN_WIDTH
 873 }
 874
 875 #else
 876 void display_topmem_process_list(int lines_rem, int scr_width);
 877 int topmem_sort(char *a, char *b);
 878 #endif /* TOPMEM */
 879
 880 /*
 881  * end TOPMEM support
 882  */
 883
 884 enum {
 885         TOP_MASK = 0
 886                 | PSSCAN_PID
 887                 | PSSCAN_PPID
 888                 | PSSCAN_VSZ
 889                 | PSSCAN_STIME
 890                 | PSSCAN_UTIME
 891                 | PSSCAN_STATE
 892                 | PSSCAN_COMM
 893                 | PSSCAN_CPU
 894                 | PSSCAN_UIDGID,
 895         TOPMEM_MASK = 0
 896                 | PSSCAN_PID
 897                 | PSSCAN_SMAPS
 898                 | PSSCAN_COMM,
 899         EXIT_MASK = (unsigned)-1,
 900 };
 901
 902 #if ENABLE_FEATURE_TOP_INTERACTIVE
 903 static unsigned handle_input(unsigned scan_mask, unsigned interval)
 904 {
 905         if (option_mask32 & OPT_EOF) {
 906                 /* EOF on stdin ("top </dev/null") */
 907                 sleep(interval);
 908                 return scan_mask;
 909         }
 910
 911         while (1) {
 912                 int32_t c;
 913
 914                 c = read_key(STDIN_FILENO, G.kbd_input, interval * 1000);
 915                 if (c == -1 && errno != EAGAIN) {
 916                         /* error/EOF */
 917                         option_mask32 |= OPT_EOF;
 918                         break;
 919                 }
 920                 interval = 0;
 921
 922                 if (c == initial_settings.c_cc[VINTR])
 923                         return EXIT_MASK;
 924                 if (c == initial_settings.c_cc[VEOF])
 925                         return EXIT_MASK;
 926
 927                 if (c == KEYCODE_UP) {
 928                         G_scroll_ofs--;
 929                         goto normalize_ofs;
 930                 }
 931                 if (c == KEYCODE_DOWN) {
 932                         G_scroll_ofs++;
 933                         goto normalize_ofs;
 934                 }
 935                 if (c == KEYCODE_HOME) {
 936                         G_scroll_ofs = 0;
 937                         break;
 938                 }
 939                 if (c == KEYCODE_END) {
 940                         G_scroll_ofs = ntop - G.lines / 2;
 941                         goto normalize_ofs;
 942                 }
 943                 if (c == KEYCODE_PAGEUP) {
 944                         G_scroll_ofs -= G.lines / 2;
 945                         goto normalize_ofs;
 946                 }
 947                 if (c == KEYCODE_PAGEDOWN) {
 948                         G_scroll_ofs += G.lines / 2;
 949  normalize_ofs:
 950                         if (G_scroll_ofs >= ntop)
 951                                 G_scroll_ofs = ntop - 1;
 952                         if (G_scroll_ofs < 0)
 953                                 G_scroll_ofs = 0;
 954                         break;
 955                 }
 956
 957                 c |= 0x20; /* lowercase */
 958                 if (c == 'q')
 959                         return EXIT_MASK;
 960
 961                 if (c == 'n') {
 962                         IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
 963                         sort_function[0] = pid_sort;
 964                         continue;
 965                 }
 966                 if (c == 'm') {
 967                         IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
 968                         sort_function[0] = mem_sort;
 969 # if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 970                         sort_function[1] = pcpu_sort;
 971                         sort_function[2] = time_sort;
 972 # endif
 973                         continue;
 974                 }
 975 # if ENABLE_FEATURE_SHOW_THREADS
 976                 if (c == 'h'
 977                 IF_FEATURE_TOPMEM(&& scan_mask != TOPMEM_MASK)
 978                 ) {
 979                         scan_mask ^= PSSCAN_TASKS;
 980                         continue;
 981                 }
 982 # endif
 983 # if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 984                 if (c == 'p') {
 985                         IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
 986                         sort_function[0] = pcpu_sort;
 987                         sort_function[1] = mem_sort;
 988                         sort_function[2] = time_sort;
 989                         continue;
 990                 }
 991                 if (c == 't') {
 992                         IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
 993                         sort_function[0] = time_sort;
 994                         sort_function[1] = mem_sort;
 995                         sort_function[2] = pcpu_sort;
 996                         continue;
 997                 }
 998 #  if ENABLE_FEATURE_TOPMEM
 999                 if (c == 's') {
1000                         scan_mask = TOPMEM_MASK;
1001                         free(prev_hist);
1002                         prev_hist = NULL;
1003                         prev_hist_count = 0;
1004                         sort_field = (sort_field + 1) % NUM_SORT_FIELD;
1005                         continue;
1006                 }
1007 #  endif
1008                 if (c == 'r') {
1009                         inverted ^= 1;
1010                         continue;
1011                 }
1012 #  if ENABLE_FEATURE_TOP_SMP_CPU
1013                 /* procps-2.0.18 uses 'C', 3.2.7 uses '1' */
1014                 if (c == 'c' || c == '1') {
1015                         /* User wants to toggle per cpu <> aggregate */
1016                         if (smp_cpu_info) {
1017                                 free(cpu_prev_jif);
1018                                 free(cpu_jif);
1019                                 cpu_jif = &cur_jif;
1020                                 cpu_prev_jif = &prev_jif;
1021                         } else {
1022                                 /* Prepare for xrealloc() */
1023                                 cpu_jif = cpu_prev_jif = NULL;
1024                         }
1025                         num_cpus = 0;
1026                         smp_cpu_info = !smp_cpu_info;
1027                         get_jiffy_counts();
1028                         continue;
1029                 }
1030 #  endif
1031 # endif
1032                 break; /* unknown key -> force refresh */
1033         }
1034
1035         return scan_mask;
1036 }
1037 #endif
1038
1039 //usage:#if ENABLE_FEATURE_SHOW_THREADS || ENABLE_FEATURE_TOP_SMP_CPU
1040 //usage:# define IF_SHOW_THREADS_OR_TOP_SMP(...) __VA_ARGS__
1041 //usage:#else
1042 //usage:# define IF_SHOW_THREADS_OR_TOP_SMP(...)
1043 //usage:#endif
1044 //usage:#define top_trivial_usage
1045 //usage:       "[-b] [-nCOUNT] [-dSECONDS]" IF_FEATURE_TOPMEM(" [-m]")
1046 //usage:#define top_full_usage "\n\n"
1047 //usage:       "Provide a view of process activity in real time."
1048 //usage:   "\n""Read the status of all processes from /proc each SECONDS"
1049 //usage:   "\n""and display a screenful of them."
1050 //usage:   "\n"
1051 //usage:        IF_FEATURE_TOP_INTERACTIVE(
1052 //usage:       "Keys:"
1053 //usage:   "\n""        N/M"
1054 //usage:                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/P")
1055 //usage:                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/T")
1056 //usage:           ": " IF_FEATURE_TOPMEM("show CPU usage, ") "sort by pid/mem"
1057 //usage:                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/cpu")
1058 //usage:                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/time")
1059 //usage:        IF_FEATURE_TOPMEM(
1060 //usage:   "\n""        S: show memory"
1061 //usage:        )
1062 //usage:   "\n""        R: reverse sort"
1063 //usage:        IF_SHOW_THREADS_OR_TOP_SMP(
1064 //usage:   "\n""        "
1065 //usage:                IF_FEATURE_SHOW_THREADS("H: toggle threads")
1066 //usage:                IF_FEATURE_SHOW_THREADS(IF_FEATURE_TOP_SMP_CPU(", "))
1067 //usage:                IF_FEATURE_TOP_SMP_CPU("1: toggle SMP")
1068 //usage:        )
1069 //usage:   "\n""        Q,^C: exit"
1070 //usage:   "\n"
1071 //usage:   "\n""Options:"
1072 //usage:        )
1073 //usage:   "\n""        -b      Batch mode"
1074 //usage:   "\n""        -n N    Exit after N iterations"
1075 //usage:   "\n""        -d N    Delay between updates"
1076 //usage:        IF_FEATURE_TOPMEM(
1077 //usage:   "\n""        -m      Same as 's' key"
1078 //usage:        )
1079
1080 /* Interactive testing:
1081  * echo sss | ./busybox top
1082  * - shows memory screen
1083  * echo sss | ./busybox top -bn1 >mem
1084  * - saves memory screen - the *whole* list, not first NROWS processes!
1085  * echo .m.s.s.s.s.s.s.q | ./busybox top -b >z
1086  * - saves several different screens, and exits
1087  *
1088  * TODO: -i STRING param as a better alternative?
1089  */
1090
1091 int top_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1092 int top_main(int argc UNUSED_PARAM, char **argv)
1093 {
1094         int iterations;
1095         unsigned col;
1096         unsigned interval;
1097         char *str_interval, *str_iterations;
1098         unsigned scan_mask = TOP_MASK;
1099
1100         INIT_G();
1101
1102         interval = 5; /* default update interval is 5 seconds */
1103         iterations = 0; /* infinite */
1104 #if ENABLE_FEATURE_TOP_SMP_CPU
1105         /*num_cpus = 0;*/
1106         /*smp_cpu_info = 0;*/  /* to start with show aggregate */
1107         cpu_jif = &cur_jif;
1108         cpu_prev_jif = &prev_jif;
1109 #endif
1110
1111         /* all args are options; -n NUM */
1112         make_all_argv_opts(argv); /* options can be specified w/o dash */
1113         col = getopt32(argv, "d:n:b"IF_FEATURE_TOPMEM("m"), &str_interval, &str_iterations);
1114 #if ENABLE_FEATURE_TOPMEM
1115         if (col & OPT_m) /* -m (busybox specific) */
1116                 scan_mask = TOPMEM_MASK;
1117 #endif
1118         if (col & OPT_d) {
1119                 /* work around for "-d 1" -> "-d -1" done by make_all_argv_opts() */
1120                 if (str_interval[0] == '-')
1121                         str_interval++;
1122                 /* Need to limit it to not overflow poll timeout */
1123                 interval = xatou16(str_interval);
1124         }
1125         if (col & OPT_n) {
1126                 if (str_iterations[0] == '-')
1127                         str_iterations++;
1128                 iterations = xatou(str_iterations);
1129         }
1130
1131         /* change to /proc */
1132         xchdir("/proc");
1133
1134 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
1135         sort_function[0] = pcpu_sort;
1136         sort_function[1] = mem_sort;
1137         sort_function[2] = time_sort;
1138 #else
1139         sort_function[0] = mem_sort;
1140 #endif
1141
1142         if (OPT_BATCH_MODE) {
1143                 option_mask32 |= OPT_EOF;
1144         }
1145 #if ENABLE_FEATURE_TOP_INTERACTIVE
1146         else {
1147                 /* Turn on unbuffered input; turn off echoing, ^C ^Z etc */
1148                 set_termios_to_raw(STDIN_FILENO, &initial_settings, TERMIOS_CLEAR_ISIG);
1149                 die_func = reset_term;
1150         }
1151
1152         bb_signals(BB_FATAL_SIGS, sig_catcher);
1153
1154         /* Eat initial input, if any */
1155         scan_mask = handle_input(scan_mask, 0);
1156 #endif
1157
1158         while (scan_mask != EXIT_MASK) {
1159                 procps_status_t *p = NULL;
1160
1161                 if (OPT_BATCH_MODE) {
1162                         G.lines = INT_MAX;
1163                         col = LINE_BUF_SIZE - 2; /* +2 bytes for '\n', NUL */
1164                 } else {
1165                         G.lines = 24; /* default */
1166                         col = 79;
1167                         /* We output to stdout, we need size of stdout (not stdin)! */
1168                         get_terminal_width_height(STDOUT_FILENO, &col, &G.lines);
1169                         if (G.lines < 5 || col < 10) {
1170                                 sleep(interval);
1171                                 continue;
1172                         }
1173                         if (col > LINE_BUF_SIZE - 2)
1174                                 col = LINE_BUF_SIZE - 2;
1175                 }
1176
1177                 /* read process IDs & status for all the processes */
1178                 ntop = 0;
1179                 while ((p = procps_scan(p, scan_mask)) != NULL) {
1180                         int n;
1181
1182                         IF_FEATURE_TOPMEM(if (scan_mask != TOPMEM_MASK)) {
1183                                 n = ntop;
1184                                 top = xrealloc_vector(top, 6, ntop++);
1185                                 top[n].pid = p->pid;
1186                                 top[n].ppid = p->ppid;
1187                                 top[n].vsz = p->vsz;
1188 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
1189                                 top[n].ticks = p->stime + p->utime;
1190 #endif
1191                                 top[n].uid = p->uid;
1192                                 strcpy(top[n].state, p->state);
1193                                 strcpy(top[n].comm, p->comm);
1194 #if ENABLE_FEATURE_TOP_SMP_PROCESS
1195                                 top[n].last_seen_on_cpu = p->last_seen_on_cpu;
1196 #endif
1197                         }
1198 #if ENABLE_FEATURE_TOPMEM
1199                         else { /* TOPMEM */
1200                                 if (!(p->smaps.mapped_ro | p->smaps.mapped_rw))
1201                                         continue; /* kernel threads are ignored */
1202                                 n = ntop;
1203                                 /* No bug here - top and topmem are the same */
1204                                 top = xrealloc_vector(topmem, 6, ntop++);
1205                                 strcpy(topmem[n].comm, p->comm);
1206                                 topmem[n].pid      = p->pid;
1207                                 topmem[n].vsz      = p->smaps.mapped_rw + p->smaps.mapped_ro;
1208                                 topmem[n].vszrw    = p->smaps.mapped_rw;
1209                                 topmem[n].rss_sh   = p->smaps.shared_clean + p->smaps.shared_dirty;
1210                                 topmem[n].rss      = p->smaps.private_clean + p->smaps.private_dirty + topmem[n].rss_sh;
1211                                 topmem[n].dirty    = p->smaps.private_dirty + p->smaps.shared_dirty;
1212                                 topmem[n].dirty_sh = p->smaps.shared_dirty;
1213                                 topmem[n].stack    = p->smaps.stack;
1214                         }
1215 #endif
1216                 } /* end of "while we read /proc" */
1217                 if (ntop == 0) {
1218                         bb_error_msg("no process info in /proc");
1219                         break;
1220                 }
1221
1222                 IF_FEATURE_TOPMEM(if (scan_mask != TOPMEM_MASK)) {
1223 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
1224                         if (!prev_hist_count) {
1225                                 do_stats();
1226                                 usleep(100000);
1227                                 clearmems();
1228                                 continue;
1229                         }
1230                         do_stats();
1231                         /* TODO: we don't need to sort all 10000 processes, we need to find top 24! */
1232                         qsort(top, ntop, sizeof(top_status_t), (void*)mult_lvl_cmp);
1233 #else
1234                         qsort(top, ntop, sizeof(top_status_t), (void*)(sort_function[0]));
1235 #endif
1236                         display_process_list(G.lines, col);
1237                 }
1238 #if ENABLE_FEATURE_TOPMEM
1239                 else { /* TOPMEM */
1240                         qsort(topmem, ntop, sizeof(topmem_status_t), (void*)topmem_sort);
1241                         display_topmem_process_list(G.lines, col);
1242                 }
1243 #endif
1244                 clearmems();
1245                 if (iterations >= 0 && !--iterations)
1246                         break;
1247 #if !ENABLE_FEATURE_TOP_INTERACTIVE
1248                 sleep(interval);
1249 #else
1250                 scan_mask = handle_input(scan_mask, interval);
1251 #endif
1252         } /* end of "while (not Q)" */
1253
1254         bb_putchar('\n');
1255 #if ENABLE_FEATURE_TOP_INTERACTIVE
1256         reset_term();
1257 #endif
1258         if (ENABLE_FEATURE_CLEAN_UP) {
1259                 clearmems();
1260 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
1261                 free(prev_hist);
1262 #endif
1263         }
1264         return EXIT_SUCCESS;
1265 }