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 enum { SORT_DEPTH = 3 };
  62
  63 struct globals {
  64         top_status_t *top;
  65         int ntop;
  66 #if ENABLE_FEATURE_USE_TERMIOS
  67         struct termios initial_settings;
  68 #endif
  69 #if !ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  70         cmp_funcp sort_function;
  71 #else
  72         cmp_funcp sort_function[SORT_DEPTH];
  73         struct save_hist *prev_hist;
  74         int prev_hist_count;
  75         jiffy_counts_t jif, prev_jif;
  76         /* int hist_iterations; */
  77         unsigned total_pcpu;
  78         /* unsigned long total_vsz; */
  79 #endif
  80 };
  81 #define G (*(struct globals*)&bb_common_bufsiz1)
  82 #define top              (G.top               )
  83 #define ntop             (G.ntop              )
  84 #if ENABLE_FEATURE_USE_TERMIOS
  85 #define initial_settings (G. initial_settings )
  86 #endif
  87 #define sort_function    (G.sort_function     )
  88 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  89 #define prev_hist        (G.prev_hist         )
  90 #define prev_hist_count  (G.prev_hist_count   )
  91 #define jif              (G.jif               )
  92 #define prev_jif         (G.prev_jif          )
  93 #define total_pcpu       (G.total_pcpu        )
  94 #endif
  95
  96 #define OPT_BATCH_MODE (option_mask32 & 0x4)
  97
  98
  99 #if ENABLE_FEATURE_USE_TERMIOS
 100 static int pid_sort(top_status_t *P, top_status_t *Q)
 101 {
 102         /* Buggy wrt pids with high bit set */
 103         /* (linux pids are in [1..2^15-1]) */
 104         return (Q->pid - P->pid);
 105 }
 106 #endif
 107
 108 static int mem_sort(top_status_t *P, top_status_t *Q)
 109 {
 110         /* We want to avoid unsigned->signed and truncation errors */
 111         if (Q->vsz < P->vsz) return -1;
 112         return Q->vsz != P->vsz; /* 0 if ==, 1 if > */
 113 }
 114
 115
 116 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 117
 118 static int pcpu_sort(top_status_t *P, top_status_t *Q)
 119 {
 120         /* Buggy wrt ticks with high bit set */
 121         /* Affects only processes for which ticks overflow */
 122         return (int)Q->pcpu - (int)P->pcpu;
 123 }
 124
 125 static int time_sort(top_status_t *P, top_status_t *Q)
 126 {
 127         /* We want to avoid unsigned->signed and truncation errors */
 128         if (Q->ticks < P->ticks) return -1;
 129         return Q->ticks != P->ticks; /* 0 if ==, 1 if > */
 130 }
 131
 132 static int mult_lvl_cmp(void* a, void* b)
 133 {
 134         int i, cmp_val;
 135
 136         for (i = 0; i < SORT_DEPTH; i++) {
 137                 cmp_val = (*sort_function[i])(a, b);
 138                 if (cmp_val != 0)
 139                         return cmp_val;
 140         }
 141         return 0;
 142 }
 143
 144
 145 static void get_jiffy_counts(void)
 146 {
 147         FILE* fp = xfopen("stat", "r");
 148         prev_jif = jif;
 149         if (fscanf(fp, "cpu  %lld %lld %lld %lld %lld %lld %lld %lld",
 150                         &jif.usr,&jif.nic,&jif.sys,&jif.idle,
 151                         &jif.iowait,&jif.irq,&jif.softirq,&jif.steal) < 4) {
 152                 bb_error_msg_and_die("failed to read /proc/stat");
 153         }
 154         fclose(fp);
 155         jif.total = jif.usr + jif.nic + jif.sys + jif.idle
 156                         + jif.iowait + jif.irq + jif.softirq + jif.steal;
 157         /* procps 2.x does not count iowait as busy time */
 158         jif.busy = jif.total - jif.idle - jif.iowait;
 159 }
 160
 161
 162 static void do_stats(void)
 163 {
 164         top_status_t *cur;
 165         pid_t pid;
 166         int i, last_i, n;
 167         struct save_hist *new_hist;
 168
 169         get_jiffy_counts();
 170         total_pcpu = 0;
 171         /* total_vsz = 0; */
 172         new_hist = xmalloc(sizeof(struct save_hist)*ntop);
 173         /*
 174          * Make a pass through the data to get stats.
 175          */
 176         /* hist_iterations = 0; */
 177         i = 0;
 178         for (n = 0; n < ntop; n++) {
 179                 cur = top + n;
 180
 181                 /*
 182                  * Calculate time in cur process.  Time is sum of user time
 183                  * and system time
 184                  */
 185                 pid = cur->pid;
 186                 new_hist[n].ticks = cur->ticks;
 187                 new_hist[n].pid = pid;
 188
 189                 /* find matching entry from previous pass */
 190                 cur->pcpu = 0;
 191                 /* do not start at index 0, continue at last used one
 192                  * (brought hist_iterations from ~14000 down to 172) */
 193                 last_i = i;
 194                 if (prev_hist_count) do {
 195                         if (prev_hist[i].pid == pid) {
 196                                 cur->pcpu = cur->ticks - prev_hist[i].ticks;
 197                                 total_pcpu += cur->pcpu;
 198                                 break;
 199                         }
 200                         i = (i+1) % prev_hist_count;
 201                         /* hist_iterations++; */
 202                 } while (i != last_i);
 203                 /* total_vsz += cur->vsz; */
 204         }
 205
 206         /*
 207          * Save cur frame's information.
 208          */
 209         free(prev_hist);
 210         prev_hist = new_hist;
 211         prev_hist_count = ntop;
 212 }
 213 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
 214
 215
 216 /* display generic info (meminfo / loadavg) */
 217 static unsigned long display_generic(int scr_width)
 218 {
 219         FILE *fp;
 220         char buf[80];
 221         char scrbuf[80];
 222         char *end;
 223         unsigned long total, used, mfree, shared, buffers, cached;
 224
 225         /* read memory info */
 226         fp = xfopen("meminfo", "r");
 227
 228         /*
 229          * Old kernels (such as 2.4.x) had a nice summary of memory info that
 230          * we could parse, however this is gone entirely in 2.6. Try parsing
 231          * the old way first, and if that fails, parse each field manually.
 232          *
 233          * First, we read in the first line. Old kernels will have bogus
 234          * strings we don't care about, whereas new kernels will start right
 235          * out with MemTotal:
 236          *                              -- PFM.
 237          */
 238         if (fscanf(fp, "MemTotal: %lu %s\n", &total, buf) != 2) {
 239                 fgets(buf, sizeof(buf), fp);    /* skip first line */
 240
 241                 fscanf(fp, "Mem: %lu %lu %lu %lu %lu %lu",
 242                         &total, &used, &mfree, &shared, &buffers, &cached);
 243                 /* convert to kilobytes */
 244                 used /= 1024;
 245                 mfree /= 1024;
 246                 shared /= 1024;
 247                 buffers /= 1024;
 248                 cached /= 1024;
 249                 total /= 1024;
 250         } else {
 251                 /*
 252                  * Revert to manual parsing, which incidentally already has the
 253                  * sizes in kilobytes. This should be safe for both 2.4 and
 254                  * 2.6.
 255                  */
 256
 257                 fscanf(fp, "MemFree: %lu %s\n", &mfree, buf);
 258
 259                 /*
 260                  * MemShared: is no longer present in 2.6. Report this as 0,
 261                  * to maintain consistent behavior with normal procps.
 262                  */
 263                 if (fscanf(fp, "MemShared: %lu %s\n", &shared, buf) != 2)
 264                         shared = 0;
 265
 266                 fscanf(fp, "Buffers: %lu %s\n", &buffers, buf);
 267                 fscanf(fp, "Cached: %lu %s\n", &cached, buf);
 268
 269                 used = total - mfree;
 270         }
 271         fclose(fp);
 272
 273         /* read load average as a string */
 274         buf[0] = '\0';
 275         open_read_close("loadavg", buf, sizeof(buf));
 276         end = strchr(buf, ' ');
 277         if (end) end = strchr(end+1, ' ');
 278         if (end) end = strchr(end+1, ' ');
 279         if (end) *end = '\0';
 280
 281         /* output memory info and load average */
 282         /* clear screen & go to top */
 283         if (scr_width > sizeof(scrbuf))
 284                 scr_width = sizeof(scrbuf);
 285         snprintf(scrbuf, scr_width,
 286                 "Mem: %ldK used, %ldK free, %ldK shrd, %ldK buff, %ldK cached",
 287                 used, mfree, shared, buffers, cached);
 288
 289         printf(OPT_BATCH_MODE ? "%s\n" : "\e[H\e[J%s\n", scrbuf);
 290
 291         if (ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS) {
 292                 /*
 293                  * xxx% = (jif.xxx - prev_jif.xxx) / (jif.total - prev_jif.total) * 100%
 294                  */
 295                 /* using (unsigned) cast to make multiplication cheaper: */
 296 #if ENABLE_FEATURE_TOP_DECIMALS
 297 /* Generated code is approx +0.5k */
 298 #define CALC_STAT(xxx) div_t xxx = div(1000 * (unsigned)(jif.xxx - prev_jif.xxx) / total_diff, 10)
 299 #define SHOW_STAT(xxx) xxx.quot, '0'+xxx.rem
 300 #define FMT "%3u.%c%%"
 301 #else
 302 #define CALC_STAT(xxx) unsigned xxx = 100 * (unsigned)(jif.xxx - prev_jif.xxx) / total_diff
 303 #define SHOW_STAT(xxx) xxx
 304 #define FMT "%3u%%"
 305 #endif
 306                 unsigned total_diff = (jif.total - prev_jif.total ? : 1);
 307                 CALC_STAT(usr);
 308                 CALC_STAT(sys);
 309                 CALC_STAT(nic);
 310                 CALC_STAT(idle);
 311                 CALC_STAT(iowait);
 312                 CALC_STAT(irq);
 313                 CALC_STAT(softirq);
 314                 //CALC_STAT(steal);
 315
 316                 snprintf(scrbuf, scr_width,
 317                         /* Barely fits in 79 chars when in "decimals" mode.
 318                          * %3u in practice almost never displays "100"
 319                          * and thus has implicit leading space:  " 99" */
 320                         "CPU:"FMT" usr"FMT" sys"FMT" nice"FMT" idle"FMT" io"FMT" irq"FMT" softirq",
 321                         SHOW_STAT(usr), SHOW_STAT(sys), SHOW_STAT(nic), SHOW_STAT(idle),
 322                         SHOW_STAT(iowait), SHOW_STAT(irq), SHOW_STAT(softirq)
 323                         //, SHOW_STAT(steal) - what is this 'steal' thing?
 324                         // I doubt anyone wants to know it
 325                 );
 326                 puts(scrbuf);
 327 #undef SHOW_STAT
 328 #undef CALC_STAT
 329 #undef FMT
 330         }
 331
 332         snprintf(scrbuf, scr_width, "Load average: %s", buf);
 333         puts(scrbuf);
 334
 335         return total;
 336 }
 337
 338 #if ENABLE_FEATURE_TOP_DECIMALS
 339 #define UPSCALE 1000
 340 #define CALC_STAT(name, val) div_t name = div((val), 10)
 341 #define SHOW_STAT(name) name.quot, '0'+name.rem
 342 #define FMT "%3u.%c"
 343 #else
 344 #define UPSCALE 100
 345 #define CALC_STAT(name, val) unsigned name = (val)
 346 #define SHOW_STAT(name) name
 347 #define FMT " %3u%%"
 348 #endif
 349 /* display process statuses */
 350 static void display_status(int count, int scr_width)
 351 {
 352         enum {
 353                 BITS_PER_INT = sizeof(int)*8
 354         };
 355
 356         top_status_t *s = top;
 357         char vsz_str_buf[8];
 358         unsigned long total_memory = display_generic(scr_width); /* or use total_vsz? */
 359         /* xxx_shift and xxx_scale variables allow us to replace
 360          * expensive divides with multiply and shift */
 361         unsigned pmem_shift, pmem_scale, pmem_half;
 362 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 363         unsigned pcpu_shift, pcpu_scale, pcpu_half;
 364         unsigned busy_jifs;
 365
 366         /* what info of the processes is shown */
 367         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
 368                 "  PID  PPID USER     STAT   VSZ %MEM %CPU COMMAND");
 369 #define MIN_WIDTH \
 370         sizeof( "  PID  PPID USER     STAT   VSZ %MEM %CPU C")
 371 #else
 372
 373         /* !CPU_USAGE_PERCENTAGE */
 374         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
 375                 "  PID  PPID USER     STAT   VSZ %MEM COMMAND");
 376 #define MIN_WIDTH \
 377         sizeof( "  PID  PPID USER     STAT   VSZ %MEM C")
 378 #endif
 379
 380         /*
 381          * MEM% = s->vsz/MemTotal
 382          */
 383         pmem_shift = BITS_PER_INT-11;
 384         pmem_scale = UPSCALE*(1U<<(BITS_PER_INT-11)) / total_memory;
 385         /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */
 386         while (pmem_scale >= 512) {
 387                 pmem_scale /= 4;
 388                 pmem_shift -= 2;
 389         }
 390         pmem_half = (1U << pmem_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2);
 391 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 392         busy_jifs = jif.busy - prev_jif.busy;
 393         /* This happens if there were lots of short-lived processes
 394          * between two top updates (e.g. compilation) */
 395         if (total_pcpu < busy_jifs) total_pcpu = busy_jifs;
 396
 397         /*
 398          * CPU% = s->pcpu/sum(s->pcpu) * busy_cpu_ticks/total_cpu_ticks
 399          * (pcpu is delta of sys+user time between samples)
 400          */
 401         /* (jif.xxx - prev_jif.xxx) and s->pcpu are
 402          * in 0..~64000 range (HZ*update_interval).
 403          * we assume that unsigned is at least 32-bit.
 404          */
 405         pcpu_shift = 6;
 406         pcpu_scale = (UPSCALE*64*(uint16_t)busy_jifs ? : 1);
 407         while (pcpu_scale < (1U<<(BITS_PER_INT-2))) {
 408                 pcpu_scale *= 4;
 409                 pcpu_shift += 2;
 410         }
 411         pcpu_scale /= ( (uint16_t)(jif.total-prev_jif.total)*total_pcpu ? : 1);
 412         /* we want (s->pcpu * pcpu_scale) to never overflow */
 413         while (pcpu_scale >= 1024) {
 414                 pcpu_scale /= 4;
 415                 pcpu_shift -= 2;
 416         }
 417         pcpu_half = (1U << pcpu_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2);
 418         /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */
 419 #endif
 420
 421         /* Ok, all prelim data is ready, go thru the list */
 422         while (count-- > 0) {
 423                 int col = scr_width;
 424                 CALC_STAT(pmem, (s->vsz*pmem_scale + pmem_half) >> pmem_shift);
 425 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 426                 CALC_STAT(pcpu, (s->pcpu*pcpu_scale + pcpu_half) >> pcpu_shift);
 427 #endif
 428
 429                 if (s->vsz >= 100*1024)
 430                         sprintf(vsz_str_buf, "%6ldM", s->vsz/1024);
 431                 else
 432                         sprintf(vsz_str_buf, "%7ld", s->vsz);
 433                 // PID PPID USER STAT VSZ %MEM [%CPU] COMMAND
 434                 col -= printf("\n" "%5u%6u %-8s %s%s" FMT
 435 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 436                                 FMT
 437 #endif
 438                                 " ",
 439                                 s->pid, s->ppid, get_cached_username(s->uid),
 440                                 s->state, vsz_str_buf,
 441                                 SHOW_STAT(pmem)
 442 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 443                                 , SHOW_STAT(pcpu)
 444 #endif
 445                 );
 446                 if (col > 0) {
 447                         char buf[col + 1];
 448                         read_cmdline(buf, col, s->pid, s->comm);
 449                         fputs(buf, stdout);
 450                 }
 451                 /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu,
 452                         jif.busy - prev_jif.busy, jif.total - prev_jif.total); */
 453                 s++;
 454         }
 455         /* printf(" %d", hist_iterations); */
 456         putchar(OPT_BATCH_MODE ? '\n' : '\r');
 457         fflush(stdout);
 458 }
 459 #undef SHOW_STAT
 460 #undef CALC_STAT
 461 #undef FMT
 462
 463
 464 static void clearmems(void)
 465 {
 466         clear_username_cache();
 467         free(top);
 468         top = 0;
 469         ntop = 0;
 470 }
 471
 472
 473 #if ENABLE_FEATURE_USE_TERMIOS
 474 #include <termios.h>
 475 #include <signal.h>
 476
 477 static void reset_term(void)
 478 {
 479         tcsetattr(0, TCSANOW, (void *) &initial_settings);
 480 #if ENABLE_FEATURE_CLEAN_UP
 481         clearmems();
 482 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 483         free(prev_hist);
 484 #endif
 485 #endif /* FEATURE_CLEAN_UP */
 486 }
 487
 488 static void sig_catcher(int sig ATTRIBUTE_UNUSED)
 489 {
 490         reset_term();
 491         exit(1);
 492 }
 493 #endif /* FEATURE_USE_TERMIOS */
 494
 495
 496 int top_main(int argc, char **argv);
 497 int top_main(int argc, char **argv)
 498 {
 499         int count, lines, col;
 500         unsigned interval = 5; /* default update rate is 5 seconds */
 501         unsigned iterations = UINT_MAX; /* 2^32 iterations by default :) */
 502         char *sinterval, *siterations;
 503 #if ENABLE_FEATURE_USE_TERMIOS
 504         struct termios new_settings;
 505         struct timeval tv;
 506         fd_set readfds;
 507         unsigned char c;
 508 #endif /* FEATURE_USE_TERMIOS */
 509
 510         interval = 5;
 511
 512         /* do normal option parsing */
 513         opt_complementary = "-";
 514         getopt32(argc, argv, "d:n:b", &sinterval, &siterations);
 515         if (option_mask32 & 0x1) interval = xatou(sinterval); // -d
 516         if (option_mask32 & 0x2) iterations = xatou(siterations); // -n
 517         //if (option_mask32 & 0x4) // -b
 518
 519         /* change to /proc */
 520         xchdir("/proc");
 521 #if ENABLE_FEATURE_USE_TERMIOS
 522         tcgetattr(0, (void *) &initial_settings);
 523         memcpy(&new_settings, &initial_settings, sizeof(struct termios));
 524         /* unbuffered input, turn off echo */
 525         new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL);
 526
 527         signal(SIGTERM, sig_catcher);
 528         signal(SIGINT, sig_catcher);
 529         tcsetattr(0, TCSANOW, (void *) &new_settings);
 530         atexit(reset_term);
 531 #endif /* FEATURE_USE_TERMIOS */
 532
 533 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 534         sort_function[0] = pcpu_sort;
 535         sort_function[1] = mem_sort;
 536         sort_function[2] = time_sort;
 537 #else
 538         sort_function = mem_sort;
 539 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
 540
 541         while (1) {
 542                 procps_status_t *p = NULL;
 543
 544                 /* Default to 25 lines - 5 lines for status */
 545                 lines = 24 - 3 USE_FEATURE_TOP_CPU_GLOBAL_PERCENTS( - 1);
 546                 col = 79;
 547 #if ENABLE_FEATURE_USE_TERMIOS
 548                 get_terminal_width_height(0, &col, &lines);
 549                 if (lines < 5 || col < MIN_WIDTH) {
 550                         sleep(interval);
 551                         continue;
 552                 }
 553                 lines -= 3 USE_FEATURE_TOP_CPU_GLOBAL_PERCENTS( + 1);
 554 #endif /* FEATURE_USE_TERMIOS */
 555
 556                 /* read process IDs & status for all the processes */
 557                 while ((p = procps_scan(p, 0
 558                                 | PSSCAN_PID
 559                                 | PSSCAN_PPID
 560                                 | PSSCAN_VSZ
 561                                 | PSSCAN_STIME
 562                                 | PSSCAN_UTIME
 563                                 | PSSCAN_STATE
 564                                 | PSSCAN_COMM
 565                                 | PSSCAN_SID
 566                                 | PSSCAN_UIDGID
 567                 ))) {
 568                         int n = ntop;
 569                         top = xrealloc(top, (++ntop) * sizeof(*top));
 570                         top[n].pid = p->pid;
 571                         top[n].ppid = p->ppid;
 572                         top[n].vsz = p->vsz;
 573 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 574                         top[n].ticks = p->stime + p->utime;
 575 #endif
 576                         top[n].uid = p->uid;
 577                         strcpy(top[n].state, p->state);
 578                         strcpy(top[n].comm, p->comm);
 579                 }
 580                 if (ntop == 0) {
 581                         bb_error_msg_and_die("no process info in /proc");
 582                 }
 583 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 584                 if (!prev_hist_count) {
 585                         do_stats();
 586                         sleep(1);
 587                         clearmems();
 588                         continue;
 589                 }
 590                 do_stats();
 591 /* TODO: we don't need to sort all 10000 processes, we need to find top 24! */
 592                 qsort(top, ntop, sizeof(top_status_t), (void*)mult_lvl_cmp);
 593 #else
 594                 qsort(top, ntop, sizeof(top_status_t), (void*)sort_function);
 595 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
 596                 count = lines;
 597                 if (OPT_BATCH_MODE || count > ntop) {
 598                         count = ntop;
 599                 }
 600                 /* show status for each of the processes */
 601                 display_status(count, col);
 602 #if ENABLE_FEATURE_USE_TERMIOS
 603                 tv.tv_sec = interval;
 604                 tv.tv_usec = 0;
 605                 FD_ZERO(&readfds);
 606                 FD_SET(0, &readfds);
 607                 select(1, &readfds, NULL, NULL, &tv);
 608                 if (FD_ISSET(0, &readfds)) {
 609                         if (read(0, &c, 1) <= 0) {   /* signal */
 610                                 return EXIT_FAILURE;
 611                         }
 612                         if (c == 'q' || c == initial_settings.c_cc[VINTR])
 613                                 break;
 614                         if (c == 'M') {
 615 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 616                                 sort_function[0] = mem_sort;
 617                                 sort_function[1] = pcpu_sort;
 618                                 sort_function[2] = time_sort;
 619 #else
 620                                 sort_function = mem_sort;
 621 #endif
 622                         }
 623 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 624                         if (c == 'P') {
 625                                 sort_function[0] = pcpu_sort;
 626                                 sort_function[1] = mem_sort;
 627                                 sort_function[2] = time_sort;
 628                         }
 629                         if (c == 'T') {
 630                                 sort_function[0] = time_sort;
 631                                 sort_function[1] = mem_sort;
 632                                 sort_function[2] = pcpu_sort;
 633                         }
 634 #endif
 635                         if (c == 'N') {
 636 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 637                                 sort_function[0] = pid_sort;
 638 #else
 639                                 sort_function = pid_sort;
 640 #endif
 641                         }
 642                 }
 643                 if (!--iterations)
 644                         break;
 645 #else
 646                 sleep(interval);
 647 #endif /* FEATURE_USE_TERMIOS */
 648                 clearmems();
 649         }
 650         if (ENABLE_FEATURE_CLEAN_UP)
 651                 clearmems();
 652         putchar('\n');
 653         return EXIT_SUCCESS;
 654 }