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 #define CALC_STAT(xxx) unsigned xxx = 100 * (unsigned)(jif.xxx - prev_jif.xxx) / total_diff
 297 #define SHOW_STAT(xxx) xxx
 298 #define FMT "%3u%%"
 299 // We can display fractional percents, but at least in glibc div() is a _function_
 300 // and generated code is really awful and big (+0.5k more code):
 301 //#define CALC_STAT(xxx) div_t xxx = div(1000 * (unsigned)(jif.xxx - prev_jif.xxx) / total_diff, 10)
 302 //#define SHOW_STAT(xxx) xxx.quot, '0'+xxx.rem
 303 //#define FMT "%3u.%c%%"
 304                 unsigned total_diff = (jif.total - prev_jif.total ? : 1);
 305                 CALC_STAT(usr);
 306                 CALC_STAT(sys);
 307                 CALC_STAT(nic);
 308                 CALC_STAT(idle);
 309                 CALC_STAT(iowait);
 310                 CALC_STAT(irq);
 311                 CALC_STAT(softirq);
 312                 //CALC_STAT(steal);
 313
 314                 snprintf(scrbuf, scr_width,
 315                         /* %3u in practice almost never displays "100"
 316                          * and thus has implicit leading space:  " 99" */
 317                         "CPU:"FMT" usr"FMT" sys"FMT" nice"FMT" idle"FMT" wait"FMT" irq"FMT" softirq",
 318                         // FMT" steal", - what is this 'steal' thing?
 319                         // I doubt anyone needs to know it
 320                         SHOW_STAT(usr), SHOW_STAT(sys), SHOW_STAT(nic), SHOW_STAT(idle),
 321                         SHOW_STAT(iowait), SHOW_STAT(irq), SHOW_STAT(softirq)
 322                         //, SHOW_STAT(steal)
 323                 );
 324                 puts(scrbuf);
 325 #undef SHOW_STAT
 326 #undef CALC_STAT
 327 #undef FMT
 328         }
 329
 330         snprintf(scrbuf, scr_width, "Load average: %s", buf);
 331         puts(scrbuf);
 332
 333         return total;
 334 }
 335
 336
 337 /* display process statuses */
 338 static void display_status(int count, int scr_width)
 339 {
 340         enum {
 341                 bits_per_int = sizeof(int)*8
 342         };
 343
 344         top_status_t *s = top;
 345         char vsz_str_buf[8];
 346         unsigned long total_memory = display_generic(scr_width); /* or use total_vsz? */
 347         unsigned pmem_shift, pmem_scale;
 348
 349 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 350         unsigned pcpu_shift, pcpu_scale;
 351         unsigned busy_jifs;
 352
 353         /* what info of the processes is shown */
 354         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
 355                 "  PID USER     STATUS   VSZ  PPID %CPU %MEM COMMAND");
 356 #define MIN_WIDTH \
 357         sizeof( "  PID USER     STATUS   VSZ  PPID %CPU %MEM C")
 358 #else
 359         printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width,
 360                 "  PID USER     STATUS   VSZ  PPID %MEM COMMAND");
 361 #define MIN_WIDTH \
 362         sizeof( "  PID USER     STATUS   VSZ  PPID %MEM C")
 363 #endif
 364
 365         /*
 366          * MEM% = s->vsz/MemTotal
 367          */
 368         pmem_shift = bits_per_int-11;
 369         pmem_scale = 1000*(1U<<(bits_per_int-11)) / total_memory;
 370         /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */
 371         while (pmem_scale >= 512) {
 372                 pmem_scale /= 4;
 373                 pmem_shift -= 2;
 374         }
 375 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 376         busy_jifs = jif.busy - prev_jif.busy;
 377         /* This happens if there were lots of short-lived processes
 378          * between two top updates (e.g. compilation) */
 379         if (total_pcpu < busy_jifs) total_pcpu = busy_jifs;
 380
 381         /*
 382          * CPU% = s->pcpu/sum(s->pcpu) * busy_cpu_ticks/total_cpu_ticks
 383          * (pcpu is delta of sys+user time between samples)
 384          */
 385         /* (jif.xxx - prev_jif.xxx) and s->pcpu are
 386          * in 0..~64000 range (HZ*update_interval).
 387          * we assume that unsigned is at least 32-bit.
 388          */
 389         pcpu_shift = 6;
 390         pcpu_scale = (1000*64*(uint16_t)busy_jifs ? : 1);
 391         while (pcpu_scale < (1U<<(bits_per_int-2))) {
 392                 pcpu_scale *= 4;
 393                 pcpu_shift += 2;
 394         }
 395         pcpu_scale /= ( (uint16_t)(jif.total-prev_jif.total)*total_pcpu ? : 1);
 396         /* we want (s->pcpu * pcpu_scale) to never overflow */
 397         while (pcpu_scale >= 1024) {
 398                 pcpu_scale /= 4;
 399                 pcpu_shift -= 2;
 400         }
 401         /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */
 402 #endif
 403         while (count-- > 0) {
 404                 div_t pmem = div((s->vsz*pmem_scale) >> pmem_shift, 10);
 405                 int col = scr_width+1;
 406                 USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE(div_t pcpu;)
 407
 408                 if (s->vsz >= 100*1024)
 409                         sprintf(vsz_str_buf, "%6ldM", s->vsz/1024);
 410                 else
 411                         sprintf(vsz_str_buf, "%7ld", s->vsz);
 412                 USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE(
 413                 pcpu = div((s->pcpu*pcpu_scale) >> pcpu_shift, 10);
 414                 )
 415                 col -= printf("\n%5u %-8s %s  "
 416                                 "%s%6u"
 417                                 USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE("%3u.%c")
 418                                 "%3u.%c ",
 419                                 s->pid, get_cached_username(s->uid), s->state,
 420                                 vsz_str_buf, s->ppid,
 421                                 USE_FEATURE_TOP_CPU_USAGE_PERCENTAGE(pcpu.quot, '0'+pcpu.rem,)
 422                                 pmem.quot, '0'+pmem.rem);
 423                 if (col > 0)
 424                         printf("%.*s", col, s->comm);
 425                 /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu,
 426                         jif.busy - prev_jif.busy, jif.total - prev_jif.total); */
 427                 s++;
 428         }
 429         /* printf(" %d", hist_iterations); */
 430         putchar(OPT_BATCH_MODE ? '\n' : '\r');
 431         fflush(stdout);
 432 }
 433
 434
 435 static void clearmems(void)
 436 {
 437         clear_username_cache();
 438         free(top);
 439         top = 0;
 440         ntop = 0;
 441 }
 442
 443
 444 #if ENABLE_FEATURE_USE_TERMIOS
 445 #include <termios.h>
 446 #include <signal.h>
 447
 448 static void reset_term(void)
 449 {
 450         tcsetattr(0, TCSANOW, (void *) &initial_settings);
 451 #if ENABLE_FEATURE_CLEAN_UP
 452         clearmems();
 453 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 454         free(prev_hist);
 455 #endif
 456 #endif /* FEATURE_CLEAN_UP */
 457 }
 458
 459 static void sig_catcher(int sig ATTRIBUTE_UNUSED)
 460 {
 461         reset_term();
 462         exit(1);
 463 }
 464 #endif /* FEATURE_USE_TERMIOS */
 465
 466
 467 int top_main(int argc, char **argv);
 468 int top_main(int argc, char **argv)
 469 {
 470         int count, lines, col;
 471         unsigned interval = 5; /* default update rate is 5 seconds */
 472         unsigned iterations = UINT_MAX; /* 2^32 iterations by default :) */
 473         char *sinterval, *siterations;
 474 #if ENABLE_FEATURE_USE_TERMIOS
 475         struct termios new_settings;
 476         struct timeval tv;
 477         fd_set readfds;
 478         unsigned char c;
 479 #endif /* FEATURE_USE_TERMIOS */
 480
 481         interval = 5;
 482
 483         /* do normal option parsing */
 484         opt_complementary = "-";
 485         getopt32(argc, argv, "d:n:b", &sinterval, &siterations);
 486         if (option_mask32 & 0x1) interval = xatou(sinterval); // -d
 487         if (option_mask32 & 0x2) iterations = xatou(siterations); // -n
 488         //if (option_mask32 & 0x4) // -b
 489
 490         /* change to /proc */
 491         xchdir("/proc");
 492 #if ENABLE_FEATURE_USE_TERMIOS
 493         tcgetattr(0, (void *) &initial_settings);
 494         memcpy(&new_settings, &initial_settings, sizeof(struct termios));
 495         /* unbuffered input, turn off echo */
 496         new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL);
 497
 498         signal(SIGTERM, sig_catcher);
 499         signal(SIGINT, sig_catcher);
 500         tcsetattr(0, TCSANOW, (void *) &new_settings);
 501         atexit(reset_term);
 502 #endif /* FEATURE_USE_TERMIOS */
 503
 504 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 505         sort_function[0] = pcpu_sort;
 506         sort_function[1] = mem_sort;
 507         sort_function[2] = time_sort;
 508 #else
 509         sort_function = mem_sort;
 510 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
 511
 512         while (1) {
 513                 procps_status_t *p = NULL;
 514
 515                 /* Default to 25 lines - 5 lines for status */
 516                 lines = 24 - 3 USE_FEATURE_TOP_CPU_GLOBAL_PERCENTS( - 1);
 517                 col = 79;
 518 #if ENABLE_FEATURE_USE_TERMIOS
 519                 get_terminal_width_height(0, &col, &lines);
 520                 if (lines < 5 || col < MIN_WIDTH) {
 521                         sleep(interval);
 522                         continue;
 523                 }
 524                 lines -= 3 USE_FEATURE_TOP_CPU_GLOBAL_PERCENTS( + 1);
 525 #endif /* FEATURE_USE_TERMIOS */
 526
 527                 /* read process IDs & status for all the processes */
 528                 while ((p = procps_scan(p, 0
 529                                 | PSSCAN_PID
 530                                 | PSSCAN_PPID
 531                                 | PSSCAN_VSZ
 532                                 | PSSCAN_STIME
 533                                 | PSSCAN_UTIME
 534                                 | PSSCAN_STATE
 535                                 | PSSCAN_COMM
 536                                 | PSSCAN_SID
 537                                 | PSSCAN_UIDGID
 538                 ))) {
 539                         int n = ntop;
 540                         top = xrealloc(top, (++ntop)*sizeof(top_status_t));
 541                         top[n].pid = p->pid;
 542                         top[n].ppid = p->ppid;
 543                         top[n].vsz = p->vsz;
 544 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 545                         top[n].ticks = p->stime + p->utime;
 546 #endif
 547                         top[n].uid = p->uid;
 548                         strcpy(top[n].state, p->state);
 549                         strcpy(top[n].comm, p->comm);
 550                 }
 551                 if (ntop == 0) {
 552                         bb_error_msg_and_die("can't find process info in /proc");
 553                 }
 554 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 555                 if (!prev_hist_count) {
 556                         do_stats();
 557                         sleep(1);
 558                         clearmems();
 559                         continue;
 560                 }
 561                 do_stats();
 562                 qsort(top, ntop, sizeof(top_status_t), (void*)mult_lvl_cmp);
 563 #else
 564                 qsort(top, ntop, sizeof(top_status_t), (void*)sort_function);
 565 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
 566                 count = lines;
 567                 if (OPT_BATCH_MODE || count > ntop) {
 568                         count = ntop;
 569                 }
 570                 /* show status for each of the processes */
 571                 display_status(count, col);
 572 #if ENABLE_FEATURE_USE_TERMIOS
 573                 tv.tv_sec = interval;
 574                 tv.tv_usec = 0;
 575                 FD_ZERO(&readfds);
 576                 FD_SET(0, &readfds);
 577                 select(1, &readfds, NULL, NULL, &tv);
 578                 if (FD_ISSET(0, &readfds)) {
 579                         if (read(0, &c, 1) <= 0) {   /* signal */
 580                                 return EXIT_FAILURE;
 581                         }
 582                         if (c == 'q' || c == initial_settings.c_cc[VINTR])
 583                                 break;
 584                         if (c == 'M') {
 585 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 586                                 sort_function[0] = mem_sort;
 587                                 sort_function[1] = pcpu_sort;
 588                                 sort_function[2] = time_sort;
 589 #else
 590                                 sort_function = mem_sort;
 591 #endif
 592                         }
 593 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 594                         if (c == 'P') {
 595                                 sort_function[0] = pcpu_sort;
 596                                 sort_function[1] = mem_sort;
 597                                 sort_function[2] = time_sort;
 598                         }
 599                         if (c == 'T') {
 600                                 sort_function[0] = time_sort;
 601                                 sort_function[1] = mem_sort;
 602                                 sort_function[2] = pcpu_sort;
 603                         }
 604 #endif
 605                         if (c == 'N') {
 606 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
 607                                 sort_function[0] = pid_sort;
 608 #else
 609                                 sort_function = pid_sort;
 610 #endif
 611                         }
 612                 }
 613                 if (!--iterations)
 614                         break;
 615 #else
 616                 sleep(interval);
 617 #endif /* FEATURE_USE_TERMIOS */
 618                 clearmems();
 619         }
 620         if (ENABLE_FEATURE_CLEAN_UP)
 621                 clearmems();
 622         putchar('\n');
 623         return EXIT_SUCCESS;
 624 }