3
0

top.c 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290
  1. /* vi: set sw=4 ts=4: */
  2. /*
  3. * A tiny 'top' utility.
  4. *
  5. * This is written specifically for the linux /proc/<PID>/stat(m)
  6. * files format.
  7. *
  8. * This reads the PIDs of all processes and their status and shows
  9. * the status of processes (first ones that fit to screen) at given
  10. * intervals.
  11. *
  12. * NOTES:
  13. * - At startup this changes to /proc, all the reads are then
  14. * relative to that.
  15. *
  16. * (C) Eero Tamminen <oak at welho dot com>
  17. *
  18. * Rewritten by Vladimir Oleynik (C) 2002 <dzo@simtreas.ru>
  19. *
  20. * 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
  25. *
  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
  30. *
  31. * Licensed under GPLv2, see file LICENSE in this source tree.
  32. */
  33. /* How to snapshot /proc for debugging top problems:
  34. * for f in /proc/[0-9]*""/stat; do
  35. * n=${f#/proc/}
  36. * n=${n%/stat}_stat
  37. * cp $f $n
  38. * done
  39. * cp /proc/stat /proc/meminfo /proc/loadavg .
  40. * top -bn1 >top.out
  41. *
  42. * ...and how to run top on it on another machine:
  43. * rm -rf proc; mkdir proc
  44. * for f in [0-9]*_stat; do
  45. * p=${f%_stat}
  46. * mkdir -p proc/$p
  47. * cp $f proc/$p/stat
  48. * done
  49. * cp stat meminfo loadavg proc
  50. * chroot . ./top -bn1 >top1.out
  51. */
  52. //config:config TOP
  53. //config: bool "top (18 kb)"
  54. //config: default y
  55. //config: help
  56. //config: The top program provides a dynamic real-time view of a running
  57. //config: system.
  58. //config:
  59. //config:config FEATURE_TOP_INTERACTIVE
  60. //config: bool "Accept keyboard commands"
  61. //config: default y
  62. //config: depends on TOP
  63. //config: help
  64. //config: Without this, top will only refresh display every 5 seconds.
  65. //config: No keyboard commands will work, only ^C to terminate.
  66. //config:
  67. //config:config FEATURE_TOP_CPU_USAGE_PERCENTAGE
  68. //config: bool "Show CPU per-process usage percentage"
  69. //config: default y
  70. //config: depends on TOP
  71. //config: help
  72. //config: Make top display CPU usage for each process.
  73. //config: This adds about 2k.
  74. //config:
  75. //config:config FEATURE_TOP_CPU_GLOBAL_PERCENTS
  76. //config: bool "Show CPU global usage percentage"
  77. //config: default y
  78. //config: depends on FEATURE_TOP_CPU_USAGE_PERCENTAGE
  79. //config: help
  80. //config: Makes top display "CPU: NN% usr NN% sys..." line.
  81. //config: This adds about 0.5k.
  82. //config:
  83. //config:config FEATURE_TOP_SMP_CPU
  84. //config: bool "SMP CPU usage display ('c' key)"
  85. //config: default y
  86. //config: depends on FEATURE_TOP_CPU_GLOBAL_PERCENTS
  87. //config: help
  88. //config: Allow 'c' key to switch between individual/cumulative CPU stats
  89. //config: This adds about 0.5k.
  90. //config:
  91. //config:config FEATURE_TOP_DECIMALS
  92. //config: bool "Show 1/10th of a percent in CPU/mem statistics"
  93. //config: default y
  94. //config: depends on FEATURE_TOP_CPU_USAGE_PERCENTAGE
  95. //config: help
  96. //config: Show 1/10th of a percent in CPU/mem statistics.
  97. //config: This adds about 0.3k.
  98. //config:
  99. //config:config FEATURE_TOP_SMP_PROCESS
  100. //config: bool "Show CPU process runs on ('j' field)"
  101. //config: default y
  102. //config: depends on TOP
  103. //config: help
  104. //config: Show CPU where process was last found running on.
  105. //config: This is the 'j' field.
  106. //config:
  107. //config:config FEATURE_TOPMEM
  108. //config: bool "Topmem command ('s' key)"
  109. //config: default y
  110. //config: depends on TOP
  111. //config: help
  112. //config: Enable 's' in top (gives lots of memory info).
  113. //applet:IF_TOP(APPLET(top, BB_DIR_USR_BIN, BB_SUID_DROP))
  114. //kbuild:lib-$(CONFIG_TOP) += top.o
  115. #include "libbb.h"
  116. #define ESC "\033"
  117. typedef struct top_status_t {
  118. unsigned long vsz;
  119. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  120. unsigned long ticks;
  121. unsigned pcpu; /* delta of ticks */
  122. #endif
  123. unsigned pid, ppid;
  124. unsigned uid;
  125. char state[4];
  126. char comm[COMM_LEN];
  127. #if ENABLE_FEATURE_TOP_SMP_PROCESS
  128. int last_seen_on_cpu;
  129. #endif
  130. } top_status_t;
  131. typedef struct jiffy_counts_t {
  132. /* Linux 2.4.x has only first four */
  133. unsigned long long usr, nic, sys, idle;
  134. unsigned long long iowait, irq, softirq, steal;
  135. unsigned long long total;
  136. unsigned long long busy;
  137. } jiffy_counts_t;
  138. /* This structure stores some critical information from one frame to
  139. the next. Used for finding deltas. */
  140. typedef struct save_hist {
  141. unsigned long ticks;
  142. pid_t pid;
  143. } save_hist;
  144. typedef int (*cmp_funcp)(top_status_t *P, top_status_t *Q);
  145. enum { SORT_DEPTH = 3 };
  146. /* Screens wider than this are unlikely */
  147. enum { LINE_BUF_SIZE = 512 - 64 };
  148. struct globals {
  149. top_status_t *top;
  150. int ntop;
  151. smallint inverted;
  152. #if ENABLE_FEATURE_TOPMEM
  153. smallint sort_field;
  154. #endif
  155. #if ENABLE_FEATURE_TOP_SMP_CPU
  156. smallint smp_cpu_info; /* one/many cpu info lines? */
  157. #endif
  158. unsigned lines; /* screen height */
  159. #if ENABLE_FEATURE_TOP_INTERACTIVE
  160. struct termios initial_settings;
  161. int scroll_ofs;
  162. #define G_scroll_ofs G.scroll_ofs
  163. #else
  164. #define G_scroll_ofs 0
  165. #endif
  166. #if !ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  167. cmp_funcp sort_function[1];
  168. #else
  169. cmp_funcp sort_function[SORT_DEPTH];
  170. struct save_hist *prev_hist;
  171. unsigned prev_hist_count;
  172. jiffy_counts_t cur_jif, prev_jif;
  173. /* int hist_iterations; */
  174. unsigned total_pcpu;
  175. /* unsigned long total_vsz; */
  176. #endif
  177. #if ENABLE_FEATURE_TOP_SMP_CPU
  178. /* Per CPU samples: current and last */
  179. jiffy_counts_t *cpu_jif, *cpu_prev_jif;
  180. unsigned num_cpus;
  181. #endif
  182. #if ENABLE_FEATURE_TOP_INTERACTIVE
  183. char kbd_input[KEYCODE_BUFFER_SIZE];
  184. #endif
  185. char line_buf[LINE_BUF_SIZE];
  186. };
  187. #define G (*ptr_to_globals)
  188. #define top (G.top )
  189. #define ntop (G.ntop )
  190. #define sort_field (G.sort_field )
  191. #define inverted (G.inverted )
  192. #define smp_cpu_info (G.smp_cpu_info )
  193. #define initial_settings (G.initial_settings )
  194. #define sort_function (G.sort_function )
  195. #define prev_hist (G.prev_hist )
  196. #define prev_hist_count (G.prev_hist_count )
  197. #define cur_jif (G.cur_jif )
  198. #define prev_jif (G.prev_jif )
  199. #define cpu_jif (G.cpu_jif )
  200. #define cpu_prev_jif (G.cpu_prev_jif )
  201. #define num_cpus (G.num_cpus )
  202. #define total_pcpu (G.total_pcpu )
  203. #define line_buf (G.line_buf )
  204. #define INIT_G() do { \
  205. SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
  206. BUILD_BUG_ON(LINE_BUF_SIZE <= 80); \
  207. } while (0)
  208. enum {
  209. OPT_d = (1 << 0),
  210. OPT_n = (1 << 1),
  211. OPT_b = (1 << 2),
  212. OPT_H = (1 << 3),
  213. OPT_m = (1 << 4),
  214. OPT_EOF = (1 << 5), /* pseudo: "we saw EOF in stdin" */
  215. };
  216. #define OPT_BATCH_MODE (option_mask32 & OPT_b)
  217. #if ENABLE_FEATURE_TOP_INTERACTIVE
  218. static int pid_sort(top_status_t *P, top_status_t *Q)
  219. {
  220. /* Buggy wrt pids with high bit set */
  221. /* (linux pids are in [1..2^15-1]) */
  222. return (Q->pid - P->pid);
  223. }
  224. #endif
  225. static int mem_sort(top_status_t *P, top_status_t *Q)
  226. {
  227. /* We want to avoid unsigned->signed and truncation errors */
  228. if (Q->vsz < P->vsz) return -1;
  229. return Q->vsz != P->vsz; /* 0 if ==, 1 if > */
  230. }
  231. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  232. static int pcpu_sort(top_status_t *P, top_status_t *Q)
  233. {
  234. /* Buggy wrt ticks with high bit set */
  235. /* Affects only processes for which ticks overflow */
  236. return (int)Q->pcpu - (int)P->pcpu;
  237. }
  238. static int time_sort(top_status_t *P, top_status_t *Q)
  239. {
  240. /* We want to avoid unsigned->signed and truncation errors */
  241. if (Q->ticks < P->ticks) return -1;
  242. return Q->ticks != P->ticks; /* 0 if ==, 1 if > */
  243. }
  244. static int mult_lvl_cmp(void* a, void* b)
  245. {
  246. int i, cmp_val;
  247. for (i = 0; i < SORT_DEPTH; i++) {
  248. cmp_val = (*sort_function[i])(a, b);
  249. if (cmp_val != 0)
  250. break;
  251. }
  252. return inverted ? -cmp_val : cmp_val;
  253. }
  254. static NOINLINE int read_cpu_jiffy(FILE *fp, jiffy_counts_t *p_jif)
  255. {
  256. #if !ENABLE_FEATURE_TOP_SMP_CPU
  257. static const char fmt[] ALIGN1 = "cpu %llu %llu %llu %llu %llu %llu %llu %llu";
  258. #else
  259. static const char fmt[] ALIGN1 = "cp%*s %llu %llu %llu %llu %llu %llu %llu %llu";
  260. #endif
  261. int ret;
  262. if (!fgets(line_buf, LINE_BUF_SIZE, fp) || line_buf[0] != 'c' /* not "cpu" */)
  263. return 0;
  264. ret = sscanf(line_buf, fmt,
  265. &p_jif->usr, &p_jif->nic, &p_jif->sys, &p_jif->idle,
  266. &p_jif->iowait, &p_jif->irq, &p_jif->softirq,
  267. &p_jif->steal);
  268. if (ret >= 4) {
  269. p_jif->total = p_jif->usr + p_jif->nic + p_jif->sys + p_jif->idle
  270. + p_jif->iowait + p_jif->irq + p_jif->softirq + p_jif->steal;
  271. /* procps 2.x does not count iowait as busy time */
  272. p_jif->busy = p_jif->total - p_jif->idle - p_jif->iowait;
  273. }
  274. return ret;
  275. }
  276. static void get_jiffy_counts(void)
  277. {
  278. FILE* fp = xfopen_for_read("stat");
  279. /* We need to parse cumulative counts even if SMP CPU display is on,
  280. * they are used to calculate per process CPU% */
  281. prev_jif = cur_jif;
  282. if (read_cpu_jiffy(fp, &cur_jif) < 4)
  283. bb_error_msg_and_die("can't read '%s'", "/proc/stat");
  284. #if !ENABLE_FEATURE_TOP_SMP_CPU
  285. fclose(fp);
  286. return;
  287. #else
  288. if (!smp_cpu_info) {
  289. fclose(fp);
  290. return;
  291. }
  292. if (!num_cpus) {
  293. /* First time here. How many CPUs?
  294. * There will be at least 1 /proc/stat line with cpu%d
  295. */
  296. while (1) {
  297. cpu_jif = xrealloc_vector(cpu_jif, 1, num_cpus);
  298. if (read_cpu_jiffy(fp, &cpu_jif[num_cpus]) <= 4)
  299. break;
  300. num_cpus++;
  301. }
  302. if (num_cpus == 0) /* /proc/stat with only "cpu ..." line?! */
  303. smp_cpu_info = 0;
  304. cpu_prev_jif = xzalloc(sizeof(cpu_prev_jif[0]) * num_cpus);
  305. /* Otherwise the first per cpu display shows all 100% idles */
  306. usleep(50000);
  307. } else { /* Non first time invocation */
  308. jiffy_counts_t *tmp;
  309. int i;
  310. /* First switch the sample pointers: no need to copy */
  311. tmp = cpu_prev_jif;
  312. cpu_prev_jif = cpu_jif;
  313. cpu_jif = tmp;
  314. /* Get the new samples */
  315. for (i = 0; i < num_cpus; i++)
  316. read_cpu_jiffy(fp, &cpu_jif[i]);
  317. }
  318. #endif
  319. fclose(fp);
  320. }
  321. static void do_stats(void)
  322. {
  323. top_status_t *cur;
  324. pid_t pid;
  325. int n;
  326. unsigned i, last_i;
  327. struct save_hist *new_hist;
  328. get_jiffy_counts();
  329. total_pcpu = 0;
  330. /* total_vsz = 0; */
  331. new_hist = xmalloc(sizeof(new_hist[0]) * ntop);
  332. /*
  333. * Make a pass through the data to get stats.
  334. */
  335. /* hist_iterations = 0; */
  336. i = 0;
  337. for (n = 0; n < ntop; n++) {
  338. cur = top + n;
  339. /*
  340. * Calculate time in cur process. Time is sum of user time
  341. * and system time
  342. */
  343. pid = cur->pid;
  344. new_hist[n].ticks = cur->ticks;
  345. new_hist[n].pid = pid;
  346. /* find matching entry from previous pass */
  347. cur->pcpu = 0;
  348. /* do not start at index 0, continue at last used one
  349. * (brought hist_iterations from ~14000 down to 172) */
  350. last_i = i;
  351. if (prev_hist_count) do {
  352. if (prev_hist[i].pid == pid) {
  353. cur->pcpu = cur->ticks - prev_hist[i].ticks;
  354. total_pcpu += cur->pcpu;
  355. break;
  356. }
  357. i = (i+1) % prev_hist_count;
  358. /* hist_iterations++; */
  359. } while (i != last_i);
  360. /* total_vsz += cur->vsz; */
  361. }
  362. /*
  363. * Save cur frame's information.
  364. */
  365. free(prev_hist);
  366. prev_hist = new_hist;
  367. prev_hist_count = ntop;
  368. }
  369. #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
  370. #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS && ENABLE_FEATURE_TOP_DECIMALS
  371. /* formats 7 char string (8 with terminating NUL) */
  372. static char *fmt_100percent_8(char pbuf[8], unsigned value, unsigned total)
  373. {
  374. unsigned t;
  375. if (value >= total) { /* 100% ? */
  376. strcpy(pbuf, " 100% ");
  377. return pbuf;
  378. }
  379. /* else generate " [N/space]N.N% " string */
  380. value = 1000 * value / total;
  381. t = value / 100;
  382. value = value % 100;
  383. pbuf[0] = ' ';
  384. pbuf[1] = t ? t + '0' : ' ';
  385. pbuf[2] = '0' + (value / 10);
  386. pbuf[3] = '.';
  387. pbuf[4] = '0' + (value % 10);
  388. pbuf[5] = '%';
  389. pbuf[6] = ' ';
  390. pbuf[7] = '\0';
  391. return pbuf;
  392. }
  393. #endif
  394. #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS
  395. static void display_cpus(int scr_width, char *scrbuf, int *lines_rem_p)
  396. {
  397. /*
  398. * xxx% = (cur_jif.xxx - prev_jif.xxx) / (cur_jif.total - prev_jif.total) * 100%
  399. */
  400. unsigned total_diff;
  401. jiffy_counts_t *p_jif, *p_prev_jif;
  402. int i;
  403. # if ENABLE_FEATURE_TOP_SMP_CPU
  404. int n_cpu_lines;
  405. # endif
  406. /* using (unsigned) casts to make operations cheaper */
  407. # define CALC_TOTAL_DIFF do { \
  408. total_diff = (unsigned)(p_jif->total - p_prev_jif->total); \
  409. if (total_diff == 0) total_diff = 1; \
  410. } while (0)
  411. # if ENABLE_FEATURE_TOP_DECIMALS
  412. # define CALC_STAT(xxx) char xxx[8]
  413. # define SHOW_STAT(xxx) fmt_100percent_8(xxx, (unsigned)(p_jif->xxx - p_prev_jif->xxx), total_diff)
  414. # define FMT "%s"
  415. # else
  416. # define CALC_STAT(xxx) unsigned xxx = 100 * (unsigned)(p_jif->xxx - p_prev_jif->xxx) / total_diff
  417. # define SHOW_STAT(xxx) xxx
  418. # define FMT "%4u%% "
  419. # endif
  420. # if !ENABLE_FEATURE_TOP_SMP_CPU
  421. {
  422. i = 1;
  423. p_jif = &cur_jif;
  424. p_prev_jif = &prev_jif;
  425. # else
  426. /* Loop thru CPU(s) */
  427. n_cpu_lines = smp_cpu_info ? num_cpus : 1;
  428. if (n_cpu_lines > *lines_rem_p)
  429. n_cpu_lines = *lines_rem_p;
  430. for (i = 0; i < n_cpu_lines; i++) {
  431. p_jif = &cpu_jif[i];
  432. p_prev_jif = &cpu_prev_jif[i];
  433. # endif
  434. CALC_TOTAL_DIFF;
  435. { /* Need a block: CALC_STAT are declarations */
  436. CALC_STAT(usr);
  437. CALC_STAT(sys);
  438. CALC_STAT(nic);
  439. CALC_STAT(idle);
  440. CALC_STAT(iowait);
  441. CALC_STAT(irq);
  442. CALC_STAT(softirq);
  443. /*CALC_STAT(steal);*/
  444. snprintf(scrbuf, scr_width,
  445. /* Barely fits in 79 chars when in "decimals" mode. */
  446. # if ENABLE_FEATURE_TOP_SMP_CPU
  447. "CPU%s:"FMT"usr"FMT"sys"FMT"nic"FMT"idle"FMT"io"FMT"irq"FMT"sirq",
  448. (smp_cpu_info ? utoa(i) : ""),
  449. # else
  450. "CPU:"FMT"usr"FMT"sys"FMT"nic"FMT"idle"FMT"io"FMT"irq"FMT"sirq",
  451. # endif
  452. SHOW_STAT(usr), SHOW_STAT(sys), SHOW_STAT(nic), SHOW_STAT(idle),
  453. SHOW_STAT(iowait), SHOW_STAT(irq), SHOW_STAT(softirq)
  454. /*, SHOW_STAT(steal) - what is this 'steal' thing? */
  455. /* I doubt anyone wants to know it */
  456. );
  457. puts(scrbuf);
  458. }
  459. }
  460. # undef SHOW_STAT
  461. # undef CALC_STAT
  462. # undef FMT
  463. *lines_rem_p -= i;
  464. }
  465. #else /* !ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS */
  466. # define display_cpus(scr_width, scrbuf, lines_rem) ((void)0)
  467. #endif
  468. enum {
  469. MI_MEMTOTAL,
  470. MI_MEMFREE,
  471. MI_MEMSHARED,
  472. MI_SHMEM,
  473. MI_BUFFERS,
  474. MI_CACHED,
  475. MI_SWAPTOTAL,
  476. MI_SWAPFREE,
  477. MI_DIRTY,
  478. MI_WRITEBACK,
  479. MI_ANONPAGES,
  480. MI_MAPPED,
  481. MI_SLAB,
  482. MI_MAX
  483. };
  484. static void parse_meminfo(unsigned long meminfo[MI_MAX])
  485. {
  486. static const char fields[] ALIGN1 =
  487. "MemTotal\0"
  488. "MemFree\0"
  489. "MemShared\0"
  490. "Shmem\0"
  491. "Buffers\0"
  492. "Cached\0"
  493. "SwapTotal\0"
  494. "SwapFree\0"
  495. "Dirty\0"
  496. "Writeback\0"
  497. "AnonPages\0"
  498. "Mapped\0"
  499. "Slab\0";
  500. char buf[60]; /* actual lines we expect are ~30 chars or less */
  501. FILE *f;
  502. int i;
  503. memset(meminfo, 0, sizeof(meminfo[0]) * MI_MAX);
  504. f = xfopen_for_read("meminfo");
  505. while (fgets(buf, sizeof(buf), f) != NULL) {
  506. char *c = strchr(buf, ':');
  507. if (!c)
  508. continue;
  509. *c = '\0';
  510. i = index_in_strings(fields, buf);
  511. if (i >= 0)
  512. meminfo[i] = strtoul(c+1, NULL, 10);
  513. }
  514. fclose(f);
  515. }
  516. static unsigned long display_header(int scr_width, int *lines_rem_p)
  517. {
  518. char scrbuf[100]; /* [80] was a bit too low on 8Gb ram box */
  519. char *buf;
  520. unsigned long meminfo[MI_MAX];
  521. parse_meminfo(meminfo);
  522. /* Output memory info */
  523. if (scr_width > (int)sizeof(scrbuf))
  524. scr_width = sizeof(scrbuf);
  525. snprintf(scrbuf, scr_width,
  526. "Mem: %luK used, %luK free, %luK shrd, %luK buff, %luK cached",
  527. meminfo[MI_MEMTOTAL] - meminfo[MI_MEMFREE],
  528. meminfo[MI_MEMFREE],
  529. meminfo[MI_MEMSHARED] + meminfo[MI_SHMEM],
  530. meminfo[MI_BUFFERS],
  531. meminfo[MI_CACHED]);
  532. /* Go to top & clear to the end of screen */
  533. printf(OPT_BATCH_MODE ? "%s\n" : ESC"[H" ESC"[J" "%s\n", scrbuf);
  534. (*lines_rem_p)--;
  535. /* Display CPU time split as percentage of total time.
  536. * This displays either a cumulative line or one line per CPU.
  537. */
  538. display_cpus(scr_width, scrbuf, lines_rem_p);
  539. /* Read load average as a string */
  540. buf = stpcpy(scrbuf, "Load average: ");
  541. open_read_close("loadavg", buf, sizeof(scrbuf) - sizeof("Load average: "));
  542. scrbuf[scr_width - 1] = '\0';
  543. strchrnul(buf, '\n')[0] = '\0';
  544. puts(scrbuf);
  545. (*lines_rem_p)--;
  546. return meminfo[MI_MEMTOTAL];
  547. }
  548. static NOINLINE void display_process_list(int lines_rem, int scr_width)
  549. {
  550. enum {
  551. BITS_PER_INT = sizeof(int) * 8
  552. };
  553. top_status_t *s;
  554. unsigned long total_memory = display_header(scr_width, &lines_rem); /* or use total_vsz? */
  555. /* xxx_shift and xxx_scale variables allow us to replace
  556. * expensive divides with multiply and shift */
  557. unsigned pmem_shift, pmem_scale, pmem_half;
  558. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  559. unsigned tmp_unsigned;
  560. unsigned pcpu_shift, pcpu_scale, pcpu_half;
  561. unsigned busy_jifs;
  562. #endif
  563. /* what info of the processes is shown */
  564. printf(OPT_BATCH_MODE ? "%.*s" : ESC"[7m" "%.*s" ESC"[m", scr_width,
  565. " PID PPID USER STAT VSZ %VSZ"
  566. IF_FEATURE_TOP_SMP_PROCESS(" CPU")
  567. IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(" %CPU")
  568. " COMMAND");
  569. lines_rem--;
  570. #if ENABLE_FEATURE_TOP_DECIMALS
  571. # define UPSCALE 1000
  572. # define CALC_STAT(name, val) div_t name = div((val), 10)
  573. # define SHOW_STAT(name) name.quot, '0'+name.rem
  574. # define FMT "%3u.%c"
  575. #else
  576. # define UPSCALE 100
  577. # define CALC_STAT(name, val) unsigned name = (val)
  578. # define SHOW_STAT(name) name
  579. # define FMT "%4u%%"
  580. #endif
  581. /*
  582. * %VSZ = s->vsz/MemTotal
  583. */
  584. pmem_shift = BITS_PER_INT-11;
  585. pmem_scale = UPSCALE*(1U<<(BITS_PER_INT-11)) / total_memory;
  586. /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */
  587. while (pmem_scale >= 512) {
  588. pmem_scale /= 4;
  589. pmem_shift -= 2;
  590. }
  591. pmem_half = (1U << pmem_shift) / (ENABLE_FEATURE_TOP_DECIMALS ? 20 : 2);
  592. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  593. busy_jifs = cur_jif.busy - prev_jif.busy;
  594. /* This happens if there were lots of short-lived processes
  595. * between two top updates (e.g. compilation) */
  596. if (total_pcpu < busy_jifs) total_pcpu = busy_jifs;
  597. /*
  598. * CPU% = s->pcpu/sum(s->pcpu) * busy_cpu_ticks/total_cpu_ticks
  599. * (pcpu is delta of sys+user time between samples)
  600. */
  601. /* (cur_jif.xxx - prev_jif.xxx) and s->pcpu are
  602. * in 0..~64000 range (HZ*update_interval).
  603. * we assume that unsigned is at least 32-bit.
  604. */
  605. pcpu_shift = 6;
  606. pcpu_scale = UPSCALE*64 * (uint16_t)busy_jifs;
  607. if (pcpu_scale == 0)
  608. pcpu_scale = 1;
  609. while (pcpu_scale < (1U << (BITS_PER_INT-2))) {
  610. pcpu_scale *= 4;
  611. pcpu_shift += 2;
  612. }
  613. tmp_unsigned = (uint16_t)(cur_jif.total - prev_jif.total) * total_pcpu;
  614. if (tmp_unsigned != 0)
  615. pcpu_scale /= tmp_unsigned;
  616. /* we want (s->pcpu * pcpu_scale) to never overflow */
  617. while (pcpu_scale >= 1024) {
  618. pcpu_scale /= 4;
  619. pcpu_shift -= 2;
  620. }
  621. pcpu_half = (1U << pcpu_shift) / (ENABLE_FEATURE_TOP_DECIMALS ? 20 : 2);
  622. /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */
  623. #endif
  624. /* Ok, all preliminary data is ready, go through the list */
  625. scr_width += 2; /* account for leading '\n' and trailing NUL */
  626. if (lines_rem > ntop - G_scroll_ofs)
  627. lines_rem = ntop - G_scroll_ofs;
  628. s = top + G_scroll_ofs;
  629. while (--lines_rem >= 0) {
  630. char vsz_str_buf[8];
  631. unsigned col;
  632. CALC_STAT(pmem, (s->vsz*pmem_scale + pmem_half) >> pmem_shift);
  633. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  634. CALC_STAT(pcpu, (s->pcpu*pcpu_scale + pcpu_half) >> pcpu_shift);
  635. #endif
  636. smart_ulltoa5(s->vsz, vsz_str_buf, " mgtpezy");
  637. /* PID PPID USER STAT VSZ %VSZ [%CPU] COMMAND */
  638. col = snprintf(line_buf, scr_width,
  639. "\n" "%5u%6u %-8.8s %s %.5s" FMT
  640. IF_FEATURE_TOP_SMP_PROCESS(" %3d")
  641. IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(FMT)
  642. " ",
  643. s->pid, s->ppid, get_cached_username(s->uid),
  644. s->state, vsz_str_buf,
  645. SHOW_STAT(pmem)
  646. IF_FEATURE_TOP_SMP_PROCESS(, s->last_seen_on_cpu)
  647. IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(, SHOW_STAT(pcpu))
  648. );
  649. if ((int)(scr_width - col) > 1)
  650. read_cmdline(line_buf + col, scr_width - col, s->pid, s->comm);
  651. fputs(line_buf, stdout);
  652. /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu,
  653. cur_jif.busy - prev_jif.busy, cur_jif.total - prev_jif.total); */
  654. s++;
  655. }
  656. /* printf(" %d", hist_iterations); */
  657. bb_putchar(OPT_BATCH_MODE ? '\n' : '\r');
  658. fflush_all();
  659. }
  660. #undef UPSCALE
  661. #undef SHOW_STAT
  662. #undef CALC_STAT
  663. #undef FMT
  664. static void clearmems(void)
  665. {
  666. clear_username_cache();
  667. free(top);
  668. top = NULL;
  669. }
  670. #if ENABLE_FEATURE_TOP_INTERACTIVE
  671. static void reset_term(void)
  672. {
  673. if (!OPT_BATCH_MODE)
  674. tcsetattr_stdin_TCSANOW(&initial_settings);
  675. }
  676. static void sig_catcher(int sig)
  677. {
  678. reset_term();
  679. kill_myself_with_sig(sig);
  680. }
  681. #endif /* FEATURE_TOP_INTERACTIVE */
  682. /*
  683. * TOPMEM support
  684. */
  685. typedef unsigned long mem_t;
  686. typedef struct topmem_status_t {
  687. unsigned pid;
  688. char comm[COMM_LEN];
  689. /* vsz doesn't count /dev/xxx mappings except /dev/zero */
  690. mem_t vsz ;
  691. mem_t vszrw ;
  692. mem_t rss ;
  693. mem_t rss_sh ;
  694. mem_t dirty ;
  695. mem_t dirty_sh;
  696. mem_t stack ;
  697. } topmem_status_t;
  698. enum { NUM_SORT_FIELD = 7 };
  699. #define topmem ((topmem_status_t*)top)
  700. #if ENABLE_FEATURE_TOPMEM
  701. static int topmem_sort(char *a, char *b)
  702. {
  703. int n;
  704. mem_t l, r;
  705. n = offsetof(topmem_status_t, vsz) + (sort_field * sizeof(mem_t));
  706. l = *(mem_t*)(a + n);
  707. r = *(mem_t*)(b + n);
  708. if (l == r) {
  709. l = ((topmem_status_t*)a)->dirty;
  710. r = ((topmem_status_t*)b)->dirty;
  711. }
  712. /* We want to avoid unsigned->signed and truncation errors */
  713. /* l>r: -1, l=r: 0, l<r: 1 */
  714. n = (l > r) ? -1 : (l != r);
  715. return inverted ? -n : n;
  716. }
  717. /* display header info (meminfo / loadavg) */
  718. static void display_topmem_header(int scr_width, int *lines_rem_p)
  719. {
  720. unsigned long meminfo[MI_MAX];
  721. parse_meminfo(meminfo);
  722. snprintf(line_buf, LINE_BUF_SIZE,
  723. "Mem total:%lu anon:%lu map:%lu free:%lu",
  724. meminfo[MI_MEMTOTAL],
  725. meminfo[MI_ANONPAGES],
  726. meminfo[MI_MAPPED],
  727. meminfo[MI_MEMFREE]);
  728. printf(OPT_BATCH_MODE ? "%.*s\n" : ESC"[H" ESC"[J" "%.*s\n", scr_width, line_buf);
  729. snprintf(line_buf, LINE_BUF_SIZE,
  730. " slab:%lu buf:%lu cache:%lu dirty:%lu write:%lu",
  731. meminfo[MI_SLAB],
  732. meminfo[MI_BUFFERS],
  733. meminfo[MI_CACHED],
  734. meminfo[MI_DIRTY],
  735. meminfo[MI_WRITEBACK]);
  736. printf("%.*s\n", scr_width, line_buf);
  737. snprintf(line_buf, LINE_BUF_SIZE,
  738. "Swap total:%lu free:%lu", // TODO: % used?
  739. meminfo[MI_SWAPTOTAL],
  740. meminfo[MI_SWAPFREE]);
  741. printf("%.*s\n", scr_width, line_buf);
  742. (*lines_rem_p) -= 3;
  743. }
  744. static void ulltoa6_and_space(unsigned long long ul, char buf[6])
  745. {
  746. /* see http://en.wikipedia.org/wiki/Tera */
  747. smart_ulltoa5(ul, buf, " mgtpezy")[0] = ' ';
  748. }
  749. static NOINLINE void display_topmem_process_list(int lines_rem, int scr_width)
  750. {
  751. #define HDR_STR " PID VSZ VSZRW RSS (SHR) DIRTY (SHR) STACK"
  752. #define MIN_WIDTH sizeof(HDR_STR)
  753. const topmem_status_t *s = topmem + G_scroll_ofs;
  754. char *cp, ch;
  755. display_topmem_header(scr_width, &lines_rem);
  756. strcpy(line_buf, HDR_STR " COMMAND");
  757. /* Mark the ^FIELD^ we sort by */
  758. cp = &line_buf[5 + sort_field * 6];
  759. ch = "^_"[inverted];
  760. cp[6] = ch;
  761. do *cp++ = ch; while (*cp == ' ');
  762. printf(OPT_BATCH_MODE ? "%.*s" : ESC"[7m" "%.*s" ESC"[m", scr_width, line_buf);
  763. lines_rem--;
  764. if (lines_rem > ntop - G_scroll_ofs)
  765. lines_rem = ntop - G_scroll_ofs;
  766. while (--lines_rem >= 0) {
  767. /* PID VSZ VSZRW RSS (SHR) DIRTY (SHR) COMMAND */
  768. ulltoa6_and_space(s->pid , &line_buf[0*6]);
  769. ulltoa6_and_space(s->vsz , &line_buf[1*6]);
  770. ulltoa6_and_space(s->vszrw , &line_buf[2*6]);
  771. ulltoa6_and_space(s->rss , &line_buf[3*6]);
  772. ulltoa6_and_space(s->rss_sh , &line_buf[4*6]);
  773. ulltoa6_and_space(s->dirty , &line_buf[5*6]);
  774. ulltoa6_and_space(s->dirty_sh, &line_buf[6*6]);
  775. ulltoa6_and_space(s->stack , &line_buf[7*6]);
  776. line_buf[8*6] = '\0';
  777. if (scr_width > (int)MIN_WIDTH) {
  778. read_cmdline(&line_buf[8*6], scr_width - MIN_WIDTH, s->pid, s->comm);
  779. }
  780. printf("\n""%.*s", scr_width, line_buf);
  781. s++;
  782. }
  783. bb_putchar(OPT_BATCH_MODE ? '\n' : '\r');
  784. fflush_all();
  785. #undef HDR_STR
  786. #undef MIN_WIDTH
  787. }
  788. #else
  789. void display_topmem_process_list(int lines_rem, int scr_width);
  790. int topmem_sort(char *a, char *b);
  791. #endif /* TOPMEM */
  792. /*
  793. * end TOPMEM support
  794. */
  795. enum {
  796. TOP_MASK = 0
  797. | PSSCAN_PID
  798. | PSSCAN_PPID
  799. | PSSCAN_VSZ
  800. | PSSCAN_STIME
  801. | PSSCAN_UTIME
  802. | PSSCAN_STATE
  803. | PSSCAN_COMM
  804. | PSSCAN_CPU
  805. | PSSCAN_UIDGID,
  806. TOPMEM_MASK = 0
  807. | PSSCAN_PID
  808. | PSSCAN_SMAPS
  809. | PSSCAN_COMM,
  810. EXIT_MASK = 0,
  811. NO_RESCAN_MASK = (unsigned)-1,
  812. };
  813. #if ENABLE_FEATURE_TOP_INTERACTIVE
  814. static unsigned handle_input(unsigned scan_mask, duration_t interval)
  815. {
  816. if (option_mask32 & OPT_EOF) {
  817. /* EOF on stdin ("top </dev/null") */
  818. sleep_for_duration(interval);
  819. return scan_mask;
  820. }
  821. while (1) {
  822. int32_t c;
  823. c = read_key(STDIN_FILENO, G.kbd_input, interval * 1000);
  824. if (c == -1 && errno != EAGAIN) {
  825. /* error/EOF */
  826. option_mask32 |= OPT_EOF;
  827. break;
  828. }
  829. interval = 0;
  830. if (c == initial_settings.c_cc[VINTR])
  831. return EXIT_MASK;
  832. if (c == initial_settings.c_cc[VEOF])
  833. return EXIT_MASK;
  834. if (c == KEYCODE_UP) {
  835. G_scroll_ofs--;
  836. goto normalize_ofs;
  837. }
  838. if (c == KEYCODE_DOWN) {
  839. G_scroll_ofs++;
  840. goto normalize_ofs;
  841. }
  842. if (c == KEYCODE_HOME) {
  843. G_scroll_ofs = 0;
  844. goto normalize_ofs;
  845. }
  846. if (c == KEYCODE_END) {
  847. G_scroll_ofs = ntop - G.lines / 2;
  848. goto normalize_ofs;
  849. }
  850. if (c == KEYCODE_PAGEUP) {
  851. G_scroll_ofs -= G.lines / 2;
  852. goto normalize_ofs;
  853. }
  854. if (c == KEYCODE_PAGEDOWN) {
  855. G_scroll_ofs += G.lines / 2;
  856. normalize_ofs:
  857. if (G_scroll_ofs >= ntop)
  858. G_scroll_ofs = ntop - 1;
  859. if (G_scroll_ofs < 0)
  860. G_scroll_ofs = 0;
  861. return NO_RESCAN_MASK;
  862. }
  863. c |= 0x20; /* lowercase */
  864. if (c == 'q')
  865. return EXIT_MASK;
  866. if (c == 'n') {
  867. IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
  868. sort_function[0] = pid_sort;
  869. continue;
  870. }
  871. if (c == 'm') {
  872. IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
  873. sort_function[0] = mem_sort;
  874. # if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  875. sort_function[1] = pcpu_sort;
  876. sort_function[2] = time_sort;
  877. # endif
  878. continue;
  879. }
  880. # if ENABLE_FEATURE_SHOW_THREADS
  881. if (c == 'h'
  882. IF_FEATURE_TOPMEM(&& scan_mask != TOPMEM_MASK)
  883. ) {
  884. scan_mask ^= PSSCAN_TASKS;
  885. continue;
  886. }
  887. # endif
  888. # if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  889. if (c == 'p') {
  890. IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
  891. sort_function[0] = pcpu_sort;
  892. sort_function[1] = mem_sort;
  893. sort_function[2] = time_sort;
  894. continue;
  895. }
  896. if (c == 't') {
  897. IF_FEATURE_TOPMEM(scan_mask = TOP_MASK;)
  898. sort_function[0] = time_sort;
  899. sort_function[1] = mem_sort;
  900. sort_function[2] = pcpu_sort;
  901. continue;
  902. }
  903. # if ENABLE_FEATURE_TOPMEM
  904. if (c == 's') {
  905. scan_mask = TOPMEM_MASK;
  906. free(prev_hist);
  907. prev_hist = NULL;
  908. prev_hist_count = 0;
  909. sort_field = (sort_field + 1) % NUM_SORT_FIELD;
  910. continue;
  911. }
  912. # endif
  913. if (c == 'r') {
  914. inverted ^= 1;
  915. continue;
  916. }
  917. # if ENABLE_FEATURE_TOP_SMP_CPU
  918. /* procps-2.0.18 uses 'C', 3.2.7 uses '1' */
  919. if (c == 'c' || c == '1') {
  920. /* User wants to toggle per cpu <> aggregate */
  921. if (smp_cpu_info) {
  922. free(cpu_prev_jif);
  923. free(cpu_jif);
  924. cpu_jif = &cur_jif;
  925. cpu_prev_jif = &prev_jif;
  926. } else {
  927. /* Prepare for xrealloc() */
  928. cpu_jif = cpu_prev_jif = NULL;
  929. }
  930. num_cpus = 0;
  931. smp_cpu_info = !smp_cpu_info;
  932. get_jiffy_counts();
  933. continue;
  934. }
  935. # endif
  936. # endif
  937. break; /* unknown key -> force refresh */
  938. }
  939. return scan_mask;
  940. }
  941. #endif
  942. //usage:#if ENABLE_FEATURE_SHOW_THREADS || ENABLE_FEATURE_TOP_SMP_CPU
  943. //usage:# define IF_SHOW_THREADS_OR_TOP_SMP(...) __VA_ARGS__
  944. //usage:#else
  945. //usage:# define IF_SHOW_THREADS_OR_TOP_SMP(...)
  946. //usage:#endif
  947. //usage:#define top_trivial_usage
  948. //usage: "[-b"IF_FEATURE_TOPMEM("m")IF_FEATURE_SHOW_THREADS("H")"]"
  949. //usage: " [-n COUNT] [-d SECONDS]"
  950. //usage:#define top_full_usage "\n\n"
  951. //usage: "Provide a view of process activity in real time."
  952. //usage: "\n""Read the status of all processes from /proc each SECONDS"
  953. //usage: "\n""and display a screenful of them."
  954. //usage: "\n"
  955. //usage: IF_FEATURE_TOP_INTERACTIVE(
  956. //usage: "Keys:"
  957. //usage: "\n"" N/M"
  958. //usage: IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/P")
  959. //usage: IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/T")
  960. //usage: ": " IF_FEATURE_TOPMEM("show CPU usage, ") "sort by pid/mem"
  961. //usage: IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/cpu")
  962. //usage: IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE("/time")
  963. //usage: IF_FEATURE_TOPMEM(
  964. //usage: "\n"" S: show memory"
  965. //usage: )
  966. //usage: "\n"" R: reverse sort"
  967. //usage: IF_SHOW_THREADS_OR_TOP_SMP(
  968. //usage: "\n"" "
  969. //usage: IF_FEATURE_SHOW_THREADS("H: toggle threads")
  970. //usage: IF_FEATURE_SHOW_THREADS(IF_FEATURE_TOP_SMP_CPU(", "))
  971. //usage: IF_FEATURE_TOP_SMP_CPU("1: toggle SMP")
  972. //usage: )
  973. //usage: "\n"" Q,^C: exit"
  974. //usage: "\n""Options:"
  975. //usage: )
  976. //usage: "\n"" -b Batch mode"
  977. //usage: "\n"" -n N Exit after N iterations"
  978. //usage: "\n"" -d SEC Delay between updates"
  979. //usage: IF_FEATURE_TOPMEM(
  980. //usage: "\n"" -m Same as 's' key"
  981. //usage: )
  982. //usage: IF_FEATURE_SHOW_THREADS(
  983. //usage: "\n"" -H Show threads"
  984. //usage: )
  985. /* Interactive testing:
  986. * echo sss | ./busybox top
  987. * - shows memory screen
  988. * echo sss | ./busybox top -bn1 >mem
  989. * - saves memory screen - the *whole* list, not first NROWS processes!
  990. * echo .m.s.s.s.s.s.s.q | ./busybox top -b >z
  991. * - saves several different screens, and exits
  992. *
  993. * TODO: -i STRING param as a better alternative?
  994. */
  995. int top_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  996. int top_main(int argc UNUSED_PARAM, char **argv)
  997. {
  998. duration_t interval;
  999. int iterations;
  1000. unsigned col;
  1001. char *str_interval, *str_iterations;
  1002. unsigned scan_mask = TOP_MASK;
  1003. INIT_G();
  1004. interval = 5; /* default update interval is 5 seconds */
  1005. iterations = 0; /* infinite */
  1006. #if ENABLE_FEATURE_TOP_SMP_CPU
  1007. /*num_cpus = 0;*/
  1008. /*smp_cpu_info = 0;*/ /* to start with show aggregate */
  1009. cpu_jif = &cur_jif;
  1010. cpu_prev_jif = &prev_jif;
  1011. #endif
  1012. /* all args are options; -n NUM */
  1013. make_all_argv_opts(argv); /* options can be specified w/o dash */
  1014. col = getopt32(argv, "d:n:bHm", &str_interval, &str_iterations);
  1015. /* NB: -m and -H are accepted even if not configured */
  1016. #if ENABLE_FEATURE_TOPMEM
  1017. if (col & OPT_m) /* -m (busybox specific) */
  1018. scan_mask = TOPMEM_MASK;
  1019. #endif
  1020. if (col & OPT_d) {
  1021. /* work around for "-d 1" -> "-d -1" done by make_all_argv_opts() */
  1022. if (str_interval[0] == '-')
  1023. str_interval++;
  1024. interval = parse_duration_str(str_interval);
  1025. /* Need to limit it to not overflow poll timeout */
  1026. if (interval > INT_MAX / 1000)
  1027. interval = INT_MAX / 1000;
  1028. }
  1029. if (col & OPT_n) {
  1030. if (str_iterations[0] == '-')
  1031. str_iterations++;
  1032. iterations = xatou(str_iterations);
  1033. }
  1034. #if ENABLE_FEATURE_SHOW_THREADS
  1035. if (col & OPT_H) {
  1036. scan_mask |= PSSCAN_TASKS;
  1037. }
  1038. #endif
  1039. /* change to /proc */
  1040. xchdir("/proc");
  1041. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  1042. sort_function[0] = pcpu_sort;
  1043. sort_function[1] = mem_sort;
  1044. sort_function[2] = time_sort;
  1045. #else
  1046. sort_function[0] = mem_sort;
  1047. #endif
  1048. if (OPT_BATCH_MODE) {
  1049. option_mask32 |= OPT_EOF;
  1050. }
  1051. #if ENABLE_FEATURE_TOP_INTERACTIVE
  1052. else {
  1053. /* Turn on unbuffered input; turn off echoing, ^C ^Z etc */
  1054. set_termios_to_raw(STDIN_FILENO, &initial_settings, TERMIOS_CLEAR_ISIG);
  1055. die_func = reset_term;
  1056. }
  1057. bb_signals(BB_FATAL_SIGS, sig_catcher);
  1058. /* Eat initial input, if any */
  1059. scan_mask = handle_input(scan_mask, 0);
  1060. #endif
  1061. while (scan_mask != EXIT_MASK) {
  1062. IF_FEATURE_TOP_INTERACTIVE(unsigned new_mask;)
  1063. procps_status_t *p = NULL;
  1064. if (OPT_BATCH_MODE) {
  1065. G.lines = INT_MAX;
  1066. col = LINE_BUF_SIZE - 2; /* +2 bytes for '\n', NUL */
  1067. } else {
  1068. G.lines = 24; /* default */
  1069. col = 79;
  1070. /* We output to stdout, we need size of stdout (not stdin)! */
  1071. get_terminal_width_height(STDOUT_FILENO, &col, &G.lines);
  1072. if (G.lines < 5 || col < 10) {
  1073. sleep_for_duration(interval);
  1074. continue;
  1075. }
  1076. if (col > LINE_BUF_SIZE - 2)
  1077. col = LINE_BUF_SIZE - 2;
  1078. }
  1079. /* read process IDs & status for all the processes */
  1080. ntop = 0;
  1081. while ((p = procps_scan(p, scan_mask)) != NULL) {
  1082. int n;
  1083. IF_FEATURE_TOPMEM(if (scan_mask != TOPMEM_MASK)) {
  1084. n = ntop;
  1085. top = xrealloc_vector(top, 6, ntop++);
  1086. top[n].pid = p->pid;
  1087. top[n].ppid = p->ppid;
  1088. top[n].vsz = p->vsz;
  1089. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  1090. top[n].ticks = p->stime + p->utime;
  1091. #endif
  1092. top[n].uid = p->uid;
  1093. strcpy(top[n].state, p->state);
  1094. strcpy(top[n].comm, p->comm);
  1095. #if ENABLE_FEATURE_TOP_SMP_PROCESS
  1096. top[n].last_seen_on_cpu = p->last_seen_on_cpu;
  1097. #endif
  1098. }
  1099. #if ENABLE_FEATURE_TOPMEM
  1100. else { /* TOPMEM */
  1101. if (!(p->smaps.mapped_ro | p->smaps.mapped_rw))
  1102. continue; /* kernel threads are ignored */
  1103. n = ntop;
  1104. /* No bug here - top and topmem are the same */
  1105. top = xrealloc_vector(topmem, 6, ntop++);
  1106. strcpy(topmem[n].comm, p->comm);
  1107. topmem[n].pid = p->pid;
  1108. topmem[n].vsz = p->smaps.mapped_rw + p->smaps.mapped_ro;
  1109. topmem[n].vszrw = p->smaps.mapped_rw;
  1110. topmem[n].rss_sh = p->smaps.shared_clean + p->smaps.shared_dirty;
  1111. topmem[n].rss = p->smaps.private_clean + p->smaps.private_dirty + topmem[n].rss_sh;
  1112. topmem[n].dirty = p->smaps.private_dirty + p->smaps.shared_dirty;
  1113. topmem[n].dirty_sh = p->smaps.shared_dirty;
  1114. topmem[n].stack = p->smaps.stack;
  1115. }
  1116. #endif
  1117. } /* end of "while we read /proc" */
  1118. if (ntop == 0) {
  1119. bb_error_msg("no process info in /proc");
  1120. break;
  1121. }
  1122. IF_FEATURE_TOPMEM(if (scan_mask != TOPMEM_MASK)) {
  1123. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  1124. if (!prev_hist_count) {
  1125. do_stats();
  1126. usleep(100000);
  1127. clearmems();
  1128. continue;
  1129. }
  1130. do_stats();
  1131. /* TODO: we don't need to sort all 10000 processes, we need to find top 24! */
  1132. qsort(top, ntop, sizeof(top_status_t), (void*)mult_lvl_cmp);
  1133. #else
  1134. qsort(top, ntop, sizeof(top_status_t), (void*)(sort_function[0]));
  1135. #endif
  1136. }
  1137. #if ENABLE_FEATURE_TOPMEM
  1138. else { /* TOPMEM */
  1139. qsort(topmem, ntop, sizeof(topmem_status_t), (void*)topmem_sort);
  1140. }
  1141. #endif
  1142. IF_FEATURE_TOP_INTERACTIVE(display:)
  1143. IF_FEATURE_TOPMEM(if (scan_mask != TOPMEM_MASK)) {
  1144. display_process_list(G.lines, col);
  1145. }
  1146. #if ENABLE_FEATURE_TOPMEM
  1147. else { /* TOPMEM */
  1148. display_topmem_process_list(G.lines, col);
  1149. }
  1150. #endif
  1151. if (iterations >= 0 && !--iterations)
  1152. break;
  1153. #if !ENABLE_FEATURE_TOP_INTERACTIVE
  1154. clearmems();
  1155. sleep_for_duration(interval);
  1156. #else
  1157. new_mask = handle_input(scan_mask, interval);
  1158. if (new_mask == NO_RESCAN_MASK)
  1159. goto display;
  1160. scan_mask = new_mask;
  1161. clearmems();
  1162. #endif
  1163. } /* end of "while (not Q)" */
  1164. bb_putchar('\n');
  1165. #if ENABLE_FEATURE_TOP_INTERACTIVE
  1166. reset_term();
  1167. #endif
  1168. if (ENABLE_FEATURE_CLEAN_UP) {
  1169. clearmems();
  1170. #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
  1171. free(prev_hist);
  1172. #endif
  1173. }
  1174. return EXIT_SUCCESS;
  1175. }