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