procps/top.c

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