Bernhard Reutner-Fischer | d9cf7ac | 2006-04-12 18:39:58 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 2 | /* |
| 3 | * A tiny 'top' utility. |
| 4 | * |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 5 | * This is written specifically for the linux /proc/<PID>/stat(m) |
| 6 | * files format. |
Denis Vlasenko | db12d1d | 2008-12-07 00:52:58 +0000 | [diff] [blame] | 7 | * |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 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. |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 11 | * |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 12 | * NOTES: |
| 13 | * - At startup this changes to /proc, all the reads are then |
| 14 | * relative to that. |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 15 | * |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 16 | * (C) Eero Tamminen <oak at welho dot com> |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 17 | * |
Eric Andersen | aff114c | 2004-04-14 17:51:38 +0000 | [diff] [blame] | 18 | * Rewritten by Vladimir Oleynik (C) 2002 <dzo@simtreas.ru> |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 19 | * |
| 20 | * Sept 2008: Vineet Gupta <vineet.gupta@arc.com> |
| 21 | * Added Support for reporting SMP Information |
| 22 | * - CPU where Process was last seen running |
| 23 | * (to see effect of sched_setaffinity() etc) |
| 24 | * - CPU Time Split (idle/IO/wait etc) PER CPU |
Denis Vlasenko | db12d1d | 2008-12-07 00:52:58 +0000 | [diff] [blame] | 25 | * |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 26 | * Copyright (c) 1992 Branko Lankester |
| 27 | * Copyright (c) 1992 Roger Binns |
| 28 | * Copyright (C) 1994-1996 Charles L. Blake. |
| 29 | * Copyright (C) 1992-1998 Michael K. Johnson |
Denis Vlasenko | db12d1d | 2008-12-07 00:52:58 +0000 | [diff] [blame] | 30 | * |
Denys Vlasenko | 0ef64bd | 2010-08-16 20:14:46 +0200 | [diff] [blame] | 31 | * Licensed under GPLv2, see file LICENSE in this source tree. |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 32 | */ |
| 33 | |
Denis Vlasenko | b6adbf1 | 2007-05-26 19:00:18 +0000 | [diff] [blame] | 34 | #include "libbb.h" |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 35 | |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 36 | |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 37 | typedef struct top_status_t { |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 38 | unsigned long vsz; |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 39 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
| 40 | unsigned long ticks; |
| 41 | unsigned pcpu; /* delta of ticks */ |
| 42 | #endif |
| 43 | unsigned pid, ppid; |
| 44 | unsigned uid; |
| 45 | char state[4]; |
Denis Vlasenko | 98ebab8 | 2007-06-30 14:47:41 +0000 | [diff] [blame] | 46 | char comm[COMM_LEN]; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 47 | #if ENABLE_FEATURE_TOP_SMP_PROCESS |
| 48 | int last_seen_on_cpu; |
| 49 | #endif |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 50 | } top_status_t; |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 51 | |
Denis Vlasenko | 98ebab8 | 2007-06-30 14:47:41 +0000 | [diff] [blame] | 52 | typedef struct jiffy_counts_t { |
Denis Vlasenko | 7886275 | 2009-03-03 11:55:31 +0000 | [diff] [blame] | 53 | /* Linux 2.4.x has only first four */ |
| 54 | unsigned long long usr, nic, sys, idle; |
| 55 | unsigned long long iowait, irq, softirq, steal; |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 56 | unsigned long long total; |
| 57 | unsigned long long busy; |
| 58 | } jiffy_counts_t; |
| 59 | |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 60 | /* This structure stores some critical information from one frame to |
| 61 | the next. Used for finding deltas. */ |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 62 | typedef struct save_hist { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 63 | unsigned long ticks; |
Denis Vlasenko | 6b06cb8 | 2008-05-15 21:30:45 +0000 | [diff] [blame] | 64 | pid_t pid; |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 65 | } save_hist; |
| 66 | |
| 67 | typedef int (*cmp_funcp)(top_status_t *P, top_status_t *Q); |
| 68 | |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 69 | |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 70 | enum { SORT_DEPTH = 3 }; |
| 71 | |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 72 | |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 73 | struct globals { |
| 74 | top_status_t *top; |
| 75 | int ntop; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 76 | #if ENABLE_FEATURE_TOPMEM |
| 77 | smallint sort_field; |
| 78 | smallint inverted; |
| 79 | #endif |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 80 | #if ENABLE_FEATURE_TOP_SMP_CPU |
| 81 | smallint smp_cpu_info; /* one/many cpu info lines? */ |
| 82 | #endif |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 83 | #if ENABLE_FEATURE_USE_TERMIOS |
| 84 | struct termios initial_settings; |
| 85 | #endif |
| 86 | #if !ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 87 | cmp_funcp sort_function[1]; |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 88 | #else |
| 89 | cmp_funcp sort_function[SORT_DEPTH]; |
| 90 | struct save_hist *prev_hist; |
| 91 | int prev_hist_count; |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 92 | jiffy_counts_t cur_jif, prev_jif; |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 93 | /* int hist_iterations; */ |
| 94 | unsigned total_pcpu; |
| 95 | /* unsigned long total_vsz; */ |
| 96 | #endif |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 97 | #if ENABLE_FEATURE_TOP_SMP_CPU |
| 98 | /* Per CPU samples: current and last */ |
| 99 | jiffy_counts_t *cpu_jif, *cpu_prev_jif; |
| 100 | int num_cpus; |
| 101 | #endif |
Denis Vlasenko | 5576136 | 2007-10-16 22:53:05 +0000 | [diff] [blame] | 102 | char line_buf[80]; |
Denys Vlasenko | 98a4c7c | 2010-02-04 15:00:15 +0100 | [diff] [blame] | 103 | }; //FIX_ALIASING; - large code growth |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 104 | enum { LINE_BUF_SIZE = COMMON_BUFSIZE - offsetof(struct globals, line_buf) }; |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 105 | #define G (*(struct globals*)&bb_common_bufsiz1) |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 106 | struct BUG_bad_size { |
| 107 | char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1]; |
| 108 | char BUG_line_buf_too_small[LINE_BUF_SIZE > 80 ? 1 : -1]; |
| 109 | }; |
| 110 | #define INIT_G() do { } while (0) |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 111 | #define top (G.top ) |
| 112 | #define ntop (G.ntop ) |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 113 | #define sort_field (G.sort_field ) |
| 114 | #define inverted (G.inverted ) |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 115 | #define smp_cpu_info (G.smp_cpu_info ) |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 116 | #define initial_settings (G.initial_settings ) |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 117 | #define sort_function (G.sort_function ) |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 118 | #define prev_hist (G.prev_hist ) |
| 119 | #define prev_hist_count (G.prev_hist_count ) |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 120 | #define cur_jif (G.cur_jif ) |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 121 | #define prev_jif (G.prev_jif ) |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 122 | #define cpu_jif (G.cpu_jif ) |
| 123 | #define cpu_prev_jif (G.cpu_prev_jif ) |
| 124 | #define num_cpus (G.num_cpus ) |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 125 | #define total_pcpu (G.total_pcpu ) |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 126 | #define line_buf (G.line_buf ) |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 127 | |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 128 | enum { |
| 129 | OPT_d = (1 << 0), |
| 130 | OPT_n = (1 << 1), |
| 131 | OPT_b = (1 << 2), |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 132 | OPT_m = (1 << 3), |
| 133 | OPT_EOF = (1 << 4), /* pseudo: "we saw EOF in stdin" */ |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 134 | }; |
| 135 | #define OPT_BATCH_MODE (option_mask32 & OPT_b) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 136 | |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 137 | |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 138 | #if ENABLE_FEATURE_USE_TERMIOS |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 139 | static int pid_sort(top_status_t *P, top_status_t *Q) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 140 | { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 141 | /* Buggy wrt pids with high bit set */ |
| 142 | /* (linux pids are in [1..2^15-1]) */ |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 143 | return (Q->pid - P->pid); |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 144 | } |
Mike Frysinger | 223b887 | 2005-07-30 09:42:05 +0000 | [diff] [blame] | 145 | #endif |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 146 | |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 147 | static int mem_sort(top_status_t *P, top_status_t *Q) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 148 | { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 149 | /* We want to avoid unsigned->signed and truncation errors */ |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 150 | if (Q->vsz < P->vsz) return -1; |
| 151 | return Q->vsz != P->vsz; /* 0 if ==, 1 if > */ |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 152 | } |
| 153 | |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 154 | |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 155 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 156 | |
| 157 | static int pcpu_sort(top_status_t *P, top_status_t *Q) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 158 | { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 159 | /* Buggy wrt ticks with high bit set */ |
| 160 | /* Affects only processes for which ticks overflow */ |
| 161 | return (int)Q->pcpu - (int)P->pcpu; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 162 | } |
| 163 | |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 164 | static int time_sort(top_status_t *P, top_status_t *Q) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 165 | { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 166 | /* We want to avoid unsigned->signed and truncation errors */ |
| 167 | if (Q->ticks < P->ticks) return -1; |
| 168 | return Q->ticks != P->ticks; /* 0 if ==, 1 if > */ |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 169 | } |
| 170 | |
Denis Vlasenko | ac678ec | 2007-04-16 22:32:04 +0000 | [diff] [blame] | 171 | static int mult_lvl_cmp(void* a, void* b) |
| 172 | { |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 173 | int i, cmp_val; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 174 | |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 175 | for (i = 0; i < SORT_DEPTH; i++) { |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 176 | cmp_val = (*sort_function[i])(a, b); |
| 177 | if (cmp_val != 0) |
| 178 | return cmp_val; |
| 179 | } |
| 180 | return 0; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 181 | } |
| 182 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 183 | static NOINLINE int read_cpu_jiffy(FILE *fp, jiffy_counts_t *p_jif) |
| 184 | { |
| 185 | #if !ENABLE_FEATURE_TOP_SMP_CPU |
Denis Vlasenko | 7886275 | 2009-03-03 11:55:31 +0000 | [diff] [blame] | 186 | static const char fmt[] = "cpu %llu %llu %llu %llu %llu %llu %llu %llu"; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 187 | #else |
Denis Vlasenko | 7886275 | 2009-03-03 11:55:31 +0000 | [diff] [blame] | 188 | static const char fmt[] = "cp%*s %llu %llu %llu %llu %llu %llu %llu %llu"; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 189 | #endif |
| 190 | int ret; |
| 191 | |
| 192 | if (!fgets(line_buf, LINE_BUF_SIZE, fp) || line_buf[0] != 'c' /* not "cpu" */) |
| 193 | return 0; |
| 194 | ret = sscanf(line_buf, fmt, |
| 195 | &p_jif->usr, &p_jif->nic, &p_jif->sys, &p_jif->idle, |
| 196 | &p_jif->iowait, &p_jif->irq, &p_jif->softirq, |
| 197 | &p_jif->steal); |
Denis Vlasenko | 7886275 | 2009-03-03 11:55:31 +0000 | [diff] [blame] | 198 | if (ret >= 4) { |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 199 | p_jif->total = p_jif->usr + p_jif->nic + p_jif->sys + p_jif->idle |
| 200 | + p_jif->iowait + p_jif->irq + p_jif->softirq + p_jif->steal; |
| 201 | /* procps 2.x does not count iowait as busy time */ |
| 202 | p_jif->busy = p_jif->total - p_jif->idle - p_jif->iowait; |
| 203 | } |
| 204 | |
| 205 | return ret; |
| 206 | } |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 207 | |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 208 | static void get_jiffy_counts(void) |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 209 | { |
Denis Vlasenko | 5415c85 | 2008-07-21 23:05:26 +0000 | [diff] [blame] | 210 | FILE* fp = xfopen_for_read("stat"); |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 211 | |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 212 | /* We need to parse cumulative counts even if SMP CPU display is on, |
| 213 | * they are used to calculate per process CPU% */ |
| 214 | prev_jif = cur_jif; |
| 215 | if (read_cpu_jiffy(fp, &cur_jif) < 4) |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 216 | bb_error_msg_and_die("can't read /proc/stat"); |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 217 | |
| 218 | #if !ENABLE_FEATURE_TOP_SMP_CPU |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 219 | fclose(fp); |
| 220 | return; |
| 221 | #else |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 222 | if (!smp_cpu_info) { |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 223 | fclose(fp); |
| 224 | return; |
| 225 | } |
| 226 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 227 | if (!num_cpus) { |
| 228 | /* First time here. How many CPUs? |
| 229 | * There will be at least 1 /proc/stat line with cpu%d |
| 230 | */ |
| 231 | while (1) { |
| 232 | cpu_jif = xrealloc_vector(cpu_jif, 1, num_cpus); |
| 233 | if (read_cpu_jiffy(fp, &cpu_jif[num_cpus]) <= 4) |
| 234 | break; |
| 235 | num_cpus++; |
| 236 | } |
| 237 | if (num_cpus == 0) /* /proc/stat with only "cpu ..." line?! */ |
| 238 | smp_cpu_info = 0; |
| 239 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 240 | cpu_prev_jif = xzalloc(sizeof(cpu_prev_jif[0]) * num_cpus); |
| 241 | |
| 242 | /* Otherwise the first per cpu display shows all 100% idles */ |
| 243 | usleep(50000); |
| 244 | } else { /* Non first time invocation */ |
| 245 | jiffy_counts_t *tmp; |
| 246 | int i; |
| 247 | |
| 248 | /* First switch the sample pointers: no need to copy */ |
| 249 | tmp = cpu_prev_jif; |
| 250 | cpu_prev_jif = cpu_jif; |
| 251 | cpu_jif = tmp; |
| 252 | |
| 253 | /* Get the new samples */ |
| 254 | for (i = 0; i < num_cpus; i++) |
| 255 | read_cpu_jiffy(fp, &cpu_jif[i]); |
| 256 | } |
| 257 | #endif |
| 258 | fclose(fp); |
| 259 | } |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 260 | |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 261 | static void do_stats(void) |
| 262 | { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 263 | top_status_t *cur; |
Denis Vlasenko | 35fb512 | 2006-11-01 09:16:49 +0000 | [diff] [blame] | 264 | pid_t pid; |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 265 | int i, last_i, n; |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 266 | struct save_hist *new_hist; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 267 | |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 268 | get_jiffy_counts(); |
| 269 | total_pcpu = 0; |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 270 | /* total_vsz = 0; */ |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 271 | new_hist = xmalloc(sizeof(new_hist[0]) * ntop); |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 272 | /* |
| 273 | * Make a pass through the data to get stats. |
| 274 | */ |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 275 | /* hist_iterations = 0; */ |
| 276 | i = 0; |
| 277 | for (n = 0; n < ntop; n++) { |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 278 | cur = top + n; |
| 279 | |
| 280 | /* |
| 281 | * Calculate time in cur process. Time is sum of user time |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 282 | * and system time |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 283 | */ |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 284 | pid = cur->pid; |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 285 | new_hist[n].ticks = cur->ticks; |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 286 | new_hist[n].pid = pid; |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 287 | |
| 288 | /* find matching entry from previous pass */ |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 289 | cur->pcpu = 0; |
| 290 | /* do not start at index 0, continue at last used one |
| 291 | * (brought hist_iterations from ~14000 down to 172) */ |
| 292 | last_i = i; |
| 293 | if (prev_hist_count) do { |
| 294 | if (prev_hist[i].pid == pid) { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 295 | cur->pcpu = cur->ticks - prev_hist[i].ticks; |
| 296 | total_pcpu += cur->pcpu; |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 297 | break; |
| 298 | } |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 299 | i = (i+1) % prev_hist_count; |
| 300 | /* hist_iterations++; */ |
| 301 | } while (i != last_i); |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 302 | /* total_vsz += cur->vsz; */ |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | /* |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 306 | * Save cur frame's information. |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 307 | */ |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 308 | free(prev_hist); |
| 309 | prev_hist = new_hist; |
| 310 | prev_hist_count = ntop; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 311 | } |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 312 | |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 313 | #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */ |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 314 | |
Denis Vlasenko | 6ee023c | 2007-08-23 10:52:52 +0000 | [diff] [blame] | 315 | #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS && ENABLE_FEATURE_TOP_DECIMALS |
| 316 | /* formats 7 char string (8 with terminating NUL) */ |
| 317 | static char *fmt_100percent_8(char pbuf[8], unsigned value, unsigned total) |
| 318 | { |
| 319 | unsigned t; |
| 320 | if (value >= total) { /* 100% ? */ |
| 321 | strcpy(pbuf, " 100% "); |
| 322 | return pbuf; |
| 323 | } |
| 324 | /* else generate " [N/space]N.N% " string */ |
| 325 | value = 1000 * value / total; |
| 326 | t = value / 100; |
| 327 | value = value % 100; |
| 328 | pbuf[0] = ' '; |
| 329 | pbuf[1] = t ? t + '0' : ' '; |
| 330 | pbuf[2] = '0' + (value / 10); |
| 331 | pbuf[3] = '.'; |
| 332 | pbuf[4] = '0' + (value % 10); |
| 333 | pbuf[5] = '%'; |
| 334 | pbuf[6] = ' '; |
| 335 | pbuf[7] = '\0'; |
| 336 | return pbuf; |
| 337 | } |
| 338 | #endif |
| 339 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 340 | #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS |
| 341 | static void display_cpus(int scr_width, char *scrbuf, int *lines_rem_p) |
| 342 | { |
| 343 | /* |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 344 | * xxx% = (cur_jif.xxx - prev_jif.xxx) / (cur_jif.total - prev_jif.total) * 100% |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 345 | */ |
| 346 | unsigned total_diff; |
| 347 | jiffy_counts_t *p_jif, *p_prev_jif; |
| 348 | int i; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 349 | # if ENABLE_FEATURE_TOP_SMP_CPU |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 350 | int n_cpu_lines; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 351 | # endif |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 352 | |
| 353 | /* using (unsigned) casts to make operations cheaper */ |
Denys Vlasenko | fe73798 | 2009-09-12 15:11:50 +0200 | [diff] [blame] | 354 | # define CALC_TOTAL_DIFF do { \ |
| 355 | total_diff = (unsigned)(p_jif->total - p_prev_jif->total); \ |
| 356 | if (total_diff == 0) total_diff = 1; \ |
| 357 | } while (0) |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 358 | |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 359 | # if ENABLE_FEATURE_TOP_DECIMALS |
| 360 | # define CALC_STAT(xxx) char xxx[8] |
| 361 | # define SHOW_STAT(xxx) fmt_100percent_8(xxx, (unsigned)(p_jif->xxx - p_prev_jif->xxx), total_diff) |
| 362 | # define FMT "%s" |
| 363 | # else |
| 364 | # define CALC_STAT(xxx) unsigned xxx = 100 * (unsigned)(p_jif->xxx - p_prev_jif->xxx) / total_diff |
| 365 | # define SHOW_STAT(xxx) xxx |
| 366 | # define FMT "%4u%% " |
| 367 | # endif |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 368 | |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 369 | # if !ENABLE_FEATURE_TOP_SMP_CPU |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 370 | { |
| 371 | i = 1; |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 372 | p_jif = &cur_jif; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 373 | p_prev_jif = &prev_jif; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 374 | # else |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 375 | /* Loop thru CPU(s) */ |
| 376 | n_cpu_lines = smp_cpu_info ? num_cpus : 1; |
| 377 | if (n_cpu_lines > *lines_rem_p) |
| 378 | n_cpu_lines = *lines_rem_p; |
| 379 | |
| 380 | for (i = 0; i < n_cpu_lines; i++) { |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 381 | p_jif = &cpu_jif[i]; |
| 382 | p_prev_jif = &cpu_prev_jif[i]; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 383 | # endif |
Denys Vlasenko | fe73798 | 2009-09-12 15:11:50 +0200 | [diff] [blame] | 384 | CALC_TOTAL_DIFF; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 385 | |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 386 | { /* Need a block: CALC_STAT are declarations */ |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 387 | CALC_STAT(usr); |
| 388 | CALC_STAT(sys); |
| 389 | CALC_STAT(nic); |
| 390 | CALC_STAT(idle); |
| 391 | CALC_STAT(iowait); |
| 392 | CALC_STAT(irq); |
| 393 | CALC_STAT(softirq); |
| 394 | /*CALC_STAT(steal);*/ |
| 395 | |
| 396 | snprintf(scrbuf, scr_width, |
| 397 | /* Barely fits in 79 chars when in "decimals" mode. */ |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 398 | # if ENABLE_FEATURE_TOP_SMP_CPU |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 399 | "CPU%s:"FMT"usr"FMT"sys"FMT"nic"FMT"idle"FMT"io"FMT"irq"FMT"sirq", |
| 400 | (smp_cpu_info ? utoa(i) : ""), |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 401 | # else |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 402 | "CPU:"FMT"usr"FMT"sys"FMT"nic"FMT"idle"FMT"io"FMT"irq"FMT"sirq", |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 403 | # endif |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 404 | SHOW_STAT(usr), SHOW_STAT(sys), SHOW_STAT(nic), SHOW_STAT(idle), |
| 405 | SHOW_STAT(iowait), SHOW_STAT(irq), SHOW_STAT(softirq) |
| 406 | /*, SHOW_STAT(steal) - what is this 'steal' thing? */ |
| 407 | /* I doubt anyone wants to know it */ |
| 408 | ); |
| 409 | puts(scrbuf); |
| 410 | } |
| 411 | } |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 412 | # undef SHOW_STAT |
| 413 | # undef CALC_STAT |
| 414 | # undef FMT |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 415 | *lines_rem_p -= i; |
| 416 | } |
| 417 | #else /* !ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS */ |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 418 | # define display_cpus(scr_width, scrbuf, lines_rem) ((void)0) |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 419 | #endif |
| 420 | |
| 421 | static unsigned long display_header(int scr_width, int *lines_rem_p) |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 422 | { |
| 423 | FILE *fp; |
| 424 | char buf[80]; |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 425 | char scrbuf[80]; |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 426 | unsigned long total, used, mfree, shared, buffers, cached; |
Denis Vlasenko | 110967a | 2007-07-15 19:27:48 +0000 | [diff] [blame] | 427 | |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 428 | /* read memory info */ |
Denis Vlasenko | 5415c85 | 2008-07-21 23:05:26 +0000 | [diff] [blame] | 429 | fp = xfopen_for_read("meminfo"); |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 430 | |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 431 | /* |
| 432 | * Old kernels (such as 2.4.x) had a nice summary of memory info that |
| 433 | * we could parse, however this is gone entirely in 2.6. Try parsing |
| 434 | * the old way first, and if that fails, parse each field manually. |
| 435 | * |
| 436 | * First, we read in the first line. Old kernels will have bogus |
| 437 | * strings we don't care about, whereas new kernels will start right |
| 438 | * out with MemTotal: |
"Vladimir N. Oleynik" | 70678bc | 2005-11-29 12:32:33 +0000 | [diff] [blame] | 439 | * -- PFM. |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 440 | */ |
| 441 | if (fscanf(fp, "MemTotal: %lu %s\n", &total, buf) != 2) { |
"Vladimir N. Oleynik" | 70678bc | 2005-11-29 12:32:33 +0000 | [diff] [blame] | 442 | fgets(buf, sizeof(buf), fp); /* skip first line */ |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 443 | |
| 444 | fscanf(fp, "Mem: %lu %lu %lu %lu %lu %lu", |
Denis Vlasenko | 5a65447 | 2007-06-10 17:11:59 +0000 | [diff] [blame] | 445 | &total, &used, &mfree, &shared, &buffers, &cached); |
| 446 | /* convert to kilobytes */ |
| 447 | used /= 1024; |
| 448 | mfree /= 1024; |
| 449 | shared /= 1024; |
| 450 | buffers /= 1024; |
| 451 | cached /= 1024; |
| 452 | total /= 1024; |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 453 | } else { |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 454 | /* |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 455 | * Revert to manual parsing, which incidentally already has the |
| 456 | * sizes in kilobytes. This should be safe for both 2.4 and |
| 457 | * 2.6. |
| 458 | */ |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 459 | fscanf(fp, "MemFree: %lu %s\n", &mfree, buf); |
| 460 | |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 461 | /* |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 462 | * MemShared: is no longer present in 2.6. Report this as 0, |
| 463 | * to maintain consistent behavior with normal procps. |
| 464 | */ |
| 465 | if (fscanf(fp, "MemShared: %lu %s\n", &shared, buf) != 2) |
| 466 | shared = 0; |
| 467 | |
| 468 | fscanf(fp, "Buffers: %lu %s\n", &buffers, buf); |
| 469 | fscanf(fp, "Cached: %lu %s\n", &cached, buf); |
| 470 | |
| 471 | used = total - mfree; |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 472 | } |
| 473 | fclose(fp); |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 474 | |
Denis Vlasenko | 110967a | 2007-07-15 19:27:48 +0000 | [diff] [blame] | 475 | /* output memory info */ |
Denis Vlasenko | 6b06cb8 | 2008-05-15 21:30:45 +0000 | [diff] [blame] | 476 | if (scr_width > (int)sizeof(scrbuf)) |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 477 | scr_width = sizeof(scrbuf); |
| 478 | snprintf(scrbuf, scr_width, |
Denis Vlasenko | c1166c3 | 2007-07-15 19:23:38 +0000 | [diff] [blame] | 479 | "Mem: %luK used, %luK free, %luK shrd, %luK buff, %luK cached", |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 480 | used, mfree, shared, buffers, cached); |
Denys Vlasenko | d9a3e89 | 2010-05-16 23:42:13 +0200 | [diff] [blame] | 481 | /* go to top & clear to the end of screen */ |
| 482 | printf(OPT_BATCH_MODE ? "%s\n" : "\033[H\033[J%s\n", scrbuf); |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 483 | (*lines_rem_p)--; |
Denis Vlasenko | f7996f3 | 2007-01-11 17:20:00 +0000 | [diff] [blame] | 484 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 485 | /* Display CPU time split as percentage of total time |
| 486 | * This displays either a cumulative line or one line per CPU |
Denis Vlasenko | 856be77 | 2007-08-17 08:29:48 +0000 | [diff] [blame] | 487 | */ |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 488 | display_cpus(scr_width, scrbuf, lines_rem_p); |
Denis Vlasenko | 5a65447 | 2007-06-10 17:11:59 +0000 | [diff] [blame] | 489 | |
Denis Vlasenko | 110967a | 2007-07-15 19:27:48 +0000 | [diff] [blame] | 490 | /* read load average as a string */ |
| 491 | buf[0] = '\0'; |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 492 | open_read_close("loadavg", buf, sizeof(buf) - 1); |
| 493 | buf[sizeof(buf) - 1] = '\n'; |
| 494 | *strchr(buf, '\n') = '\0'; |
Denis Vlasenko | 25d8062 | 2006-10-27 09:34:22 +0000 | [diff] [blame] | 495 | snprintf(scrbuf, scr_width, "Load average: %s", buf); |
Denis Vlasenko | 5a65447 | 2007-06-10 17:11:59 +0000 | [diff] [blame] | 496 | puts(scrbuf); |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 497 | (*lines_rem_p)--; |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 498 | |
Eric Andersen | 7857c03 | 2003-10-11 18:47:20 +0000 | [diff] [blame] | 499 | return total; |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 500 | } |
| 501 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 502 | static NOINLINE void display_process_list(int lines_rem, int scr_width) |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 503 | { |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 504 | enum { |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 505 | BITS_PER_INT = sizeof(int) * 8 |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 506 | }; |
| 507 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 508 | top_status_t *s; |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 509 | char vsz_str_buf[8]; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 510 | unsigned long total_memory = display_header(scr_width, &lines_rem); /* or use total_vsz? */ |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 511 | /* xxx_shift and xxx_scale variables allow us to replace |
| 512 | * expensive divides with multiply and shift */ |
| 513 | unsigned pmem_shift, pmem_scale, pmem_half; |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 514 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denys Vlasenko | 36df048 | 2009-10-19 16:07:28 +0200 | [diff] [blame] | 515 | unsigned tmp_unsigned; |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 516 | unsigned pcpu_shift, pcpu_scale, pcpu_half; |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 517 | unsigned busy_jifs; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 518 | #endif |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 519 | |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 520 | /* what info of the processes is shown */ |
Denys Vlasenko | d9a3e89 | 2010-05-16 23:42:13 +0200 | [diff] [blame] | 521 | printf(OPT_BATCH_MODE ? "%.*s" : "\033[7m%.*s\033[0m", scr_width, |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 522 | " PID PPID USER STAT VSZ %MEM" |
Denys Vlasenko | 9be4f31 | 2009-11-07 04:06:31 +0100 | [diff] [blame] | 523 | IF_FEATURE_TOP_SMP_PROCESS(" CPU") |
| 524 | IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(" %CPU") |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 525 | " COMMAND"); |
| 526 | lines_rem--; |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 527 | |
Denis Vlasenko | 24c5fba | 2007-07-15 19:25:01 +0000 | [diff] [blame] | 528 | #if ENABLE_FEATURE_TOP_DECIMALS |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 529 | # define UPSCALE 1000 |
| 530 | # define CALC_STAT(name, val) div_t name = div((val), 10) |
| 531 | # define SHOW_STAT(name) name.quot, '0'+name.rem |
| 532 | # define FMT "%3u.%c" |
Denis Vlasenko | 24c5fba | 2007-07-15 19:25:01 +0000 | [diff] [blame] | 533 | #else |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 534 | # define UPSCALE 100 |
| 535 | # define CALC_STAT(name, val) unsigned name = (val) |
| 536 | # define SHOW_STAT(name) name |
| 537 | # define FMT "%4u%%" |
Denis Vlasenko | 24c5fba | 2007-07-15 19:25:01 +0000 | [diff] [blame] | 538 | #endif |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 539 | /* |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 540 | * MEM% = s->vsz/MemTotal |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 541 | */ |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 542 | pmem_shift = BITS_PER_INT-11; |
| 543 | pmem_scale = UPSCALE*(1U<<(BITS_PER_INT-11)) / total_memory; |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 544 | /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */ |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 545 | while (pmem_scale >= 512) { |
| 546 | pmem_scale /= 4; |
| 547 | pmem_shift -= 2; |
| 548 | } |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 549 | pmem_half = (1U << pmem_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2); |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 550 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 551 | busy_jifs = cur_jif.busy - prev_jif.busy; |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 552 | /* This happens if there were lots of short-lived processes |
| 553 | * between two top updates (e.g. compilation) */ |
| 554 | if (total_pcpu < busy_jifs) total_pcpu = busy_jifs; |
| 555 | |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 556 | /* |
| 557 | * CPU% = s->pcpu/sum(s->pcpu) * busy_cpu_ticks/total_cpu_ticks |
| 558 | * (pcpu is delta of sys+user time between samples) |
| 559 | */ |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 560 | /* (cur_jif.xxx - prev_jif.xxx) and s->pcpu are |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 561 | * in 0..~64000 range (HZ*update_interval). |
| 562 | * we assume that unsigned is at least 32-bit. |
| 563 | */ |
| 564 | pcpu_shift = 6; |
Denys Vlasenko | fe73798 | 2009-09-12 15:11:50 +0200 | [diff] [blame] | 565 | pcpu_scale = UPSCALE*64 * (uint16_t)busy_jifs; |
| 566 | if (pcpu_scale == 0) |
| 567 | pcpu_scale = 1; |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 568 | while (pcpu_scale < (1U << (BITS_PER_INT-2))) { |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 569 | pcpu_scale *= 4; |
| 570 | pcpu_shift += 2; |
| 571 | } |
Denys Vlasenko | fe73798 | 2009-09-12 15:11:50 +0200 | [diff] [blame] | 572 | tmp_unsigned = (uint16_t)(cur_jif.total - prev_jif.total) * total_pcpu; |
| 573 | if (tmp_unsigned != 0) |
| 574 | pcpu_scale /= tmp_unsigned; |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 575 | /* we want (s->pcpu * pcpu_scale) to never overflow */ |
| 576 | while (pcpu_scale >= 1024) { |
| 577 | pcpu_scale /= 4; |
| 578 | pcpu_shift -= 2; |
| 579 | } |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 580 | pcpu_half = (1U << pcpu_shift) / (ENABLE_FEATURE_TOP_DECIMALS? 20 : 2); |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 581 | /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */ |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 582 | #endif |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 583 | |
Bernhard Reutner-Fischer | a985d30 | 2008-02-11 11:44:38 +0000 | [diff] [blame] | 584 | /* Ok, all preliminary data is ready, go through the list */ |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 585 | scr_width += 2; /* account for leading '\n' and trailing NUL */ |
| 586 | if (lines_rem > ntop) |
| 587 | lines_rem = ntop; |
| 588 | s = top; |
| 589 | while (--lines_rem >= 0) { |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 590 | unsigned col; |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 591 | CALC_STAT(pmem, (s->vsz*pmem_scale + pmem_half) >> pmem_shift); |
| 592 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
| 593 | CALC_STAT(pcpu, (s->pcpu*pcpu_scale + pcpu_half) >> pcpu_shift); |
| 594 | #endif |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 595 | |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 596 | if (s->vsz >= 100000) |
Denis Vlasenko | b308d81 | 2007-08-28 19:35:34 +0000 | [diff] [blame] | 597 | sprintf(vsz_str_buf, "%6ldm", s->vsz/1024); |
Manuel Novoa III | d499330 | 2002-09-18 19:27:10 +0000 | [diff] [blame] | 598 | else |
Mike Frysinger | 0aa6ba5 | 2007-02-08 08:21:58 +0000 | [diff] [blame] | 599 | sprintf(vsz_str_buf, "%7ld", s->vsz); |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 600 | /* PID PPID USER STAT VSZ %MEM [%CPU] COMMAND */ |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 601 | col = snprintf(line_buf, scr_width, |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 602 | "\n" "%5u%6u %-8.8s %s%s" FMT |
Denys Vlasenko | 9be4f31 | 2009-11-07 04:06:31 +0100 | [diff] [blame] | 603 | IF_FEATURE_TOP_SMP_PROCESS(" %3d") |
| 604 | IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(FMT) |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 605 | " ", |
| 606 | s->pid, s->ppid, get_cached_username(s->uid), |
| 607 | s->state, vsz_str_buf, |
| 608 | SHOW_STAT(pmem) |
Denys Vlasenko | 9be4f31 | 2009-11-07 04:06:31 +0100 | [diff] [blame] | 609 | IF_FEATURE_TOP_SMP_PROCESS(, s->last_seen_on_cpu) |
| 610 | IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(, SHOW_STAT(pcpu)) |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 611 | ); |
Denis Vlasenko | 6b06cb8 | 2008-05-15 21:30:45 +0000 | [diff] [blame] | 612 | if ((int)(col + 1) < scr_width) |
Denys Vlasenko | 3a0f6f2 | 2009-09-12 00:15:34 +0200 | [diff] [blame] | 613 | read_cmdline(line_buf + col, scr_width - col, s->pid, s->comm); |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 614 | fputs(line_buf, stdout); |
Bernhard Reutner-Fischer | e2922e4 | 2006-05-19 12:48:56 +0000 | [diff] [blame] | 615 | /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu, |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 616 | cur_jif.busy - prev_jif.busy, cur_jif.total - prev_jif.total); */ |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 617 | s++; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 618 | } |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 619 | /* printf(" %d", hist_iterations); */ |
Denis Vlasenko | 4daad90 | 2007-09-27 10:20:47 +0000 | [diff] [blame] | 620 | bb_putchar(OPT_BATCH_MODE ? '\n' : '\r'); |
Denys Vlasenko | 8131eea | 2009-11-02 14:19:51 +0100 | [diff] [blame] | 621 | fflush_all(); |
Eric Andersen | 44608e9 | 2002-10-22 12:21:15 +0000 | [diff] [blame] | 622 | } |
Denis Vlasenko | 24c5fba | 2007-07-15 19:25:01 +0000 | [diff] [blame] | 623 | #undef UPSCALE |
Denis Vlasenko | 7451196 | 2007-06-11 16:31:55 +0000 | [diff] [blame] | 624 | #undef SHOW_STAT |
| 625 | #undef CALC_STAT |
| 626 | #undef FMT |
Eric Andersen | 44608e9 | 2002-10-22 12:21:15 +0000 | [diff] [blame] | 627 | |
| 628 | static void clearmems(void) |
| 629 | { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 630 | clear_username_cache(); |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 631 | free(top); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 632 | top = NULL; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 633 | ntop = 0; |
| 634 | } |
| 635 | |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 636 | #if ENABLE_FEATURE_USE_TERMIOS |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 637 | |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 638 | static void reset_term(void) |
| 639 | { |
Denis Vlasenko | 202ac50 | 2008-11-05 13:20:58 +0000 | [diff] [blame] | 640 | tcsetattr_stdin_TCSANOW(&initial_settings); |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 641 | if (ENABLE_FEATURE_CLEAN_UP) { |
| 642 | clearmems(); |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 643 | # if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 644 | free(prev_hist); |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 645 | # endif |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 646 | } |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 647 | } |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 648 | |
Denis Vlasenko | a60f84e | 2008-07-05 09:18:54 +0000 | [diff] [blame] | 649 | static void sig_catcher(int sig UNUSED_PARAM) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 650 | { |
| 651 | reset_term(); |
Bernhard Reutner-Fischer | 636a1f8 | 2008-05-19 09:29:47 +0000 | [diff] [blame] | 652 | exit(EXIT_FAILURE); |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 653 | } |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 654 | #endif /* FEATURE_USE_TERMIOS */ |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 655 | |
Denis Vlasenko | e7c1ad1 | 2007-09-08 17:21:01 +0000 | [diff] [blame] | 656 | /* |
| 657 | * TOPMEM support |
| 658 | */ |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 659 | |
| 660 | typedef unsigned long mem_t; |
| 661 | |
| 662 | typedef struct topmem_status_t { |
| 663 | unsigned pid; |
| 664 | char comm[COMM_LEN]; |
| 665 | /* vsz doesn't count /dev/xxx mappings except /dev/zero */ |
| 666 | mem_t vsz ; |
| 667 | mem_t vszrw ; |
| 668 | mem_t rss ; |
| 669 | mem_t rss_sh ; |
| 670 | mem_t dirty ; |
| 671 | mem_t dirty_sh; |
| 672 | mem_t stack ; |
| 673 | } topmem_status_t; |
| 674 | |
| 675 | enum { NUM_SORT_FIELD = 7 }; |
| 676 | |
| 677 | #define topmem ((topmem_status_t*)top) |
| 678 | |
| 679 | #if ENABLE_FEATURE_TOPMEM |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 680 | |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 681 | static int topmem_sort(char *a, char *b) |
| 682 | { |
| 683 | int n; |
| 684 | mem_t l, r; |
| 685 | |
| 686 | n = offsetof(topmem_status_t, vsz) + (sort_field * sizeof(mem_t)); |
| 687 | l = *(mem_t*)(a + n); |
| 688 | r = *(mem_t*)(b + n); |
Denys Vlasenko | a95ce93 | 2010-07-13 12:13:04 +0200 | [diff] [blame] | 689 | if (l == r) { |
| 690 | l = ((topmem_status_t*)a)->dirty; |
| 691 | r = ((topmem_status_t*)b)->dirty; |
| 692 | } |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 693 | /* We want to avoid unsigned->signed and truncation errors */ |
| 694 | /* l>r: -1, l=r: 0, l<r: 1 */ |
| 695 | n = (l > r) ? -1 : (l != r); |
| 696 | return inverted ? -n : n; |
| 697 | } |
| 698 | |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 699 | /* display header info (meminfo / loadavg) */ |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 700 | static void display_topmem_header(int scr_width, int *lines_rem_p) |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 701 | { |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 702 | enum { |
| 703 | TOTAL = 0, MFREE, BUF, CACHE, |
| 704 | SWAPTOTAL, SWAPFREE, DIRTY, |
| 705 | MWRITE, ANON, MAP, SLAB, |
| 706 | NUM_FIELDS |
| 707 | }; |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 708 | static const char match[NUM_FIELDS][12] = { |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 709 | "\x09" "MemTotal:", // TOTAL |
| 710 | "\x08" "MemFree:", // MFREE |
| 711 | "\x08" "Buffers:", // BUF |
| 712 | "\x07" "Cached:", // CACHE |
| 713 | "\x0a" "SwapTotal:", // SWAPTOTAL |
| 714 | "\x09" "SwapFree:", // SWAPFREE |
| 715 | "\x06" "Dirty:", // DIRTY |
| 716 | "\x0a" "Writeback:", // MWRITE |
| 717 | "\x0a" "AnonPages:", // ANON |
| 718 | "\x07" "Mapped:", // MAP |
| 719 | "\x05" "Slab:", // SLAB |
| 720 | }; |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 721 | char meminfo_buf[4 * 1024]; |
| 722 | const char *Z[NUM_FIELDS]; |
Denis Vlasenko | 6b06cb8 | 2008-05-15 21:30:45 +0000 | [diff] [blame] | 723 | unsigned i; |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 724 | int sz; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 725 | |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 726 | for (i = 0; i < NUM_FIELDS; i++) |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 727 | Z[i] = "?"; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 728 | |
| 729 | /* read memory info */ |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 730 | sz = open_read_close("meminfo", meminfo_buf, sizeof(meminfo_buf) - 1); |
| 731 | if (sz >= 0) { |
| 732 | char *p = meminfo_buf; |
| 733 | meminfo_buf[sz] = '\0'; |
| 734 | /* Note that fields always appear in the match[] order */ |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 735 | for (i = 0; i < NUM_FIELDS; i++) { |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 736 | char *found = strstr(p, match[i] + 1); |
| 737 | if (found) { |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 738 | /* Cut "NNNN" out of " NNNN kb" */ |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 739 | char *s = skip_whitespace(found + match[i][0]); |
| 740 | p = skip_non_whitespace(s); |
| 741 | *p++ = '\0'; |
| 742 | Z[i] = s; |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 743 | } |
| 744 | } |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 745 | } |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 746 | |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 747 | snprintf(line_buf, LINE_BUF_SIZE, |
Denys Vlasenko | 917693b | 2010-03-04 12:50:59 +0100 | [diff] [blame] | 748 | "Mem total:%s anon:%s map:%s free:%s", |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 749 | Z[TOTAL], Z[ANON], Z[MAP], Z[MFREE]); |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 750 | printf(OPT_BATCH_MODE ? "%.*s\n" : "\033[H\033[J%.*s\n", scr_width, line_buf); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 751 | |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 752 | snprintf(line_buf, LINE_BUF_SIZE, |
Denys Vlasenko | 917693b | 2010-03-04 12:50:59 +0100 | [diff] [blame] | 753 | " slab:%s buf:%s cache:%s dirty:%s write:%s", |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 754 | Z[SLAB], Z[BUF], Z[CACHE], Z[DIRTY], Z[MWRITE]); |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 755 | printf("%.*s\n", scr_width, line_buf); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 756 | |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 757 | snprintf(line_buf, LINE_BUF_SIZE, |
Denys Vlasenko | 917693b | 2010-03-04 12:50:59 +0100 | [diff] [blame] | 758 | "Swap total:%s free:%s", // TODO: % used? |
Maksym Kryzhanovskyy | 87496aa | 2010-06-06 08:24:39 +0200 | [diff] [blame] | 759 | Z[SWAPTOTAL], Z[SWAPFREE]); |
Denys Vlasenko | d94332f | 2010-06-06 17:40:54 +0200 | [diff] [blame] | 760 | printf("%.*s\n", scr_width, line_buf); |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 761 | |
| 762 | (*lines_rem_p) -= 3; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 763 | } |
| 764 | |
Denis Vlasenko | 56ea65c | 2008-01-06 03:26:53 +0000 | [diff] [blame] | 765 | static void ulltoa6_and_space(unsigned long long ul, char buf[6]) |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 766 | { |
Denis Vlasenko | 56ea65c | 2008-01-06 03:26:53 +0000 | [diff] [blame] | 767 | /* see http://en.wikipedia.org/wiki/Tera */ |
| 768 | smart_ulltoa5(ul, buf, " mgtpezy"); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 769 | buf[5] = ' '; |
| 770 | } |
| 771 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 772 | static NOINLINE void display_topmem_process_list(int lines_rem, int scr_width) |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 773 | { |
| 774 | #define HDR_STR " PID VSZ VSZRW RSS (SHR) DIRTY (SHR) STACK" |
| 775 | #define MIN_WIDTH sizeof(HDR_STR) |
| 776 | const topmem_status_t *s = topmem; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 777 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 778 | display_topmem_header(scr_width, &lines_rem); |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 779 | strcpy(line_buf, HDR_STR " COMMAND"); |
| 780 | line_buf[5 + sort_field * 6] = '*'; |
| 781 | printf(OPT_BATCH_MODE ? "%.*s" : "\e[7m%.*s\e[0m", scr_width, line_buf); |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 782 | lines_rem--; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 783 | |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 784 | if (lines_rem > ntop) |
| 785 | lines_rem = ntop; |
| 786 | while (--lines_rem >= 0) { |
| 787 | /* PID VSZ VSZRW RSS (SHR) DIRTY (SHR) COMMAND */ |
Denis Vlasenko | 56ea65c | 2008-01-06 03:26:53 +0000 | [diff] [blame] | 788 | ulltoa6_and_space(s->pid , &line_buf[0*6]); |
| 789 | ulltoa6_and_space(s->vsz , &line_buf[1*6]); |
| 790 | ulltoa6_and_space(s->vszrw , &line_buf[2*6]); |
| 791 | ulltoa6_and_space(s->rss , &line_buf[3*6]); |
| 792 | ulltoa6_and_space(s->rss_sh , &line_buf[4*6]); |
| 793 | ulltoa6_and_space(s->dirty , &line_buf[5*6]); |
| 794 | ulltoa6_and_space(s->dirty_sh, &line_buf[6*6]); |
| 795 | ulltoa6_and_space(s->stack , &line_buf[7*6]); |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 796 | line_buf[8*6] = '\0'; |
Denis Vlasenko | 6b06cb8 | 2008-05-15 21:30:45 +0000 | [diff] [blame] | 797 | if (scr_width > (int)MIN_WIDTH) { |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 798 | read_cmdline(&line_buf[8*6], scr_width - MIN_WIDTH, s->pid, s->comm); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 799 | } |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 800 | printf("\n""%.*s", scr_width, line_buf); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 801 | s++; |
| 802 | } |
Denis Vlasenko | 4daad90 | 2007-09-27 10:20:47 +0000 | [diff] [blame] | 803 | bb_putchar(OPT_BATCH_MODE ? '\n' : '\r'); |
Denys Vlasenko | 8131eea | 2009-11-02 14:19:51 +0100 | [diff] [blame] | 804 | fflush_all(); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 805 | #undef HDR_STR |
| 806 | #undef MIN_WIDTH |
| 807 | } |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 808 | |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 809 | #else |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 810 | void display_topmem_process_list(int lines_rem, int scr_width); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 811 | int topmem_sort(char *a, char *b); |
| 812 | #endif /* TOPMEM */ |
| 813 | |
Denis Vlasenko | e7c1ad1 | 2007-09-08 17:21:01 +0000 | [diff] [blame] | 814 | /* |
| 815 | * end TOPMEM support |
| 816 | */ |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 817 | |
| 818 | enum { |
| 819 | TOP_MASK = 0 |
| 820 | | PSSCAN_PID |
| 821 | | PSSCAN_PPID |
| 822 | | PSSCAN_VSZ |
| 823 | | PSSCAN_STIME |
| 824 | | PSSCAN_UTIME |
| 825 | | PSSCAN_STATE |
| 826 | | PSSCAN_COMM |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 827 | | PSSCAN_CPU |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 828 | | PSSCAN_UIDGID, |
| 829 | TOPMEM_MASK = 0 |
| 830 | | PSSCAN_PID |
| 831 | | PSSCAN_SMAPS |
| 832 | | PSSCAN_COMM, |
| 833 | }; |
| 834 | |
Denis Vlasenko | 9b49a5e | 2007-10-11 10:05:36 +0000 | [diff] [blame] | 835 | int top_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
Denis Vlasenko | a60f84e | 2008-07-05 09:18:54 +0000 | [diff] [blame] | 836 | int top_main(int argc UNUSED_PARAM, char **argv) |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 837 | { |
Denis Vlasenko | e7c1ad1 | 2007-09-08 17:21:01 +0000 | [diff] [blame] | 838 | int iterations; |
Denis Vlasenko | 5599502 | 2008-05-18 22:28:26 +0000 | [diff] [blame] | 839 | unsigned lines, col; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 840 | int lines_rem; |
Denis Vlasenko | 5599502 | 2008-05-18 22:28:26 +0000 | [diff] [blame] | 841 | unsigned interval; |
Denis Vlasenko | c884221 | 2008-09-25 11:42:10 +0000 | [diff] [blame] | 842 | char *str_interval, *str_iterations; |
Denys Vlasenko | d75295c | 2009-09-21 23:58:43 +0200 | [diff] [blame] | 843 | unsigned scan_mask = TOP_MASK; |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 844 | #if ENABLE_FEATURE_USE_TERMIOS |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 845 | struct termios new_settings; |
Denis Vlasenko | b308d81 | 2007-08-28 19:35:34 +0000 | [diff] [blame] | 846 | struct pollfd pfd[1]; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 847 | unsigned char c; |
Denis Vlasenko | b308d81 | 2007-08-28 19:35:34 +0000 | [diff] [blame] | 848 | |
| 849 | pfd[0].fd = 0; |
| 850 | pfd[0].events = POLLIN; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 851 | #endif |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 852 | |
Denis Vlasenko | e7c1ad1 | 2007-09-08 17:21:01 +0000 | [diff] [blame] | 853 | INIT_G(); |
| 854 | |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 855 | interval = 5; /* default update interval is 5 seconds */ |
Denis Vlasenko | e7c1ad1 | 2007-09-08 17:21:01 +0000 | [diff] [blame] | 856 | iterations = 0; /* infinite */ |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 857 | #if ENABLE_FEATURE_TOP_SMP_CPU |
| 858 | /*num_cpus = 0;*/ |
| 859 | /*smp_cpu_info = 0;*/ /* to start with show aggregate */ |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 860 | cpu_jif = &cur_jif; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 861 | cpu_prev_jif = &prev_jif; |
| 862 | #endif |
Denis Vlasenko | 8581863 | 2007-04-19 14:47:11 +0000 | [diff] [blame] | 863 | |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 864 | /* all args are options; -n NUM */ |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 865 | opt_complementary = "-"; /* options can be specified w/o dash */ |
| 866 | col = getopt32(argv, "d:n:b"IF_FEATURE_TOPMEM("m"), &str_interval, &str_iterations); |
| 867 | #if ENABLE_FEATURE_TOPMEM |
| 868 | if (col & OPT_m) /* -m (busybox specific) */ |
| 869 | scan_mask = TOPMEM_MASK; |
| 870 | #endif |
Denis Vlasenko | c884221 | 2008-09-25 11:42:10 +0000 | [diff] [blame] | 871 | if (col & OPT_d) { |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 872 | /* work around for "-d 1" -> "-d -1" done by getopt32 |
| 873 | * (opt_complementary == "-" does this) */ |
Denis Vlasenko | c884221 | 2008-09-25 11:42:10 +0000 | [diff] [blame] | 874 | if (str_interval[0] == '-') |
| 875 | str_interval++; |
Denis Vlasenko | b308d81 | 2007-08-28 19:35:34 +0000 | [diff] [blame] | 876 | /* Need to limit it to not overflow poll timeout */ |
Denis Vlasenko | c884221 | 2008-09-25 11:42:10 +0000 | [diff] [blame] | 877 | interval = xatou16(str_interval); |
| 878 | } |
| 879 | if (col & OPT_n) { |
| 880 | if (str_iterations[0] == '-') |
| 881 | str_iterations++; |
| 882 | iterations = xatou(str_iterations); |
Denis Vlasenko | b308d81 | 2007-08-28 19:35:34 +0000 | [diff] [blame] | 883 | } |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 884 | |
Eric Andersen | 44608e9 | 2002-10-22 12:21:15 +0000 | [diff] [blame] | 885 | /* change to /proc */ |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 886 | xchdir("/proc"); |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 887 | #if ENABLE_FEATURE_USE_TERMIOS |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 888 | tcgetattr(0, (void *) &initial_settings); |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 889 | memcpy(&new_settings, &initial_settings, sizeof(new_settings)); |
Denis Vlasenko | 42dfcd2 | 2006-09-09 12:55:02 +0000 | [diff] [blame] | 890 | /* unbuffered input, turn off echo */ |
| 891 | new_settings.c_lflag &= ~(ISIG | ICANON | ECHO | ECHONL); |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 892 | |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 893 | bb_signals(BB_FATAL_SIGS, sig_catcher); |
Denis Vlasenko | 202ac50 | 2008-11-05 13:20:58 +0000 | [diff] [blame] | 894 | tcsetattr_stdin_TCSANOW(&new_settings); |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 895 | #endif |
Mike Frysinger | 223b887 | 2005-07-30 09:42:05 +0000 | [diff] [blame] | 896 | |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 897 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 898 | sort_function[0] = pcpu_sort; |
| 899 | sort_function[1] = mem_sort; |
| 900 | sort_function[2] = time_sort; |
| 901 | #else |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 902 | sort_function[0] = mem_sort; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 903 | #endif |
Mike Frysinger | 223b887 | 2005-07-30 09:42:05 +0000 | [diff] [blame] | 904 | |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 905 | while (1) { |
Denis Vlasenko | 459e4d6 | 2006-11-05 00:43:51 +0000 | [diff] [blame] | 906 | procps_status_t *p = NULL; |
Eric Andersen | 44608e9 | 2002-10-22 12:21:15 +0000 | [diff] [blame] | 907 | |
Denis Vlasenko | e7c1ad1 | 2007-09-08 17:21:01 +0000 | [diff] [blame] | 908 | lines = 24; /* default */ |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 909 | col = 79; |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 910 | #if ENABLE_FEATURE_USE_TERMIOS |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 911 | /* We output to stdout, we need size of stdout (not stdin)! */ |
| 912 | get_terminal_width_height(STDOUT_FILENO, &col, &lines); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 913 | if (lines < 5 || col < 10) { |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 914 | sleep(interval); |
| 915 | continue; |
| 916 | } |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 917 | #endif |
Denis Vlasenko | 4c1d88d | 2007-09-08 17:34:05 +0000 | [diff] [blame] | 918 | if (col > LINE_BUF_SIZE-2) /* +2 bytes for '\n', NUL, */ |
| 919 | col = LINE_BUF_SIZE-2; |
Rob Landley | 997650b | 2006-04-24 23:13:46 +0000 | [diff] [blame] | 920 | |
| 921 | /* read process IDs & status for all the processes */ |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 922 | while ((p = procps_scan(p, scan_mask)) != NULL) { |
| 923 | int n; |
Denys Vlasenko | b410d4a | 2009-09-19 22:29:42 +0200 | [diff] [blame] | 924 | #if ENABLE_FEATURE_TOPMEM |
| 925 | if (scan_mask != TOPMEM_MASK) |
| 926 | #endif |
| 927 | { |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 928 | n = ntop; |
Denis Vlasenko | 2784228 | 2008-08-04 13:20:36 +0000 | [diff] [blame] | 929 | top = xrealloc_vector(top, 6, ntop++); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 930 | top[n].pid = p->pid; |
| 931 | top[n].ppid = p->ppid; |
| 932 | top[n].vsz = p->vsz; |
Denis Vlasenko | 3bba545 | 2006-12-30 17:57:03 +0000 | [diff] [blame] | 933 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 934 | top[n].ticks = p->stime + p->utime; |
Denis Vlasenko | 3bba545 | 2006-12-30 17:57:03 +0000 | [diff] [blame] | 935 | #endif |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 936 | top[n].uid = p->uid; |
| 937 | strcpy(top[n].state, p->state); |
| 938 | strcpy(top[n].comm, p->comm); |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 939 | #if ENABLE_FEATURE_TOP_SMP_PROCESS |
| 940 | top[n].last_seen_on_cpu = p->last_seen_on_cpu; |
| 941 | #endif |
Denys Vlasenko | b410d4a | 2009-09-19 22:29:42 +0200 | [diff] [blame] | 942 | } |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 943 | #if ENABLE_FEATURE_TOPMEM |
Denys Vlasenko | b410d4a | 2009-09-19 22:29:42 +0200 | [diff] [blame] | 944 | else { /* TOPMEM */ |
Alexander Shishkin | 0834a6d | 2010-08-28 23:20:34 +0200 | [diff] [blame] | 945 | if (!(p->smaps.mapped_ro | p->smaps.mapped_rw)) |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 946 | continue; /* kernel threads are ignored */ |
| 947 | n = ntop; |
Denis Vlasenko | deeed59 | 2008-07-08 05:14:36 +0000 | [diff] [blame] | 948 | /* No bug here - top and topmem are the same */ |
Denis Vlasenko | 2784228 | 2008-08-04 13:20:36 +0000 | [diff] [blame] | 949 | top = xrealloc_vector(topmem, 6, ntop++); |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 950 | strcpy(topmem[n].comm, p->comm); |
| 951 | topmem[n].pid = p->pid; |
Alexander Shishkin | 0834a6d | 2010-08-28 23:20:34 +0200 | [diff] [blame] | 952 | topmem[n].vsz = p->smaps.mapped_rw + p->smaps.mapped_ro; |
| 953 | topmem[n].vszrw = p->smaps.mapped_rw; |
| 954 | topmem[n].rss_sh = p->smaps.shared_clean + p->smaps.shared_dirty; |
| 955 | topmem[n].rss = p->smaps.private_clean + p->smaps.private_dirty + topmem[n].rss_sh; |
| 956 | topmem[n].dirty = p->smaps.private_dirty + p->smaps.shared_dirty; |
| 957 | topmem[n].dirty_sh = p->smaps.shared_dirty; |
| 958 | topmem[n].stack = p->smaps.stack; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 959 | } |
Denys Vlasenko | b410d4a | 2009-09-19 22:29:42 +0200 | [diff] [blame] | 960 | #endif |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 961 | } /* end of "while we read /proc" */ |
Eric Andersen | 44608e9 | 2002-10-22 12:21:15 +0000 | [diff] [blame] | 962 | if (ntop == 0) { |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 963 | bb_error_msg("no process info in /proc"); |
| 964 | break; |
Rob Landley | b280455 | 2006-02-13 22:04:27 +0000 | [diff] [blame] | 965 | } |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 966 | |
Denys Vlasenko | b410d4a | 2009-09-19 22:29:42 +0200 | [diff] [blame] | 967 | if (scan_mask != TOPMEM_MASK) { |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 968 | #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 969 | if (!prev_hist_count) { |
| 970 | do_stats(); |
| 971 | usleep(100000); |
| 972 | clearmems(); |
| 973 | continue; |
| 974 | } |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 975 | do_stats(); |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 976 | /* TODO: we don't need to sort all 10000 processes, we need to find top 24! */ |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 977 | qsort(top, ntop, sizeof(top_status_t), (void*)mult_lvl_cmp); |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 978 | #else |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 979 | qsort(top, ntop, sizeof(top_status_t), (void*)(sort_function[0])); |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 980 | #endif |
Denis Vlasenko | e96dcb4 | 2008-04-17 18:04:38 +0000 | [diff] [blame] | 981 | } |
| 982 | #if ENABLE_FEATURE_TOPMEM |
| 983 | else { /* TOPMEM */ |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 984 | qsort(topmem, ntop, sizeof(topmem_status_t), (void*)topmem_sort); |
| 985 | } |
Denis Vlasenko | e96dcb4 | 2008-04-17 18:04:38 +0000 | [diff] [blame] | 986 | #endif |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 987 | lines_rem = lines; |
| 988 | if (OPT_BATCH_MODE) { |
| 989 | lines_rem = INT_MAX; |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 990 | } |
Denys Vlasenko | b410d4a | 2009-09-19 22:29:42 +0200 | [diff] [blame] | 991 | if (scan_mask != TOPMEM_MASK) |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 992 | display_process_list(lines_rem, col); |
Denis Vlasenko | e96dcb4 | 2008-04-17 18:04:38 +0000 | [diff] [blame] | 993 | #if ENABLE_FEATURE_TOPMEM |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 994 | else |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 995 | display_topmem_process_list(lines_rem, col); |
Denis Vlasenko | e96dcb4 | 2008-04-17 18:04:38 +0000 | [diff] [blame] | 996 | #endif |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 997 | clearmems(); |
| 998 | if (iterations >= 0 && !--iterations) |
| 999 | break; |
| 1000 | #if !ENABLE_FEATURE_USE_TERMIOS |
| 1001 | sleep(interval); |
| 1002 | #else |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 1003 | if (option_mask32 & (OPT_b|OPT_EOF)) |
| 1004 | /* batch mode, or EOF on stdin ("top </dev/null") */ |
| 1005 | sleep(interval); |
| 1006 | else if (safe_poll(pfd, 1, interval * 1000) > 0) { |
Bernhard Reutner-Fischer | 5e25ddb | 2008-05-19 09:48:17 +0000 | [diff] [blame] | 1007 | if (safe_read(STDIN_FILENO, &c, 1) != 1) { /* error/EOF? */ |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 1008 | option_mask32 |= OPT_EOF; |
| 1009 | continue; |
| 1010 | } |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 1011 | if (c == initial_settings.c_cc[VINTR]) |
"Vladimir N. Oleynik" | c218a29 | 2006-02-15 17:15:56 +0000 | [diff] [blame] | 1012 | break; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 1013 | c |= 0x20; /* lowercase */ |
| 1014 | if (c == 'q') |
| 1015 | break; |
| 1016 | if (c == 'n') { |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 1017 | IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;) |
Denis Vlasenko | 8bdba4d | 2007-08-29 18:18:08 +0000 | [diff] [blame] | 1018 | sort_function[0] = pid_sort; |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 1019 | } |
| 1020 | if (c == 'm') { |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 1021 | IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 1022 | sort_function[0] = mem_sort; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 1023 | # if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 1024 | sort_function[1] = pcpu_sort; |
| 1025 | sort_function[2] = time_sort; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 1026 | # endif |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 1027 | } |
Denys Vlasenko | d75295c | 2009-09-21 23:58:43 +0200 | [diff] [blame] | 1028 | # if ENABLE_FEATURE_SHOW_THREADS |
Denys Vlasenko | b410d4a | 2009-09-19 22:29:42 +0200 | [diff] [blame] | 1029 | if (c == 'h' |
| 1030 | IF_FEATURE_TOPMEM(&& scan_mask != TOPMEM_MASK) |
| 1031 | ) { |
| 1032 | scan_mask ^= PSSCAN_TASKS; |
| 1033 | } |
Denys Vlasenko | d75295c | 2009-09-21 23:58:43 +0200 | [diff] [blame] | 1034 | # endif |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 1035 | # if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 1036 | if (c == 'p') { |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 1037 | IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 1038 | sort_function[0] = pcpu_sort; |
| 1039 | sort_function[1] = mem_sort; |
| 1040 | sort_function[2] = time_sort; |
| 1041 | } |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 1042 | if (c == 't') { |
Denis Vlasenko | 5e34ff2 | 2009-04-21 11:09:40 +0000 | [diff] [blame] | 1043 | IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;) |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 1044 | sort_function[0] = time_sort; |
| 1045 | sort_function[1] = mem_sort; |
| 1046 | sort_function[2] = pcpu_sort; |
| 1047 | } |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 1048 | # if ENABLE_FEATURE_TOPMEM |
Denis Vlasenko | ff6e8e2 | 2007-09-08 16:51:19 +0000 | [diff] [blame] | 1049 | if (c == 's') { |
| 1050 | scan_mask = TOPMEM_MASK; |
| 1051 | free(prev_hist); |
| 1052 | prev_hist = NULL; |
| 1053 | prev_hist_count = 0; |
| 1054 | sort_field = (sort_field + 1) % NUM_SORT_FIELD; |
| 1055 | } |
| 1056 | if (c == 'r') |
| 1057 | inverted ^= 1; |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 1058 | # endif |
| 1059 | # if ENABLE_FEATURE_TOP_SMP_CPU |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 1060 | /* procps-2.0.18 uses 'C', 3.2.7 uses '1' */ |
| 1061 | if (c == 'c' || c == '1') { |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 1062 | /* User wants to toggle per cpu <> aggregate */ |
| 1063 | if (smp_cpu_info) { |
| 1064 | free(cpu_prev_jif); |
| 1065 | free(cpu_jif); |
Denis Vlasenko | 35840ab | 2008-09-25 11:11:37 +0000 | [diff] [blame] | 1066 | cpu_jif = &cur_jif; |
Denis Vlasenko | 17e7f04 | 2008-09-25 10:48:06 +0000 | [diff] [blame] | 1067 | cpu_prev_jif = &prev_jif; |
| 1068 | } else { |
| 1069 | /* Prepare for xrealloc() */ |
| 1070 | cpu_jif = cpu_prev_jif = NULL; |
| 1071 | } |
| 1072 | num_cpus = 0; |
| 1073 | smp_cpu_info = !smp_cpu_info; |
| 1074 | get_jiffy_counts(); |
| 1075 | } |
Denys Vlasenko | 0052882 | 2009-09-11 23:26:42 +0200 | [diff] [blame] | 1076 | # endif |
| 1077 | # endif |
Eric Andersen | 08a7220 | 2002-09-30 20:52:10 +0000 | [diff] [blame] | 1078 | } |
Denis Vlasenko | fa07680 | 2006-11-05 00:38:51 +0000 | [diff] [blame] | 1079 | #endif /* FEATURE_USE_TERMIOS */ |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 1080 | } /* end of "while (1)" */ |
| 1081 | |
Denis Vlasenko | 4daad90 | 2007-09-27 10:20:47 +0000 | [diff] [blame] | 1082 | bb_putchar('\n'); |
Paul Fox | 275b929 | 2008-03-20 16:05:02 +0000 | [diff] [blame] | 1083 | #if ENABLE_FEATURE_USE_TERMIOS |
Denis Vlasenko | cf7cf62 | 2008-03-19 19:38:46 +0000 | [diff] [blame] | 1084 | reset_term(); |
Paul Fox | 275b929 | 2008-03-20 16:05:02 +0000 | [diff] [blame] | 1085 | #endif |
Eric Andersen | 420b208 | 2002-09-17 22:14:58 +0000 | [diff] [blame] | 1086 | return EXIT_SUCCESS; |
| 1087 | } |