b9429db70708bfaa4e30382f4206fbac9b3bb9c1
[lttngtop.git] / src / cursesdisplay.c
1 /*
2 * Copyright (C) 2011 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 *perf_panel_window = NULL;
42 PANEL *perf_panel, *main_panel;
43
44 int perf_panel_visible = 0;
45 int perf_line_selected = 0;
46
47 int last_display_index, currently_displayed_index;
48
49 struct processtop *selected_process = NULL;
50 int selected_ret;
51
52 int selected_line = 0; /* select bar position */
53 int selected_in_list = 0; /* selection relative to the whole list */
54 int list_offset = 0; /* first index in the list to display (scroll) */
55 int nb_log_lines = 0;
56 char log_lines[MAX_LINE_LENGTH * MAX_LOG_LINES + MAX_LOG_LINES];
57
58 int max_elements = 80;
59
60 int toggle_threads = -1;
61 int toggle_pause = -1;
62
63 int max_center_lines;
64 GPtrArray *selected_processes;
65
66 pthread_t keyboard_thread;
67
68 void reset_ncurses()
69 {
70 curs_set(1);
71 endwin();
72 exit(0);
73 }
74
75 static void handle_sigterm(int signal)
76 {
77 reset_ncurses();
78 }
79
80 void init_screen()
81 {
82 initscr();
83 noecho();
84 halfdelay(DEFAULT_DELAY);
85 nonl();
86 intrflush(stdscr, false);
87 keypad(stdscr, true);
88 curs_set(0);
89
90 if (has_colors()) {
91 start_color();
92 init_pair(1, COLOR_RED, COLOR_BLACK); /* - */
93 init_pair(2, COLOR_GREEN, COLOR_BLACK); /* + */
94 init_pair(3, COLOR_BLACK, COLOR_WHITE); /* keys */
95 init_pair(4, COLOR_WHITE, COLOR_GREEN); /* keys activated */
96 init_pair(5, COLOR_WHITE, COLOR_BLUE); /* select line */
97 init_pair(6, COLOR_WHITE, COLOR_GREEN); /* selected process */
98 }
99 termtype = getenv("TERM");
100 if (!strcmp(termtype, "xterm") || !strcmp(termtype, "xterm-color") ||
101 !strcmp(termtype, "vt220")) {
102 define_key("\033[H", KEY_HOME);
103 define_key("\033[F", KEY_END);
104 define_key("\033OP", KEY_F(1));
105 define_key("\033OQ", KEY_F(2));
106 define_key("\033OR", KEY_F(3));
107 define_key("\033OS", KEY_F(4));
108 define_key("\0330U", KEY_F(6));
109 define_key("\033[11~", KEY_F(1));
110 define_key("\033[12~", KEY_F(2));
111 define_key("\033[13~", KEY_F(3));
112 define_key("\033[14~", KEY_F(4));
113 define_key("\033[16~", KEY_F(6));
114 define_key("\033[17;2~", KEY_F(18));
115 }
116 signal(SIGTERM, handle_sigterm);
117 mousemask(BUTTON1_CLICKED, NULL);
118 refresh();
119 }
120
121 WINDOW *create_window(int height, int width, int startx, int starty)
122 {
123 WINDOW *win;
124 win = newwin(height, width, startx, starty);
125 box(win, 0 , 0);
126 wrefresh(win);
127 return win;
128 }
129
130 WINDOW *create_window_no_border(int height, int width, int startx, int starty)
131 {
132 WINDOW *win;
133 win = newwin(height, width, startx, starty);
134 wrefresh(win);
135 return win;
136 }
137
138 void print_digit(WINDOW *win, int digit)
139 {
140 if (digit < 0) {
141 wattron(win, COLOR_PAIR(1));
142 wprintw(win, "%d", digit);
143 wattroff(win, COLOR_PAIR(1));
144 } else if (digit > 0) {
145 wattron(win, COLOR_PAIR(2));
146 wprintw(win, "+%d", digit);
147 wattroff(win, COLOR_PAIR(2));
148 } else {
149 wprintw(win, "0");
150 }
151 }
152
153 void print_digits(WINDOW *win, int first, int second)
154 {
155 wprintw(win, "(");
156 print_digit(win, first);
157 wprintw(win, ", ");
158 print_digit(win, second);
159 wprintw(win, ")");
160 }
161
162 void print_headers(int line, char *desc, int value, int first, int second)
163 {
164 wattron(header, A_BOLD);
165 mvwprintw(header, line, 4, "%s", desc);
166 wattroff(header, A_BOLD);
167 mvwprintw(header, line, 16, "%d", value);
168 wmove(header, line, 24);
169 print_digits(header, first, second);
170 wmove(header, line, 40);
171 }
172
173 void set_window_title(WINDOW *win, char *title)
174 {
175 wattron(win, A_BOLD);
176 mvwprintw(win, 0, 1, title);
177 wattroff(win, A_BOLD);
178 }
179
180 void print_log(char *str)
181 {
182 int i;
183 int current_line = 1;
184 int current_char = 1;
185 char *tmp, *tmp2;
186 /* rotate the line buffer */
187 if (nb_log_lines >= MAX_LOG_LINES) {
188 tmp = strndup(log_lines, MAX_LINE_LENGTH * MAX_LOG_LINES + MAX_LOG_LINES);
189 tmp2 = strchr(tmp, '\n');
190 memset(log_lines, '\0', strlen(log_lines));
191 strncat(log_lines, tmp2 + 1, strlen(tmp2) - 1);
192 log_lines[strlen(log_lines)] = '\n';
193 log_lines[strlen(log_lines)] = '\0';
194 free(tmp);
195 }
196 nb_log_lines++;
197
198 strncat(log_lines, str, MAX_LINE_LENGTH - 1);
199
200 if (nb_log_lines < MAX_LOG_LINES)
201 log_lines[strlen(log_lines)] = '\n';
202 log_lines[strlen(log_lines)] = '\0';
203
204 werase(status);
205 box(status, 0 , 0);
206 set_window_title(status, "Status");
207 for (i = 0; i < strlen(log_lines); i++) {
208 if (log_lines[i] == '\n') {
209 wmove(status, ++current_line, 1);
210 current_char = 1;
211 } else {
212 mvwprintw(status, current_line, current_char++, "%c",
213 log_lines[i]);
214 }
215 }
216 wrefresh(status);
217 }
218
219 int process_selected(struct processtop *process)
220 {
221 int i;
222 struct processtop *stored_process;
223
224 for (i = 0; i < selected_processes->len; i++) {
225 stored_process = g_ptr_array_index(selected_processes, i);
226 if (stored_process->tid == process->tid)
227 return 1;
228 }
229 return 0;
230 }
231
232 void update_selected_processes()
233 {
234 if (process_selected(selected_process)) {
235 g_ptr_array_remove(selected_processes, selected_process);
236 print_log("Process removed");
237 } else {
238 g_ptr_array_add(selected_processes, selected_process);
239 print_log("Process added");
240 }
241 }
242
243 void print_key(WINDOW *win, char *key, char *desc, int toggle)
244 {
245 int pair;
246 if (toggle > 0)
247 pair = 4;
248 else
249 pair = 3;
250 wattron(win, COLOR_PAIR(pair));
251 wprintw(footer, "%s", key);
252 wattroff(win, COLOR_PAIR(pair));
253 wprintw(footer, ":%s", desc);
254 }
255
256 void update_footer()
257 {
258 sem_wait(&update_display_sem);
259 werase(footer);
260 wmove(footer, 1, 1);
261 print_key(footer, "F2", "CPUtop ", current_view == cpu);
262 print_key(footer, "F3", "PerfTop ", current_view == perf);
263 print_key(footer, "F4", "IOTop ", current_view == iostream);
264 print_key(footer, "Enter", "Details ", current_view == process_details);
265 print_key(footer, "Space", "Highlight ", 0);
266 print_key(footer, "q", "Quit | ", 0);
267 print_key(footer, "P", "Perf Pref ", 0);
268 print_key(footer, "p", "Pause ", toggle_pause);
269
270 wrefresh(footer);
271 sem_post(&update_display_sem);
272 }
273
274 void basic_header()
275 {
276 werase(header);
277 box(header, 0 , 0);
278 set_window_title(header, "Statistics for interval [gathering data...[");
279 wattron(header, A_BOLD);
280 mvwprintw(header, 1, 4, "CPUs");
281 mvwprintw(header, 2, 4, "Threads");
282 mvwprintw(header, 3, 4, "FDs");
283 wattroff(header, A_BOLD);
284 wrefresh(header);
285 }
286
287 struct tm format_timestamp(uint64_t timestamp)
288 {
289 struct tm tm;
290 uint64_t ts_sec = 0, ts_nsec;
291 time_t time_s;
292
293 ts_nsec = timestamp;
294 ts_sec += ts_nsec / NSEC_PER_SEC;
295 ts_nsec = ts_nsec % NSEC_PER_SEC;
296
297 time_s = (time_t) ts_sec;
298
299 localtime_r(&time_s, &tm);
300
301 return tm;
302 }
303
304 static void scale_unit(uint64_t bytes, char *ret)
305 {
306 if (bytes >= 1000000000)
307 sprintf(ret, "%" PRIu64 "G", bytes/1000000000);
308 if (bytes >= 1000000)
309 sprintf(ret, "%" PRIu64 "M", bytes/1000000);
310 else if (bytes >= 1000)
311 sprintf(ret, "%" PRIu64 "K", bytes/1000);
312 else
313 sprintf(ret, "%" PRIu64, bytes);
314 }
315 uint64_t total_io()
316 {
317 int i;
318 struct processtop *tmp;
319 uint64_t total = 0;
320
321 for (i = 0; i < data->process_table->len; i++) {
322 tmp = g_ptr_array_index(data->process_table, i);
323 total += tmp->fileread;
324 total += tmp->filewrite;
325 }
326
327 return total;
328 }
329
330 void update_header()
331 {
332 struct tm start, end;
333 uint64_t ts_nsec_start, ts_nsec_end;
334 char io[4];
335
336 ts_nsec_start = data->start % NSEC_PER_SEC;
337 start = format_timestamp(data->start);
338
339 ts_nsec_end = data->end % NSEC_PER_SEC;
340 end = format_timestamp(data->end);
341
342 werase(header);
343 box(header, 0 , 0);
344 set_window_title(header, "Statistics for interval ");
345 wattron(header, A_BOLD);
346
347 wprintw(header, "[%02d:%02d:%02d.%09" PRIu64 ", %02d:%02d:%02d.%09" PRIu64 "[",
348 start.tm_hour, start.tm_min, start.tm_sec, ts_nsec_start,
349 end.tm_hour, end.tm_min, end.tm_sec, ts_nsec_end);
350 mvwprintw(header, 1, 4, "CPUs");
351 wattroff(header, A_BOLD);
352 wprintw(header, "\t%d\t(max/cpu : %0.2f%)", data->cpu_table->len,
353 100.0/data->cpu_table->len);
354 print_headers(2, "Threads", data->nbthreads, data->nbnewthreads,
355 -1*(data->nbdeadthreads));
356 print_headers(3, "FDs", data->nbfiles, data->nbnewfiles,
357 -1*(data->nbclosedfiles));
358 scale_unit(total_io(), io);
359 mvwprintw(header, 3, 43, "%sB/sec", io);
360 wrefresh(header);
361 }
362
363 gint sort_by_cpu_desc(gconstpointer p1, gconstpointer p2)
364 {
365 struct processtop *n1 = *(struct processtop **)p1;
366 struct processtop *n2 = *(struct processtop **)p2;
367 unsigned long totaln1 = n1->totalcpunsec;
368 unsigned long totaln2 = n2->totalcpunsec;
369
370 if (totaln1 < totaln2)
371 return 1;
372 if (totaln1 == totaln2)
373 return 0;
374 return -1;
375 }
376
377 gint sort_by_cpu_group_by_threads_desc(gconstpointer p1, gconstpointer p2)
378 {
379 struct processtop *n1 = *(struct processtop **)p1;
380 struct processtop *n2 = *(struct processtop **)p2;
381 unsigned long totaln1 = n1->threadstotalcpunsec;
382 unsigned long totaln2 = n2->threadstotalcpunsec;
383
384 if (totaln1 < totaln2)
385 return 1;
386 if (totaln1 == totaln2)
387 return 0;
388 return -1;
389 }
390
391 void update_cputop_display()
392 {
393 int i;
394 int header_offset = 2;
395 struct processtop *tmp;
396 unsigned long elapsed;
397 double maxcputime;
398 int nblinedisplayed = 0;
399 int current_line = 0;
400
401 elapsed = data->end - data->start;
402 maxcputime = elapsed * data->cpu_table->len / 100.0;
403
404 g_ptr_array_sort(data->process_table, sort_by_cpu_desc);
405
406 set_window_title(center, "CPU Top");
407 wattron(center, A_BOLD);
408 mvwprintw(center, 1, 1, "CPU(%)");
409 mvwprintw(center, 1, 12, "TGID");
410 mvwprintw(center, 1, 22, "PID");
411 mvwprintw(center, 1, 32, "NAME");
412 wattroff(center, A_BOLD);
413
414 max_center_lines = LINES - 5 - 7 - 1 - header_offset;
415
416 /* iterate the process (thread) list */
417 for (i = list_offset; i < data->process_table->len &&
418 nblinedisplayed < max_center_lines; i++) {
419 tmp = g_ptr_array_index(data->process_table, i);
420
421 /* FIXME : random segfault here */
422 if (process_selected(tmp)) {
423 wattron(center, COLOR_PAIR(6));
424 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
425 }
426 if (current_line == selected_line) {
427 selected_process = tmp;
428 wattron(center, COLOR_PAIR(5));
429 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
430 }
431 /* CPU(%) */
432 mvwprintw(center, current_line + header_offset, 1, "%1.2f",
433 tmp->totalcpunsec / maxcputime);
434 /* TGID */
435 mvwprintw(center, current_line + header_offset, 12, "%d", tmp->pid);
436 /* PID */
437 mvwprintw(center, current_line + header_offset, 22, "%d", tmp->tid);
438 /* NAME */
439 mvwprintw(center, current_line + header_offset, 32, "%s", tmp->comm);
440 wattroff(center, COLOR_PAIR(6));
441 wattroff(center, COLOR_PAIR(5));
442 nblinedisplayed++;
443 current_line++;
444 }
445 }
446
447 gint sort_perf(gconstpointer p1, gconstpointer p2, gpointer key)
448 {
449 struct processtop *n1 = *(struct processtop **) p1;
450 struct processtop *n2 = *(struct processtop **) p2;
451
452 struct perfcounter *tmp1, *tmp2;
453 unsigned long totaln2 = 0;
454 unsigned long totaln1 = 0;
455
456 if (!key)
457 return 0;
458
459 tmp1 = g_hash_table_lookup(n1->perf, key);
460 if (!tmp1)
461 totaln1 = 0;
462 else
463 totaln1 = tmp1->count;
464
465 tmp2 = g_hash_table_lookup(n2->perf, key);
466 if (!tmp2)
467 totaln2 = 0;
468 else
469 totaln2 = tmp2->count;
470
471 if (totaln1 < totaln2)
472 return 1;
473 if (totaln1 == totaln2) {
474 totaln1 = n1->tid;
475 totaln2 = n2->tid;
476 if (totaln1 < totaln2)
477 return 1;
478 return -1;
479 }
480 return -1;
481 }
482
483 void print_key_title(char *key, int line)
484 {
485 wattron(center, A_BOLD);
486 mvwprintw(center, line, 1, "%s\t", key);
487 wattroff(center, A_BOLD);
488 }
489
490 void update_process_details()
491 {
492 unsigned long elapsed;
493 double maxcputime;
494 struct processtop *tmp;
495 struct files *file_tmp;
496 int i, j = 0;
497 char unit[4];
498 char filename_buf[COLS];
499
500 set_window_title(center, "Process details");
501
502
503 tmp = find_process_tid(data,
504 selected_process->tid,
505 selected_process->comm);
506 elapsed = data->end - data->start;
507 maxcputime = elapsed * data->cpu_table->len / 100.0;
508
509 print_key_title("Name", 1);
510 wprintw(center, "%s", selected_process->comm);
511 print_key_title("TID", 2);
512 wprintw(center, "%d", selected_process->tid);
513 if (!tmp) {
514 print_key_title("Does not exit at this time", 3);
515 return;
516 }
517
518 print_key_title("PID", 3);
519 wprintw(center, "%d", tmp->pid);
520 print_key_title("PPID", 4);
521 wprintw(center, "%d", tmp->ppid);
522 print_key_title("CPU", 5);
523 wprintw(center, "%1.2f %%", tmp->totalcpunsec/maxcputime);
524
525 print_key_title("READ B/s", 6);
526 scale_unit(tmp->fileread, unit);
527 wprintw(center, "%s", unit);
528
529 print_key_title("WRITE B/s", 7);
530 scale_unit(tmp->filewrite, unit);
531 wprintw(center, "%s", unit);
532
533 wattron(center, A_BOLD);
534 mvwprintw(center, 8, 1, "FD");
535 mvwprintw(center, 8, 10, "READ");
536 mvwprintw(center, 8, 17, "WRITE");
537 mvwprintw(center, 8, 24, "FILENAME");
538 wattroff(center, A_BOLD);
539
540 for (i = selected_line; i < tmp->process_files_table->len &&
541 i < (selected_line + max_center_lines - 7); i++) {
542 file_tmp = get_file(tmp, i);
543 if (file_tmp != NULL) {
544 mvwprintw(center, 9 + j, 1, "%d", i);
545 scale_unit(file_tmp->read, unit);
546 mvwprintw(center, 9 + j, 10, "%s", unit);
547 scale_unit(file_tmp->write, unit);
548 mvwprintw(center, 9 + j, 17, "%s", unit);
549 snprintf(filename_buf, COLS - 25, "%s", file_tmp->name);
550 mvwprintw(center, 9 + j, 24, "%s", filename_buf);
551 j++;
552 }
553 }
554 }
555
556 void update_perf()
557 {
558 int i;
559 int nblinedisplayed = 0;
560 int current_line = 0;
561 struct processtop *tmp;
562 int header_offset = 2;
563 int perf_row = 40;
564 struct perfcounter *perfn1, *perfn2;
565 char *perf_key = NULL;
566 int value;
567 GHashTableIter iter;
568 gpointer key;
569
570 set_window_title(center, "Perf Top");
571 wattron(center, A_BOLD);
572 mvwprintw(center, 1, 1, "PID");
573 mvwprintw(center, 1, 11, "TID");
574 mvwprintw(center, 1, 22, "NAME");
575
576 perf_row = 40;
577 g_hash_table_iter_init(&iter, data->perf_list);
578 while (g_hash_table_iter_next (&iter, &key, (gpointer) &perfn1)) {
579 if (perfn1->visible) {
580 /* + 5 to strip the "perf_" prefix */
581 mvwprintw(center, 1, perf_row, "%s",
582 (char *) key + 5);
583 perf_row += 20;
584 }
585 if (perfn1->sort) {
586 perf_key = (char *) key;
587 }
588 }
589
590 wattroff(center, A_BOLD);
591
592 g_ptr_array_sort_with_data(data->process_table, sort_perf, perf_key);
593
594 for (i = 0; i < data->process_table->len &&
595 nblinedisplayed < max_center_lines; i++) {
596 tmp = g_ptr_array_index(data->process_table, i);
597
598 if (process_selected(tmp)) {
599 wattron(center, COLOR_PAIR(6));
600 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
601 }
602 if (current_line == selected_line) {
603 selected_process = tmp;
604 wattron(center, COLOR_PAIR(5));
605 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
606 }
607
608 mvwprintw(center, current_line + header_offset, 1, "%d", tmp->pid);
609 mvwprintw(center, current_line + header_offset, 11, "%d", tmp->tid);
610 mvwprintw(center, current_line + header_offset, 22, "%s", tmp->comm);
611
612 g_hash_table_iter_init(&iter, data->perf_list);
613
614 perf_row = 40;
615 while (g_hash_table_iter_next (&iter, &key, (gpointer) &perfn1)) {
616 if (perfn1->visible) {
617 perfn2 = g_hash_table_lookup(tmp->perf, (char *) key);
618 if (perfn2)
619 value = perfn2->count;
620 else
621 value = 0;
622 mvwprintw(center, current_line + header_offset,
623 perf_row, "%d", value);
624 perf_row += 20;
625 }
626 }
627
628 wattroff(center, COLOR_PAIR(6));
629 wattroff(center, COLOR_PAIR(5));
630 nblinedisplayed++;
631 current_line++;
632 }
633 }
634
635 gint sort_by_ret_desc(gconstpointer p1, gconstpointer p2)
636 {
637 struct processtop *n1 = *(struct processtop **)p1;
638 struct processtop *n2 = *(struct processtop **)p2;
639
640 unsigned long totaln1 = n1->totalfileread + n1->totalfilewrite;
641 unsigned long totaln2 = n2->totalfileread + n2->totalfilewrite;
642
643 if (totaln1 < totaln2)
644 return 1;
645 if (totaln1 == totaln2)
646 return 0;
647 return -1;
648 }
649
650 void update_iostream()
651 {
652 int i;
653 int header_offset = 2;
654 struct processtop *tmp;
655 int nblinedisplayed = 0;
656 int current_line = 0;
657 int total = 0;
658 char unit[4];
659
660 set_window_title(center, "IO Top");
661 wattron(center, A_BOLD);
662 mvwprintw(center, 1, 1, "PID");
663 mvwprintw(center, 1, 11, "TID");
664 mvwprintw(center, 1, 22, "NAME");
665 mvwprintw(center, 1, 40, "R (B/sec)");
666 mvwprintw(center, 1, 52, "W (B/sec)");
667 mvwprintw(center, 1, 64, "Total");
668 wattroff(center, A_BOLD);
669
670 g_ptr_array_sort(data->process_table, sort_by_ret_desc);
671
672 for (i = list_offset; i < data->process_table->len &&
673 nblinedisplayed < max_center_lines; i++) {
674 tmp = g_ptr_array_index(data->process_table, i);
675
676 if (process_selected(tmp)) {
677 wattron(center, COLOR_PAIR(6));
678 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
679 }
680 if (current_line == selected_line) {
681 selected_process = tmp;
682 wattron(center, COLOR_PAIR(5));
683 mvwhline(center, current_line + header_offset, 1, ' ', COLS-3);
684 }
685 /* TGID */
686 mvwprintw(center, current_line + header_offset, 1, "%d", tmp->pid);
687 /* PID */
688 mvwprintw(center, current_line + header_offset, 11, "%d", tmp->tid);
689 /* NAME */
690 mvwprintw(center, current_line + header_offset, 22, "%s", tmp->comm);
691
692 /* READ (bytes/sec) */
693 scale_unit(tmp->fileread, unit);
694 mvwprintw(center, current_line + header_offset, 40, "%s", unit);
695
696 /* WRITE (bytes/sec) */
697 scale_unit(tmp->filewrite, unit);
698 mvwprintw(center, current_line + header_offset, 52, "%s", unit);
699
700 /* TOTAL STREAM */
701 total = tmp->totalfileread + tmp->totalfilewrite;
702
703 scale_unit(total, unit);
704 mvwprintw(center, current_line + header_offset, 64, "%s", unit);
705
706 wattroff(center, COLOR_PAIR(6));
707 wattroff(center, COLOR_PAIR(5));
708 nblinedisplayed++;
709 current_line++;
710 }
711 }
712
713 void update_current_view()
714 {
715 sem_wait(&update_display_sem);
716 if (!data)
717 return;
718 update_header();
719
720 werase(center);
721 box(center, 0, 0);
722 switch (current_view) {
723 case cpu:
724 update_cputop_display();
725 break;
726 case perf:
727 update_perf();
728 break;
729 case process_details:
730 update_process_details();
731 break;
732 case iostream:
733 update_iostream();
734 break;
735 case tree:
736 update_cputop_display();
737 break;
738 default:
739 break;
740 }
741 update_panels();
742 doupdate();
743 sem_post(&update_display_sem);
744 }
745
746 void setup_perf_panel()
747 {
748 int size;
749 if (!data)
750 return;
751 if (perf_panel_window) {
752 del_panel(perf_panel);
753 delwin(perf_panel_window);
754 }
755 size = g_hash_table_size(data->perf_list);
756 perf_panel_window = create_window(size + 2, 30, 10, 10);
757 perf_panel = new_panel(perf_panel_window);
758 perf_panel_visible = 0;
759 hide_panel(perf_panel);
760 }
761
762 void update_perf_panel(int line_selected, int toggle_view, int toggle_sort)
763 {
764 int i;
765 struct perfcounter *perf;
766 GList *perflist;
767
768 if (!data)
769 return;
770
771 werase(perf_panel_window);
772 box(perf_panel_window, 0 , 0);
773 set_window_title(perf_panel_window, "Perf Preferences ");
774 wattron(perf_panel_window, A_BOLD);
775 mvwprintw(perf_panel_window, g_hash_table_size(data->perf_list) + 1, 1,
776 " 's' to sort");
777 wattroff(perf_panel_window, A_BOLD);
778
779 if (toggle_sort == 1) {
780 i = 0;
781 perflist = g_list_first(g_hash_table_get_keys(data->perf_list));
782 while (perflist) {
783 perf = g_hash_table_lookup(data->perf_list, perflist->data);
784 if (i != line_selected)
785 perf->sort = 0;
786 else
787 perf->sort = 1;
788 i++;
789 perflist = g_list_next(perflist);
790 }
791 update_current_view();
792 }
793
794 i = 0;
795 perflist = g_list_first(g_hash_table_get_keys(data->perf_list));
796 while (perflist) {
797 perf = g_hash_table_lookup(data->perf_list, perflist->data);
798 if (i == line_selected && toggle_view == 1) {
799 perf->visible = perf->visible == 1 ? 0:1;
800 update_current_view();
801 }
802 if (i == line_selected) {
803 wattron(perf_panel_window, COLOR_PAIR(5));
804 mvwhline(perf_panel_window, i + 1, 1, ' ', 30 - 2);
805 }
806 if (perf->sort == 1)
807 wattron(perf_panel_window, A_BOLD);
808 mvwprintw(perf_panel_window, i + 1, 1, "[%c] %s",
809 perf->visible == 1 ? 'x' : ' ',
810 (char *) perflist->data + 5);
811 wattroff(perf_panel_window, A_BOLD);
812 wattroff(perf_panel_window, COLOR_PAIR(5));
813 i++;
814 perflist = g_list_next(perflist);
815 }
816 update_panels();
817 doupdate();
818 }
819
820 void toggle_perf_panel(void)
821 {
822 if (perf_panel_visible) {
823 hide_panel(perf_panel);
824 perf_panel_visible = 0;
825 } else {
826 setup_perf_panel();
827 update_perf_panel(perf_line_selected, 0, 0);
828 show_panel(perf_panel);
829 perf_panel_visible = 1;
830 }
831 update_panels();
832 doupdate();
833 }
834
835 void display(unsigned int index)
836 {
837 last_display_index = index;
838 currently_displayed_index = index;
839 data = g_ptr_array_index(copies, index);
840 if (!data)
841 return;
842 max_elements = data->process_table->len;
843 update_current_view();
844 update_footer();
845 update_panels();
846 doupdate();
847 }
848
849 void pause_display()
850 {
851 toggle_pause = 1;
852 print_log("Pause");
853 sem_wait(&pause_sem);
854 }
855
856 void resume_display()
857 {
858 toggle_pause = -1;
859 print_log("Resume");
860 sem_post(&pause_sem);
861 }
862
863 void *handle_keyboard(void *p)
864 {
865 int ch;
866 while((ch = getch())) {
867 switch(ch) {
868 /* Move the cursor and scroll */
869 case KEY_DOWN:
870 if (perf_panel_visible) {
871 if (perf_line_selected < g_hash_table_size(data->perf_list) - 1)
872 perf_line_selected++;
873 update_perf_panel(perf_line_selected, 0, 0);
874 } else {
875 if (selected_line < (max_center_lines - 1) &&
876 selected_line < max_elements - 1) {
877 selected_line++;
878 selected_in_list++;
879 } else if (selected_in_list < (max_elements - 1)
880 && (list_offset < (max_elements - max_center_lines))) {
881 selected_in_list++;
882 list_offset++;
883 }
884 update_current_view();
885 }
886 break;
887 case KEY_NPAGE:
888 break;
889 case KEY_UP:
890 if (perf_panel_visible) {
891 if (perf_line_selected > 0)
892 perf_line_selected--;
893 update_perf_panel(perf_line_selected, 0, 0);
894 } else {
895 if (selected_line > 0) {
896 selected_line--;
897 selected_in_list--;
898 } else if (selected_in_list > 0 && list_offset > 0) {
899 selected_in_list--;
900 list_offset--;
901 }
902 update_current_view();
903 }
904 break;
905 case KEY_PPAGE:
906 break;
907
908 /* Navigate the history with arrows */
909 case KEY_LEFT:
910 if (currently_displayed_index > 0) {
911 currently_displayed_index--;
912 print_log("Going back in time");
913 } else {
914 print_log("Cannot rewind, last data is already displayed");
915 }
916 data = g_ptr_array_index(copies, currently_displayed_index);
917 max_elements = data->process_table->len;
918
919 /* we force to pause the display when moving in time */
920 if (toggle_pause < 0)
921 pause_display();
922
923 update_current_view();
924 update_footer();
925 break;
926 case KEY_RIGHT:
927 if (currently_displayed_index < last_display_index) {
928 currently_displayed_index++;
929 print_log("Going forward in time");
930 data = g_ptr_array_index(copies, currently_displayed_index);
931 max_elements = data->process_table->len;
932 update_current_view();
933 update_footer();
934 } else {
935 print_log("Manually moving forward");
936 sem_post(&timer);
937 /* we force to resume the refresh when moving forward */
938 if (toggle_pause > 0)
939 resume_display();
940 }
941
942 break;
943 case ' ':
944 if (perf_panel_visible) {
945 update_perf_panel(perf_line_selected, 1, 0);
946 } else {
947 update_selected_processes();
948 update_current_view();
949 }
950 break;
951 case 's':
952 if (perf_panel_visible)
953 update_perf_panel(perf_line_selected, 0, 1);
954 break;
955
956 case 13: /* FIXME : KEY_ENTER ?? */
957 if (current_view != process_details) {
958 previous_view = current_view;
959 current_view = process_details;
960 } else {
961 current_view = previous_view;
962 previous_view = process_details;
963 }
964 update_current_view();
965 break;
966
967 case KEY_F(1):
968 current_view = cpu;
969 selected_line = 0;
970 update_current_view();
971 break;
972 case KEY_F(2):
973 current_view = cpu;
974 selected_line = 0;
975 update_current_view();
976 break;
977 case KEY_F(3):
978 current_view = perf;
979 selected_line = 0;
980 update_current_view();
981 break;
982 case KEY_F(4):
983 current_view = iostream;
984 selected_line = 0;
985 update_current_view();
986 break;
987 case KEY_F(10):
988 case 'q':
989 reset_ncurses();
990 break;
991 case 't':
992 toggle_threads *= -1;
993 update_current_view();
994 break;
995 case 'p':
996 if (toggle_pause < 0) {
997 pause_display();
998 } else {
999 resume_display();
1000 }
1001 break;
1002 case 'P':
1003 toggle_perf_panel();
1004 break;
1005 default:
1006 if (data)
1007 update_current_view();
1008 break;
1009 }
1010 update_footer();
1011 }
1012 return NULL;
1013 }
1014
1015 void init_ncurses()
1016 {
1017 selected_processes = g_ptr_array_new();
1018 sem_init(&update_display_sem, 0, 1);
1019 init_screen();
1020
1021 header = create_window(5, COLS - 1, 0, 0);
1022 center = create_window(LINES - 5 - 7, COLS - 1, 5, 0);
1023 status = create_window(MAX_LOG_LINES + 2, COLS - 1, LINES - 7, 0);
1024 footer = create_window(1, COLS - 1, LINES - 1, 0);
1025
1026 print_log("Starting display");
1027
1028 main_panel = new_panel(center);
1029 setup_perf_panel();
1030
1031 current_view = cpu;
1032
1033 basic_header();
1034 update_footer();
1035
1036 pthread_create(&keyboard_thread, NULL, handle_keyboard, (void *)NULL);
1037 }
1038
This page took 0.080647 seconds and 4 git commands to generate.