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