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