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