projects / lttngtop.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
missing Makefile
[lttngtop.git] / src / cursesdisplay.c
1 /*
2 * Copyright (C) 2011-2012 Julien Desfossez
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <signal.h>
21 #include <string.h>
22 #include <ncurses.h>
23 #include <panel.h>
24 #include <pthread.h>
25 #include <semaphore.h>
26
27 #include "cursesdisplay.h"
28 #include "lttngtoptypes.h"
29 #include "iostreamtop.h"
30 #include "common.h"
31
32 #define DEFAULT_DELAY 15
33 #define MAX_LINE_LENGTH 50
34 #define MAX_LOG_LINES 4
35
36 /* to prevent concurrent updates of the different windows */
37 sem_t update_display_sem;
38
39 char *termtype;
40 WINDOW *footer, *header, *center, *status;
41 WINDOW *pref_panel_window = NULL;
42 PANEL *pref_panel, *main_panel;
43
44 int pref_panel_visible = 0;
45 int pref_line_selected = 0;
46 int pref_current_sort = 0;
47
48 int last_display_index, currently_displayed_index;
49
50 struct processtop *selected_process = NULL;
51 int selected_ret;
52
53 int selected_line = 0; /* select bar position */
54 int selected_in_list = 0; /* selection relative to the whole list */
55 int list_offset = 0; /* first index in the list to display (scroll) */
56 int nb_log_lines = 0;
57 char log_lines[MAX_LINE_LENGTH * MAX_LOG_LINES + MAX_LOG_LINES];
58
59 int max_elements = 80;
60
61 int toggle_threads = 1;
62 int toggle_virt = -1;
63 int toggle_pause = -1;
64
65 int filter_host_panel = 0;
66
67 int max_center_lines;
68
69 pthread_t keyboard_thread;
70
71 struct header_view cputopview[6];
72 struct header_view iostreamtopview[3];
73 struct header_view fileview[3];
74 struct header_view kprobeview[2];
75
76 void reset_ncurses()
77 {
78 curs_set(1);
79 endwin();
80 quit = 1;
81 sem_post(&pause_sem);
82 sem_post(&timer);
83 sem_post(&goodtodisplay);
84 sem_post(&end_trace_sem);
85 sem_post(&goodtoupdate);
86 }
87
88 static void handle_sigterm(int signal)
89 {
90 pthread_cancel(keyboard_thread);
91 reset_ncurses();
92 }
93
94 void init_screen()
95 {
96 initscr();
97 noecho();
98 halfdelay(DEFAULT_DELAY);
99 nonl();
100 intrflush(stdscr, false);
101 keypad(stdscr, true);
102 curs_set(0);
103
104 if (has_colors()) {
105 start_color();
106 init_pair(1, COLOR_RED, COLOR_BLACK); /* - */
107 init_pair(2, COLOR_GREEN, COLOR_BLACK); /* + */
108 init_pair(3, COLOR_BLACK, COLOR_WHITE); /* keys */
109 init_pair(4, COLOR_WHITE, COLOR_GREEN); /* keys activated */
110 init_pair(5, COLOR_BLACK, COLOR_YELLOW); /* select line */
111 init_pair(6, COLOR_GREEN, COLOR_BLACK); /* selected process */
112 init_pair(7, COLOR_RED, COLOR_YELLOW); /* selected process + line*/
113 }
114 termtype = getenv("TERM");
115 if (!strcmp(termtype, "xterm") || !strcmp(termtype, "xterm-color") ||
116 !strcmp(termtype, "vt220")) {
117 define_key("\033[H", KEY_HOME);
118 define_key("\033[F", KEY_END);
119 define_key("\033OP", KEY_F(1));
120 define_key("\033OQ", KEY_F(2));
121 define_key("\033OR", KEY_F(3));
122 define_key("\033OS", KEY_F(4));
123 define_key("\0330U", KEY_F(6));
124 define_key("\033[11~", KEY_F(1));
125 define_key("\033[12~", KEY_F(2));
126 define_key("\033[13~", KEY_F(3));
127 define_key("\033[14~", KEY_F(4));
128 define_key("\033[16~", KEY_F(6));
129 define_key("\033[17;2~", KEY_F(18));
130 }
131 signal(SIGTERM, handle_sigterm);
132 signal(SIGINT, handle_sigterm);
133 mousemask(BUTTON1_CLICKED, NULL);
134 refresh();
135 }
136
137 WINDOW *create_window(int height, int width, int startx, int starty)
138 {
139 WINDOW *win;
140 win = newwin(height, width, startx, starty);
141 box(win, 0 , 0);
142 wrefresh(win);
143 return win;
144 }
145
146 WINDOW *create_window_no_border(int height, int width, int startx, int starty)
147 {
148 WINDOW *win;
149 win = newwin(height, width, startx, starty);
150 wrefresh(win);
151 return win;
152 }
153
154 void print_digit(WINDOW *win, int digit)
155 {
156 if (digit < 0) {
157 wattron(win, COLOR_PAIR(1));
158 wprintw(win, "%d", digit);
159 wattroff(win, COLOR_PAIR(1));
160 } else if (digit > 0) {
161 wattron(win, COLOR_PAIR(2));
162 wprintw(win, "+%d", digit);
163 wattroff(win, COLOR_PAIR(2));
164 } else {
165 wprintw(win, "0");
166 }
167 }
168
169 void print_digits(WINDOW *win, int first, int second)
170 {
171 wprintw(win, "(");
172 print_digit(win, first);
173 wprintw(win, ", ");
174 print_digit(win, second);
175 wprintw(win, ")");
176 }
177
178 void print_headers(int line, char *desc, int value, int first, int second)
179 {
180 wattron(header, A_BOLD);
181 mvwprintw(header, line, 4, "%s", desc);
182 wattroff(header, A_BOLD);
183 mvwprintw(header, line, 16, "%d", value);
184 wmove(header, line, 24);
185 print_digits(header, first, second);
186 wmove(header, line, 40);
187 }
188
189 void set_window_title(WINDOW *win, char *title)
190 {
191 wattron(win, A_BOLD);
192 mvwprintw(win, 0, 1, title);
193 wattroff(win, A_BOLD);
194 }
195
196 void print_log(char *str)
197 {
198 int i;
199 int current_line = 1;
200 int current_char = 1;
201 char *tmp, *tmp2;
202 /* rotate the line buffer */
203 if (nb_log_lines >= MAX_LOG_LINES) {
204 tmp = strndup(log_lines, MAX_LINE_LENGTH * MAX_LOG_LINES + MAX_LOG_LINES);
205 tmp2 = strchr(tmp, '\n');
206 memset(log_lines, '\0', strlen(log_lines));
207 strncat(log_lines, tmp2 + 1, strlen(tmp2) - 1);
208 log_lines[strlen(log_lines)] = '\n';
209 log_lines[strlen(log_lines)] = '\0';
210 free(tmp);
211 }
212 nb_log_lines++;
213
214 strncat(log_lines, str, MAX_LINE_LENGTH - 1);
215
216 if (nb_log_lines < MAX_LOG_LINES)
217 log_lines[strlen(log_lines)] = '\n';
218 log_lines[strlen(log_lines)] = '\0';
219
220 werase(status);
221 box(status, 0 , 0);
222 set_window_title(status, "Status");
223 for (i = 0; i < strlen(log_lines); i++) {
224 if (log_lines[i] == '\n') {
225 wmove(status, ++current_line, 1);
226 current_char = 1;
227 } else {
228 mvwprintw(status, current_line, current_char++, "%c",
229 log_lines[i]);
230 }
231 }
232 wrefresh(status);
233 }
234
235 int process_selected(struct processtop *process)
236 {
237 if (lookup_filter_tid_list(process->tid))
238 return 1;
239 return 0;
240 }
241
242 void update_selected_processes()
243 {
244 if (process_selected(selected_process)) {
245 remove_filter_tid_list(selected_process->tid);
246 } else {
247 add_filter_tid_list(selected_process);
248 }
249 }
250
251 void print_key(WINDOW *win, char *key, char *desc, int toggle)
252 {
253 int pair;
254 if (toggle > 0)
255 pair = 4;
256 else
257 pair = 3;
258 wattron(win, COLOR_PAIR(pair));
259 wprintw(footer, "%s", key);
260 wattroff(win, COLOR_PAIR(pair));
261 wprintw(footer, ":%s", desc);
262 }
263
264 void update_footer()
265 {
266 sem_wait(&update_display_sem);
267 werase(footer);
268 wmove(footer, 1, 1);
269 print_key(footer, "F2", "CPUtop ", current_view == cpu);
270 print_key(footer, "F3", "PerfTop ", current_view == perf);
271 print_key(footer, "F4", "IOTop ", current_view == iostream);
272 print_key(footer, "Enter", "Details ", current_view == process_details);
273 print_key(footer, "Space", "Highlight ", 0);
274 print_key(footer, "q", "Quit ", 0);
275 print_key(footer, "r", "Pref ", 0);
276 print_key(footer, "t", "Threads ", toggle_threads);
277 print_key(footer, "v", "Virt ", toggle_virt);
278 print_key(footer, "p", "Pause ", toggle_pause);
279
280 wrefresh(footer);
281 sem_post(&update_display_sem);
282 }
283
284 void basic_header()
285 {
286 werase(header);
287 box(header, 0 , 0);
288 set_window_title(header, "Statistics for interval [gathering data...[");
289 wattron(header, A_BOLD);
290 mvwprintw(header, 1, 4, "CPUs");
291 mvwprintw(header, 2, 4, "Threads");
292 mvwprintw(header, 3, 4, "FDs");
293 wattroff(header, A_BOLD);
294 wrefresh(header);
295 }
296
297 static void scale_unit(uint64_t bytes, char *ret)
298 {
299 if (bytes >= 1000000000)
300 sprintf(ret, "%" PRIu64 "G", bytes/1000000000);
301 if (bytes >= 1000000)
302 sprintf(ret, "%" PRIu64 "M", bytes/1000000);
303 else if (bytes >= 1000)
304 sprintf(ret, "%" PRIu64 "K", bytes/1000);
305 else
306 sprintf(ret, "%" PRIu64, bytes);
307 }
308
309 uint64_t total_io()
310 {
311 int i;
312 struct processtop *tmp;
313 uint64_t total = 0;
314
315 for (i = 0; i < data->process_table->len; i++) {
316 tmp = g_ptr_array_index(data->process_table, i);
317 total += tmp->fileread;
318 total += tmp->filewrite;
319 }
320
321 return total;
322 }
323
324 void update_header()
325 {
326 struct tm start, end;
327 uint64_t ts_nsec_start, ts_nsec_end;
328 char io[4];
329
330 ts_nsec_start = data->start % NSEC_PER_SEC;
331 start = format_timestamp(data->start);
332
333 ts_nsec_end = data->end % NSEC_PER_SEC;
334 end = format_timestamp(data->end);
335
336 werase(header);
337 box(header, 0 , 0);
338 set_window_title(header, "Statistics for interval ");
339 wattron(header, A_BOLD);
340
341 wprintw(header, "[%02d:%02d:%02d.%09" PRIu64 ", %02d:%02d:%02d.%09" PRIu64 "[",
342 start.tm_hour, start.tm_min, start.tm_sec, ts_nsec_start,
343 end.tm_hour, end.tm_min, end.tm_sec, ts_nsec_end);
344 mvwprintw(header, 1, 4, "CPUs");
345 wattroff(header, A_BOLD);
346 wprintw(header, "\t%d\t(max/cpu : %0.2f%)", data->cpu_table->len,
347 100.0/data->cpu_table->len);
348 print_headers(2, "Threads", data->nbthreads, data->nbnewthreads,
349 -1*(data->nbdeadthreads));
350 print_headers(3, "FDs", data->nbfiles, data->nbnewfiles,
351 -1*(data->nbclosedfiles));
352 scale_unit(total_io(), io);
353 mvwprintw(header, 3, 43, "%sB/sec", io);
354 wrefresh(header);
355 }
356
357 gint sort_by_cpu_desc(gconstpointer p1, gconstpointer p2)
358 {
359 struct processtop *n1 = *(struct processtop **)p1;
360 struct processtop *n2 = *(struct processtop **)p2;
361 unsigned long totaln1 = n1->totalcpunsec;
362 unsigned long totaln2 = n2->totalcpunsec;
363
364 if (totaln1 < totaln2)
365 return 1;
366 if (totaln1 == totaln2)
367 return 0;
368 return -1;
369 }
370
371 gint sort_by_tid_desc(gconstpointer p1, gconstpointer p2)
372 {
373 struct processtop *n1 = *(struct processtop **)p1;
374 struct processtop *n2 = *(struct processtop **)p2;
375 unsigned long totaln1 = n1->tid;
376 unsigned long totaln2 = n2->tid;
377
378 if (totaln1 < totaln2)
379 return 1;
380 if (totaln1 == totaln2)
381 return 0;
382 return -1;
383 }
384
385 gint sort_by_pid_desc(gconstpointer p1, gconstpointer p2)
386 {
387 struct processtop *n1 = *(struct processtop **)p1;
388 struct processtop *n2 = *(struct processtop **)p2;
389 unsigned long totaln1 = n1->pid;
390 unsigned long totaln2 = n2->pid;
391
392 if (totaln1 < totaln2)
393 return 1;
394 if (totaln1 == totaln2)
395 return 0;
396 return -1;
397 }
398
399 gint sort_by_process_read_desc(gconstpointer p1, gconstpointer p2)
400 {
401 struct processtop *n1 = *(struct processtop **)p1;
402 struct processtop *n2 = *(struct processtop **)p2;
403 unsigned long totaln1 = n1->fileread;
404 unsigned long totaln2 = n2->fileread;
405
406 if (totaln1 < totaln2)
407 return 1;
408 if (totaln1 == totaln2)
409 return 0;
410 return -1;
411 }
412
413 gint sort_by_process_write_desc(gconstpointer p1, gconstpointer p2)
414 {
415 struct processtop *n1 = *(struct processtop **)p1;
416 struct processtop *n2 = *(struct processtop **)p2;
417 unsigned long totaln1 = n1->filewrite;
418 unsigned long totaln2 = n2->filewrite;
419
420 if (totaln1 < totaln2)
421 return 1;
422 if (totaln1 == totaln2)
423 return 0;
424 return -1;
425 }
426
427 gint sort_by_process_total_desc(gconstpointer p1, gconstpointer p2)
428 {
429 struct processtop *n1 = *(struct processtop **)p1;
430 struct processtop *n2 = *(struct processtop **)p2;
431 unsigned long totaln1 = n1->totalfilewrite + n1->totalfileread;
432 unsigned long totaln2 = n2->totalfilewrite + n2->totalfileread;
433
434 if (totaln1 < totaln2)
435 return 1;
436 if (totaln1 == totaln2)
437 return 0;
438 return -1;
439 }
440
441 gint sort_by_file_read_desc(gconstpointer p1, gconstpointer p2)
442 {
443 struct files *n1 = *(struct files **)p1;
444 struct files *n2 = *(struct files **)p2;
445 unsigned long totaln1;
446 unsigned long totaln2;
447
448 totaln1 = n1->read;
449 totaln2 = n2->read;
450
451 if (totaln1 < totaln2)
452 return 1;
453 if (totaln1 == totaln2)
454 return 0;
455 return -1;
456 }
457
458 gint sort_by_file_write_desc(gconstpointer p1, gconstpointer p2)
459 {
460 struct files *n1 = *(struct files **)p1;
461 struct files *n2 = *(struct files **)p2;
462 unsigned long totaln1;
463 unsigned long totaln2;
464
465 totaln1 = n1->write;
466 totaln2 = n2->write;
467
468 if (totaln1 < totaln2)
469 return 1;
470 if (totaln1 == totaln2)
471 return 0;
472 return -1;
473 }
474
475 gint sort_by_file_fd_desc(gconstpointer p1, gconstpointer p2)
476 {
477 struct files *n1 = *(struct files **)p1;
478 struct files *n2 = *(struct files **)p2;
479 unsigned long totaln1;
480 unsigned long totaln2;
481
482 totaln1 = n1->fd;
483 totaln2 = n2->fd;
484
485 if (totaln1 < totaln2)
486 return 1;
487 if (totaln1 == totaln2)
488 return 0;
489 return -1;
490 }
491
492 gint sort_by_cpu_group_by_threads_desc(gconstpointer p1, gconstpointer p2)
493 {
494 struct processtop *n1 = *(struct processtop **)p1;
495 struct processtop *n2 = *(struct processtop **)p2;
496 unsigned long totaln1 = n1->threadstotalcpunsec;
497 unsigned long totaln2 = n2->threadstotalcpunsec;
498
499 if (totaln1 < totaln2)
500 return 1;
501 if (totaln1 == totaln2)
502 return 0;
503 return -1;
504 }
505
506 void update_kprobes_display()
507 {
508 int i, column;
509 struct kprobes *probe;
510 int header_offset = 2;
511 int current_line = 0;
512
513 set_window_title(center, "Kprobes Top ");
514 wattron(center, A_BOLD);
515 column = 1;
516 for (i = 0; i < 2; i++) {
517 if (kprobeview[i].sort) {
518 wattron(center, A_UNDERLINE);
519 pref_current_sort = i;
520 }
521 mvwprintw(center, 1, column, "%s", kprobeview[i].title);
522 wattroff(center, A_UNDERLINE);
523 column += 30;
524 }
525 wattroff(center, A_BOLD);
526
527 for (i = 0; i < data->kprobes_table->len; i++) {
528 column = 1;
529 probe = g_ptr_array_index(data->kprobes_table, i);
530 mvwprintw(center, current_line + header_offset, column,
531 "%s", probe->probe_name + 6);
532 column += 30;
533 mvwprintw(center, current_line + header_offset, column,
534 "%d", probe->count);
535 current_line++;
536 }
537 }
538
539 void update_cputop_display()
540 {
541 int i;
542 int header_offset = 2;
543 struct processtop *tmp;
544 unsigned long elapsed;
545 double maxcputime;
546 int nblinedisplayed = 0;
547 int current_line = 0;
548 int current_row_offset;
549 int column;
550
551 elapsed = data->end - data->start;
552 maxcputime = elapsed * data->cpu_table->len / 100.0;
553
554 if (cputopview[0].sort == 1)
555 g_ptr_array_sort(data->process_table, sort_by_cpu_desc);
556 else if (cputopview[1].sort == 1)
557 g_ptr_array_sort(data->process_table, sort_by_pid_desc);
558 else if (cputopview[2].sort == 1)
559 g_ptr_array_sort(data->process_table, sort_by_tid_desc);
560 else if (cputopview[3].sort == 1)
561 g_ptr_array_sort(data->process_table, sort_by_cpu_desc);
562 else
563 g_ptr_array_sort(data->process_table, sort_by_cpu_desc);
564
565 set_window_title(center, "CPU Top");
566 wattron(center, A_BOLD);
567 column = 1;
568 for (i = 0; i < 6; i++) {
569 if (toggle_virt < 0 && (i == 3 || i == 4)) {
570 continue;
571 }
572 if (cputopview[i].sort) {
573 wattron(center, A_UNDERLINE);
574 pref_current_sort = i;
575 }
576 mvwprintw(center, 1, column, cputopview[i].title);
577 wattroff(center, A_UNDERLINE);
578 column += 10;
579 }
580 wattroff(center, A_BOLD);
581
582 max_center_lines = LINES - 5 - 7 - 1 - header_offset;
583
584 /* iterate the process (thread) list */
585 for (i = list_offset; i < data->process_table->len &&
586 nblinedisplayed < max_center_lines; i++) {
587 tmp = g_ptr_array_index(data->process_table, i);
588 current_row_offset = 1;
589 if (toggle_filter > 0 && !lookup_filter_tid_list(tmp->tid))
590 continue;
591
592 if (tmp->pid != tmp->tid)
593 if (toggle_threads == -1)
594 continue;
595
596 /* line */
597 if (current_line == selected_line) {
598 selected_process = tmp;
599 wattron(center, COLOR_PAIR(5));
600 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
601 }
602 /* filtered process */
603 if (process_selected(tmp)) {
604 if (current_line == selected_line)
605 wattron(center, COLOR_PAIR(7));
606 else
607 wattron(center, COLOR_PAIR(6));
608 }
609 /* CPU(%) */
610 mvwprintw(center, current_line + header_offset,
611 current_row_offset, "%1.2f",
612 tmp->totalcpunsec / maxcputime);
613 current_row_offset += 10;
614 /* PID */
615 mvwprintw(center, current_line + header_offset,
616 current_row_offset, "%d", tmp->pid);
617 current_row_offset += 10;
618 /* TID */
619 mvwprintw(center, current_line + header_offset,
620 current_row_offset, "%d", tmp->tid);
621 current_row_offset += 10;
622 if (toggle_virt > 0) {
623 /* VPID */
624 mvwprintw(center, current_line + header_offset,
625 current_row_offset, "%d", tmp->vpid);
626 current_row_offset += 10;
627 /* VTID */
628 mvwprintw(center, current_line + header_offset,
629 current_row_offset, "%d", tmp->vtid);
630 current_row_offset += 10;
631 }
632 /* NAME */
633 mvwprintw(center, current_line + header_offset,
634 current_row_offset, "%s", tmp->comm);
635 wattroff(center, COLOR_PAIR(7));
636 wattroff(center, COLOR_PAIR(6));
637 wattroff(center, COLOR_PAIR(5));
638 nblinedisplayed++;
639 current_line++;
640 }
641 }
642
643 gint sort_perf(gconstpointer p1, gconstpointer p2, gpointer key)
644 {
645 struct processtop *n1 = *(struct processtop **) p1;
646 struct processtop *n2 = *(struct processtop **) p2;
647
648 struct perfcounter *tmp1, *tmp2;
649 unsigned long totaln2 = 0;
650 unsigned long totaln1 = 0;
651
652 if (!key)
653 return 0;
654
655 tmp1 = g_hash_table_lookup(n1->perf, key);
656 if (!tmp1)
657 totaln1 = 0;
658 else
659 totaln1 = tmp1->count;
660
661 tmp2 = g_hash_table_lookup(n2->perf, key);
662 if (!tmp2)
663 totaln2 = 0;
664 else
665 totaln2 = tmp2->count;
666
667 if (totaln1 < totaln2)
668 return 1;
669 if (totaln1 == totaln2) {
670 totaln1 = n1->tid;
671 totaln2 = n2->tid;
672 if (totaln1 < totaln2)
673 return 1;
674 return -1;
675 }
676 return -1;
677 }
678
679 void print_key_title(char *key, int line)
680 {
681 wattron(center, A_BOLD);
682 mvwprintw(center, line, 1, "%s", key);
683 mvwprintw(center, line, 30, " ");
684 wattroff(center, A_BOLD);
685 }
686
687 void update_process_details()
688 {
689 unsigned long elapsed;
690 double maxcputime;
691 struct processtop *tmp;
692 struct files *file_tmp;
693 int i, j = 0;
694 char unit[4];
695 char filename_buf[COLS];
696 int line = 1;
697 int column;
698 GPtrArray *newfilearray = g_ptr_array_new();
699 GHashTableIter iter;
700 struct perfcounter *perfn1, *perfn2;
701 gpointer key;
702
703 set_window_title(center, "Process details");
704
705
706 tmp = find_process_tid(data,
707 selected_process->tid,
708 selected_process->comm);
709 elapsed = data->end - data->start;
710 maxcputime = elapsed * data->cpu_table->len / 100.0;
711
712 print_key_title("Name", line++);
713 wprintw(center, "%s", selected_process->comm);
714 print_key_title("TID", line++);
715 wprintw(center, "%d", selected_process->tid);
716 if (!tmp) {
717 print_key_title("Does not exit at this time", 3);
718 return;
719 }
720
721 print_key_title("PID", line++);
722 wprintw(center, "%d", tmp->pid);
723 print_key_title("PPID", line++);
724 wprintw(center, "%d", tmp->ppid);
725 print_key_title("VPID", line++);
726 wprintw(center, "%d", tmp->vpid);
727 print_key_title("VTID", line++);
728 wprintw(center, "%d", tmp->vtid);
729 print_key_title("VPPID", line++);
730 wprintw(center, "%d", tmp->vppid);
731 print_key_title("CPU", line++);
732 wprintw(center, "%1.2f %%", tmp->totalcpunsec/maxcputime);
733
734 print_key_title("READ B/s", line++);
735 scale_unit(tmp->fileread, unit);
736 wprintw(center, "%s", unit);
737
738 print_key_title("WRITE B/s", line++);
739 scale_unit(tmp->filewrite, unit);
740 wprintw(center, "%s", unit);
741
742 g_hash_table_iter_init(&iter, global_perf_liszt);
743 while (g_hash_table_iter_next (&iter, &key, (gpointer) &perfn1)) {
744 print_key_title((char *) key, line++);
745 perfn2 = g_hash_table_lookup(tmp->perf, (char *) key);
746 wprintw(center, "%d", perfn2 ? perfn2->count : 0);
747 }
748 line++;
749
750 wattron(center, A_BOLD);
751 column = 1;
752 for (i = 0; i < 3; i++) {
753 if (fileview[i].sort) {
754 pref_current_sort = i;
755 wattron(center, A_UNDERLINE);
756 }
757 mvwprintw(center, line, column, fileview[i].title);
758 wattroff(center, A_UNDERLINE);
759 column += 10;
760 }
761 mvwprintw(center, line++, column, "FILENAME");
762 wattroff(center, A_BOLD);
763
764 /*
765 * since the process_files_table array could contain NULL file structures,
766 * and that the positions inside the array is important (it is the FD), we
767 * need to create a temporary array that we can sort.
768 */
769 for (i = 0; i < tmp->process_files_table->len; i++) {
770 file_tmp = g_ptr_array_index(tmp->process_files_table, i);
771 if (file_tmp)
772 g_ptr_array_add(newfilearray, file_tmp);
773 }
774
775 if (fileview[0].sort == 1)
776 g_ptr_array_sort(newfilearray, sort_by_file_fd_desc);
777 else if (fileview[1].sort == 1)
778 g_ptr_array_sort(newfilearray, sort_by_file_read_desc);
779 else if (fileview[2].sort == 1)
780 g_ptr_array_sort(newfilearray, sort_by_file_write_desc);
781 else
782 g_ptr_array_sort(newfilearray, sort_by_file_read_desc);
783
784 for (i = selected_line; i < newfilearray->len &&
785 i < (selected_line + max_center_lines - line + 2); i++) {
786 file_tmp = g_ptr_array_index(newfilearray, i);
787 if (!file_tmp)
788 continue;
789 mvwprintw(center, line + j, 1, "%d", file_tmp->fd);
790 scale_unit(file_tmp->read, unit);
791 mvwprintw(center, line + j, 11, "%s", unit);
792 scale_unit(file_tmp->write, unit);
793 mvwprintw(center, line + j, 21, "%s", unit);
794 snprintf(filename_buf, COLS - 25, "%s", file_tmp->name);
795 mvwprintw(center, line + j, 31, "%s", filename_buf);
796 j++;
797 }
798 g_ptr_array_free(newfilearray, TRUE);
799 }
800
801 void update_perf()
802 {
803 int i;
804 int nblinedisplayed = 0;
805 int current_line = 0;
806 struct processtop *tmp;
807 int header_offset = 2;
808 int perf_row = 40;
809 struct perfcounter *perfn1, *perfn2;
810 char *perf_key = NULL;
811 int value;
812 GHashTableIter iter;
813 gpointer key;
814
815 set_window_title(center, "Perf Top");
816 wattron(center, A_BOLD);
817 mvwprintw(center, 1, 1, "PID");
818 mvwprintw(center, 1, 11, "TID");
819 mvwprintw(center, 1, 22, "NAME");
820
821 perf_row = 40;
822 g_hash_table_iter_init(&iter, global_perf_liszt);
823 while (g_hash_table_iter_next (&iter, &key, (gpointer) &perfn1)) {
824 if (perfn1->visible) {
825 if (perfn1->sort) {
826 /* pref_current_sort = i; */
827 wattron(center, A_UNDERLINE);
828 }
829 /* + 5 to strip the "perf_" prefix */
830 mvwprintw(center, 1, perf_row, "%s",
831 (char *) key + 5);
832 wattroff(center, A_UNDERLINE);
833 perf_row += 20;
834 }
835 if (perfn1->sort) {
836 perf_key = (char *) key;
837 }
838 }
839 wattroff(center, A_BOLD);
840
841 g_ptr_array_sort_with_data(data->process_table, sort_perf, perf_key);
842
843 for (i = 0; i < data->process_table->len &&
844 nblinedisplayed < max_center_lines; i++) {
845 tmp = g_ptr_array_index(data->process_table, i);
846
847 if (toggle_filter > 0 && !lookup_filter_tid_list(tmp->tid))
848 continue;
849
850 if (tmp->pid != tmp->tid)
851 if (toggle_threads == -1)
852 continue;
853
854 if (process_selected(tmp)) {
855 if (current_line == selected_line)
856 wattron(center, COLOR_PAIR(7));
857 else
858 wattron(center, COLOR_PAIR(6));
859 }
860 if (current_line == selected_line) {
861 selected_process = tmp;
862 wattron(center, COLOR_PAIR(5));
863 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
864 }
865
866 mvwprintw(center, current_line + header_offset, 1, "%d", tmp->pid);
867 mvwprintw(center, current_line + header_offset, 11, "%d", tmp->tid);
868 mvwprintw(center, current_line + header_offset, 22, "%s", tmp->comm);
869
870 g_hash_table_iter_init(&iter, global_perf_liszt);
871
872 perf_row = 40;
873 while (g_hash_table_iter_next (&iter, &key, (gpointer) &perfn1)) {
874 if (perfn1->visible) {
875 perfn2 = g_hash_table_lookup(tmp->perf, (char *) key);
876 if (perfn2)
877 value = perfn2->count;
878 else
879 value = 0;
880 mvwprintw(center, current_line + header_offset,
881 perf_row, "%d", value);
882 perf_row += 20;
883 }
884 }
885
886 wattroff(center, COLOR_PAIR(6));
887 wattroff(center, COLOR_PAIR(5));
888 nblinedisplayed++;
889 current_line++;
890 }
891 }
892
893 void update_iostream()
894 {
895 int i;
896 int header_offset = 2;
897 struct processtop *tmp;
898 int nblinedisplayed = 0;
899 int current_line = 0;
900 int total = 0;
901 char unit[4];
902 int column;
903
904 set_window_title(center, "IO Top");
905 wattron(center, A_BOLD);
906 mvwprintw(center, 1, 1, "PID");
907 mvwprintw(center, 1, 11, "TID");
908 mvwprintw(center, 1, 22, "NAME");
909 column = 40;
910 for (i = 0; i < 3; i++) {
911 if (iostreamtopview[i].sort) {
912 pref_current_sort = i;
913 wattron(center, A_UNDERLINE);
914 }
915 mvwprintw(center, 1, column, iostreamtopview[i].title);
916 wattroff(center, A_UNDERLINE);
917 column += 12;
918 }
919 wattroff(center, A_BOLD);
920 wattroff(center, A_UNDERLINE);
921
922 if (iostreamtopview[0].sort == 1)
923 g_ptr_array_sort(data->process_table, sort_by_process_read_desc);
924 else if (iostreamtopview[1].sort == 1)
925 g_ptr_array_sort(data->process_table, sort_by_process_write_desc);
926 else if (iostreamtopview[2].sort == 1)
927 g_ptr_array_sort(data->process_table, sort_by_process_total_desc);
928 else
929 g_ptr_array_sort(data->process_table, sort_by_process_total_desc);
930
931 for (i = list_offset; i < data->process_table->len &&
932 nblinedisplayed < max_center_lines; i++) {
933 tmp = g_ptr_array_index(data->process_table, i);
934
935 if (toggle_filter > 0 && !lookup_filter_tid_list(tmp->tid))
936 continue;
937
938 if (tmp->pid != tmp->tid)
939 if (toggle_threads == -1)
940 continue;
941
942 if (process_selected(tmp)) {
943 if (current_line == selected_line)
944 wattron(center, COLOR_PAIR(7));
945 else
946 wattron(center, COLOR_PAIR(6));
947 }
948 if (current_line == selected_line) {
949 selected_process = tmp;
950 wattron(center, COLOR_PAIR(5));
951 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
952 }
953 /* TGID */
954 mvwprintw(center, current_line + header_offset, 1, "%d", tmp->pid);
955 /* PID */
956 mvwprintw(center, current_line + header_offset, 11, "%d", tmp->tid);
957 /* NAME */
958 mvwprintw(center, current_line + header_offset, 22, "%s", tmp->comm);
959
960 /* READ (bytes/sec) */
961 scale_unit(tmp->fileread, unit);
962 mvwprintw(center, current_line + header_offset, 40, "%s", unit);
963
964 /* WRITE (bytes/sec) */
965 scale_unit(tmp->filewrite, unit);
966 mvwprintw(center, current_line + header_offset, 52, "%s", unit);
967
968 /* TOTAL STREAM */
969 total = tmp->totalfileread + tmp->totalfilewrite;
970
971 scale_unit(total, unit);
972 mvwprintw(center, current_line + header_offset, 64, "%s", unit);
973
974 wattroff(center, COLOR_PAIR(6));
975 wattroff(center, COLOR_PAIR(5));
976 nblinedisplayed++;
977 current_line++;
978 }
979 }
980
981 void update_current_view()
982 {
983 sem_wait(&update_display_sem);
984 if (!data)
985 return;
986 update_header();
987
988 werase(center);
989 box(center, 0, 0);
990 switch (current_view) {
991 case cpu:
992 update_cputop_display();
993 break;
994 case perf:
995 update_perf();
996 break;
997 case process_details:
998 update_process_details();
999 break;
1000 case iostream:
1001 update_iostream();
1002 break;
1003 case tree:
1004 update_cputop_display();
1005 break;
1006 case kprobes:
1007 update_kprobes_display();
1008 break;
1009 default:
1010 break;
1011 }
1012 update_panels();
1013 doupdate();
1014 sem_post(&update_display_sem);
1015 }
1016
1017 void update_process_detail_sort(int *line_selected)
1018 {
1019 int i;
1020 int size;
1021
1022 size = 3;
1023
1024 if (*line_selected > (size - 1))
1025 *line_selected = size - 1;
1026 else if (*line_selected < 0)
1027 *line_selected = 0;
1028
1029 if (fileview[*line_selected].sort == 1)
1030 fileview[*line_selected].reverse = 1;
1031 for (i = 0; i < size; i++)
1032 fileview[i].sort = 0;
1033 fileview[*line_selected].sort = 1;
1034 }
1035
1036 void update_process_detail_pref(int *line_selected, int toggle_view, int toggle_sort)
1037 {
1038 int i;
1039 int size;
1040
1041 if (!data)
1042 return;
1043 if (pref_panel_window) {
1044 del_panel(pref_panel);
1045 delwin(pref_panel_window);
1046 }
1047 size = 3;
1048
1049 pref_panel_window = create_window(size + 2, 30, 10, 10);
1050 pref_panel = new_panel(pref_panel_window);
1051
1052 werase(pref_panel_window);
1053 box(pref_panel_window, 0 , 0);
1054 set_window_title(pref_panel_window, "Process Detail Preferences ");
1055 wattron(pref_panel_window, A_BOLD);
1056 mvwprintw(pref_panel_window, size + 1, 1,
1057 " 's' : sort, space : toggle");
1058 wattroff(pref_panel_window, A_BOLD);
1059
1060 if (*line_selected > (size - 1))
1061 *line_selected = size - 1;
1062 else if (*line_selected < 0)
1063 *line_selected = 0;
1064 if (toggle_sort == 1) {
1065 update_process_detail_sort(line_selected);
1066 update_current_view();
1067 }
1068
1069 for (i = 0; i < size; i++) {
1070 if (i == *line_selected) {
1071 wattron(pref_panel_window, COLOR_PAIR(5));
1072 mvwhline(pref_panel_window, i + 1, 1, ' ', 30 - 2);
1073 }
1074 if (fileview[i].sort == 1)
1075 wattron(pref_panel_window, A_BOLD);
1076 mvwprintw(pref_panel_window, i + 1, 1, "[-] %s",
1077 fileview[i].title);
1078 wattroff(pref_panel_window, A_BOLD);
1079 wattroff(pref_panel_window, COLOR_PAIR(5));
1080
1081 }
1082 update_panels();
1083 doupdate();
1084 }
1085
1086 void update_iostream_sort(int *line_selected)
1087 {
1088 int i;
1089 int size;
1090
1091 size = 3;
1092 if (*line_selected > (size - 1))
1093 *line_selected = size - 1;
1094 else if (*line_selected < 0)
1095 *line_selected = 0;
1096 if (iostreamtopview[*line_selected].sort == 1)
1097 iostreamtopview[*line_selected].reverse = 1;
1098 for (i = 0; i < size; i++)
1099 iostreamtopview[i].sort = 0;
1100 iostreamtopview[*line_selected].sort = 1;
1101
1102 }
1103
1104 void update_iostream_pref(int *line_selected, int toggle_view, int toggle_sort)
1105 {
1106 int i;
1107 int size;
1108
1109 if (!data)
1110 return;
1111 if (pref_panel_window) {
1112 del_panel(pref_panel);
1113 delwin(pref_panel_window);
1114 }
1115 size = 3;
1116
1117 pref_panel_window = create_window(size + 2, 30, 10, 10);
1118 pref_panel = new_panel(pref_panel_window);
1119
1120 werase(pref_panel_window);
1121 box(pref_panel_window, 0 , 0);
1122 set_window_title(pref_panel_window, "IOTop Preferences ");
1123 wattron(pref_panel_window, A_BOLD);
1124 mvwprintw(pref_panel_window, size + 1, 1,
1125 " 's' : sort, space : toggle");
1126 wattroff(pref_panel_window, A_BOLD);
1127
1128 if (*line_selected > (size - 1))
1129 *line_selected = size - 1;
1130 else if (*line_selected < 0)
1131 *line_selected = 0;
1132 if (toggle_sort == 1) {
1133 update_iostream_sort(line_selected);
1134 update_current_view();
1135 }
1136
1137 for (i = 0; i < size; i++) {
1138 if (i == *line_selected) {
1139 wattron(pref_panel_window, COLOR_PAIR(5));
1140 mvwhline(pref_panel_window, i + 1, 1, ' ', 30 - 2);
1141 }
1142 if (iostreamtopview[i].sort == 1)
1143 wattron(pref_panel_window, A_BOLD);
1144 mvwprintw(pref_panel_window, i + 1, 1, "[-] %s",
1145 iostreamtopview[i].title);
1146 wattroff(pref_panel_window, A_BOLD);
1147 wattroff(pref_panel_window, COLOR_PAIR(5));
1148
1149 }
1150 update_panels();
1151 doupdate();
1152 }
1153
1154 void update_cpu_sort(int *line_selected)
1155 {
1156 int i;
1157 int size = 3;
1158
1159 if (*line_selected > (size - 1))
1160 *line_selected = size - 1;
1161 else if (*line_selected < 0)
1162 *line_selected = 0;
1163
1164 /* special case, we don't support sorting by procname for now */
1165 if (*line_selected != 3) {
1166 if (cputopview[*line_selected].sort == 1)
1167 cputopview[*line_selected].reverse = 1;
1168 for (i = 0; i < size; i++)
1169 cputopview[i].sort = 0;
1170 cputopview[*line_selected].sort = 1;
1171 }
1172 }
1173
1174 void update_cpu_pref(int *line_selected, int toggle_view, int toggle_sort)
1175 {
1176 int i;
1177 int size;
1178
1179 if (!data)
1180 return;
1181 if (pref_panel_window) {
1182 del_panel(pref_panel);
1183 delwin(pref_panel_window);
1184 }
1185 size = 4;
1186
1187 pref_panel_window = create_window(size + 2, 30, 10, 10);
1188 pref_panel = new_panel(pref_panel_window);
1189
1190 werase(pref_panel_window);
1191 box(pref_panel_window, 0 , 0);
1192 set_window_title(pref_panel_window, "CPUTop Preferences ");
1193 wattron(pref_panel_window, A_BOLD);
1194 mvwprintw(pref_panel_window, size + 1, 1,
1195 " 's' : sort, space : toggle");
1196 wattroff(pref_panel_window, A_BOLD);
1197
1198 if (*line_selected > (size - 1))
1199 *line_selected = size - 1;
1200 else if (*line_selected < 0)
1201 *line_selected = 0;
1202 if (toggle_sort == 1) {
1203 update_cpu_sort(line_selected);
1204 update_current_view();
1205 }
1206
1207 for (i = 0; i < size; i++) {
1208 if (i == *line_selected) {
1209 wattron(pref_panel_window, COLOR_PAIR(5));
1210 mvwhline(pref_panel_window, i + 1, 1, ' ', 30 - 2);
1211 }
1212 if (cputopview[i].sort == 1)
1213 wattron(pref_panel_window, A_BOLD);
1214 mvwprintw(pref_panel_window, i + 1, 1, "[-] %s",
1215 cputopview[i].title);
1216 wattroff(pref_panel_window, A_BOLD);
1217 wattroff(pref_panel_window, COLOR_PAIR(5));
1218
1219 }
1220 update_panels();
1221 doupdate();
1222 }
1223
1224 void update_perf_sort(int *line_selected)
1225 {
1226 int i;
1227 struct perfcounter *perf;
1228 GList *perflist;
1229 int size;
1230
1231 size = g_hash_table_size(global_perf_liszt);
1232 if (*line_selected > (size - 1))
1233 *line_selected = size - 1;
1234 else if (*line_selected < 0)
1235 *line_selected = 0;
1236
1237 i = 0;
1238 perflist = g_list_first(g_hash_table_get_keys(global_perf_liszt));
1239 while (perflist) {
1240 perf = g_hash_table_lookup(global_perf_liszt, perflist->data);
1241 if (i != *line_selected)
1242 perf->sort = 0;
1243 else
1244 perf->sort = 1;
1245 i++;
1246 perflist = g_list_next(perflist);
1247 }
1248 }
1249
1250 void update_perf_pref(int *line_selected, int toggle_view, int toggle_sort)
1251 {
1252 int i;
1253 struct perfcounter *perf;
1254 GList *perflist;
1255 int size;
1256
1257 if (!data)
1258 return;
1259 if (pref_panel_window) {
1260 del_panel(pref_panel);
1261 delwin(pref_panel_window);
1262 }
1263 size = g_hash_table_size(global_perf_liszt);
1264
1265 pref_panel_window = create_window(size + 2, 30, 10, 10);
1266 pref_panel = new_panel(pref_panel_window);
1267
1268 werase(pref_panel_window);
1269 box(pref_panel_window, 0 , 0);
1270 set_window_title(pref_panel_window, "Perf Preferences ");
1271 wattron(pref_panel_window, A_BOLD);
1272 mvwprintw(pref_panel_window, g_hash_table_size(global_perf_liszt) + 1, 1,
1273 " 's' : sort, space : toggle");
1274 wattroff(pref_panel_window, A_BOLD);
1275
1276 if (*line_selected > (size - 1))
1277 *line_selected = size - 1;
1278 else if (*line_selected < 0)
1279 *line_selected = 0;
1280
1281 if (toggle_sort == 1) {
1282 update_perf_sort(line_selected);
1283 update_current_view();
1284 }
1285
1286 i = 0;
1287 perflist = g_list_first(g_hash_table_get_keys(global_perf_liszt));
1288 while (perflist) {
1289 perf = g_hash_table_lookup(global_perf_liszt, perflist->data);
1290 if (i == *line_selected && toggle_view == 1) {
1291 perf->visible = perf->visible == 1 ? 0:1;
1292 update_current_view();
1293 }
1294 if (i == *line_selected) {
1295 wattron(pref_panel_window, COLOR_PAIR(5));
1296 mvwhline(pref_panel_window, i + 1, 1, ' ', 30 - 2);
1297 }
1298 if (perf->sort == 1)
1299 wattron(pref_panel_window, A_BOLD);
1300 mvwprintw(pref_panel_window, i + 1, 1, "[%c] %s",
1301 perf->visible == 1 ? 'x' : ' ',
1302 (char *) perflist->data + 5);
1303 wattroff(pref_panel_window, A_BOLD);
1304 wattroff(pref_panel_window, COLOR_PAIR(5));
1305 i++;
1306 perflist = g_list_next(perflist);
1307 }
1308 update_panels();
1309 doupdate();
1310 }
1311
1312 void update_hostname_pref(int *line_selected, int toggle_filter, int toggle_sort)
1313 {
1314 int i;
1315 struct host *host;
1316 GList *hostlist;
1317 int size;
1318
1319 if (!data)
1320 return;
1321 if (pref_panel_window) {
1322 del_panel(pref_panel);
1323 delwin(pref_panel_window);
1324 }
1325 size = g_hash_table_size(global_host_list);
1326
1327 pref_panel_window = create_window(size + 2, 30, 10, 10);
1328 pref_panel = new_panel(pref_panel_window);
1329
1330 werase(pref_panel_window);
1331 box(pref_panel_window, 0 , 0);
1332 set_window_title(pref_panel_window, "Hosts Preferences ");
1333 wattron(pref_panel_window, A_BOLD);
1334 mvwprintw(pref_panel_window, g_hash_table_size(global_host_list) + 1, 1,
1335 " space : toggle filter");
1336 wattroff(pref_panel_window, A_BOLD);
1337
1338 if (*line_selected > (size - 1))
1339 *line_selected = size - 1;
1340 else if (*line_selected < 0)
1341 *line_selected = 0;
1342
1343 i = 0;
1344 hostlist = g_list_first(g_hash_table_get_keys(global_host_list));
1345 while (hostlist) {
1346 host = g_hash_table_lookup(global_host_list, hostlist->data);
1347 if (i == *line_selected && toggle_filter == 1) {
1348 host->filter = host->filter == 1 ? 0:1;
1349 update_hostname_filter(host);
1350 update_current_view();
1351 }
1352 if (i == *line_selected) {
1353 wattron(pref_panel_window, COLOR_PAIR(5));
1354 mvwhline(pref_panel_window, i + 1, 1, ' ', 30 - 2);
1355 }
1356 if (host->filter == 1)
1357 wattron(pref_panel_window, A_BOLD);
1358 mvwprintw(pref_panel_window, i + 1, 1, "[%c] %s",
1359 host->filter == 1 ? 'x' : ' ',
1360 (char *) hostlist->data);
1361 wattroff(pref_panel_window, A_BOLD);
1362 wattroff(pref_panel_window, COLOR_PAIR(5));
1363 i++;
1364 hostlist = g_list_next(hostlist);
1365 }
1366 update_panels();
1367 doupdate();
1368 }
1369
1370 int update_preference_panel(int *line_selected, int toggle_view, int toggle_sort)
1371 {
1372 int ret = 0;
1373
1374 switch(current_view) {
1375 case perf:
1376 if (filter_host_panel)
1377 update_hostname_pref(line_selected,
1378 toggle_view, toggle_sort);
1379 else
1380 update_perf_pref(line_selected,
1381 toggle_view, toggle_sort);
1382 break;
1383 case cpu:
1384 if (filter_host_panel)
1385 update_hostname_pref(line_selected,
1386 toggle_view, toggle_sort);
1387 else
1388 update_cpu_pref(line_selected,
1389 toggle_view, toggle_sort);
1390 break;
1391 case iostream:
1392 if (filter_host_panel)
1393 update_hostname_pref(line_selected,
1394 toggle_view, toggle_sort);
1395 else
1396 update_iostream_pref(line_selected,
1397 toggle_view, toggle_sort);
1398 break;
1399 case process_details:
1400 update_process_detail_pref(line_selected,
1401 toggle_view, toggle_sort);
1402 break;
1403 default:
1404 ret = -1;
1405 break;
1406 }
1407
1408 return ret;
1409 }
1410
1411 int update_sort(int *line_selected)
1412 {
1413 int ret = 0;
1414
1415 switch(current_view) {
1416 case perf:
1417 update_perf_sort(line_selected);
1418 break;
1419 case cpu:
1420 update_cpu_sort(line_selected);
1421 break;
1422 case iostream:
1423 update_iostream_sort(line_selected);
1424 break;
1425 case process_details:
1426 update_process_detail_sort(line_selected);
1427 break;
1428 default:
1429 ret = -1;
1430 break;
1431 }
1432
1433 return ret;
1434 }
1435
1436 void toggle_pref_panel(void)
1437 {
1438 int ret;
1439
1440 if (pref_panel_visible) {
1441 hide_panel(pref_panel);
1442 pref_panel_visible = 0;
1443 } else {
1444 ret = update_preference_panel(&pref_line_selected, 0, 0);
1445 if (ret < 0)
1446 return;
1447 show_panel(pref_panel);
1448 pref_panel_visible = 1;
1449 }
1450 update_panels();
1451 doupdate();
1452 }
1453
1454 void toggle_host_panel(void)
1455 {
1456 int ret;
1457
1458 filter_host_panel = filter_host_panel ? 0 : 1;
1459 if (pref_panel_visible) {
1460 hide_panel(pref_panel);
1461 pref_panel_visible = 0;
1462 } else {
1463 ret = update_preference_panel(&pref_line_selected, 0, 0);
1464 if (ret < 0)
1465 return;
1466 show_panel(pref_panel);
1467 pref_panel_visible = 1;
1468 }
1469 update_panels();
1470 doupdate();
1471 }
1472
1473 void display(unsigned int index)
1474 {
1475 last_display_index = index;
1476 currently_displayed_index = index;
1477 data = g_ptr_array_index(copies, index);
1478 if (!data)
1479 return;
1480 max_elements = data->process_table->len;
1481 update_current_view();
1482 update_footer();
1483 update_panels();
1484 doupdate();
1485 }
1486
1487 void pause_display()
1488 {
1489 toggle_pause = 1;
1490 print_log("Pause");
1491 sem_wait(&pause_sem);
1492 }
1493
1494 void resume_display()
1495 {
1496 toggle_pause = -1;
1497 print_log("Resume");
1498 sem_post(&pause_sem);
1499 }
1500
1501 void *handle_keyboard(void *p)
1502 {
1503 int ch;
1504 while((ch = getch())) {
1505 switch(ch) {
1506 /* Move the cursor and scroll */
1507 case 'j':
1508 case KEY_DOWN:
1509 if (pref_panel_visible) {
1510 pref_line_selected++;
1511 update_preference_panel(&pref_line_selected, 0, 0);
1512 } else {
1513 if (selected_line < (max_center_lines - 1) &&
1514 selected_line < max_elements - 1) {
1515 selected_line++;
1516 selected_in_list++;
1517 } else if (selected_in_list < (max_elements - 1)
1518 && (list_offset < (max_elements - max_center_lines))) {
1519 selected_in_list++;
1520 list_offset++;
1521 }
1522 update_current_view();
1523 }
1524 break;
1525 case KEY_NPAGE:
1526 break;
1527 case 'k':
1528 case KEY_UP:
1529 if (pref_panel_visible) {
1530 if (pref_line_selected > 0)
1531 pref_line_selected--;
1532 update_preference_panel(&pref_line_selected, 0, 0);
1533 } else {
1534 if (selected_line > 0) {
1535 selected_line--;
1536 selected_in_list--;
1537 } else if (selected_in_list > 0 && list_offset > 0) {
1538 selected_in_list--;
1539 list_offset--;
1540 }
1541 update_current_view();
1542 }
1543 break;
1544 case KEY_PPAGE:
1545 break;
1546
1547 /* Navigate the history with arrows */
1548 case KEY_LEFT:
1549 if (currently_displayed_index > 0) {
1550 currently_displayed_index--;
1551 print_log("Going back in time");
1552 } else {
1553 print_log("Cannot rewind, last data is already displayed");
1554 }
1555 data = g_ptr_array_index(copies, currently_displayed_index);
1556 max_elements = data->process_table->len;
1557
1558 /* we force to pause the display when moving in time */
1559 if (toggle_pause < 0)
1560 pause_display();
1561
1562 update_current_view();
1563 update_footer();
1564 break;
1565 case KEY_RIGHT:
1566 if (currently_displayed_index < last_display_index) {
1567 currently_displayed_index++;
1568 print_log("Going forward in time");
1569 data = g_ptr_array_index(copies, currently_displayed_index);
1570 max_elements = data->process_table->len;
1571 update_current_view();
1572 update_footer();
1573 } else {
1574 print_log("Manually moving forward");
1575 sem_post(&timer);
1576 if (toggle_pause > 0) {
1577 sem_post(&pause_sem);
1578 update_current_view();
1579 sem_wait(&pause_sem);
1580 }
1581 }
1582
1583 break;
1584 case ' ':
1585 if (pref_panel_visible) {
1586 update_preference_panel(&pref_line_selected, 1, 0);
1587 } else {
1588 update_selected_processes();
1589 if (toggle_filter > 0) {
1590 max_elements = g_hash_table_size(global_filter_list);
1591 if (selected_line >= max_elements)
1592 selected_line = max_elements - 1;
1593 }
1594 update_current_view();
1595 }
1596 break;
1597 case 's':
1598 if (pref_panel_visible)
1599 update_preference_panel(&pref_line_selected, 0, 1);
1600 break;
1601 case '>':
1602 /* perf uses a hashtable, it is ordered backward */
1603 if (current_view == perf) {
1604 pref_current_sort--;
1605 } else if (!pref_panel_visible) {
1606 pref_current_sort++;
1607 }
1608 update_sort(&pref_current_sort);
1609 update_current_view();
1610 break;
1611 case '<':
1612 /* perf uses a hashtable, it is ordered backward */
1613 if (current_view == perf) {
1614 pref_current_sort++;
1615 } else if (!pref_panel_visible) {
1616 pref_current_sort--;
1617 }
1618 update_sort(&pref_current_sort);
1619 update_current_view();
1620 break;
1621
1622 case 13: /* FIXME : KEY_ENTER ?? */
1623 if (pref_panel_visible)
1624 break;
1625 if (current_view != process_details) {
1626 previous_view = current_view;
1627 current_view = process_details;
1628 } else {
1629 current_view = previous_view;
1630 previous_view = process_details;
1631 }
1632 selected_line = 0;
1633 update_current_view();
1634 break;
1635
1636 case KEY_F(1):
1637 if (pref_panel_visible)
1638 toggle_pref_panel();
1639 current_view = cpu;
1640 selected_line = 0;
1641 update_current_view();
1642 break;
1643 case KEY_F(2):
1644 if (pref_panel_visible)
1645 toggle_pref_panel();
1646 current_view = cpu;
1647 selected_line = 0;
1648 update_current_view();
1649 break;
1650 case KEY_F(3):
1651 if (pref_panel_visible)
1652 toggle_pref_panel();
1653 current_view = perf;
1654 selected_line = 0;
1655 update_current_view();
1656 break;
1657 case KEY_F(4):
1658 if (pref_panel_visible)
1659 toggle_pref_panel();
1660 current_view = iostream;
1661 selected_line = 0;
1662 update_current_view();
1663 break;
1664 case KEY_F(5):
1665 if (pref_panel_visible)
1666 toggle_pref_panel();
1667 current_view = kprobes;
1668 selected_line = 0;
1669 update_current_view();
1670 break;
1671 case KEY_F(10):
1672 case 'q':
1673 reset_ncurses();
1674 /* exit keyboard thread */
1675 pthread_exit(0);
1676 break;
1677 case 'f':
1678 toggle_filter *= -1;
1679 selected_line = 0;
1680 if (toggle_filter > 0)
1681 max_elements = g_hash_table_size(global_filter_list);
1682 else
1683 max_elements = data->process_table->len;
1684 update_current_view();
1685 break;
1686 case 'h':
1687 toggle_host_panel();
1688 break;
1689 case 't':
1690 toggle_threads *= -1;
1691 update_current_view();
1692 break;
1693 case 'p':
1694 if (toggle_pause < 0) {
1695 pause_display();
1696 } else {
1697 resume_display();
1698 }
1699 break;
1700 case 'r':
1701 toggle_pref_panel();
1702 break;
1703 case 'v':
1704 toggle_virt *= -1;
1705 update_current_view();
1706 break;
1707 /* ESCAPE, but slow to process, don't know why */
1708 case 27:
1709 if (pref_panel_visible)
1710 toggle_pref_panel();
1711 else if (current_view == process_details) {
1712 current_view = previous_view;
1713 previous_view = process_details;
1714 }
1715 update_current_view();
1716 break;
1717 default:
1718 if (data)
1719 update_current_view();
1720 break;
1721 }
1722 update_footer();
1723 }
1724 return NULL;
1725 }
1726
1727 void init_view_headers()
1728 {
1729 cputopview[0].title = strdup("CPU(%)");
1730 cputopview[0].sort = 1;
1731 cputopview[1].title = strdup("PID");
1732 cputopview[2].title = strdup("TID");
1733 cputopview[3].title = strdup("VPID");
1734 cputopview[4].title = strdup("VTID");
1735 cputopview[5].title = strdup("NAME");
1736
1737 iostreamtopview[0].title = strdup("R (B/sec)");
1738 iostreamtopview[1].title = strdup("W (B/sec)");
1739 iostreamtopview[2].title = strdup("Total (B)");
1740 iostreamtopview[2].sort = 1;
1741
1742 fileview[0].title = strdup("FD");
1743 fileview[1].title = strdup("READ");
1744 fileview[1].sort = 1;
1745 fileview[2].title = strdup("WRITE");
1746
1747 kprobeview[0].title = strdup("NAME");
1748 kprobeview[1].title = strdup("HIT");
1749 kprobeview[1].sort = 1;
1750 }
1751
1752 void init_ncurses()
1753 {
1754 sem_init(&update_display_sem, 0, 1);
1755 init_view_headers();
1756 init_screen();
1757
1758 header = create_window(5, COLS - 1, 0, 0);
1759 center = create_window(LINES - 5 - 7, COLS - 1, 5, 0);
1760 status = create_window(MAX_LOG_LINES + 2, COLS - 1, LINES - 7, 0);
1761 footer = create_window(1, COLS - 1, LINES - 1, 0);
1762
1763 print_log("Starting display");
1764
1765 main_panel = new_panel(center);
1766
1767 current_view = cpu;
1768
1769 basic_header();
1770 update_footer();
1771
1772 pthread_create(&keyboard_thread, NULL, handle_keyboard, (void *)NULL);
1773 }
LTTngTop ncurse top like application showing statistics
This page took 0.067885 seconds and 4 git commands to generate.