Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mkinitrd-magellan/busybox/procps/top.c

    Contents of /trunk/mkinitrd-magellan/busybox/procps/top.c

    Parent Directory Parent Directory | Revision Log Revision Log

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